jsilnet 0.0.0-stage → 0.2.0

package/src/writer/pe.js

@@ -0,0 +1,196 @@
+import { FormatError, UnsupportedFormatError } from "../binary/errors.js";
+
+function align(value, alignment) {
+  if (!Number.isInteger(alignment) || alignment < 1 || (alignment & (alignment - 1)) !== 0) {
+    throw new UnsupportedFormatError(`Unsupported PE alignment ${alignment}`);
+  }
+  return Math.ceil(value / alignment) * alignment;
+}
+
+function writeU16(view, offset, value, label) {
+  if (!Number.isInteger(value) || value < 0 || value > 0xffff) throw new RangeError(`${label} exceeds 16-bit range`);
+  view.setUint16(offset, value, true);
+}
+
+function writeU32(view, offset, value, label) {
+  if (!Number.isInteger(value) || value < 0 || value > 0xffffffff) throw new RangeError(`${label} exceeds 32-bit range`);
+  view.setUint32(offset, value, true);
+}
+
+export function getNextSectionVirtualAddress(pe) {
+  let maxVirtualEnd = pe.sizeOfImage;
+  for (const section of pe.sections) {
+    maxVirtualEnd = Math.max(maxVirtualEnd, section.virtualAddress + Math.max(section.virtualSize, section.rawSize));
+  }
+  return align(maxVirtualEnd, pe.sectionAlignment);
+}
+
+function expandHeaderForSection(input, pe) {
+  const firstRawPointer = Math.min(
+    ...pe.sections.filter((section) => section.rawSize > 0).map((section) => section.rawPointer),
+    pe.sizeOfHeaders
+  );
+  const sectionHeaderOffset = pe.sectionOffset + pe.sectionCount * 40;
+  const newHeaderEnd = sectionHeaderOffset + 40;
+  if (sectionHeaderOffset > firstRawPointer) {
+    throw new UnsupportedFormatError("PE section headers overlap section data");
+  }
+  const required = newHeaderEnd - Math.min(pe.sizeOfHeaders, firstRawPointer);
+  const delta = required > 0 ? align(required, pe.fileAlignment) : 0;
+  const insertionOffset = firstRawPointer;
+  const output = new Uint8Array(input.length + delta);
+  output.set(input.subarray(0, insertionOffset));
+  output.set(input.subarray(insertionOffset), insertionOffset + delta);
+  const view = new DataView(output.buffer);
+
+  if (delta > 0) {
+    for (let index = 0; index < pe.sections.length; index++) {
+      const header = pe.sectionOffset + index * 40;
+      for (const fieldOffset of [20, 24, 28]) {
+        const pointer = view.getUint32(header + fieldOffset, true);
+        if (pointer >= insertionOffset && pointer !== 0) view.setUint32(header + fieldOffset, pointer + delta, true);
+      }
+    }
+    if (pe.symbolTablePointer >= insertionOffset && pe.symbolTablePointer !== 0) {
+      view.setUint32(pe.peOffset + 12, pe.symbolTablePointer + delta, true);
+    }
+    view.setUint32(pe.optionalHeaderOffset + 60, pe.sizeOfHeaders + delta, true);
+    const debugDirectory = pe.directories[6];
+    if (debugDirectory?.rva && debugDirectory.size > 0) {
+      if (debugDirectory.size % 28 !== 0) {
+        throw new UnsupportedFormatError("Debug directory size is not a multiple of IMAGE_DEBUG_DIRECTORY");
+      }
+      const originalOffset = pe.rvaToOffset(debugDirectory.rva, debugDirectory.size);
+      if (originalOffset < insertionOffset && originalOffset + debugDirectory.size > insertionOffset) {
+        throw new UnsupportedFormatError("Debug directory crosses the PE header expansion boundary");
+      }
+      const debugOffset = originalOffset >= insertionOffset ? originalOffset + delta : originalOffset;
+      for (let offset = debugOffset; offset < debugOffset + debugDirectory.size; offset += 28) {
+        const pointer = view.getUint32(offset + 24, true);
+        if (pointer >= insertionOffset && pointer !== 0) view.setUint32(offset + 24, pointer + delta, true);
+      }
+    }
+  }
+  return { bytes: output, delta, insertionOffset, sectionHeaderOffset, firstRawPointer: firstRawPointer + delta };
+}
+
+export function appendPeSection(
+  input,
+  pe,
+  cli,
+  payload,
+  metadataOffset,
+  metadataSize,
+  resourcesDirectory = null,
+  preserveStrongName = false,
+  debugDirectoryPayload = null
+) {
+  if (payload.length === 0) throw new RangeError("Cannot add an empty PE section");
+  if (pe.sectionCount >= 0xffff) throw new UnsupportedFormatError("PE section-count limit reached");
+  const fileAlignment = pe.fileAlignment;
+  const sectionAlignment = pe.sectionAlignment;
+  const expanded = expandHeaderForSection(input, pe);
+  const rawPointer = align(expanded.bytes.length, fileAlignment);
+  const rawSize = align(payload.length, fileAlignment);
+  const sectionHeaderOffset = expanded.sectionHeaderOffset;
+  if (sectionHeaderOffset + 40 > pe.sizeOfHeaders + expanded.delta ||
+      sectionHeaderOffset + 40 > expanded.firstRawPointer) {
+    throw new UnsupportedFormatError("PE headers have no room for an additional section header");
+  }
+  const virtualAddress = getNextSectionVirtualAddress(pe);
+  const imageSize = align(virtualAddress + payload.length, sectionAlignment);
+  if (rawPointer + rawSize > 0xffffffff || imageSize > 0xffffffff) {
+    throw new RangeError("Rewritten PE exceeds 32-bit image limits");
+  }
+
+  const output = new Uint8Array(rawPointer + rawSize);
+  output.set(expanded.bytes);
+  output.set(payload, rawPointer);
+  const view = new DataView(output.buffer);
+  view.setUint16(pe.peOffset + 6, pe.sectionCount + 1, true);
+  writeU32(view, pe.optionalHeaderOffset + 4, pe.sizeOfCode + rawSize, "SizeOfCode");
+  writeU32(view, pe.optionalHeaderOffset + 56, imageSize, "SizeOfImage");
+  view.setUint32(pe.checksumOffset, 0, true);
+
+  output.set(new TextEncoder().encode(".jsilnet"), sectionHeaderOffset);
+  writeU32(view, sectionHeaderOffset + 8, payload.length, "section virtual size");
+  writeU32(view, sectionHeaderOffset + 12, virtualAddress, "section virtual address");
+  writeU32(view, sectionHeaderOffset + 16, rawSize, "section raw size");
+  writeU32(view, sectionHeaderOffset + 20, rawPointer, "section raw pointer");
+  writeU32(view, sectionHeaderOffset + 24, 0, "section relocation pointer");
+  writeU32(view, sectionHeaderOffset + 28, 0, "section line-number pointer");
+  writeU16(view, sectionHeaderOffset + 32, 0, "section relocation count");
+  writeU16(view, sectionHeaderOffset + 34, 0, "section line-number count");
+  writeU32(view, sectionHeaderOffset + 36, 0x60000020, "section characteristics");
+
+  const shiftedCliOffset = cli.offset >= expanded.insertionOffset ? cli.offset + expanded.delta : cli.offset;
+  if (metadataOffset !== null) {
+    const newMetadataRva = virtualAddress + metadataOffset;
+    writeU32(view, shiftedCliOffset + 8, newMetadataRva, "CLI metadata RVA");
+    writeU32(view, shiftedCliOffset + 12, metadataSize, "CLI metadata size");
+  }
+  if (resourcesDirectory) {
+    writeU32(view, shiftedCliOffset + 24, resourcesDirectory.rva, "CLI resources RVA");
+    writeU32(view, shiftedCliOffset + 28, resourcesDirectory.size, "CLI resources size");
+  }
+  if (!preserveStrongName && (cli.flags & 0x08) !== 0) {
+    const signature = cli.strongNameSignature;
+    if (signature.rva !== 0 && signature.size !== 0) {
+      const oldOffset = pe.rvaToOffset(signature.rva, signature.size);
+      const signatureOffset = oldOffset >= expanded.insertionOffset ? oldOffset + expanded.delta : oldOffset;
+      output.fill(0, signatureOffset, signatureOffset + signature.size);
+    }
+    writeU32(view, shiftedCliOffset + 16, cli.flags & ~0x08, "CLI flags");
+    writeU32(view, shiftedCliOffset + 32, 0, "strong-name RVA");
+    writeU32(view, shiftedCliOffset + 36, 0, "strong-name size");
+  }
+  if (debugDirectoryPayload) {
+    const directoryBase = pe.optionalHeaderOffset +
+      (pe.optionalHeaderMagic === 0x10b ? 96 : 112);
+    const directoryField = directoryBase + 6 * 8;
+    if (directoryField + 8 > pe.optionalHeaderOffset + pe.optionalHeaderSize) {
+      throw new UnsupportedFormatError("PE optional header has no debug data-directory slot");
+    }
+    writeU32(
+      view,
+      directoryField,
+      virtualAddress + debugDirectoryPayload.tableOffset,
+      "debug directory RVA"
+    );
+    writeU32(view, directoryField + 4, debugDirectoryPayload.size, "debug directory size");
+    for (const entry of debugDirectoryPayload.preservedEntries) {
+      const pointer = entry.pointer >= expanded.insertionOffset && entry.pointer !== 0
+        ? entry.pointer + expanded.delta
+        : entry.pointer;
+      writeU32(view, rawPointer + entry.pointerOffset, pointer, "debug record raw pointer");
+    }
+    for (const entry of debugDirectoryPayload.relocatedEntries) {
+      writeU32(
+        view,
+        rawPointer + entry.entryOffset + 16,
+        entry.size,
+        "debug record data size"
+      );
+      writeU32(
+        view,
+        rawPointer + entry.entryOffset + 20,
+        virtualAddress + entry.dataOffset,
+        "debug record data RVA"
+      );
+      writeU32(
+        view,
+        rawPointer + entry.entryOffset + 24,
+        rawPointer + entry.dataOffset,
+        "debug record raw pointer"
+      );
+    }
+  }
+  return {
+    bytes: output,
+    virtualAddress,
+    rawPointer,
+    rawSize,
+    headerExpansion: expanded.delta,
+    cliOffset: shiftedCliOffset
+  };
+}

