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

Merge pull request #52 from jakcron/nstool-1.0

Browse source 
Merge NSTool 1.0.5 changes into master.
This commit is contained in:
Jack 2018-10-06 18:25:24 +08:00 committed by GitHub
commit 803a671ed0
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
34 changed files with 546 additions and 565 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
.vscode/c_cpp_properties.json vendored
View file

@ -65,7 +65,14 @@
"name": "Win32",
"includePath": [
"C:/Program Files (x86)/Microsoft Visual Studio 14.0/VC/include",
"${workspaceRoot}"
"${workspaceRoot}",
"${workspaceRoot}/lib/libfnd/include",
"${workspaceRoot}/lib/libpolarssl/include",
"${workspaceRoot}/lib/liblz4/include",
"${workspaceRoot}/lib/libes/include",
"${workspaceRoot}/lib/libpki/include",
"${workspaceRoot}/lib/libhac/include",
"${workspaceRoot}/lib/libhac-hb/include"
],
"defines": [
"_DEBUG",

32
lib/libfnd/include/fnd/AesCtrWrappedIFile.h Normal file
View file

@ -0,0 +1,32 @@
#pragma once
#include <fnd/IFile.h>
#include <fnd/SharedPtr.h>
#include <fnd/Vec.h>
#include <fnd/aes.h>
namespace fnd
{
class AesCtrWrappedIFile : public fnd::IFile
{
public:
AesCtrWrappedIFile(const fnd::SharedPtr<fnd::IFile>& file, const fnd::aes::sAes128Key& key, const fnd::aes::sAesIvCtr& ctr);
size_t size();
void seek(size_t offset);
void read(byte_t* out, size_t len);
void read(byte_t* out, size_t offset, size_t len);
void write(const byte_t* out, size_t len);
void write(const byte_t* out, size_t offset, size_t len);
private:
const std::string kModuleName = "AesCtrWrappedIFile";
static const size_t kCacheSize = 0x10000;
static const size_t kCacheSizeAllocSize = kCacheSize + fnd::aes::kAesBlockSize;
fnd::SharedPtr<fnd::IFile> mFile;
fnd::aes::sAes128Key mKey;
fnd::aes::sAesIvCtr mBaseCtr, mCurrentCtr;
size_t mFileOffset;
fnd::Vec<byte_t> mCache;
};
}

2
lib/libfnd/include/fnd/IFile.h
View file

@ -6,7 +6,7 @@ namespace fnd
class IFile
{
public:
inline virtual ~IFile() {}
virtual ~IFile() = default;
virtual size_t size() = 0;
virtual void seek(size_t offset) = 0;

2
lib/libfnd/include/fnd/ISerialisable.h
View file

@ -7,6 +7,8 @@ namespace fnd
class ISerialisable
{
public:
virtual ~ISerialisable() = default;
// serialise
virtual void toBytes() = 0;
// deserialise

59
lib/libfnd/include/fnd/LayeredIntegrityMetadata.h Normal file
View file

@ -0,0 +1,59 @@
#pragma once
#include <fnd/types.h>
#include <fnd/List.h>
#include <fnd/sha.h>
namespace fnd
{
class LayeredIntegrityMetadata
{
public:
struct sLayer
{
size_t offset;
size_t size;
size_t block_size;
void operator=(const sLayer& other)
{
offset = other.offset;
size = other.size;
block_size = other.block_size;
}
bool operator==(const sLayer& other) const
{
return (offset == other.offset && size == other.size && block_size == other.block_size);
}
bool operator!=(const sLayer& other) const
{
return !(*this == other);
}
};
LayeredIntegrityMetadata();
void operator=(const LayeredIntegrityMetadata& other);
bool operator==(const LayeredIntegrityMetadata& other) const;
bool operator!=(const LayeredIntegrityMetadata& other) const;
const fnd::List<sLayer>& getHashLayerInfo() const;
void setHashLayerInfo(const fnd::List<sLayer>& layer_info);
const sLayer& getDataLayer() const;
void setDataLayerInfo(const sLayer& data_info);
const fnd::List<fnd::sha::sSha256Hash>& getMasterHashList() const;
void setMasterHashList(const fnd::List<fnd::sha::sSha256Hash>& master_hash_list);
bool getAlignHashToBlock() const;
void setAlignHashToBlock(bool doAlign);
private:
// data
fnd::List<sLayer> mLayerInfo;
sLayer mDataLayer;
fnd::List<fnd::sha::sSha256Hash> mMasterHashList;
bool mDoAlignHashToBlock;
};
}

47
lib/libfnd/include/fnd/LayeredIntegrityWrappedIFile.h Normal file
View file

@ -0,0 +1,47 @@
#pragma once
#include <sstream>
#include <fnd/IFile.h>
#include <fnd/SharedPtr.h>
#include <fnd/Vec.h>
#include <fnd/List.h>
#include <fnd/LayeredIntegrityMetadata.h>
namespace fnd
{
class LayeredIntegrityWrappedIFile : public fnd::IFile
{
public:
LayeredIntegrityWrappedIFile(const fnd::SharedPtr<fnd::IFile>& file, const LayeredIntegrityMetadata& hdr);
size_t size();
void seek(size_t offset);
void read(byte_t* out, size_t len);
void read(byte_t* out, size_t offset, size_t len);
void write(const byte_t* out, size_t len);
void write(const byte_t* out, size_t offset, size_t len);
private:
const std::string kModuleName = "LayeredIntegrityWrappedIFile";
static const size_t kDefaultCacheSize = 0x10000;
std::stringstream mErrorSs;
fnd::SharedPtr<fnd::IFile> mFile;
// data file
fnd::SharedPtr<fnd::IFile> mData;
size_t mDataOffset;
size_t mDataBlockSize;
fnd::List<fnd::sha::sSha256Hash> mDataHashLayer;
bool mAlignHashCalcToBlock;
fnd::Vec<byte_t> mCache;
size_t mCacheBlockNum;
inline size_t getOffsetBlock(size_t offset) const { return offset / mDataBlockSize; }
inline size_t getOffsetInBlock(size_t offset) const { return offset % mDataBlockSize; }
inline size_t getRemanderBlockReadSize(size_t total_size) const { return total_size % mDataBlockSize; }
inline size_t getBlockNum(size_t total_size) const { return (total_size / mDataBlockSize) + (getRemanderBlockReadSize(total_size) > 0); }
void initialiseDataLayer(const LayeredIntegrityMetadata& hdr);
void readData(size_t block_offset, size_t block_num);
};
}

23
lib/libfnd/include/fnd/OffsetAdjustedIFile.h Normal file
View file

@ -0,0 +1,23 @@
#pragma once
#include <fnd/IFile.h>
#include <fnd/SharedPtr.h>
namespace fnd
{
class OffsetAdjustedIFile : public fnd::IFile
{
public:
OffsetAdjustedIFile(const fnd::SharedPtr<fnd::IFile>& file, size_t offset, size_t size);
size_t size();
void seek(size_t offset);
void read(byte_t* out, size_t len);
void read(byte_t* out, size_t offset, size_t len);
void write(const byte_t* out, size_t len);
void write(const byte_t* out, size_t offset, size_t len);
private:
fnd::SharedPtr<fnd::IFile> mFile;
size_t mBaseOffset, mCurrentOffset;
size_t mSize;
};
}

8
lib/libfnd/libfnd.vcxproj
View file

@ -122,6 +122,7 @@
</ItemGroup>
<ItemGroup>
<ClInclude Include="include\fnd\aes.h" />
<ClInclude Include="include\fnd\AesCtrWrappedIFile.h" />
<ClInclude Include="include\fnd\base64.h" />
<ClInclude Include="include\fnd\BitMath.h" />
<ClInclude Include="include\fnd\ecdsa.h" />
@ -131,8 +132,11 @@
<ClInclude Include="include\fnd\IFile.h" />
<ClInclude Include="include\fnd\io.h" />
<ClInclude Include="include\fnd\ISerialisable.h" />
<ClInclude Include="include\fnd\LayeredIntegrityMetadata.h" />
<ClInclude Include="include\fnd\LayeredIntegrityWrappedIFile.h" />
<ClInclude Include="include\fnd\List.h" />
<ClInclude Include="include\fnd\lz4.h" />
<ClInclude Include="include\fnd\OffsetAdjustedIFile.h" />
<ClInclude Include="include\fnd\ResourceFileReader.h" />
<ClInclude Include="include\fnd\rsa.h" />
<ClInclude Include="include\fnd\sha.h" />
@ -144,11 +148,15 @@
<ClInclude Include="include\fnd\Vec.h" />
</ItemGroup>
<ItemGroup>
<ClCompile Include="source\AesCtrWrappedIFile.cpp" />
<ClCompile Include="source\aes_wrapper.cpp" />
<ClCompile Include="source\base64_wrapper.cpp" />
<ClCompile Include="source\Exception.cpp" />
<ClCompile Include="source\io.cpp" />
<ClCompile Include="source\LayeredIntegrityMetadata.cpp" />
<ClCompile Include="source\LayeredIntegrityWrappedIFile.cpp" />
<ClCompile Include="source\lz4_wrapper.cpp" />
<ClCompile Include="source\OffsetAdjustedIFile.cpp" />
<ClCompile Include="source\ResourceFileReader.cpp" />
<ClCompile Include="source\rsa_wrapper.cpp" />
<ClCompile Include="source\sha_wrapper.cpp" />

24
lib/libfnd/libfnd.vcxproj.filters
View file

@ -21,6 +21,9 @@
<ClInclude Include="include\fnd\aes.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\fnd\AesCtrWrappedIFile.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\fnd\base64.h">
<Filter>Header Files</Filter>
</ClInclude>
@ -48,12 +51,21 @@
<ClInclude Include="include\fnd\ISerialisable.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\fnd\LayeredIntegrityMetadata.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\fnd\LayeredIntegrityWrappedIFile.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\fnd\List.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\fnd\lz4.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\fnd\OffsetAdjustedIFile.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\fnd\ResourceFileReader.h">
<Filter>Header Files</Filter>
</ClInclude>
@ -86,6 +98,9 @@
<ClCompile Include="source\aes_wrapper.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="source\AesCtrWrappedIFile.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="source\base64_wrapper.cpp">
<Filter>Source Files</Filter>
</ClCompile>
@ -95,9 +110,18 @@
<ClCompile Include="source\io.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="source\LayeredIntegrityMetadata.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="source\LayeredIntegrityWrappedIFile.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="source\lz4_wrapper.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="source\OffsetAdjustedIFile.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="source\ResourceFileReader.cpp">
<Filter>Source Files</Filter>
</ClCompile>

80
lib/libfnd/source/AesCtrWrappedIFile.cpp Normal file
View file

@ -0,0 +1,80 @@
#include <fnd/AesCtrWrappedIFile.h>
fnd::AesCtrWrappedIFile::AesCtrWrappedIFile(const fnd::SharedPtr<fnd::IFile>& file, const fnd::aes::sAes128Key& key, const fnd::aes::sAesIvCtr& ctr) :
mFile(file),
mKey(key),
mBaseCtr(ctr),
mFileOffset(0)
{
mCache.alloc(kCacheSizeAllocSize);
}
size_t fnd::AesCtrWrappedIFile::size()
{
return (*mFile)->size();
}
void fnd::AesCtrWrappedIFile::seek(size_t offset)
{
mFileOffset = offset;
}
void fnd::AesCtrWrappedIFile::read(byte_t* out, size_t len)
{
size_t read_len;
size_t read_pos;
size_t cache_reads = (len / kCacheSize) + ((len % kCacheSize) != 0);
for (size_t i = 0; i < cache_reads; i++)
{
read_len = _MIN(len - (i * kCacheSize), kCacheSize);
read_pos = ((mFileOffset >> 4) << 4) + (i * kCacheSize);
(*mFile)->seek(read_pos);
(*mFile)->read(mCache.data(), kCacheSizeAllocSize);
fnd::aes::AesIncrementCounter(mBaseCtr.iv, read_pos>>4, mCurrentCtr.iv);
fnd::aes::AesCtr(mCache.data(), kCacheSizeAllocSize, mKey.key, mCurrentCtr.iv, mCache.data());
memcpy(out + (i * kCacheSize), mCache.data() + (mFileOffset & 0xf), read_len);
}
seek(mFileOffset + len);
}
void fnd::AesCtrWrappedIFile::read(byte_t* out, size_t offset, size_t len)
{
seek(offset);
read(out, len);
}
void fnd::AesCtrWrappedIFile::write(const byte_t* in, size_t len)
{
size_t write_len;
size_t write_pos;
size_t cache_writes = (len / kCacheSize) + ((len % kCacheSize) != 0);
for (size_t i = 0; i < cache_writes; i++)
{
write_len = _MIN(len - (i * kCacheSize), kCacheSize);
write_pos = ((mFileOffset >> 4) << 4) + (i * kCacheSize);
memcpy(mCache.data() + (mFileOffset & 0xf), in + (i * kCacheSize), write_len);
fnd::aes::AesIncrementCounter(mBaseCtr.iv, write_pos>>4, mCurrentCtr.iv);
fnd::aes::AesCtr(mCache.data(), kCacheSizeAllocSize, mKey.key, mCurrentCtr.iv, mCache.data());
(*mFile)->seek(write_pos);
(*mFile)->write(mCache.data(), kCacheSizeAllocSize);
}
seek(mFileOffset + len);
}
void fnd::AesCtrWrappedIFile::write(const byte_t* in, size_t offset, size_t len)
{
seek(offset);
write(in, len);
}

71
lib/libfnd/source/LayeredIntegrityMetadata.cpp Normal file
View file

@ -0,0 +1,71 @@
#include <fnd/LayeredIntegrityMetadata.h>
fnd::LayeredIntegrityMetadata::LayeredIntegrityMetadata() :
mLayerInfo(),
mDataLayer(),
mMasterHashList(),
mDoAlignHashToBlock(false)
{
}
void fnd::LayeredIntegrityMetadata::operator=(const LayeredIntegrityMetadata& other)
{
mLayerInfo = other.mLayerInfo;
mDataLayer = other.mDataLayer;
mMasterHashList = other.mMasterHashList;
mDoAlignHashToBlock = other.mDoAlignHashToBlock;
}
bool fnd::LayeredIntegrityMetadata::operator==(const LayeredIntegrityMetadata& other) const
{
return (mLayerInfo == other.mLayerInfo) \
&& (mDataLayer == other.mDataLayer) \
&& (mMasterHashList == other.mMasterHashList) \
&& (mDoAlignHashToBlock == other.mDoAlignHashToBlock);
}
bool fnd::LayeredIntegrityMetadata::operator!=(const LayeredIntegrityMetadata& other) const
{
return !(*this == other);
}
const fnd::List<fnd::LayeredIntegrityMetadata::sLayer>& fnd::LayeredIntegrityMetadata::getHashLayerInfo() const
{
return mLayerInfo;
}
void fnd::LayeredIntegrityMetadata::setHashLayerInfo(const fnd::List<sLayer>& layer_info)
{
mLayerInfo = layer_info;
}
const fnd::LayeredIntegrityMetadata::sLayer& fnd::LayeredIntegrityMetadata::getDataLayer() const
{
return mDataLayer;
}
void fnd::LayeredIntegrityMetadata::setDataLayerInfo(const sLayer& data_info)
{
mDataLayer = data_info;
}
const fnd::List<fnd::sha::sSha256Hash>& fnd::LayeredIntegrityMetadata::getMasterHashList() const
{
return mMasterHashList;
}
void fnd::LayeredIntegrityMetadata::setMasterHashList(const fnd::List<fnd::sha::sSha256Hash>& master_hash_list)
{
mMasterHashList = master_hash_list;
}
bool fnd::LayeredIntegrityMetadata::getAlignHashToBlock() const
{
return mDoAlignHashToBlock;
}
void fnd::LayeredIntegrityMetadata::setAlignHashToBlock(bool doAlign)
{
mDoAlignHashToBlock = doAlign;
}

103
programs/nstool/source/HashTreeWrappedIFile.cpp → lib/libfnd/source/LayeredIntegrityWrappedIFile.cpp
View file

@ -1,8 +1,7 @@
#include "common.h"
#include "HashTreeWrappedIFile.h"
#include "OffsetAdjustedIFile.h"
#include <fnd/LayeredIntegrityWrappedIFile.h>
#include <fnd/OffsetAdjustedIFile.h>
HashTreeWrappedIFile::HashTreeWrappedIFile(const fnd::SharedPtr<fnd::IFile>& file, const HashTreeMeta& hdr) :
fnd::LayeredIntegrityWrappedIFile::LayeredIntegrityWrappedIFile(const fnd::SharedPtr<fnd::IFile>& file, const fnd::LayeredIntegrityMetadata& hdr) :
mFile(file),
mData(nullptr),
mDataHashLayer(),
@ -11,80 +10,84 @@ HashTreeWrappedIFile::HashTreeWrappedIFile(const fnd::SharedPtr<fnd::IFile>& fil
initialiseDataLayer(hdr);
}
size_t HashTreeWrappedIFile::size()
size_t fnd::LayeredIntegrityWrappedIFile::size()
{
return (*mData)->size();
}
void HashTreeWrappedIFile::seek(size_t offset)
void fnd::LayeredIntegrityWrappedIFile::seek(size_t offset)
{
mDataOffset = offset;
}
void HashTreeWrappedIFile::read(byte_t* out, size_t len)
void fnd::LayeredIntegrityWrappedIFile::read(byte_t* out, size_t len)
{
size_t offset_in_start_block = getOffsetInBlock(mDataOffset);
size_t offset_in_end_block = getOffsetInBlock(offset_in_start_block + len);
size_t start_block = getOffsetBlock(mDataOffset);
size_t block_num = align(offset_in_start_block + len, mDataBlockSize) / mDataBlockSize;
size_t partial_last_block_num = block_num % mCacheBlockNum;
bool has_partial_block_num = partial_last_block_num > 0;
size_t read_iterations = (block_num / mCacheBlockNum) + has_partial_block_num;
size_t block_read_len;
size_t block_export_offset;
size_t block_export_size;
size_t block_export_pos = 0;
for (size_t i = 0; i < read_iterations; i++)
struct sBlockPosition
{
// how many blocks to read from source file
block_read_len = (i+1 == read_iterations && has_partial_block_num) ? partial_last_block_num : mCacheBlockNum;
size_t index;
size_t pos;
} start_blk, end_blk;
// offset in this current read to copy from
block_export_offset = (i == 0) ? offset_in_start_block : 0;
start_blk.index = getOffsetBlock(mDataOffset);
start_blk.pos = getOffsetInBlock(mDataOffset);
// size of current read to copy
block_export_size = (block_read_len * mDataBlockSize) - block_export_offset;
end_blk.index = getOffsetBlock(mDataOffset + len);
end_blk.pos = getOffsetInBlock(mDataOffset + len);
if (end_blk.pos == 0 && len != 0)
{
end_blk.index -= 1;
end_blk.pos = mDataBlockSize;
}
// if last read, reduce the export size by one block less offset_in_end_block
if (i+1 == read_iterations)
{
block_export_size -= (mDataBlockSize - offset_in_end_block);
}
size_t total_blk_num = (end_blk.index - start_blk.index) + 1;
// read the blocks
readData(start_block + (i * mCacheBlockNum), block_read_len);
size_t read_blk_num = 0;
size_t cache_export_start_pos, cache_export_end_pos, cache_export_size;
size_t export_pos = 0;
for (size_t i = 0; i < total_blk_num; i += read_blk_num, export_pos += cache_export_size)
{
read_blk_num = _MIN(mCacheBlockNum, (total_blk_num - i));
readData(start_blk.index + i, read_blk_num);
// export the section of data that is relevant
memcpy(out + block_export_pos, mCache.data() + block_export_offset, block_export_size);
// if this is the first read, adjust offset
if (i == 0)
cache_export_start_pos = start_blk.pos;
else
cache_export_start_pos = 0;
// if this is the last block, adjust end offset
if ((i + read_blk_num) == total_blk_num)
cache_export_end_pos = ((read_blk_num - 1) * mDataBlockSize) + end_blk.pos;
else
cache_export_end_pos = read_blk_num * mDataBlockSize;
// update export position
block_export_pos += block_export_size;
// determine cache export size
cache_export_size = cache_export_end_pos - cache_export_start_pos;
memcpy(out + export_pos, mCache.data() + cache_export_start_pos, cache_export_size);
}
// update offset
seek(mDataOffset + len);
}
void HashTreeWrappedIFile::read(byte_t* out, size_t offset, size_t len)
void fnd::LayeredIntegrityWrappedIFile::read(byte_t* out, size_t offset, size_t len)
{
seek(offset);
read(out, len);
}
void HashTreeWrappedIFile::write(const byte_t* out, size_t len)
void fnd::LayeredIntegrityWrappedIFile::write(const byte_t* out, size_t len)
{
throw fnd::Exception(kModuleName, "write() not supported");
}
void HashTreeWrappedIFile::write(const byte_t* out, size_t offset, size_t len)
void fnd::LayeredIntegrityWrappedIFile::write(const byte_t* out, size_t offset, size_t len)
{
throw fnd::Exception(kModuleName, "write() not supported");
}
void HashTreeWrappedIFile::initialiseDataLayer(const HashTreeMeta& hdr)
void fnd::LayeredIntegrityWrappedIFile::initialiseDataLayer(const fnd::LayeredIntegrityMetadata& hdr)
{
fnd::sha::sSha256Hash hash;
fnd::Vec<byte_t> cur, prev;
@ -102,7 +105,7 @@ void HashTreeWrappedIFile::initialiseDataLayer(const HashTreeMeta& hdr)
for (size_t i = 0; i < hdr.getHashLayerInfo().size(); i++)
{
// get block size
const HashTreeMeta::sLayer& layer = hdr.getHashLayerInfo()[i];
const fnd::LayeredIntegrityMetadata::sLayer& layer = hdr.getHashLayerInfo()[i];
// allocate layer
cur.alloc(align(layer.size, layer.block_size));
@ -135,22 +138,18 @@ void HashTreeWrappedIFile::initialiseDataLayer(const HashTreeMeta& hdr)
}
// generate reader for data layer
mData = new OffsetAdjustedIFile(mFile, hdr.getDataLayer().offset, hdr.getDataLayer().size);
mData = new fnd::OffsetAdjustedIFile(mFile, hdr.getDataLayer().offset, hdr.getDataLayer().size);
mDataOffset = 0;
mDataBlockSize = hdr.getDataLayer().block_size;
// allocate scratchpad
//mScratch.alloc(mDataBlockSize * 0x10);
// allocate cache
size_t cache_size = align(kDefaultCacheSize, mDataBlockSize);
mCacheBlockNum = cache_size / mDataBlockSize;
//printf("Block Size: 0x%" PRIx64 "\n", mDataBlockSize);
//printf("Cache size: 0x%" PRIx64 ", (block_num: %" PRId64 ")\n", cache_size, mCacheBlockNum);
mCache.alloc(cache_size);
}
void HashTreeWrappedIFile::readData(size_t block_offset, size_t block_num)
void fnd::LayeredIntegrityWrappedIFile::readData(size_t block_offset, size_t block_num)
{
(*mData)->seek(block_offset * mDataBlockSize);
fnd::sha::sSha256Hash hash;
// determine read size
@ -177,8 +176,6 @@ void HashTreeWrappedIFile::readData(size_t block_offset, size_t block_num)
throw fnd::Exception(kModuleName, "Read excessive of cache size");
}
//printf("readlen=0x%" PRIx64 "\n", read_len);
// validate blocks
size_t validate_size;
for (size_t i = 0; i < block_num; i++)

47
lib/libfnd/source/OffsetAdjustedIFile.cpp Normal file
View file

@ -0,0 +1,47 @@
#include <fnd/OffsetAdjustedIFile.h>
fnd::OffsetAdjustedIFile::OffsetAdjustedIFile(const fnd::SharedPtr<fnd::IFile>& file, size_t offset, size_t size) :
mFile(file),
mBaseOffset(offset),
mCurrentOffset(0),
mSize(size)
{
}
size_t fnd::OffsetAdjustedIFile::size()
{
return mSize;
}
void fnd::OffsetAdjustedIFile::seek(size_t offset)
{
mCurrentOffset = _MIN(offset, mSize);
}
void fnd::OffsetAdjustedIFile::read(byte_t* out, size_t len)
{
// assert proper position in file
(*mFile)->seek(mCurrentOffset + mBaseOffset);
(*mFile)->read(out, len);
seek(mCurrentOffset + len);
}
void fnd::OffsetAdjustedIFile::read(byte_t* out, size_t offset, size_t len)
{
seek(offset);
read(out, len);
}
void fnd::OffsetAdjustedIFile::write(const byte_t* out, size_t len)
{
// assert proper position in file
(*mFile)->seek(mCurrentOffset + mBaseOffset);
(*mFile)->write(out, len);
seek(mCurrentOffset + len);
}
void fnd::OffsetAdjustedIFile::write(const byte_t* out, size_t offset, size_t len)
{
seek(offset);
write(out, len);
}

2
programs/nstool/makefile
View file

@ -34,7 +34,7 @@ else
endif
BIN_DIR = bin
OUTPUT = $(BIN_DIR)/$(shell basename $(CURDIR))
OUTPUT = $(BIN_DIR)/$(shell basename "$(CURDIR)")
all: build

8
programs/nstool/nstool.vcxproj
View file

@ -178,21 +178,17 @@
<None Include="README.md" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="source\AesCtrWrappedIFile.h" />
<ClInclude Include="source\AssetProcess.h" />
<ClInclude Include="source\CnmtProcess.h" />
<ClInclude Include="source\common.h" />
<ClInclude Include="source\ElfSymbolParser.h" />
<ClInclude Include="source\EsTikProcess.h" />
<ClInclude Include="source\HashTreeMeta.h" />
<ClInclude Include="source\HashTreeWrappedIFile.h" />
<ClInclude Include="source\KeyConfiguration.h" />
<ClInclude Include="source\NacpProcess.h" />
<ClInclude Include="source\NcaProcess.h" />
<ClInclude Include="source\NpdmProcess.h" />
<ClInclude Include="source\NroProcess.h" />
<ClInclude Include="source\NsoProcess.h" />
<ClInclude Include="source\OffsetAdjustedIFile.h" />
<ClInclude Include="source\PfsProcess.h" />
<ClInclude Include="source\PkiCertProcess.h" />
<ClInclude Include="source\PkiValidator.h" />
@ -204,13 +200,10 @@
<ClInclude Include="source\XciProcess.h" />
</ItemGroup>
<ItemGroup>
<ClCompile Include="source\AesCtrWrappedIFile.cpp" />
<ClCompile Include="source\AssetProcess.cpp" />
<ClCompile Include="source\CnmtProcess.cpp" />
<ClCompile Include="source\ElfSymbolParser.cpp" />
<ClCompile Include="source\EsTikProcess.cpp" />
<ClCompile Include="source\HashTreeMeta.cpp" />
<ClCompile Include="source\HashTreeWrappedIFile.cpp" />
<ClCompile Include="source\KeyConfiguration.cpp" />
<ClCompile Include="source\main.cpp" />
<ClCompile Include="source\NacpProcess.cpp" />
@ -218,7 +211,6 @@
<ClCompile Include="source\NpdmProcess.cpp" />
<ClCompile Include="source\NroProcess.cpp" />
<ClCompile Include="source\NsoProcess.cpp" />
<ClCompile Include="source\OffsetAdjustedIFile.cpp" />
<ClCompile Include="source\PfsProcess.cpp" />
<ClCompile Include="source\PkiCertProcess.cpp" />
<ClCompile Include="source\PkiValidator.cpp" />

30
programs/nstool/nstool.vcxproj.filters
View file

@ -19,27 +19,21 @@
<None Include="README.md" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="source\AesCtrWrappedIFile.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="source\AssetProcess.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="source\CnmtProcess.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="source\common.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="source\ElfSymbolParser.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="source\EsTikProcess.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="source\HashTreeMeta.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="source\HashTreeWrappedIFile.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="source\KeyConfiguration.h">
<Filter>Header Files</Filter>
</ClInclude>
@ -58,9 +52,6 @@
<ClInclude Include="source\NsoProcess.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="source\OffsetAdjustedIFile.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="source\PfsProcess.h">
<Filter>Header Files</Filter>
</ClInclude>
@ -88,14 +79,8 @@
<ClInclude Include="source\XciProcess.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="source\common.h">
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="source\AesCtrWrappedIFile.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="source\AssetProcess.cpp">
<Filter>Source Files</Filter>
</ClCompile>
@ -108,12 +93,6 @@
<ClCompile Include="source\EsTikProcess.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="source\HashTreeMeta.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="source\HashTreeWrappedIFile.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="source\KeyConfiguration.cpp">
<Filter>Source Files</Filter>
</ClCompile>
@ -135,9 +114,6 @@
<ClCompile Include="source\NsoProcess.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="source\OffsetAdjustedIFile.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="source\PfsProcess.cpp">
<Filter>Source Files</Filter>
</ClCompile>

105
programs/nstool/source/AesCtrWrappedIFile.cpp
View file

@ -1,105 +0,0 @@
#include "AesCtrWrappedIFile.h"
AesCtrWrappedIFile::AesCtrWrappedIFile(const fnd::SharedPtr<fnd::IFile>& file, const fnd::aes::sAes128Key& key, const fnd::aes::sAesIvCtr& ctr) :
mFile(file),
mKey(key),
mBaseCtr(ctr),
mFileOffset(0)
{
mCache.alloc(kCacheSizeAllocSize);
}
size_t AesCtrWrappedIFile::size()
{
return (*mFile)->size();
}
void AesCtrWrappedIFile::seek(size_t offset)
{
mFileOffset = offset;
}
void AesCtrWrappedIFile::read(byte_t* out, size_t len)
{
//printf("[%x] AesCtrWrappedIFile::read(offset=0x%" PRIx64 ", size=0x%" PRIx64 ")\n", this, mFileOffset, len);
size_t read_len;
size_t read_pos;
size_t cache_reads = (len / kCacheSize) + ((len % kCacheSize) != 0);
for (size_t i = 0; i < cache_reads; i++)
{
read_len = _MIN(len - (i * kCacheSize), kCacheSize);
read_pos = ((mFileOffset >> 4) << 4) + (i * kCacheSize);
//printf("[%x] AesCtrWrappedIFile::read() CACHE READ: readlen=%" PRIx64 "\n", this, read_len);
(*mFile)->seek(read_pos);
(*mFile)->read(mCache.data(), kCacheSizeAllocSize);
fnd::aes::AesIncrementCounter(mBaseCtr.iv, read_pos>>4, mCurrentCtr.iv);
fnd::aes::AesCtr(mCache.data(), kCacheSizeAllocSize, mKey.key, mCurrentCtr.iv, mCache.data());
memcpy(out + (i * kCacheSize), mCache.data() + (mFileOffset & 0xf), read_len);
}
seek(mFileOffset + len);
}
void AesCtrWrappedIFile::read(byte_t* out, size_t offset, size_t len)
{
seek(offset);
read(out, len);
}
void AesCtrWrappedIFile::write(const byte_t* in, size_t len)
{
size_t write_len;
size_t write_pos;
size_t cache_writes = (len / kCacheSize) + ((len % kCacheSize) != 0);
for (size_t i = 0; i < cache_writes; i++)
{
write_len = _MIN(len - (i * kCacheSize), kCacheSize);
write_pos = ((mFileOffset >> 4) << 4) + (i * kCacheSize);
//printf("[%x] AesCtrWrappedIFile::read() CACHE READ: readlen=%" PRIx64 "\n", this, read_len);
memcpy(mCache.data() + (mFileOffset & 0xf), in + (i * kCacheSize), write_len);
fnd::aes::AesIncrementCounter(mBaseCtr.iv, write_pos>>4, mCurrentCtr.iv);
fnd::aes::AesCtr(mCache.data(), kCacheSizeAllocSize, mKey.key, mCurrentCtr.iv, mCache.data());
(*mFile)->seek(write_pos);
(*mFile)->write(mCache.data(), kCacheSizeAllocSize);
}
seek(mFileOffset + len);
/*
for (size_t i = 0; i < (len / kAesCtrScratchSize); i++)
{
memcpy(mScratch.data() + mBlockOffset, out + (i * kAesCtrScratchSize), kAesCtrScratchSize);
fnd::aes::AesCtr(mScratch.data(), kAesCtrScratchAllocSize, mKey.key, mCurrentCtr.iv, mScratch.data());
(*mFile)->write(mScratch.data() + mBlockOffset, kAesCtrScratchSize);
}
if (len % kAesCtrScratchSize)
{
size_t write_len = len % kAesCtrScratchSize;
size_t write_pos = ((len / kAesCtrScratchSize) * kAesCtrScratchSize);
memcpy(mScratch.data() + mBlockOffset, out + write_pos, write_len);
fnd::aes::AesCtr(mScratch.data(), kAesCtrScratchAllocSize, mKey.key, mCurrentCtr.iv, mScratch.data());
(*mFile)->write(mScratch.data() + mBlockOffset, write_len);
}
*/
seek(mFileOffset + len);
}
void AesCtrWrappedIFile::write(const byte_t* in, size_t offset, size_t len)
{
seek(offset);
write(in, len);
}

28
programs/nstool/source/AesCtrWrappedIFile.h
View file

@ -1,28 +0,0 @@
#include <fnd/IFile.h>
#include <fnd/SharedPtr.h>
#include <fnd/Vec.h>
#include <fnd/aes.h>
class AesCtrWrappedIFile : public fnd::IFile
{
public:
AesCtrWrappedIFile(const fnd::SharedPtr<fnd::IFile>& file, const fnd::aes::sAes128Key& key, const fnd::aes::sAesIvCtr& ctr);
size_t size();
void seek(size_t offset);
void read(byte_t* out, size_t len);
void read(byte_t* out, size_t offset, size_t len);
void write(const byte_t* out, size_t len);
void write(const byte_t* out, size_t offset, size_t len);
private:
const std::string kModuleName = "AesCtrWrappedIFile";
static const size_t kCacheSize = 0x10000;
static const size_t kCacheSizeAllocSize = kCacheSize + fnd::aes::kAesBlockSize;
fnd::SharedPtr<fnd::IFile> mFile;
fnd::aes::sAes128Key mKey;
fnd::aes::sAesIvCtr mBaseCtr, mCurrentCtr;
size_t mFileOffset;
fnd::Vec<byte_t> mCache;
};

6
programs/nstool/source/AssetProcess.cpp
View file

@ -1,9 +1,9 @@
#include <iostream>
#include <iomanip>
#include <fnd/SimpleFile.h>
#include <fnd/OffsetAdjustedIFile.h>
#include <fnd/Vec.h>
#include "AssetProcess.h"
#include "OffsetAdjustedIFile.h"
AssetProcess::AssetProcess() :
@ -109,7 +109,7 @@ void AssetProcess::processSections()
outfile.close();
}
mNacp.setInputFile(new OffsetAdjustedIFile(mFile, mHdr.getNacpInfo().offset, mHdr.getNacpInfo().size));
mNacp.setInputFile(new fnd::OffsetAdjustedIFile(mFile, mHdr.getNacpInfo().offset, mHdr.getNacpInfo().size));
mNacp.setCliOutputMode(mCliOutputMode);
mNacp.setVerifyMode(mVerify);
@ -121,7 +121,7 @@ void AssetProcess::processSections()
if ((mHdr.getRomfsInfo().size + mHdr.getRomfsInfo().offset) > (*mFile)->size())
throw fnd::Exception(kModuleName, "ASET geometry for romfs beyond file size");
mRomfs.setInputFile(new OffsetAdjustedIFile(mFile, mHdr.getRomfsInfo().offset, mHdr.getRomfsInfo().size));
mRomfs.setInputFile(new fnd::OffsetAdjustedIFile(mFile, mHdr.getRomfsInfo().offset, mHdr.getRomfsInfo().size));
mRomfs.setCliOutputMode(mCliOutputMode);
mRomfs.setVerifyMode(mVerify);

2
programs/nstool/source/CnmtProcess.cpp
View file

@ -1,7 +1,7 @@
#include <iostream>
#include <iomanip>
#include <fnd/SimpleTextOutput.h>
#include "OffsetAdjustedIFile.h"
#include <fnd/OffsetAdjustedIFile.h>
#include "CnmtProcess.h"
CnmtProcess::CnmtProcess() :

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

@ -1,8 +1,8 @@
#include <iostream>
#include <iomanip>
#include <fnd/SimpleTextOutput.h>
#include <fnd/OffsetAdjustedIFile.h>
#include <nn/pki/SignUtils.h>
#include "OffsetAdjustedIFile.h"
#include "EsTikProcess.h"
#include "PkiValidator.h"

135
programs/nstool/source/HashTreeMeta.cpp
View file

@ -1,135 +0,0 @@
#include "HashTreeMeta.h"
HashTreeMeta::HashTreeMeta() :
mLayerInfo(),
mDataLayer(),
mMasterHashList(),
mDoAlignHashToBlock(false)
{
}
HashTreeMeta::HashTreeMeta(const byte_t* data, size_t len, HashTreeType type) :
HashTreeMeta()
{
importData(data, len, type);
}
void HashTreeMeta::operator=(const HashTreeMeta& other)
{
mLayerInfo = other.mLayerInfo;
mDataLayer = other.mDataLayer;
mMasterHashList = other.mMasterHashList;
mDoAlignHashToBlock = other.mDoAlignHashToBlock;
}
bool HashTreeMeta::operator==(const HashTreeMeta& other) const
{
return (mLayerInfo == other.mLayerInfo) \
&& (mDataLayer == other.mDataLayer) \
&& (mMasterHashList == other.mMasterHashList) \
&& (mDoAlignHashToBlock == other.mDoAlignHashToBlock);
}
bool HashTreeMeta::operator!=(const HashTreeMeta& other) const
{
return !(*this == other);
}
void HashTreeMeta::importData(const byte_t* data, size_t len, HashTreeType type)
{
if (type == HASH_TYPE_INTEGRITY)
{
nn::hac::HierarchicalIntegrityHeader hdr;
hdr.fromBytes(data, len);
importHierarchicalIntergityHeader(hdr);
}
else if (type == HASH_TYPE_SHA256)
{
nn::hac::HierarchicalSha256Header hdr;
hdr.fromBytes(data, len);
importHierarchicalSha256Header(hdr);
}
}
const fnd::List<HashTreeMeta::sLayer>& HashTreeMeta::getHashLayerInfo() const
{
return mLayerInfo;
}
void HashTreeMeta::setHashLayerInfo(const fnd::List<sLayer>& layer_info)
{
mLayerInfo = layer_info;
}
const HashTreeMeta::sLayer& HashTreeMeta::getDataLayer() const
{
return mDataLayer;
}
void HashTreeMeta::setDataLayer(const sLayer& data_info)
{
mDataLayer = data_info;
}
const fnd::List<fnd::sha::sSha256Hash>& HashTreeMeta::getMasterHashList() const
{
return mMasterHashList;
}
void HashTreeMeta::setMasterHashList(const fnd::List<fnd::sha::sSha256Hash>& master_hash_list)
{
mMasterHashList = master_hash_list;
}
bool HashTreeMeta::getAlignHashToBlock() const
{
return mDoAlignHashToBlock;
}
void HashTreeMeta::setAlignHashToBlock(bool doAlign)
{
mDoAlignHashToBlock = doAlign;
}
void HashTreeMeta::importHierarchicalIntergityHeader(const nn::hac::HierarchicalIntegrityHeader& hdr)
{
mDoAlignHashToBlock = true;
for (size_t i = 0; i < hdr.getLayerInfo().size(); i++)
{
sLayer layer;
layer.offset = hdr.getLayerInfo()[i].offset;
layer.size = hdr.getLayerInfo()[i].size;
layer.block_size = _BIT(hdr.getLayerInfo()[i].block_size);
if (i+1 == hdr.getLayerInfo().size())
{
mDataLayer = layer;
}
else
{
mLayerInfo.addElement(layer);
}
}
mMasterHashList = hdr.getMasterHashList();
}
void HashTreeMeta::importHierarchicalSha256Header(const nn::hac::HierarchicalSha256Header& hdr)
{
mDoAlignHashToBlock = false;
for (size_t i = 0; i < hdr.getLayerInfo().size(); i++)
{
sLayer layer;
layer.offset = hdr.getLayerInfo()[i].offset;
layer.size = hdr.getLayerInfo()[i].size;
layer.block_size = hdr.getHashBlockSize();
if (i+1 == hdr.getLayerInfo().size())
{
mDataLayer = layer;
}
else
{
mLayerInfo.addElement(layer);
}
}
mMasterHashList.addElement(hdr.getMasterHash());
}

68
programs/nstool/source/HashTreeMeta.h
View file

@ -1,68 +0,0 @@
#pragma once
#include <nn/hac/HierarchicalIntegrityHeader.h>
#include <nn/hac/HierarchicalSha256Header.h>
class HashTreeMeta
{
public:
enum HashTreeType
{
HASH_TYPE_INTEGRITY,
HASH_TYPE_SHA256
};
struct sLayer
{
size_t offset;
size_t size;
size_t block_size;
void operator=(const sLayer& other)
{
offset = other.offset;
size = other.size;
block_size = other.block_size;
}
bool operator==(const sLayer& other) const
{
return (offset == other.offset && size == other.size && block_size == other.block_size);
}
bool operator!=(const sLayer& other) const
{
return !(*this == other);
}
};
HashTreeMeta();
HashTreeMeta(const byte_t* data, size_t len, HashTreeType type);
void operator=(const HashTreeMeta& other);
bool operator==(const HashTreeMeta& other) const;
bool operator!=(const HashTreeMeta& other) const;
void importData(const byte_t* data, size_t len, HashTreeType type);
const fnd::List<sLayer>& getHashLayerInfo() const;
void setHashLayerInfo(const fnd::List<sLayer>& layer_info);
const sLayer& getDataLayer() const;
void setDataLayer(const sLayer& data_info);
const fnd::List<fnd::sha::sSha256Hash>& getMasterHashList() const;
void setMasterHashList(const fnd::List<fnd::sha::sSha256Hash>& master_hash_list);
bool getAlignHashToBlock() const;
void setAlignHashToBlock(bool doAlign);
private:
// data
fnd::List<sLayer> mLayerInfo;
sLayer mDataLayer;
fnd::List<fnd::sha::sSha256Hash> mMasterHashList;
bool mDoAlignHashToBlock;
void importHierarchicalIntergityHeader(const nn::hac::HierarchicalIntegrityHeader& hdr);
void importHierarchicalSha256Header(const nn::hac::HierarchicalSha256Header& hdr);
};

45
programs/nstool/source/HashTreeWrappedIFile.h
View file

@ -1,45 +0,0 @@
#pragma once
#include <sstream>
#include <fnd/IFile.h>
#include <fnd/SharedPtr.h>
#include <fnd/Vec.h>
#include <fnd/sha.h>
#include "HashTreeMeta.h"
class HashTreeWrappedIFile : public fnd::IFile
{
public:
HashTreeWrappedIFile(const fnd::SharedPtr<fnd::IFile>& file, const HashTreeMeta& hdr);
size_t size();
void seek(size_t offset);
void read(byte_t* out, size_t len);
void read(byte_t* out, size_t offset, size_t len);
void write(const byte_t* out, size_t len);
void write(const byte_t* out, size_t offset, size_t len);
private:
const std::string kModuleName = "HashTreeWrappedIFile";
static const size_t kDefaultCacheSize = 0x10000;
std::stringstream mErrorSs;
fnd::SharedPtr<fnd::IFile> mFile;
// data file
fnd::SharedPtr<fnd::IFile> mData;
size_t mDataOffset;
size_t mDataBlockSize;
fnd::List<fnd::sha::sSha256Hash> mDataHashLayer;
bool mAlignHashCalcToBlock;
fnd::Vec<byte_t> mCache;
size_t mCacheBlockNum;
inline size_t getOffsetBlock(size_t offset) const { return offset / mDataBlockSize; }
inline size_t getOffsetInBlock(size_t offset) const { return offset % mDataBlockSize; }
inline size_t getRemanderBlockReadSize(size_t total_size) const { return total_size % mDataBlockSize; }
inline size_t getBlockNum(size_t total_size) const { return (total_size / mDataBlockSize) + (getRemanderBlockReadSize(total_size) > 0); }
void initialiseDataLayer(const HashTreeMeta& hdr);
void readData(size_t block_offset, size_t block_num);
};

2
programs/nstool/source/NacpProcess.cpp
View file

@ -2,7 +2,7 @@
#include <iostream>
#include <iomanip>
#include <fnd/SimpleTextOutput.h>
#include "OffsetAdjustedIFile.h"
#include <fnd/OffsetAdjustedIFile.h>
#include "NacpProcess.h"
NacpProcess::NacpProcess() :

85
programs/nstool/source/NcaProcess.cpp
View file

@ -2,15 +2,18 @@
#include <iomanip>
#include <sstream>
#include <fnd/SimpleTextOutput.h>
#include <fnd/OffsetAdjustedIFile.h>
#include <fnd/AesCtrWrappedIFile.h>
#include <fnd/LayeredIntegrityWrappedIFile.h>
#include <nn/hac/NcaUtils.h>
#include <nn/hac/AesKeygen.h>
#include <nn/hac/HierarchicalSha256Header.h>
#include <nn/hac/HierarchicalIntegrityHeader.h>
#include "NcaProcess.h"
#include "PfsProcess.h"
#include "RomfsProcess.h"
#include "NpdmProcess.h"
#include "OffsetAdjustedIFile.h"
#include "AesCtrWrappedIFile.h"
#include "HashTreeWrappedIFile.h"
NcaProcess::NcaProcess() :
mFile(),
@ -258,9 +261,69 @@ void NcaProcess::generatePartitionConfiguration()
info.hash_type = (nn::hac::nca::HashType)fs_header.hash_type;
info.enc_type = (nn::hac::nca::EncryptionType)fs_header.encryption_type;
if (info.hash_type == nn::hac::nca::HASH_HIERARCHICAL_SHA256)
info.hash_tree_meta.importData(fs_header.hash_superblock, nn::hac::nca::kFsHeaderHashSuperblockLen, HashTreeMeta::HASH_TYPE_SHA256);
{
// info.hash_tree_meta.importData(fs_header.hash_superblock, nn::hac::nca::kFsHeaderHashSuperblockLen, LayeredIntegrityMetadata::HASH_TYPE_SHA256);
nn::hac::HierarchicalSha256Header hdr;
fnd::List<fnd::LayeredIntegrityMetadata::sLayer> hash_layers;
fnd::LayeredIntegrityMetadata::sLayer data_layer;
fnd::List<fnd::sha::sSha256Hash> master_hash_list;
// import raw data
hdr.fromBytes(fs_header.hash_superblock, nn::hac::nca::kFsHeaderHashSuperblockLen);
for (size_t i = 0; i < hdr.getLayerInfo().size(); i++)
{
fnd::LayeredIntegrityMetadata::sLayer layer;
layer.offset = hdr.getLayerInfo()[i].offset;
layer.size = hdr.getLayerInfo()[i].size;
layer.block_size = hdr.getHashBlockSize();
if (i + 1 == hdr.getLayerInfo().size())
{
data_layer = layer;
}
else
{
hash_layers.addElement(layer);
}
}
master_hash_list.addElement(hdr.getMasterHash());
// write data into metadata
info.layered_intergrity_metadata.setAlignHashToBlock(false);
info.layered_intergrity_metadata.setHashLayerInfo(hash_layers);
info.layered_intergrity_metadata.setDataLayerInfo(data_layer);
info.layered_intergrity_metadata.setMasterHashList(master_hash_list);
}
else if (info.hash_type == nn::hac::nca::HASH_HIERARCHICAL_INTERGRITY)
info.hash_tree_meta.importData(fs_header.hash_superblock, nn::hac::nca::kFsHeaderHashSuperblockLen, HashTreeMeta::HASH_TYPE_INTEGRITY);
{
// info.hash_tree_meta.importData(fs_header.hash_superblock, nn::hac::nca::kFsHeaderHashSuperblockLen, LayeredIntegrityMetadata::HASH_TYPE_INTEGRITY);
nn::hac::HierarchicalIntegrityHeader hdr;
fnd::List<fnd::LayeredIntegrityMetadata::sLayer> hash_layers;
fnd::LayeredIntegrityMetadata::sLayer data_layer;
fnd::List<fnd::sha::sSha256Hash> master_hash_list;
hdr.fromBytes(fs_header.hash_superblock, nn::hac::nca::kFsHeaderHashSuperblockLen);
for (size_t i = 0; i < hdr.getLayerInfo().size(); i++)
{
fnd::LayeredIntegrityMetadata::sLayer layer;
layer.offset = hdr.getLayerInfo()[i].offset;
layer.size = hdr.getLayerInfo()[i].size;
layer.block_size = _BIT(hdr.getLayerInfo()[i].block_size);
if (i + 1 == hdr.getLayerInfo().size())
{
data_layer = layer;
}
else
{
hash_layers.addElement(layer);
}
}
// write data into metadata
info.layered_intergrity_metadata.setAlignHashToBlock(true);
info.layered_intergrity_metadata.setHashLayerInfo(hash_layers);
info.layered_intergrity_metadata.setDataLayerInfo(data_layer);
info.layered_intergrity_metadata.setMasterHashList(hdr.getMasterHashList());
}
// create reader
try
@ -280,13 +343,13 @@ void NcaProcess::generatePartitionConfiguration()
// create reader based on encryption type0
if (info.enc_type == nn::hac::nca::CRYPT_NONE)
{
info.reader = new OffsetAdjustedIFile(mFile, info.offset, info.size);
info.reader = new fnd::OffsetAdjustedIFile(mFile, info.offset, info.size);
}
else if (info.enc_type == nn::hac::nca::CRYPT_AESCTR)
{
if (mContentKey.aes_ctr.isSet == false)
throw fnd::Exception(kModuleName, "AES-CTR Key was not determined");
info.reader = new OffsetAdjustedIFile(new AesCtrWrappedIFile(mFile, mContentKey.aes_ctr.var, info.aes_ctr), info.offset, info.size);
info.reader = new fnd::OffsetAdjustedIFile(new fnd::AesCtrWrappedIFile(mFile, mContentKey.aes_ctr.var, info.aes_ctr), info.offset, info.size);
}
else if (info.enc_type == nn::hac::nca::CRYPT_AESXTS || info.enc_type == nn::hac::nca::CRYPT_AESCTREX)
{
@ -304,7 +367,7 @@ void NcaProcess::generatePartitionConfiguration()
// filter out unrecognised hash types, and hash based readers
if (info.hash_type == nn::hac::nca::HASH_HIERARCHICAL_SHA256 || info.hash_type == nn::hac::nca::HASH_HIERARCHICAL_INTERGRITY)
{
info.reader = new HashTreeWrappedIFile(info.reader, info.hash_tree_meta);
info.reader = new fnd::LayeredIntegrityWrappedIFile(info.reader, info.layered_intergrity_metadata);
}
else if (info.hash_type != nn::hac::nca::HASH_NONE)
{
@ -348,7 +411,7 @@ void NcaProcess::validateNcaSignatures()
const nn::hac::PfsHeader::sFile& file = exefs.getPfsHeader().getFileList().getElement(kNpdmExefsPath);
NpdmProcess npdm;
npdm.setInputFile(new OffsetAdjustedIFile(mPartitions[nn::hac::nca::PARTITION_CODE].reader, file.offset, file.size));
npdm.setInputFile(new fnd::OffsetAdjustedIFile(mPartitions[nn::hac::nca::PARTITION_CODE].reader, file.offset, file.size));
npdm.setCliOutputMode(0);
npdm.process();
@ -440,7 +503,7 @@ void NcaProcess::displayHeader()
}
if (info.hash_type == nn::hac::nca::HASH_HIERARCHICAL_INTERGRITY)
{
HashTreeMeta& hash_hdr = info.hash_tree_meta;
fnd::LayeredIntegrityMetadata& hash_hdr = info.layered_intergrity_metadata;
std::cout << " HierarchicalIntegrity Header:" << std::endl;
for (size_t j = 0; j < hash_hdr.getHashLayerInfo().size(); j++)
{
@ -463,7 +526,7 @@ void NcaProcess::displayHeader()
}
else if (info.hash_type == nn::hac::nca::HASH_HIERARCHICAL_SHA256)
{
HashTreeMeta& hash_hdr = info.hash_tree_meta;
fnd::LayeredIntegrityMetadata& hash_hdr = info.layered_intergrity_metadata;
std::cout << " HierarchicalSha256 Header:" << std::endl;
std::cout << " Master Hash:" << std::endl;
std::cout << " " << fnd::SimpleTextOutput::arrayToString(hash_hdr.getMasterHashList()[0].bytes, 0x10, true, ":") << std::endl;

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

@ -3,8 +3,8 @@
#include <fnd/types.h>
#include <fnd/IFile.h>
#include <fnd/SharedPtr.h>
#include <fnd/LayeredIntegrityMetadata.h>
#include <nn/hac/NcaHeader.h>
#include "HashTreeMeta.h"
#include "KeyConfiguration.h"
@ -100,7 +100,7 @@ private:
nn::hac::nca::FormatType format_type;
nn::hac::nca::HashType hash_type;
nn::hac::nca::EncryptionType enc_type;
HashTreeMeta hash_tree_meta;
fnd::LayeredIntegrityMetadata layered_intergrity_metadata;
fnd::aes::sAesIvCtr aes_ctr;
} mPartitions[nn::hac::nca::kPartitionNum];

4
programs/nstool/source/NroProcess.cpp
View file

@ -1,10 +1,10 @@
#include <iostream>
#include <iomanip>
#include <fnd/SimpleTextOutput.h>
#include <fnd/OffsetAdjustedIFile.h>
#include <fnd/Vec.h>
#include <fnd/lz4.h>
#include <nn/hac/nro-hb.h>
#include "OffsetAdjustedIFile.h"
#include "NroProcess.h"
NroProcess::NroProcess():
@ -107,7 +107,7 @@ void NroProcess::importHeader()
if (((le_uint64_t*)raw_hdr->reserved_0)->get() == nn::hac::nro::kNroHomebrewStructMagic && (*mFile)->size() > mHdr.getNroSize())
{
mIsHomebrewNro = true;
mAssetProc.setInputFile(new OffsetAdjustedIFile(mFile, mHdr.getNroSize(), (*mFile)->size() - mHdr.getNroSize()));
mAssetProc.setInputFile(new fnd::OffsetAdjustedIFile(mFile, mHdr.getNroSize(), (*mFile)->size() - mHdr.getNroSize()));
mAssetProc.setCliOutputMode(mCliOutputMode);
mAssetProc.setVerifyMode(mVerify);
}

2
programs/nstool/source/NsoProcess.cpp
View file

@ -1,9 +1,9 @@
#include <iostream>
#include <iomanip>
#include <fnd/SimpleTextOutput.h>
#include <fnd/OffsetAdjustedIFile.h>
#include <fnd/Vec.h>
#include <fnd/lz4.h>
#include "OffsetAdjustedIFile.h"
#include "NsoProcess.h"
NsoProcess::NsoProcess():

47
programs/nstool/source/OffsetAdjustedIFile.cpp
View file

@ -1,47 +0,0 @@
#include "OffsetAdjustedIFile.h"
OffsetAdjustedIFile::OffsetAdjustedIFile(const fnd::SharedPtr<fnd::IFile>& file, size_t offset, size_t size) :
mFile(file),
mBaseOffset(offset),
mCurrentOffset(0),
mSize(size)
{
}
size_t OffsetAdjustedIFile::size()
{
return mSize;
}
void OffsetAdjustedIFile::seek(size_t offset)
{
mCurrentOffset = _MIN(offset, mSize);
}
void OffsetAdjustedIFile::read(byte_t* out, size_t len)
{
// assert proper position in file
(*mFile)->seek(mCurrentOffset + mBaseOffset);
(*mFile)->read(out, len);
seek(mCurrentOffset + len);
}
void OffsetAdjustedIFile::read(byte_t* out, size_t offset, size_t len)
{
seek(offset);
read(out, len);
}
void OffsetAdjustedIFile::write(const byte_t* out, size_t len)
{
// assert proper position in file
(*mFile)->seek(mCurrentOffset + mBaseOffset);
(*mFile)->write(out, len);
seek(mCurrentOffset + len);
}
void OffsetAdjustedIFile::write(const byte_t* out, size_t offset, size_t len)
{
seek(offset);
write(out, len);
}

19
programs/nstool/source/OffsetAdjustedIFile.h
View file

@ -1,19 +0,0 @@
#include <fnd/IFile.h>
#include <fnd/SharedPtr.h>
class OffsetAdjustedIFile : public fnd::IFile
{
public:
OffsetAdjustedIFile(const fnd::SharedPtr<fnd::IFile>& file, size_t offset, size_t size);
size_t size();
void seek(size_t offset);
void read(byte_t* out, size_t len);
void read(byte_t* out, size_t offset, size_t len);
void write(const byte_t* out, size_t len);
void write(const byte_t* out, size_t offset, size_t len);
private:
fnd::SharedPtr<fnd::IFile> mFile;
size_t mBaseOffset, mCurrentOffset;
size_t mSize;
};

2
programs/nstool/source/PkiCertProcess.cpp
View file

@ -1,8 +1,8 @@
#include <iostream>
#include <iomanip>
#include <fnd/SimpleTextOutput.h>
#include <fnd/OffsetAdjustedIFile.h>
#include <nn/pki/SignUtils.h>
#include "OffsetAdjustedIFile.h"
#include "PkiCertProcess.h"
#include "PkiValidator.h"

6
programs/nstool/source/XciProcess.cpp
View file

@ -1,8 +1,8 @@
#include <iostream>
#include <iomanip>
#include <fnd/SimpleTextOutput.h>
#include <fnd/OffsetAdjustedIFile.h>
#include <nn/hac/XciUtils.h>
#include "OffsetAdjustedIFile.h"
#include "XciProcess.h"
XciProcess::XciProcess() :
@ -206,7 +206,7 @@ void XciProcess::processRootPfs()
{
std::cout << "[WARNING] XCI Root HFS0: FAIL (bad hash)" << std::endl;
}
mRootPfs.setInputFile(new OffsetAdjustedIFile(mFile, mHdr.getPartitionFsAddress(), mHdr.getPartitionFsSize()));
mRootPfs.setInputFile(new fnd::OffsetAdjustedIFile(mFile, mHdr.getPartitionFsAddress(), mHdr.getPartitionFsSize()));
mRootPfs.setListFs(mListFs);
mRootPfs.setVerifyMode(false);
mRootPfs.setCliOutputMode(mCliOutputMode);
@ -226,7 +226,7 @@ void XciProcess::processPartitionPfs()
}
PfsProcess tmp;
tmp.setInputFile(new OffsetAdjustedIFile(mFile, mHdr.getPartitionFsAddress() + rootPartitions[i].offset, rootPartitions[i].size));
tmp.setInputFile(new fnd::OffsetAdjustedIFile(mFile, mHdr.getPartitionFsAddress() + rootPartitions[i].offset, rootPartitions[i].size));
tmp.setListFs(mListFs);
tmp.setVerifyMode(mVerify);
tmp.setCliOutputMode(mCliOutputMode);

2
programs/nstool/source/version.h
View file

@ -3,5 +3,5 @@
#define BIN_NAME "nstool"
#define VER_MAJOR 1
#define VER_MINOR 0
#define VER_PATCH 4
#define VER_PATCH 5
#define AUTHORS "jakcron"