Files
reverse-engineering-anything/tests/acceptance/v8CodeCacheCli.test.ts
T

154 lines
5.0 KiB
TypeScript

import { createHash } from "node:crypto";
import { writeFile } from "node:fs/promises";
import { join } from "node:path";
import { expect } from "vitest";
import { toolContract } from "../../src/contracts/toolContracts.js";
import {
v8CodeCacheFixture,
withSyntheticNarrowHeader,
} from "../../src/v8/V8CodeCache.fixture.js";
import { createTestTempDirectory } from "../fixtures/temporaryDirectory.js";
import { cliTest } from "../support/cli/cliFixture.js";
const outputSchema = toolContract("inspect_v8_code_cache").outputSchema;
cliTest(
"reports wide and synthetic narrow header extents through the public CLI",
async ({ cli }) => {
const root = await createTestTempDirectory("rea-v8-cli-");
const wide = v8CodeCacheFixture();
const narrow = withSyntheticNarrowHeader(wide);
const payloadDigest = createHash("sha256")
.update(wide.subarray(32))
.digest("hex");
for (const [bytes, headerBytes] of [
[wide, 32],
[narrow, 28],
] as const) {
const path = join(root, `header-${String(headerBytes)}.jsc`);
await writeFile(path, bytes);
const result = await cli.run({
arguments: ["inspect-v8-code-cache", path, "--json"],
});
expect(result.exitCode, result.stderr).toBe(0);
const report = outputSchema.parse(result.json).normalized_result;
expect(report.header.magic).toBe(bytes.readUInt32LE(0));
expect(report.header.magic_build_stable).toBe(0xc0de);
expect(report.header.header_bytes).toBe(headerBytes);
expect(report.header.fields).toHaveLength(headerBytes / 4);
expect(report.payload.offset).toBe(headerBytes);
expect(report.payload.bytes).toBe(bytes.length - headerBytes);
expect(report.payload.sha256).toBe(payloadDigest);
expect(report.coverage.status).toBe("complete");
}
},
);
cliTest(
"locates retained printable bytes from a working-directory-relative cache",
async ({ cli }) => {
const root = await createTestTempDirectory("rea-v8-cli-strings-");
const path = join(root, "module.jsc");
const marker = "EMBEDDED_CONFIG_KEY_7c1d";
const bytes = v8CodeCacheFixture(
`var settings = { key: "${marker}" }; settings.key;`,
);
await writeFile(path, bytes);
const result = await cli.run({
arguments: [
"inspect-v8-code-cache",
"module.jsc",
"--minStringBytes",
"8",
"--json",
],
cwd: root,
});
expect(result.exitCode, result.stderr).toBe(0);
const report = outputSchema.parse(result.json).normalized_result;
const observation = report.embedded_strings.find((entry) =>
entry.text.includes(marker),
);
if (observation === undefined) throw new Error("Missing printable marker");
expect(report.artifact.path).toBe(path);
expect(observation.offset).toBeGreaterThanOrEqual(report.payload.offset);
expect(observation.offset + observation.bytes).toBeLessThanOrEqual(
report.artifact.bytes,
);
expect(
bytes
.subarray(
observation.offset,
observation.offset + observation.retained_bytes,
)
.toString("latin1"),
).toBe(observation.text);
},
);
cliTest(
"fails closed on a file that is not a V8 code cache",
async ({ cli }) => {
const root = await createTestTempDirectory("rea-v8-cli-foreign-");
const path = join(root, "random.bin");
const foreign = Buffer.from(v8CodeCacheFixture());
foreign.writeUInt32LE(0xdeadbeef, 0);
await writeFile(path, foreign);
const result = await cli.run({
arguments: ["inspect-v8-code-cache", path, "--json"],
});
expect(result.exitCode).toBe(1);
expect(result.json).toMatchObject({
code: "unsupported_target",
details: {
operation: "inspect_v8_code_cache",
partial_observation: {
kind: "file-snapshot-hash",
path,
bytes: foreign.length,
sha256: createHash("sha256").update(foreign).digest("hex"),
},
},
});
},
);
cliTest(
"retains file identity when a synthetic cache exceeds the string budget",
async ({ cli }) => {
const root = await createTestTempDirectory("rea-v8-budget-");
const path = join(root, "synthetic.jsc");
const payload = Buffer.from("aaaa\0bbbb");
const bytes = Buffer.concat([
v8CodeCacheFixture().subarray(0, 32),
payload,
]);
bytes.writeUInt32LE(payload.length, 20);
await writeFile(path, bytes);
const result = await cli.run({
arguments: [
"inspect-v8-code-cache",
path,
"--max-strings",
"1",
"--min-string-bytes",
"4",
"--json",
],
});
expect(result.exitCode, result.stderr).toBe(1);
expect(result.json).toMatchObject({
code: "resource_constraint",
details: {
reported_limits: { boundary: "max_strings", maximum: 1 },
partial_observation: {
kind: "file-snapshot-hash",
path,
bytes: bytes.length,
sha256: createHash("sha256").update(bytes).digest("hex"),
},
},
});
},
);