mirror of
https://github.com/morluto/rea.git
synced 2026-11-16 19:53:50 +00:00
* refactor(native): bind producer_limits and max_input_bytes as the per-call controls of pwntools and Apple dispatch refusals producerLimitControl in src/domain/producerResourceLimits.ts names one producer budget as producer_limits.<field>; the shared provider outcome classifier now carries a resource signal's limit. Pwntools file-size, CPU and output refusals and the Apple dispatch input refusal bind their control, and their remediation no longer names CLI flags. * fix(native): report the selected output allowance as the omitted file_bytes default * fix(native): bind producer_limits.diagnostic_bytes as the pwntools command output-limit control * refactor(rust): bind producer_limits as the per-call control of Rust input and report refusals (#11458) * refactor(rust): bind producer_limits as the per-call control of Rust input and report refusals * test(rust): cover the complete-report refusal's producer_limits control * refactor(browser): bind caller-selectable browser deadlines as per-call controls instead of naming CLI flags (#11466) * refactor(rust): bind producer_limits as the per-call control of Rust input and report refusals * test(rust): cover the complete-report refusal's producer_limits control * refactor(browser): bind caller-selectable browser deadlines as per-call controls instead of naming CLI flags deadlineParameterLimit in src/domain/analysisResourceLimits.ts owns the millisecond deadline control that nativeDeadlineRecovery and the browser recoveries share. CDP command and discovery, web bundle per-script and total, network capture and source-map decode deadlines now carry it; browserDeadlineIncrease no longer takes CLI flag text. * fix(browser): record a per-script deadline's parameter control in partial web bundle results * refactor(providers): bind Wabt, SQLite, EVMole, Apktool and Go controls instead of naming CLI commands (#11472) * refactor(providers): bind Wabt, SQLite, EVMole and Apktool deadline and byte controls instead of naming CLI commands These remediation strings named rea commands and flags through template text the cli-option guard did not count. Wabt byte refusals and output limits bind max_input_bytes, max_tool_bytes or max_output_bytes while a larger value is selectable; SQLite worker_timeout_ms, EVMole timeout_ms and Apktool decode_timeout_ms bind through deadlineParameterLimit; the shared provider outcome classifier now carries an output limit's control. * refactor(go): bind Go analysis budgets as per-call controls instead of naming CLI flags * fix(providers): keep the typed primary when Wabt, EVMole or pwntools command cleanup fails * ci(guards): count template-built CLI option and command text outside the CLI layer (#11478) * refactor(providers): bind Wabt, SQLite, EVMole and Apktool deadline and byte controls instead of naming CLI commands These remediation strings named rea commands and flags through template text the cli-option guard did not count. Wabt byte refusals and output limits bind max_input_bytes, max_tool_bytes or max_output_bytes while a larger value is selectable; SQLite worker_timeout_ms, EVMole timeout_ms and Apktool decode_timeout_ms bind through deadlineParameterLimit; the shared provider outcome classifier now carries an output limit's control. * refactor(go): bind Go analysis budgets as per-call controls instead of naming CLI flags * fix(providers): keep the typed primary when Wabt, EVMole or pwntools command cleanup fails * ci(guards): count template-built CLI option and command text outside the CLI layer The cli-option-text-outside-cli pattern now also matches "(CLI ...", "on the CLI", "or use rea ..." and backticked `rea <command>` references, so remediation built from a template such as --${name} or rea inspect-... <path> is counted. Doctor.ts is exempt: setup and doctor run only through the CLI. The baseline records the newly counted pre-existing sites (22 -> 45 across 21 files). * ci(guards): extract the CLI text matcher, exempt host-only commands with written reasons, and test each spelling * ci(guards): exempt a host-only command and its own arguments in any matched CLI phrase * fix(native): bind producer_limits.output_bytes for oversized pwndbg debugger replies through one owner * fix(cli): name an Evidence target source failure's control by the source option that sets it * feat(cli): render the flags of result-recorded controls in the full-output envelope (#11507) * feat(cli): render the flags of result-recorded controls in the full-output envelope * fix(cli): collect result controls only for a full-output envelope, in its requested format, past undefined values * ci(guards): end a host-only command's arguments before the next CLI command * refactor(reverse): record the output budget that stopped a one-shot command as a parameter control (#11528) * fix(cli): read result controls only at positions the output schema declares as recorded controls * refactor(providers): record the controls that bounded Rust compiler paths and kernel module text instead of naming CLI options (#11532) * refactor(rust): record the control that bounded compiler-path coverage instead of naming CLI options * refactor(native): record the controls that omitted kernel module .modinfo text instead of naming CLI options (#11534) * fix(rust): describe compiler coverage from the retained result after report trimming * refactor(providers): record managed representation and JavaScript semantic ceiling controls instead of naming CLI options (#11537) * refactor(managed): record the representation budget on a resource-limit issue instead of naming its CLI option * refactor(javascript): record the semantic retention ceilings that stopped a graph instead of naming CLI options (#11540) * fix(cli): name a composed command's source options for the controls its result records * fix(cli): read result controls from the delivered Evidence when a summary wraps it * fix(rust): keep the report-byte control recorded when trimming omits every compiler path When the complete-report allowance left room for no compiler path, rustc_commit became null and its coverage.limit was lost, so --full-output could not name the option that raises the allowance. The report now records rustc_commit_omission { reason, limit } outside the dropped record, and the summary view carries it. * refactor(flutter): record the string-pool budgets that left a projection partial instead of naming the CLI option (#11541) * refactor(flutter): record the string-pool budgets that left a projection partial instead of naming the CLI option * test(flutter): assert the complete set of recorded string-pool budgets * feat(cli): name the options of controls a failure's partial Evidence records (#11557) meta.cli_controls was collected only from a successful result. A failure whose partial observation is Evidence of the command's own operation is now read the same way, at the positions the output schema declares as recorded controls; Evidence of another operation or a retained reference is not read. When --evidence_output publishes the partial, the delivery records it before replacing it. * refactor(javascript): record the evaluator budgets that limited sources instead of naming the CLI option (#11564) Per-value unknown reasons and the Electron wrapper limitation named --semantic-precision. The static examination now records the semantic_precision controls that limited a source (examination.controls), and analyze_javascript_application's semantic_graph.coverage.controls records every evaluator budget that limited any source (examination and semantic IR coverage), beside the retention ceilings. The CLI renders --semantic-precision from those records in meta.cli_controls; the reason texts name only the contract field.
838 lines
27 KiB
TypeScript
838 lines
27 KiB
TypeScript
import { createHash } from "node:crypto";
|
|
import { readFile, writeFile } from "node:fs/promises";
|
|
import { join } from "node:path";
|
|
|
|
import { expect } from "vitest";
|
|
|
|
import { elf, thinMach } from "../../src/domain/binaryTarget.fixture.js";
|
|
import { buildManagedPeFixture } from "../../src/dotnet/ManagedPe.fixture.js";
|
|
import { createTestTempDirectory } from "../fixtures/temporaryDirectory.js";
|
|
import { cliTest } from "../support/cli/cliFixture.js";
|
|
|
|
cliTest(
|
|
"delivers a managed artifact summary beside its complete Evidence bundle",
|
|
async ({ cli }) => {
|
|
const root = await createTestTempDirectory("rea-managed-cli-delivery-");
|
|
const path = join(root, "fixture.dll");
|
|
await writeFile(path, buildManagedPeFixture());
|
|
const destination = join(root, "artifact.json");
|
|
const result = await cli.run({
|
|
arguments: [
|
|
"inspect-managed-artifact",
|
|
path,
|
|
"--detail",
|
|
"summary",
|
|
"--evidence_output",
|
|
destination,
|
|
"--json",
|
|
],
|
|
});
|
|
expect(result.exitCode, result.stderr).toBe(0);
|
|
const bytes = await readFile(destination);
|
|
expect(result.json).toMatchObject({
|
|
evidence_bundle: { path: destination, bytes: bytes.length },
|
|
summary: { operation: "inspect_analysis_view" },
|
|
});
|
|
expect(JSON.parse(bytes.toString())).toMatchObject({
|
|
records: [{ operation: "inspect_managed_artifact" }],
|
|
});
|
|
},
|
|
);
|
|
|
|
cliTest(
|
|
"recovers the same managed artifact through decimal CLI budgets and retains caller choices",
|
|
async ({ cli }) => {
|
|
const root = await createTestTempDirectory("rea-managed-cli-budgets-");
|
|
const path = join(root, "fixture.dll");
|
|
const bytes = buildManagedPeFixture();
|
|
await writeFile(path, bytes);
|
|
const command = ["inspect-managed-artifact", path];
|
|
const refused = await cli.run({
|
|
arguments: [
|
|
...command,
|
|
"--max-snapshot-bytes",
|
|
String(bytes.length - 1),
|
|
"--json",
|
|
],
|
|
});
|
|
expect(refused.exitCode).toBe(1);
|
|
expect(refused.json).toMatchObject({
|
|
code: "resource_constraint",
|
|
details: {
|
|
reported_limits: { max_snapshot_bytes: bytes.length - 1 },
|
|
// The provider names the field; the CLI adds the flag that sets it.
|
|
limit: {
|
|
control_kind: "parameter",
|
|
parameter: "max_snapshot_bytes",
|
|
effective_value: bytes.length - 1,
|
|
cli_flag: "--max-snapshot-bytes",
|
|
},
|
|
},
|
|
});
|
|
expect(
|
|
JSON.stringify((refused.json as { remediation: unknown }).remediation),
|
|
).not.toContain("--");
|
|
const admitted = ["--max-snapshot-bytes", String(bytes.length)];
|
|
const partial = await cli.run({
|
|
arguments: [
|
|
...command,
|
|
...admitted,
|
|
"--max-metadata-representation-bytes",
|
|
"1",
|
|
"--full-output",
|
|
"--json",
|
|
],
|
|
});
|
|
expect(partial.exitCode, partial.stderr).toBe(0);
|
|
expect(partial.json).toMatchObject({
|
|
data: {
|
|
parameters: {
|
|
max_snapshot_bytes: bytes.length,
|
|
max_metadata_representation_bytes: 1,
|
|
},
|
|
normalized_result: {
|
|
coverage: {
|
|
state: "partial",
|
|
issues: [
|
|
expect.objectContaining({
|
|
code: "resource-limit",
|
|
limit: expect.objectContaining({
|
|
parameter: "max_metadata_representation_bytes",
|
|
}),
|
|
}),
|
|
],
|
|
},
|
|
},
|
|
},
|
|
// The CLI names its option for the recorded control outside the result.
|
|
meta: {
|
|
cli_controls: {
|
|
max_metadata_representation_bytes:
|
|
"--max-metadata-representation-bytes",
|
|
},
|
|
},
|
|
});
|
|
const complete = await cli.run({
|
|
arguments: [
|
|
...command,
|
|
...admitted,
|
|
"--max-metadata-representation-bytes",
|
|
"1048576",
|
|
"--json",
|
|
],
|
|
});
|
|
expect(complete.exitCode, complete.stderr).toBe(0);
|
|
expect(complete.json).toMatchObject({
|
|
subject: {
|
|
identity: { sha256: createHash("sha256").update(bytes).digest("hex") },
|
|
},
|
|
parameters: {
|
|
max_snapshot_bytes: bytes.length,
|
|
max_metadata_representation_bytes: 1048576,
|
|
},
|
|
normalized_result: { coverage: { state: "complete", issues: [] } },
|
|
});
|
|
for (const flag of [
|
|
"--max-snapshot-bytes",
|
|
"--max-metadata-representation-bytes",
|
|
]) {
|
|
const malformed = await cli.run({
|
|
arguments: [...command, flag, "1e3", "--json"],
|
|
});
|
|
expect(malformed.exitCode).toBe(1);
|
|
expect(malformed.json).toMatchObject({ code: "VALIDATION_ERROR" });
|
|
}
|
|
},
|
|
);
|
|
|
|
cliTest(
|
|
"managed CLI preserves malformed prefix evidence without a complete CIL fingerprint",
|
|
async ({ cli }) => {
|
|
const root = await createTestTempDirectory("rea-managed-cil-prefix-");
|
|
for (const [name, il, status, coverage] of [
|
|
["dangling", [0xfe, 0x13], "malformed", "partial"],
|
|
["complete", [0x00, 0x2a], "present", "complete"],
|
|
] as const) {
|
|
const path = join(root, `${name}.dll`);
|
|
await writeFile(
|
|
path,
|
|
buildManagedPeFixture({
|
|
ilBody: Buffer.from([(il.length << 2) | 2, ...il]),
|
|
}),
|
|
);
|
|
const result = await cli.run({
|
|
arguments: ["inspect-managed-members", path, "--json"],
|
|
});
|
|
expect(result.exitCode).toBe(0);
|
|
expect(result.json).toMatchObject({
|
|
operation: "inspect_managed_members",
|
|
subject: { local_path: path },
|
|
normalized_result: {
|
|
coverage: { state: coverage },
|
|
user_strings: { state: coverage },
|
|
methods: [
|
|
expect.objectContaining({
|
|
body: expect.objectContaining({
|
|
status,
|
|
il_sha256: expect.any(String),
|
|
normalized_il_sha256:
|
|
status === "malformed" ? null : expect.any(String),
|
|
issue:
|
|
status === "malformed"
|
|
? expect.stringMatching(
|
|
/CIL prefix.*offset 0.*no following instruction/iu,
|
|
)
|
|
: null,
|
|
}),
|
|
}),
|
|
],
|
|
},
|
|
});
|
|
}
|
|
},
|
|
);
|
|
|
|
cliTest(
|
|
"managed CLI inspects malformed MethodSpecs used by isolated non-call instructions",
|
|
async ({ cli }) => {
|
|
const root = await createTestTempDirectory(
|
|
"rea-managed-methodspec-operands-",
|
|
);
|
|
for (const [opcode, name, operandKind] of [
|
|
[0x71, "ldobj", "type"],
|
|
[0x7e, "ldsfld", "field"],
|
|
[0xd0, "ldtoken", "method"],
|
|
] as const) {
|
|
const path = join(root, `${name}.dll`);
|
|
// Each body has one token operand; no call can trigger MethodSpec
|
|
// inspection on behalf of the non-call instruction under observation.
|
|
const il = Buffer.from([opcode, 1, 0, 0, 0x2b, 0x2a]);
|
|
await writeFile(
|
|
path,
|
|
buildManagedPeFixture({
|
|
memberRefName: "NotAMethod",
|
|
memberRefSignature: Buffer.from([0x06, 0x0e]),
|
|
methodSpecMethods: [(1 << 1) | 1],
|
|
ilBody: Buffer.concat([Buffer.from([(il.length << 2) | 2]), il]),
|
|
}),
|
|
);
|
|
const result = await cli.run({
|
|
arguments: ["inspect-managed-members", path, "--json"],
|
|
});
|
|
expect(result.exitCode, result.stderr).toBe(0);
|
|
expect(result.json).toMatchObject({
|
|
operation: "inspect_managed_members",
|
|
subject: { local_path: path },
|
|
normalized_result: {
|
|
methods: [
|
|
expect.objectContaining({
|
|
body: expect.objectContaining({
|
|
status: "present",
|
|
il_sha256: createHash("sha256").update(il).digest("hex"),
|
|
normalized_il_sha256: expect.any(String),
|
|
anchors: [
|
|
expect.objectContaining({
|
|
opcode: name,
|
|
operand_kind: operandKind,
|
|
operand: "0x2b000001",
|
|
}),
|
|
expect.objectContaining({ opcode: "ret", operand: null }),
|
|
],
|
|
issue: null,
|
|
}),
|
|
}),
|
|
],
|
|
call_edges: [],
|
|
field_accesses:
|
|
name === "ldsfld"
|
|
? [
|
|
expect.objectContaining({
|
|
opcode: "ldsfld",
|
|
field_token: "0x2b000001",
|
|
field_name: null,
|
|
field_declaring_type: null,
|
|
}),
|
|
]
|
|
: [],
|
|
coverage: {
|
|
state: "partial",
|
|
issues: expect.arrayContaining([
|
|
expect.objectContaining({
|
|
code: "invalid-row",
|
|
scope: "metadata.MethodSpec:0x2b000001",
|
|
detail:
|
|
"MethodSpec method does not have a decodable method signature",
|
|
}),
|
|
]),
|
|
},
|
|
},
|
|
});
|
|
}
|
|
},
|
|
);
|
|
|
|
cliTest(
|
|
"managed CLI retains metadata and CIL after repeated local constructor owner lookups",
|
|
async ({ cli }) => {
|
|
const root = await createTestTempDirectory("rea-managed-row-lookup-");
|
|
const path = join(root, "local-attributes.dll");
|
|
await writeFile(
|
|
path,
|
|
buildManagedPeFixture({
|
|
additionalEmptyTypes: 512,
|
|
customAttributeRowCount: 512,
|
|
customAttributeTypeRaw: (1 << 3) | 2,
|
|
typeName: "LookupAttribute",
|
|
extendsRaw: 0,
|
|
methodName: ".ctor",
|
|
methodFlags: 0x1886,
|
|
methodSignature: Buffer.from([0x20, 0x01, 0x01, 0x0e]),
|
|
ilBody: Buffer.from([0x06, 0x2a]),
|
|
}),
|
|
);
|
|
const artifact = await cli.run({
|
|
arguments: ["inspect-managed-artifact", path, "--json"],
|
|
});
|
|
expect(artifact.exitCode).toBe(0);
|
|
expect(artifact.json).toMatchObject({
|
|
normalized_result: {
|
|
coverage: { state: "complete", issues: [] },
|
|
attributes: expect.arrayContaining([
|
|
expect.objectContaining({
|
|
type_name: "Fixture.LookupAttribute",
|
|
constructor_token: "0x06000001",
|
|
}),
|
|
]),
|
|
},
|
|
});
|
|
expect(artifact.json).toHaveProperty(
|
|
"normalized_result.attributes.length",
|
|
512,
|
|
);
|
|
const members = await cli.run({
|
|
arguments: ["inspect-managed-members", path, "--json"],
|
|
});
|
|
expect(members.exitCode).toBe(0);
|
|
expect(members.json).toMatchObject({
|
|
normalized_result: {
|
|
coverage: { state: "complete", issues: [] },
|
|
types: expect.arrayContaining([
|
|
expect.objectContaining({ full_name: "Fixture.Empty0" }),
|
|
expect.objectContaining({ full_name: "Fixture.Empty511" }),
|
|
expect.objectContaining({ full_name: "Fixture.LookupAttribute" }),
|
|
]),
|
|
methods: [
|
|
expect.objectContaining({
|
|
name: ".ctor",
|
|
declaring_type: "Fixture.LookupAttribute",
|
|
body: expect.objectContaining({
|
|
status: "present",
|
|
instruction_count: 1,
|
|
}),
|
|
}),
|
|
],
|
|
},
|
|
});
|
|
expect(members.json).toHaveProperty("normalized_result.types.length", 513);
|
|
},
|
|
);
|
|
|
|
cliTest(
|
|
"managed CLI separates .NET Standard API targets from runtime evidence",
|
|
async ({ cli }) => {
|
|
const root = await createTestTempDirectory("rea-managed-runtime-family-");
|
|
for (const [name, targetFramework, readyToRun, runtimeFamily] of [
|
|
["standard", ".NETStandard,Version=v2.0", false, "unknown"],
|
|
["core", ".NETCoreApp,Version=v8.0", false, "modern-dotnet"],
|
|
["standard-r2r", ".NETStandard,Version=v2.0", true, "modern-dotnet"],
|
|
] as const) {
|
|
const path = join(root, `${name}.dll`);
|
|
await writeFile(
|
|
path,
|
|
buildManagedPeFixture({ targetFramework, readyToRun }),
|
|
);
|
|
const result = await cli.run({
|
|
arguments: ["inspect-managed-artifact", path, "--json"],
|
|
});
|
|
expect(result.exitCode).toBe(0);
|
|
expect(result.json).toMatchObject({
|
|
operation: "inspect_managed_artifact",
|
|
subject: { local_path: path },
|
|
normalized_result: {
|
|
classification: {
|
|
status: "managed",
|
|
runtime_family: runtimeFamily,
|
|
implementation: readyToRun ? "cil-and-ready-to-run" : "cil",
|
|
evidence: expect.arrayContaining([
|
|
expect.objectContaining({
|
|
code: readyToRun
|
|
? "ready-to-run-signature-observed"
|
|
: "target-framework-observed",
|
|
detail: expect.stringContaining(
|
|
readyToRun
|
|
? "ReadyToRun signature"
|
|
: name === "standard"
|
|
? "does not identify a runtime family"
|
|
: "names modern .NET",
|
|
),
|
|
file_offset: expect.any(Number),
|
|
}),
|
|
]),
|
|
},
|
|
target_frameworks: [targetFramework],
|
|
coverage: { state: "complete", issues: [] },
|
|
},
|
|
});
|
|
}
|
|
|
|
const hintedPath = join(root, "ready-to-run-with-runtime-hints.dll");
|
|
const hintedTarget = ".NETFramework,Version=v4.8";
|
|
await writeFile(
|
|
hintedPath,
|
|
buildManagedPeFixture({
|
|
readyToRun: true,
|
|
targetFramework: hintedTarget,
|
|
references: ["UnityEngine.CoreModule"],
|
|
}),
|
|
);
|
|
const hinted = await cli.run({
|
|
arguments: ["inspect-managed-artifact", hintedPath, "--json"],
|
|
});
|
|
expect(hinted.exitCode).toBe(0);
|
|
expect(hinted.json).toMatchObject({
|
|
normalized_result: {
|
|
classification: {
|
|
runtime_family: "modern-dotnet",
|
|
implementation: "cil-and-ready-to-run",
|
|
evidence: expect.arrayContaining([
|
|
expect.objectContaining({
|
|
code: "ready-to-run-signature-observed",
|
|
}),
|
|
expect.objectContaining({ code: "unity-reference-observed" }),
|
|
expect.objectContaining({ code: "target-framework-observed" }),
|
|
]),
|
|
},
|
|
target_frameworks: [hintedTarget],
|
|
},
|
|
});
|
|
},
|
|
);
|
|
|
|
cliTest(
|
|
"managed CLI qualifies a local nested custom-attribute type name",
|
|
async ({ cli }) => {
|
|
const root = await createTestTempDirectory("rea-managed-nested-attribute-");
|
|
const path = join(root, "nested-attribute.dll");
|
|
await writeFile(
|
|
path,
|
|
buildManagedPeFixture({
|
|
additionalEmptyTypes: 1,
|
|
customAttributeTypeRaw: (1 << 3) | 2,
|
|
nestedTypes: [[2, 1]],
|
|
typeName: "InnerAttribute",
|
|
typeNamespace: "",
|
|
}),
|
|
);
|
|
|
|
const result = await cli.run({
|
|
arguments: ["inspect-managed-artifact", path, "--json"],
|
|
});
|
|
expect(result.exitCode).toBe(0);
|
|
expect(result.json).toMatchObject({
|
|
normalized_result: {
|
|
attributes: [
|
|
expect.objectContaining({
|
|
type_name: "Empty0+InnerAttribute",
|
|
}),
|
|
],
|
|
coverage: { state: "complete", issues: [] },
|
|
},
|
|
});
|
|
},
|
|
);
|
|
|
|
cliTest(
|
|
"managed CLI preserves evidence, filters, envelopes, and bounded token counts",
|
|
async ({ cli }) => {
|
|
const root = await createTestTempDirectory("rea-managed-cli-output-");
|
|
const path = join(root, "fixture.dll");
|
|
await writeFile(
|
|
path,
|
|
buildManagedPeFixture({
|
|
ilBody: Buffer.from([0x0e, 0x17, 0x26, 0x2a]),
|
|
}),
|
|
);
|
|
const argv = ["inspect-managed-members", path, "--json"];
|
|
const result = await cli.run({ arguments: argv });
|
|
expect(result.exitCode).toBe(0);
|
|
expect(result.json).toMatchObject({
|
|
operation: "inspect_managed_members",
|
|
provider: { id: "rea-dotnet-static" },
|
|
subject: { local_path: path },
|
|
normalized_result: {
|
|
methods: [
|
|
expect.objectContaining({
|
|
token: expect.any(String),
|
|
body: expect.objectContaining({
|
|
status: "present",
|
|
decoded_instruction_count: 3,
|
|
anchors: [
|
|
{
|
|
il_offset: 0,
|
|
opcode: "ldc.i4.1",
|
|
operand_kind: "none",
|
|
operand: null,
|
|
},
|
|
{
|
|
il_offset: 1,
|
|
opcode: "pop",
|
|
operand_kind: "none",
|
|
operand: null,
|
|
},
|
|
{
|
|
il_offset: 2,
|
|
opcode: "ret",
|
|
operand_kind: "none",
|
|
operand: null,
|
|
},
|
|
],
|
|
}),
|
|
}),
|
|
],
|
|
},
|
|
});
|
|
const filtered = await cli.run({
|
|
arguments: [...argv, "--filter-output", "operation", "--full-output"],
|
|
});
|
|
expect(filtered.exitCode).toBe(0);
|
|
expect(filtered.json).toMatchObject({
|
|
ok: true,
|
|
data: "inspect_managed_members",
|
|
meta: {
|
|
command: "inspect-managed-members",
|
|
duration: expect.stringMatching(/^\d+ms$/u),
|
|
},
|
|
});
|
|
const count = await cli.run({
|
|
arguments: [...argv, "--filter-output", "operation", "--token-count"],
|
|
});
|
|
expect(count.exitCode).toBe(0);
|
|
expect(count.stdout).toMatch(/^\d+\n$/u);
|
|
const omittedCount = await cli.run({
|
|
arguments: [...argv, "--filter-output", "toString", "--token-count"],
|
|
});
|
|
expect(omittedCount.exitCode).toBe(0);
|
|
// A missing JSON selection delivers an empty object, which costs one token.
|
|
expect(omittedCount.stdout).toBe("1\n");
|
|
const jsonl = await cli.run({
|
|
arguments: [
|
|
"inspect-managed-members",
|
|
path,
|
|
"--format",
|
|
"jsonl",
|
|
"--filter-output",
|
|
"operation",
|
|
],
|
|
});
|
|
expect(jsonl.exitCode).toBe(1);
|
|
expect(jsonl.json).toMatchObject({
|
|
$rea: "jsonl/v1",
|
|
type: "error",
|
|
result: {
|
|
code: "invalid_request",
|
|
category: "invalid_input",
|
|
remediation: {
|
|
action: expect.stringMatching(
|
|
/--format json.*record collection.*--filter-output/iu,
|
|
),
|
|
},
|
|
details: {
|
|
issues: [
|
|
{
|
|
path: ["filter-output"],
|
|
reason: "invalid_value",
|
|
observed: [{ path: ["operation"], shape: "string" }],
|
|
},
|
|
],
|
|
},
|
|
},
|
|
});
|
|
},
|
|
);
|
|
|
|
cliTest(
|
|
"managed CLI rejects repeated or empty type selections as invalid input",
|
|
async ({ cli }) => {
|
|
const root = await createTestTempDirectory("rea-managed-cli-types-");
|
|
const path = join(root, "fixture.dll");
|
|
await writeFile(path, buildManagedPeFixture());
|
|
for (const [types, message] of [
|
|
[["Fixture.Empty0", "Fixture.Empty0"], "must not repeat a name"],
|
|
[[""], ">=1 characters"],
|
|
] as const) {
|
|
const result = await cli.run({
|
|
arguments: [
|
|
"inspect-managed-members",
|
|
path,
|
|
...types.flatMap((type) => ["--type", type]),
|
|
"--json",
|
|
],
|
|
});
|
|
expect(result.exitCode).toBe(1);
|
|
expect(result.json).toMatchObject({
|
|
code: "VALIDATION_ERROR",
|
|
fieldErrors: [
|
|
expect.objectContaining({
|
|
path: expect.stringMatching(/^type/u),
|
|
message: expect.stringContaining(message),
|
|
}),
|
|
],
|
|
});
|
|
}
|
|
},
|
|
);
|
|
|
|
cliTest(
|
|
"managed CLI bounds CIL claims by section virtual ranges",
|
|
async ({ cli }) => {
|
|
const root = await createTestTempDirectory("rea-managed-virtual-size-");
|
|
for (const virtualSectionSize of [0, 0x800, 0x801, 0x802]) {
|
|
// The two-byte tiny method starts at RVA 0x2800. Its header alone fits
|
|
// at size 0x801, and its full CIL fits exactly at size 0x802.
|
|
const bytes = buildManagedPeFixture({
|
|
virtualSectionSize,
|
|
ilBody: Buffer.from([0x06, 0x2a]),
|
|
});
|
|
const path = join(root, `virtual-${virtualSectionSize}.dll`);
|
|
await writeFile(path, bytes);
|
|
const result = await cli.run({
|
|
arguments: ["inspect-managed-members", path, "--json"],
|
|
});
|
|
expect(result.exitCode).toBe(0);
|
|
expect(result.json).toMatchObject({
|
|
normalized_result:
|
|
virtualSectionSize === 0
|
|
? {
|
|
methods: [],
|
|
metadata: { status: "malformed" },
|
|
coverage: { state: "unavailable" },
|
|
}
|
|
: {
|
|
methods: [
|
|
{
|
|
rva: 0x2800,
|
|
body:
|
|
virtualSectionSize === 0x802
|
|
? {
|
|
status: "present",
|
|
normalized_il_sha256: expect.any(String),
|
|
}
|
|
: {
|
|
status: "malformed",
|
|
normalized_il_sha256: null,
|
|
},
|
|
},
|
|
],
|
|
coverage: {
|
|
state: virtualSectionSize === 0x802 ? "complete" : "partial",
|
|
},
|
|
},
|
|
});
|
|
}
|
|
},
|
|
);
|
|
|
|
cliTest(
|
|
"managed CLI distinguishes raw padding from overlapping virtual sections",
|
|
async ({ cli }) => {
|
|
const root = await createTestTempDirectory("rea-managed-section-identity-");
|
|
for (const virtualSectionSize of [0x800, 0x900]) {
|
|
const bytes = buildManagedPeFixture({ virtualSectionSize });
|
|
const coff = bytes.readUInt32LE(0x3c) + 4;
|
|
const firstSection = coff + 20 + bytes.readUInt16LE(coff + 16);
|
|
const secondSection = firstSection + 40;
|
|
bytes.writeUInt16LE(2, coff + 2);
|
|
bytes.write(".il", secondSection, "ascii");
|
|
bytes.writeUInt32LE(0x100, secondSection + 8);
|
|
bytes.writeUInt32LE(0x2800, secondSection + 12);
|
|
bytes.writeUInt32LE(0x100, secondSection + 16);
|
|
bytes.writeUInt32LE(0x0a00, secondSection + 20);
|
|
const path = join(root, `sections-${virtualSectionSize}.dll`);
|
|
await writeFile(path, bytes);
|
|
const result = await cli.run({
|
|
arguments: ["inspect-managed-members", path, "--json"],
|
|
});
|
|
expect(result.exitCode).toBe(0);
|
|
expect(result.json).toMatchObject({
|
|
normalized_result: {
|
|
methods: [
|
|
{
|
|
rva: 0x2800,
|
|
body:
|
|
virtualSectionSize === 0x800
|
|
? {
|
|
status: "present",
|
|
file_offset: 0x0a00,
|
|
normalized_il_sha256: expect.any(String),
|
|
}
|
|
: {
|
|
status: "malformed",
|
|
normalized_il_sha256: null,
|
|
issue: expect.stringContaining("ambiguous overlapping"),
|
|
},
|
|
},
|
|
],
|
|
coverage: {
|
|
state: virtualSectionSize === 0x800 ? "complete" : "partial",
|
|
},
|
|
},
|
|
});
|
|
}
|
|
},
|
|
);
|
|
|
|
cliTest(
|
|
"managed CLI reports a section table past EOF as invalid input",
|
|
async ({ cli }) => {
|
|
const root = await createTestTempDirectory("rea-managed-cli-sections-");
|
|
const path = join(root, "fixture.dll");
|
|
const bytes = buildManagedPeFixture();
|
|
const pe = bytes.readUInt32LE(0x3c);
|
|
const sections = pe + 24 + bytes.readUInt16LE(pe + 20);
|
|
bytes.writeUInt32LE(bytes.length + 0x1000, sections + 20);
|
|
await writeFile(path, bytes);
|
|
for (const command of [
|
|
"inspect-managed-artifact",
|
|
"inspect-managed-members",
|
|
"inspect-managed-native-boundaries",
|
|
]) {
|
|
const result = await cli.run({
|
|
arguments: [command, path, "--json"],
|
|
});
|
|
expect(result.exitCode).toBe(1);
|
|
expect(result.json).toMatchObject({
|
|
code: "invalid_request",
|
|
details: {
|
|
issues: [
|
|
{
|
|
path: ["path"],
|
|
reason: "invalid_format",
|
|
message: expect.stringContaining("pe.section-data"),
|
|
},
|
|
],
|
|
},
|
|
});
|
|
}
|
|
},
|
|
);
|
|
|
|
cliTest(
|
|
"managed CLI refuses non-PE executables as unsupported targets",
|
|
async ({ cli }) => {
|
|
const root = await createTestTempDirectory("rea-managed-non-pe-");
|
|
for (const [name, bytes, format] of [
|
|
["native.elf", elf(2, 1, 0x3e), "elf"],
|
|
["native.macho", thinMach(0xfeedfacf, 0x01000007), "mach-o"],
|
|
] as const) {
|
|
const path = join(root, name);
|
|
await writeFile(path, bytes);
|
|
for (const command of [
|
|
"inspect-managed-artifact",
|
|
"inspect-managed-members",
|
|
"inspect-managed-native-boundaries",
|
|
]) {
|
|
const result = await cli.run({
|
|
arguments: [command, path, "--json"],
|
|
});
|
|
expect(result.exitCode).not.toBe(0);
|
|
expect(result.json).toMatchObject({
|
|
code: "unsupported_target",
|
|
category: "unsupported_target",
|
|
retryable: false,
|
|
remediation: {
|
|
action:
|
|
"Select a target supported by this operation or choose an operation supporting the reported target format.",
|
|
},
|
|
details: {
|
|
operation: command.replaceAll("-", "_"),
|
|
path,
|
|
reason: `Managed static triage requires a PE target; observed ${format}.`,
|
|
},
|
|
});
|
|
}
|
|
}
|
|
},
|
|
);
|
|
|
|
cliTest(
|
|
"managed CLI retains target frameworks with multi-byte SerString lengths",
|
|
async ({ cli }) => {
|
|
const root = await createTestTempDirectory("rea-managed-serstring-");
|
|
for (const length of [0x80, 0x4000]) {
|
|
const targetFramework = "A".repeat(length);
|
|
const path = join(root, `framework-${length}.dll`);
|
|
await writeFile(path, buildManagedPeFixture({ targetFramework }));
|
|
|
|
const result = await cli.run({
|
|
arguments: ["inspect-managed-artifact", path, "--json"],
|
|
});
|
|
|
|
expect(result.exitCode).toBe(0);
|
|
expect(result.json).toMatchObject({
|
|
operation: "inspect_managed_artifact",
|
|
normalized_result: {
|
|
target_frameworks: [targetFramework],
|
|
attributes: [
|
|
expect.objectContaining({ decoded_fixed_string: targetFramework }),
|
|
],
|
|
coverage: { state: "complete", issues: [] },
|
|
},
|
|
});
|
|
}
|
|
},
|
|
);
|
|
|
|
cliTest(
|
|
"managed CLI renders type names and preserves unresolved operands",
|
|
async ({ cli }) => {
|
|
const root = await createTestTempDirectory("rea-managed-signature-names-");
|
|
const path = join(root, "names.dll");
|
|
await writeFile(
|
|
path,
|
|
buildManagedPeFixture({
|
|
fieldSignature: Buffer.from([0x06, 0x12, 0x04]),
|
|
typeSpecSignatures: [Buffer.from([0x08])],
|
|
methodSignature: Buffer.from([
|
|
0x00, 0x02, 0x12, 0x04, 0x12, 0x09, 0x12, 0x06,
|
|
]),
|
|
typeReferences: [{ namespace: "System", name: "Uri" }],
|
|
}),
|
|
);
|
|
const result = await cli.run({
|
|
arguments: ["inspect-managed-members", path, "--json"],
|
|
});
|
|
expect(result.exitCode).toBe(0);
|
|
expect(result.json).toMatchObject({
|
|
normalized_result: {
|
|
signature_resolution: "type-names-v2",
|
|
fields: [
|
|
expect.objectContaining({
|
|
signature: expect.objectContaining({
|
|
field_type: "class:4 (Fixture.Program)",
|
|
}),
|
|
}),
|
|
],
|
|
methods: [
|
|
expect.objectContaining({
|
|
signature: expect.objectContaining({
|
|
return_type: "class:4 (Fixture.Program)",
|
|
parameter_types: ["class:9 (System.Uri)", "class:6"],
|
|
resolved_sha256: null,
|
|
}),
|
|
}),
|
|
],
|
|
},
|
|
});
|
|
},
|
|
);
|