* fix(managed): charge retained member facts instead of decoding bounds inspect_managed_members returned no types or methods for ordinary assemblies: Newtonsoft.Json 13.0.3 (netstandard2.0, 705 KB) exceeded the 64 MiB representation budget. Each method body reserved 256 bytes per IL byte and each signature 256 bytes per blob byte before decoding, and those worst-case bounds were never returned, so the budget scaled with total IL size rather than with the retained output. The final projection admission also charged every decoded string at six bytes per character and every scalar at 32 bytes, about eight times its JSON size. Bound IL, exception-clause and signature decoding with a transient admission that does not consume capacity, then reserve the decoded body or signature that is actually retained. Projection admission now charges the exact UTF-8 JSON bytes of decoded strings, keys and scalars; escaped and multibyte text still counts at its encoded size. Newtonsoft.Json now yields 496 types, 4185 methods and 18846 call edges. Assemblies whose retained facts exceed the budget, such as the 2.3 MB System.Private.ServiceModel 4.7.0, remain unavailable. * fix(managed): bound concurrent decoding and count JSON bytes in place Review follow-up. A method's IL bound and its exception-section bounds were each checked against the same remaining capacity although their bookkeeping is live at the same time, so 40 MiB of IL plus 40 MiB of exception clauses passed a 64 MiB budget. Transient admissions now accumulate until the method body or signature is built, and reserve respects bounds that are still live. Projection admission also serialized each decoded string to measure it, which could allocate about six times a near-limit string before the check. It now counts the exact escaped UTF-8 bytes without building the JSON text. * fix(managed): admit derived call and field edges as they are built Review follow-up. Released IL bounds no longer stand in for the call and field-access records that edges() derives from anchors. Each record is now admitted before the graph grows further, so a crafted assembly cannot materialize the whole derived graph before the representation guard fails. * fix(managed): admit derived caller names before building them Review follow-up. The caller name of call and field-access records was interpolated per anchor before any admission saw it. It is now built once per method, after its exact JSON size, counted from the type and member names, has been admitted.
557 lines
19 KiB
TypeScript
557 lines
19 KiB
TypeScript
import type { ManagedDecodeBudget } from "./ManagedDecodeBudget.js";
|
|
import type {
|
|
ManagedExceptionRegion,
|
|
ManagedInstructionAnchor,
|
|
ParsedInstruction,
|
|
} from "./ManagedMemberInspectorCore.js";
|
|
|
|
const PREFIX_OPCODES = new Set([
|
|
"unaligned.",
|
|
"volatile.",
|
|
"tail.",
|
|
"constrained.",
|
|
"readonly.",
|
|
]);
|
|
|
|
const OPCODES = new Map<
|
|
number,
|
|
{ readonly name: string; readonly operand: string }
|
|
>([
|
|
[0x00, { name: "nop", operand: "none" }],
|
|
[0x01, { name: "break", operand: "none" }],
|
|
[0x02, { name: "ldarg.0", operand: "none" }],
|
|
[0x03, { name: "ldarg.1", operand: "none" }],
|
|
[0x04, { name: "ldarg.2", operand: "none" }],
|
|
[0x05, { name: "ldarg.3", operand: "none" }],
|
|
[0x06, { name: "ldloc.0", operand: "none" }],
|
|
[0x07, { name: "ldloc.1", operand: "none" }],
|
|
[0x08, { name: "ldloc.2", operand: "none" }],
|
|
[0x09, { name: "ldloc.3", operand: "none" }],
|
|
[0x0a, { name: "stloc.0", operand: "none" }],
|
|
[0x0b, { name: "stloc.1", operand: "none" }],
|
|
[0x0c, { name: "stloc.2", operand: "none" }],
|
|
[0x0d, { name: "stloc.3", operand: "none" }],
|
|
[0x0e, { name: "ldarg.s", operand: "short-var" }],
|
|
[0x0f, { name: "ldarga.s", operand: "short-var" }],
|
|
[0x10, { name: "starg.s", operand: "short-var" }],
|
|
[0x11, { name: "ldloc.s", operand: "short-var" }],
|
|
[0x12, { name: "ldloca.s", operand: "short-var" }],
|
|
[0x13, { name: "stloc.s", operand: "short-var" }],
|
|
[0x14, { name: "ldnull", operand: "none" }],
|
|
[0x15, { name: "ldc.i4.m1", operand: "none" }],
|
|
[0x16, { name: "ldc.i4.0", operand: "none" }],
|
|
[0x17, { name: "ldc.i4.1", operand: "none" }],
|
|
[0x18, { name: "ldc.i4.2", operand: "none" }],
|
|
[0x19, { name: "ldc.i4.3", operand: "none" }],
|
|
[0x1a, { name: "ldc.i4.4", operand: "none" }],
|
|
[0x1b, { name: "ldc.i4.5", operand: "none" }],
|
|
[0x1c, { name: "ldc.i4.6", operand: "none" }],
|
|
[0x1d, { name: "ldc.i4.7", operand: "none" }],
|
|
[0x1e, { name: "ldc.i4.8", operand: "none" }],
|
|
[0x1f, { name: "ldc.i4.s", operand: "short-i" }],
|
|
[0x20, { name: "ldc.i4", operand: "i" }],
|
|
[0x21, { name: "ldc.i8", operand: "i8" }],
|
|
[0x22, { name: "ldc.r4", operand: "r4" }],
|
|
[0x23, { name: "ldc.r8", operand: "r8" }],
|
|
[0x25, { name: "dup", operand: "none" }],
|
|
[0x26, { name: "pop", operand: "none" }],
|
|
[0x27, { name: "jmp", operand: "method" }],
|
|
[0x28, { name: "call", operand: "method" }],
|
|
[0x29, { name: "calli", operand: "signature" }],
|
|
[0x2a, { name: "ret", operand: "none" }],
|
|
[0x2b, { name: "br.s", operand: "short-branch" }],
|
|
[0x2c, { name: "brfalse.s", operand: "short-branch" }],
|
|
[0x2d, { name: "brtrue.s", operand: "short-branch" }],
|
|
[0x2e, { name: "beq.s", operand: "short-branch" }],
|
|
[0x2f, { name: "bge.s", operand: "short-branch" }],
|
|
[0x30, { name: "bgt.s", operand: "short-branch" }],
|
|
[0x31, { name: "ble.s", operand: "short-branch" }],
|
|
[0x32, { name: "blt.s", operand: "short-branch" }],
|
|
[0x33, { name: "bne.un.s", operand: "short-branch" }],
|
|
[0x34, { name: "bge.un.s", operand: "short-branch" }],
|
|
[0x35, { name: "bgt.un.s", operand: "short-branch" }],
|
|
[0x36, { name: "ble.un.s", operand: "short-branch" }],
|
|
[0x37, { name: "blt.un.s", operand: "short-branch" }],
|
|
[0x38, { name: "br", operand: "branch" }],
|
|
[0x39, { name: "brfalse", operand: "branch" }],
|
|
[0x3a, { name: "brtrue", operand: "branch" }],
|
|
[0x3b, { name: "beq", operand: "branch" }],
|
|
[0x3c, { name: "bge", operand: "branch" }],
|
|
[0x3d, { name: "bgt", operand: "branch" }],
|
|
[0x3e, { name: "ble", operand: "branch" }],
|
|
[0x3f, { name: "blt", operand: "branch" }],
|
|
[0x40, { name: "bne.un", operand: "branch" }],
|
|
[0x41, { name: "bge.un", operand: "branch" }],
|
|
[0x42, { name: "bgt.un", operand: "branch" }],
|
|
[0x43, { name: "ble.un", operand: "branch" }],
|
|
[0x44, { name: "blt.un", operand: "branch" }],
|
|
[0x45, { name: "switch", operand: "switch" }],
|
|
[0x46, { name: "ldind.i1", operand: "none" }],
|
|
[0x47, { name: "ldind.u1", operand: "none" }],
|
|
[0x48, { name: "ldind.i2", operand: "none" }],
|
|
[0x49, { name: "ldind.u2", operand: "none" }],
|
|
[0x4a, { name: "ldind.i4", operand: "none" }],
|
|
[0x4b, { name: "ldind.u4", operand: "none" }],
|
|
[0x4c, { name: "ldind.i8", operand: "none" }],
|
|
[0x4d, { name: "ldind.i", operand: "none" }],
|
|
[0x4e, { name: "ldind.r4", operand: "none" }],
|
|
[0x4f, { name: "ldind.r8", operand: "none" }],
|
|
[0x50, { name: "ldind.ref", operand: "none" }],
|
|
[0x51, { name: "stind.ref", operand: "none" }],
|
|
[0x52, { name: "stind.i1", operand: "none" }],
|
|
[0x53, { name: "stind.i2", operand: "none" }],
|
|
[0x54, { name: "stind.i4", operand: "none" }],
|
|
[0x55, { name: "stind.i8", operand: "none" }],
|
|
[0x56, { name: "stind.r4", operand: "none" }],
|
|
[0x57, { name: "stind.r8", operand: "none" }],
|
|
[0x58, { name: "add", operand: "none" }],
|
|
[0x59, { name: "sub", operand: "none" }],
|
|
[0x5a, { name: "mul", operand: "none" }],
|
|
[0x5b, { name: "div", operand: "none" }],
|
|
[0x5c, { name: "div.un", operand: "none" }],
|
|
[0x5d, { name: "rem", operand: "none" }],
|
|
[0x5e, { name: "rem.un", operand: "none" }],
|
|
[0x5f, { name: "and", operand: "none" }],
|
|
[0x60, { name: "or", operand: "none" }],
|
|
[0x61, { name: "xor", operand: "none" }],
|
|
[0x62, { name: "shl", operand: "none" }],
|
|
[0x63, { name: "shr", operand: "none" }],
|
|
[0x64, { name: "shr.un", operand: "none" }],
|
|
[0x65, { name: "neg", operand: "none" }],
|
|
[0x66, { name: "not", operand: "none" }],
|
|
[0x67, { name: "conv.i1", operand: "none" }],
|
|
[0x68, { name: "conv.i2", operand: "none" }],
|
|
[0x69, { name: "conv.i4", operand: "none" }],
|
|
[0x6a, { name: "conv.i8", operand: "none" }],
|
|
[0x6b, { name: "conv.r4", operand: "none" }],
|
|
[0x6c, { name: "conv.r8", operand: "none" }],
|
|
[0x6d, { name: "conv.u4", operand: "none" }],
|
|
[0x6e, { name: "conv.u8", operand: "none" }],
|
|
[0x6f, { name: "callvirt", operand: "method" }],
|
|
[0x70, { name: "cpobj", operand: "type" }],
|
|
[0x71, { name: "ldobj", operand: "type" }],
|
|
[0x72, { name: "ldstr", operand: "string" }],
|
|
[0x73, { name: "newobj", operand: "method" }],
|
|
[0x74, { name: "castclass", operand: "type" }],
|
|
[0x75, { name: "isinst", operand: "type" }],
|
|
[0x76, { name: "conv.r.un", operand: "none" }],
|
|
[0x79, { name: "unbox", operand: "type" }],
|
|
[0x7a, { name: "throw", operand: "none" }],
|
|
[0x7b, { name: "ldfld", operand: "field" }],
|
|
[0x7c, { name: "ldflda", operand: "field" }],
|
|
[0x7d, { name: "stfld", operand: "field" }],
|
|
[0x7e, { name: "ldsfld", operand: "field" }],
|
|
[0x7f, { name: "ldsflda", operand: "field" }],
|
|
[0x80, { name: "stsfld", operand: "field" }],
|
|
[0x81, { name: "stobj", operand: "type" }],
|
|
[0x82, { name: "conv.ovf.i1.un", operand: "none" }],
|
|
[0x83, { name: "conv.ovf.i2.un", operand: "none" }],
|
|
[0x84, { name: "conv.ovf.i4.un", operand: "none" }],
|
|
[0x85, { name: "conv.ovf.i8.un", operand: "none" }],
|
|
[0x86, { name: "conv.ovf.u1.un", operand: "none" }],
|
|
[0x87, { name: "conv.ovf.u2.un", operand: "none" }],
|
|
[0x88, { name: "conv.ovf.u4.un", operand: "none" }],
|
|
[0x89, { name: "conv.ovf.u8.un", operand: "none" }],
|
|
[0x8a, { name: "conv.ovf.i.un", operand: "none" }],
|
|
[0x8b, { name: "conv.ovf.u.un", operand: "none" }],
|
|
[0x8c, { name: "box", operand: "type" }],
|
|
[0x8d, { name: "newarr", operand: "type" }],
|
|
[0x8e, { name: "ldlen", operand: "none" }],
|
|
[0x8f, { name: "ldelema", operand: "type" }],
|
|
[0x90, { name: "ldelem.i1", operand: "none" }],
|
|
[0x91, { name: "ldelem.u1", operand: "none" }],
|
|
[0x92, { name: "ldelem.i2", operand: "none" }],
|
|
[0x93, { name: "ldelem.u2", operand: "none" }],
|
|
[0x94, { name: "ldelem.i4", operand: "none" }],
|
|
[0x95, { name: "ldelem.u4", operand: "none" }],
|
|
[0x96, { name: "ldelem.i8", operand: "none" }],
|
|
[0x97, { name: "ldelem.i", operand: "none" }],
|
|
[0x98, { name: "ldelem.r4", operand: "none" }],
|
|
[0x99, { name: "ldelem.r8", operand: "none" }],
|
|
[0x9a, { name: "ldelem.ref", operand: "none" }],
|
|
[0x9b, { name: "stelem.i", operand: "none" }],
|
|
[0x9c, { name: "stelem.i1", operand: "none" }],
|
|
[0x9d, { name: "stelem.i2", operand: "none" }],
|
|
[0x9e, { name: "stelem.i4", operand: "none" }],
|
|
[0x9f, { name: "stelem.i8", operand: "none" }],
|
|
[0xa0, { name: "stelem.r4", operand: "none" }],
|
|
[0xa1, { name: "stelem.r8", operand: "none" }],
|
|
[0xa2, { name: "stelem.ref", operand: "none" }],
|
|
[0xa3, { name: "ldelem", operand: "type" }],
|
|
[0xa4, { name: "stelem", operand: "type" }],
|
|
[0xa5, { name: "unbox.any", operand: "type" }],
|
|
[0xb3, { name: "conv.ovf.i1", operand: "none" }],
|
|
[0xb4, { name: "conv.ovf.u1", operand: "none" }],
|
|
[0xb5, { name: "conv.ovf.i2", operand: "none" }],
|
|
[0xb6, { name: "conv.ovf.u2", operand: "none" }],
|
|
[0xb7, { name: "conv.ovf.i4", operand: "none" }],
|
|
[0xb8, { name: "conv.ovf.u4", operand: "none" }],
|
|
[0xb9, { name: "conv.ovf.i8", operand: "none" }],
|
|
[0xba, { name: "conv.ovf.u8", operand: "none" }],
|
|
[0xc2, { name: "refanyval", operand: "type" }],
|
|
[0xc3, { name: "ckfinite", operand: "none" }],
|
|
[0xc6, { name: "mkrefany", operand: "type" }],
|
|
[0xd0, { name: "ldtoken", operand: "token" }],
|
|
[0xd1, { name: "conv.u2", operand: "none" }],
|
|
[0xd2, { name: "conv.u1", operand: "none" }],
|
|
[0xd3, { name: "conv.i", operand: "none" }],
|
|
[0xd4, { name: "conv.ovf.i", operand: "none" }],
|
|
[0xd5, { name: "conv.ovf.u", operand: "none" }],
|
|
[0xd6, { name: "add.ovf", operand: "none" }],
|
|
[0xd7, { name: "add.ovf.un", operand: "none" }],
|
|
[0xd8, { name: "mul.ovf", operand: "none" }],
|
|
[0xd9, { name: "mul.ovf.un", operand: "none" }],
|
|
[0xda, { name: "sub.ovf", operand: "none" }],
|
|
[0xdb, { name: "sub.ovf.un", operand: "none" }],
|
|
[0xdc, { name: "endfinally", operand: "none" }],
|
|
[0xdd, { name: "leave", operand: "branch" }],
|
|
[0xde, { name: "leave.s", operand: "short-branch" }],
|
|
[0xdf, { name: "stind.i", operand: "none" }],
|
|
[0xe0, { name: "conv.u", operand: "none" }],
|
|
[0xfe00, { name: "arglist", operand: "none" }],
|
|
[0xfe01, { name: "ceq", operand: "none" }],
|
|
[0xfe02, { name: "cgt", operand: "none" }],
|
|
[0xfe03, { name: "cgt.un", operand: "none" }],
|
|
[0xfe04, { name: "clt", operand: "none" }],
|
|
[0xfe05, { name: "clt.un", operand: "none" }],
|
|
[0xfe06, { name: "ldftn", operand: "method" }],
|
|
[0xfe07, { name: "ldvirtftn", operand: "method" }],
|
|
[0xfe09, { name: "ldarg", operand: "var" }],
|
|
[0xfe0a, { name: "ldarga", operand: "var" }],
|
|
[0xfe0b, { name: "starg", operand: "var" }],
|
|
[0xfe0c, { name: "ldloc", operand: "var" }],
|
|
[0xfe0d, { name: "ldloca", operand: "var" }],
|
|
[0xfe0e, { name: "stloc", operand: "var" }],
|
|
[0xfe0f, { name: "localloc", operand: "none" }],
|
|
[0xfe11, { name: "endfilter", operand: "none" }],
|
|
[0xfe12, { name: "unaligned.", operand: "short-i" }],
|
|
[0xfe13, { name: "volatile.", operand: "none" }],
|
|
[0xfe14, { name: "tail.", operand: "none" }],
|
|
[0xfe15, { name: "initobj", operand: "type" }],
|
|
[0xfe16, { name: "constrained.", operand: "type" }],
|
|
[0xfe17, { name: "cpblk", operand: "none" }],
|
|
[0xfe18, { name: "initblk", operand: "none" }],
|
|
[0xfe1a, { name: "rethrow", operand: "none" }],
|
|
[0xfe1c, { name: "sizeof", operand: "type" }],
|
|
[0xfe1d, { name: "refanytype", operand: "none" }],
|
|
[0xfe1e, { name: "readonly.", operand: "none" }],
|
|
]);
|
|
|
|
const tokenKind = (token: string): ManagedInstructionAnchor["operand_kind"] => {
|
|
if (
|
|
token.startsWith("0x06") ||
|
|
token.startsWith("0x0a") ||
|
|
token.startsWith("0x2b")
|
|
)
|
|
return "method";
|
|
if (token.startsWith("0x04")) return "field";
|
|
if (token.startsWith("0x70")) return "string";
|
|
if (token.startsWith("0x11")) return "signature";
|
|
if (
|
|
token.startsWith("0x01") ||
|
|
token.startsWith("0x02") ||
|
|
token.startsWith("0x1b")
|
|
)
|
|
return "type";
|
|
return "token";
|
|
};
|
|
|
|
type OperandResult = {
|
|
readonly next: number;
|
|
readonly anchorKind: ManagedInstructionAnchor["operand_kind"];
|
|
readonly value: string | null;
|
|
};
|
|
|
|
type OperandReader = (il: Buffer, offset: number) => OperandResult;
|
|
|
|
const FIXED_OPERAND_READERS = new Map<string, OperandReader>([
|
|
[
|
|
"none",
|
|
(_il, offset) => ({ next: offset, anchorKind: "none", value: null }),
|
|
],
|
|
[
|
|
"short-var",
|
|
(il, offset) => ({
|
|
next: offset + 1,
|
|
anchorKind: "variable",
|
|
value: String(il.readUInt8(offset)),
|
|
}),
|
|
],
|
|
[
|
|
"var",
|
|
(il, offset) => ({
|
|
next: offset + 2,
|
|
anchorKind: "variable",
|
|
value: String(il.readUInt16LE(offset)),
|
|
}),
|
|
],
|
|
[
|
|
"short-i",
|
|
(il, offset) => ({
|
|
next: offset + 1,
|
|
anchorKind: "constant",
|
|
value: String(il.readInt8(offset)),
|
|
}),
|
|
],
|
|
[
|
|
"i",
|
|
(il, offset) => ({
|
|
next: offset + 4,
|
|
anchorKind: "constant",
|
|
value: String(il.readInt32LE(offset)),
|
|
}),
|
|
],
|
|
[
|
|
"i8",
|
|
(il, offset) => ({
|
|
next: offset + 8,
|
|
anchorKind: "constant",
|
|
value: il.readBigInt64LE(offset).toString(),
|
|
}),
|
|
],
|
|
[
|
|
"r4",
|
|
(il, offset) => ({
|
|
next: offset + 4,
|
|
anchorKind: "constant",
|
|
value: String(il.readFloatLE(offset)),
|
|
}),
|
|
],
|
|
[
|
|
"r8",
|
|
(il, offset) => ({
|
|
next: offset + 8,
|
|
anchorKind: "constant",
|
|
value: String(il.readDoubleLE(offset)),
|
|
}),
|
|
],
|
|
[
|
|
"short-branch",
|
|
(il, offset) => ({
|
|
next: offset + 1,
|
|
anchorKind: "branch",
|
|
value: String(offset + 1 + il.readInt8(offset)),
|
|
}),
|
|
],
|
|
[
|
|
"branch",
|
|
(il, offset) => ({
|
|
next: offset + 4,
|
|
anchorKind: "branch",
|
|
value: String(offset + 4 + il.readInt32LE(offset)),
|
|
}),
|
|
],
|
|
]);
|
|
|
|
const TOKEN_OPERAND_KINDS = new Map<
|
|
string,
|
|
ManagedInstructionAnchor["operand_kind"]
|
|
>([
|
|
["method", "method"],
|
|
["field", "field"],
|
|
["type", "type"],
|
|
["string", "string"],
|
|
["signature", "signature"],
|
|
]);
|
|
|
|
const readOperand = (
|
|
il: Buffer,
|
|
offset: number,
|
|
kind: string,
|
|
): OperandResult => {
|
|
const fixed = FIXED_OPERAND_READERS.get(kind);
|
|
if (fixed !== undefined) return fixed(il, offset);
|
|
if (kind === "switch") {
|
|
const count = il.readUInt32LE(offset);
|
|
return {
|
|
next: offset + 4 + count * 4,
|
|
anchorKind: "switch",
|
|
value: String(count),
|
|
};
|
|
}
|
|
const raw = il.readUInt32LE(offset);
|
|
const token = `0x${raw.toString(16).padStart(8, "0")}`;
|
|
const tokenOperandKind = TOKEN_OPERAND_KINDS.get(kind);
|
|
if (tokenOperandKind !== undefined)
|
|
return { next: offset + 4, anchorKind: tokenOperandKind, value: token };
|
|
if (kind === "token")
|
|
return { next: offset + 4, anchorKind: tokenKind(token), value: token };
|
|
return { next: offset, anchorKind: "unknown", value: null };
|
|
};
|
|
|
|
export const decodeInstructions = (
|
|
il: Buffer,
|
|
): {
|
|
readonly parsed: readonly ParsedInstruction[];
|
|
readonly instructionStarts: readonly number[];
|
|
readonly count: number;
|
|
readonly truncated: number;
|
|
readonly issue: string | null;
|
|
} => {
|
|
const parsed: ParsedInstruction[] = [];
|
|
const instructionStarts: number[] = [];
|
|
let offset = 0;
|
|
let prefixStart: number | null = null;
|
|
let issue: string | null = null;
|
|
try {
|
|
while (offset < il.length) {
|
|
const start = offset;
|
|
const first = il.readUInt8(offset);
|
|
offset += 1;
|
|
const code = first === 0xfe ? 0xfe00 + il.readUInt8(offset++) : first;
|
|
const descriptor = OPCODES.get(code);
|
|
if (descriptor === undefined) {
|
|
issue = `Unsupported CIL opcode 0x${code.toString(16)} at IL offset ${String(start)}`;
|
|
break;
|
|
}
|
|
const operand = readOperand(il, offset, descriptor.operand);
|
|
if (operand.next < offset || operand.next > il.length) {
|
|
issue = `Instruction ${descriptor.name} at IL offset ${String(start)} leaves method body`;
|
|
break;
|
|
}
|
|
offset = operand.next;
|
|
if (PREFIX_OPCODES.has(descriptor.name)) {
|
|
prefixStart ??= start;
|
|
} else {
|
|
instructionStarts.push(prefixStart ?? start);
|
|
prefixStart = null;
|
|
}
|
|
parsed.push({
|
|
offset: start,
|
|
opcode: descriptor.name,
|
|
operandKind: operand.anchorKind,
|
|
operand: operand.value,
|
|
});
|
|
}
|
|
} catch (cause: unknown) {
|
|
issue =
|
|
cause instanceof Error ? cause.message : "Instruction decode failed";
|
|
}
|
|
const truncated = offset < il.length && issue === null ? 1 : 0;
|
|
return { parsed, instructionStarts, count: parsed.length, truncated, issue };
|
|
};
|
|
|
|
export const parseExceptionRegions = (
|
|
bytes: Buffer,
|
|
offset: number,
|
|
methodEnd: number,
|
|
budget?: ManagedDecodeBudget,
|
|
): ExceptionRegionParseResult => {
|
|
const regions: ManagedExceptionRegion[] = [];
|
|
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",
|
|
regions,
|
|
);
|
|
|
|
const kind = bytes.readUInt8(sectionOffset);
|
|
if ((kind & 0x3f) !== 1)
|
|
return malformedExceptionRegions(
|
|
`Unsupported method data section kind ${String(kind & 0x3f)}`,
|
|
regions,
|
|
);
|
|
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",
|
|
regions,
|
|
);
|
|
if ((size - 4) % clauseSize !== 0)
|
|
return malformedExceptionRegions(
|
|
"Exception section size does not contain whole clauses",
|
|
regions,
|
|
);
|
|
if (
|
|
!fat &&
|
|
(bytes[sectionOffset + 2] !== 0 || bytes[sectionOffset + 3] !== 0)
|
|
)
|
|
return malformedExceptionRegions(
|
|
"Small exception section reserved bytes are nonzero",
|
|
regions,
|
|
);
|
|
|
|
const count = (size - 4) / clauseSize;
|
|
// Accumulates with the method IL bound; the body reserves what it retains.
|
|
budget?.admitTransient(count * 256, sectionOffset);
|
|
for (const region of readExceptionClauses(
|
|
bytes,
|
|
sectionOffset + 4,
|
|
count,
|
|
fat,
|
|
))
|
|
regions.push(region);
|
|
|
|
hasMoreSections = (kind & 0x80) !== 0;
|
|
sectionOffset += size;
|
|
}
|
|
return { status: "complete", regions };
|
|
};
|
|
|
|
export type ExceptionRegionParseResult =
|
|
| {
|
|
readonly status: "complete";
|
|
readonly regions: ManagedExceptionRegion[];
|
|
}
|
|
| {
|
|
readonly status: "malformed";
|
|
readonly regions: ManagedExceptionRegion[];
|
|
readonly issue: string;
|
|
};
|
|
|
|
const malformedExceptionRegions = (
|
|
issue: string,
|
|
regions: ManagedExceptionRegion[] = [],
|
|
): ExceptionRegionParseResult => ({ status: "malformed", regions, issue });
|
|
|
|
const readExceptionClauses = (
|
|
bytes: Buffer,
|
|
start: number,
|
|
count: number,
|
|
fat: boolean,
|
|
): ManagedExceptionRegion[] => {
|
|
const regions: ManagedExceptionRegion[] = [];
|
|
const clauseSize = fat ? 24 : 12;
|
|
for (let index = 0; index < count; index += 1) {
|
|
const clause = start + index * clauseSize;
|
|
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;
|
|
};
|