jsilnet 0.1.0 → 0.2.0

package/src/metadata/portable-pdb.js

@@ -1,5 +1,5 @@
-import { deflateRawSync, inflateRawSync } from "node:zlib";
-import { createHash } from "node:crypto";
+import { deflateRawSync, inflateRawSync } from "../platform/compression.js";
+import { createHash } from "../platform/crypto.js";
 import { BinaryReader, readCompressedInt, readCompressedUInt } from "../binary/reader.js";
 import { FormatError, UnsupportedFormatError } from "../binary/errors.js";
 import {

package/src/metadata/strong-name.js

@@ -1,10 +1,6 @@
-import {
-  createPrivateKey,
-  createPublicKey,
-  createSign,
-  createVerify
-} from "node:crypto";
+import forge from "node-forge";
 import { FormatError, UnsupportedFormatError } from "../binary/errors.js";
+import { binaryStringToBytes, bytesToBinaryString } from "../platform/bytes.js";
 
 const rsaSignAlgorithm = 0x00002400;
 const sha1Algorithm = 0x00008004;
@@ -26,74 +22,76 @@ export function getStrongNameHashName(algorithm) {
   return name;
 }
 
-export function importStrongNamePrivateKey(input) {
-  const key = input && typeof input === "object" && input.type === "private"
-    ? input
-    : createPrivateKey(input);
-  if (key.asymmetricKeyType !== "rsa") {
-    throw new UnsupportedFormatError("Strong-name signing requires an RSA private key");
-  }
-  if (!key.asymmetricKeyDetails?.modulusLength) {
-    throw new UnsupportedFormatError("Strong-name RSA key does not expose its modulus length");
-  }
-  return key;
-}
-
-function getRsaJwk(key) {
-  const jwk = createPublicKey(key).export({ format: "jwk" });
-  if (!jwk.n || !jwk.e || jwk.kty !== "RSA") {
-    throw new UnsupportedFormatError("Strong-name key is not a usable RSA key");
-  }
-  return jwk;
+function binaryIntegerBytes(value, length) {
+  let hex = value.toString(16);
+  if ((hex.length & 1) !== 0) hex = `0${hex}`;
+  const encoded = binaryStringToBytes(forge.util.hexToBytes(hex));
+  if (encoded.length > length) throw new FormatError("RSA integer exceeds its declared size");
+  const output = new Uint8Array(length);
+  output.set(encoded, length - encoded.length);
+  return output;
 }
 
-function getRsaModulus(key, jwk) {
-  const modulusLength = Math.ceil(key.asymmetricKeyDetails.modulusLength / 8);
-  const encoded = Buffer.from(jwk.n, "base64url");
-  if (encoded.length > modulusLength) {
-    throw new FormatError("RSA modulus exceeds its declared bit length");
-  }
-  const modulus = Buffer.alloc(modulusLength);
-  encoded.copy(modulus, modulusLength - encoded.length);
-  return modulus;
+function getRsaModulusBits(key) {
+  return key.n.bitLength();
 }
 
-function getRsaExponent(jwk) {
-  const bytes = Buffer.from(jwk.e, "base64url");
-  if (bytes.length === 0 || bytes.length > 4) {
-    throw new UnsupportedFormatError("Strong-name RSA public exponent exceeds the CAPI format");
+export function importStrongNamePrivateKey(input) {
+  if (input && typeof input === "object" && input.n && input.e && input.d) return input;
+  let pem = input;
+  if (input && typeof input === "object" && input.type === "private" &&
+      typeof input.export === "function") {
+    if (input.asymmetricKeyType !== "rsa") {
+      throw new UnsupportedFormatError("Strong-name signing requires an RSA private key");
+    }
+    pem = input.export({ format: "pem", type: "pkcs8" });
+  } else if (input instanceof Uint8Array) {
+    pem = new TextDecoder("ascii", { fatal: true }).decode(input);
+  }
+  if (typeof pem !== "string") {
+    throw new UnsupportedFormatError("Strong-name signing requires an RSA PEM or private key");
+  }
+  const key = forge.pki.privateKeyFromPem(pem);
+  if (!key.n || !key.e || !key.d) {
+    throw new UnsupportedFormatError("Strong-name signing requires an RSA private key");
   }
-  let exponent = 0;
-  for (const byte of bytes) exponent = exponent * 256 + byte;
-  return exponent;
+  return key;
 }
 
-export function encodeStrongNamePublicKey(key, hashAlgorithm) {
+export function encodeStrongNamePublicKey(keyInput, hashAlgorithm) {
   const hashName = getStrongNameHashName(hashAlgorithm);
-  const jwk = getRsaJwk(key);
-  const modulus = getRsaModulus(key, jwk);
-  const exponent = getRsaExponent(jwk);
-  const modulusBits = key.asymmetricKeyDetails.modulusLength;
+  const key = importStrongNamePrivateKey(keyInput);
+  const modulusBits = getRsaModulusBits(key);
+  const modulusLength = Math.ceil(modulusBits / 8);
+  const modulus = binaryIntegerBytes(key.n, modulusLength);
+  const exponent = Number(key.e.toString(10));
   if (modulusBits % 8 !== 0) {
     throw new UnsupportedFormatError("Strong-name RSA modulus length must be byte-aligned");
   }
+  if (exponent < 3 || exponent % 2 === 0) {
+    throw new UnsupportedFormatError("Strong-name RSA public exponent is invalid");
+  }
 
-  const capiKey = Buffer.alloc(20 + modulus.length);
+  const capiKey = new Uint8Array(20 + modulus.length);
+  const capiView = new DataView(capiKey.buffer);
   capiKey[0] = 0x06;
   capiKey[1] = 0x02;
-  capiKey.writeUInt32LE(rsaSignAlgorithm, 4);
-  capiKey.writeUInt32LE(0x31415352, 8);
-  capiKey.writeUInt32LE(modulusBits, 12);
-  capiKey.writeUInt32LE(exponent, 16);
-  Buffer.from(modulus).reverse().copy(capiKey, 20);
+  capiView.setUint32(4, rsaSignAlgorithm, true);
+  capiView.setUint32(8, 0x31415352, true);
+  capiView.setUint32(12, modulusBits, true);
+  capiView.setUint32(16, exponent, true);
+  for (let index = 0; index < modulus.length; index++) {
+    capiKey[20 + index] = modulus[modulus.length - 1 - index];
+  }
 
   const hashAlgorithmId = [...hashNames].find(([, name]) => name === hashName)?.[0];
-  const publicKey = Buffer.alloc(12 + capiKey.length);
-  publicKey.writeUInt32LE(rsaSignAlgorithm, 0);
-  publicKey.writeUInt32LE(hashAlgorithmId, 4);
-  publicKey.writeUInt32LE(capiKey.length, 8);
-  capiKey.copy(publicKey, 12);
-  return publicKey;
+  const publicKey = new Uint8Array(12 + capiKey.length);
+  const publicKeyView = new DataView(publicKey.buffer);
+  publicKeyView.setUint32(0, rsaSignAlgorithm, true);
+  publicKeyView.setUint32(4, hashAlgorithmId, true);
+  publicKeyView.setUint32(8, capiKey.length, true);
+  publicKey.set(capiKey, 12);
+  return typeof Buffer === "undefined" ? publicKey : Buffer.from(publicKey);
 }
 
 export function decodeStrongNamePublicKey(bytes) {
@@ -120,20 +118,15 @@ export function decodeStrongNamePublicKey(bytes) {
       publicKeySize !== 20 + modulusBits / 8 || exponent < 3 || exponent % 2 === 0) {
     throw new FormatError("Strong-name CAPI RSA key has inconsistent dimensions");
   }
-  const modulus = Buffer.from(bytes.subarray(32)).reverse();
+  const modulus = Uint8Array.from(bytes.subarray(32)).reverse();
   if ((modulus[0] & 0x80) === 0) {
     throw new FormatError("Strong-name RSA modulus does not match its declared bit length");
   }
-  const exponentBytes = Buffer.alloc(4);
-  exponentBytes.writeUInt32BE(exponent);
-  let exponentStart = 0;
-  while (exponentStart < exponentBytes.length - 1 && exponentBytes[exponentStart] === 0) exponentStart++;
-  const jwk = {
-    kty: "RSA",
-    n: modulus.toString("base64url"),
-    e: exponentBytes.subarray(exponentStart).toString("base64url")
-  };
-  const publicKey = createPublicKey({ key: jwk, format: "jwk" });
+  const modulusHex = forge.util.bytesToHex(bytesToBinaryString(modulus));
+  const publicKey = forge.pki.rsa.setPublicKey(
+    new forge.jsbn.BigInteger(modulusHex, 16),
+    new forge.jsbn.BigInteger(String(exponent), 10)
+  );
   return {
     publicKey,
     hashAlgorithm,
@@ -171,29 +164,30 @@ function getStrongNameRanges(bytes, pe, cli) {
 }
 
 function updateStrongNameData(signer, bytes, pe, ranges) {
-  signer.update(bytes.subarray(0, pe.peOffset));
-  signer.update(bytes.subarray(pe.peOffset, pe.peOffset + 24));
+  const update = (part) => signer.update(bytesToBinaryString(part));
+  update(bytes.subarray(0, pe.peOffset));
+  update(bytes.subarray(pe.peOffset, pe.peOffset + 24));
 
-  const optionalHeader = Buffer.from(bytes.subarray(
+  const optionalHeader = Uint8Array.from(bytes.subarray(
     pe.optionalHeaderOffset,
     pe.optionalHeaderOffset + ranges.fixedOptionalHeaderSize
   ));
   optionalHeader.fill(0, 64, 68);
-  signer.update(optionalHeader);
+  update(optionalHeader);
 
   const directoriesOffset = pe.optionalHeaderOffset + ranges.fixedOptionalHeaderSize;
-  const directories = Buffer.from(bytes.subarray(directoriesOffset, directoriesOffset + 16 * 8));
+  const directories = Uint8Array.from(bytes.subarray(directoriesOffset, directoriesOffset + 16 * 8));
   directories.fill(0, 4 * 8, 5 * 8);
-  signer.update(directories);
-  signer.update(bytes.subarray(pe.sectionOffset, pe.sectionOffset + pe.sectionCount * 40));
+  update(directories);
+  update(bytes.subarray(pe.sectionOffset, pe.sectionOffset + pe.sectionCount * 40));
 
   for (const section of pe.sections) {
     const start = section.rawPointer;
     const end = start + section.rawSize;
     const beforeEnd = Math.min(end, ranges.signatureOffset);
-    if (start < beforeEnd) signer.update(bytes.subarray(start, beforeEnd));
+    if (start < beforeEnd) update(bytes.subarray(start, beforeEnd));
     const afterStart = Math.max(start, ranges.signatureEnd);
-    if (afterStart < end) signer.update(bytes.subarray(afterStart, end));
+    if (afterStart < end) update(bytes.subarray(afterStart, end));
   }
 }
 
@@ -204,9 +198,9 @@ export function signStrongNameImage(bytes, pe, cli, privateKey, hashAlgorithm) {
   const view = new DataView(output.buffer, output.byteOffset, output.byteLength);
   view.setUint32(cli.strongNameFlagOffset, cli.flags | 0x08, true);
 
-  const signer = createSign(hashName);
+  const signer = forge.md[hashName].create();
   updateStrongNameData(signer, output, pe, ranges);
-  const signature = Buffer.from(signer.sign(privateKey)).reverse();
+  const signature = binaryStringToBytes(privateKey.sign(signer)).reverse();
   if (signature.length !== cli.strongNameSignature.size) {
     throw new FormatError(
       `Strong-name signature size ${signature.length} does not match reserved slot ${cli.strongNameSignature.size}`
@@ -222,8 +216,15 @@ export function verifyStrongNameImage(bytes, pe, cli, publicKeyBytes, hashAlgori
   const hashName = getStrongNameHashName(hashAlgorithm || key.hashAlgorithm);
   if (cli.strongNameSignature.size !== key.signatureSize) return false;
   const ranges = getStrongNameRanges(bytes, pe, cli);
-  const signature = Buffer.from(bytes.subarray(ranges.signatureOffset, ranges.signatureEnd)).reverse();
-  const verifier = createVerify(hashName);
+  const signature = bytesToBinaryString(
+    Uint8Array.from(bytes.subarray(ranges.signatureOffset, ranges.signatureEnd)).reverse()
+  );
+  const verifier = forge.md[hashName].create();
   updateStrongNameData(verifier, bytes, pe, ranges);
-  return verifier.verify(key.publicKey, signature);
+  try {
+    return key.publicKey.verify(verifier.digest().getBytes(), signature);
+  } catch (error) {
+    if (error instanceof Error && error.message === "Encryption block is invalid.") return false;
+    throw error;
+  }
 }

package/src/pe/headers.js

@@ -1,4 +1,4 @@
-import { inflateRawSync } from "node:zlib";
+import { inflateRawSync } from "../platform/compression.js";
 import { BinaryReader } from "../binary/reader.js";
 import { FormatError, UnsupportedFormatError } from "../binary/errors.js";
 import { MetadataHeaps, parseMetadataRoot } from "../metadata/streams.js";

package/src/platform/bytes.js

@@ -0,0 +1,21 @@
+export function bytesToBinaryString(bytes) {
+  const chunks = [];
+  const chunkSize = 0x8000;
+  for (let offset = 0; offset < bytes.length; offset += chunkSize) {
+    chunks.push(String.fromCharCode(...bytes.subarray(offset, offset + chunkSize)));
+  }
+  return chunks.join("");
+}
+
+export function binaryStringToBytes(value) {
+  const bytes = new Uint8Array(value.length);
+  for (let index = 0; index < value.length; index++) bytes[index] = value.charCodeAt(index);
+  return bytes;
+}
+
+export function equalBytes(left, right) {
+  if (left.length !== right.length) return false;
+  let difference = 0;
+  for (let index = 0; index < left.length; index++) difference |= left[index] ^ right[index];
+  return difference === 0;
+}

package/src/platform/compression.js

@@ -0,0 +1,24 @@
+import { deflateSync, inflateSync } from "fflate";
+
+export function deflateRawSync(bytes) {
+  return deflateSync(bytes);
+}
+
+export function inflateRawSync(bytes, options = {}) {
+  const { maxOutputLength } = options;
+  if (maxOutputLength === undefined) return inflateSync(bytes);
+  if (!Number.isSafeInteger(maxOutputLength) || maxOutputLength < 0 ||
+      maxOutputLength === Number.MAX_SAFE_INTEGER) {
+    throw new RangeError("maxOutputLength must be a nonnegative safe integer");
+  }
+  const maximum = maxOutputLength + 1;
+  let capacity = Math.min(maximum, 0x10000);
+  while (true) {
+    const output = inflateSync(bytes, { out: new Uint8Array(capacity) });
+    if (output.length < capacity) return output;
+    if (capacity === maximum) {
+      throw new RangeError(`Decompressed data exceeds ${maxOutputLength} bytes`);
+    }
+    capacity = Math.min(maximum, capacity * 2);
+  }
+}

package/src/platform/crypto.js

@@ -0,0 +1,17 @@
+import forge from "node-forge";
+import { binaryStringToBytes, bytesToBinaryString } from "./bytes.js";
+
+export function createHash(name) {
+  const factory = forge.md[name];
+  if (!factory) throw new RangeError(`Unsupported hash algorithm ${name}`);
+  const digest = factory.create();
+  return {
+    update(bytes) {
+      digest.update(bytesToBinaryString(bytes));
+      return this;
+    },
+    digest() {
+      return binaryStringToBytes(digest.digest().getBytes());
+    }
+  };
+}

package/src/types/assembly/instruction-editing.d.ts

@@ -0,0 +1,33 @@
+export function createInstructionEditor(assembly: any, hooks: any): {
+    setInstructionOperand(methodRid: any, instructionOffset: any, value: any): any;
+    setInstructionOpcode(methodRid: any, instructionOffset: any, opcodeNameOrCode: any): any;
+    insertInstruction(methodRid: any, beforeOffset: any, opcodeNameOrCode: any, operand: any): {
+        opcode: any;
+        operand: {
+            kind: string;
+            targetOffset: any;
+            targetOffsets?: undefined;
+            value?: undefined;
+        } | {
+            kind: string;
+            targetOffsets: any[];
+            targetOffset?: undefined;
+            value?: undefined;
+        } | {
+            kind: any;
+            value: any;
+            targetOffset?: undefined;
+            targetOffsets?: undefined;
+        };
+        offset: number;
+        size: any;
+        opcodeSize: number;
+        opcodeOffset: any;
+        operandOffset: any;
+        patchOffsets: any[];
+        originalOffset: any;
+        isNew: boolean;
+    };
+    removeInstruction(methodRid: any, instructionOffset: any): any;
+    setMethodMaxStack(methodRid: any, maxStack: any): any;
+};

package/src/types/assembly/method-removal.d.ts

@@ -0,0 +1,3 @@
+export function createMethodRemovalEditor(hooks: any): {
+    removeMethod(rid: any): Map<any, any>;
+};

package/src/types/assembly/pointer-table-editing.d.ts

@@ -0,0 +1,3 @@
+export function createPointerTableEditor(hooks: any): {
+    reorderPointerTable(pointerTable: any, targetRids: any): /*elided*/ any;
+};

package/src/types/assembly/portable-pdb-editing.d.ts

@@ -0,0 +1,23 @@
+export function createPortablePdbEditor(hooks: any): {
+    addEmbeddedPortablePdbDocument(debugEntryIndex: any, name: any, options: any): any;
+    insertEmbeddedPortablePdbDocument(debugEntryIndex: any, options: any): any;
+    addEmbeddedPortablePdbTypeDefinitionDocuments(debugEntryIndex: any, typeRid: any, documentRids: any): any;
+    removeEmbeddedPortablePdbDocument(debugEntryIndex: any, documentRid: any): any;
+    replaceEmbeddedPortablePdbTypeDefinitionDocuments(debugEntryIndex: any, typeRid: any, documentRids: any): any;
+    replaceEmbeddedPortablePdbDocumentMetadata(debugEntryIndex: any, documentRid: any, options: any): any;
+    replaceEmbeddedPortablePdbDocumentName(debugEntryIndex: any, documentRid: any, name: any, separator: any): any;
+    replaceEmbeddedPortablePdbSequencePoints(debugEntryIndex: any, methodRid: any, sequencePoints: any): any;
+    replaceEmbeddedPortablePdbMethodDocument(debugEntryIndex: any, methodRid: any, documentRid: any): any;
+    replaceEmbeddedPortablePdbImportScope(debugEntryIndex: any, importScopeRid: any, options: any): any;
+    replaceEmbeddedPortablePdbLocalScope(debugEntryIndex: any, localScopeRid: any, options: any): any;
+    replaceEmbeddedPortablePdbLocalVariable(debugEntryIndex: any, localVariableRid: any, options: any): any;
+    replaceEmbeddedPortablePdbLocalConstant(debugEntryIndex: any, localConstantRid: any, options: any): any;
+    replaceEmbeddedPortablePdbCustomDebugInformation(debugEntryIndex: any, customDebugInformationRid: any, value: any): any;
+    replaceEmbeddedPortablePdbSource(debugEntryIndex: any, documentRid: any, source: any, options: any): any;
+    addEmbeddedPortablePdbSource(debugEntryIndex: any, documentRid: any, source: any, options: any): any;
+    removeEmbeddedPortablePdbSource(debugEntryIndex: any, documentRid: any): any;
+    removeEmbeddedPortablePdbCustomDebugInformation(debugEntryIndex: any, recordRid: any): any;
+    replaceEmbeddedPortablePdbSourceLink(debugEntryIndex: any, sourceLink: any): any;
+    removeEmbeddedPortablePdbSourceLink(debugEntryIndex: any): any;
+    addEmbeddedPortablePdbSourceLink(debugEntryIndex: any, sourceLink: any): any;
+};

package/src/types/binary/errors.d.ts

@@ -0,0 +1,7 @@
+export class FormatError extends Error {
+    constructor(message: any, { offset, context }?: {});
+    offset: any;
+    context: any;
+}
+export class UnsupportedFormatError extends FormatError {
+}

package/src/types/binary/reader.d.ts

@@ -0,0 +1,30 @@
+export function readCompressedUInt(reader: any): any;
+export function readCompressedInt(reader: any): number;
+export class BinaryReader {
+    constructor(input: any, { start, length, baseOffset, context }?: {
+        start?: number;
+        baseOffset?: number;
+    });
+    bytes: Uint8Array<any>;
+    view: DataView<any>;
+    baseOffset: number;
+    context: any;
+    position: number;
+    get remaining(): number;
+    get absoluteOffset(): number;
+    ensure(size: any): void;
+    seek(position: any): void;
+    skip(size: any): void;
+    align(alignment: any): void;
+    u1(): number;
+    i1(): number;
+    u2(): number;
+    i2(): number;
+    u4(): number;
+    i4(): number;
+    u8(): bigint;
+    f4(): number;
+    f8(): number;
+    take(size: any): Uint8Array<any>;
+    slice(size: any, context?: any): BinaryReader;
+}

package/src/types/il/body.d.ts

@@ -0,0 +1,51 @@
+export function parseMethodBody(input: any, fileOffset: any, methodRva?: any): {
+    format: string;
+    flags: number;
+    maxStack: number;
+    codeSize: number;
+    localVarSigToken: number;
+    headerOffset: any;
+    headerSize: number;
+    codeOffset: any;
+    endOffset: any;
+    instructions: {
+        opcode: any;
+        offset: number;
+        size: number;
+        opcodeOffset: number;
+        opcodeSize: number;
+        operandOffset: number;
+        patchOffsets: any[];
+        operand: {
+            kind: string;
+            targetOffset: number;
+            targetOffsets?: undefined;
+            value?: undefined;
+        } | {
+            kind: string;
+            targetOffsets: number[];
+            targetOffset?: undefined;
+            value?: undefined;
+        } | {
+            kind: any;
+            value: any;
+            targetOffset?: undefined;
+            targetOffsets?: undefined;
+        };
+    }[];
+    sections: {
+        offset: any;
+        rva: any;
+        size: number;
+        fat: boolean;
+        moreSections: boolean;
+        clauses: {
+            flags: number;
+            tryOffset: number;
+            tryLength: number;
+            handlerOffset: number;
+            handlerLength: number;
+            classTokenOrFilterOffset: number;
+        }[];
+    }[];
+};

package/src/types/il/instructions.d.ts

@@ -0,0 +1,33 @@
+export function decodeInstructions(input: any, { baseOffset, ilOffset }?: {
+    baseOffset?: number;
+    ilOffset?: number;
+}): {
+    opcode: any;
+    offset: number;
+    size: number;
+    opcodeOffset: number;
+    opcodeSize: number;
+    operandOffset: number;
+    patchOffsets: any[];
+    operand: {
+        kind: string;
+        targetOffset: number;
+        targetOffsets?: undefined;
+        value?: undefined;
+    } | {
+        kind: string;
+        targetOffsets: number[];
+        targetOffset?: undefined;
+        value?: undefined;
+    } | {
+        kind: any;
+        value: any;
+        targetOffset?: undefined;
+        targetOffsets?: undefined;
+    };
+}[];
+export function encodeOpcode(opcode: any): Uint8Array<ArrayBuffer>;
+export function getInstructionSize(opcode: any, operand: any): any;
+export function encodeInstruction(instruction: any): Uint8Array<any>;
+export function formatInstruction(instruction: any): string;
+export function encodeOperand(instruction: any, value: any): Uint8Array<any>;

package/src/types/il/opcodes.d.ts

@@ -0,0 +1,2 @@
+export function getOpcode(code: any): any;
+export function listOpcodes(): any[];

package/src/types/il/rewrite.d.ts

@@ -0,0 +1,38 @@
+export function createStructuralState(body: any): {
+    body: any;
+    instructions: any;
+    branchTargets: Map<any, any>;
+    clauses: any[];
+    maxStack: any;
+};
+export function layoutStructuralState(state: any): any;
+export function insertInstruction(state: any, beforeOffset: any, opcode: any, value: any): {
+    opcode: any;
+    operand: {
+        kind: string;
+        targetOffset: any;
+        targetOffsets?: undefined;
+        value?: undefined;
+    } | {
+        kind: string;
+        targetOffsets: any[];
+        targetOffset?: undefined;
+        value?: undefined;
+    } | {
+        kind: any;
+        value: any;
+        targetOffset?: undefined;
+        targetOffsets?: undefined;
+    };
+    offset: number;
+    size: any;
+    opcodeSize: number;
+    opcodeOffset: any;
+    operandOffset: any;
+    patchOffsets: any[];
+    originalOffset: any;
+    isNew: boolean;
+};
+export function removeInstruction(state: any, offset: any): any;
+export function updateStructuralOperand(state: any, instruction: any, value: any): void;
+export function encodeMethodBody(state: any, methodRva: any): Uint8Array<ArrayBuffer>;