Merge pull request #52 from jakcron/nstool-1.0

Merge NSTool 1.0.5 changes into master.

.vscode/c_cpp_properties.json

@@ -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",

lib/libfnd/include/fnd/AesCtrWrappedIFile.h

@@ -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;
+	};
+}

lib/libfnd/include/fnd/IFile.h

@@ -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;

lib/libfnd/include/fnd/ISerialisable.h

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

lib/libfnd/include/fnd/LayeredIntegrityMetadata.h

@@ -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;
+	};
+}

lib/libfnd/include/fnd/LayeredIntegrityWrappedIFile.h

@@ -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);
+	};
+}

lib/libfnd/include/fnd/OffsetAdjustedIFile.h

@@ -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;
+	};
+}

lib/libfnd/libfnd.vcxproj

@@ -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" />

lib/libfnd/libfnd.vcxproj.filters

@@ -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>

lib/libfnd/source/AesCtrWrappedIFile.cpp

@@ -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);
+}

lib/libfnd/source/LayeredIntegrityMetadata.cpp

@@ -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;
+}

lib/libfnd/source/LayeredIntegrityWrappedIFile.cpp

@@ -1,8 +1,7 @@
-#include "common.h"
+#include <fnd/LayeredIntegrityWrappedIFile.h>
-#include "HashTreeWrappedIFile.h"
+#include <fnd/OffsetAdjustedIFile.h>
-#include "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);
+	struct sBlockPosition 
-	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++)
 	{
-		// how many blocks to read from source file
+		size_t index;
-		block_read_len = (i+1 == read_iterations && has_partial_block_num) ? partial_last_block_num : mCacheBlockNum;
+		size_t pos;
+	} start_blk, end_blk;
 
-		// offset in this current read to copy from
+	start_blk.index = getOffsetBlock(mDataOffset);
-		block_export_offset = (i == 0) ? offset_in_start_block : 0;
+	start_blk.pos = getOffsetInBlock(mDataOffset);
 
-		// size of current read to copy
+	end_blk.index = getOffsetBlock(mDataOffset + len);
-		block_export_size = (block_read_len * mDataBlockSize) - block_export_offset;
+	end_blk.pos = getOffsetInBlock(mDataOffset + len);
-
+	if (end_blk.pos == 0 && len != 0)
-		// 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);
+		end_blk.index -= 1;
+		end_blk.pos = mDataBlockSize;
 	}
 
-		// read the blocks
+	size_t total_blk_num = (end_blk.index - start_blk.index) + 1;
-		readData(start_block + (i * mCacheBlockNum), block_read_len);
 
-		// export the section of data that is relevant
+	size_t read_blk_num = 0;
-		memcpy(out + block_export_pos, mCache.data() + block_export_offset, block_export_size);
+	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);
 
-		// update export position
+		// if this is the first read, adjust offset
-		block_export_pos += block_export_size;
+		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;
+
+		// 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
+	// allocate cache
-	//mScratch.alloc(mDataBlockSize * 0x10);
 	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++)

lib/libfnd/source/OffsetAdjustedIFile.cpp

@@ -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);
+}

programs/nstool/makefile

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

programs/nstool/nstool.vcxproj

@@ -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" />

programs/nstool/nstool.vcxproj.filters

@@ -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>

programs/nstool/source/AesCtrWrappedIFile.cpp

@@ -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);
-}

programs/nstool/source/AesCtrWrappedIFile.h

@@ -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;
-};

programs/nstool/source/AssetProcess.cpp

@@ -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);
 

programs/nstool/source/CnmtProcess.cpp

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

programs/nstool/source/EsTikProcess.cpp

@@ -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"
 

programs/nstool/source/HashTreeMeta.cpp

@@ -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());
-}

programs/nstool/source/HashTreeMeta.h

@@ -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);
-};

programs/nstool/source/HashTreeWrappedIFile.h

@@ -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);
-};

programs/nstool/source/NacpProcess.cpp

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

programs/nstool/source/NcaProcess.cpp

@@ -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;

programs/nstool/source/NcaProcess.h

@@ -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];
 

programs/nstool/source/NroProcess.cpp

@@ -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);
 	}

programs/nstool/source/NsoProcess.cpp

@@ -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():

programs/nstool/source/OffsetAdjustedIFile.cpp

@@ -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);
-}

programs/nstool/source/OffsetAdjustedIFile.h

@@ -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;
-};

programs/nstool/source/PkiCertProcess.cpp

@@ -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"
 

programs/nstool/source/XciProcess.cpp

@@ -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);

programs/nstool/source/version.h

@@ -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"