jsilnet 0.0.0-stage → 0.2.0

package/src/metadata/streams.js

@@ -0,0 +1,285 @@
+import { BinaryReader, readCompressedUInt } from "../binary/reader.js";
+import { FormatError } from "../binary/errors.js";
+
+const utf8Decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+
+function validateStringsHeap(bytes) {
+  let start = 1;
+  while (start < bytes.length) {
+    const end = bytes.indexOf(0, start);
+    if (end < 0) {
+      throw new FormatError("Unterminated string heap entry", { context: "#Strings" });
+    }
+    try {
+      utf8Decoder.decode(bytes.subarray(start, end));
+    } catch (error) {
+      throw new FormatError(`Invalid UTF-8 string: ${error.message}`, { context: "#Strings" });
+    }
+    start = end + 1;
+  }
+}
+
+function validateLengthPrefixedHeap(
+  bytes,
+  name,
+  validatePayload = () => {},
+  allowTrailingZeroPadding = false,
+  entryOffsets = new Set([0])
+) {
+  const reader = new BinaryReader(bytes, { start: 1, baseOffset: 1, context: name });
+  while (reader.remaining > 0) {
+    if (allowTrailingZeroPadding &&
+        bytes.subarray(reader.absoluteOffset).every((byte) => byte === 0)) {
+      break;
+    }
+    const entryOffset = reader.absoluteOffset;
+    entryOffsets.add(entryOffset);
+    const prefixOffset = reader.position;
+    const size = readCompressedUInt(reader);
+    const prefixSize = reader.position - prefixOffset;
+    const expectedPrefixSize = size <= 0x7f ? 1 : size <= 0x3fff ? 2 : 4;
+    if (prefixSize !== expectedPrefixSize) {
+      throw new FormatError(`Noncanonical length prefix in ${name}`, {
+        offset: entryOffset,
+        context: name
+      });
+    }
+    validatePayload(reader.take(size), entryOffset);
+  }
+  return reader.absoluteOffset;
+}
+
+export function parseMetadataRoot(input, offset, size) {
+  const bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
+  if (!Number.isInteger(offset) || !Number.isInteger(size) || offset < 0 || size < 0 || offset + size > bytes.length) {
+    throw new FormatError("Metadata directory is outside the file", { offset, context: "metadata root" });
+  }
+  const reader = new BinaryReader(bytes, { start: offset, length: size, baseOffset: offset, context: "metadata root" });
+  if (reader.u4() !== 0x424a5342) throw new FormatError("Invalid BSJB metadata signature", { offset });
+  const majorVersion = reader.u2();
+  const minorVersion = reader.u2();
+  const reserved = reader.u4();
+  if (reserved !== 0) {
+    throw new FormatError("Metadata root reserved field must be zero", {
+      offset: offset + 8,
+      context: "metadata root"
+    });
+  }
+  const versionLength = reader.u4();
+  const versionBytes = reader.take(versionLength);
+  const nul = versionBytes.indexOf(0);
+  if (nul < 0 || versionBytes.subarray(nul).some((byte) => byte !== 0)) {
+    throw new FormatError("Metadata version string is not null-terminated", {
+      offset: offset + 16,
+      context: "metadata root"
+    });
+  }
+  let version;
+  try {
+    version = utf8Decoder.decode(versionBytes.subarray(0, nul));
+  } catch (error) {
+    throw new FormatError(`Invalid UTF-8 metadata version: ${error.message}`, {
+      offset: offset + 16,
+      context: "metadata root"
+    });
+  }
+  reader.align(4);
+  const flags = reader.u2();
+  if (flags !== 0) {
+    throw new FormatError("Metadata root flags must be zero", {
+      offset: reader.absoluteOffset - 2,
+      context: "metadata root"
+    });
+  }
+  const streamCount = reader.u2();
+  const streams = new Map();
+  for (let i = 0; i < streamCount; i++) {
+    const streamOffset = reader.u4();
+    const streamSize = reader.u4();
+    const nameBytes = [];
+    for (let j = 0; j < 32; j++) {
+      const value = reader.u1();
+      if (value === 0) break;
+      if (value > 0x7f) {
+        throw new FormatError("Metadata stream name contains a non-ASCII byte", {
+          offset: reader.absoluteOffset - 1,
+          context: "metadata root"
+        });
+      }
+      nameBytes.push(value);
+    }
+    if (reader.bytes[reader.position - 1] !== 0) {
+      throw new FormatError("Metadata stream name is not null-terminated within 32 bytes", {
+        offset: reader.absoluteOffset,
+        context: "metadata root"
+      });
+    }
+    const nameEnd = reader.position;
+    reader.align(4);
+    if (reader.bytes.subarray(nameEnd, reader.position).some((byte) => byte !== 0)) {
+      throw new FormatError("Metadata stream name padding must be zero", {
+        offset: offset + nameEnd,
+        context: "metadata root"
+      });
+    }
+    if (nameBytes.length === 0) {
+      throw new FormatError("Metadata stream name must not be empty", {
+        offset: reader.absoluteOffset,
+        context: "metadata root"
+      });
+    }
+    const name = String.fromCharCode(...nameBytes);
+    if (streams.has(name)) throw new FormatError(`Duplicate metadata stream ${name}`, { offset: reader.absoluteOffset });
+    if ((streamOffset & 3) !== 0) {
+      throw new FormatError(`Metadata stream ${name} is not four-byte aligned`, {
+        offset: offset + streamOffset,
+        context: "metadata root"
+      });
+    }
+    if (streamOffset + streamSize > size) {
+      throw new FormatError(`Metadata stream ${name} exceeds the metadata directory`, {
+        offset: offset + streamOffset,
+        context: "metadata root"
+      });
+    }
+    streams.set(name, {
+      name,
+      offset: offset + streamOffset,
+      relativeOffset: streamOffset,
+      size: streamSize,
+      bytes: bytes.slice(offset + streamOffset, offset + streamOffset + streamSize)
+    });
+  }
+  const streamHeaderEnd = reader.position;
+  const ranges = [...streams.values()]
+    .sort((left, right) => left.relativeOffset - right.relativeOffset);
+  for (let index = 0; index < ranges.length; index++) {
+    const stream = ranges[index];
+    if (stream.relativeOffset < streamHeaderEnd) {
+      throw new FormatError(`Metadata stream ${stream.name} overlaps the stream directory`, {
+        offset: offset + stream.relativeOffset,
+        context: "metadata root"
+      });
+    }
+    const next = ranges[index + 1];
+    if (stream.size > 0 && next && stream.relativeOffset + stream.size > next.relativeOffset) {
+      throw new FormatError(`Metadata streams ${stream.name} and ${next.name} overlap`, {
+        offset: offset + next.relativeOffset,
+        context: "metadata root"
+      });
+    }
+  }
+  return { offset, size, majorVersion, minorVersion, version, versionLength, versionBytes, flags, streams };
+}
+
+export class MetadataHeaps {
+  constructor(streams) {
+    this.strings = streams.get("#Strings")?.bytes.slice();
+    this.userStrings = streams.get("#US")?.bytes.slice();
+    this.guids = streams.get("#GUID")?.bytes.slice();
+    this.blobs = streams.get("#Blob")?.bytes.slice();
+    this.userStringDataEnd = this.userStrings?.length ?? 0;
+    this.blobEntryOffsets = null;
+    this.userStringEntryOffsets = null;
+    for (const [name, bytes] of [
+      ["#Strings", this.strings],
+      ["#US", this.userStrings],
+      ["#Blob", this.blobs]
+    ]) {
+      if (bytes && (bytes.length === 0 || bytes[0] !== 0)) {
+        throw new FormatError(`${name} heap is missing its zero entry`, { context: name });
+      }
+    }
+    if (this.guids && this.guids.length % 16 !== 0) {
+      throw new FormatError("#GUID heap size is not a multiple of 16 bytes", { context: "#GUID" });
+    }
+    if (this.strings) validateStringsHeap(this.strings);
+    if (this.blobs) {
+      this.blobEntryOffsets = new Set([0]);
+      validateLengthPrefixedHeap(this.blobs, "#Blob", () => {}, false, this.blobEntryOffsets);
+    }
+    if (this.userStrings) {
+      this.userStringEntryOffsets = new Set([0]);
+      this.userStringDataEnd = validateLengthPrefixedHeap(this.userStrings, "#US", (payload, offset) => {
+        const textLength = payload.length - 1;
+        if (payload.length < 1 || (textLength & 1) !== 0 || payload[textLength] > 1) {
+          throw new FormatError("Invalid UTF-16LE user-string encoding", {
+            offset,
+            context: "#US"
+          });
+        }
+      }, true, this.userStringEntryOffsets);
+    }
+  }
+
+  #heap(bytes, name, index) {
+    if (!bytes) throw new FormatError(`Metadata heap ${name} is missing`);
+    if (!Number.isInteger(index) || index < 0 || index >= bytes.length) {
+      throw new FormatError(`Index ${index} is outside ${name}`, { context: "metadata heap" });
+    }
+    return bytes;
+  }
+
+  getString(index) {
+    if (index === 0) return "";
+    const bytes = this.#heap(this.strings, "#Strings", index);
+    let end = index;
+    while (end < bytes.length && bytes[end] !== 0) end++;
+    if (end === bytes.length) throw new FormatError("Unterminated string heap entry", { context: "#Strings" });
+    try {
+      return utf8Decoder.decode(bytes.subarray(index, end));
+    } catch (error) {
+      throw new FormatError(`Invalid UTF-8 string: ${error.message}`, { context: "#Strings" });
+    }
+  }
+
+  getBlob(index) {
+    if (index === 0) return new Uint8Array();
+    const bytes = this.#heap(this.blobs, "#Blob", index);
+    if (!this.blobEntryOffsets?.has(index)) {
+      throw new FormatError(`Index ${index} is not a #Blob entry boundary`, {
+        context: "#Blob"
+      });
+    }
+    const reader = new BinaryReader(bytes, { start: index, baseOffset: index, context: "#Blob" });
+    const size = readCompressedUInt(reader);
+    return reader.take(size).slice();
+  }
+
+  getGuid(index) {
+    if (index === 0) return null;
+    const bytes = this.#heap(this.guids, "#GUID", (index - 1) * 16);
+    const offset = (index - 1) * 16;
+    if (offset + 16 > bytes.length) throw new FormatError("GUID index exceeds #GUID heap", { context: "#GUID" });
+    return bytes.slice(offset, offset + 16);
+  }
+
+  getUserString(tokenOrOffset) {
+    const offset = tokenOrOffset > 0xffffff ? tokenOrOffset & 0x00ffffff : tokenOrOffset;
+    if (offset === 0) return "";
+    const bytes = this.#heap(this.userStrings, "#US", offset);
+    if (!this.userStringEntryOffsets?.has(offset) || offset >= this.userStringDataEnd) {
+      throw new FormatError(`Index ${offset} is not a #US entry boundary`, {
+        context: "#US"
+      });
+    }
+    const reader = new BinaryReader(bytes, { start: offset, baseOffset: offset, context: "#US" });
+    const size = readCompressedUInt(reader);
+    if (size < 1) throw new FormatError("#US entry is missing its special-character byte", { context: "#US" });
+    const payload = reader.take(size);
+    const textLength = payload.length - 1;
+    if ((textLength & 1) !== 0 || payload[textLength] > 1) {
+      throw new FormatError("Invalid UTF-16LE user-string encoding", { context: "#US" });
+    }
+    let result = "";
+    for (let index = 0; index < textLength; index += 0x8000) {
+      const end = Math.min(textLength, index + 0x8000);
+      const units = [];
+      for (let offset = index; offset < end; offset += 2) {
+        units.push(payload[offset] | (payload[offset + 1] << 8));
+      }
+      result += String.fromCharCode(...units);
+    }
+    return result;
+  }
+}

