mirror of
https://github.com/Thealexbarney/LibHac.git
synced 2024-11-14 10:49:41 +01:00
NCA reading improvements
Add on-the-fly Partition FS hash verification Do some cleanup on NCA classes
This commit is contained in:
Alex Barney
parent
47a3eda0ed
commit
209d81187a
10 changed files with 207 additions and 212 deletions
|
|
@ -23,12 +23,12 @@ namespace LibHac
|
|||
Patch = patchRomfs ?? throw new NullReferenceException($"{nameof(patchRomfs)} cannot be null");
|
||||
Base = baseRomfs ?? throw new NullReferenceException($"{nameof(baseRomfs)} cannot be null");
|
||||
|
||||
IvfcLevelHeader level5 = section.Header.Bktr.IvfcHeader.LevelHeaders[5];
|
||||
IvfcLevelHeader level5 = section.Header.IvfcInfo.LevelHeaders[5];
|
||||
Length = level5.LogicalOffset + level5.HashDataSize;
|
||||
|
||||
using (var reader = new BinaryReader(patchRomfs, Encoding.Default, true))
|
||||
{
|
||||
patchRomfs.Position = section.Header.Bktr.RelocationHeader.Offset;
|
||||
patchRomfs.Position = section.Header.BktrInfo.RelocationHeader.Offset;
|
||||
RelocationBlock = new RelocationBlock(reader);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -8,15 +8,15 @@ namespace LibHac
|
|||
{
|
||||
public class BktrCryptoStream : Aes128CtrStream
|
||||
{
|
||||
public SubsectionBlock SubsectionBlock { get; }
|
||||
private List<SubsectionEntry> SubsectionEntries { get; } = new List<SubsectionEntry>();
|
||||
public AesSubsectionBlock AesSubsectionBlock { get; }
|
||||
private List<AesSubsectionEntry> SubsectionEntries { get; } = new List<AesSubsectionEntry>();
|
||||
private List<long> SubsectionOffsets { get; }
|
||||
private SubsectionEntry CurrentEntry { get; set; }
|
||||
private AesSubsectionEntry CurrentEntry { get; set; }
|
||||
|
||||
public BktrCryptoStream(Stream baseStream, byte[] key, long offset, long length, long counterOffset, byte[] ctrHi, BktrSuperblock bktr)
|
||||
public BktrCryptoStream(Stream baseStream, byte[] key, long offset, long length, long counterOffset, byte[] ctrHi, BktrPatchInfo bktr)
|
||||
: base(baseStream, key, offset, length, counterOffset, ctrHi)
|
||||
{
|
||||
BktrHeader header = bktr.SubsectionHeader;
|
||||
BktrHeader header = bktr.EncryptionHeader;
|
||||
byte[] subsectionBytes;
|
||||
using (var streamDec = new RandomAccessSectorStream(new Aes128CtrStream(baseStream, key, offset, length, counterOffset, ctrHi)))
|
||||
{
|
||||
|
|
@ -27,16 +27,16 @@ namespace LibHac
|
|||
|
||||
using (var reader = new BinaryReader(new MemoryStream(subsectionBytes)))
|
||||
{
|
||||
SubsectionBlock = new SubsectionBlock(reader);
|
||||
AesSubsectionBlock = new AesSubsectionBlock(reader);
|
||||
}
|
||||
|
||||
foreach (SubsectionBucket bucket in SubsectionBlock.Buckets)
|
||||
foreach (AesSubsectionBucket bucket in AesSubsectionBlock.Buckets)
|
||||
{
|
||||
SubsectionEntries.AddRange(bucket.Entries);
|
||||
}
|
||||
|
||||
// Add a subsection for the BKTR headers to make things easier
|
||||
var headerSubsection = new SubsectionEntry
|
||||
var headerSubsection = new AesSubsectionEntry
|
||||
{
|
||||
Offset = bktr.RelocationHeader.Offset,
|
||||
Counter = (uint)(ctrHi[4] << 24 | ctrHi[5] << 16 | ctrHi[6] << 8 | ctrHi[7]),
|
||||
|
|
@ -92,7 +92,7 @@ namespace LibHac
|
|||
return totalBytesRead;
|
||||
}
|
||||
|
||||
private SubsectionEntry GetSubsectionEntry(long offset)
|
||||
private AesSubsectionEntry GetSubsectionEntry(long offset)
|
||||
{
|
||||
int index = SubsectionOffsets.BinarySearch(offset);
|
||||
if (index < 0) index = ~index - 1;
|
||||
|
|
|
|||
|
|
@ -75,15 +75,15 @@ namespace LibHac
|
|||
}
|
||||
}
|
||||
|
||||
public class SubsectionBlock
|
||||
public class AesSubsectionBlock
|
||||
{
|
||||
public uint Field0;
|
||||
public int BucketCount;
|
||||
public long Size;
|
||||
public long[] BaseOffsets;
|
||||
public SubsectionBucket[] Buckets;
|
||||
public AesSubsectionBucket[] Buckets;
|
||||
|
||||
public SubsectionBlock(BinaryReader reader)
|
||||
public AesSubsectionBlock(BinaryReader reader)
|
||||
{
|
||||
long start = reader.BaseStream.Position;
|
||||
|
||||
|
|
@ -91,7 +91,7 @@ namespace LibHac
|
|||
BucketCount = reader.ReadInt32();
|
||||
Size = reader.ReadInt64();
|
||||
BaseOffsets = new long[BucketCount];
|
||||
Buckets = new SubsectionBucket[BucketCount];
|
||||
Buckets = new AesSubsectionBucket[BucketCount];
|
||||
|
||||
for (int i = 0; i < BucketCount; i++)
|
||||
{
|
||||
|
|
@ -102,47 +102,47 @@ namespace LibHac
|
|||
|
||||
for (int i = 0; i < BucketCount; i++)
|
||||
{
|
||||
Buckets[i] = new SubsectionBucket(reader);
|
||||
Buckets[i] = new AesSubsectionBucket(reader);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public class SubsectionBucket
|
||||
public class AesSubsectionBucket
|
||||
{
|
||||
public int BucketNum;
|
||||
public int EntryCount;
|
||||
public long VirtualOffsetEnd;
|
||||
public SubsectionEntry[] Entries;
|
||||
public SubsectionBucket(BinaryReader reader)
|
||||
public AesSubsectionEntry[] Entries;
|
||||
public AesSubsectionBucket(BinaryReader reader)
|
||||
{
|
||||
long start = reader.BaseStream.Position;
|
||||
|
||||
BucketNum = reader.ReadInt32();
|
||||
EntryCount = reader.ReadInt32();
|
||||
VirtualOffsetEnd = reader.ReadInt64();
|
||||
Entries = new SubsectionEntry[EntryCount];
|
||||
Entries = new AesSubsectionEntry[EntryCount];
|
||||
|
||||
for (int i = 0; i < EntryCount; i++)
|
||||
{
|
||||
Entries[i] = new SubsectionEntry(reader);
|
||||
Entries[i] = new AesSubsectionEntry(reader);
|
||||
}
|
||||
|
||||
reader.BaseStream.Position = start + 0x4000;
|
||||
}
|
||||
}
|
||||
|
||||
public class SubsectionEntry
|
||||
public class AesSubsectionEntry
|
||||
{
|
||||
public long Offset;
|
||||
public uint Field8;
|
||||
public uint Counter;
|
||||
|
||||
public SubsectionEntry Next;
|
||||
public AesSubsectionEntry Next;
|
||||
public long OffsetEnd;
|
||||
|
||||
public SubsectionEntry() { }
|
||||
public AesSubsectionEntry() { }
|
||||
|
||||
public SubsectionEntry(BinaryReader reader)
|
||||
public AesSubsectionEntry(BinaryReader reader)
|
||||
{
|
||||
Offset = reader.ReadInt64();
|
||||
Field8 = reader.ReadUInt32();
|
||||
|
|
|
|||
|
|
@ -19,7 +19,7 @@ namespace LibHac
|
|||
private readonly SHA256 _hash = SHA256.Create();
|
||||
|
||||
public IntegrityVerificationStream(IntegrityVerificationInfo info, Stream hashStream, bool enableIntegrityChecks)
|
||||
: base(info.Data, 1 << info.BlockSizePower)
|
||||
: base(info.Data, info.BlockSize)
|
||||
{
|
||||
HashStream = hashStream;
|
||||
EnableIntegrityChecks = enableIntegrityChecks;
|
||||
|
|
@ -61,6 +61,9 @@ namespace LibHac
|
|||
HashStream.Read(_hashBuffer, 0, DigestSize);
|
||||
|
||||
int bytesRead = base.Read(buffer, 0, count);
|
||||
int bytesToHash = SectorSize;
|
||||
|
||||
if (bytesRead == 0) return 0;
|
||||
|
||||
// If a hash is zero the data for the entire block is zero
|
||||
if (Type == IntegrityStreamType.Save && _hashBuffer.IsEmpty())
|
||||
|
|
@ -73,6 +76,12 @@ namespace LibHac
|
|||
{
|
||||
// Pad out unused portion of block
|
||||
Array.Clear(buffer, bytesRead, SectorSize - bytesRead);
|
||||
|
||||
// Partition FS hashes don't pad out an incomplete block
|
||||
if (Type == IntegrityStreamType.PartitionFs)
|
||||
{
|
||||
bytesToHash = bytesRead;
|
||||
}
|
||||
}
|
||||
|
||||
if (!EnableIntegrityChecks) return bytesRead;
|
||||
|
|
@ -84,7 +93,7 @@ namespace LibHac
|
|||
_hash.TransformBlock(Salt, 0, Salt.Length, null, 0);
|
||||
}
|
||||
|
||||
_hash.TransformBlock(buffer, 0, SectorSize, null, 0);
|
||||
_hash.TransformBlock(buffer, 0, bytesToHash, null, 0);
|
||||
_hash.TransformFinalBlock(buffer, 0, 0);
|
||||
|
||||
byte[] hash = _hash.Hash;
|
||||
|
|
@ -119,7 +128,7 @@ namespace LibHac
|
|||
public class IntegrityVerificationInfo
|
||||
{
|
||||
public Stream Data { get; set; }
|
||||
public int BlockSizePower { get; set; }
|
||||
public int BlockSize { get; set; }
|
||||
public byte[] Salt { get; set; }
|
||||
public IntegrityStreamType Type { get; set; }
|
||||
}
|
||||
|
|
@ -127,6 +136,7 @@ namespace LibHac
|
|||
public enum IntegrityStreamType
|
||||
{
|
||||
Save,
|
||||
RomFs
|
||||
RomFs,
|
||||
PartitionFs
|
||||
}
|
||||
}
|
||||
|
|
|
|||
178
LibHac/Nca.cs
178
LibHac/Nca.cs
|
|
@ -83,24 +83,24 @@ namespace LibHac
|
|||
NcaSection sect = Sections[index];
|
||||
if (sect == null) throw new ArgumentOutOfRangeException(nameof(index));
|
||||
|
||||
if (sect.SuperblockHashValidity == Validity.Invalid) return null;
|
||||
//if (sect.SuperblockHashValidity == Validity.Invalid) return null;
|
||||
|
||||
long offset = sect.Offset;
|
||||
long size = sect.Size;
|
||||
|
||||
Stream rawStream = StreamSource.CreateStream(offset, size);
|
||||
|
||||
switch (sect.Header.CryptType)
|
||||
switch (sect.Header.EncryptionType)
|
||||
{
|
||||
case SectionCryptType.None:
|
||||
case NcaEncryptionType.None:
|
||||
return rawStream;
|
||||
case SectionCryptType.XTS:
|
||||
case NcaEncryptionType.XTS:
|
||||
throw new NotImplementedException("NCA sections using XTS are not supported");
|
||||
case SectionCryptType.CTR:
|
||||
case NcaEncryptionType.AesCtr:
|
||||
return new RandomAccessSectorStream(new Aes128CtrStream(rawStream, DecryptedKeys[2], offset, sect.Header.Ctr), false);
|
||||
case SectionCryptType.BKTR:
|
||||
case NcaEncryptionType.AesCtrEx:
|
||||
rawStream = new RandomAccessSectorStream(
|
||||
new BktrCryptoStream(rawStream, DecryptedKeys[2], 0, size, offset, sect.Header.Ctr, sect.Header.Bktr),
|
||||
new BktrCryptoStream(rawStream, DecryptedKeys[2], 0, size, offset, sect.Header.Ctr, sect.Header.BktrInfo),
|
||||
false);
|
||||
if (BaseNca == null) return rawStream;
|
||||
|
||||
|
|
@ -125,25 +125,10 @@ namespace LibHac
|
|||
switch (sect.Header.Type)
|
||||
{
|
||||
case SectionType.Pfs0:
|
||||
PfsSuperblock pfs0Superblock = sect.Pfs0.Superblock;
|
||||
|
||||
return new SubStream(rawStream, pfs0Superblock.Pfs0Offset, pfs0Superblock.Pfs0Size);
|
||||
return InitIvfcForPartitionfs(sect.Header.Sha256Info, new SharedStreamSource(rawStream), enableIntegrityChecks);
|
||||
case SectionType.Romfs:
|
||||
case SectionType.Bktr:
|
||||
|
||||
var romfsStreamSource = new SharedStreamSource(rawStream);
|
||||
|
||||
IvfcHeader ivfc;
|
||||
if (sect.Header.Type == SectionType.Romfs)
|
||||
{
|
||||
ivfc = sect.Header.Romfs.IvfcHeader;
|
||||
}
|
||||
else
|
||||
{
|
||||
ivfc = sect.Header.Bktr.IvfcHeader;
|
||||
}
|
||||
|
||||
return InitIvfcForRomfs(ivfc, romfsStreamSource, enableIntegrityChecks);
|
||||
return InitIvfcForRomfs(sect.Header.IvfcInfo, new SharedStreamSource(rawStream), enableIntegrityChecks);
|
||||
default:
|
||||
throw new ArgumentOutOfRangeException();
|
||||
}
|
||||
|
|
@ -158,7 +143,7 @@ namespace LibHac
|
|||
initInfo[0] = new IntegrityVerificationInfo
|
||||
{
|
||||
Data = new MemoryStream(ivfc.MasterHash),
|
||||
BlockSizePower = 0
|
||||
BlockSize = 0
|
||||
};
|
||||
|
||||
for (int i = 1; i < ivfc.NumLevels; i++)
|
||||
|
|
@ -169,7 +154,7 @@ namespace LibHac
|
|||
initInfo[i] = new IntegrityVerificationInfo
|
||||
{
|
||||
Data = data,
|
||||
BlockSizePower = level.BlockSize,
|
||||
BlockSize = 1 << level.BlockSizePower,
|
||||
Type = IntegrityStreamType.RomFs
|
||||
};
|
||||
}
|
||||
|
|
@ -177,6 +162,39 @@ namespace LibHac
|
|||
return new HierarchicalIntegrityVerificationStream(initInfo, enableIntegrityChecks);
|
||||
}
|
||||
|
||||
private static Stream InitIvfcForPartitionfs(Sha256Info sb,
|
||||
SharedStreamSource pfsStreamSource, bool enableIntegrityChecks)
|
||||
{
|
||||
SharedStream hashStream = pfsStreamSource.CreateStream(sb.HashTableOffset, sb.HashTableSize);
|
||||
SharedStream dataStream = pfsStreamSource.CreateStream(sb.DataOffset, sb.DataSize);
|
||||
|
||||
var initInfo = new IntegrityVerificationInfo[3];
|
||||
|
||||
// Set the master hash
|
||||
initInfo[0] = new IntegrityVerificationInfo
|
||||
{
|
||||
Data = new MemoryStream(sb.MasterHash),
|
||||
BlockSize = 0,
|
||||
Type = IntegrityStreamType.PartitionFs
|
||||
};
|
||||
|
||||
initInfo[1] = new IntegrityVerificationInfo
|
||||
{
|
||||
Data = hashStream,
|
||||
BlockSize = (int)sb.HashTableSize,
|
||||
Type = IntegrityStreamType.PartitionFs
|
||||
};
|
||||
|
||||
initInfo[2] = new IntegrityVerificationInfo
|
||||
{
|
||||
Data = dataStream,
|
||||
BlockSize = sb.BlockSize,
|
||||
Type = IntegrityStreamType.PartitionFs
|
||||
};
|
||||
|
||||
return new HierarchicalIntegrityVerificationStream(initInfo, enableIntegrityChecks);
|
||||
}
|
||||
|
||||
public void SetBaseNca(Nca baseNca) => BaseNca = baseNca;
|
||||
|
||||
private void DecryptHeader(Keyset keyset, Stream stream)
|
||||
|
|
@ -216,46 +234,12 @@ namespace LibHac
|
|||
sect.Header = header;
|
||||
sect.Type = header.Type;
|
||||
|
||||
if (sect.Type == SectionType.Pfs0)
|
||||
{
|
||||
sect.Pfs0 = new Pfs0Section();
|
||||
sect.Pfs0.Superblock = header.Pfs;
|
||||
}
|
||||
else if (sect.Type == SectionType.Romfs)
|
||||
{
|
||||
ProcessIvfcSection(sect);
|
||||
}
|
||||
|
||||
return sect;
|
||||
}
|
||||
|
||||
private void ProcessIvfcSection(NcaSection sect)
|
||||
{
|
||||
sect.Romfs = new RomfsSection();
|
||||
sect.Romfs.Superblock = sect.Header.Romfs;
|
||||
IvfcLevelHeader[] headers = sect.Romfs.Superblock.IvfcHeader.LevelHeaders;
|
||||
|
||||
for (int i = 0; i < Romfs.IvfcMaxLevel; i++)
|
||||
{
|
||||
var level = new IvfcLevel();
|
||||
sect.Romfs.IvfcLevels[i] = level;
|
||||
IvfcLevelHeader header = headers[i];
|
||||
level.DataOffset = header.LogicalOffset;
|
||||
level.DataSize = header.HashDataSize;
|
||||
level.HashBlockSize = 1 << header.BlockSize;
|
||||
level.HashBlockCount = Util.DivideByRoundUp(level.DataSize, level.HashBlockSize);
|
||||
level.HashSize = level.HashBlockCount * 0x20;
|
||||
|
||||
if (i != 0)
|
||||
{
|
||||
level.HashOffset = sect.Romfs.IvfcLevels[i - 1].DataOffset;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void CheckBktrKey(NcaSection sect)
|
||||
{
|
||||
long offset = sect.Header.Bktr.SubsectionHeader.Offset;
|
||||
long offset = sect.Header.BktrInfo.EncryptionHeader.Offset;
|
||||
using (var streamDec = new RandomAccessSectorStream(new Aes128CtrStream(GetStream(), DecryptedKeys[2], sect.Offset, sect.Size, sect.Offset, sect.Header.Ctr)))
|
||||
{
|
||||
var reader = new BinaryReader(streamDec);
|
||||
|
|
@ -283,16 +267,16 @@ namespace LibHac
|
|||
case SectionType.Invalid:
|
||||
break;
|
||||
case SectionType.Pfs0:
|
||||
PfsSuperblock pfs0 = sect.Header.Pfs;
|
||||
Sha256Info pfs0 = sect.Header.Sha256Info;
|
||||
expected = pfs0.MasterHash;
|
||||
offset = pfs0.HashTableOffset;
|
||||
size = pfs0.HashTableSize;
|
||||
break;
|
||||
case SectionType.Romfs:
|
||||
IvfcHeader ivfc = sect.Header.Romfs.IvfcHeader;
|
||||
IvfcHeader ivfc = sect.Header.IvfcInfo;
|
||||
expected = ivfc.MasterHash;
|
||||
offset = ivfc.LevelHeaders[0].LogicalOffset;
|
||||
size = 1 << ivfc.LevelHeaders[0].BlockSize;
|
||||
size = 1 << ivfc.LevelHeaders[0].BlockSizePower;
|
||||
break;
|
||||
case SectionType.Bktr:
|
||||
CheckBktrKey(sect);
|
||||
|
|
@ -308,7 +292,7 @@ namespace LibHac
|
|||
stream.Read(hashTable, 0, hashTable.Length);
|
||||
|
||||
sect.SuperblockHashValidity = Crypto.CheckMemoryHashTable(hashTable, expected, 0, hashTable.Length);
|
||||
if (sect.Type == SectionType.Romfs) sect.Romfs.IvfcLevels[0].HashValidity = sect.SuperblockHashValidity;
|
||||
// todo if (sect.Type == SectionType.Romfs) sect.Romfs.IvfcLevels[0].HashValidity = sect.SuperblockHashValidity;
|
||||
}
|
||||
|
||||
public void VerifySection(int index, IProgressReport logger = null)
|
||||
|
|
@ -323,71 +307,16 @@ namespace LibHac
|
|||
case SectionType.Invalid:
|
||||
break;
|
||||
case SectionType.Pfs0:
|
||||
VerifyPfs0(stream, sect.Pfs0, logger);
|
||||
// todo VerifyPfs0(stream, sect.Pfs0, logger);
|
||||
break;
|
||||
case SectionType.Romfs:
|
||||
VerifyIvfc(stream, sect.Romfs.IvfcLevels, logger);
|
||||
// todo VerifyIvfc(stream, sect.Romfs.IvfcLevels, logger);
|
||||
break;
|
||||
case SectionType.Bktr:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
private void VerifyPfs0(Stream section, Pfs0Section pfs0, IProgressReport logger = null)
|
||||
{
|
||||
PfsSuperblock sb = pfs0.Superblock;
|
||||
var table = new byte[sb.HashTableSize];
|
||||
section.Position = sb.HashTableOffset;
|
||||
section.Read(table, 0, table.Length);
|
||||
|
||||
pfs0.Validity = VerifyHashTable(section, table, sb.Pfs0Offset, sb.Pfs0Size, sb.BlockSize, false, logger);
|
||||
}
|
||||
|
||||
private void VerifyIvfc(Stream section, IvfcLevel[] levels, IProgressReport logger = null)
|
||||
{
|
||||
for (int i = 1; i < levels.Length; i++)
|
||||
{
|
||||
logger?.LogMessage($" Verifying IVFC Level {i}...");
|
||||
IvfcLevel level = levels[i];
|
||||
var table = new byte[level.HashSize];
|
||||
section.Position = level.HashOffset;
|
||||
section.Read(table, 0, table.Length);
|
||||
level.HashValidity = VerifyHashTable(section, table, level.DataOffset, level.DataSize, level.HashBlockSize, true, logger);
|
||||
}
|
||||
}
|
||||
|
||||
private Validity VerifyHashTable(Stream section, byte[] hashTable, long dataOffset, long dataLen, long blockSize, bool isFinalBlockFull, IProgressReport logger = null)
|
||||
{
|
||||
const int hashSize = 0x20;
|
||||
var currentBlock = new byte[blockSize];
|
||||
var expectedHash = new byte[hashSize];
|
||||
long blockCount = Util.DivideByRoundUp(dataLen, blockSize);
|
||||
int curBlockSize = (int)blockSize;
|
||||
section.Position = dataOffset;
|
||||
logger?.SetTotal(blockCount);
|
||||
|
||||
for (long i = 0; i < blockCount; i++)
|
||||
{
|
||||
var remaining = (dataLen - i * blockSize);
|
||||
if (remaining < blockSize)
|
||||
{
|
||||
Array.Clear(currentBlock, 0, currentBlock.Length);
|
||||
if (!isFinalBlockFull) curBlockSize = (int)remaining;
|
||||
}
|
||||
Array.Copy(hashTable, i * hashSize, expectedHash, 0, hashSize);
|
||||
section.Read(currentBlock, 0, curBlockSize);
|
||||
|
||||
if (Crypto.CheckMemoryHashTable(currentBlock, expectedHash, 0, curBlockSize) == Validity.Invalid)
|
||||
{
|
||||
return Validity.Invalid;
|
||||
}
|
||||
|
||||
logger?.ReportAdd(1);
|
||||
}
|
||||
|
||||
return Validity.Valid;
|
||||
}
|
||||
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
if (!KeepOpen)
|
||||
|
|
@ -399,7 +328,6 @@ namespace LibHac
|
|||
|
||||
public class NcaSection
|
||||
{
|
||||
public Stream Stream { get; set; }
|
||||
public NcaFsHeader Header { get; set; }
|
||||
public SectionType Type { get; set; }
|
||||
public int SectionNum { get; set; }
|
||||
|
|
@ -407,8 +335,6 @@ namespace LibHac
|
|||
public long Size { get; set; }
|
||||
public Validity SuperblockHashValidity { get; set; }
|
||||
|
||||
public Pfs0Section Pfs0 { get; set; }
|
||||
public RomfsSection Romfs { get; set; }
|
||||
public bool IsExefs { get; internal set; }
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -84,48 +84,66 @@ namespace LibHac
|
|||
|
||||
public class NcaFsHeader
|
||||
{
|
||||
public byte Field0;
|
||||
public byte Field1;
|
||||
public SectionPartitionType PartitionType;
|
||||
public SectionFsType FsType;
|
||||
public SectionCryptType CryptType;
|
||||
public short Version;
|
||||
public NcaFormatType FormatType;
|
||||
public NcaHashType HashType;
|
||||
public NcaEncryptionType EncryptionType;
|
||||
public SectionType Type;
|
||||
|
||||
public PfsSuperblock Pfs;
|
||||
public RomfsSuperblock Romfs;
|
||||
public BktrSuperblock Bktr;
|
||||
public IvfcHeader IvfcInfo;
|
||||
public Sha256Info Sha256Info;
|
||||
public BktrPatchInfo BktrInfo;
|
||||
|
||||
public byte[] Ctr;
|
||||
|
||||
public NcaFsHeader(BinaryReader reader)
|
||||
{
|
||||
long start = reader.BaseStream.Position;
|
||||
Field0 = reader.ReadByte();
|
||||
Field1 = reader.ReadByte();
|
||||
PartitionType = (SectionPartitionType)reader.ReadByte();
|
||||
FsType = (SectionFsType)reader.ReadByte();
|
||||
CryptType = (SectionCryptType)reader.ReadByte();
|
||||
Version = reader.ReadInt16();
|
||||
FormatType = (NcaFormatType)reader.ReadByte();
|
||||
HashType = (NcaHashType)reader.ReadByte();
|
||||
EncryptionType = (NcaEncryptionType)reader.ReadByte();
|
||||
reader.BaseStream.Position += 3;
|
||||
|
||||
if (PartitionType == SectionPartitionType.Pfs0 && FsType == SectionFsType.Pfs0)
|
||||
switch (HashType)
|
||||
{
|
||||
case NcaHashType.Sha256:
|
||||
Sha256Info = new Sha256Info(reader);
|
||||
break;
|
||||
case NcaHashType.Ivfc:
|
||||
IvfcInfo = new IvfcHeader(reader);
|
||||
break;
|
||||
}
|
||||
|
||||
if (EncryptionType == NcaEncryptionType.AesCtrEx)
|
||||
{
|
||||
BktrInfo = new BktrPatchInfo();
|
||||
|
||||
reader.BaseStream.Position = start + 0x100;
|
||||
|
||||
BktrInfo.RelocationHeader = new BktrHeader(reader);
|
||||
BktrInfo.EncryptionHeader = new BktrHeader(reader);
|
||||
}
|
||||
|
||||
if (FormatType == NcaFormatType.Pfs0)
|
||||
{
|
||||
Type = SectionType.Pfs0;
|
||||
Pfs = new PfsSuperblock(reader);
|
||||
}
|
||||
else if (PartitionType == SectionPartitionType.Romfs && FsType == SectionFsType.Romfs)
|
||||
else if (FormatType == NcaFormatType.Romfs)
|
||||
{
|
||||
if (CryptType == SectionCryptType.BKTR)
|
||||
if (EncryptionType == NcaEncryptionType.AesCtrEx)
|
||||
{
|
||||
Type = SectionType.Bktr;
|
||||
Bktr = new BktrSuperblock(reader);
|
||||
}
|
||||
else
|
||||
{
|
||||
Type = SectionType.Romfs;
|
||||
Romfs = new RomfsSuperblock(reader);
|
||||
}
|
||||
}
|
||||
|
||||
reader.BaseStream.Position = start + 0x140;
|
||||
Ctr = reader.ReadBytes(8).Reverse().ToArray();
|
||||
|
||||
reader.BaseStream.Position = start + 512;
|
||||
}
|
||||
}
|
||||
|
|
@ -156,10 +174,16 @@ namespace LibHac
|
|||
}
|
||||
}
|
||||
|
||||
public class BktrPatchInfo
|
||||
{
|
||||
public BktrHeader RelocationHeader;
|
||||
public BktrHeader EncryptionHeader;
|
||||
}
|
||||
|
||||
public class IvfcHeader
|
||||
{
|
||||
public string Magic;
|
||||
public uint Id;
|
||||
public int Version;
|
||||
public uint MasterHashSize;
|
||||
public uint NumLevels;
|
||||
public IvfcLevelHeader[] LevelHeaders = new IvfcLevelHeader[6];
|
||||
|
|
@ -169,7 +193,8 @@ namespace LibHac
|
|||
public IvfcHeader(BinaryReader reader)
|
||||
{
|
||||
Magic = reader.ReadAscii(4);
|
||||
Id = reader.ReadUInt32();
|
||||
Version = reader.ReadInt16();
|
||||
reader.BaseStream.Position += 2;
|
||||
MasterHashSize = reader.ReadUInt32();
|
||||
NumLevels = reader.ReadUInt32();
|
||||
|
||||
|
|
@ -187,24 +212,46 @@ namespace LibHac
|
|||
{
|
||||
public long LogicalOffset;
|
||||
public long HashDataSize;
|
||||
public int BlockSize;
|
||||
public int BlockSizePower;
|
||||
public uint Reserved;
|
||||
|
||||
public IvfcLevelHeader(BinaryReader reader)
|
||||
{
|
||||
LogicalOffset = reader.ReadInt64();
|
||||
HashDataSize = reader.ReadInt64();
|
||||
BlockSize = reader.ReadInt32();
|
||||
BlockSizePower = reader.ReadInt32();
|
||||
Reserved = reader.ReadUInt32();
|
||||
}
|
||||
}
|
||||
|
||||
public class Sha256Info
|
||||
{
|
||||
public byte[] MasterHash;
|
||||
public int BlockSize; // In bytes
|
||||
public uint Always2;
|
||||
public long HashTableOffset;
|
||||
public long HashTableSize;
|
||||
public long DataOffset;
|
||||
public long DataSize;
|
||||
|
||||
public Sha256Info(BinaryReader reader)
|
||||
{
|
||||
MasterHash = reader.ReadBytes(0x20);
|
||||
BlockSize = reader.ReadInt32();
|
||||
Always2 = reader.ReadUInt32();
|
||||
HashTableOffset = reader.ReadInt64();
|
||||
HashTableSize = reader.ReadInt64();
|
||||
DataOffset = reader.ReadInt64();
|
||||
DataSize = reader.ReadInt64();
|
||||
}
|
||||
}
|
||||
|
||||
public class BktrHeader
|
||||
{
|
||||
public long Offset;
|
||||
public long Size;
|
||||
public uint Magic;
|
||||
public uint Field14;
|
||||
public uint Version;
|
||||
public uint NumEntries;
|
||||
public uint Field1C;
|
||||
|
||||
|
|
@ -213,7 +260,7 @@ namespace LibHac
|
|||
Offset = reader.ReadInt64();
|
||||
Size = reader.ReadInt64();
|
||||
Magic = reader.ReadUInt32();
|
||||
Field14 = reader.ReadUInt32();
|
||||
Version = reader.ReadUInt32();
|
||||
NumEntries = reader.ReadUInt32();
|
||||
Field1C = reader.ReadUInt32();
|
||||
}
|
||||
|
|
@ -281,21 +328,24 @@ namespace LibHac
|
|||
Gamecard
|
||||
}
|
||||
|
||||
public enum SectionCryptType
|
||||
public enum NcaEncryptionType
|
||||
{
|
||||
None = 1,
|
||||
Auto,
|
||||
None,
|
||||
XTS,
|
||||
CTR,
|
||||
BKTR
|
||||
AesCtr,
|
||||
AesCtrEx
|
||||
}
|
||||
|
||||
public enum SectionFsType
|
||||
public enum NcaHashType
|
||||
{
|
||||
Pfs0 = 2,
|
||||
Romfs
|
||||
Auto,
|
||||
None,
|
||||
Sha256,
|
||||
Ivfc
|
||||
}
|
||||
|
||||
public enum SectionPartitionType
|
||||
public enum NcaFormatType
|
||||
{
|
||||
Romfs,
|
||||
Pfs0
|
||||
|
|
|
|||
|
|
@ -71,7 +71,7 @@ namespace LibHac
|
|||
public class PfsSuperblock
|
||||
{
|
||||
public byte[] MasterHash; /* SHA-256 hash of the hash table. */
|
||||
public uint BlockSize; /* In bytes. */
|
||||
public int BlockSize; /* In bytes. */
|
||||
public uint Always2;
|
||||
public long HashTableOffset; /* Normally zero. */
|
||||
public long HashTableSize;
|
||||
|
|
@ -81,7 +81,7 @@ namespace LibHac
|
|||
public PfsSuperblock(BinaryReader reader)
|
||||
{
|
||||
MasterHash = reader.ReadBytes(0x20);
|
||||
BlockSize = reader.ReadUInt32();
|
||||
BlockSize = reader.ReadInt32();
|
||||
Always2 = reader.ReadUInt32();
|
||||
HashTableOffset = reader.ReadInt64();
|
||||
HashTableSize = reader.ReadInt64();
|
||||
|
|
|
|||
|
|
@ -130,7 +130,7 @@ namespace LibHac.Savefile
|
|||
initInfo[0] = new IntegrityVerificationInfo
|
||||
{
|
||||
Data = new MemoryStream(Header.MasterHashA),
|
||||
BlockSizePower = 0,
|
||||
BlockSize = 0,
|
||||
Type = IntegrityStreamType.Save
|
||||
};
|
||||
|
||||
|
|
@ -145,7 +145,7 @@ namespace LibHac.Savefile
|
|||
initInfo[i] = new IntegrityVerificationInfo
|
||||
{
|
||||
Data = data,
|
||||
BlockSizePower = level.BlockSize,
|
||||
BlockSize = 1 << level.BlockSizePower,
|
||||
Salt = new HMACSHA256(Encoding.ASCII.GetBytes(SaltSources[i - 1])).ComputeHash(ivfc.SaltSource),
|
||||
Type = IntegrityStreamType.Save
|
||||
};
|
||||
|
|
|
|||
|
|
@ -178,34 +178,43 @@ namespace hactoolnet
|
|||
|
||||
void PrintPfs0(NcaSection sect)
|
||||
{
|
||||
PfsSuperblock sBlock = sect.Pfs0.Superblock;
|
||||
PrintItem(sb, colLen, $" Superblock Hash{sect.SuperblockHashValidity.GetValidityString()}:", sBlock.MasterHash);
|
||||
sb.AppendLine($" Hash Table{sect.Pfs0.Validity.GetValidityString()}:");
|
||||
Sha256Info hashInfo = sect.Header.Sha256Info;
|
||||
|
||||
PrintItem(sb, colLen, " Offset:", $"0x{sBlock.HashTableOffset:x12}");
|
||||
PrintItem(sb, colLen, " Size:", $"0x{sBlock.HashTableSize:x12}");
|
||||
PrintItem(sb, colLen, " Block Size:", $"0x{sBlock.BlockSize:x}");
|
||||
PrintItem(sb, colLen, " PFS0 Offset:", $"0x{sBlock.Pfs0Offset:x12}");
|
||||
PrintItem(sb, colLen, " PFS0 Size:", $"0x{sBlock.Pfs0Size:x12}");
|
||||
PrintItem(sb, colLen, $" Superblock Hash{sect.SuperblockHashValidity.GetValidityString()}:", hashInfo.MasterHash);
|
||||
// todo sb.AppendLine($" Hash Table{sect.Pfs0.Validity.GetValidityString()}:");
|
||||
sb.AppendLine($" Hash Table:");
|
||||
|
||||
PrintItem(sb, colLen, " Offset:", $"0x{hashInfo.HashTableOffset:x12}");
|
||||
PrintItem(sb, colLen, " Size:", $"0x{hashInfo.HashTableSize:x12}");
|
||||
PrintItem(sb, colLen, " Block Size:", $"0x{hashInfo.BlockSize:x}");
|
||||
PrintItem(sb, colLen, " PFS0 Offset:", $"0x{hashInfo.DataOffset:x12}");
|
||||
PrintItem(sb, colLen, " PFS0 Size:", $"0x{hashInfo.DataSize:x12}");
|
||||
}
|
||||
|
||||
void PrintRomfs(NcaSection sect)
|
||||
{
|
||||
RomfsSuperblock sBlock = sect.Romfs.Superblock;
|
||||
IvfcLevel[] levels = sect.Romfs.IvfcLevels;
|
||||
IvfcHeader ivfcInfo = sect.Header.IvfcInfo;
|
||||
|
||||
PrintItem(sb, colLen, $" Superblock Hash{sect.SuperblockHashValidity.GetValidityString()}:", sBlock.IvfcHeader.MasterHash);
|
||||
PrintItem(sb, colLen, " Magic:", sBlock.IvfcHeader.Magic);
|
||||
PrintItem(sb, colLen, " ID:", $"{sBlock.IvfcHeader.Id:x8}");
|
||||
PrintItem(sb, colLen, $" Superblock Hash{sect.SuperblockHashValidity.GetValidityString()}:", ivfcInfo.MasterHash);
|
||||
PrintItem(sb, colLen, " Magic:", ivfcInfo.Magic);
|
||||
PrintItem(sb, colLen, " Version:", $"{ivfcInfo.Version:x8}");
|
||||
|
||||
for (int i = 0; i < Romfs.IvfcMaxLevel; i++)
|
||||
{
|
||||
IvfcLevel level = levels[i];
|
||||
sb.AppendLine($" Level {i}{level.HashValidity.GetValidityString()}:");
|
||||
PrintItem(sb, colLen, " Data Offset:", $"0x{level.DataOffset:x12}");
|
||||
PrintItem(sb, colLen, " Data Size:", $"0x{level.DataSize:x12}");
|
||||
PrintItem(sb, colLen, " Hash Offset:", $"0x{level.HashOffset:x12}");
|
||||
PrintItem(sb, colLen, " Hash BlockSize:", $"0x{level.HashBlockSize:x8}");
|
||||
IvfcLevelHeader level = ivfcInfo.LevelHeaders[i];
|
||||
long hashOffset = 0;
|
||||
|
||||
if (i != 0)
|
||||
{
|
||||
hashOffset = ivfcInfo.LevelHeaders[i - 1].LogicalOffset;
|
||||
}
|
||||
|
||||
// todo sb.AppendLine($" Level {i}{level.HashValidity.GetValidityString()}:");
|
||||
sb.AppendLine($" Level {i}:");
|
||||
PrintItem(sb, colLen, " Data Offset:", $"0x{level.LogicalOffset:x12}");
|
||||
PrintItem(sb, colLen, " Data Size:", $"0x{level.HashDataSize:x12}");
|
||||
PrintItem(sb, colLen, " Hash Offset:", $"0x{hashOffset:x12}");
|
||||
PrintItem(sb, colLen, " Hash BlockSize:", $"0x{1 << level.BlockSizePower:x8}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -170,7 +170,7 @@ namespace hactoolnet
|
|||
|
||||
foreach (NcaSection sect in nca.Sections.Where(x => x != null))
|
||||
{
|
||||
Console.WriteLine($" {sect.SectionNum} {sect.Type} {sect.Header.CryptType} {sect.SuperblockHashValidity}");
|
||||
Console.WriteLine($" {sect.SectionNum} {sect.Type} {sect.Header.EncryptionType} {sect.SuperblockHashValidity}");
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue