Bump version

Fix top level printing issue
Fix deserialization of NCCH extended header
2026-02-05 21:34:02 +00:00 · 2024-11-14 11:32:17 -05:00 · 2024-11-14 11:24:08 -05:00 · 2024-11-14 11:20:46 -05:00 · 2024-11-14 03:17:11 -05:00 · 2024-11-14 00:12:35 -05:00
6 changed files with 582 additions and 309 deletions
--- a/InfoPrint/InfoPrint.csproj
+++ b/InfoPrint/InfoPrint.csproj
@@ -9,7 +9,7 @@
        <Nullable>enable</Nullable>
        <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
        <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-        <Version>1.7.0</Version>
+        <Version>1.7.3</Version>
    </PropertyGroup>

    <!-- Support All Frameworks -->
--- a/SabreTools.Serialization.Test/SabreTools.Serialization.Test.csproj
+++ b/SabreTools.Serialization.Test/SabreTools.Serialization.Test.csproj
@@ -27,7 +27,7 @@
            <PrivateAssets>all</PrivateAssets>
        </PackageReference>
        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
-        <PackageReference Include="SabreTools.Models" Version="1.5.0" />
+        <PackageReference Include="SabreTools.Models" Version="1.5.1" />
        <PackageReference Include="xunit" Version="2.9.2" />
        <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2">
            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
--- a/SabreTools.Serialization/Deserializers/N3DS.cs
+++ b/SabreTools.Serialization/Deserializers/N3DS.cs
@@ -21,7 +21,7 @@ namespace SabreTools.Serialization.Deserializers
                return null;

            // Cache the current offset
-            int initialOffset = (int)data.Position;
+            long initialOffset = data.Position;

            // Create a new cart image to fill
            var cart = new Cart();
@@ -62,118 +62,72 @@ namespace SabreTools.Serialization.Deserializers

            #endregion

-            #region Partitions
-
-            // Create the partition table
-            cart.Partitions = new NCCHHeader[8];
-
-            // Iterate and build the partitions
-            for (int i = 0; i < 8; i++)
-            {
-                cart.Partitions[i] = ParseNCCHHeader(data);
-            }
-
-            #endregion
-
            // Cache the media unit size for further use
            long mediaUnitSize = 0;
            if (header.PartitionFlags != null)
                mediaUnitSize = (uint)(0x200 * Math.Pow(2, header.PartitionFlags[(int)NCSDFlags.MediaUnitSize]));

-            #region Extended Headers
+            #region Partitions

-            // Create the extended header table
-            cart.ExtendedHeaders = new NCCHExtendedHeader[8];
+            // Create the tables
+            cart.Partitions = new NCCHHeader[8];
+            cart.ExtendedHeaders = new NCCHExtendedHeader?[8];
+            cart.ExeFSHeaders = new ExeFSHeader?[8];
+            cart.RomFSHeaders = new RomFSHeader?[8];

-            // Iterate and build the extended headers
+            // Iterate and build the partitions
            for (int i = 0; i < 8; i++)
            {
-                // If we have an encrypted or invalid partition
-                if (cart.Partitions[i]!.MagicID != NCCHMagicNumber)
+                // Cache the offset of the partition
+                initialOffset = data.Position;
+
+                // Handle the normal header
+                var partition = ParseNCCHHeader(data);
+                if (partition == null || partition.MagicID != NCCHMagicNumber)
                    continue;

-                // If we have no partitions table
-                if (cart.Header!.PartitionsTable == null)
-                    continue;
+                // Set the normal header
+                cart.Partitions[i] = partition;

-                // Get the extended header offset
-                long offset = (cart.Header.PartitionsTable[i]!.Offset * mediaUnitSize) + 0x200;
-                if (offset < 0 || offset >= data.Length)
-                    continue;
+                // Handle the extended header, if it exists
+                if (partition.ExtendedHeaderSizeInBytes > 0)
+                {
+                    var extendedHeader = ParseNCCHExtendedHeader(data);
+                    if (extendedHeader != null)
+                        cart.ExtendedHeaders[i] = extendedHeader;
+                }

-                // Seek to the extended header
-                data.Seek(offset, SeekOrigin.Begin);
+                // Handle the ExeFS, if it exists
+                if (partition.ExeFSSizeInMediaUnits > 0)
+                {
+                    long offset = partition.ExeFSOffsetInMediaUnits * mediaUnitSize;
+                    data.Seek(initialOffset + offset, SeekOrigin.Begin);

-                // Parse the extended header
-                var extendedHeader = ParseNCCHExtendedHeader(data);
-                if (extendedHeader != null)
-                    cart.ExtendedHeaders[i] = extendedHeader;
-            }
+                    var exeFsHeader = ParseExeFSHeader(data);
+                    if (exeFsHeader == null)
+                        return null;

-            #endregion
+                    cart.ExeFSHeaders[i] = exeFsHeader;
+                }

-            #region ExeFS Headers
+                // Handle the RomFS, if it exists
+                if (partition.RomFSSizeInMediaUnits > 0)
+                {
+                    long offset = partition.RomFSOffsetInMediaUnits * mediaUnitSize;
+                    data.Seek(initialOffset + offset, SeekOrigin.Begin);

-            // Create the ExeFS header table
-            cart.ExeFSHeaders = new ExeFSHeader[8];
+                    var romFsHeader = ParseRomFSHeader(data);
+                    if (romFsHeader == null)
+                        continue;
+                    else if (romFsHeader.MagicString != RomFSMagicNumber || romFsHeader.MagicNumber != RomFSSecondMagicNumber)
+                        continue;

-            // Iterate and build the ExeFS headers
-            for (int i = 0; i < 8; i++)
-            {
-                // If we have an encrypted or invalid partition
-                if (cart.Partitions[i]!.MagicID != NCCHMagicNumber)
-                    continue;
-
-                // If we have no partitions table
-                if (cart.Header!.PartitionsTable == null)
-                    continue;
-
-                // Get the ExeFS header offset
-                long offset = (cart.Header.PartitionsTable[i]!.Offset + cart.Partitions[i]!.ExeFSOffsetInMediaUnits) * mediaUnitSize;
-                if (offset < 0 || offset >= data.Length)
-                    continue;
-
-                // Seek to the ExeFS header
-                data.Seek(offset, SeekOrigin.Begin);
-
-                // Parse the ExeFS header
-                var exeFsHeader = ParseExeFSHeader(data);
-                if (exeFsHeader == null)
-                    return null;
-
-                cart.ExeFSHeaders[i] = exeFsHeader;
-            }
-
-            #endregion
-
-            #region RomFS Headers
-
-            // Create the RomFS header table
-            cart.RomFSHeaders = new RomFSHeader[8];
-
-            // Iterate and build the RomFS headers
-            for (int i = 0; i < 8; i++)
-            {
-                // If we have an encrypted or invalid partition
-                if (cart.Partitions[i]!.MagicID != NCCHMagicNumber)
-                    continue;
-
-                // If we have no partitions table
-                if (cart.Header!.PartitionsTable == null)
-                    continue;
-
-                // Get the RomFS header offset
-                long offset = (cart.Header.PartitionsTable[i]!.Offset + cart.Partitions[i]!.RomFSOffsetInMediaUnits) * mediaUnitSize;
-                if (offset < 0 || offset >= data.Length)
-                    continue;
-
-                // Seek to the RomFS header
-                data.Seek(offset, SeekOrigin.Begin);
-
-                // Parse the RomFS header
-                var romFsHeader = ParseRomFSHeader(data);
-                if (romFsHeader != null)
                    cart.RomFSHeaders[i] = romFsHeader;
+                }
+
+                // Skip past other data
+                long partitionSize = partition.ContentSizeInMediaUnits * mediaUnitSize;
+                data.Seek(initialOffset + partitionSize, SeekOrigin.Begin);
            }

            #endregion
@@ -264,25 +218,20 @@ namespace SabreTools.Serialization.Deserializers

            header.WritableAddressMediaUnits = data.ReadUInt32();
            header.CardInfoBitmask = data.ReadUInt32();
-            header.Reserved3 = data.ReadBytes(0x108);
+            header.Reserved1 = data.ReadBytes(0xF8);
+            header.FilledSize = data.ReadUInt32();
+            header.Reserved2 = data.ReadBytes(0x0C);
            header.TitleVersion = data.ReadUInt16();
            header.CardRevision = data.ReadUInt16();
+            header.Reserved3 = data.ReadBytes(0x0C);
+            header.CVerTitleID = data.ReadBytes(0x08);
+            header.CVerVersionNumber = data.ReadUInt16();
            header.Reserved4 = data.ReadBytes(0xCD6);
            header.InitialData = ParseInitialData(data);

            return header;
        }

-        /// <summary>
-        /// Parse a Stream into a development card info header
-        /// </summary>
-        /// <param name="data">Stream to parse</param>
-        /// <returns>Filled development card info header on success, null on error</returns>
-        public static DevelopmentCardInfoHeader? ParseDevelopmentCardInfoHeader(Stream data)
-        {
-            return data.ReadType<DevelopmentCardInfoHeader>();
-        }
-
        /// <summary>
        /// Parse a Stream into initial data
        /// </summary>
@@ -303,6 +252,16 @@ namespace SabreTools.Serialization.Deserializers
            return id;
        }

+        /// <summary>
+        /// Parse a Stream into a development card info header
+        /// </summary>
+        /// <param name="data">Stream to parse</param>
+        /// <returns>Filled development card info header on success, null on error</returns>
+        public static DevelopmentCardInfoHeader? ParseDevelopmentCardInfoHeader(Stream data)
+        {
+            return data.ReadType<DevelopmentCardInfoHeader>();
+        }
+
        /// <summary>
        /// Parse a Stream into an NCCH header
        /// </summary>
@@ -370,7 +329,51 @@ namespace SabreTools.Serialization.Deserializers
        /// <returns>Filled NCCH extended header on success, null on error</returns>
        public static NCCHExtendedHeader? ParseNCCHExtendedHeader(Stream data)
        {
-            return data.ReadType<NCCHExtendedHeader>();
+            // TODO: Replace with `data.ReadType<NCCHExtendedHeader>();` when enum serialization fixed
+            var header = new NCCHExtendedHeader();
+
+            header.SCI = data.ReadType<SystemControlInfo>();
+            header.ACI = ParseAccessControlInfo(data);
+            header.AccessDescSignature = data.ReadBytes(0x100);
+            header.NCCHHDRPublicKey = data.ReadBytes(0x100);
+            header.ACIForLimitations = ParseAccessControlInfo(data);
+
+            return header;
+        }
+
+        /// <summary>
+        /// Parse a Stream into an access control info
+        /// </summary>
+        /// <param name="data">Stream to parse</param>
+        /// <returns>Filled access control info on success, null on error</returns>
+        public static AccessControlInfo? ParseAccessControlInfo(Stream data)
+        {
+            var aci = new AccessControlInfo();
+
+            aci.ARM11LocalSystemCapabilities = data.ReadType<ARM11LocalSystemCapabilities>();
+            aci.ARM11KernelCapabilities = data.ReadType<ARM11KernelCapabilities>();
+            aci.ARM9AccessControl = ParseARM9AccessControl(data);
+
+            return aci;
+        }
+
+        /// <summary>
+        /// Parse a Stream into an ARM9 access control
+        /// </summary>
+        /// <param name="data">Stream to parse</param>
+        /// <returns>Filled ARM9 access control on success, null on error</returns>
+        public static ARM9AccessControl? ParseARM9AccessControl(Stream data)
+        {
+            var a9ac = new ARM9AccessControl();
+
+            a9ac.Descriptors = new ARM9AccessControlDescriptors[15];
+            for (int i = 0; i < a9ac.Descriptors.Length; i++)
+            {
+                a9ac.Descriptors[i] = (ARM9AccessControlDescriptors)data.ReadByteValue();
+            }
+            a9ac.DescriptorVersion = data.ReadByteValue();
+
+            return a9ac;
        }

        /// <summary>
--- a/SabreTools.Serialization/Printers/N3DS.cs
+++ b/SabreTools.Serialization/Printers/N3DS.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Text;
 using SabreTools.Models.N3DS;
 using SabreTools.Serialization.Interfaces;
@@ -44,26 +45,26 @@ namespace SabreTools.Serialization.Printers
            builder.AppendLine(header.PartitionsCryptType, "  Partitions crypt type");
            builder.AppendLine();

-            builder.AppendLine("  Partition table:");
-            builder.AppendLine("  -------------------------");
+            builder.AppendLine("    Partition table:");
+            builder.AppendLine("    -------------------------");
            if (header.PartitionsTable == null || header.PartitionsTable.Length == 0)
            {
-                builder.AppendLine("  No partition table entries");
+                builder.AppendLine("    No partition table entries");
            }
            else
            {
                for (int i = 0; i < header.PartitionsTable.Length; i++)
                {
                    var partitionTableEntry = header.PartitionsTable[i];
-                    builder.AppendLine($"  Partition table entry {i}");
+                    builder.AppendLine($"    Partition table entry {i}");
                    if (partitionTableEntry == null)
                    {
-                        builder.AppendLine("    [NULL]");
+                        builder.AppendLine("      [NULL]");
                        continue;
                    }

-                    builder.AppendLine(partitionTableEntry.Offset, "    Offset");
-                    builder.AppendLine(partitionTableEntry.Length, "    Length");
+                    builder.AppendLine(partitionTableEntry.Offset, "      Offset");
+                    builder.AppendLine(partitionTableEntry.Length, "      Length");
                }
            }
            builder.AppendLine();
@@ -77,17 +78,17 @@ namespace SabreTools.Serialization.Printers
                builder.AppendLine(header.PartitionFlags, "  Partition flags");
                builder.AppendLine();

-                builder.AppendLine("  Partition ID table:");
-                builder.AppendLine("  -------------------------");
+                builder.AppendLine("    Partition ID table:");
+                builder.AppendLine("    -------------------------");
                if (header.PartitionIdTable == null || header.PartitionIdTable.Length == 0)
                {
-                    builder.AppendLine("  No partition ID table entries");
+                    builder.AppendLine("    No partition ID table entries");
                }
                else
                {
                    for (int i = 0; i < header.PartitionIdTable.Length; i++)
                    {
-                        builder.AppendLine(header.PartitionIdTable[i], $"  Partition {i} ID");
+                        builder.AppendLine(header.PartitionIdTable[i], $"    Partition {i} ID");
                    }
                }
                builder.AppendLine();
@@ -146,62 +147,6 @@ namespace SabreTools.Serialization.Printers
                return;
            }

