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(native): report unidentified text plists as unknown (#4320)
You Wish4e14452ddbf4
diff --git a/docs/native-investigation.md b/docs/native-investigation.mdindex 6d0dffc33..e7fdd3f16 100644--- a/docs/native-investigation.md+++ b/docs/native-investigation.md@@ -261,6 +261,13 @@ Mach-O fixtures check each case against source-owned return values.## Static inspection+`inspect_plist.format` describes the selected source, not plutil's conversion+format. Sources explicitly identified as XML, binary or JSON retain those+labels. For generic text, a bounded source-prefix probe recognizes leading XML+markup, including UTF-8 and BOM-marked UTF-16 sources. Unidentified text and+OpenStep plists, including a data-only value such as `<deadbeef>`, report+`unknown` even when plutil decodes their values through an XML conversion.+`inspect_macho.selected_architecture` identifies the exact selected lipo sliceand its `container_file_offset` in the input file. A thin Mach-O has a knownoffset of zero; an unknown universal-slice offset stays null. The Evidencediff --git a/src/native/NativeMacOSProvider.ts b/src/native/NativeMacOSProvider.tsindex 8e7c938cf..13d319840 100644--- a/src/native/NativeMacOSProvider.ts+++ b/src/native/NativeMacOSProvider.ts@@ -822,12 +822,14 @@ class NativeMacOSClient implements AnalysisClient {json.value,...(xml === undefined ? [] : [xml.value]),].map((item) => invocation(item, plist.value, "$PLIST"));+ const format = await plistSourceFormat(+ classified.value.stdout,+ plist.value,+ requested,+ );+ if (!format.ok) return format;const result = inspectPlistSchema.parse({- format: /binary property list/iu.test(classified.value.stdout)- ? "binary"- : /XML|text/iu.test(classified.value.stdout)- ? "xml"- : "unknown",+ format: format.value,value: parsed.value.value,bundle: parsed.value.bundle,source_path: plist.value,@@ -1175,6 +1177,58 @@ const plutilDiagnostic = (stderr: string, path: string): string => {return text.startsWith(`${path}: `) ? text.slice(path.length + 2) : text;};+/** Bytes examined for leading markup when `file` reports only text. */+const PLIST_MARKUP_PROBE_BYTES = 4_096;++/**+ * Preserve explicit source identities. For generic text, recognize XML+ * markup rather than a lone `<`, which also opens an OpenStep data value.+ * A prefix without recognizable markup stays unknown.+ */+const plistSourceFormat = async (+ description: string,+ path: string,+ requested: string | undefined,+): Promise<Result<"binary" | "xml" | "json" | "unknown", AnalysisError>> => {+ if (/binary property list/iu.test(description)) return ok("binary");+ if (/\bXML\b/iu.test(description)) return ok("xml");+ if (/\bJSON\b/iu.test(description)) return ok("json");+ if (!/\btext\b/iu.test(description)) return ok("unknown");+ try {+ const handle = await open(path, "r");+ try {+ const head = Buffer.alloc(PLIST_MARKUP_PROBE_BYTES);+ const { bytesRead } = await handle.read(head, 0, head.length, 0);+ const encoding =+ head[0] === 0xff && head[1] === 0xfe+ ? "utf-16le"+ : head[0] === 0xfe && head[1] === 0xff+ ? "utf-16be"+ : "utf-8";+ const text = new TextDecoder(encoding)+ .decode(head.subarray(0, bytesRead))+ .trimStart();+ return ok(+ /^<(?:[!?]|(?:plist|dict|array|string|integer|real|data|date|true|false)[\s/>])/u.test(+ text,+ )+ ? "xml"+ : "unknown",+ );+ } finally {+ await handle.close();+ }+ } catch (cause: unknown) {+ const code =+ cause instanceof Error && "code" in cause ? cause.code : undefined;+ if (code === "ENOENT" || code === "ENOTDIR")+ return err(unreadablePlist(path, requested, "no file exists there"));+ return err(+ new ProviderAdapterError(IDENTITY.id, "inspect_plist", { cause }),+ );+ }+};+/*** Admit a readable regular file before plutil runs, so a later plutil failure* reflects the bytes rather than a missing path or a host permission denial.diff --git a/tests/boundary/cli/nativePlistCli.test.ts b/tests/boundary/cli/nativePlistCli.test.tsindex 62ec9ce98..d63fdbffd 100644--- a/tests/boundary/cli/nativePlistCli.test.ts+++ b/tests/boundary/cli/nativePlistCli.test.ts@@ -75,7 +75,104 @@ describe.skipIf(process.platform !== "darwin")(}},);+ },+);++describe.skipIf(process.platform !== "darwin")(+ "native plist CLI source formats",+ () => {+ cliTest.for([+ ["openstep", "unknown"],+ ["openstep-data", "unknown"],+ ["openstep-data-root", "unknown"],+ ["openstep-empty-data", "unknown"],+ ["xml", "xml"],+ ["xml16", "xml"],+ ["binary", "binary"],+ ] as const)(+ "reports the original $0 plist format through the compiled CLI",+ async ([encoding, format], { cli }) => {+ const directory = await createTestTempDirectory("rea-plist-format-");+ const target = join(directory, "target");+ const plist = join(directory, "selected.plist");+ const withData = encoding === "openstep-data";+ const dataRoot = encoding === "openstep-data-root";+ const emptyData = encoding === "openstep-empty-data";+ await writeFile(target, thinMach(0xfeedfacf, 0x0100000c));+ await writeFile(+ plist,+ dataRoot+ ? "<deadbeef>\n"+ : emptyData+ ? "<>\n"+ : `{ Name = Example; Items = (a, b); ${withData ? "Blob = <deadbeef>;" : ""} }\n`,+ );+ if (encoding === "binary" || encoding.startsWith("xml")) {+ await promisify(execFile)("/usr/bin/plutil", [+ "-convert",+ encoding === "binary" ? "binary1" : "xml1",+ "--",+ plist,+ ]);+ if (encoding === "xml16") {+ const { stdout } = await promisify(execFile)("/usr/bin/plutil", [+ "-convert",+ "xml1",+ "-o",+ "-",+ "--",+ plist,+ ]);+ await writeFile(+ plist,+ Buffer.concat([+ Buffer.from([0xfe, 0xff]),+ Buffer.from(+ stdout.replace("UTF-8", "UTF-16"),+ "utf16le",+ ).swap16(),+ ]),+ );+ }+ }+ const result = await cli.run({+ arguments: [+ "inspect-plist",+ target,+ "--relative-path",+ plist,+ "--json",+ ],+ environment: {+ REA_LOG_LEVEL: "silent",+ REA_ANALYSIS_PROVIDER: "auto",+ },+ });+ expect(result.exitCode, result.stderr).toBe(0);+ expect(result.json).toMatchObject({+ normalized_result: {+ format,+ source_path: plist,+ value:+ dataRoot || emptyData+ ? { $plist_type: "data", base64: emptyData ? "" : "3q2+7w==" }+ : {+ Name: "Example",+ Items: ["a", "b"],+ ...(withData+ ? { Blob: { $plist_type: "data", base64: "3q2+7w==" } }+ : {}),+ },+ },+ });+ },+ );+ },+);+describe.skipIf(process.platform !== "darwin")(+ "native plist CLI typed values",+ () => {cliTest.for(["xml", "binary"] as const)("decodes $0 plists that plutil cannot express as JSON",async (format, { cli }) => {diff --git a/tests/boundary/providers/native/plistSourceFormat.test.ts b/tests/boundary/providers/native/plistSourceFormat.test.tsnew file mode 100644index 000000000..ab267b576--- /dev/null+++ b/tests/boundary/providers/native/plistSourceFormat.test.ts@@ -0,0 +1,155 @@+import { writeFile } from "node:fs/promises";+import { join } from "node:path";++import { expect, it } from "vitest";++import { inspectPlistSchema } from "../../../../src/domain/native/nativeInspection.js";+import { ok } from "../../../../src/domain/result.js";+import { NativeMacOSProvider } from "../../../../src/native/NativeMacOSProvider.js";+import {+ NativeFixtureRunner,+ nativeMachoTarget,+} from "../../../fixtures/nativeCommands.js";+import { createTestTempDirectory } from "../../../fixtures/temporaryDirectory.js";++const VALUE = { Name: "Example", Items: ["a", "b"] };+const XML =+ "<plist><dict><key>Name</key><string>Example</string><key>Items</key><array><string>a</string><string>b</string></array><key>Blob</key><data>3q2+7w==</data></dict></plist>";+const DATA = { $plist_type: "data", base64: "3q2+7w==" };++class PlistSourceRunner extends NativeFixtureRunner {+ constructor(+ description: string,+ private readonly xmlFallback: boolean,+ private readonly convertedXml: string = XML,+ ) {+ super({ file: description, plutil: JSON.stringify(VALUE) });+ }++ override async run(tool: string, arguments_: readonly string[]) {+ const result = await super.run(tool, arguments_);+ if (!result.ok || tool !== "plutil" || !this.xmlFallback) return result;+ const json = arguments_.includes("json");+ const stdout = json ? "" : this.convertedXml;+ return ok({+ ...result.value,+ stdout,+ stdoutBytes: Buffer.byteLength(stdout),+ exitCode: json ? 1 : 0,+ });+ }+}++const OPENSTEP = "{ Name = Example; Items = (a, b); }\n";++interface PlistSourceCase {+ readonly description: string;+ readonly contents?: string | Buffer;+ readonly expected: string;+ readonly xmlFallback: boolean;+ readonly convertedXml?: string;+ readonly expectedValue?: unknown;+}++it.for<PlistSourceCase>([+ { description: "ASCII text\n", expected: "unknown", xmlFallback: false },+ {+ description: "JSON text data\n",+ contents: JSON.stringify(VALUE),+ expected: "json",+ xmlFallback: false,+ },+ ...["<deadbeef>\n", "<de ad\nbe ef>\n", "<>\n"].map((contents) => ({+ description: "ASCII text\n",+ contents,+ expected: "unknown",+ xmlFallback: true,+ convertedXml: `<plist><data>${contents.startsWith("<>") ? "" : DATA.base64}</data></plist>`,+ expectedValue: {+ ...DATA,+ base64: contents.startsWith("<>") ? "" : DATA.base64,+ },+ })),+ // `file` reports XML without a declaration as plain text.+ {+ description: "ASCII text, with no line terminators\n",+ contents: ` \n${XML}`,+ expected: "xml",+ xmlFallback: true,+ },+ {+ description: "ASCII text\n",+ contents: `<!-- source plist -->\n${XML}`,+ expected: "xml",+ xmlFallback: true,+ },+ ...[false, true].map((bigEndian) => ({+ description: `Unicode text, UTF-16, ${bigEndian ? "big" : "little"}-endian text\n`,+ contents: bigEndian+ ? Buffer.from(`\uFEFF${XML}`, "utf16le").swap16()+ : Buffer.from(`\uFEFF${XML}`, "utf16le"),+ expected: "xml",+ xmlFallback: true,+ })),+ { description: "ASCII text\n", expected: "unknown", xmlFallback: true },+ {+ description: "Unicode text, UTF-8 text\n",+ expected: "unknown",+ xmlFallback: false,+ },+ {+ description: "XML 1.0 document text, ASCII text\n",+ expected: "xml",+ xmlFallback: false,+ },+ {+ description:+ "XML 1.0 document text, Unicode text, UTF-16, big-endian text\n",+ expected: "xml",+ xmlFallback: true,+ },+ {+ description: "Apple binary property list\n",+ expected: "binary",+ xmlFallback: true,+ },+])(+ "keeps source format $expected for $description (XML fallback: $xmlFallback)",+ async (+ {+ description,+ contents = OPENSTEP,+ expected,+ xmlFallback,+ convertedXml = XML,+ expectedValue = { ...VALUE, ...(xmlFallback ? { Blob: DATA } : {}) },+ },+ { onTestFinished },+ ) => {+ const root = await createTestTempDirectory("rea-plist-source-format-");+ const path = join(root, "selected.plist");+ await writeFile(path, contents);+ const client = new NativeMacOSProvider(+ {},+ new PlistSourceRunner(description, xmlFallback, convertedXml),+ "darwin",+ ).createClient(nativeMachoTarget(join(root, "target")));+ onTestFinished(async () => {+ const closed = await client.close();+ if (!closed.ok) throw closed.error;+ });++ const inspected = await client.execute("inspect_plist", { path });+ if (!inspected.ok) throw inspected.error;+ const result = inspectPlistSchema.parse(inspected.value.result);+ expect(result.format).toBe(expected);+ expect(result.source_path).toBe(path);+ expect(result.value).toEqual(expectedValue);+ expect(result.provenance.map(({ tool }) => tool)).toEqual(+ xmlFallback ? ["file", "plutil", "plutil"] : ["file", "plutil"],+ );+ expect(result.limitations).toEqual(+ xmlFallback ? [expect.stringContaining("XML conversion")] : [],+ );+ },+);