rea-agents 3.2.1 → 4.0.0

package/dist/dotnet/ManagedMemberInstructionDecoder.js

@@ -379,49 +379,66 @@ export const decodeInstructions = (il) => {
     return { parsed, count: parsed.length, truncated, issue };
 };
 export const parseExceptionRegions = (bytes, offset, methodEnd) => {
-    if (offset >= methodEnd)
-        return [];
-    const kind = bytes.readUInt8(offset);
-    if ((kind & 0x3f) !== 1)
-        return [];
-    const fat = (kind & 0x40) !== 0;
-    const size = fat
-        ? bytes.readUInt32LE(offset) >>> 8
-        : bytes.readUInt8(offset + 1);
-    const start = fat ? offset + 4 : offset + 4;
-    const clauseSize = fat ? 24 : 12;
-    if (size < 4 || offset > methodEnd - size)
-        return [];
-    const count = Math.floor((size - 4) / clauseSize);
     const regions = [];
+    let sectionOffset = offset;
+    let hasMoreSections = true;
+    while (hasMoreSections) {
+        if (!Number.isSafeInteger(sectionOffset) ||
+            sectionOffset < 0 ||
+            sectionOffset > methodEnd - 4 ||
+            sectionOffset > bytes.length - 4)
+            return malformedExceptionRegions("Exception section header leaves artifact");
+        const kind = bytes.readUInt8(sectionOffset);
+        if ((kind & 0x3f) !== 1)
+            return malformedExceptionRegions(`Unsupported method data section kind ${String(kind & 0x3f)}`);
+        const fat = (kind & 0x40) !== 0;
+        const size = fat
+            ? bytes.readUInt8(sectionOffset + 1) |
+                (bytes.readUInt8(sectionOffset + 2) << 8) |
+                (bytes.readUInt8(sectionOffset + 3) << 16)
+            : bytes.readUInt8(sectionOffset + 1);
+        const clauseSize = fat ? 24 : 12;
+        if (size < 4 ||
+            sectionOffset > methodEnd - size ||
+            sectionOffset > bytes.length - size)
+            return malformedExceptionRegions("Exception section size leaves artifact");
+        if ((size - 4) % clauseSize !== 0)
+            return malformedExceptionRegions("Exception section size does not contain whole clauses");
+        if (!fat &&
+            (bytes[sectionOffset + 2] !== 0 || bytes[sectionOffset + 3] !== 0))
+            return malformedExceptionRegions("Small exception section reserved bytes are nonzero");
+        const count = (size - 4) / clauseSize;
+        regions.push(...readExceptionClauses(bytes, sectionOffset + 4, count, fat));
+        hasMoreSections = (kind & 0x80) !== 0;
+        sectionOffset += size;
+    }
+    return { status: "complete", regions };
+};
+const malformedExceptionRegions = (issue) => ({ status: "malformed", regions: [], issue });
+const readExceptionClauses = (bytes, start, count, fat) => {
+    const regions = [];
+    const clauseSize = fat ? 24 : 12;
     for (let index = 0; index < count; index += 1) {
         const clause = start + index * clauseSize;
-        if (fat) {
-            const flags = bytes.readUInt32LE(clause);
-            const extra = bytes.readUInt32LE(clause + 20);
-            regions.push({
-                flags,
-                try_offset: bytes.readUInt32LE(clause + 4),
-                try_length: bytes.readUInt32LE(clause + 8),
-                handler_offset: bytes.readUInt32LE(clause + 12),
-                handler_length: bytes.readUInt32LE(clause + 16),
-                class_token: flags === 0 ? `0x${extra.toString(16).padStart(8, "0")}` : null,
-                filter_offset: flags === 1 ? extra : null,
-            });
-        }
-        else {
-            const flags = bytes.readUInt16LE(clause);
-            const extra = bytes.readUInt32LE(clause + 8);
-            regions.push({
-                flags,
-                try_offset: bytes.readUInt16LE(clause + 2),
-                try_length: bytes.readUInt8(clause + 4),
-                handler_offset: bytes.readUInt16LE(clause + 5),
-                handler_length: bytes.readUInt8(clause + 7),
-                class_token: flags === 0 ? `0x${extra.toString(16).padStart(8, "0")}` : null,
-                filter_offset: flags === 1 ? extra : null,
-            });
-        }
+        const flags = fat ? bytes.readUInt32LE(clause) : bytes.readUInt16LE(clause);
+        const extra = bytes.readUInt32LE(clause + (fat ? 20 : 8));
+        regions.push({
+            flags,
+            try_offset: fat
+                ? bytes.readUInt32LE(clause + 4)
+                : bytes.readUInt16LE(clause + 2),
+            try_length: fat
+                ? bytes.readUInt32LE(clause + 8)
+                : bytes.readUInt8(clause + 4),
+            handler_offset: fat
+                ? bytes.readUInt32LE(clause + 12)
+                : bytes.readUInt16LE(clause + 5),
+            handler_length: fat
+                ? bytes.readUInt32LE(clause + 16)
+                : bytes.readUInt8(clause + 7),
+            class_token: flags === 0 ? `0x${extra.toString(16).padStart(8, "0")}` : null,
+            filter_offset: flags === 1 ? extra : null,
+        });
     }
     return regions;
 };

package/dist/dotnet/ManagedMemberRows.js

@@ -88,6 +88,8 @@ export const edges = (methods, methodCore, fieldCore, refCore) => {
     const fieldAccesses = [];
     for (const method of methods) {
         for (const anchor of method.body.anchors) {
+            if (anchor.opcode === "ldtoken")
+                continue;
             if (anchor.operand_kind === "method" && anchor.operand !== null) {
                 const named = methodCore.get(anchor.operand)?.name ??
                     refCore.get(anchor.operand)?.name ??

package/dist/dotnet/ManagedMethodBodyReader.js

@@ -1,5 +1,12 @@
 import { decodeInstructions, parseExceptionRegions, } from "./ManagedMemberInstructionDecoder.js";
 import { sha256Bytes } from "./ManagedMetadataHeaps.js";
+const bodyStatus = (decodedIssue, truncatedInstructions, exceptionRegions) => {
+    if (decodedIssue !== null || exceptionRegions?.status === "malformed")
+        return "malformed";
+    if (truncatedInstructions > 0)
+        return "partial";
+    return "present";
+};
 const readMethodBodyHeader = (bytes, offset) => {
     const first = bytes.readUInt8(offset);
     if ((first & 3) === 2)
@@ -61,11 +68,10 @@ export const methodBody = (bytes, pe, rva) => {
         ])), "utf8");
         const methodEnd = ilOffset + header.ilSize;
         const sectionOffset = (methodEnd + 3) & ~3;
-        const status = decoded.issue !== null
-            ? "malformed"
-            : decoded.truncated > 0
-                ? "partial"
-                : "present";
+        const exceptionRegions = header.format === "fat" && (header.flags & 8) !== 0
+            ? parseExceptionRegions(bytes, sectionOffset, bytes.length)
+            : null;
+        const status = bodyStatus(decoded.issue, decoded.truncated, exceptionRegions);
         return {
             status,
             header_format: header.format,
@@ -84,10 +90,11 @@ export const methodBody = (bytes, pe, rva) => {
             truncated_instructions: decoded.truncated,
             opcode_counts: opcodeCounts,
             anchors,
-            exception_regions: header.format === "fat" && (header.flags & 8) !== 0
-                ? parseExceptionRegions(bytes, sectionOffset, bytes.length)
-                : [],
+            exception_regions: exceptionRegions?.regions ?? [],
             issue: decoded.issue ??
+                (exceptionRegions?.status === "malformed"
+                    ? exceptionRegions.issue
+                    : null) ??
                 (decoded.truncated > 0
                     ? "Instruction decoding stopped before the end of the method body"
                     : null),

package/dist/dotnet/ManagedPeReader.js

@@ -20,6 +20,8 @@ const architectureFor = (machine) => {
         case 0x8664:
             return "x86_64";
         case 0x01c0:
+        case 0x01c2:
+        case 0x01c4:
             return "arm";
         case 0xaa64:
             return "arm64";