Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
fix(scripts): remove the ADB verifier's pushed probe file from the device (#5256)
Syed Musa Raza Naqvi81b94cebec40
diff --git a/scripts/verify-adb.mjs b/scripts/verify-adb.mjsindex 916a9383a..1c214e347 100644--- a/scripts/verify-adb.mjs+++ b/scripts/verify-adb.mjs@@ -1,12 +1,15 @@+import { execFile } from "node:child_process";import { createHash } from "node:crypto";import { mkdtemp, readFile, rm, stat } from "node:fs/promises";import { tmpdir } from "node:os";-import { join } from "node:path";+import { join, posix } from "node:path";+import { promisify } from "node:util";import { AdbDeviceAnalysisService } from "../dist/application/adb/AdbDeviceAnalysisService.js";import { createAdbDeviceAnalysisProvider } from "../dist/composition/adb.js";import { closeVerifierResources } from "./lib/verifier-cleanup.mjs";+const execFileAsync = promisify(execFile);const options = parseArguments(process.argv.slice(2));if (options.help) {process.stdout.write(@@ -40,6 +43,80 @@ const run = async (operation, input) => {return result.value.normalized_result;};+// Remove the verifier's own transfer probe with the provider-reported adb+// client, then confirm through the directory listing that it is gone.+const removeDeviceProbe = async (binary, serial, devicePath) => {+ const name = "verifier transfer probe removed";+ if (typeof binary !== "string" || binary === "") {+ check(name, false, `${devicePath}: adb client path unavailable`);+ return;+ }+ try {+ await execFileAsync(+ binary,+ ["-s", serial, "shell", "rm", "--", devicePath],+ {+ timeout: 30_000,+ },+ );+ } catch (cause) {+ check(name, false, `${devicePath}: ${formatFailure(cause)}`);+ return;+ }+ const listing = await run("list_adb_directory", {+ serial,+ device_path: posix.dirname(devicePath),+ });+ if (listing !== null)+ check(+ name,+ listing.coverage === "complete" &&+ !listing.entries.some(+ (entry) => entry.name === posix.basename(devicePath),+ ),+ devicePath,+ );+};++const verifyTransferRoundtrip = async ({+ adbBinary,+ serial,+ payload,+ devicePath,+ outputDirectory,+}) => {+ const pushed = await run("push_adb_file", {+ serial,+ local_path: payload,+ device_path: devicePath,+ overwrite: false,+ });+ if (pushed === null) return;+ // A successful no-overwrite push proves the verifier created this exact+ // destination; pull_adb_file deliberately retains device originals.+ try {+ check(+ "push reports matching device-side digest",+ pushed.device_digest_source === "device_sha256sum" &&+ pushed.device_sha256 === pushed.sha256,+ `${pushed.bytes} bytes`,+ );+ const pulled = await run("pull_adb_file", {+ serial,+ device_path: devicePath,+ output_directory: outputDirectory,+ });+ if (pulled !== null)+ check(+ "pulled file digest matches the pushed digest",+ pulled.sha256 === pushed.sha256,+ `${pulled.bytes} bytes`,+ );+ } finally {+ await removeDeviceProbe(adbBinary, serial, devicePath);+ }+};+let verifierFailed = false;let verifierFailure;try {@@ -245,31 +322,13 @@ try {fs.writeFile(payload, payloadBytes),);const deviceTarget = `/data/local/tmp/rea-verify-${Date.now()}.txt`;- const pushed = await run("push_adb_file", {+ await verifyTransferRoundtrip({+ adbBinary: client?.client.binary_path,serial,- local_path: payload,- device_path: deviceTarget,- overwrite: false,+ payload,+ devicePath: deviceTarget,+ outputDirectory: transferRoot,});- if (pushed !== null) {- check(- "push reports matching device-side digest",- pushed.device_digest_source === "device_sha256sum" &&- pushed.device_sha256 === pushed.sha256,- `${pushed.bytes} bytes`,- );- const pulled = await run("pull_adb_file", {- serial,- device_path: deviceTarget,- output_directory: transferRoot,- });- if (pulled !== null)- check(- "pulled file digest matches the pushed digest",- pulled.sha256 === pushed.sha256,- `${pulled.bytes} bytes`,- );- }const screenRoot = await mkdtemp(join(tmpdir(), "rea-adb-screen-"));try {const screen = await run("capture_adb_screen", {diff --git a/tests/boundary/process/adbVerifierCleanup.test.ts b/tests/boundary/process/adbVerifierCleanup.test.tsindex 42e53b85b..0a8db02b3 100644--- a/tests/boundary/process/adbVerifierCleanup.test.ts+++ b/tests/boundary/process/adbVerifierCleanup.test.ts@@ -1,5 +1,13 @@import { spawnSync } from "node:child_process";-import { mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";+import {+ chmod,+ mkdtemp,+ mkdir,+ readFile,+ readdir,+ rm,+ writeFile,+} from "node:fs/promises";import { tmpdir } from "node:os";import { join } from "node:path";import { afterEach, expect, it } from "vitest";@@ -12,7 +20,12 @@ afterEach(async () => {});const runVerifier = async (- settings: { closeFails?: boolean; thrown?: "undefined" | "null" } = {},+ settings: {+ closeFails?: boolean;+ thrown?: "undefined" | "null";+ removal?: "fails" | "leaves_probe";+ pull?: "error" | "throw";+ } = {},) => {const root = await mkdtemp(join(tmpdir(), "rea-adb-verifier-test-"));roots.push(root);@@ -29,6 +42,24 @@ const runVerifier = async (new URL("../../../scripts/lib/verifier-cleanup.mjs", import.meta.url),),);+ // The simulated device directory stands in for /data/local/tmp; the fake+ // adb client records its argv and removes only the named probe.+ const device = join(root, "device");+ await mkdir(device);+ const adb = join(root, "adb");+ await writeFile(+ adb,+ [+ "#!/bin/sh",+ `printf '%s\\n' "$*" >> "$REA_FAKE_ADB_LOG"`,+ `[ "$REA_FAKE_ADB_REMOVAL" = "fails" ] && exit 1`,+ `[ "$REA_FAKE_ADB_REMOVAL" = "leaves_probe" ] && exit 0`,+ `[ "$1 $3 $4 $5" = "-s shell rm --" ] || exit 2`,+ `rm -- "$REA_FAKE_DEVICE/$(basename -- "$6")"`,+ "",+ ].join("\n"),+ );+ await chmod(adb, 0o755);await writeFile(join(root, "dist", "composition", "adb.js"),`import { writeFile } from "node:fs/promises";@@ -46,12 +77,21 @@ export const createAdbDeviceAnalysisProvider = () => ({);await writeFile(join(root, "dist", "application", "adb", "AdbDeviceAnalysisService.js"),- `export class AdbDeviceAnalysisService {+ `import { readdir, writeFile } from "node:fs/promises";+import { basename, join } from "node:path";+export class AdbDeviceAnalysisService {async execute(operation, input) {if (process.env.REA_ADB_THROW === "undefined") throw undefined;if (process.env.REA_ADB_THROW === "null") throw null;+ const device = process.env.REA_FAKE_DEVICE;+ if (operation === "push_adb_file")+ await writeFile(join(device, basename(input.device_path)), "probe");+ if (operation === "pull_adb_file" && process.env.REA_ADB_PULL === "throw")+ throw new Error("pull transport crashed");+ if (operation === "pull_adb_file" && process.env.REA_ADB_PULL === "error")+ return { ok: false, error: { message: "pull refused" } };const result = {- inspect_adb_client: { client: { version: "1", binary_path: "/tmp/adb" } },+ inspect_adb_client: { client: { version: "1", binary_path: process.env.REA_FAKE_ADB } },list_adb_devices: { devices: [{ serial: "test", state: "device", kind: "emulator", kind_basis: "stub" }] },inspect_adb_device: { properties: [{ name: "ro.build.version.sdk", value: "35" }], emulator_observed: true },list_adb_processes: { processes: [{ name: "probe" }], columns: "pid name" },@@ -61,7 +101,7 @@ export const createAdbDeviceAnalysisProvider = () => ({read_adb_logcat: { lines: [], coverage: "complete" },list_adb_features: { features: ["feature"], coverage: "complete" },list_adb_services: { services: ["service"], coverage: "complete" },- list_adb_directory: { entries: [], coverage: "complete" },+ list_adb_directory: { entries: (await readdir(device)).map((name) => ({ name })), coverage: "complete" },list_adb_packages: { packages: input.scope === "all" ? [{ package_name: "com.test" }] : [], coverage: "complete" },push_adb_file: { bytes: 3, sha256: "${"a".repeat(64)}", device_sha256: "${"a".repeat(64)}", device_digest_source: "device_sha256sum" },pull_adb_file: { bytes: 3, sha256: "${"a".repeat(64)}" },@@ -72,6 +112,7 @@ export const createAdbDeviceAnalysisProvider = () => ({}\n`,);const marker = join(root, "provider-closed");+ const adbLog = join(root, "adb.log");const run = spawnSync(process.execPath,[join(root, "scripts", "verify-adb.mjs")],@@ -82,6 +123,11 @@ export const createAdbDeviceAnalysisProvider = () => ({...process.env,REA_ADB_CLOSE_MARKER: marker,REA_ADB_CLOSE_FAIL: settings.closeFails ? "1" : "0",+ REA_FAKE_ADB: adb,+ REA_FAKE_ADB_LOG: adbLog,+ REA_FAKE_ADB_REMOVAL: settings.removal ?? "removes",+ REA_ADB_PULL: settings.pull ?? "succeeds",+ REA_FAKE_DEVICE: device,...(settings.thrown === undefined? {}: { REA_ADB_THROW: settings.thrown }),@@ -89,16 +135,91 @@ export const createAdbDeviceAnalysisProvider = () => ({},);const closed = await readFile(marker, "utf8").catch(() => null);- return { ...run, closed };+ const adbCalls = await readFile(adbLog, "utf8").then(+ (text) => text.trim().split("\n"),+ () => [],+ );+ return { ...run, closed, adbCalls, deviceFiles: await readdir(device) };};-it("runs the production verifier successfully and closes its provider", async () => {- const result = await runVerifier();+// The fake adb client is a POSIX shell script.+const posix = it.skipIf(process.platform === "win32");- expect(result.status, `${result.stdout}\n${result.stderr}`).toBe(0);- expect(result.stdout).toContain("all adb device checks passed");- expect(result.closed).toBe("closed");-});+posix(+ "runs the production verifier successfully and closes its provider",+ async () => {+ const result = await runVerifier();++ expect(result.status, `${result.stdout}\n${result.stderr}`).toBe(0);+ expect(result.stdout).toContain("all adb device checks passed");+ expect(result.closed).toBe("closed");+ },+);++posix(+ "removes exactly its own pushed probe before reporting success",+ async () => {+ const result = await runVerifier();++ expect(result.status, `${result.stdout}\n${result.stderr}`).toBe(0);+ expect(result.adbCalls).toHaveLength(1);+ expect(result.adbCalls[0]).toMatch(+ /^-s test shell rm -- \/data\/local\/tmp\/rea-verify-\d+\.txt$/u,+ );+ expect(result.stdout).toContain("[ok] verifier transfer probe removed");+ expect(result.deviceFiles).toEqual([]);+ },+);++posix(+ "fails visibly and keeps the probe when device removal fails",+ async () => {+ const result = await runVerifier({ removal: "fails" });++ expect(result.status).toBe(1);+ expect(result.stdout).toMatch(+ /\[FAIL\] verifier transfer probe removed — \/data\/local\/tmp\/rea-verify-\d+\.txt: /u,+ );+ expect(result.stdout).not.toContain("all adb device checks passed");+ expect(result.deviceFiles).toHaveLength(1);+ expect(result.closed).toBe("closed");+ },+);++posix(+ "fails when removal reports success but the listing still shows the probe",+ async () => {+ const result = await runVerifier({ removal: "leaves_probe" });++ expect(result.status).toBe(1);+ expect(result.adbCalls).toHaveLength(1);+ expect(result.stdout).toMatch(+ /\[FAIL\] verifier transfer probe removed — \/data\/local\/tmp\/rea-verify-\d+\.txt\n/u,+ );+ expect(result.stdout).not.toContain("all adb device checks passed");+ expect(result.deviceFiles).toHaveLength(1);+ },+);++posix.each([+ ["returns an error", "error", "[FAIL] pull_adb_file — pull refused"],+ ["throws", "throw", "verifier aborted — Error: pull transport crashed"],+] as const)(+ "still removes the probe when the pull %s",+ async (_label, pull, failure) => {+ const result = await runVerifier({ pull });++ expect(result.status).toBe(1);+ expect(`${result.stdout}${result.stderr}`).toContain(failure);+ expect(result.adbCalls).toHaveLength(1);+ expect(result.adbCalls[0]).toMatch(+ /^-s test shell rm -- \/data\/local\/tmp\/rea-verify-\d+\.txt$/u,+ );+ expect(result.stdout).toContain("[ok] verifier transfer probe removed");+ expect(result.deviceFiles).toEqual([]);+ expect(result.closed).toBe("closed");+ },+);it("makes provider cleanup failure fail the production verifier with resource details", async () => {const result = await runVerifier({ closeFails: true });