-            builder.AppendLine();
-            builder.AppendLine("  Initial Data:");
-            builder.AppendLine("  -------------------------");
-            if (header.InitialData == null)
-            {
-                builder.AppendLine("  No initial data");
-            }
-            else
-            {
-                builder.AppendLine(header.InitialData.CardSeedKeyY, "  Card seed keyY");
-                builder.AppendLine(header.InitialData.EncryptedCardSeed, "  Encrypted card seed");
-                builder.AppendLine(header.InitialData.CardSeedAESMAC, "  Card seed AES-MAC");
-                builder.AppendLine(header.InitialData.CardSeedNonce, "  Card seed nonce");
-                builder.AppendLine(header.InitialData.Reserved, "  Reserved");
-                builder.AppendLine();
-
-                builder.AppendLine("  Backup Header:");
-                builder.AppendLine("  -------------------------");
-                if (header.InitialData.BackupHeader == null)
-                {
-                    builder.AppendLine("  No backup header");
-                }
-                else
-                {
-                    builder.AppendLine(header.InitialData.BackupHeader.MagicID, "    Magic ID");
-                    builder.AppendLine(header.InitialData.BackupHeader.ContentSizeInMediaUnits, "    Content size in media units");
-                    builder.AppendLine(header.InitialData.BackupHeader.PartitionId, "    Partition ID");
-                    builder.AppendLine(header.InitialData.BackupHeader.MakerCode, "    Maker code");
-                    builder.AppendLine(header.InitialData.BackupHeader.Version, "    Version");
-                    builder.AppendLine(header.InitialData.BackupHeader.VerificationHash, "    Verification hash");
-                    builder.AppendLine(header.InitialData.BackupHeader.ProgramId, "    Program ID");
-                    builder.AppendLine(header.InitialData.BackupHeader.Reserved1, "    Reserved 1");
-                    builder.AppendLine(header.InitialData.BackupHeader.LogoRegionHash, "    Logo region SHA-256 hash");
-                    builder.AppendLine(header.InitialData.BackupHeader.ProductCode, "    Product code");
-                    builder.AppendLine(header.InitialData.BackupHeader.ExtendedHeaderHash, "    Extended header SHA-256 hash");
-                    builder.AppendLine(header.InitialData.BackupHeader.ExtendedHeaderSizeInBytes, "    Extended header size in bytes");
-                    builder.AppendLine(header.InitialData.BackupHeader.Reserved2, "    Reserved 2");
-                    builder.AppendLine($"    Flags: {header.InitialData.BackupHeader.Flags} (0x{header.InitialData.BackupHeader.Flags:X})");
-                    builder.AppendLine(header.InitialData.BackupHeader.PlainRegionOffsetInMediaUnits, "    Plain region offset, in media units");
-                    builder.AppendLine(header.InitialData.BackupHeader.PlainRegionSizeInMediaUnits, "    Plain region size, in media units");
-                    builder.AppendLine(header.InitialData.BackupHeader.LogoRegionOffsetInMediaUnits, "    Logo region offset, in media units");
-                    builder.AppendLine(header.InitialData.BackupHeader.LogoRegionSizeInMediaUnits, "    Logo region size, in media units");
-                    builder.AppendLine(header.InitialData.BackupHeader.ExeFSOffsetInMediaUnits, "    ExeFS offset, in media units");
-                    builder.AppendLine(header.InitialData.BackupHeader.ExeFSSizeInMediaUnits, "    ExeFS size, in media units");
-                    builder.AppendLine(header.InitialData.BackupHeader.ExeFSHashRegionSizeInMediaUnits, "    ExeFS hash region size, in media units");
-                    builder.AppendLine(header.InitialData.BackupHeader.Reserved3, "    Reserved 3");
-                    builder.AppendLine(header.InitialData.BackupHeader.RomFSOffsetInMediaUnits, "    RomFS offset, in media units");
-                    builder.AppendLine(header.InitialData.BackupHeader.RomFSSizeInMediaUnits, "    RomFS size, in media units");
-                    builder.AppendLine(header.InitialData.BackupHeader.RomFSHashRegionSizeInMediaUnits, "    RomFS hash region size, in media units");
-                    builder.AppendLine(header.InitialData.BackupHeader.Reserved4, "    Reserved 4");
-                    builder.AppendLine(header.InitialData.BackupHeader.ExeFSSuperblockHash, "    ExeFS superblock SHA-256 hash");
-                    builder.AppendLine(header.InitialData.BackupHeader.RomFSSuperblockHash, "    RomFS superblock SHA-256 hash");
-                }
-            }
-            builder.AppendLine();
-
            builder.AppendLine(header.CardDeviceReserved1, "  Card device reserved 1");
            builder.AppendLine(header.TitleKey, "  Title key");
            builder.AppendLine(header.CardDeviceReserved2, "  Card device reserved 2");
@@ -547,14 +492,20 @@ namespace SabreTools.Serialization.Printers
                    }
                    else
                    {
-                        builder.AppendLine($"        Descriptors: {entry.ACI.ARM9AccessControl.Descriptors} (0x{entry.ACI.ARM9AccessControl.Descriptors:X})");
+                        string descriptorsStr = "[NULL]";
+                        if (entry.ACI.ARM9AccessControl.Descriptors != null)
+                        {
+                            var descriptors = Array.ConvertAll(entry.ACI.ARM9AccessControl.Descriptors, d => d.ToString());
+                            descriptorsStr = string.Join(", ", descriptors);
+                        }
+                        builder.AppendLine(descriptorsStr, "        Descriptors");
                        builder.AppendLine(entry.ACI.ARM9AccessControl.DescriptorVersion, "        Descriptor version");
                    }
-
-                    builder.AppendLine(entry.AccessDescSignature, "    AccessDec signature (RSA-2048-SHA256)");
-                    builder.AppendLine(entry.NCCHHDRPublicKey, "    NCCH HDR RSA-2048 public key");
                }

+                builder.AppendLine(entry.AccessDescSignature, "    AccessDec signature (RSA-2048-SHA256)");
+                builder.AppendLine(entry.NCCHHDRPublicKey, "    NCCH HDR RSA-2048 public key");
+
                builder.AppendLine("    Access control info (for limitations of first ACI):");
                if (entry.ACIForLimitations == null)
                {
@@ -615,7 +566,13 @@ namespace SabreTools.Serialization.Printers
                    }
                    else
                    {
-                        builder.AppendLine($"        Descriptors: {entry.ACIForLimitations.ARM9AccessControl.Descriptors} (0x{entry.ACIForLimitations.ARM9AccessControl.Descriptors:X})");
+                        string descriptorsStr = "[NULL]";
+                        if (entry.ACIForLimitations.ARM9AccessControl.Descriptors != null)
+                        {
+                            var descriptors = Array.ConvertAll(entry.ACIForLimitations.ARM9AccessControl.Descriptors, d => d.ToString());
+                            descriptorsStr = string.Join(", ", descriptors);
+                        }
+                        builder.AppendLine(descriptorsStr, "        Descriptors");
                        builder.AppendLine(entry.ACIForLimitations.ARM9AccessControl.DescriptorVersion, "        Descriptor version");
                    }
                }
--- a/SabreTools.Serialization/SabreTools.Serialization.csproj
+++ b/SabreTools.Serialization/SabreTools.Serialization.csproj
@@ -10,7 +10,7 @@
        <Nullable>enable</Nullable>
        <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
        <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-        <Version>1.7.0</Version>
+        <Version>1.7.3</Version>

        <!-- Package Properties -->
        <Authors>Matt Nadareski</Authors>
