Files
reverse-engineering-anything/tests/boundary/native/pwndbgReplyFinalization.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

283 lines
10 KiB
TypeScript

import { createHash } from "node:crypto";
import { resolvePwntoolsLimits } from "../../../src/domain/native/pwntoolsResourceLimits.js";
import { mkdir, writeFile } from "node:fs/promises";
import type { FileHandle } from "node:fs/promises";
import { expect, it, onTestFinished, vi } from "vitest";
const replyClose = vi.hoisted(() => ({
path: "",
denied: false,
onClose: undefined as (() => void) | undefined,
handles: [] as FileHandle[],
}));
vi.mock("node:fs/promises", async (original) => {
const actual = await original<typeof import("node:fs/promises")>();
return {
...actual,
open: async (...args: Parameters<typeof actual.open>) => {
const handle = await actual.open(...args);
if (args[0] === replyClose.path) {
replyClose.handles.push(handle);
const close = handle.close.bind(handle);
handle.close = async () => {
if (replyClose.denied) {
replyClose.onClose?.();
throw new Error("controlled debugger reply close denial");
}
await close();
replyClose.onClose?.();
};
}
return handle;
},
};
});
import { ArtifactResourceScope } from "../../../src/resources/ArtifactResourceScope.js";
import {
AnalysisError,
primaryAnalysisError,
} from "../../../src/domain/analysisErrorBase.js";
import { projectAnalysisError } from "../../../src/domain/analysisErrorProjection.js";
import { recordedCrashSchema } from "../../../src/domain/native/recordedCrash.js";
import { PwntoolsRecordedCrashProvider } from "../../../src/native/pwntools/PwntoolsRecordedCrashProvider.js";
import { runOwnedCommand } from "../../../src/process/OwnedCommand.js";
import { snapshotEnvironment } from "../../../src/process/snapshotEnvironment.js";
import {
recordedCrashDebuggerFixture,
recordedCrashFixture,
recordedCrashFixtureBytes,
} from "../../fixtures/binaryDiagnostics/recordedCrash.js";
import {
createTestWorkspace,
removeTestWorkspace,
} from "../../support/workspace/workspaceFixture.js";
const fixture = async (
reply = Buffer.from(
JSON.stringify({ ok: true, value: recordedCrashDebuggerFixture() }),
),
) => {
const workspace = await createTestWorkspace("rea-pwndbg-reply-finalization-");
const path = workspace.path("recorded.core");
const value = recordedCrashFixture(path);
const bytes = recordedCrashFixtureBytes(value);
const sha256 = createHash("sha256").update(bytes).digest("hex");
await writeFile(path, bytes);
const init = workspace.path("gdbinit.py");
const venv = workspace.path("venv");
await writeFile(init, "# authored debugger fixture\n");
await mkdir(venv);
const resources = new ArtifactResourceScope();
replyClose.path = workspace.path("debugger/reply.json");
replyClose.denied = false;
replyClose.onClose = undefined;
replyClose.handles = [];
const environment = snapshotEnvironment(
{
REA_PWNDBG_GDB: process.execPath,
REA_PWNDBG_GDBINIT: init,
REA_PWNDBG_VENV_PATH: venv,
},
process.platform,
);
const provider = new PwntoolsRecordedCrashProvider(environment);
onTestFinished(async () => {
replyClose.denied = false;
replyClose.onClose = undefined;
await resources.close();
await provider.close();
await removeTestWorkspace(workspace.root);
});
const {
artifact: _artifact,
diagnostics: _diagnostics,
decoder_diagnostics: _decoderDiagnostics,
debugger: _debugger,
...payload
} = value;
const exits: (number | null | undefined)[] = [];
// Exercise the real projection and owned-process boundary on every host.
// The child authors debugger output; this does not establish GDB/pwndbg support.
const project = async (signal: AbortSignal) =>
provider.profile.enrich!({
environment,
input: { path, include_debugger_context: true },
report: provider.profile.project({
input: { path, include_debugger_context: true },
payload,
snapshot: { bytes, sha256 },
diagnostics: value.decoder_diagnostics,
}),
snapshot: { bytes, sha256 },
rootPath: workspace.root,
resources,
options: { signal },
timeoutMs: 10_000,
producerLimits: resolvePwntoolsLimits(),
runCommand: async (spawn) => {
const output = await runOwnedCommand(
{
...spawn,
command: process.execPath,
arguments: [
"-e",
`const fs=require('node:fs');const request=JSON.parse(fs.readFileSync(process.argv[1],'utf8'));fs.writeFileSync(request.reply_path,Buffer.from(${JSON.stringify(reply.toString("base64"))},'base64'));process.stdout.write('authored debugger output');`,
spawn.arguments.at(-1) ?? "",
],
},
{ timeoutMs: 10_000, diagnosticBytes: 1024 * 1024 },
);
exits.push(output.exitCode);
return output;
},
});
return { project, resources, value, sha256, exits };
};
it.each([
{ cancel: false, denied: false },
{ cancel: true, denied: false },
{ cancel: false, denied: true },
{ cancel: true, denied: true },
])(
"retains authored completed debugger output through reply close (cancel=$cancel, denied=$denied)",
async ({ cancel, denied }) => {
const selected = await fixture();
replyClose.denied = denied;
const controller = new AbortController();
const reason = { stage: "completed debugger output close" };
if (cancel) replyClose.onClose = () => controller.abort(reason);
const result = await selected.project(controller.signal).then(
(value) => ({ ok: true as const, value }),
(cause: unknown) => {
if (!(cause instanceof AnalysisError)) throw cause;
return { ok: false as const, error: cause };
},
);
expect(result.ok).toBe(!cancel && !denied);
const completed = recordedCrashSchema.parse(
result.ok ? result.value : result.error.partialObservation,
);
expect(completed).toMatchObject({
artifact: { path: selected.value.artifact.path, sha256: selected.sha256 },
threads: selected.value.threads,
debugger: {
...recordedCrashDebuggerFixture(),
diagnostics: {
stdout: "authored debugger output",
stderr: "",
truncated: false,
},
},
});
expect(selected.exits).toEqual([0]);
if (!result.ok) {
if (cancel) {
expect(primaryAnalysisError(result.error)._tag).toBe(
"AnalysisCancelledError",
);
expect(primaryAnalysisError(result.error).cause).toBe(reason);
}
expect(result.error.cleanupIncomplete).toBe(denied);
expect(projectAnalysisError(result.error)).toMatchObject({
details: { partial_observation: completed },
});
if (denied) {
expect(result.error.cleanupResources).toEqual([replyClose.path]);
expect(replyClose.handles[0]?.fd).toBeGreaterThanOrEqual(0);
await expect(selected.resources.close()).rejects.toBeDefined();
replyClose.denied = false;
await selected.resources.close();
expect(result.error.cleanupIncomplete).toBe(false);
expect(result.error.cleanupResources).toEqual([]);
expect(result.error.partialObservation).toEqual(completed);
}
}
expect(replyClose.handles.every((handle) => handle.fd === -1)).toBe(true);
},
);
it.each(["malformed JSON", "malformed UTF-8", "producer refusal"])(
"keeps %s primary alongside denied close and retains only the earlier core facts",
async (scenario) => {
const reply =
scenario === "malformed JSON"
? Buffer.from("{")
: scenario === "producer refusal"
? Buffer.from(
JSON.stringify({
ok: false,
reason: "unsupported",
message: "authored refusal",
}),
)
: Buffer.from(
JSON.stringify({
ok: true,
value: recordedCrashDebuggerFixture(),
}),
);
if (scenario === "malformed UTF-8") {
const marker = reply.indexOf("source seam");
expect(marker).toBeGreaterThanOrEqual(0);
reply[marker] = 0xff;
}
const selected = await fixture(reply);
replyClose.denied = true;
const controller = new AbortController();
const reason = { stage: "rejected debugger reply close" };
replyClose.onClose = () => controller.abort(reason);
const error: unknown = await selected
.project(controller.signal)
.catch((cause: unknown) => cause);
if (!(error instanceof AnalysisError))
throw new Error("Expected debugger reply failure");
expect(controller.signal.reason).toBe(reason);
expect(primaryAnalysisError(error)._tag).toBe(
scenario === "producer refusal"
? "AnalysisCapabilityUnavailableError"
: "AnalysisOutputError",
);
expect(error.partialObservation).toMatchObject({
artifact: { path: selected.value.artifact.path, sha256: selected.sha256 },
threads: selected.value.threads,
debugger: { status: "unavailable", requested: true },
});
expect(error.cleanupIncomplete).toBe(true);
replyClose.denied = false;
await selected.resources.close();
expect(error.cleanupIncomplete).toBe(false);
expect(error.cleanupResources).toEqual([]);
expect(replyClose.handles.every((handle) => handle.fd === -1)).toBe(true);
},
);
it("binds producer_limits.output_bytes when the debugger bridge reports its reply over budget", async () => {
const selected = await fixture(
Buffer.from(
JSON.stringify({
ok: false,
reason: "output-limit",
message: "authored debugger reply exceeded output_bytes",
}),
),
);
const error: unknown = await selected
.project(new AbortController().signal)
.catch((cause: unknown) => cause);
if (!(error instanceof AnalysisError))
throw new Error("Expected debugger reply failure");
const projected = projectAnalysisError(error);
expect(projected.details?.limit).toMatchObject({
control_kind: "parameter",
parameter: "producer_limits.output_bytes",
effective_value: resolvePwntoolsLimits().output_bytes,
});
expect(projected.remediation.action).toContain(
"Increase producer_limits.output_bytes",
);
expect(projected.remediation.action).not.toContain("--");
});