Files
reverse-engineering-anything/tests/composition/reverseEngineering.test.ts
T
morluto 2430b081c9 refactor(providers): bind provider refusals' per-call controls instead of naming CLI flags (#11455)
* 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.
2026-11-16 07:12:16 +08:00

1077 lines
34 KiB
TypeScript

import { fileIdentity } from "../fixtures/evidenceSubject.js";
import { createHash } from "node:crypto";
import type { Stats } from "node:fs";
import { mkdtemp, rm, writeFile } from "node:fs/promises";
import { tmpdir } from "node:os";
import { isAbsolute, join, relative, resolve } from "node:path";
import { PassThrough } from "node:stream";
import { describe, expect, it } from "vitest";
import { digestFile } from "../../src/application/reverse/ReverseEngineeringService.js";
import { ok } from "../../src/domain/result.js";
import { TestReverseEngineeringService as ReverseEngineeringService } from "../support/reverseEngineeringService.js";
import {
fixtureCommandRepair,
ownedFailure,
ownedLaunchRefusal,
ownedOutput,
providerSnapshot,
} from "../support/reverseEngineeringCompositionFixtures.js";
import { createReverseEngineeringService } from "../../src/composition/reverseEngineering.js";
import { projectAnalysisError } from "../../src/domain/analysisErrorProjection.js";
import { AnalysisCancelledError } from "../../src/domain/analysisErrorCore.js";
import { rizinCommandLimitations } from "../../src/rizin/RizinCommand.js";
import { objdumpCommandLimitations } from "../../src/objdump/ObjdumpCommand.js";
it.each(["objdump", "rizin"] as const)(
"recovers a bounded %s capture after the caller raises output admission",
async (provider) => {
const directory = await mkdtemp(
join(tmpdir(), "rea-reverse-output-admission-"),
);
const path = join(directory, "input.bin");
await writeFile(path, "selected artifact");
const profile = {
executable: process.execPath,
arguments: ["-e", "process.stdout.write('complete-output')"],
repair: fixtureCommandRepair,
identity: {
id: "fixture-command",
name: "Fixture command",
version: "1",
},
};
const service = new ReverseEngineeringService({
commands: { objdump: () => ok(profile), rizin: () => ok(profile) },
});
const inspect = (max_output_bytes: number) =>
provider === "objdump"
? service.inspectWithObjdump({
operation: "architectures",
max_output_bytes,
})
: service.executeRizinCommand({
path,
command: "iI",
max_output_bytes,
});
try {
const limited = await inspect(8);
if (!limited.ok) throw limited.error;
expect(limited.value.normalized_result).toMatchObject({
stdout: "complete",
output_budget_bytes: 8,
output_budget_source: "request",
output_truncated: true,
output_limit: {
control_kind: "parameter",
parameter: "max_output_bytes",
effective_value: 8,
unit: "bytes",
minimum: 1,
default_value: 16 * 1024 * 1024,
applies_at: "next_call",
},
completion_status: "unknown",
});
expect(limited.value.parameters).toMatchObject({ max_output_bytes: 8 });
expect(limited.value.limitations).toContainEqual(
expect.stringContaining("max_output_bytes=8"),
);
expect(limited.value.limitations.join(" ")).not.toContain(
"--max-output-bytes",
);
const recovered = await inspect(32);
if (!recovered.ok) throw recovered.error;
expect(recovered.value.normalized_result).toMatchObject({
stdout: "complete-output",
output_budget_bytes: 32,
output_budget_source: "request",
output_truncated: false,
completion_status: "complete",
});
expect(recovered.value.normalized_result).not.toHaveProperty(
"output_limit",
);
expect(recovered.value.parameters).toMatchObject({
max_output_bytes: 32,
});
} finally {
await service.close();
await rm(directory, { recursive: true, force: true });
}
},
);
describe("reverse engineering command services", () => {
it("uses compatible local DWARF link flags and disables debuginfod through the environment", async () => {
const directory = await mkdtemp(join(tmpdir(), "rea-reverse-tools-"));
const path = join(directory, "fixture.bin");
await writeFile(path, Buffer.from([0x7f, 0x45, 0x4c, 0x46]));
const calls: {
command: string;
args: readonly string[];
env: NodeJS.ProcessEnv | undefined;
}[] = [];
const service = new ReverseEngineeringService({
environment: {
REA_OBJDUMP_COMMAND: "/tools/objdump",
DEBUGINFOD_URLS: "https://debug.example.invalid",
},
runOwned: async (spawn) => {
calls.push({
command: spawn.command,
args: spawn.arguments,
env: spawn.env,
});
return ownedOutput("DWARF output\n", "diagnostic\n");
},
});
try {
const result = await service.inspectWithObjdump({
path,
operation: "dwarf",
follow_debug_links: true,
});
if (!result.ok) throw result.error;
expect(result.ok).toBe(true);
if (!result.ok) return;
expect(calls).toEqual([
{
command: resolve("/tools/objdump"),
args: ["-W", "-WK", path],
env: expect.objectContaining({ DEBUGINFOD_URLS: "" }),
},
]);
expect(result.value.raw_result).toMatchObject({
stdout: "DWARF output\n",
stderr: "diagnostic\n",
exit_code: 0,
output_truncated: false,
});
expect(result.value.provider.id).toBe("objdump.command");
expect(result.value.subject?.local_path).toBe(path);
} finally {
await rm(directory, { recursive: true, force: true });
}
});
it("rejects non-regular artifacts without launching the provider", async () => {
const directory = await mkdtemp(
join(tmpdir(), "rea-reverse-special-file-"),
);
let invoked = false;
const service = new ReverseEngineeringService({
runOwned: async () => {
invoked = true;
return ownedOutput();
},
});
try {
const result = await service.inspectWithObjdump({
path: directory,
operation: "file_headers",
});
expect(result).toMatchObject({
ok: false,
error: {
_tag: "AnalysisInputError",
operation: "inspect_with_objdump",
cause: {
code: "EINVAL",
message: "Artifact digest requires a regular file",
},
},
});
expect(invoked).toBe(false);
} finally {
await rm(directory, { recursive: true, force: true });
}
});
it("classifies captured spawn failures instead of reporting provider evidence", async () => {
const directory = await mkdtemp(
join(tmpdir(), "rea-objdump-spawn-failure-"),
);
const path = join(directory, "fixture.bin");
await writeFile(path, "fixture");
const service = new ReverseEngineeringService({
runOwned: async (spawn) => {
throw ownedLaunchRefusal("ENOENT", spawn.command);
},
});
try {
const result = await service.inspectWithObjdump({
path,
operation: "file_headers",
});
expect(result.ok).toBe(false);
if (!result.ok) {
expect(result.error._tag).toBe("AnalysisCapabilityUnavailableError");
expect(result.error.message).toContain("ENOENT");
expect(result.error.message).not.toContain("stdout");
}
} finally {
await rm(directory, { recursive: true, force: true });
}
});
it("marks max-buffer termination as unknown completion while retaining output", async () => {
const directory = await mkdtemp(join(tmpdir(), "rea-objdump-max-buffer-"));
const path = join(directory, "fixture.bin");
await writeFile(path, "fixture");
const service = new ReverseEngineeringService({
runOwned: async () => {
throw ownedFailure(
"output-limit",
ownedOutput("captured partial output", "", {
exitCode: null,
signal: "SIGTERM",
diagnosticTruncated: true,
}),
);
},
});
try {
const result = await service.executeRizinCommand({
path,
command: "wx 00 @ 0",
});
expect(result.ok).toBe(true);
if (result.ok) {
expect(result.value.raw_result).toMatchObject({
stdout: "captured partial output",
exit_code: null,
output_truncated: true,
completion_status: "unknown",
});
expect(result.value.limitations).toContainEqual(
expect.stringContaining("max_output_bytes=16777216"),
);
}
} finally {
await rm(directory, { recursive: true, force: true });
}
});
});
it.each([
["file_headers", true, undefined, ["-f"], false],
["section_headers", true, undefined, ["-h"], false],
["symbols", true, undefined, ["-t"], false],
["relocations", true, undefined, ["-r"], false],
["disassemble", true, undefined, ["-d"], false],
["disassemble_all", true, undefined, ["-D"], false],
[
"disassemble",
true,
"sample_symbol",
["--disassemble=sample_symbol"],
false,
],
["dwarf", true, undefined, ["-W", "-WK"], true],
["dwarf", false, undefined, ["-W", "-WN"], false],
] as const)(
"scopes the debug-link limitation to %s when following links is %s",
async (operation, followDebugLinks, symbol, flags, warns) => {
const directory = await mkdtemp(join(tmpdir(), "rea-objdump-limitations-"));
const path = join(directory, "fixture.bin");
await writeFile(path, "inert artifact");
const calls: (readonly string[])[] = [];
const service = new ReverseEngineeringService({
environment: { REA_OBJDUMP_COMMAND: "/tools/objdump" },
runOwned: async (spawn) => {
calls.push(spawn.arguments);
return ownedOutput("captured stdout", "captured stderr");
},
});
try {
const result = await service.inspectWithObjdump({
path,
operation,
follow_debug_links: followDebugLinks,
...(symbol === undefined ? {} : { symbol }),
});
if (!result.ok) throw result.error;
expect(calls).toEqual([[...flags, path]]);
expect(result.value.parameters).toMatchObject({
path,
operation,
follow_debug_links: followDebugLinks,
...(symbol === undefined ? {} : { symbol }),
});
expect(result.value.parameters.command_arguments).toEqual(calls[0]);
expect(result.value.raw_result).toMatchObject({
stdout: "captured stdout",
stderr: "captured stderr",
exit_code: 0,
output_truncated: false,
completion_status: "complete",
});
expect(
result.value.limitations.some((text) =>
text.startsWith("DWARF output"),
),
).toBe(warns);
} finally {
await service.close();
await rm(directory, { recursive: true, force: true });
}
},
);
it("uses one selected environment snapshot for provider selection and execution", async () => {
const directory = await mkdtemp(join(tmpdir(), "rea-provider-environment-"));
const path = join(directory, "fixture.bin");
await writeFile(path, Buffer.from([0x7f, 0x45, 0x4c, 0x46]));
const selectedEnvironment = {
REA_RIZIN_COMMAND: "/selected/rizin",
PATH: "/selected/bin",
SELECTED_VALUE: "captured",
};
const calls: { command: string; env: NodeJS.ProcessEnv | undefined }[] = [];
const service = createReverseEngineeringService(selectedEnvironment, {
runOwned: async (spawn) => {
calls.push({ command: spawn.command, env: spawn.env });
return ownedOutput("headers");
},
});
selectedEnvironment.REA_RIZIN_COMMAND = "/changed/rizin";
selectedEnvironment.SELECTED_VALUE = "changed after construction";
try {
const result = await service.executeRizinCommand({
path,
command: "iI",
});
expect(result.ok).toBe(true);
expect(calls).toEqual([
{
command: resolve("/selected/rizin"),
env: {
REA_RIZIN_COMMAND: "/selected/rizin",
PATH: "/selected/bin",
SELECTED_VALUE: "captured",
},
},
]);
} finally {
await rm(directory, { recursive: true, force: true });
}
});
it("marks signal-terminated provider commands as unknown completion", async () => {
const directory = await mkdtemp(join(tmpdir(), "rea-provider-signal-exit-"));
const path = join(directory, "fixture.bin");
await writeFile(path, "fixture");
let invocation = 0;
const service = new ReverseEngineeringService({
runOwned: async () => {
invocation += 1;
if (invocation === 1)
throw ownedFailure(
"process",
ownedOutput("partial output", "", {
exitCode: null,
signal: "SIGKILL",
}),
);
return ownedOutput("ordinary partial output", "ordinary diagnostic", {
exitCode: 2,
});
},
});
try {
const signaled = await service.executeRizinCommand({
path,
command: "wx 00 @ 0",
});
expect(signaled.ok).toBe(true);
if (signaled.ok) {
expect(signaled.value.raw_result).toMatchObject({
stdout: "partial output",
exit_code: null,
signal: "SIGKILL",
completion_status: "unknown",
});
expect(signaled.value.limitations.join(" ")).toContain("signal");
}
const ordinaryExit = await service.executeRizinCommand({
path,
command: "iI",
});
expect(ordinaryExit.ok).toBe(true);
if (ordinaryExit.ok) {
expect(ordinaryExit.value.raw_result).toMatchObject({
stdout: "ordinary partial output",
exit_code: 2,
signal: null,
completion_status: "complete",
});
expect(ordinaryExit.value.limitations.join(" ")).not.toContain(
"terminated by signal",
);
expect(ordinaryExit.value.limitations).toContainEqual(
expect.stringMatching(
/files.*network.*outside the selected artifact.*not bound to Evidence/iu,
),
);
expect(ordinaryExit.value.limitations).toEqual(
expect.arrayContaining([
...rizinCommandLimitations({ path, command: "iI" }),
]),
);
}
} finally {
await rm(directory, { recursive: true, force: true });
}
});
describe("Rizin command service", () => {
it("defaults Rizin to plain presentation and preserves caller-selected colour on nonzero exits", async () => {
const directory = await mkdtemp(join(tmpdir(), "rea-rizin-"));
const path = join(directory, "fixture with spaces.bin");
const callerPath = relative(process.cwd(), path);
await writeFile(path, "fixture");
const calls: { command: string; args: readonly string[] }[] = [];
const service = new ReverseEngineeringService({
environment: { REA_RIZIN_COMMAND: "/tools/rizin" },
runOwned: async (spawn) => {
calls.push({ command: spawn.command, args: spawn.arguments });
return ownedOutput(
"\u001b[31mpartial data\u001b[0m\n",
"command error",
{ exitCode: 2 },
);
},
});
try {
const command = "e scr.color=1;pd 1";
const result = await service.executeRizinCommand({
path: callerPath,
command,
});
expect(result.ok).toBe(true);
if (!result.ok) return;
const lookupPath = result.value.subject?.local_path;
expect(isAbsolute(lookupPath ?? "")).toBe(true);
expect(fileIdentity(result.value.subject).sha256).toBe(
createHash("sha256").update("fixture").digest("hex"),
);
expect(calls).toEqual([
{
command: resolve("/tools/rizin"),
args: ["-N", "-q", "-e", "scr.color=0", "-c", command, lookupPath],
},
]);
expect(result.value.raw_result).toMatchObject({
stdout: "\u001b[31mpartial data\u001b[0m\n",
stderr: "command error",
exit_code: 2,
completion_status: "complete",
});
expect(result.value.limitations.join(" ")).not.toContain(
"terminated by signal",
);
expect(result.value.normalized_result).toMatchObject({
stdout: "\u001b[31mpartial data\u001b[0m\n",
});
expect(result.value.limitations).toContainEqual(
expect.stringMatching(
/files.*network.*outside the selected artifact.*not bound to Evidence/iu,
),
);
expect(result.value.limitations).toEqual(
expect.arrayContaining([
...rizinCommandLimitations({ path: callerPath, command }),
]),
);
expect(result.value.parameters).toMatchObject({
path: callerPath,
command,
provider_executable: resolve("/tools/rizin"),
});
expect(result.value.parameters.command_arguments).toEqual(calls[0]?.args);
expect(result.value.provider.id).toBe("rizin");
} finally {
await rm(directory, { recursive: true, force: true });
}
});
it.each(["iI\nq", "wx\u0000 00"])(
"rejects malformed Rizin command %j before launching the provider",
async (command) => {
const directory = await mkdtemp(join(tmpdir(), "rea-rizin-input-"));
const path = join(directory, "fixture.bin");
await writeFile(path, "fixture");
let invoked = false;
const service = new ReverseEngineeringService({
runOwned: async () => {
invoked = true;
return ownedOutput();
},
});
try {
const result = await service.executeRizinCommand({
path,
command,
});
expect(result).toMatchObject({
ok: false,
error: {
_tag: "AnalysisInputError",
operation: "execute_rizin_command",
},
});
expect(invoked).toBe(false);
} finally {
await rm(directory, { recursive: true, force: true });
}
},
);
it("preserves pre and post artifact digests when an unrestricted Rizin command changes the file", async () => {
const directory = await mkdtemp(join(tmpdir(), "rea-rizin-mutation-"));
const path = join(directory, "fixture.bin");
await writeFile(path, "before");
const service = new ReverseEngineeringService({
runOwned: async () => {
await writeFile(path, "after");
return ownedOutput("changed");
},
});
try {
const result = await service.executeRizinCommand({
path,
command: "wx 00 @ 0",
});
expect(result.ok).toBe(true);
if (!result.ok) return;
expect(fileIdentity(result.value.subject).sha256).toBe(
createHash("sha256").update("before").digest("hex"),
);
expect(result.value.raw_result).toMatchObject({
artifact_sha256_after: createHash("sha256")
.update("after")
.digest("hex"),
artifact_changed: true,
});
expect(result.value.limitations).toContainEqual(
expect.stringMatching(
/may have changed the artifact.*pre-run and post-run digests/iu,
),
);
} finally {
await rm(directory, { recursive: true, force: true });
}
});
});
it("passes decoder and map inputs to Rizin before the path and records them", async () => {
const directory = await mkdtemp(join(tmpdir(), "rea-rizin-load-"));
const path = join(directory, "flash.bin");
await writeFile(path, Buffer.from([0x70, 0x47]));
const calls: (readonly string[])[] = [];
const service = new ReverseEngineeringService({
environment: { REA_RIZIN_COMMAND: "/tools/rizin" },
runOwned: async (spawn) => {
calls.push(spawn.arguments);
return ownedOutput("bx lr\n");
},
});
const input = {
path,
command: "pi 1",
asm_arch: "arm",
asm_bits: 16,
asm_cpu: "cortexm",
base_address: "0x08000000",
};
try {
const result = await service.executeRizinCommand(input);
if (!result.ok) throw result.error;
const argv = [
"-N",
"-q",
"-e",
"scr.color=0",
"-a",
"arm",
"-b",
"16",
"-e",
"asm.cpu=cortexm",
"-n",
"-m",
"0x08000000",
"-c",
"pi 1",
path,
];
// The command is the last launch; a provider probe may precede it.
expect(calls.at(-1)).toEqual(argv);
expect(result.value.parameters).toMatchObject({
...input,
command_arguments: argv,
});
expect(result.value.limitations).toEqual(
expect.arrayContaining([...rizinCommandLimitations(input)]),
);
// Command validity stays unverified independently of decoder/map inputs.
expect(rizinCommandLimitations(input)).toHaveLength(4);
expect(
rizinCommandLimitations({ path, command: "pi 1", asm_bits: 16 }),
).toHaveLength(3);
expect(
rizinCommandLimitations({ path, command: "pi 1", base_address: "0x0" }),
).toHaveLength(3);
expect(rizinCommandLimitations({ path, command: "pi 1" })).toHaveLength(2);
expect(
objdumpCommandLimitations({ operation: "architectures" }),
).toHaveLength(1);
expect(objdumpCommandLimitations({ path, operation: "symbols" })).toEqual(
[],
);
expect(
objdumpCommandLimitations({
path,
operation: "disassemble",
symbol: "main",
}),
).toHaveLength(1);
expect(
objdumpCommandLimitations({
path,
operation: "dwarf",
follow_debug_links: true,
}),
).toHaveLength(1);
} finally {
await rm(directory, { recursive: true, force: true });
}
});
it("checks only the spelling and range of decoder and map inputs", async () => {
const directory = await mkdtemp(join(tmpdir(), "rea-rizin-load-input-"));
const path = join(directory, "image.bin");
await writeFile(path, "image");
const calls: (readonly string[])[] = [];
const service = new ReverseEngineeringService({
runOwned: async (spawn) => {
calls.push(spawn.arguments);
return ownedOutput();
},
});
try {
// Rizin's own names: digits first, dotted plugins, '+', '-' and case.
for (const [selection, flags] of [
[{ asm_arch: "6502", asm_bits: 8 }, ["-a", "6502", "-b", "8"]],
[{ asm_arch: "x86.nasm", asm_bits: 64 }, ["-a", "x86.nasm", "-b", "64"]],
[{ asm_cpu: "c55x+" }, ["-e", "asm.cpu=c55x+"]],
[{ asm_cpu: "c166-generic" }, ["-e", "asm.cpu=c166-generic"]],
[{ asm_cpu: "ATxmega128a4u" }, ["-e", "asm.cpu=ATxmega128a4u"]],
[{ asm_bits: 1 }, ["-b", "1"]],
[{ base_address: "0x0" }, ["-n", "-m", "0x0"]],
[
{ base_address: "0xFFFFFFFFFFFFFFFF" },
["-n", "-m", "0xFFFFFFFFFFFFFFFF"],
],
] as const) {
const result = await service.executeRizinCommand({
path,
command: "e asm.arch",
...selection,
});
if (!result.ok) throw result.error;
expect(result.value.parameters.command_arguments).toEqual([
"-N",
"-q",
"-e",
"scr.color=0",
...flags,
"-c",
"e asm.arch",
path,
]);
}
calls.length = 0;
for (const [field, value] of [
["asm_arch", ""],
["asm_arch", "arm;q"],
["asm_arch", "arm x"],
["asm_arch", "-q"],
["asm_cpu", "?"],
["asm_cpu", "cortex=m"],
["asm_bits", 0],
["asm_bits", 65],
["asm_bits", 16.5],
["asm_bits", "16"],
["base_address", "0x"],
["base_address", "08000000"],
["base_address", "0X08000000"],
["base_address", "0x10000000000000000"],
] as const) {
const result = await service.executeRizinCommand({
path,
command: "e asm.arch",
[field]: value,
});
if (result.ok) throw new Error(`${field}=${String(value)} was accepted`);
expect(projectAnalysisError(result.error)).toMatchObject({
code: "invalid_request",
details: {
operation: "execute_rizin_command",
issues: [expect.objectContaining({ path: [field] })],
},
});
}
expect(calls).toEqual([]);
} finally {
await rm(directory, { recursive: true, force: true });
}
});
it("retains partial Evidence when a provider command times out", async () => {
const directory = await mkdtemp(join(tmpdir(), "rea-rizin-timeout-partial-"));
const path = join(directory, "fixture.bin");
await writeFile(path, "before");
const service = new ReverseEngineeringService({
runOwned: async () => {
throw ownedFailure(
"timeout",
ownedOutput("captured before timeout", "still running", {
exitCode: null,
signal: "SIGTERM",
}),
);
},
});
try {
const result = await service.executeRizinCommand({
path,
command: "wx 00 @ 0",
});
expect(result.ok).toBe(false);
if (!result.ok) {
expect(result.error._tag).toBe("AnalysisTimeoutError");
expect(JSON.stringify(result.error.partialObservation)).not.toContain(
"command_timeout_ms",
);
expect(result.error.partialObservation).toMatchObject({
operation: "execute_rizin_command",
raw_result: {
stdout: "captured before timeout",
stderr: "still running",
completion_status: "unknown",
signal: "SIGTERM",
artifact_sha256_after: expect.any(String),
},
});
expect(JSON.stringify(projectAnalysisError(result.error))).toContain(
"captured before timeout",
);
const projected = projectAnalysisError(result.error);
expect(projected.message).toContain("command_timeout_ms");
// The deadline names the provider whose command it bounded.
expect(projected.message).toContain("rizin command");
expect(projected.message).not.toContain("objdump");
expect(projected.message).toContain("120000 ms");
expect(projected.remediation.action).toContain("120000");
}
} finally {
await rm(directory, { recursive: true, force: true });
}
});
it("keeps a selected architecture deadline on Evidence", async () => {
const service = new ReverseEngineeringService({
runOwned: async () => ownedOutput("elf64-x86-64\n"),
});
const selected = await service.inspectWithObjdump({
operation: "architectures",
command_timeout_ms: 5_000,
});
expect(selected.ok).toBe(true);
if (!selected.ok) return;
expect(selected.value.parameters).toMatchObject({
operation: "architectures",
command_timeout_ms: 5_000,
});
expect(selected.value.parameters).not.toHaveProperty("path");
const omitted = await service.inspectWithObjdump({
operation: "architectures",
});
expect(omitted.ok).toBe(true);
if (!omitted.ok) return;
expect(omitted.value.parameters).not.toHaveProperty("command_timeout_ms");
});
it("shares one preflight deadline across stat and digest", async () => {
const stat = async (): Promise<Stats> => {
await new Promise((resolve) => setTimeout(resolve, 150));
return { isFile: () => true } as Stats;
};
const open = () => {
const stream = new PassThrough();
return stream as unknown as ReturnType<
typeof import("node:fs").createReadStream
>;
};
const started = performance.now();
await expect(
digestFile("/tmp/rea-preflight-deadline", undefined, stat, 200, open),
).rejects.toMatchObject({ code: "ETIMEDOUT" });
expect(performance.now() - started).toBeLessThan(280);
});
it("retains an explicit null reason when digest admission is already cancelled", async () => {
const controller = new AbortController();
controller.abort(null);
await expect(
digestFile("/tmp/rea-cancelled-digest", controller.signal),
).rejects.toMatchObject({
_tag: "AnalysisCancelledError",
cause: null,
});
});
it("retains an object reason when cancellation interrupts an active digest stream", async () => {
const controller = new AbortController();
const reason = { source: "caller digest cancellation" };
const stat = async (): Promise<Stats> => ({ isFile: () => true }) as Stats;
const open = () => {
const stream = new PassThrough();
queueMicrotask(() => controller.abort(reason));
return stream as unknown as ReturnType<
typeof import("node:fs").createReadStream
>;
};
const failure: unknown = await digestFile(
"/tmp/rea-cancelled-stream",
controller.signal,
stat,
1_000,
open,
).catch((cause: unknown) => cause);
expect(failure).toBeInstanceOf(AnalysisCancelledError);
if (!(failure instanceof AnalysisCancelledError))
throw new Error("Expected digest cancellation");
expect(failure.cause).toBe(reason);
});
it("forwards selected and omitted deadlines through the production command runner", async () => {
const directory = await mkdtemp(join(tmpdir(), "rea-owned-timeout-"));
const path = join(directory, "fixture.bin");
await writeFile(path, "before");
const timeouts: (number | null)[] = [];
const service = new ReverseEngineeringService({
runOwned: async (_spawn, limits) => {
timeouts.push(limits.timeoutMs);
return providerSnapshot();
},
});
try {
const selected = await service.executeRizinCommand({
path,
command: "i",
command_timeout_ms: 5_000,
});
expect(selected.ok).toBe(true);
const omitted = await service.executeRizinCommand({
path,
command: "i",
});
expect(omitted.ok).toBe(true);
expect(timeouts).toEqual([5_000, 120_000]);
} finally {
await rm(directory, { recursive: true, force: true });
}
});
it("applies a caller-selected one-shot deadline on the next call", async () => {
const directory = await mkdtemp(
join(tmpdir(), "rea-rizin-timeout-selected-"),
);
const path = join(directory, "fixture.bin");
await writeFile(path, "before");
const timeouts: number[] = [];
const service = new ReverseEngineeringService({
runOwned: async (_spawn, limits) => {
timeouts.push(limits.timeoutMs ?? -1);
throw ownedFailure(
"timeout",
ownedOutput("", "", { exitCode: null, signal: "SIGTERM" }),
);
},
});
try {
const selected = await service.executeRizinCommand({
path,
command: "i",
command_timeout_ms: 5_000,
});
expect(selected.ok).toBe(false);
if (!selected.ok) {
expect(selected.error).toMatchObject({ timeoutMs: 5_000 });
expect(projectAnalysisError(selected.error).message).toContain("5000 ms");
expect(selected.error.partialObservation).toMatchObject({
parameters: { command_timeout_ms: 5_000 },
});
}
expect(timeouts).toEqual([5_000]);
for (const command_timeout_ms of [0, 2_147_483_648]) {
const rejected = await service.executeRizinCommand({
path,
command: "i",
command_timeout_ms,
});
expect(rejected.ok).toBe(false);
if (!rejected.ok) expect(rejected.error._tag).toBe("AnalysisInputError");
}
} finally {
await rm(directory, { recursive: true, force: true });
}
});
it("preserves raw byte counts when cancellation rejects invalid UTF-8 output", async () => {
const directory = await mkdtemp(
join(tmpdir(), "rea-rizin-abort-invalid-utf8-"),
);
const path = join(directory, "fixture.bin");
await writeFile(path, "fixture");
const controller = new AbortController();
const service = new ReverseEngineeringService({
runOwned: async () => {
controller.abort();
throw ownedFailure(
"cancelled",
ownedOutput("�", "€", {
stdout: { text: "�", bytes: 1, observedBytes: 1 },
exitCode: null,
}),
{ cancellation: { reason: controller.signal.reason } },
);
},
});
try {
const result = await service.executeRizinCommand(
{ path, command: "iI" },
{ signal: controller.signal },
);
expect(result.ok).toBe(false);
if (!result.ok) {
expect(result.error._tag).toBe("AnalysisCancelledError");
expect(result.error.capturedOutput).toMatchObject({
stdout: "�",
stderr: "€",
stdout_bytes: 1,
stderr_bytes: 3,
});
}
} finally {
await rm(directory, { recursive: true, force: true });
}
});
it("preserves provider facts when cancellation interrupts the post-run digest", async () => {
const directory = await mkdtemp(join(tmpdir(), "rea-rizin-digest-cancel-"));
const path = join(directory, "fixture.bin");
await writeFile(path, "fixture");
const controller = new AbortController();
const service = new ReverseEngineeringService({
runOwned: async () => {
controller.abort();
return ownedOutput("", "", {
stdout: {
text: "�",
bytes: 1,
observedBytes: 1,
invalidUtf8: true,
},
stderr: {
text: "�",
bytes: 1,
observedBytes: 1,
invalidUtf8: true,
},
});
},
});
try {
const result = await service.executeRizinCommand(
{ path, command: "iI" },
{ signal: controller.signal },
);
expect(result.ok).toBe(false);
if (!result.ok) {
expect(result.error._tag).toBe("AnalysisCancelledError");
expect(result.error.capturedOutput).toMatchObject({
stdout: "�",
stderr: "�",
stdout_bytes: 1,
stderr_bytes: 1,
exit_code: 0,
signal: null,
});
expect(result.error.partialObservation).toMatchObject({
raw_result: {
stdout: "�",
exit_code: null,
completion_status: "unknown",
artifact_sha256_after: null,
},
limitations: expect.arrayContaining([
expect.stringContaining("cancellation interrupted the digest"),
]),
});
}
} finally {
await rm(directory, { recursive: true, force: true });
}
});
it("marks signal-terminated provider output incomplete", async () => {
const directory = await mkdtemp(join(tmpdir(), "rea-rizin-signal-"));
const path = join(directory, "fixture.bin");
await writeFile(path, "fixture");
const service = new ReverseEngineeringService({
runOwned: async () => {
throw ownedFailure(
"process",
ownedOutput("partial", "", { exitCode: null, signal: "SIGSEGV" }),
);
},
});
try {
const result = await service.executeRizinCommand({ path, command: "iI" });
expect(result.ok).toBe(true);
if (result.ok)
expect(result.value.raw_result).toMatchObject({
signal: "SIGSEGV",
exit_code: null,
completion_status: "unknown",
});
} finally {
await rm(directory, { recursive: true, force: true });
}
});