@@ -52,7 +52,7 @@
        <PackageReference Include="SabreTools.ASN1" Version="1.4.0" />
        <PackageReference Include="SabreTools.Hashing" Version="1.4.0" />
        <PackageReference Include="SabreTools.IO" Version="1.5.0" />
-        <PackageReference Include="SabreTools.Models" Version="1.5.0" />
+        <PackageReference Include="SabreTools.Models" Version="1.5.1" />
    </ItemGroup>

 </Project>
--- a/SabreTools.Serialization/Wrappers/N3DS.cs
+++ b/SabreTools.Serialization/Wrappers/N3DS.cs
@@ -1,10 +1,11 @@
 using System;
 using System.IO;
 using SabreTools.Models.N3DS;
+using static SabreTools.Models.N3DS.Constants;

 namespace SabreTools.Serialization.Wrappers
 {
-    public class N3DS : WrapperBase<Models.N3DS.Cart>
+    public class N3DS : WrapperBase<Cart>
    {
        #region Descriptive Properties

@@ -13,17 +14,209 @@ namespace SabreTools.Serialization.Wrappers

        #endregion

+        #region Extension Properties
+
+        /// <summary>
+        /// Backup header
+        /// </summary>
+        public NCCHHeader? BackupHeader => Model.CardInfoHeader?.InitialData?.BackupHeader;
+
+        /// <summary>
+        /// ExeFS headers
+        /// </summary>
+        public ExeFSHeader?[] ExeFSHeaders => Model.ExeFSHeaders ?? [];
+        
+        /// <summary>
+        /// Media unit size in bytes
+        /// </summary>
+        public uint MediaUnitSize
+        {
+            get
+            {
+                if (Model.Header?.PartitionFlags == null)
+                    return default;
+
+                return (uint)(0x200 * Math.Pow(2, Model.Header.PartitionFlags[(int)NCSDFlags.MediaUnitSize]));
+            }
+        }
+
+        /// <summary>
+        /// Partitions data table
+        /// </summary>
+        public NCCHHeader?[] Partitions => Model.Partitions ?? [];
+
+        /// <summary>
+        /// Partitions header table
+        /// </summary>
+        public PartitionTableEntry?[] PartitionsTable => Model.Header?.PartitionsTable ?? [];
+
+        #region Named Partition Entries
+
+        /// <summary>
+        /// Partition table entry for Executable Content (CXI)
+        /// </summary>
+        public PartitionTableEntry? ExecutableContentEntry
+        {
+            get
+            {
+                if (PartitionsTable == null || PartitionsTable.Length == 0)
+                    return null;
+
+                return PartitionsTable[0];
+            }
+        }
+
+        /// <summary>
+        /// Partition table entry for E-Manual (CFA)
+        /// </summary>
+        public PartitionTableEntry? EManualEntry
+        {
+            get
+            {
+                if (PartitionsTable == null || PartitionsTable.Length == 0)
+                    return null;
+
+                return PartitionsTable[1];
+            }
+        }
+
+        /// <summary>
+        /// Partition table entry for Download Play Child container (CFA)
+        /// </summary>
+        public PartitionTableEntry? DownloadPlayChildContainerEntry
+        {
+            get
+            {
+                if (PartitionsTable == null || PartitionsTable.Length == 0)
+                    return null;
+
+                return PartitionsTable[2];
+            }
+        }
+
+        /// <summary>
+        /// Partition table entry for New3DS Update Data (CFA)
+        /// </summary>
+        public PartitionTableEntry? New3DSUpdateDataEntry
+        {
+            get
+            {
+                if (PartitionsTable == null || PartitionsTable.Length == 0)
+                    return null;
+
+                return PartitionsTable[6];
+            }
+        }
+
+        /// <summary>
+        /// Partition table entry for Update Data (CFA)
+        /// </summary>
+        public PartitionTableEntry? UpdateDataEntry
+        {
+            get
+            {
+                if (PartitionsTable == null || PartitionsTable.Length == 0)
+                    return null;
+
+                return PartitionsTable[7];
+            }
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Partitions flags
+        /// </summary>
+        public byte[] PartitionFlags => Model.Header?.PartitionFlags ?? [];
+
+        #region Partition Flags
+
+        /// <summary>
+        /// Backup Write Wait Time (The time to wait to write save to backup after the card is recognized (0-255
+        /// seconds)). NATIVE_FIRM loads this flag from the gamecard NCSD header starting with 6.0.0-11.
+        /// </summary>
+        public byte BackupWriteWaitTime
+        {
+            get
+            {
+                if (PartitionFlags == null || PartitionFlags.Length == 0)
+                    return default;
+
+                return PartitionFlags[(int)NCSDFlags.BackupWriteWaitTime];
+            }
+        }
+
+        /// <summary>
+        /// Media Card Device (1 = NOR Flash, 2 = None, 3 = BT) (Only SDK 2.X)
+        /// </summary>
+        public MediaCardDeviceType MediaCardDevice2X
+        {
+            get
+            {
+                if (PartitionFlags == null || PartitionFlags.Length == 0)
+                    return default;
+
+                return (MediaCardDeviceType)PartitionFlags[(int)NCSDFlags.MediaCardDevice2X];
+            }
+        }
+
+        /// <summary>
+        /// Media Card Device (1 = NOR Flash, 2 = None, 3 = BT) (SDK 3.X+)
+        /// </summary>
+        public MediaCardDeviceType MediaCardDevice3X
+        {
+            get
+            {
+                if (PartitionFlags == null || PartitionFlags.Length == 0)
+                    return default;
+
+                return (MediaCardDeviceType)PartitionFlags[(int)NCSDFlags.MediaCardDevice3X];
+            }
+        }
+
+        /// <summary>
+        /// Media Platform Index (1 = CTR)
+        /// </summary>
+        public MediaPlatformIndex MediaPlatformIndex
+        {
+            get
+            {
+                if (PartitionFlags == null || PartitionFlags.Length == 0)
+                    return default;
+
+                return (MediaPlatformIndex)PartitionFlags[(int)NCSDFlags.MediaPlatformIndex];
+            }
+        }
+
+        /// <summary>
+        /// Media Type Index (0 = Inner Device, 1 = Card1, 2 = Card2, 3 = Extended Device)
+        /// </summary>
+        public MediaTypeIndex MediaTypeIndex
+        {
+            get
+            {
+                if (PartitionFlags == null || PartitionFlags.Length == 0)
+                    return default;
+
+                return (MediaTypeIndex)PartitionFlags[(int)NCSDFlags.MediaTypeIndex];
+            }
+        }
+
+        #endregion
+
+        #endregion
+
        #region Constructors

        /// <inheritdoc/>
-        public N3DS(Models.N3DS.Cart? model, byte[]? data, int offset)
+        public N3DS(Cart? model, byte[]? data, int offset)
            : base(model, data, offset)
        {
            // All logic is handled by the base class
        }

        /// <inheritdoc/>
-        public N3DS(Models.N3DS.Cart? model, Stream? data)
+        public N3DS(Cart? model, Stream? data)
            : base(model, data)
        {
            // All logic is handled by the base class
@@ -77,177 +270,297 @@ namespace SabreTools.Serialization.Wrappers

        #endregion

-        // TODO: Hook these up for external use
-        #region Currently Unused Extensions
+        #region Data

-        #region ExeFSFileHeader
+        /// <summary>
+        /// Get the bit masks for a partition
+        /// </summary>
+        public BitMasks GetBitMasks(int index)
+        {
+            if (Partitions == null)
+                return 0;
+            if (index < 0 || index >= Partitions.Length)
+                return 0;
+
+            var partition = Partitions[index];
+            if (partition?.Flags == null)
+                return 0;
+
+            return partition.Flags.BitMasks;
+        }
+
+        /// <summary>
+        /// Get the crypto method for a partition
+        /// </summary>
+        public CryptoMethod GetCryptoMethod(int index)
+        {
+            if (Partitions == null)
+                return 0;
+            if (index < 0 || index >= Partitions.Length)
+                return 0;
+
+            var partition = Partitions[index];
+            if (partition?.Flags == null)
+                return 0;
+
+            return partition.Flags.CryptoMethod;
+        }

        /// <summary>
        /// Determines if a file header represents a CODE block
        /// </summary>
-        public static bool IsCodeBinary(ExeFSFileHeader? header)
+        public bool IsCodeBinary(int fsIndex, int headerIndex)
        {
-            if (header == null)
+            if (ExeFSHeaders == null)
+                return false;
+            if (fsIndex < 0 || fsIndex >= ExeFSHeaders.Length)
                return false;

-            return header.FileName == ".code\0\0\0";
+            var fsHeader = ExeFSHeaders[fsIndex];
+            if (fsHeader?.FileHeaders == null)
+                return false;
+
+            if (headerIndex < 0 || headerIndex >= fsHeader.FileHeaders.Length)
+                return false;
+
+            var fileHeader = fsHeader.FileHeaders[headerIndex];
+            if (fileHeader == null)
+                return false;
+
+            return fileHeader.FileName == ".code\0\0\0";
        }

-        #endregion
+        /// <summary>
+        /// Get the initial value for the plain counter
+        /// </summary>
+        public byte[] PlainIV(int index)
+        {
+            if (Partitions == null)
+                return [];
+            if (index < 0 || index >= Partitions.Length)
+                return [];

-        #region NCCHHeaderFlags
+            var header = Partitions[index];
+            if (header == null || header.MagicID != NCCHMagicNumber)
+                return [];
+
+            byte[] partitionIdBytes = BitConverter.GetBytes(header.PartitionId);
+            Array.Reverse(partitionIdBytes);
+            return [.. partitionIdBytes, .. PlainCounter];
+        }
+
+        /// <summary>
+        /// Get the initial value for the ExeFS counter
+        /// </summary>
+        public byte[] ExeFSIV(int index)
+        {
+            if (Partitions == null)
+                return [];
+            if (index < 0 || index >= Partitions.Length)
+                return [];
+
+            var header = Partitions[index];
+            if (header == null || header.MagicID != NCCHMagicNumber)
+                return [];
+
+            byte[] partitionIdBytes = BitConverter.GetBytes(header.PartitionId);
+            Array.Reverse(partitionIdBytes);
+            return [.. partitionIdBytes, .. ExefsCounter];
+        }
+
+        /// <summary>
+        /// Get the initial value for the RomFS counter
+        /// </summary>
+        public byte[] RomFSIV(int index)
+        {
+            if (Partitions == null)
+                return [];
+            if (index < 0 || index >= Partitions.Length)
+                return [];
+
+            var header = Partitions[index];
+            if (header == null || header.MagicID != NCCHMagicNumber)
+                return [];
+
+            byte[] partitionIdBytes = BitConverter.GetBytes(header.PartitionId);
+            Array.Reverse(partitionIdBytes);
+            return [.. partitionIdBytes, .. RomfsCounter];
+        }

        /// <summary>
        /// Get if the NoCrypto bit is set
        /// </summary>
-        public static bool PossiblyDecrypted(NCCHHeaderFlags flags)
+        public bool PossiblyDecrypted(int index)
        {
-            if (flags == null)
-                return false;
-
+            var bitMasks = GetBitMasks(index);
 #if NET20 || NET35
-            return (flags.BitMasks & BitMasks.NoCrypto) != 0;
+            return (bitMasks & BitMasks.NoCrypto) != 0;
 #else
-            return flags.BitMasks.HasFlag(BitMasks.NoCrypto);
+            return bitMasks.HasFlag(BitMasks.NoCrypto);
 #endif
        }

        #endregion

-        #region NCSDHeader
+        #region Offsets

        /// <summary>
-        /// Partition table entry for Executable Content (CXI)
+        /// Get the offset of a partition ExeFS
        /// </summary>
-        public static PartitionTableEntry? ExecutableContent(NCSDHeader? header)
+        /// <returns>Offset to the ExeFS of the partition, 0 on error</returns>
+        public uint GetExeFSOffset(int index)
        {
-            if (header?.PartitionsTable == null)
-                return null;
+            // No partitions means no size is available
+            if (PartitionsTable == null || Partitions == null)
+                return 0;
+            if (index < 0 || index >= Partitions.Length)
+                return 0;

-            return header.PartitionsTable[0];
+            // Invalid partition table entry means no size is available
+            var entry = PartitionsTable[index];
+            if (entry == null)
+                return 0;
+
+            // Invalid partition means no size is available
+            var header = Partitions[index];
+            if (header == null || header.MagicID != NCCHMagicNumber)
+                return 0;
+
+            // If the offset is 0, return 0
+            uint exeFsOffsetMU = header.ExeFSOffsetInMediaUnits;
+            if (exeFsOffsetMU == 0)
+                return 0;
+
+            // Return the adjusted offset
+            uint partitionOffsetMU = entry.Offset;
+            return (partitionOffsetMU + exeFsOffsetMU) * MediaUnitSize;
        }

        /// <summary>
-        /// Partition table entry for E-Manual (CFA)
+        /// Get the offset of a partition
        /// </summary>
-        public static PartitionTableEntry? EManual(NCSDHeader? header)
+        /// <returns>Offset to the partition, 0 on error</returns>
+        public uint GetPartitionOffset(int index)
        {
-            if (header?.PartitionsTable == null)
-                return null;
+            // No partitions means no size is available
+            if (PartitionsTable == null)
+                return 0;
+            if (index < 0 || index >= PartitionsTable.Length)
+                return 0;

-            return header.PartitionsTable[1];
+            // Invalid partition table entry means no size is available
+            var entry = PartitionsTable[index];
+            if (entry == null)
+                return 0;
+
+            // Return the adjusted offset
+            uint partitionOffsetMU = entry.Offset;
+            if (entry.Offset == 0)
+                return 0;
+
+            // Return the adjusted offset
+            return partitionOffsetMU * MediaUnitSize;
        }

        /// <summary>
-        /// Partition table entry for Download Play Child container (CFA)
+        /// Get the offset of a partition RomFS
        /// </summary>
-        public static PartitionTableEntry? DownloadPlayChildContainer(NCSDHeader? header)
+        /// <returns>Offset to the RomFS of the partition, 0 on error</returns>
+        public uint GetRomFSOffset(int index)
        {
-            if (header?.PartitionsTable == null)
-                return null;
+            // No partitions means no size is available
+            if (PartitionsTable == null || Partitions == null)
+                return 0;
+            if (index < 0 || index >= Partitions.Length)
+                return 0;

-            return header.PartitionsTable[2];
-        }
+            // Invalid partition table entry means no size is available
+            var entry = PartitionsTable[index];
+            if (entry == null)
+                return 0;

-        /// <summary>
-        /// Partition table entry for New3DS Update Data (CFA)
-        /// </summary>
-        public static PartitionTableEntry? New3DSUpdateData(NCSDHeader? header)
-        {
-            if (header?.PartitionsTable == null)
-                return null;
+            // Invalid partition means no size is available
+            var header = Partitions[index];
+            if (header == null || header.MagicID != NCCHMagicNumber)
+                return 0;

-            return header.PartitionsTable[6];
-        }
+            // If the offset is 0, return 0
+            uint romFsOffsetMU = header.RomFSOffsetInMediaUnits;
+            if (romFsOffsetMU == 0)
+                return 0;

-        /// <summary>
-        /// Partition table entry for Update Data (CFA)
-        /// </summary>
-        public static PartitionTableEntry? UpdateData(NCSDHeader? header)
-        {
-            if (header?.PartitionsTable == null)
-                return null;
-
-            return header.PartitionsTable[7];
-        }
-
-        /// <summary>
-        /// Backup Write Wait Time (The time to wait to write save to backup after the card is recognized (0-255
-        /// seconds)).NATIVE_FIRM loads this flag from the gamecard NCSD header starting with 6.0.0-11.
-        /// </summary>
-        public static byte BackupWriteWaitTime(NCSDHeader? header)
-        {
-            if (header?.PartitionFlags == null)
-                return default;
-
-            return header.PartitionFlags[(int)NCSDFlags.BackupWriteWaitTime];
-        }
-
-        /// <summary>
-        /// Media Card Device (1 = NOR Flash, 2 = None, 3 = BT) (SDK 3.X+)
-        /// </summary>
-        public static MediaCardDeviceType MediaCardDevice3X(NCSDHeader? header)
-        {
-            if (header?.PartitionFlags == null)
-                return default;
-
-            return (MediaCardDeviceType)header.PartitionFlags[(int)NCSDFlags.MediaCardDevice3X];
-        }
-
-        /// <summary>
-        /// Media Platform Index (1 = CTR)
-        /// </summary>
-        public static MediaPlatformIndex MediaPlatformIndex(NCSDHeader? header)
-        {
-            if (header?.PartitionFlags == null)
-                return default;
-
-            return (MediaPlatformIndex)header.PartitionFlags[(int)NCSDFlags.MediaPlatformIndex];
-        }
-
-        /// <summary>
-        /// Media Type Index (0 = Inner Device, 1 = Card1, 2 = Card2, 3 = Extended Device)
-        /// </summary>
-        public static MediaTypeIndex MediaTypeIndex(NCSDHeader? header)
-        {
-            if (header?.PartitionFlags == null)
-                return default;
-
-            return (MediaTypeIndex)header.PartitionFlags[(int)NCSDFlags.MediaTypeIndex];
-        }
-
-        /// <summary>
-        /// Media Unit Size i.e. u32 MediaUnitSize = 0x200*2^flags[6];
-        /// </summary>
-        public static uint MediaUnitSize(Cart cart)
-        {
-            return MediaUnitSize(cart.Header);
-        }
-
-        /// <summary>
-        /// Media Unit Size i.e. u32 MediaUnitSize = 0x200*2^flags[6];
-        /// </summary>
-        public static uint MediaUnitSize(NCSDHeader? header)
-        {
-            if (header?.PartitionFlags == null)
-                return default;
-
-            return (uint)(0x200 * Math.Pow(2, header.PartitionFlags[(int)NCSDFlags.MediaUnitSize]));
-        }
-
-        /// <summary>
-        /// Media Card Device (1 = NOR Flash, 2 = None, 3 = BT) (Only SDK 2.X)
-        /// </summary>
-        public static MediaCardDeviceType MediaCardDevice2X(NCSDHeader? header)
-        {
-            if (header?.PartitionFlags == null)
-                return default;
-
-            return (MediaCardDeviceType)header.PartitionFlags[(int)NCSDFlags.MediaCardDevice2X];
+            // Return the adjusted offset
+            uint partitionOffsetMU = entry.Offset;
+            return (partitionOffsetMU + romFsOffsetMU) * MediaUnitSize;
        }

        #endregion

+        #region Sizes
+
+        /// <summary>
+        /// Get the size of a partition ExeFS
+        /// </summary>
+        /// <returns>Size of the partition ExeFS in bytes, 0 on error</returns>
+        public uint GetExeFSSize(int index)
+        {
+            // Empty partitions array means no size is available
+            if (Partitions == null)
+                return 0;
+            if (index < 0 || index >= Partitions.Length)
+                return 0;
+
+            // Invalid partition header means no size is available
+            var header = Partitions[index];
+            if (header == null)
+                return 0;
+
+            // Return the adjusted size
+            return header.ExeFSSizeInMediaUnits * MediaUnitSize;
+        }
+
+        /// <summary>
+        /// Get the size of a partition extended header
+        /// </summary>
+        /// <returns>Size of the partition extended header in bytes, 0 on error</returns>
+        public uint GetExtendedHeaderSize(int index)
+        {
+            // Empty partitions array means no size is available
+            if (Partitions == null)
+                return 0;
+            if (index < 0 || index >= Partitions.Length)
+                return 0;
+
+            // Invalid partition header means no size is available
+            var header = Partitions[index];
+            if (header == null)
+                return 0;
+
+            // Return the adjusted size
+            return header.ExtendedHeaderSizeInBytes;
+        }
+
+        /// <summary>
+        /// Get the size of a partition RomFS
+        /// </summary>
+        /// <returns>Size of the partition RomFS in bytes, 0 on error</returns>
+        public uint GetRomFSSize(int index)
+        {
+            // Empty partitions array means no size is available
+            if (Partitions == null)
+                return 0;
+            if (index < 0 || index >= Partitions.Length)
+                return 0;
+
+            // Invalid partition header means no size is available
+            var header = Partitions[index];
+            if (header == null)
+                return 0;
+
+            // Return the adjusted size
+            return header.RomFSSizeInMediaUnits * MediaUnitSize;
+        }
+
        #endregion
    }
 }
Author	SHA1	Message	Date
Matt Nadareski	1fcf44fb8d	Bump version	2024-11-14 11:32:17 -05:00
Matt Nadareski	a2a472baf9	Fix top level printing issue	2024-11-14 11:24:08 -05:00
Matt Nadareski	b5b4a50d94	Fix deserialization of NCCH extended header The actual fix to this is somewhere in the conversion code where an array of Enum values somehow just... fails? I'm not totally sure how that's happening but this is the easiest way around it until that auto stuff can be fixed.	2024-11-14 11:20:46 -05:00
Matt Nadareski	f1b5464052	Extend N3DS wrapper further	2024-11-14 03:17:11 -05:00
Matt Nadareski	2c0224db22	Fix byte order for N3DS IV	2024-11-14 00:12:35 -05:00
Matt Nadareski	1e78eecb40	Bump version	2024-11-13 23:13:55 -05:00
Matt Nadareski	3626faea60	Fix building N3DS cart image	2024-11-13 23:05:26 -05:00
Matt Nadareski	a0177f1174	Add bitmasks helper method	2024-11-13 21:29:43 -05:00
Matt Nadareski	db5fe4a2cd	Add extension property for backup header	2024-11-13 21:25:46 -05:00
Matt Nadareski	5716143168	Bump version	2024-11-13 20:48:55 -05:00
Matt Nadareski	2a59b23149	Add more extensions to N3DS wrapper	2024-11-13 20:47:25 -05:00
Matt Nadareski	bdbec4ed02	Update Models to 1.5.1	2024-11-13 20:41:13 -05:00
Matt Nadareski	25193f1805	Start making fixes to N3DS	2024-11-13 20:21:32 -05:00