* feat: add Frida instrumentation support * fix: resolve Frida CI checks * test: cover Frida contract validation branches * docs: link Frida instrumentation guide * fix(frida): handle cancellation cleanup safely * fix(frida): address PR review findings * fix(frida): preserve resume and message observations * fix(ci): use canonical registry for rolldown * fix(frida): declare foreign code effects * fix(frida): retain failed startup resources for cleanup retries Keep failed startup session and spawn handles owned until detach, resume, and remote lease cleanup complete. Serialize retries and release each remote reference once. Await CLI provider cleanup while preserving the primary failure and any completed observations. Add regressions for retained startup resources, concurrent cleanup, shared remote leases, and CLI cleanup outcomes. Validation: 41 focused tests pass on the PR head and its latest-main integration; serial static and docs checks pass. Real Linux Frida 17.23.2 workflows and the native spawn/controlled-failure cleanup probe pass. Assisted-by: Kogasa (gensokyo-skills:kogasa-surprise-testing) --------- Co-authored-by: N0zoM1z0 <1705004398@qq.com>
237 lines
6.4 KiB
TypeScript
237 lines
6.4 KiB
TypeScript
import { expect, it } from "vitest";
|
|
|
|
import { createCli } from "../../../src/cli.js";
|
|
import type { FridaInstrumentationPort } from "../../../src/application/frida/FridaInstrumentationPort.js";
|
|
import { AnalysisCapabilityUnavailableError } from "../../../src/domain/analysisErrorCore.js";
|
|
import { FridaInstrumentationManager } from "../../../src/frida/FridaInstrumentationManager.js";
|
|
|
|
it("maps one-shot Frida CLI target, script, duration, and remote options", async () => {
|
|
const calls: unknown[] = [];
|
|
const provider: FridaInstrumentationPort = {
|
|
async listDevices() {
|
|
calls.push({ operation: "devices" });
|
|
return { ok: true, value: { devices: [], cleanupError: null } };
|
|
},
|
|
async listProcesses() {
|
|
return {
|
|
ok: true,
|
|
value: { deviceId: "local", processes: [], cleanupError: null },
|
|
};
|
|
},
|
|
async startSession(input) {
|
|
calls.push({ operation: "start", input });
|
|
return {
|
|
ok: true,
|
|
value: {
|
|
sessionId: "00000000-0000-4000-8000-000000000001",
|
|
deviceId: "remote",
|
|
target: "fixture",
|
|
pid: 71,
|
|
mode: input.mode,
|
|
state: "running",
|
|
},
|
|
};
|
|
},
|
|
async loadScript(sessionId, source) {
|
|
calls.push({ operation: "load", sessionId, source });
|
|
return {
|
|
ok: true,
|
|
value: {
|
|
scriptId: "00000000-0000-4000-8000-000000000002",
|
|
sourceKind: source.sourceKind,
|
|
sourcePath: source.sourceKind === "file" ? source.path : null,
|
|
sourceSha256: "a".repeat(64),
|
|
messages: [{ type: "send", payload: "observed" }],
|
|
messagesTruncated: false,
|
|
},
|
|
};
|
|
},
|
|
async resumeSession(sessionId) {
|
|
calls.push({ operation: "resume", sessionId });
|
|
return { ok: true, value: null };
|
|
},
|
|
async unloadScript() {
|
|
return { ok: true, value: null };
|
|
},
|
|
status(sessionId) {
|
|
return {
|
|
sessionId,
|
|
deviceId: "remote",
|
|
target: "fixture",
|
|
pid: 71,
|
|
mode: "attach",
|
|
state: "running",
|
|
targetResumeObserved: false,
|
|
scripts: [],
|
|
messages: [],
|
|
messagesTruncated: false,
|
|
};
|
|
},
|
|
async closeSession(sessionId) {
|
|
calls.push({ operation: "close", sessionId });
|
|
return { ok: true, value: { targetResumeObserved: false } };
|
|
},
|
|
async closeAll() {},
|
|
};
|
|
const cli = createCli({}, undefined, provider);
|
|
let stdout = "";
|
|
let exitCode = 0;
|
|
await cli.serve(
|
|
[
|
|
"instrument-with-frida",
|
|
"attach",
|
|
"71",
|
|
"--script",
|
|
"send('hello')",
|
|
"--remote-address",
|
|
"127.0.0.1:27042",
|
|
"--token",
|
|
"synthetic-secret-token",
|
|
"--keepalive-interval",
|
|
"10",
|
|
"--duration-ms",
|
|
"0",
|
|
"--json",
|
|
],
|
|
{
|
|
env: {},
|
|
exit: (code) => {
|
|
exitCode = code;
|
|
},
|
|
stdout: (text) => {
|
|
stdout += text;
|
|
},
|
|
},
|
|
);
|
|
expect(exitCode).toBe(0);
|
|
const result: unknown = JSON.parse(stdout);
|
|
expect(JSON.stringify(result)).not.toContain("synthetic-secret-token");
|
|
expect(calls).toEqual([
|
|
{
|
|
operation: "start",
|
|
input: {
|
|
mode: "attach",
|
|
pid: 71,
|
|
remote: {
|
|
address: "127.0.0.1:27042",
|
|
token: "synthetic-secret-token",
|
|
keepaliveInterval: 10,
|
|
},
|
|
source: { sourceKind: "inline", source: "send('hello')" },
|
|
durationMs: 0,
|
|
},
|
|
},
|
|
{
|
|
operation: "load",
|
|
sessionId: "00000000-0000-4000-8000-000000000001",
|
|
source: { sourceKind: "inline", source: "send('hello')" },
|
|
},
|
|
{
|
|
operation: "close",
|
|
sessionId: "00000000-0000-4000-8000-000000000001",
|
|
},
|
|
]);
|
|
|
|
stdout = "";
|
|
exitCode = 0;
|
|
await cli.serve(
|
|
["list-frida-devices", "--token", "synthetic-secret-token", "--json"],
|
|
{
|
|
env: {},
|
|
exit: (code) => {
|
|
exitCode = code;
|
|
},
|
|
stdout: (text) => {
|
|
stdout += text;
|
|
},
|
|
},
|
|
);
|
|
expect(exitCode).not.toBe(0);
|
|
expect(calls).toHaveLength(3);
|
|
expect(stdout).not.toContain("synthetic-secret-token");
|
|
});
|
|
|
|
it("awaits failed startup cleanup and retains the primary error if cleanup still fails", async () => {
|
|
for (const cleanupFails of [false, true]) {
|
|
const calls: string[] = [];
|
|
const provider: FridaInstrumentationPort =
|
|
new FridaInstrumentationManager();
|
|
provider.startSession = async () => {
|
|
calls.push("start");
|
|
return {
|
|
ok: false,
|
|
error: new AnalysisCapabilityUnavailableError(
|
|
"frida",
|
|
"start_frida_session",
|
|
"attach failed after spawn",
|
|
{
|
|
cleanup: {
|
|
reason: "first resume failed",
|
|
resources: ["paused spawn"],
|
|
},
|
|
},
|
|
),
|
|
};
|
|
};
|
|
provider.closeAll = async () => {
|
|
calls.push("cleanup");
|
|
if (cleanupFails) throw new Error("resume still failed");
|
|
};
|
|
let stdout = "";
|
|
await createCli({}, undefined, provider).serve(
|
|
[
|
|
"instrument-with-frida",
|
|
"spawn",
|
|
"/tmp/fixture",
|
|
"--script",
|
|
"send('ready')",
|
|
"--json",
|
|
],
|
|
{
|
|
env: {},
|
|
exit: () => {},
|
|
stdout: (text) => {
|
|
stdout += text;
|
|
},
|
|
},
|
|
);
|
|
expect(calls).toEqual(["start", "cleanup"]);
|
|
const output: unknown = JSON.parse(stdout);
|
|
expect(output).toMatchObject({
|
|
code: cleanupFails ? "cleanup_incomplete" : "capability_unavailable",
|
|
});
|
|
expect(stdout).toContain("attach failed after spawn");
|
|
if (cleanupFails) expect(stdout).toContain("primary_error");
|
|
}
|
|
});
|
|
|
|
it("preserves observed devices when CLI provider cleanup fails", async () => {
|
|
const provider: FridaInstrumentationPort = new FridaInstrumentationManager();
|
|
const devices = [
|
|
{ deviceId: "remote-device", name: "selected endpoint", type: "remote" },
|
|
];
|
|
provider.listDevices = async () => ({
|
|
ok: true,
|
|
value: { devices, cleanupError: null },
|
|
});
|
|
provider.closeAll = async () => {
|
|
throw new Error("remote removal failed");
|
|
};
|
|
let stdout = "";
|
|
await createCli({}, undefined, provider).serve(
|
|
["list-frida-devices", "--json"],
|
|
{
|
|
env: {},
|
|
exit: () => {},
|
|
stdout: (text) => {
|
|
stdout += text;
|
|
},
|
|
},
|
|
);
|
|
const output: unknown = JSON.parse(stdout);
|
|
expect(output).toMatchObject({
|
|
code: "cleanup_incomplete",
|
|
details: { diagnostics: { partial_observation: { devices } } },
|
|
});
|
|
});
|