package/src/metadata/strong-name.js

@@ -0,0 +1,230 @@
+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;
+const hashNames = new Map([
+  [sha1Algorithm, "sha1"],
+  [0x0000800c, "sha256"],
+  [0x0000800d, "sha384"],
+  [0x0000800e, "sha512"]
+]);
+
+export function getStrongNameHashName(algorithm) {
+  const resolvedAlgorithm = algorithm || sha1Algorithm;
+  const name = hashNames.get(resolvedAlgorithm);
+  if (!name) {
+    throw new UnsupportedFormatError(
+      `Strong-name hash algorithm 0x${resolvedAlgorithm.toString(16)} is unsupported`
+    );
+  }
+  return name;
+}
+
+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 getRsaModulusBits(key) {
+  return key.n.bitLength();
+}
+
+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");
+  }
+  return key;
+}
+
+export function encodeStrongNamePublicKey(keyInput, hashAlgorithm) {
+  const hashName = getStrongNameHashName(hashAlgorithm);
+  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 = new Uint8Array(20 + modulus.length);
+  const capiView = new DataView(capiKey.buffer);
+  capiKey[0] = 0x06;
+  capiKey[1] = 0x02;
+  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 = 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) {
+  if (!(bytes instanceof Uint8Array) || bytes.length < 32) {
+    throw new FormatError("Strong-name public key is truncated");
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const signatureAlgorithm = view.getUint32(0, true);
+  const hashAlgorithm = view.getUint32(4, true);
+  const publicKeySize = view.getUint32(8, true);
+  if (signatureAlgorithm !== rsaSignAlgorithm || publicKeySize !== bytes.length - 12) {
+    throw new UnsupportedFormatError("Strong-name public key uses an unsupported algorithm or size");
+  }
+  getStrongNameHashName(hashAlgorithm);
+  if (bytes[12] !== 0x06 || bytes[13] !== 0x02 ||
+      view.getUint16(14, true) !== 0 ||
+      view.getUint32(16, true) !== rsaSignAlgorithm ||
+      view.getUint32(20, true) !== 0x31415352) {
+    throw new UnsupportedFormatError("Strong-name public key does not contain a supported CAPI RSA key");
+  }
+  const modulusBits = view.getUint32(24, true);
+  const exponent = view.getUint32(28, true);
+  if (modulusBits === 0 || modulusBits % 8 !== 0 ||
+      publicKeySize !== 20 + modulusBits / 8 || exponent < 3 || exponent % 2 === 0) {
+    throw new FormatError("Strong-name CAPI RSA key has inconsistent dimensions");
+  }
+  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 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,
+    signatureSize: modulusBits / 8
+  };
+}
+
+export function assertStrongNamePEProfile(pe) {
+  const fixedOptionalHeaderSize = pe.optionalHeaderMagic === 0x10b ? 96 : 112;
+  if (pe.optionalHeaderSize !== fixedOptionalHeaderSize + 16 * 8 ||
+      pe.directories.length < 15 || pe.directories.length > 16) {
+    throw new UnsupportedFormatError(
+      "Strong-name signing requires the standard PE optional header with 15 or 16 declared data directories"
+    );
+  }
+  return fixedOptionalHeaderSize;
+}
+
+function getStrongNameRanges(bytes, pe, cli) {
+  const fixedOptionalHeaderSize = assertStrongNamePEProfile(pe);
+  const signature = cli.strongNameSignature;
+  if (signature.rva === 0 || signature.size === 0) {
+    throw new UnsupportedFormatError("Strong-name signing requires a reserved signature directory");
+  }
+  const signatureOffset = pe.rvaToOffset(signature.rva, signature.size);
+  const signatureEnd = signatureOffset + signature.size;
+  const containingSection = pe.sections.find((section) =>
+    signatureOffset >= section.rawPointer &&
+    signatureEnd <= section.rawPointer + section.rawSize
+  );
+  if (!containingSection) {
+    throw new FormatError("Strong-name signature slot is not contained in section data");
+  }
+  return { signatureOffset, signatureEnd, fixedOptionalHeaderSize };
+}
+
+function updateStrongNameData(signer, bytes, pe, ranges) {
+  const update = (part) => signer.update(bytesToBinaryString(part));
+  update(bytes.subarray(0, pe.peOffset));
+  update(bytes.subarray(pe.peOffset, pe.peOffset + 24));
+
+  const optionalHeader = Uint8Array.from(bytes.subarray(
+    pe.optionalHeaderOffset,
+    pe.optionalHeaderOffset + ranges.fixedOptionalHeaderSize
+  ));
+  optionalHeader.fill(0, 64, 68);
+  update(optionalHeader);
+
+  const directoriesOffset = pe.optionalHeaderOffset + ranges.fixedOptionalHeaderSize;
+  const directories = Uint8Array.from(bytes.subarray(directoriesOffset, directoriesOffset + 16 * 8));
+  directories.fill(0, 4 * 8, 5 * 8);
+  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) update(bytes.subarray(start, beforeEnd));
+    const afterStart = Math.max(start, ranges.signatureEnd);
+    if (afterStart < end) update(bytes.subarray(afterStart, end));
+  }
+}
+
+export function signStrongNameImage(bytes, pe, cli, privateKey, hashAlgorithm) {
+  const hashName = getStrongNameHashName(hashAlgorithm);
+  const output = Uint8Array.from(bytes);
+  const ranges = getStrongNameRanges(output, pe, cli);
+  const view = new DataView(output.buffer, output.byteOffset, output.byteLength);
+  view.setUint32(cli.strongNameFlagOffset, cli.flags | 0x08, true);
+
+  const signer = forge.md[hashName].create();
+  updateStrongNameData(signer, output, pe, ranges);
+  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}`
+    );
+  }
+  output.set(signature, ranges.signatureOffset);
+  return output;
+}
+
+export function verifyStrongNameImage(bytes, pe, cli, publicKeyBytes, hashAlgorithm) {
+  if ((cli.flags & 0x08) === 0) return false;
+  const key = decodeStrongNamePublicKey(publicKeyBytes);
+  const hashName = getStrongNameHashName(hashAlgorithm || key.hashAlgorithm);
+  if (cli.strongNameSignature.size !== key.signatureSize) return false;
+  const ranges = getStrongNameRanges(bytes, pe, cli);
+  const signature = bytesToBinaryString(
+    Uint8Array.from(bytes.subarray(ranges.signatureOffset, ranges.signatureEnd)).reverse()
+  );
+  const verifier = forge.md[hashName].create();
+  updateStrongNameData(verifier, bytes, pe, ranges);
+  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;
+  }
+}