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(apple): keep scalar facts when object-table entries share a record (#5806)
Shreyash Patangef5410bdc4c86
diff --git a/src/artifacts/apple/PlistScalars.test.ts b/src/artifacts/apple/PlistScalars.test.tsindex bf280afec..75f0ee78a 100644--- a/src/artifacts/apple/PlistScalars.test.ts+++ b/src/artifacts/apple/PlistScalars.test.ts@@ -290,6 +290,127 @@ describe("binary plist number rewriting", () => {});});+/**+ * Three-element array whose last two entries share one scalar record, beside+ * an unrelated Int64 sibling. Objects: array, shared scalar, duplicate entry,+ * sibling.+ */+const sharedScalarEntries = (scalar: Buffer): Buffer => {+ const sibling = Buffer.alloc(9);+ sibling[0] = 0x13;+ sibling.writeBigInt64BE(1152921504606846979n, 1);+ const scalarOffset = 12;+ const siblingOffset = scalarOffset + scalar.length;+ const tableOffset = siblingOffset + sibling.length;+ const bytes = Buffer.alloc(tableOffset + 4 + 32);+ bytes.set([0xa3, 1, 2, 3], 8);+ scalar.copy(bytes, scalarOffset);+ sibling.copy(bytes, siblingOffset);+ return binaryPlistObjectTable(+ bytes,+ [8, scalarOffset, scalarOffset, siblingOffset],+ tableOffset,+ );+};++const int64 = (value: bigint): Buffer => {+ const bytes = Buffer.alloc(9);+ bytes[0] = 0x13;+ bytes.writeBigInt64BE(value, 1);+ return bytes;+};++describe("binary plist shared object-table entries", () => {+ const plan = (bytes: Buffer) =>+ estimateBinaryPlistExpansion(bytes, 1024 * 1024, {+ numberProjection: true,+ });++ it("keeps every exact integer when two entries share one Int64 record", () => {+ const bytes = sharedScalarEntries(int64(9007199254740993n));+ const original = Buffer.from(bytes);+ const scalarPlan = plan(bytes);+ const metadata = scanBinaryPlistScalars(bytes, scalarPlan);++ expect(metadata.literals.incomplete).toBe(false);+ // The shared record is one source literal, not two.+ expect(metadata.literals.unsafeIntegerLiterals).toBe(2);+ const decoded = decodeBinaryPlistScalars(bytes, metadata, scalarPlan);+ const parsed = projectPlistValue(parseBinary(decoded));+ const numbers = createPlistNumberProjection(metadata.literals);+ expect(numbers.project(parsed.value)).toEqual([+ { $plist_type: "integer", decimal: "9007199254740993" },+ { $plist_type: "integer", decimal: "9007199254740993" },+ { $plist_type: "integer", decimal: "1152921504606846979" },+ ]);+ expect(numbers.limitations().join("\n")).not.toContain(+ "could not be completely observed",+ );+ expect(bytes).toEqual(original);+ });++ it("rewrites a shared 16-byte integer once for every entry", () => {+ const wide = Buffer.alloc(17);+ wide[0] = 0x14;+ wide.writeBigUInt64BE(1n, 1);+ wide.writeBigUInt64BE(2n, 9);+ const bytes = sharedScalarEntries(wide);+ const original = Buffer.from(bytes);+ const scalarPlan = plan(bytes);+ const metadata = scanBinaryPlistScalars(bytes, scalarPlan);++ expect(metadata.literals.incomplete).toBe(false);+ expect(metadata.wideIntegers).toEqual([+ { offset: 12, value: (1n << 64n) | 2n },+ ]);+ const decoded = decodeBinaryPlistScalars(bytes, metadata, scalarPlan);+ const parsed = projectPlistValue(parseBinary(decoded));+ expect(+ createPlistNumberProjection(metadata.literals).project(parsed.value),+ ).toEqual([+ { $plist_type: "integer", decimal: "18446744073709551618" },+ { $plist_type: "integer", decimal: "18446744073709551618" },+ { $plist_type: "integer", decimal: "1152921504606846979" },+ ]);+ expect(bytes).toEqual(original);+ });++ it("records a shared date once and keeps its sibling exact", () => {+ const date = Buffer.alloc(9);+ date[0] = 0x33;+ date.writeDoubleBE(0.1005, 1);+ const bytes = sharedScalarEntries(date);+ const scalarPlan = plan(bytes);+ const metadata = scanBinaryPlistScalars(bytes, scalarPlan);++ expect(metadata.literals.incomplete).toBe(false);+ expect(metadata.dates).toEqual([+ { offset: 12, payloadOffset: 13, secondsSince2001: 0.1005 },+ ]);+ const decoded = decodeBinaryPlistScalars(bytes, metadata, scalarPlan);+ const [first, second, sibling] = parseBinary(decoded) as [+ Date,+ Date,+ number,+ ];+ expect(Number.isNaN(first.getTime())).toBe(true);+ expect(Number.isNaN(second.getTime())).toBe(true);+ expect(+ createPlistNumberProjection(metadata.literals).project(sibling),+ ).toEqual({ $plist_type: "integer", decimal: "1152921504606846979" });+ });++ it("still reports metadata incomplete for an out-of-range entry", () => {+ const bytes = sharedScalarEntries(int64(9007199254740993n));+ expect(scanBinaryPlistScalars(bytes).literals.incomplete).toBe(false);+ // Repoint the duplicate into the header, before the object region.+ const table = Number(bytes.readBigUInt64BE(bytes.length - 8));+ bytes[table + 2] = 7;+ expect(bytes.subarray(0, 8).toString("ascii")).toBe("bplist00");+ expect(scanBinaryPlistScalars(bytes).literals.incomplete).toBe(true);+ });+});+describe("binary plist numeric association", () => {it("keeps an overlapping int64 exact without rewriting either object", () => {const bytes = integerPayloadContainingReal();diff --git a/src/artifacts/apple/PlistScalars.ts b/src/artifacts/apple/PlistScalars.tsindex ae25eb334..1566608f4 100644--- a/src/artifacts/apple/PlistScalars.ts+++ b/src/artifacts/apple/PlistScalars.ts@@ -191,10 +191,13 @@ export const scanBinaryPlistScalars = (});}}- if (!validOffsets.has(offset) || visitedOffsets.has(offset)) {+ if (!validOffsets.has(offset)) {incomplete = true;continue;}+ // Several table entries may share one record. Its source facts are+ // identical for every entry, so observe them once.+ if (visitedOffsets.has(offset)) continue;visitedOffsets.add(offset);const marker = bytes[offset] ?? 0;const type = marker >> 4;diff --git a/tests/boundary/filesystem/keyedArchiveNumberMetadata.test.ts b/tests/boundary/filesystem/keyedArchiveNumberMetadata.test.tsindex 54f54a4cf..9531fb743 100644--- a/tests/boundary/filesystem/keyedArchiveNumberMetadata.test.ts+++ b/tests/boundary/filesystem/keyedArchiveNumberMetadata.test.ts@@ -1,8 +1,13 @@+import { readFile } from "node:fs/promises";+import { expect, it } from "vitest";import { inspectBundleKeyedArchive } from "../../../src/artifacts/apple/KeyedArchiveReader.js";import { parseEvidence } from "../../../src/domain/evidence.js";-import { keyedArchiveWideIntegerFixture } from "../../fixtures/keyedArchiveWideIntegers.js";+import {+ keyedArchiveSharedEntryFixture,+ keyedArchiveWideIntegerFixture,+} from "../../fixtures/keyedArchiveWideIntegers.js";import {archiveNumberMetadataCases,expectKeyedArchiveNumberMetadata,@@ -75,6 +80,55 @@ cliTest(},);+const sharedEntryObjects = [+ expect.objectContaining({+ id: 1,+ status: "observed",+ value: { $plist_type: "integer", decimal: "9007199254740993" },+ }),+ expect.objectContaining({+ id: 2,+ status: "observed",+ value: { $plist_type: "integer", decimal: "9007199254740993" },+ }),+ expect.objectContaining({+ id: 3,+ status: "observed",+ value: { $plist_type: "integer", decimal: "1152921504606846979" },+ }),+];++it("keeps exact integers when two object-table entries share one record", async () => {+ const fixture = await keyedArchiveSharedEntryFixture();+ const result = await inspectBundleKeyedArchive({+ bundlePath: fixture.root,+ targetSha256: fixture.digest,+ parameters: { path: "archive.plist" },+ });+ expect(result.archive_sha256).toBe(fixture.digest);+ expect(result.objects.slice(1)).toEqual(sharedEntryObjects);+ expect(result.limitations).not.toContainEqual(+ expect.stringMatching(/metadata could not be completely observed/u),+ );+ expect(await readFile(fixture.path)).toEqual(fixture.bytes);+});++cliTest(+ "compiled CLI keeps exact integers when object-table entries share one record",+ async ({ cli }) => {+ const fixture = await keyedArchiveSharedEntryFixture();+ const output = await cli.run({+ arguments: ["inspect-keyed-archive", fixture.path, "--json"],+ environment: { REA_LOG_LEVEL: "silent", REA_ANALYSIS_PROVIDER: "auto" },+ });+ expect(output.exitCode, output.stderr).toBe(0);+ const result = parseEvidence(output.json).normalized_result as {+ objects: unknown[];+ };+ expect(result.objects.slice(1)).toEqual(sharedEntryObjects);+ },+);+it.each(archiveNumberMetadataCases)("filesystem preserves numeric meaning for $name",async (item) => {diff --git a/tests/fixtures/keyedArchiveWideIntegers.ts b/tests/fixtures/keyedArchiveWideIntegers.tsindex 4bf436248..91e708f47 100644--- a/tests/fixtures/keyedArchiveWideIntegers.ts+++ b/tests/fixtures/keyedArchiveWideIntegers.ts@@ -27,6 +27,58 @@ const integer64 = (value: bigint): Buffer => {return bytes;};+/**+ * Minimal valid NSKeyedArchiver whose object-table entries 10 and 11 both+ * point at one Int64 record, beside an unrelated Int64 sibling (entry 12).+ * The shared record is encoded once; only its offset is listed twice.+ */+const sharedEntryArchiveBytes = (): Buffer => {+ const objects = [+ Buffer.from([0xd3, 1, 3, 4, 2, 8, 5]), // root dict: three key/value pairs+ ascii("$archiver"),+ ascii("NSKeyedArchiver"),+ ascii("$objects"),+ ascii("$top"),+ Buffer.from([0xd1, 6, 7]), // $top.root -> UID 1+ ascii("root"),+ Buffer.from([0x80, 1]), // UID 1+ Buffer.from([0xa4, 9, 10, 11, 12]), // $objects refs+ ascii("$null"),+ integer64(9_007_199_254_740_993n),+ integer64(1_152_921_504_606_846_979n),+ ];+ const header = Buffer.from("bplist00", "ascii");+ const offsets: number[] = [];+ let position = header.length;+ for (const object of objects) {+ offsets.push(position);+ position += object.length;+ }+ // Entries 10 and 11 share the first Int64 record; entry 12 is the sibling.+ const [shared, sibling] = [offsets[10] ?? 0, offsets[11] ?? 0];+ offsets.splice(11, 1, shared, sibling);+ const trailer = Buffer.alloc(32);+ trailer[6] = 1;+ trailer[7] = 1;+ trailer.writeBigUInt64BE(BigInt(offsets.length), 8);+ trailer.writeBigUInt64BE(0n, 16);+ trailer.writeBigUInt64BE(BigInt(position), 24);+ return Buffer.concat([header, ...objects, Buffer.from(offsets), trailer]);+};++export const keyedArchiveSharedEntryFixture = async () => {+ const root = await createTestTempDirectory("rea-keyed-shared-entry-");+ const path = join(root, "archive.plist");+ const bytes = sharedEntryArchiveBytes();+ await writeFile(path, bytes);+ return {+ root,+ path,+ bytes,+ digest: createHash("sha256").update(bytes).digest("hex"),+ };+};+/** Minimal valid NSKeyedArchiver with a 16-byte integer and an Int64 control. */const archiveBytes = (): Buffer => {const objects = [