nitro-patcher 0.2.0 → 0.3.0

package/src/nitro/nds-file.ts

@@ -1,13 +1,14 @@
 // Native TypeScript port of NitroHelper/NDSFile.cs, GPL-3.0.
-import { readFile, writeFile } from '#nitro-runtime';
-import { BinaryWriter, bytes, range, DEFAULT_MAX_SIZE } from './binary';
-import { Header } from './header';
-import { Banner } from './banner';
-import { FileAllocationTable, FileNameTable, OverlayTable } from './filesystem';
-import type { NitroFile, NitroFolder } from './filesystem';
-import { crc16 } from './crc';
-import { encryptSecureArea } from './crypto';
-import { TWL } from './twl';
+import { readFile, writeFile } from "#nitro-runtime";
+
+import { Banner } from "./banner";
+import { BinaryWriter, DEFAULT_MAX_SIZE, bytes, range } from "./binary";
+import { crc16 } from "./crc";
+import { encryptSecureArea } from "./crypto";
+import { FileAllocationTable, FileNameTable, OverlayTable } from "./filesystem";
+import type { NitroFile, NitroFolder } from "./filesystem";
+import { Header } from "./header";
+import { TWL } from "./twl";
 
 export interface RomOptions {
   /** Maximum generated ROM size in bytes. Defaults to 1 GiB. */
@@ -22,7 +23,7 @@ export interface RomFileInfo {
   size: number;
 }
 
-const key = (path: string): string => path.replaceAll('\\', '/').toLowerCase();
+const key = (path: string): string => path.replaceAll("\\", "/").toLowerCase();
 
 /** Parsed Nintendo DS ROM. Replacements do not change the input buffer. */
 export class NDSFile {
@@ -40,31 +41,21 @@ export class NDSFile {
   private readonly maxOutputSize: number;
 
   constructor(input: Uint8Array, options: RomOptions = {}) {
-    this.original = bytes(input, 'ROM');
+    this.original = bytes(input, "ROM");
     this.maxOutputSize = options.maxOutputSize ?? DEFAULT_MAX_SIZE;
     this.header = new Header(this.original);
     const h = this.header;
-    range(this.original, h.ARM9romOffset, h.ARM9size + (h.nitrocode ? 12 : 0), 'ARM9');
-    range(this.original, h.ARM7romOffset, h.ARM7size, 'ARM7');
+    range(this.original, h.ARM9romOffset, h.ARM9size + (h.nitrocode ? 12 : 0), "ARM9");
+    range(this.original, h.ARM7romOffset, h.ARM7size, "ARM7");
     this.banner = new Banner(this.original, h.bannerOffset, h.banner_size);
     this.fatTable = new FileAllocationTable(this.original, h.FAToffset, h.FATsize);
     this.fntTable = new FileNameTable(this.fatTable, this.original, h.FNToffset, h.FNTsize);
     this.root = this.fntTable.root;
-    this.overlay9Table = new OverlayTable(
-      this.original,
-      h.ARM9overlayOffset,
-      h.ARM9overlaySize,
-      true,
-    );
-    this.overlay7Table = new OverlayTable(
-      this.original,
-      h.ARM7overlayOffset,
-      h.ARM7overlaySize,
-      false,
-    );
+    this.overlay9Table = new OverlayTable(this.original, h.ARM9overlayOffset, h.ARM9overlaySize, true);
+    this.overlay7Table = new OverlayTable(this.original, h.ARM7overlayOffset, h.ARM7overlaySize, false);
     const arm9Overlays = this.overlay9Table.readBasicOverlays(this.fatTable);
     this.root.folders.push({
-      name: 'overlay',
+      name: "overlay",
       id: 0xffff,
       files: [...arm9Overlays, ...this.overlay7Table.readBasicOverlays(this.fatTable)],
       folders: [],
@@ -73,23 +64,23 @@ export class NDSFile {
       range(this.original, offset, size, name);
       this.root.files.push({ name, id: 0xffff, offset, size });
     };
-    system('header.bin', 0, h.headerSize);
-    system('banner.bin', h.bannerOffset, this.banner.raw.length);
-    system('fnt.bin', h.FNToffset, h.FNTsize);
-    system('fat.bin', h.FAToffset, h.FATsize);
-    system('arm9.bin', h.ARM9romOffset, h.ARM9size + (h.nitrocode ? 12 : 0));
-    system('arm7.bin', h.ARM7romOffset, h.ARM7size);
-    if (h.ARM9overlaySize) system('overarm9.bin', h.ARM9overlayOffset, h.ARM9overlaySize);
-    if (h.ARM7overlaySize) system('overarm7.bin', h.ARM7overlayOffset, h.ARM7overlaySize);
+    system("header.bin", 0, h.headerSize);
+    system("banner.bin", h.bannerOffset, this.banner.raw.length);
+    system("fnt.bin", h.FNToffset, h.FNTsize);
+    system("fat.bin", h.FAToffset, h.FATsize);
+    system("arm9.bin", h.ARM9romOffset, h.ARM9size + (h.nitrocode ? 12 : 0));
+    system("arm7.bin", h.ARM7romOffset, h.ARM7size);
+    if (h.ARM9overlaySize) system("overarm9.bin", h.ARM9overlayOffset, h.ARM9overlaySize);
+    if (h.ARM7overlaySize) system("overarm7.bin", h.ARM7overlayOffset, h.ARM7overlaySize);
     const visit = (folder: NitroFolder, prefix: string): void => {
       for (const file of folder.files) {
         const path = prefix + file.name;
         if (this.paths.has(key(path))) throw new Error(`Duplicate ROM path: ${path}`);
         this.paths.set(key(path), { path, file });
       }
-      for (const child of folder.folders) visit(child, prefix + child.name + '/');
+      for (const child of folder.folders) visit(child, `${prefix + child.name}/`);
     };
-    visit(this.root, '');
+    visit(this.root, "");
     if (h.unitCode & 2 && h.twlInternalFlags & 1 && h.tid_high && h.tid_high !== 0xffffffff) {
       // Upstream silently discarded malformed TWL regions. Preserve valid DSi data,
       // and reject malformed data instead of emitting a ROM with missing sections.
@@ -135,20 +126,13 @@ export class NDSFile {
 
   /** Rebuild offsets, allocation table, CRCs and ROM padding. Safe to call repeatedly. */
   toBuffer(): Buffer {
-    const fntReplacement = this.root.files.find((file) => file.name === 'fnt.bin')?.replacement;
+    const fntReplacement = this.root.files.find((file) => file.name === "fnt.bin")?.replacement;
     if (fntReplacement) {
-      const replacementTree = new FileNameTable(
-        this.fatTable,
-        fntReplacement,
-        0,
-        fntReplacement.length,
-      );
+      const replacementTree = new FileNameTable(this.fatTable, fntReplacement, 0, fntReplacement.length);
       const collect = (folder: NitroFolder): number[] =>
-        [...folder.files.map((file) => file.id), ...folder.folders.flatMap(collect)].sort(
-          (a, b) => a - b,
-        );
-      if (collect(replacementTree.root).join(',') !== collect(this.data).join(','))
-        throw new Error('Replacement FNT must preserve existing file IDs');
+        [...folder.files.map((file) => file.id), ...folder.folders.flatMap(collect)].sort((a, b) => a - b);
+      if (collect(replacementTree.root).join(",") !== collect(this.data).join(","))
+        throw new Error("Replacement FNT must preserve existing file IDs");
     }
     const h = new Header(this.header.toBuffer());
     h.nitrocode = this.header.nitrocode;
@@ -161,7 +145,7 @@ export class NDSFile {
       if (!file) throw new Error(`Missing ROM system file: ${name}`);
       return file;
     };
-    const replacedHeader = system('header.bin').replacement;
+    const replacedHeader = system("header.bin").replacement;
     if (replacedHeader) {
       const replacement = new Header(replacedHeader);
       h.gameTitle = replacement.gameTitle;
@@ -177,13 +161,13 @@ export class NDSFile {
     const overlayIds = new Set<number>();
     const writeOverlays = (arm9: boolean): void => {
       const originalTable = arm9 ? this.overlay9Table : this.overlay7Table;
-      const name = arm9 ? 'overarm9.bin' : 'overarm7.bin';
+      const name = arm9 ? "overarm9.bin" : "overarm7.bin";
       const entry = this.root.files.find((file) => file.name === name);
       if (!entry) return;
       const raw = entry.replacement ?? originalTable.toBuffer();
       const table = new OverlayTable(raw, 0, raw.length, arm9);
       const files = this.overlay.files
-        .filter((file) => file.name.startsWith(arm9 ? 'overlay_' : 'overlay7_'))
+        .filter((file) => file.name.startsWith(arm9 ? "overlay_" : "overlay7_"))
         .sort((a, b) => a.id - b.id);
       for (const file of files) {
         const item = table.entries.find((item) => item.fileId === file.id);
@@ -193,8 +177,7 @@ export class NDSFile {
           item.reserved = ((item.reserved & 0xff000000) | (size & 0xffffff)) >>> 0;
         overlayIds.add(file.id);
       }
-      if (table.entries.length !== files.length)
-        throw new Error('Changing overlay file count is unsupported');
+      if (table.entries.length !== files.length) throw new Error("Changing overlay file count is unsupported");
       const encoded = table.toBuffer();
       if (arm9) {
         h.ARM9overlayOffset = writer.position;
@@ -209,30 +192,29 @@ export class NDSFile {
     };
     writer.position = h.headerSize;
     h.ARM9romOffset = writer.position;
-    const arm9 = system('arm9.bin');
+    const arm9 = system("arm9.bin");
     const arm9Bytes = this.fileBytes(arm9);
     if (arm9.replacement) {
-      h.nitrocode =
-        arm9Bytes.length >= 12 && arm9Bytes.readUInt32LE(arm9Bytes.length - 12) === 0xdec00621;
+      h.nitrocode = arm9Bytes.length >= 12 && arm9Bytes.readUInt32LE(arm9Bytes.length - 12) === 0xdec00621;
     }
     h.ARM9size = arm9Bytes.length - (h.nitrocode ? 12 : 0);
     write(arm9);
     h.ARM9overlayOffset = 0;
     writeOverlays(true);
     h.ARM7romOffset = writer.position;
-    h.ARM7size = this.fileBytes(system('arm7.bin')).length;
-    write(system('arm7.bin'));
+    h.ARM7size = this.fileBytes(system("arm7.bin")).length;
+    write(system("arm7.bin"));
     h.ARM7overlayOffset = 0;
     writeOverlays(false);
     h.FNToffset = writer.position;
-    h.FNTsize = this.fileBytes(system('fnt.bin')).length;
-    write(system('fnt.bin'));
+    h.FNTsize = this.fileBytes(system("fnt.bin")).length;
+    write(system("fnt.bin"));
     h.FAToffset = writer.position;
     h.FATsize = this.fatTable.entries.length * 8;
     writer.write(Buffer.alloc(h.FATsize));
     writer.pad(0x200);
     h.bannerOffset = writer.position;
-    const bannerFile = system('banner.bin');
+    const bannerFile = system("banner.bin");
     const banner = bannerFile.replacement
       ? new Banner(bannerFile.replacement, 0, bannerFile.replacement.length)
       : this.banner;
@@ -265,8 +247,7 @@ export class NDSFile {
     writer.position = logicalEnd;
     // An ARM9 replacement can add or remove the decrypted secure-area marker.
     // Both TWL hashing and the header CRC must use the bytes being serialized.
-    h.decrypted =
-      writer.length >= 0x4008 && writer.buffer.readBigUInt64LE(0x4000) === 0xe7ffdeffe7ffdeffn;
+    h.decrypted = writer.length >= 0x4008 && writer.buffer.readBigUInt64LE(0x4000) === 0xe7ffdeffe7ffdeffn;
     if (this.twl) this.twl.writeTo(writer, h);
     h.ROMsize = writer.position;
     h.size = 2 ** Math.ceil(Math.log2(Math.max(h.ROMsize + h.dlp_signature.length, 0x20000)));

package/src/nitro/twl.ts

@@ -1,9 +1,10 @@
-import { hashDigest, hmacSha1, verifyRsaSha1, readFileSync } from '#nitro-runtime';
-import type { BinaryWriter } from './binary';
-import type { ModcryptHeader } from './crypto';
-import type { Arm9Header } from './blz';
-import { aes128CtrCrypt, encryptSecureArea, modcryptKey } from './crypto';
-import { compressArm9, decompressArm9 } from './blz';
+import { hashDigest, hmacSha1, readFileSync, verifyRsaSha1 } from "#nitro-runtime";
+
+import type { BinaryWriter } from "./binary";
+import type { Arm9Header } from "./blz";
+import { compressArm9, decompressArm9 } from "./blz";
+import type { ModcryptHeader } from "./crypto";
+import { aes128CtrCrypt, encryptSecureArea, modcryptKey } from "./crypto";
 
 export interface TwlHeader extends ModcryptHeader {
   digest_sector_size: number;
@@ -43,8 +44,8 @@ export interface OverlayRange {
 }
 
 export const HMAC_SHA1_KEY = Buffer.from(
-  '2106c0deba98ce3fa692e39d46f2ed0176e3cc08562363facad4ecdf9a6278348f6d633cfe22ca9220889723d2cfaec232678dfeca836498acfd3e3787465824',
-  'hex',
+  "2106c0deba98ce3fa692e39d46f2ed0176e3cc08562363facad4ecdf9a6278348f6d633cfe22ca9220889723d2cfaec232678dfeca836498acfd3e3787465824",
+  "hex",
 );
 const hash = (data: Buffer): Buffer => hmacSha1(HMAC_SHA1_KEY, data);
 function slice(data: Buffer, start: number, size: number, label: string): Buffer {
@@ -60,46 +61,44 @@ function slice(data: Buffer, start: number, size: number, label: string): Buffer
 }
 function validate(h: TwlHeader): void {
   for (const field of [
-    'digest_ntr_start',
-    'digest_ntr_size',
-    'digest_twl_start',
-    'digest_twl_size',
-    'sector_hashtable_start',
-    'sector_hashtable_size',
-    'block_hashtable_start',
-    'block_hashtable_size',
-    'dsi9_rom_offset',
-    'dsi9_size',
-    'dsi7_rom_offset',
-    'dsi7_size',
-    'modcrypt1_start',
-    'modcrypt1_size',
-    'modcrypt2_start',
-    'modcrypt2_size',
-    'total_rom_size',
+    "digest_ntr_start",
+    "digest_ntr_size",
+    "digest_twl_start",
+    "digest_twl_size",
+    "sector_hashtable_start",
+    "sector_hashtable_size",
+    "block_hashtable_start",
+    "block_hashtable_size",
+    "dsi9_rom_offset",
+    "dsi9_size",
+    "dsi7_rom_offset",
+    "dsi7_size",
+    "modcrypt1_start",
+    "modcrypt1_size",
+    "modcrypt2_start",
+    "modcrypt2_size",
+    "total_rom_size",
   ] as const) {
     if (!Number.isSafeInteger(h[field]) || h[field] < 0 || h[field] > 0xffffffff) {
       throw new Error(`Invalid TWL ${field}`);
     }
   }
   const s = h.digest_sector_size;
-  if (!Number.isSafeInteger(s) || s <= 0 || s > 0x4000 || 0x4000 % s)
-    throw new Error('Invalid TWL digest sector size');
+  if (!Number.isSafeInteger(s) || s <= 0 || s > 0x4000 || 0x4000 % s) throw new Error("Invalid TWL digest sector size");
   if (
     !Number.isSafeInteger(h.digest_block_sectorcount) ||
     h.digest_block_sectorcount <= 0 ||
     h.digest_block_sectorcount > 0x100000
   )
-    throw new Error('Invalid TWL digest block sector count');
+    throw new Error("Invalid TWL digest block sector count");
   if (h.digest_ntr_size < 0x4000 || h.digest_ntr_size % s || h.digest_twl_size % s)
-    throw new Error('Invalid TWL digest region size');
+    throw new Error("Invalid TWL digest region size");
   const hashes = (h.digest_ntr_size + h.digest_twl_size) / s;
   if (
     hashes * 20 > h.sector_hashtable_size ||
-    Math.ceil(h.sector_hashtable_size / (h.digest_block_sectorcount * 20)) * 20 >
-      h.block_hashtable_size
+    Math.ceil(h.sector_hashtable_size / (h.digest_block_sectorcount * 20)) * 20 > h.block_hashtable_size
   )
-    throw new Error('TWL hash tables are too small');
+    throw new Error("TWL hash tables are too small");
 }
 export class TWL {
   readonly firstDSiHashOffset: number;
@@ -117,51 +116,31 @@ export class TWL {
     this.firstDSiHashOffset = (h.digest_ntr_size / h.digest_sector_size) * 20;
     this.dsiHashSize = (h.digest_twl_size / h.digest_sector_size) * 20;
     this.Hashtable1Data = Buffer.from(
-      slice(original, h.sector_hashtable_start, h.sector_hashtable_size, 'Sector hash table'),
+      slice(original, h.sector_hashtable_start, h.sector_hashtable_size, "Sector hash table"),
     );
     this.Hashtable2Data = Buffer.from(
-      slice(original, h.block_hashtable_start, h.block_hashtable_size, 'Block hash table'),
-    );
-    this.DSi9Data = Buffer.from(
-      slice(original, h.dsi9_rom_offset, Math.max(h.modcrypt1_size, h.dsi9_size), 'ARM9i'),
-    );
-    this.DSi7Data = Buffer.from(
-      slice(original, h.dsi7_rom_offset, Math.max(h.modcrypt2_size, h.dsi7_size), 'ARM7i'),
+      slice(original, h.block_hashtable_start, h.block_hashtable_size, "Block hash table"),
     );
+    this.DSi9Data = Buffer.from(slice(original, h.dsi9_rom_offset, Math.max(h.modcrypt1_size, h.dsi9_size), "ARM9i"));
+    this.DSi7Data = Buffer.from(slice(original, h.dsi7_rom_offset, Math.max(h.modcrypt2_size, h.dsi7_size), "ARM7i"));
     this.Header2Data = h.trimmedRom
       ? null
       : Array.from({ length: 3 }, (_, i) =>
-          Buffer.from(
-            slice(original, h.digest_twl_start - 0x3000 + 0x1000 * i, 0x1000, 'Secondary header'),
-          ),
+          Buffer.from(slice(original, h.digest_twl_start - 0x3000 + 0x1000 * i, 0x1000, "Secondary header")),
         );
-    this.Overlays9Sha1Hmac = overlays.map((o) =>
-      hash(slice(original, o.offset, o.size, 'ARM9 overlay')),
-    );
+    this.Overlays9Sha1Hmac = overlays.map((o) => hash(slice(original, o.offset, o.size, "ARM9 overlay")));
     let encrypted = false;
     const modcryptStart = [
       { start: h.modcrypt1_start, size: h.modcrypt1_size },
       { start: h.modcrypt2_start, size: h.modcrypt2_size },
-    ].find(
-      ({ start, size }) => size > 0 && start >= h.digest_twl_start && start < 0xffffffff,
-    )?.start;
+    ].find(({ start, size }) => size > 0 && start >= h.digest_twl_start && start < 0xffffffff)?.start;
     if (modcryptStart !== undefined) {
       const index = Math.floor((modcryptStart - h.digest_twl_start) / h.digest_sector_size);
       const actual = hash(
-        slice(
-          original,
-          h.digest_twl_start + index * h.digest_sector_size,
-          h.digest_sector_size,
-          'Modcrypt sector',
-        ),
+        slice(original, h.digest_twl_start + index * h.digest_sector_size, h.digest_sector_size, "Modcrypt sector"),
       );
       encrypted = !actual.equals(
-        slice(
-          this.Hashtable1Data,
-          this.firstDSiHashOffset + index * 20,
-          20,
-          'Modcrypt sector hash',
-        ),
+        slice(this.Hashtable1Data, this.firstDSiHashOffset + index * 20, 20, "Modcrypt sector hash"),
       );
     }
     if (encrypted) this.cryptSections(h);
@@ -178,8 +157,8 @@ export class TWL {
       const off = h[`modcrypt${id}_start`] - start;
       const result = aes128CtrCrypt(
         key,
-        slice(counter, 0, 16, 'Modcrypt counter'),
-        slice(data, off, size, 'Modcrypt payload'),
+        slice(counter, 0, 16, "Modcrypt counter"),
+        slice(data, off, size, "Modcrypt payload"),
       );
       if (writer) {
         writer.position = start + off;
@@ -194,20 +173,16 @@ export class TWL {
     this.DSi7Data = this.importData(data, offset, size);
   }
   private importData(data: Buffer | string, offset: number, size?: number): Buffer {
-    if (typeof data === 'string') data = readFileSync(data);
+    if (typeof data === "string") data = readFileSync(data);
     size ??= data.length - offset;
-    const src = slice(data, offset, size, 'DSi import');
+    const src = slice(data, offset, size, "DSi import");
     const out = Buffer.alloc(Math.ceil(size / 16) * 16, 255);
     src.copy(out);
     return out;
   }
-  updateOverlays9Sha1Hmac(
-    arm9Data: Buffer,
-    header: Arm9Header,
-    overlays: readonly Buffer[],
-  ): Buffer {
+  updateOverlays9Sha1Hmac(arm9Data: Buffer, header: Arm9Header, overlays: readonly Buffer[]): Buffer {
     if (overlays.length !== this.Overlays9Sha1Hmac.length)
-      throw new Error('Changing ARM9 overlay count is unsupported');
+      throw new Error("Changing ARM9 overlay count is unsupported");
     const hashes = overlays.map(hash);
     if (hashes.every((h, i) => h.equals(this.Overlays9Sha1Hmac[i]))) return Buffer.from(arm9Data);
     const init = header.reserved2.readUInt32LE(0) & 0x3fff;
@@ -215,30 +190,23 @@ export class TWL {
     const unpacked = decompressArm9(arm9Data, header);
     const end = unpacked.data.readUInt32LE(init + 8) - header.ARM9ramAddress;
     let found = -1;
-    for (
-      let p = Math.min(end - hashes.length * 20, unpacked.data.length - hashes.length * 20);
-      p >= 0;
-      p--
-    ) {
+    for (let p = Math.min(end - hashes.length * 20, unpacked.data.length - hashes.length * 20); p >= 0; p--) {
       if (unpacked.data.subarray(p, p + 20).equals(this.Overlays9Sha1Hmac[0])) {
         found = p;
         break;
       }
     }
-    if (found < 0)
-      throw new Error('ARM9 overlay hashes changed but original hash table was not found');
+    if (found < 0) throw new Error("ARM9 overlay hashes changed but original hash table was not found");
     hashes.forEach((h, i) => h.copy(unpacked.data, found + i * 20));
     // Original C# inverted this check and tried to compress uncompressed data.
     // Preserve the original storage format: recompress only a compressed ARM9.
-    return unpacked.compressed
-      ? compressArm9(unpacked.data, header, arm9Data.length - hdrptr)
-      : unpacked.data;
+    return unpacked.compressed ? compressArm9(unpacked.data, header, arm9Data.length - hdrptr) : unpacked.data;
   }
   writeTo(writer: BinaryWriter, h: TwlHeader): Buffer {
     validate(h);
     // Fixed DSi regions cannot be shifted safely without rewriting the header.
     if (writer.position > h.sector_hashtable_start) {
-      throw new Error('NTR output overlaps the fixed DSi sector hash table');
+      throw new Error("NTR output overlaps the fixed DSi sector hash table");
     }
     if (
       h.sector_hashtable_start + h.sector_hashtable_size > h.block_hashtable_start ||
@@ -246,7 +214,7 @@ export class TWL {
       h.dsi9_rom_offset + this.DSi9Data.length > h.dsi7_rom_offset ||
       h.dsi7_rom_offset + this.DSi7Data.length > h.total_rom_size
     ) {
-      throw new Error('DSi sections overlap or exceed the ROM size');
+      throw new Error("DSi sections overlap or exceed the ROM size");
     }
     const fill = (end: number): void => {
       if (writer.position < end) writer.fillTo(end, 255);
@@ -268,7 +236,7 @@ export class TWL {
     fill(h.total_rom_size);
     const finalPosition = writer.position;
     const read = (p: number, n: number): Buffer =>
-      slice(writer.buffer.subarray(0, writer.length), p, n, 'TWL output digest');
+      slice(writer.buffer.subarray(0, writer.length), p, n, "TWL output digest");
     let secure: Buffer = Buffer.from(read(h.digest_ntr_start, 0x4000));
     if (h.decrypted) secure = encryptSecureArea(h.gameCode, secure);
     let index = 0;
@@ -276,19 +244,10 @@ export class TWL {
       writer.position = h.sector_hashtable_start + index++ * 20;
       writer.write(hash(b));
     };
-    for (let p = 0; p < 0x4000; p += h.digest_sector_size)
-      put(secure.subarray(p, p + h.digest_sector_size));
-    for (
-      let p = h.digest_ntr_start + 0x4000;
-      p < h.digest_ntr_start + h.digest_ntr_size;
-      p += h.digest_sector_size
-    )
+    for (let p = 0; p < 0x4000; p += h.digest_sector_size) put(secure.subarray(p, p + h.digest_sector_size));
+    for (let p = h.digest_ntr_start + 0x4000; p < h.digest_ntr_start + h.digest_ntr_size; p += h.digest_sector_size)
       put(read(p, h.digest_sector_size));
-    for (
-      let p = h.digest_twl_start;
-      p < h.digest_twl_start + h.digest_twl_size;
-      p += h.digest_sector_size
-    )
+    for (let p = h.digest_twl_start; p < h.digest_twl_start + h.digest_twl_size; p += h.digest_sector_size)
       put(read(p, h.digest_sector_size));
     index = 0;
     for (
@@ -314,9 +273,9 @@ export const updateHeaderSignatures = (
   originalHeader: Buffer,
   keepOriginal: boolean,
 ): void => {
-  const signedData = Buffer.from(slice(originalHeader, 0, 0xe00, 'Signed header'));
-  const digest = slice(header.hmac_digest_master, 0, 20, 'Master digest');
-  const signature = slice(header.rsa_signature, 0, 128, 'RSA signature');
+  const signedData = Buffer.from(slice(originalHeader, 0, 0xe00, "Signed header"));
+  const digest = slice(header.hmac_digest_master, 0, 20, "Master digest");
+  const signature = slice(header.rsa_signature, 0, 128, "RSA signature");
   digest.copy(signedData, 0x328);
   const valid = verifyRsaSha1(signedData, signature);
   const position = writer.position;
@@ -328,7 +287,7 @@ export const updateHeaderSignatures = (
       mask[0] = 0;
       mask[1] = 1;
       mask[107] = 0;
-      hashDigest('sha1', signedData).copy(mask, 108);
+      hashDigest("sha1", signedData).copy(mask, 108);
       header.rsa_signature = mask;
     }
     writer.position = 0xf80;

package/src/nitro-helper.ts

@@ -1,14 +1,14 @@
-export { NDSFile } from './nitro/nds-file';
-export type { RomOptions, RomFileInfo } from './nitro/nds-file';
-export { Header, UnitCode } from './nitro/header';
-export { Banner } from './nitro/banner';
-export { FileAllocationTable, FileNameTable, OverlayTable } from './nitro/filesystem';
-export type { NitroFile, NitroFolder, FatEntry, OverlayItem } from './nitro/filesystem';
-export { BinaryWriter } from './nitro/binary';
-export { crc16, crc32 } from './nitro/crc';
-export { encryptSecureArea, aes128CtrCrypt, modcryptKey } from './nitro/crypto';
-export type { ModcryptHeader } from './nitro/crypto';
-export { compressBLZ, decompressBLZ, compressArm9, decompressArm9 } from './nitro/blz';
-export type { Arm9Header } from './nitro/blz';
-export { TWL, updateHeaderSignatures } from './nitro/twl';
-export type { TwlHeader, SignedTwlHeader, OverlayRange } from './nitro/twl';
+export { NDSFile } from "./nitro/nds-file";
+export type { RomFileInfo, RomOptions } from "./nitro/nds-file";
+export { Header, UnitCode } from "./nitro/header";
+export { Banner } from "./nitro/banner";
+export { FileAllocationTable, FileNameTable, OverlayTable } from "./nitro/filesystem";
+export type { FatEntry, NitroFile, NitroFolder, OverlayItem } from "./nitro/filesystem";
+export { BinaryWriter } from "./nitro/binary";
+export { crc16, crc32 } from "./nitro/crc";
+export { aes128CtrCrypt, encryptSecureArea, modcryptKey } from "./nitro/crypto";
+export type { ModcryptHeader } from "./nitro/crypto";
+export { compressArm9, compressBLZ, decompressArm9, decompressBLZ } from "./nitro/blz";
+export type { Arm9Header } from "./nitro/blz";
+export { TWL, updateHeaderSignatures } from "./nitro/twl";
+export type { OverlayRange, SignedTwlHeader, TwlHeader } from "./nitro/twl";