rea-agents 2.0.0 → 2.2.0

package/dist/dotnet/ManagedMetadataLayout.js

@@ -1,4 +1,5 @@
 import { managedFailure } from "./ManagedReaderFailure.js";
+import { computeRowSize, } from "./ManagedMetadataRowSizes.js";
 export const METADATA_TABLE_NAMES = [
     "Module",
     "TypeRef",
@@ -114,110 +115,7 @@ const codedSize = (name, rowCounts) => {
     return maximum < 2 ** (16 - descriptor.bits) ? 2 : 4;
 };
 const tableSize = (index, rows) => (rows[index] ?? 0) < 0x1_0000 ? 2 : 4;
-const rowSize = (table, rowCounts, heaps) => {
-    const t = (index) => tableSize(index, rowCounts);
-    const c = (name) => codedSize(name, rowCounts);
-    const { string: s, guid: g, blob: b } = heaps;
-    switch (table) {
-        case 0:
-            return 2 + s + g * 3;
-        case 1:
-            return c("ResolutionScope") + s * 2;
-        case 2:
-            return 4 + s * 2 + c("TypeDefOrRef") + t(4) + t(6);
-        case 3:
-            return t(4);
-        case 4:
-            return 2 + s + b;
-        case 5:
-            return t(6);
-        case 6:
-            return 8 + s + b + t(8);
-        case 7:
-            return t(8);
-        case 8:
-            return 4 + s;
-        case 9:
-            return t(2) + c("TypeDefOrRef");
-        case 10:
-            return c("MemberRefParent") + s + b;
-        case 11:
-            return 2 + c("HasConstant") + b;
-        case 12:
-            return c("HasCustomAttribute") + c("CustomAttributeType") + b;
-        case 13:
-            return c("HasFieldMarshal") + b;
-        case 14:
-            return 2 + c("HasDeclSecurity") + b;
-        case 15:
-            return 6 + t(2);
-        case 16:
-            return 4 + t(4);
-        case 17:
-            return b;
-        case 18:
-            return t(2) + t(20);
-        case 19:
-            return t(20);
-        case 20:
-            return 2 + s + c("TypeDefOrRef");
-        case 21:
-            return t(2) + t(23);
-        case 22:
-            return t(23);
-        case 23:
-            return 2 + s + b;
-        case 24:
-            return 2 + t(6) + c("HasSemantics");
-        case 25:
-            return t(2) + c("MethodDefOrRef") * 2;
-        case 26:
-            return s;
-        case 27:
-            return b;
-        case 28:
-            return 2 + c("MemberForwarded") + s + t(26);
-        case 29:
-            return 4 + t(4);
-        case 30:
-            return 8;
-        case 31:
-            return 4;
-        case 32:
-            return 16 + b + s * 2;
-        case 33:
-            return 4;
-        case 34:
-            return 12;
-        case 35:
-            return 12 + b * 2 + s * 2;
-        case 36:
-            return 4 + t(35);
-        case 37:
-            return 12 + t(35);
-        case 38:
-            return 4 + s + b;
-        case 39:
-            return 8 + s * 2 + c("Implementation");
-        case 40:
-            return 8 + s + c("Implementation");
-        case 41:
-            return t(2) * 2;
-        case 42:
-            return 4 + c("TypeOrMethodDef") + s;
-        case 43:
-            return c("MethodDefOrRef") + b;
-        case 44:
-            return t(42) + c("TypeDefOrRef");
-        default:
-            throw managedFailure("invalid-tables", "metadata.tables", `Metadata table ${String(table)} is unsupported`);
-    }
-};
-/** Parse ECMA-335 stream and table layout with checked byte extents. */
-export const readManagedMetadataLayout = (artifact, rootOffset, size, maxTableRows) => {
-    if (size < 20 || rootOffset < 0 || rootOffset > artifact.length - size)
-        throw managedFailure("invalid-metadata-root", "metadata.root", "CLI metadata directory leaves the artifact byte range", rootOffset);
-    const bytes = artifact.subarray(rootOffset, rootOffset + size);
+const readMetadataStreams = (bytes, rootOffset) => {
     if (bytes.readUInt32LE(0) !== 0x424a_5342)
         throw managedFailure("invalid-metadata-root", "metadata.signature", "CLI metadata signature is not BSJB", rootOffset);
     const versionLength = bytes.readUInt32LE(12);
@@ -249,10 +147,13 @@ export const readManagedMetadataLayout = (artifact, rootOffset, size, maxTableRo
         });
         cursor = named.next;
     }
+    return { streams, version };
+};
+const readTablesHeader = (bytes, streams) => {
     const tablesStream = streamByName(streams, ["#~", "#-"]);
     if (tablesStream === undefined)
         throw managedFailure("missing-stream", "metadata.tables", "Required metadata table stream #~ or #- is absent");
-    const tableBytes = artifact.subarray(tablesStream.offset, tablesStream.offset + tablesStream.size);
+    const tableBytes = bytes.subarray(tablesStream.offset, tablesStream.offset + tablesStream.size);
     requireRange(tableBytes, 0, 24, "metadata.tables-header");
     const heapSizes = tableBytes[6] ?? 0;
     const heaps = {
@@ -263,6 +164,9 @@ export const readManagedMetadataLayout = (artifact, rootOffset, size, maxTableRo
     const valid = tableBytes.readBigUInt64LE(8);
     if ((valid & ~SUPPORTED_TABLE_MASK) !== 0n)
         throw managedFailure("invalid-tables", "metadata.valid-mask", "Metadata valid mask names unsupported tables outside the admitted ECMA-335 range", tablesStream.offset + 8);
+    return { tableBytes, tablesOffset: tablesStream.offset, heaps, valid };
+};
+const readRowCounts = (tableBytes, valid, maxTableRows, tablesOffset) => {
     const rowCounts = Array(METADATA_TABLE_NAMES.length).fill(0);
     let tableCursor = 24;
     for (let index = 0; index < METADATA_TABLE_NAMES.length; index += 1) {
@@ -271,30 +175,64 @@ export const readManagedMetadataLayout = (artifact, rootOffset, size, maxTableRo
         requireRange(tableBytes, tableCursor, 4, "metadata.table-row-count");
         const count = tableBytes.readUInt32LE(tableCursor);
         if (count > maxTableRows)
-            throw managedFailure("limit-exceeded", `metadata.${METADATA_TABLE_NAMES[index] ?? String(index)}`, `Metadata table row count ${String(count)} exceeds max_table_rows ${String(maxTableRows)}`, tablesStream.offset + tableCursor);
+            throw managedFailure("limit-exceeded", `metadata.${METADATA_TABLE_NAMES[index] ?? String(index)}`, `Metadata table row count ${String(count)} exceeds max_table_rows ${String(maxTableRows)}`, tablesOffset + tableCursor);
         rowCounts[index] = count;
         tableCursor += 4;
     }
+    return rowCounts;
+};
+const buildRowSizeContext = (rowCounts, heaps) => ({
+    tableSize: (index) => tableSize(index, rowCounts),
+    codedSize: (name) => codedSize(name, rowCounts),
+    stringSize: heaps.string,
+    guidSize: heaps.guid,
+    blobSize: heaps.blob,
+});
+const buildMetadataTables = ({ tableBytes, rowCounts, heaps, valid, tablesOffset, }) => {
     const tables = new Map();
+    const context = buildRowSizeContext(rowCounts, heaps);
+    let tableCursor = 24;
+    for (let index = 0; index < METADATA_TABLE_NAMES.length; index += 1) {
+        if ((valid & (1n << BigInt(index))) === 0n)
+            continue;
+        tableCursor += 4;
+    }
     for (let index = 0; index < METADATA_TABLE_NAMES.length; index += 1) {
         const count = rowCounts[index] ?? 0;
         if ((valid & (1n << BigInt(index))) === 0n)
             continue;
-        const sizeOfRow = rowSize(index, rowCounts, heaps);
+        const sizeOfRow = computeRowSize(index, context);
         const byteLength = count * sizeOfRow;
         if (!Number.isSafeInteger(byteLength))
-            throw managedFailure("invalid-tables", "metadata.tables", "Metadata table byte size overflowed", tablesStream.offset + tableCursor);
+            throw managedFailure("invalid-tables", "metadata.tables", "Metadata table byte size overflowed", tablesOffset + tableCursor);
         requireRange(tableBytes, tableCursor, byteLength, "metadata.table-data");
         tables.set(index, {
             index,
             name: METADATA_TABLE_NAMES[index] ?? `Table${String(index)}`,
             rowCount: count,
             rowSize: sizeOfRow,
-            offset: tablesStream.offset + tableCursor,
+            offset: tablesOffset + tableCursor,
         });
         tableCursor += byteLength;
     }
-    const layout = {
+    return tables;
+};
+/** Parse ECMA-335 stream and table layout with checked byte extents. */
+export const readManagedMetadataLayout = (artifact, rootOffset, size, maxTableRows) => {
+    if (size < 20 || rootOffset < 0 || rootOffset > artifact.length - size)
+        throw managedFailure("invalid-metadata-root", "metadata.root", "CLI metadata directory leaves the artifact byte range", rootOffset);
+    const bytes = artifact.subarray(rootOffset, rootOffset + size);
+    const { streams, version } = readMetadataStreams(bytes, rootOffset);
+    const { tableBytes, tablesOffset, heaps, valid } = readTablesHeader(artifact, streams);
+    const rowCounts = readRowCounts(tableBytes, valid, maxTableRows, tablesOffset);
+    const tables = buildMetadataTables({
+        tableBytes,
+        rowCounts,
+        heaps,
+        valid,
+        tablesOffset,
+    });
+    return {
         rootOffset,
         size,
         version,
@@ -311,7 +249,6 @@ export const readManagedMetadataLayout = (artifact, rootOffset, size, maxTableRo
         tableIndexSize: (index) => tableSize(index, rowCounts),
         codedIndexSize: (name) => codedSize(name, rowCounts),
     };
-    return layout;
 };
 /** Resolve a one-based metadata row to its exact file offset. */
 export const metadataRowOffset = (layout, table, row) => {

package/dist/dotnet/ManagedMetadataRowSizes.js

@@ -0,0 +1,54 @@
+import { managedFailure } from "./ManagedReaderFailure.js";
+const ROW_SIZE_FACTORIES = [
+    ({ stringSize: s, guidSize: g }) => 2 + s + g * 3,
+    ({ codedSize: c, stringSize: s }) => c("ResolutionScope") + s * 2,
+    ({ tableSize: t, codedSize: c, stringSize: s }) => 4 + s * 2 + c("TypeDefOrRef") + t(4) + t(6),
+    ({ tableSize: t }) => t(4),
+    ({ stringSize: s, blobSize: b }) => 2 + s + b,
+    ({ tableSize: t }) => t(6),
+    ({ tableSize: t, stringSize: s, blobSize: b }) => 8 + s + b + t(8),
+    ({ tableSize: t }) => t(8),
+    ({ stringSize: s }) => 4 + s,
+    ({ tableSize: t, codedSize: c }) => t(2) + c("TypeDefOrRef"),
+    ({ codedSize: c, stringSize: s, blobSize: b }) => c("MemberRefParent") + s + b,
+    ({ codedSize: c, blobSize: b }) => 2 + c("HasConstant") + b,
+    ({ codedSize: c, blobSize: b }) => c("HasCustomAttribute") + c("CustomAttributeType") + b,
+    ({ codedSize: c, blobSize: b }) => c("HasFieldMarshal") + b,
+    ({ codedSize: c, blobSize: b }) => 2 + c("HasDeclSecurity") + b,
+    ({ tableSize: t }) => 6 + t(2),
+    ({ tableSize: t }) => 4 + t(4),
+    ({ blobSize: b }) => b,
+    ({ tableSize: t }) => t(2) + t(20),
+    ({ tableSize: t }) => t(20),
+    ({ stringSize: s, codedSize: c }) => 2 + s + c("TypeDefOrRef"),
+    ({ tableSize: t }) => t(2) + t(23),
+    ({ tableSize: t }) => t(23),
+    ({ stringSize: s, blobSize: b }) => 2 + s + b,
+    ({ tableSize: t, codedSize: c }) => 2 + t(6) + c("HasSemantics"),
+    ({ tableSize: t, codedSize: c }) => t(2) + c("MethodDefOrRef") * 2,
+    ({ stringSize: s }) => s,
+    ({ blobSize: b }) => b,
+    ({ tableSize: t, codedSize: c, stringSize: s }) => 2 + c("MemberForwarded") + s + t(26),
+    ({ tableSize: t }) => 4 + t(4),
+    () => 8,
+    () => 4,
+    ({ blobSize: b, stringSize: s }) => 16 + b + s * 2,
+    () => 4,
+    () => 12,
+    ({ blobSize: b, stringSize: s }) => 12 + b * 2 + s * 2,
+    ({ tableSize: t }) => 4 + t(35),
+    ({ tableSize: t }) => 12 + t(35),
+    ({ stringSize: s, blobSize: b }) => 4 + s + b,
+    ({ stringSize: s, codedSize: c }) => 8 + s * 2 + c("Implementation"),
+    ({ stringSize: s, codedSize: c }) => 8 + s + c("Implementation"),
+    ({ tableSize: t }) => t(2) * 2,
+    ({ stringSize: s, codedSize: c }) => 4 + c("TypeOrMethodDef") + s,
+    ({ codedSize: c, blobSize: b }) => c("MethodDefOrRef") + b,
+    ({ tableSize: t, codedSize: c }) => t(42) + c("TypeDefOrRef"),
+];
+export const computeRowSize = (table, context) => {
+    const factory = ROW_SIZE_FACTORIES[table];
+    if (factory === undefined)
+        throw managedFailure("invalid-tables", "metadata.tables", `Metadata table ${String(table)} is unsupported`);
+    return factory(context);
+};

package/dist/dotnet/ManagedMethodBodyReader.js

@@ -0,0 +1,143 @@
+import { decodeInstructions, parseExceptionRegions, } from "./ManagedMemberInstructionDecoder.js";
+import { sha256Bytes } from "./ManagedMetadataHeaps.js";
+const readMethodBodyHeader = (bytes, offset) => {
+    const first = bytes.readUInt8(offset);
+    if ((first & 3) === 2)
+        return {
+            format: "tiny",
+            size: 1,
+            flags: 0,
+            maxStack: 8,
+            ilSize: first >> 2,
+            localSig: 0,
+        };
+    if ((first & 3) !== 3)
+        throw new RangeError("Unsupported method body header");
+    if (offset > bytes.length - 12)
+        throw new RangeError("Fat method body header leaves artifact");
+    const flagsAndSize = bytes.readUInt16LE(offset);
+    const headerDwords = flagsAndSize >>> 12;
+    if (headerDwords < 3)
+        throw new RangeError("Fat method body header is smaller than 12 bytes");
+    const size = headerDwords * 4;
+    if (offset > bytes.length - size)
+        throw new RangeError("Method body header leaves artifact");
+    return {
+        format: "fat",
+        size,
+        flags: flagsAndSize & 0x0fff,
+        maxStack: bytes.readUInt16LE(offset + 2),
+        ilSize: bytes.readUInt32LE(offset + 4),
+        localSig: bytes.readUInt32LE(offset + 8),
+    };
+};
+export const methodBody = (bytes, pe, rva, limits) => {
+    if (rva === 0)
+        return emptyMethodBody(rva, "absent", null);
+    try {
+        const offset = pe.rvaToOffset(rva, 1, "method.body");
+        const header = readMethodBodyHeader(bytes, offset);
+        if (header.ilSize > limits.maxMethodBodyBytes)
+            return oversizedMethodBody(header, rva, offset, limits);
+        const ilOffset = offset + header.size;
+        if (ilOffset > bytes.length - header.ilSize)
+            throw new RangeError("Method IL bytes leave artifact");
+        const il = bytes.subarray(ilOffset, ilOffset + header.ilSize);
+        const decoded = decodeInstructions(il, limits.maxMethodInstructions);
+        const opcodeCounts = {};
+        for (const instruction of decoded.parsed)
+            opcodeCounts[instruction.opcode] =
+                (opcodeCounts[instruction.opcode] ?? 0) + 1;
+        const anchors = decoded.parsed
+            .map((instruction, index) => ({ instruction, index }))
+            .filter(({ instruction }) => instruction.operandKind !== "none")
+            .slice(0, limits.instructionAnchorLimit)
+            .map(({ instruction }) => ({
+            il_offset: instruction.offset,
+            opcode: instruction.opcode,
+            operand_kind: instruction.operandKind,
+            operand: instruction.operand,
+        }));
+        const normalized = Buffer.from(JSON.stringify(decoded.parsed.map(({ opcode, operandKind, operand }) => [
+            opcode,
+            operandKind,
+            operand,
+        ])), "utf8");
+        const methodEnd = ilOffset + header.ilSize;
+        const sectionOffset = (methodEnd + 3) & ~3;
+        const status = decoded.issue !== null
+            ? "malformed"
+            : decoded.truncated > 0
+                ? "partial"
+                : "present";
+        return {
+            status,
+            header_format: header.format,
+            rva,
+            file_offset: offset,
+            max_stack: header.maxStack,
+            init_locals: (header.flags & 0x10) !== 0,
+            local_var_sig_token: header.localSig === 0
+                ? null
+                : `0x${header.localSig.toString(16).padStart(8, "0")}`,
+            il_size: header.ilSize,
+            il_sha256: sha256Bytes(il),
+            normalized_il_sha256: status === "present" ? sha256Bytes(normalized) : null,
+            instruction_count: decoded.count,
+            decoded_instruction_count: decoded.parsed.length,
+            truncated_instructions: decoded.truncated,
+            opcode_counts: opcodeCounts,
+            anchors,
+            exception_regions: header.format === "fat" && (header.flags & 8) !== 0
+                ? parseExceptionRegions(bytes, sectionOffset, bytes.length)
+                : [],
+            issue: decoded.issue ??
+                (decoded.truncated > 0
+                    ? `Instruction decode reached max_method_instructions ${String(limits.maxMethodInstructions)} before the end of the method body`
+                    : null),
+        };
+    }
+    catch (cause) {
+        return emptyMethodBody(rva, "malformed", cause instanceof Error ? cause.message : "Method body parse failed");
+    }
+};
+const emptyMethodBody = (rva, status, issue) => ({
+    status,
+    header_format: status === "absent" ? "none" : "unknown",
+    rva,
+    file_offset: null,
+    max_stack: null,
+    init_locals: null,
+    local_var_sig_token: null,
+    il_size: 0,
+    il_sha256: null,
+    normalized_il_sha256: null,
+    instruction_count: 0,
+    decoded_instruction_count: 0,
+    truncated_instructions: 0,
+    opcode_counts: {},
+    anchors: [],
+    exception_regions: [],
+    issue,
+});
+const oversizedMethodBody = (header, rva, offset, limits) => ({
+    status: "too-large",
+    header_format: header.format,
+    rva,
+    file_offset: offset,
+    max_stack: header.maxStack,
+    init_locals: (header.flags & 0x10) !== 0,
+    local_var_sig_token: header.localSig === 0
+        ? null
+        : `0x${header.localSig.toString(16).padStart(8, "0")}`,
+    il_size: header.ilSize,
+    il_sha256: null,
+    normalized_il_sha256: null,
+    instruction_count: 0,
+    decoded_instruction_count: 0,
+    truncated_instructions: 0,
+    opcode_counts: {},
+    anchors: [],
+    exception_regions: [],
+    issue: `Method body exceeds max_method_body_bytes ${String(limits.maxMethodBodyBytes)}`,
+});