nold/nstool
1
0
Fork 0
mirror of https://github.com/jakcron/nstool synced 2024-11-14 17:56:39 +00:00
Code Issues Projects Releases Packages Wiki Activity

Take out non-ticket code from libes into new libpki.

Browse source
This commit is contained in:
jakcron 2018-08-06 16:59:56 +08:00
parent 43270f2e80
commit 900415f49d
23 changed files with 245 additions and 196 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
.vscode/c_cpp_properties.json vendored
View file

@ -9,10 +9,11 @@
"/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include",
"/usr/include",
"${workspaceRoot}",
"${workspaceRoot}/lib/libcrypto/include",
"${workspaceRoot}/lib/libcrypto/source/polarssl/libinclude",
"${workspaceRoot}/lib/libcrypto/include",
"${workspaceRoot}/lib/libcrypto/source/polarssl/libinclude",
"${workspaceRoot}/lib/libcompress/include",
"${workspaceRoot}/lib/libes/include",
"${workspaceRoot}/lib/libpki/include",
"${workspaceRoot}/lib/libfnd/include",
"${workspaceRoot}/lib/libnx/include",
"${workspaceRoot}/lib/libnx-hb/include"

13
README.md
View file

@ -10,12 +10,13 @@ Tools & Libraries for NX (Nintendo Switch).
# Libraries
* __libfnd__ - Foundation library.
* __libcrypto__ - Cryptographic functions (AES,SHA,RSA). Wrapper for [mbedTLS](https://github.com/ARMmbed/mbedtls)
* __libcompress__ - Compression algorithms (LZ4). Wrapper for [lz4](https://github.com/lz4/lz4)
* __libes__ - Handling of (NX relevant) eShop file type processing. (eTickets, etc)
* __libnx__ - Handling of NX file types.
* __libnx-hb__ - Handling of NX (homebrew extensions) file types.
* __libfnd__ - Foundation library.
* __libcrypto__ - Cryptographic functions (AES,SHA,RSA). Wrapper for [mbedTLS](https://github.com/ARMmbed/mbedtls)
* __libcompress__ - Compression algorithms (LZ4). Wrapper for [lz4](https://github.com/lz4/lz4)
* __libpki__ - Processes Nintendo's proprietary PKI.
* __libes__ - Processes Nintendo's eShop file types.
* __libnx__ - Processes NX file types.
* __libnx-hb__ - Processes NX file types (homebrew extensions).
# Building

14
lib/libes/include/es/SignUtils.h
View file

@ -1,14 +0,0 @@
#pragma once
#include <es/sign.h>
#include <crypto/sha.h>
namespace es
{
namespace sign
{
es::sign::SignatureAlgo getSignatureAlgo(es::sign::SignatureId sign_id);
es::sign::HashAlgo getHashAlgo(es::sign::SignatureId sign_id);
}
}

45
lib/libes/source/SignUtils.cpp
View file

@ -1,45 +0,0 @@
#include <es/SignUtils.h>
es::sign::SignatureAlgo es::sign::getSignatureAlgo(es::sign::SignatureId sign_id)
{
SignatureAlgo sign_algo = SIGN_ALGO_RSA4096;
switch (sign_id)
{
case (es::sign::SIGN_ID_RSA4096_SHA1):
case (es::sign::SIGN_ID_RSA4096_SHA256):
sign_algo = SIGN_ALGO_RSA4096;
break;
case (es::sign::SIGN_ID_RSA2048_SHA1):
case (es::sign::SIGN_ID_RSA2048_SHA256):
sign_algo = SIGN_ALGO_RSA2048;
break;
case (es::sign::SIGN_ID_ECDSA240_SHA1):
case (es::sign::SIGN_ID_ECDSA240_SHA256):
sign_algo = SIGN_ALGO_ECDSA240;
break;
};
return sign_algo;
}
es::sign::HashAlgo es::sign::getHashAlgo(es::sign::SignatureId sign_id)
{
HashAlgo hash_algo = HASH_ALGO_SHA1;
switch (sign_id)
{
case (es::sign::SIGN_ID_RSA4096_SHA1):
case (es::sign::SIGN_ID_RSA2048_SHA1):
case (es::sign::SIGN_ID_ECDSA240_SHA1):
hash_algo = HASH_ALGO_SHA1;
break;
case (es::sign::SIGN_ID_RSA4096_SHA256):
case (es::sign::SIGN_ID_RSA2048_SHA256):
case (es::sign::SIGN_ID_ECDSA240_SHA256):
hash_algo = HASH_ALGO_SHA256;
break;
};
return hash_algo;
}

6
lib/libes/include/es/CertificateBody.h → lib/libpki/include/pki/CertificateBody.h
View file

@ -1,9 +1,9 @@
#pragma once
#include <string>
#include <fnd/ISerialisable.h>
#include <es/cert.h>
#include <pki/cert.h>
namespace es
namespace pki
{
class CertificateBody
: public fnd::ISerialisable
@ -27,7 +27,7 @@ namespace es
const std::string& getIssuer() const;
void setIssuer(const std::string& issuer);
es::cert::PublicKeyType getPublicKeyType() const;
pki::cert::PublicKeyType getPublicKeyType() const;
void setPublicKeyType(cert::PublicKeyType type);
const std::string& getSubject() const;

14
lib/libpki/include/pki/SignUtils.h Normal file
View file

@ -0,0 +1,14 @@
#pragma once
#include <pki/sign.h>
#include <crypto/sha.h>
namespace pki
{
namespace sign
{
pki::sign::SignatureAlgo getSignatureAlgo(pki::sign::SignatureId sign_id);
pki::sign::HashAlgo getHashAlgo(pki::sign::SignatureId sign_id);
}
}

10
lib/libes/include/es/SignatureBlock.h → lib/libpki/include/pki/SignatureBlock.h
View file

@ -1,9 +1,9 @@
#pragma once
#include <string>
#include <fnd/ISerialisable.h>
#include <es/sign.h>
#include <pki/sign.h>
namespace es
namespace pki
{
class SignatureBlock
: public fnd::ISerialisable
@ -24,8 +24,8 @@ namespace es
// variables
void clear();
es::sign::SignatureId getSignType() const;
void setSignType(es::sign::SignatureId type);
pki::sign::SignatureId getSignType() const;
void setSignType(pki::sign::SignatureId type);
bool isLittleEndian() const;
void setLittleEndian(bool isLE);
@ -41,7 +41,7 @@ namespace es
fnd::Vec<byte_t> mRawBinary;
// variables
es::sign::SignatureId mSignType;
pki::sign::SignatureId mSignType;
bool mIsLittleEndian;
fnd::Vec<byte_t> mSignature;
};

8
lib/libes/include/es/SignedData.h → lib/libpki/include/pki/SignedData.h
View file

@ -1,9 +1,9 @@
#pragma once
#include <string>
#include <fnd/ISerialisable.h>
#include <es/SignatureBlock.h>
#include <pki/SignatureBlock.h>
namespace es
namespace pki
{
template <class T>
class SignedData
@ -25,7 +25,7 @@ namespace es
// variables
void clear();
const es::SignatureBlock& getSignature() const;
const pki::SignatureBlock& getSignature() const;
void setSignature(const SignatureBlock& signature);
const T& getBody() const;
@ -111,7 +111,7 @@ namespace es
}
template <class T>
inline const es::SignatureBlock& SignedData<T>::getSignature() const
inline const pki::SignatureBlock& SignedData<T>::getSignature() const
{
return mSignature;
}

2
lib/libes/include/es/cert.h → lib/libpki/include/pki/cert.h
View file

@ -5,7 +5,7 @@
#include <crypto/rsa.h>
#include <crypto/ecdsa.h>
namespace es
namespace pki
{
namespace cert
{

2
lib/libes/include/es/sign.h → lib/libpki/include/pki/sign.h
View file

@ -5,7 +5,7 @@
#include <crypto/rsa.h>
#include <crypto/ecdsa.h>
namespace es
namespace pki
{
namespace sign
{

47
lib/libpki/makefile Normal file
View file

@ -0,0 +1,47 @@
# Sources
SRC_DIR = source
OBJS = $(foreach dir,$(SRC_DIR),$(subst .cpp,.o,$(wildcard $(dir)/*.cpp))) $(foreach dir,$(SRC_DIR),$(subst .c,.o,$(wildcard $(dir)/*.c)))
# External dependencies
DEPENDS = fnd crypto
LIB_DIR = ..
INCS = -I"include" $(foreach dep,$(DEPENDS), -I"$(LIB_DIR)/lib$(dep)/include")
# Compiler Settings
CXXFLAGS = -std=c++11 $(INCS) -D__STDC_FORMAT_MACROS -Wall -Wno-unused-value
CFLAGS = -std=c11 $(INCS) -Wall -Wno-unused-value
ARFLAGS = cr -o
ifeq ($(OS),Windows_NT)
# Windows Only Flags/Libs
CC = x86_64-w64-mingw32-gcc
CXX = x86_64-w64-mingw32-g++
CFLAGS += -Wno-unused-but-set-variable
CXXFLAGS += -Wno-unused-but-set-variable
else
UNAME = $(shell uname -s)
ifeq ($(UNAME), Darwin)
# MacOS Only Flags/Libs
CFLAGS += -Wno-unused-private-field
CXXFLAGS += -Wno-unused-private-field
ARFLAGS = rc
else
# *nix Only Flags/Libs
CFLAGS += -Wno-unused-but-set-variable
CXXFLAGS += -Wno-unused-but-set-variable
endif
endif
# Output
OUTPUT = $(shell basename $(CURDIR)).a
main: build
rebuild: clean build
build: $(OBJS)
ar $(ARFLAGS) $(OUTPUT) $(OBJS)
clean:
rm -rf $(OUTPUT) $(OBJS)

48
lib/libes/source/CertificateBody.cpp → lib/libpki/source/CertificateBody.cpp
View file

@ -1,16 +1,16 @@
#include <es/CertificateBody.h>
#include <pki/CertificateBody.h>
es::CertificateBody::CertificateBody()
pki::CertificateBody::CertificateBody()
{
clear();
}
es::CertificateBody::CertificateBody(const CertificateBody& other)
pki::CertificateBody::CertificateBody(const CertificateBody& other)
{
*this = other;
}
void es::CertificateBody::operator=(const CertificateBody& other)
void pki::CertificateBody::operator=(const CertificateBody& other)
{
mRawBinary = other.mRawBinary;
mIssuer = other.mIssuer;
@ -22,7 +22,7 @@ void es::CertificateBody::operator=(const CertificateBody& other)
mEcdsa240PublicKey = other.mEcdsa240PublicKey;
}
bool es::CertificateBody::operator==(const CertificateBody& other) const
bool pki::CertificateBody::operator==(const CertificateBody& other) const
{
return (mIssuer == other.mIssuer) \
&& (mSubject == other.mSubject) \
@ -33,12 +33,12 @@ bool es::CertificateBody::operator==(const CertificateBody& other) const
&& (mEcdsa240PublicKey == other.mEcdsa240PublicKey);
}
bool es::CertificateBody::operator!=(const CertificateBody& other) const
bool pki::CertificateBody::operator!=(const CertificateBody& other) const
{
return !(*this == other);
}
void es::CertificateBody::toBytes()
void pki::CertificateBody::toBytes()
{
// get public key size
size_t pubkeySize = 0;
@ -86,7 +86,7 @@ void es::CertificateBody::toBytes()
}
}
void es::CertificateBody::fromBytes(const byte_t* src, size_t size)
void pki::CertificateBody::fromBytes(const byte_t* src, size_t size)
{
clear();
@ -155,13 +155,13 @@ void es::CertificateBody::fromBytes(const byte_t* src, size_t size)
}
}
const fnd::Vec<byte_t>& es::CertificateBody::getBytes() const
const fnd::Vec<byte_t>& pki::CertificateBody::getBytes() const
{
return mRawBinary;
}
void es::CertificateBody::clear()
void pki::CertificateBody::clear()
{
mIssuer.clear();
mSubject.clear();
@ -173,12 +173,12 @@ void es::CertificateBody::clear()
memset(&mEcdsa240PublicKey, 0, sizeof(crypto::ecdsa::sEcdsa240Point));
}
const std::string& es::CertificateBody::getIssuer() const
const std::string& pki::CertificateBody::getIssuer() const
{
return mIssuer;
}
void es::CertificateBody::setIssuer(const std::string& issuer)
void pki::CertificateBody::setIssuer(const std::string& issuer)
{
if (issuer.size() > cert::kIssuerSize)
{
@ -188,22 +188,22 @@ void es::CertificateBody::setIssuer(const std::string& issuer)
mIssuer = issuer;
}
es::cert::PublicKeyType es::CertificateBody::getPublicKeyType() const
pki::cert::PublicKeyType pki::CertificateBody::getPublicKeyType() const
{
return mPublicKeyType;
}
void es::CertificateBody::setPublicKeyType(cert::PublicKeyType type)
void pki::CertificateBody::setPublicKeyType(cert::PublicKeyType type)
{
mPublicKeyType = type;
}
const std::string& es::CertificateBody::getSubject() const
const std::string& pki::CertificateBody::getSubject() const
{
return mSubject;
}
void es::CertificateBody::setSubject(const std::string& subject)
void pki::CertificateBody::setSubject(const std::string& subject)
{
if (subject.size() > cert::kSubjectSize)
{
@ -213,42 +213,42 @@ void es::CertificateBody::setSubject(const std::string& subject)
mSubject = subject;
}
uint32_t es::CertificateBody::getCertId() const
uint32_t pki::CertificateBody::getCertId() const
{
return mCertId;
}
void es::CertificateBody::setCertId(uint32_t id)
void pki::CertificateBody::setCertId(uint32_t id)
{
mCertId = id;
}
const crypto::rsa::sRsa4096Key& es::CertificateBody::getRsa4098PublicKey() const
const crypto::rsa::sRsa4096Key& pki::CertificateBody::getRsa4098PublicKey() const
{
return mRsa4096PublicKey;
}
void es::CertificateBody::setRsa4098PublicKey(const crypto::rsa::sRsa4096Key& key)
void pki::CertificateBody::setRsa4098PublicKey(const crypto::rsa::sRsa4096Key& key)
{
mRsa4096PublicKey = key;
}
const crypto::rsa::sRsa2048Key& es::CertificateBody::getRsa2048PublicKey() const
const crypto::rsa::sRsa2048Key& pki::CertificateBody::getRsa2048PublicKey() const
{
return mRsa2048PublicKey;
}
void es::CertificateBody::setRsa2048PublicKey(const crypto::rsa::sRsa2048Key& key)
void pki::CertificateBody::setRsa2048PublicKey(const crypto::rsa::sRsa2048Key& key)
{
mRsa2048PublicKey = key;
}
const crypto::ecdsa::sEcdsa240Point& es::CertificateBody::getEcdsa240PublicKey() const
const crypto::ecdsa::sEcdsa240Point& pki::CertificateBody::getEcdsa240PublicKey() const
{
return mEcdsa240PublicKey;
}
void es::CertificateBody::setEcdsa240PublicKey(const crypto::ecdsa::sEcdsa240Point& key)
void pki::CertificateBody::setEcdsa240PublicKey(const crypto::ecdsa::sEcdsa240Point& key)
{
mEcdsa240PublicKey = key;
}

45
lib/libpki/source/SignUtils.cpp Normal file
View file

@ -0,0 +1,45 @@
#include <pki/SignUtils.h>
pki::sign::SignatureAlgo pki::sign::getSignatureAlgo(pki::sign::SignatureId sign_id)
{
SignatureAlgo sign_algo = SIGN_ALGO_RSA4096;
switch (sign_id)
{
case (pki::sign::SIGN_ID_RSA4096_SHA1):
case (pki::sign::SIGN_ID_RSA4096_SHA256):
sign_algo = SIGN_ALGO_RSA4096;
break;
case (pki::sign::SIGN_ID_RSA2048_SHA1):
case (pki::sign::SIGN_ID_RSA2048_SHA256):
sign_algo = SIGN_ALGO_RSA2048;
break;
case (pki::sign::SIGN_ID_ECDSA240_SHA1):
case (pki::sign::SIGN_ID_ECDSA240_SHA256):
sign_algo = SIGN_ALGO_ECDSA240;
break;
};
return sign_algo;
}
pki::sign::HashAlgo pki::sign::getHashAlgo(pki::sign::SignatureId sign_id)
{
HashAlgo hash_algo = HASH_ALGO_SHA1;
switch (sign_id)
{
case (pki::sign::SIGN_ID_RSA4096_SHA1):
case (pki::sign::SIGN_ID_RSA2048_SHA1):
case (pki::sign::SIGN_ID_ECDSA240_SHA1):
hash_algo = HASH_ALGO_SHA1;
break;
case (pki::sign::SIGN_ID_RSA4096_SHA256):
case (pki::sign::SIGN_ID_RSA2048_SHA256):
case (pki::sign::SIGN_ID_ECDSA240_SHA256):
hash_algo = HASH_ALGO_SHA256;
break;
};
return hash_algo;
}

32
lib/libes/source/SignatureBlock.cpp → lib/libpki/source/SignatureBlock.cpp
View file

@ -1,16 +1,16 @@
#include <es/SignatureBlock.h>
#include <pki/SignatureBlock.h>
es::SignatureBlock::SignatureBlock()
pki::SignatureBlock::SignatureBlock()
{
clear();
}
es::SignatureBlock::SignatureBlock(const SignatureBlock& other)
pki::SignatureBlock::SignatureBlock(const SignatureBlock& other)
{
*this = other;
}
void es::SignatureBlock::operator=(const SignatureBlock& other)
void pki::SignatureBlock::operator=(const SignatureBlock& other)
{
mRawBinary = other.mRawBinary;
mSignType = other.mSignType;
@ -18,19 +18,19 @@ void es::SignatureBlock::operator=(const SignatureBlock& other)
mSignature = other.mSignature;
}
bool es::SignatureBlock::operator==(const SignatureBlock& other) const
bool pki::SignatureBlock::operator==(const SignatureBlock& other) const
{
return (mSignType == other.mSignType) \
&& (mIsLittleEndian == other.mIsLittleEndian) \
&& (mSignature == other.mSignature);
}
bool es::SignatureBlock::operator!=(const SignatureBlock& other) const
bool pki::SignatureBlock::operator!=(const SignatureBlock& other) const
{
return !(*this == other);
}
void es::SignatureBlock::toBytes()
void pki::SignatureBlock::toBytes()
{
size_t totalSize = 0;
size_t sigSize = 0;
@ -68,7 +68,7 @@ void es::SignatureBlock::toBytes()
memcpy(mRawBinary.data() + 4, mSignature.data(), sigSize);
}
void es::SignatureBlock::fromBytes(const byte_t* src, size_t size)
void pki::SignatureBlock::fromBytes(const byte_t* src, size_t size)
{
clear();
@ -138,12 +138,12 @@ void es::SignatureBlock::fromBytes(const byte_t* src, size_t size)
memcpy(mSignature.data(), mRawBinary.data() + 4, sigSize);
}
const fnd::Vec<byte_t>& es::SignatureBlock::getBytes() const
const fnd::Vec<byte_t>& pki::SignatureBlock::getBytes() const
{
return mRawBinary;
}
void es::SignatureBlock::clear()
void pki::SignatureBlock::clear()
{
mRawBinary.clear();
mSignType = sign::SIGN_ID_RSA4096_SHA1;
@ -151,32 +151,32 @@ void es::SignatureBlock::clear()
mSignature.clear();
}
es::sign::SignatureId es::SignatureBlock::getSignType() const
pki::sign::SignatureId pki::SignatureBlock::getSignType() const
{
return mSignType;
}
void es::SignatureBlock::setSignType(es::sign::SignatureId type)
void pki::SignatureBlock::setSignType(pki::sign::SignatureId type)
{
mSignType = type;
}
bool es::SignatureBlock::isLittleEndian() const
bool pki::SignatureBlock::isLittleEndian() const
{
return mIsLittleEndian;
}
void es::SignatureBlock::setLittleEndian(bool isLE)
void pki::SignatureBlock::setLittleEndian(bool isLE)
{
mIsLittleEndian = isLE;
}
const fnd::Vec<byte_t>& es::SignatureBlock::getSignature() const
const fnd::Vec<byte_t>& pki::SignatureBlock::getSignature() const
{
return mSignature;
}
void es::SignatureBlock::setSignature(const fnd::Vec<byte_t>& signature)
void pki::SignatureBlock::setSignature(const fnd::Vec<byte_t>& signature)
{
mSignature = signature;
}

2
lib/makefile
View file

@ -1,4 +1,4 @@
LIBS = libfnd libcrypto libcompress libes libnx libnx-hb
LIBS = libfnd libcrypto libcompress libes libpki libnx libnx-hb
main: build
rebuild: clean build

2
programs/nstool/makefile
View file

@ -3,7 +3,7 @@ SRC_DIR = source
OBJS = $(foreach dir,$(SRC_DIR),$(subst .cpp,.o,$(wildcard $(dir)/*.cpp))) $(foreach dir,$(SRC_DIR),$(subst .c,.o,$(wildcard $(dir)/*.c)))
# External dependencies
DEPENDS = nx-hb nx es crypto compress fnd
DEPENDS = nx-hb nx es pki crypto compress fnd
LIB_DIR = ../../lib
LIBS = $(foreach dep,$(DEPENDS), -L"$(LIB_DIR)/lib$(dep)" -l$(dep))
INCS = $(foreach dep,$(DEPENDS), -I"$(LIB_DIR)/lib$(dep)/include")

34
programs/nstool/source/EsCertProcess.cpp
View file

@ -2,7 +2,7 @@
#include <iomanip>
#include <fnd/SimpleTextOutput.h>
#include <es/SignUtils.h>
#include <pki/SignUtils.h>
#include "OffsetAdjustedIFile.h"
#include "EsCertProcess.h"
#include "PkiValidator.h"
@ -66,7 +66,7 @@ void EsCertProcess::importCerts()
scratch.alloc(mFile->size());
mFile->read(scratch.data(), 0, scratch.size());
es::SignedData<es::CertificateBody> cert;
pki::SignedData<pki::CertificateBody> cert;
for (size_t f_pos = 0; f_pos < scratch.size(); f_pos += cert.getBytes().size())
{
cert.fromBytes(scratch.data() + f_pos, scratch.size() - f_pos);
@ -98,7 +98,7 @@ void EsCertProcess::displayCerts()
}
}
void EsCertProcess::displayCert(const es::SignedData<es::CertificateBody>& cert)
void EsCertProcess::displayCert(const pki::SignedData<pki::CertificateBody>& cert)
{
#define _SPLIT_VER(ver) ( (ver>>26) & 0x3f), ( (ver>>20) & 0x3f), ( (ver>>16) & 0xf), (ver & 0xffff)
#define _HEXDUMP_U(var, len) do { for (size_t a__a__A = 0; a__a__A < len; a__a__A++) printf("%02X", var[a__a__A]); } while(0)
@ -119,7 +119,7 @@ void EsCertProcess::displayCert(const es::SignedData<es::CertificateBody>& cert)
std::cout << std::endl;
std::cout << " CertID: 0x" << std::hex << cert.getBody().getCertId() << std::endl;
if (cert.getBody().getPublicKeyType() == es::cert::RSA4096)
if (cert.getBody().getPublicKeyType() == pki::cert::RSA4096)
{
std::cout << " PublicKey:" << std::endl;
std::cout << " Modulus:" << std::endl;
@ -127,7 +127,7 @@ void EsCertProcess::displayCert(const es::SignedData<es::CertificateBody>& cert)
std::cout << " Public Exponent:" << std::endl;
fnd::SimpleTextOutput::hexDump(cert.getBody().getRsa4098PublicKey().public_exponent, crypto::rsa::kRsaPublicExponentSize, 0x10, 6);
}
else if (cert.getBody().getPublicKeyType() == es::cert::RSA2048)
else if (cert.getBody().getPublicKeyType() == pki::cert::RSA2048)
{
std::cout << " PublicKey:" << std::endl;
std::cout << " Public Exponent:" << std::endl;
@ -135,7 +135,7 @@ void EsCertProcess::displayCert(const es::SignedData<es::CertificateBody>& cert)
std::cout << " Modulus:" << std::endl;
fnd::SimpleTextOutput::hexDump(cert.getBody().getRsa2048PublicKey().public_exponent, crypto::rsa::kRsaPublicExponentSize, 0x10, 6);
}
else if (cert.getBody().getPublicKeyType() == es::cert::ECDSA240)
else if (cert.getBody().getPublicKeyType() == pki::cert::ECDSA240)
{
std::cout << " PublicKey:" << std::endl;
std::cout << " R:" << std::endl;
@ -151,27 +151,27 @@ void EsCertProcess::displayCert(const es::SignedData<es::CertificateBody>& cert)
#undef _SPLIT_VER
}
const char* EsCertProcess::getSignTypeStr(es::sign::SignatureId type) const
const char* EsCertProcess::getSignTypeStr(pki::sign::SignatureId type) const
{
const char* str;
switch (type)
{
case (es::sign::SIGN_ID_RSA4096_SHA1):
case (pki::sign::SIGN_ID_RSA4096_SHA1):
str = "RSA4096-SHA1";
break;
case (es::sign::SIGN_ID_RSA2048_SHA1):
case (pki::sign::SIGN_ID_RSA2048_SHA1):
str = "RSA2048-SHA1";
break;
case (es::sign::SIGN_ID_ECDSA240_SHA1):
case (pki::sign::SIGN_ID_ECDSA240_SHA1):
str = "ECDSA240-SHA1";
break;
case (es::sign::SIGN_ID_RSA4096_SHA256):
case (pki::sign::SIGN_ID_RSA4096_SHA256):
str = "RSA4096-SHA256";
break;
case (es::sign::SIGN_ID_RSA2048_SHA256):
case (pki::sign::SIGN_ID_RSA2048_SHA256):
str = "RSA2048-SHA256";
break;
case (es::sign::SIGN_ID_ECDSA240_SHA256):
case (pki::sign::SIGN_ID_ECDSA240_SHA256):
str = "ECDSA240-SHA256";
break;
default:
@ -186,18 +186,18 @@ const char* EsCertProcess::getEndiannessStr(bool isLittleEndian) const
return isLittleEndian ? "LittleEndian" : "BigEndian";
}
const char* EsCertProcess::getPublicKeyTypeStr(es::cert::PublicKeyType type) const
const char* EsCertProcess::getPublicKeyTypeStr(pki::cert::PublicKeyType type) const
{
const char* str;
switch (type)
{
case (es::cert::RSA4096):
case (pki::cert::RSA4096):
str = "RSA4096";
break;
case (es::cert::RSA2048):
case (pki::cert::RSA2048):
str = "RSA2048";
break;
case (es::cert::ECDSA240):
case (pki::cert::ECDSA240):
str = "ECDSA240";
break;
default:

12
programs/nstool/source/EsCertProcess.h
View file

@ -4,8 +4,8 @@
#include <fnd/IFile.h>
#include <fnd/List.h>
#include <fnd/Vec.h>
#include <es/SignedData.h>
#include <es/CertificateBody.h>
#include <pki/SignedData.h>
#include <pki/CertificateBody.h>
#include "nstool.h"
class EsCertProcess
@ -30,15 +30,15 @@ private:
CliOutputMode mCliOutputMode;
bool mVerify;
fnd::List<es::SignedData<es::CertificateBody>> mCert;
fnd::List<pki::SignedData<pki::CertificateBody>> mCert;
void importCerts();
void validateCerts();
void displayCerts();
void displayCert(const es::SignedData<es::CertificateBody>& cert);
void displayCert(const pki::SignedData<pki::CertificateBody>& cert);
const char* getSignTypeStr(es::sign::SignatureId type) const;
const char* getSignTypeStr(pki::sign::SignatureId type) const;
const char* getEndiannessStr(bool isLittleEndian) const;
const char* getPublicKeyTypeStr(es::cert::PublicKeyType type) const;
const char* getPublicKeyTypeStr(pki::cert::PublicKeyType type) const;
};

12
programs/nstool/source/EsTikProcess.cpp
View file

@ -132,22 +132,22 @@ const char* EsTikProcess::getSignTypeStr(uint32_t type) const
const char* str = nullptr;
switch(type)
{
case (es::sign::SIGN_ID_RSA4096_SHA1):
case (pki::sign::SIGN_ID_RSA4096_SHA1):
str = "RSA4096-SHA1";
break;
case (es::sign::SIGN_ID_RSA2048_SHA1):
case (pki::sign::SIGN_ID_RSA2048_SHA1):
str = "RSA2048-SHA1";
break;
case (es::sign::SIGN_ID_ECDSA240_SHA1):
case (pki::sign::SIGN_ID_ECDSA240_SHA1):
str = "ECDSA240-SHA1";
break;
case (es::sign::SIGN_ID_RSA4096_SHA256):
case (pki::sign::SIGN_ID_RSA4096_SHA256):
str = "RSA4096-SHA256";
break;
case (es::sign::SIGN_ID_RSA2048_SHA256):
case (pki::sign::SIGN_ID_RSA2048_SHA256):
str = "RSA2048-SHA256";
break;
case (es::sign::SIGN_ID_ECDSA240_SHA256):
case (pki::sign::SIGN_ID_ECDSA240_SHA256):
str = "ECDSA240-SHA256";
break;
default:

4
programs/nstool/source/EsTikProcess.h
View file

@ -3,7 +3,7 @@
#include <fnd/types.h>
#include <fnd/IFile.h>
#include <fnd/Vec.h>
#include <es/SignedData.h>
#include <pki/SignedData.h>
#include <es/TicketBody_V2.h>
#include "nstool.h"
@ -29,7 +29,7 @@ private:
CliOutputMode mCliOutputMode;
bool mVerify;
es::SignedData<es::TicketBody_V2> mTik;
pki::SignedData<es::TicketBody_V2> mTik;
void displayTicket();
const char* getSignTypeStr(uint32_t type) const;

52
programs/nstool/source/PkiValidator.cpp
View file

@ -2,7 +2,7 @@
#include <iostream>
#include <iomanip>
#include <sstream>
#include <es/SignUtils.h>
#include <pki/SignUtils.h>
PkiValidator::PkiValidator()
{
@ -12,7 +12,7 @@ PkiValidator::PkiValidator()
void PkiValidator::setRootKey(const crypto::rsa::sRsa4096Key& root_key)
{
// save a copy of the certificate bank
fnd::List<es::SignedData<es::CertificateBody>> old_certs = mCertificateBank;
fnd::List<pki::SignedData<pki::CertificateBody>> old_certs = mCertificateBank;
// clear the certificate bank
mCertificateBank.clear();
@ -27,7 +27,7 @@ void PkiValidator::setRootKey(const crypto::rsa::sRsa4096Key& root_key)
}
}
void PkiValidator::addCertificates(const fnd::List<es::SignedData<es::CertificateBody>>& certs)
void PkiValidator::addCertificates(const fnd::List<pki::SignedData<pki::CertificateBody>>& certs)
{
for (size_t i = 0; i < certs.size(); i++)
{
@ -35,11 +35,11 @@ void PkiValidator::addCertificates(const fnd::List<es::SignedData<es::Certificat
}
}
void PkiValidator::addCertificate(const es::SignedData<es::CertificateBody>& cert)
void PkiValidator::addCertificate(const pki::SignedData<pki::CertificateBody>& cert)
{
std::string cert_ident;
es::sign::SignatureAlgo cert_sign_algo;
es::sign::HashAlgo cert_hash_algo;
pki::sign::SignatureAlgo cert_sign_algo;
pki::sign::HashAlgo cert_hash_algo;
fnd::Vec<byte_t> cert_hash;
try
@ -51,17 +51,17 @@ void PkiValidator::addCertificate(const es::SignedData<es::CertificateBody>& cer
throw fnd::Exception(kModuleName, "Certificate already exists");
}
cert_sign_algo = es::sign::getSignatureAlgo(cert.getSignature().getSignType());
cert_hash_algo = es::sign::getHashAlgo(cert.getSignature().getSignType());
cert_sign_algo = pki::sign::getSignatureAlgo(cert.getSignature().getSignType());
cert_hash_algo = pki::sign::getHashAlgo(cert.getSignature().getSignType());
// get cert hash
switch (cert_hash_algo)
{
case (es::sign::HASH_ALGO_SHA1):
case (pki::sign::HASH_ALGO_SHA1):
cert_hash.alloc(crypto::sha::kSha1HashLen);
crypto::sha::Sha1(cert.getBody().getBytes().data(), cert.getBody().getBytes().size(), cert_hash.data());
break;
case (es::sign::HASH_ALGO_SHA256):
case (pki::sign::HASH_ALGO_SHA256):
cert_hash.alloc(crypto::sha::kSha256HashLen);
crypto::sha::Sha256(cert.getBody().getBytes().data(), cert.getBody().getBytes().size(), cert_hash.data());
break;
@ -86,19 +86,19 @@ void PkiValidator::clearCertificates()
mCertificateBank.clear();
}
void PkiValidator::validateSignature(const std::string& issuer, es::sign::SignatureId signature_id, const fnd::Vec<byte_t>& signature, const fnd::Vec<byte_t>& hash) const
void PkiValidator::validateSignature(const std::string& issuer, pki::sign::SignatureId signature_id, const fnd::Vec<byte_t>& signature, const fnd::Vec<byte_t>& hash) const
{
es::sign::SignatureAlgo sign_algo = es::sign::getSignatureAlgo(signature_id);
es::sign::HashAlgo hash_algo = es::sign::getHashAlgo(signature_id);
pki::sign::SignatureAlgo sign_algo = pki::sign::getSignatureAlgo(signature_id);
pki::sign::HashAlgo hash_algo = pki::sign::getHashAlgo(signature_id);
// validate signature
int sig_validate_res = -1;
// special case if signed by Root
if (issuer == es::sign::kRootIssuerStr)
if (issuer == pki::sign::kRootIssuerStr)
{
if (sign_algo != es::sign::SIGN_ALGO_RSA4096)
if (sign_algo != pki::sign::SIGN_ALGO_RSA4096)
{
throw fnd::Exception(kModuleName, "Issued by Root, but does not have a RSA4096 signature");
}
@ -107,18 +107,18 @@ void PkiValidator::validateSignature(const std::string& issuer, es::sign::Signat
else
{
// try to find issuer cert
const es::CertificateBody& issuer_cert = getCert(issuer).getBody();
es::cert::PublicKeyType issuer_pubk_type = issuer_cert.getPublicKeyType();
const pki::CertificateBody& issuer_cert = getCert(issuer).getBody();
pki::cert::PublicKeyType issuer_pubk_type = issuer_cert.getPublicKeyType();
if (issuer_pubk_type == es::cert::RSA4096 && sign_algo == es::sign::SIGN_ALGO_RSA4096)
if (issuer_pubk_type == pki::cert::RSA4096 && sign_algo == pki::sign::SIGN_ALGO_RSA4096)
{
sig_validate_res = crypto::rsa::pkcs::rsaVerify(issuer_cert.getRsa4098PublicKey(), getCryptoHashAlgoFromEsSignHashAlgo(hash_algo), hash.data(), signature.data());
}
else if (issuer_pubk_type == es::cert::RSA2048 && sign_algo == es::sign::SIGN_ALGO_RSA2048)
else if (issuer_pubk_type == pki::cert::RSA2048 && sign_algo == pki::sign::SIGN_ALGO_RSA2048)
{
sig_validate_res = crypto::rsa::pkcs::rsaVerify(issuer_cert.getRsa2048PublicKey(), getCryptoHashAlgoFromEsSignHashAlgo(hash_algo), hash.data(), signature.data());
}
else if (issuer_pubk_type == es::cert::ECDSA240 && sign_algo == es::sign::SIGN_ALGO_ECDSA240)
else if (issuer_pubk_type == pki::cert::ECDSA240 && sign_algo == pki::sign::SIGN_ALGO_ECDSA240)
{
throw fnd::Exception(kModuleName, "ECDSA signatures are not supported");
}
@ -136,14 +136,14 @@ void PkiValidator::validateSignature(const std::string& issuer, es::sign::Signat
}
void PkiValidator::makeCertIdent(const es::SignedData<es::CertificateBody>& cert, std::string& ident) const
void PkiValidator::makeCertIdent(const pki::SignedData<pki::CertificateBody>& cert, std::string& ident) const
{
makeCertIdent(cert.getBody().getIssuer(), cert.getBody().getSubject(), ident);
}
void PkiValidator::makeCertIdent(const std::string& issuer, const std::string& subject, std::string& ident) const
{
ident = issuer + es::sign::kIdentDelimiter + subject;
ident = issuer + pki::sign::kIdentDelimiter + subject;
ident = ident.substr(0, _MIN(ident.length(),64));
}
@ -164,7 +164,7 @@ bool PkiValidator::doesCertExist(const std::string& ident) const
return exists;
}
const es::SignedData<es::CertificateBody>& PkiValidator::getCert(const std::string& ident) const
const pki::SignedData<pki::CertificateBody>& PkiValidator::getCert(const std::string& ident) const
{
std::string full_cert_name;
for (size_t i = 0; i < mCertificateBank.size(); i++)
@ -179,16 +179,16 @@ const es::SignedData<es::CertificateBody>& PkiValidator::getCert(const std::stri
throw fnd::Exception(kModuleName, "Issuer certificate does not exist");
}
crypto::sha::HashType PkiValidator::getCryptoHashAlgoFromEsSignHashAlgo(es::sign::HashAlgo hash_algo) const
crypto::sha::HashType PkiValidator::getCryptoHashAlgoFromEsSignHashAlgo(pki::sign::HashAlgo hash_algo) const
{
crypto::sha::HashType hash_type = crypto::sha::HASH_SHA1;
switch (hash_algo)
{
case (es::sign::HASH_ALGO_SHA1):
case (pki::sign::HASH_ALGO_SHA1):
hash_type = crypto::sha::HASH_SHA1;
break;
case (es::sign::HASH_ALGO_SHA256):
case (pki::sign::HASH_ALGO_SHA256):
hash_type = crypto::sha::HASH_SHA256;
break;
};

18
programs/nstool/source/PkiValidator.h
View file

@ -3,8 +3,8 @@
#include <fnd/List.h>
#include <fnd/Vec.h>
#include <crypto/rsa.h>
#include <es/SignedData.h>
#include <es/CertificateBody.h>
#include <pki/SignedData.h>
#include <pki/CertificateBody.h>
#include <string>
class PkiValidator
@ -13,22 +13,22 @@ public:
PkiValidator();
void setRootKey(const crypto::rsa::sRsa4096Key& root_key);
void addCertificates(const fnd::List<es::SignedData<es::CertificateBody>>& certs);
void addCertificate(const es::SignedData<es::CertificateBody>& cert);
void addCertificates(const fnd::List<pki::SignedData<pki::CertificateBody>>& certs);
void addCertificate(const pki::SignedData<pki::CertificateBody>& cert);
void clearCertificates();
void validateSignature(const std::string& issuer, es::sign::SignatureId signature_id, const fnd::Vec<byte_t>& signature, const fnd::Vec<byte_t>& hash) const;
void validateSignature(const std::string& issuer, pki::sign::SignatureId signature_id, const fnd::Vec<byte_t>& signature, const fnd::Vec<byte_t>& hash) const;
private:
const std::string kModuleName = "NNPkiValidator";
crypto::rsa::sRsa4096Key mRootKey;
fnd::List<es::SignedData<es::CertificateBody>> mCertificateBank;
fnd::List<pki::SignedData<pki::CertificateBody>> mCertificateBank;
void makeCertIdent(const es::SignedData<es::CertificateBody>& cert, std::string& ident) const;
void makeCertIdent(const pki::SignedData<pki::CertificateBody>& cert, std::string& ident) const;
void makeCertIdent(const std::string& issuer, const std::string& subject, std::string& ident) const;
bool doesCertExist(const std::string& ident) const;
const es::SignedData<es::CertificateBody>& getCert(const std::string& ident) const;
crypto::sha::HashType getCryptoHashAlgoFromEsSignHashAlgo(es::sign::HashAlgo hash_algo) const;
const pki::SignedData<pki::CertificateBody>& getCert(const std::string& ident) const;
crypto::sha::HashType getCryptoHashAlgoFromEsSignHashAlgo(pki::sign::HashAlgo hash_algo) const;
};

14
programs/nstool/source/UserSettings.cpp
View file

@ -22,7 +22,7 @@
#include <nx/nso.h>
#include <nx/nro.h>
#include <nx/aset.h>
#include <es/SignatureBlock.h>
#include <pki/SignatureBlock.h>
UserSettings::UserSettings()
{}
@ -756,10 +756,10 @@ FileType UserSettings::determineFileTypeFromFile(const std::string& path)
// test nso
else if (_ASSERT_SIZE(sizeof(nx::sNroHeader)) && _TYPE_PTR(nx::sNroHeader)->st_magic.get() == nx::nro::kNroStructMagic)
file_type = FILE_NRO;
// test es certificate
// test pki certificate
else if (determineValidEsCertFromSample(scratch))
file_type = FILE_ES_CERT;
// test es ticket
// test ticket
else if (determineValidEsTikFromSample(scratch))
file_type = FILE_ES_TIK;
// test hb asset
@ -866,7 +866,7 @@ bool UserSettings::determineValidNacpFromSample(const fnd::Vec<byte_t>& sample)
bool UserSettings::determineValidEsCertFromSample(const fnd::Vec<byte_t>& sample) const
{
es::SignatureBlock sign;
pki::SignatureBlock sign;
try
{
@ -880,7 +880,7 @@ bool UserSettings::determineValidEsCertFromSample(const fnd::Vec<byte_t>& sample
if (sign.isLittleEndian() == true)
return false;
if (sign.getSignType() != es::sign::SIGN_ID_RSA4096_SHA256 && sign.getSignType() != es::sign::SIGN_ID_RSA2048_SHA256 && sign.getSignType() != es::sign::SIGN_ID_ECDSA240_SHA256)
if (sign.getSignType() != pki::sign::SIGN_ID_RSA4096_SHA256 && sign.getSignType() != pki::sign::SIGN_ID_RSA2048_SHA256 && sign.getSignType() != pki::sign::SIGN_ID_ECDSA240_SHA256)
return false;
return true;
@ -888,7 +888,7 @@ bool UserSettings::determineValidEsCertFromSample(const fnd::Vec<byte_t>& sample
bool UserSettings::determineValidEsTikFromSample(const fnd::Vec<byte_t>& sample) const
{
es::SignatureBlock sign;
pki::SignatureBlock sign;
try
{
@ -902,7 +902,7 @@ bool UserSettings::determineValidEsTikFromSample(const fnd::Vec<byte_t>& sample)
if (sign.isLittleEndian() == false)
return false;
if (sign.getSignType() != es::sign::SIGN_ID_RSA2048_SHA256)
if (sign.getSignType() != pki::sign::SIGN_ID_RSA2048_SHA256)
return false;
return true;