package/src/writer/structural.js

@@ -0,0 +1,241 @@
+import { FormatError } from "../binary/errors.js";
+import { serializeMetadataRoot } from "../metadata/root-writer.js";
+import { serializeTablesStream } from "../metadata/writer.js";
+import { encodeMethodBody } from "../il/rewrite.js";
+import { appendPeSection, getNextSectionVirtualAddress } from "./pe.js";
+import { applyPatches } from "./patch.js";
+
+function align(value, alignment) {
+  return Math.ceil(value / alignment) * alignment;
+}
+
+function writeDebugDirectory(payload, tableOffset, assembly, replacements) {
+  const entries = assembly.pe.debugDirectoryEntries;
+  const tableSize = entries.length * 28;
+  const view = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
+  const preservedEntries = [];
+  const relocatedEntries = [];
+  let dataOffset = align(tableOffset + tableSize, 4);
+  for (let index = 0; index < entries.length; index++) {
+    const entry = entries[index];
+    const entryOffset = tableOffset + index * 28;
+    const replacementValue = replacements.get(index);
+    const replacement = replacementValue?.bytes ?? replacementValue;
+    view.setUint32(entryOffset, entry.characteristics, true);
+    view.setUint32(
+      entryOffset + 4,
+      replacementValue?.timeDateStamp ?? entry.timeDateStamp,
+      true
+    );
+    view.setUint16(entryOffset + 8, entry.majorVersion, true);
+    view.setUint16(entryOffset + 10, entry.minorVersion, true);
+    view.setUint32(entryOffset + 12, entry.type, true);
+    if (replacement) {
+      view.setUint32(entryOffset + 16, replacement.length, true);
+      relocatedEntries.push({
+        entryOffset,
+        dataOffset,
+        size: replacement.length
+      });
+      payload.set(replacement, dataOffset);
+      dataOffset = align(dataOffset + replacement.length, 4);
+    } else {
+      view.setUint32(entryOffset + 16, entry.sizeOfData, true);
+      view.setUint32(entryOffset + 20, entry.addressOfRawData, true);
+      view.setUint32(entryOffset + 24, entry.pointerToRawData, true);
+      if (entry.pointerToRawData !== 0) {
+        preservedEntries.push({
+          pointerOffset: entryOffset + 24,
+          pointer: entry.pointerToRawData
+        });
+      }
+    }
+  }
+  return {
+    size: tableSize,
+    preservedEntries,
+    relocatedEntries,
+    endOffset: dataOffset
+  };
+}
+
+function cloneTables(tables) {
+  const rows = new Map();
+  for (const [id, tableRows] of tables.rows) {
+    rows.set(id, tableRows.map((row) => {
+      const copy = { ...row };
+      for (const [key, value] of Object.entries(copy)) {
+        if (value && typeof value === "object") {
+          copy[key] = value.target !== undefined
+            ? { ...value, target: value.target ? { ...value.target } : null }
+            : { ...value };
+        }
+      }
+      return copy;
+    }));
+  }
+  return { ...tables, rows, counts: [...tables.counts] };
+}
+
+function getHeapStreams(assembly) {
+  if (assembly._heapStreams) {
+    return new Map([...assembly._heapStreams].map(([name, bytes]) => [name, bytes.slice()]));
+  }
+  return new Map([...assembly.metadataRoot.streams].map(([name, stream]) => [name, stream.bytes.slice()]));
+}
+
+function buildMetadata(assembly, tables, heapStreams, tableStreamName) {
+  const streams = new Map(heapStreams);
+  streams.set(tableStreamName, serializeTablesStream(tables, heapStreams));
+  return serializeMetadataRoot(assembly.metadataRoot, streams);
+}
+
+function buildResourcePayload(assembly, tables) {
+  if (assembly._resourceEdits.size === 0) return null;
+  const rows = tables.rows.get(40) ?? [];
+  const entries = [];
+  let size = 0;
+  for (const resource of assembly.resources) {
+    if (resource.implementation !== null) continue;
+    const data = assembly._resourceEdits.get(resource.rid) ?? resource.data;
+    if (!(data instanceof Uint8Array)) {
+      throw new FormatError(`Embedded ManifestResource row ${resource.rid} has no payload`);
+    }
+    const offset = align(size, 8);
+    if (offset > 0xffffffff) throw new RangeError("Manifest resource offset exceeds 32-bit range");
+    const row = rows[resource.rid - 1];
+    if (!row || row.rid !== resource.rid) {
+      throw new FormatError(`ManifestResource row ${resource.rid} is missing from the metadata tables`);
+    }
+    row.Offset = offset;
+    if (data.length > 0xffffffff) throw new RangeError("Manifest resource exceeds the CLI size limit");
+    entries.push({ offset, data });
+    size = offset + 4 + data.length;
+    if (size > 0xffffffff) throw new RangeError("CLI resources directory exceeds 32-bit range");
+  }
+  if (entries.length === 0) throw new FormatError("No embedded resources are available for replacement");
+  const output = new Uint8Array(size);
+  const view = new DataView(output.buffer);
+  for (const entry of entries) {
+    view.setUint32(entry.offset, entry.data.length, true);
+    output.set(entry.data, entry.offset + 4);
+  }
+  return output;
+}
+
+export function serializeStructural(
+  assembly,
+  { preserveStrongName = false, strongNameSignatureSize = 0 } = {}
+) {
+  const source = applyPatches(assembly.bytes, assembly._patches, assembly.cli, assembly.pe, {
+    preserveStrongName
+  });
+  const tables = cloneTables(assembly.tables);
+  const heapStreams = getHeapStreams(assembly);
+  const tableStreamName = assembly.metadataRoot.streams.has("#~") ? "#~" : "#-";
+  let metadata = buildMetadata(assembly, tables, heapStreams, tableStreamName);
+  const virtualAddress = getNextSectionVirtualAddress(assembly.pe);
+  let bodyOffset = align(metadata.length, 4);
+  const encodedBodies = [];
+  const bodies = new Map(assembly._addedMethodBodies ?? []);
+  for (const [methodRid, state] of assembly._structuralBodies) bodies.set(methodRid, state);
+  for (const [methodRid, state] of [...bodies].sort(([left], [right]) => left - right)) {
+    const methodRow = tables.rows.get(6)?.[methodRid - 1];
+    if (!methodRow) throw new FormatError(`MethodDef row ${methodRid} is missing from the metadata tables`);
+    const methodRva = virtualAddress + bodyOffset;
+    if (methodRva > 0xffffffff) throw new RangeError("Rewritten method RVA exceeds 32-bit range");
+    const bytes = state instanceof Uint8Array
+      ? state
+      : encodeMethodBody(state, methodRva);
+    methodRow.RVA = methodRva;
+    encodedBodies.push({ offset: bodyOffset, bytes });
+    bodyOffset = align(bodyOffset + bytes.length, 4);
+  }
+  const resourcePayload = buildResourcePayload(assembly, tables);
+  const resourceOffset = resourcePayload ? align(bodyOffset, 8) : 0;
+  const resourceEnd = resourcePayload ? resourceOffset + resourcePayload.length : bodyOffset;
+  const signatureOffset = strongNameSignatureSize > 0 ? align(resourceEnd, 4) : 0;
+  const signatureEnd = strongNameSignatureSize > 0
+    ? signatureOffset + strongNameSignatureSize
+    : resourceEnd;
+  const hasDebugEdits = (assembly._embeddedPortablePdbEdits?.size ?? 0) > 0;
+  const debugTableOffset = hasDebugEdits ? align(signatureEnd, 4) : 0;
+  const debugTableSize = hasDebugEdits
+    ? assembly.pe.debugDirectoryEntries.length * 28
+    : 0;
+  const debugDataStart = hasDebugEdits
+    ? align(debugTableOffset + debugTableSize, 4)
+    : 0;
+  const debugRecordEdits = new Map(assembly._embeddedPortablePdbEdits ?? []);
+  for (const [index, edit] of assembly._debugRecordEdits ?? []) {
+    debugRecordEdits.set(index, edit);
+  }
+  let finalPayloadSize = hasDebugEdits ? debugDataStart : signatureEnd;
+  if (hasDebugEdits) {
+    for (const [index, replacementValue] of [...debugRecordEdits].sort(
+      ([left], [right]) => left - right
+    )) {
+      if (!assembly.pe.debugDirectoryEntries[index]) {
+        throw new FormatError(`Debug-directory entry ${index} is missing`);
+      }
+      const replacement = replacementValue?.bytes ?? replacementValue;
+      finalPayloadSize = align(finalPayloadSize, 4) + replacement.length;
+    }
+  }
+  const rewrittenMetadata = buildMetadata(assembly, tables, heapStreams, tableStreamName);
+  if (rewrittenMetadata.length !== metadata.length) {
+    throw new FormatError("Metadata size changed while assigning method RVAs");
+  }
+  metadata = rewrittenMetadata;
+
+  const payload = new Uint8Array(finalPayloadSize);
+  payload.set(metadata);
+  for (const body of encodedBodies) payload.set(body.bytes, body.offset);
+  if (resourcePayload) payload.set(resourcePayload, resourceOffset);
+  let debugDirectoryPayload = null;
+  if (hasDebugEdits) {
+    debugDirectoryPayload = writeDebugDirectory(
+      payload,
+      debugTableOffset,
+      assembly,
+      debugRecordEdits
+    );
+  }
+  const resourcesDirectory = resourcePayload
+    ? { rva: virtualAddress + resourceOffset, size: resourcePayload.length }
+    : assembly._clearResourcesDirectory
+      ? { rva: 0, size: 0 }
+      : null;
+  const appended = appendPeSection(
+    source,
+    assembly.pe,
+    assembly.cli,
+    payload,
+    0,
+    metadata.length,
+    resourcesDirectory,
+    preserveStrongName,
+    hasDebugEdits
+      ? {
+        tableOffset: debugTableOffset,
+        size: debugDirectoryPayload.size,
+        preservedEntries: debugDirectoryPayload.preservedEntries,
+        relocatedEntries: debugDirectoryPayload.relocatedEntries
+      }
+      : null
+  );
+  if (strongNameSignatureSize > 0) {
+    const signatureRva = virtualAddress + signatureOffset;
+    if (signatureRva > 0xffffffff) throw new RangeError("Strong-name signature RVA exceeds 32-bit range");
+    const view = new DataView(
+      appended.bytes.buffer,
+      appended.bytes.byteOffset,
+      appended.bytes.byteLength
+    );
+    const directoryOffset = appended.cliOffset +
+      assembly.cli.strongNameDirectoryOffset - assembly.cli.offset;
+    view.setUint32(directoryOffset, signatureRva, true);
+    view.setUint32(directoryOffset + 4, strongNameSignatureSize, true);
+  }
+  return appended.bytes;
+}