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): preserve mixed-slice signature observations (#5765)
Jeff89b1941c8e30
diff --git a/src/native/NativeMacOSProvider.ts b/src/native/NativeMacOSProvider.tsindex e48422cc7..3b3b565d0 100644--- a/src/native/NativeMacOSProvider.ts+++ b/src/native/NativeMacOSProvider.ts@@ -667,6 +667,10 @@ class NativeMacOSClient implements AnalysisClient {binding: SignatureTargetBinding,signal?: AbortSignal,): Promise<Result<InspectSignature, AnalysisError>> {+ const executablePaths = [+ binding.snapshotPath,+ ...(await canonicalPath(binding.snapshotPath)),+ ];const display = await this.#captureSignature(binding,["-d", "--verbose=4"],@@ -676,10 +680,12 @@ class NativeMacOSClient implements AnalysisClient {const unsigned = isNonzeroUnsignedObservation(display.value,binding.snapshotPath,+ executablePaths,);const displayFailure = codeSignCaptureFailure(display.value,binding.snapshotPath,+ executablePaths,);if (displayFailure !== null) return err(displayFailure);const requirements = await this.#captureSignature(@@ -691,6 +697,7 @@ class NativeMacOSClient implements AnalysisClient {const requirementsFailure = codeSignCaptureFailure(requirements.value,binding.snapshotPath,+ executablePaths,);if (requirementsFailure !== null) return err(requirementsFailure);const entitlements = await this.#captureSignature(@@ -702,13 +709,15 @@ class NativeMacOSClient implements AnalysisClient {const entitlementsFailure = codeSignCaptureFailure(entitlements.value,binding.snapshotPath,+ executablePaths,);if (entitlementsFailure !== null) return err(entitlementsFailure);// codesign echoes the resolved executable path in its diagnostics.- const parsed = parseCodeSignature(display.value.stderr, unsigned, [- binding.snapshotPath,- ...(await canonicalPath(binding.snapshotPath)),- ]);+ const parsed = parseCodeSignature(+ display.value.stderr,+ unsigned,+ executablePaths,+ );// The requirement is printed to stdout; stderr echoes the path.const requirementText =/designated\s*=>\s*(.+)$/mu.exec(requirements.value.stdout)?.[1] ?? null;@@ -727,49 +736,79 @@ class NativeMacOSClient implements AnalysisClient {];const mixedSigning =!unsigned &&- (isNonzeroUnsignedObservation(requirements.value, binding.snapshotPath) ||- isNonzeroUnsignedObservation(entitlements.value, binding.snapshotPath));+ (isNonzeroUnsignedObservation(+ requirements.value,+ binding.snapshotPath,+ executablePaths,+ ) ||+ isNonzeroUnsignedObservation(+ entitlements.value,+ binding.snapshotPath,+ executablePaths,+ ));+ const observation = () =>+ inspectSignatureSchema.parse({+ ...parsed,+ designated_requirement: requirementText,+ entitlements: entitlementValue.value,+ provenance: captures.map((capture) =>+ invocation(capture, binding.snapshotPath),+ ),+ limitations,+ });if (mixedSigning) {+ limitations.push(+ "Partial signature coverage: aggregate signing metadata describes codesign’s default slice; Mach-O slices have mixed signing states.",+ );const slices = await this.#inspectMixedSignatureSlices(binding,parsed.format,+ executablePaths,+ { captures, limitations },{requirements: requirements.value.exitCode,entitlements: entitlements.value.exitCode,},signal,);- if (!slices.ok) return slices;- captures.push(...slices.value.captures);- limitations.push(...slices.value.limitations);+ if (!slices.ok) {+ limitations.push(+ "Architecture-specific signature inspection did not complete; remaining slice signing states are unknown.",+ );+ return err(slices.error.retainPartialObservation(observation()));+ }}- const provenance = captures.map((capture) =>- invocation(capture, binding.snapshotPath),- );const version = await verifySignatureTarget(this.target, binding, signal);- if (!version.ok) return version;- const result = inspectSignatureSchema.parse({- ...parsed,- designated_requirement: requirementText,- entitlements: entitlementValue.value,- provenance,- limitations,- });- return ok(result);+ if (!version.ok)+ return err(version.error.retainPartialObservation(observation()));+ return ok(observation());}async #inspectMixedSignatureSlices(binding: SignatureTargetBinding,format: string | null,+ executablePaths: readonly string[],+ observation: { captures: NativeCommandCapture[]; limitations: string[] },aggregateExits: Readonly<{requirements: number | null;entitlements: number | null;}>,signal?: AbortSignal,- ): Promise<Result<MixedSignatureSlices, AnalysisError>> {- const captures: NativeCommandCapture[] = [];+ ): Promise<Result<void, AnalysisError>> {+ const { captures, limitations } = observation;const unsigned: string[] = [];- const unclassified: string[] = [];+ const unsignedNote = limitations.length;+ limitations.push(+ "One or more Mach-O slices are unsigned, but their architectures could not be classified.",+ );+ if (aggregateExits.requirements !== 0)+ limitations.push(+ "The aggregate designated requirement is unavailable because Mach-O slices have mixed signing states.",+ );+ if (aggregateExits.entitlements !== 0)+ limitations.push(+ "The aggregate entitlements are unavailable because Mach-O slices have mixed signing states.",+ );for (const architecture of codeSignArchitectures(format, this.target)) {const slice = await this.#captureSignature(binding,@@ -779,28 +818,17 @@ class NativeMacOSClient implements AnalysisClient {if (!slice.ok) return slice;captures.push(slice.value);if (slice.value.exitCode === 0) continue;- if (isNonzeroUnsignedObservation(slice.value, binding.snapshotPath))- unsigned.push(architecture);- else unclassified.push(architecture);- }- const limitations = [- unsigned.length > 0- ? `Unsigned Mach-O slices: ${unsigned.join(", ")}.`- : "One or more Mach-O slices are unsigned, but their architectures could not be classified.",- ];- if (unclassified.length > 0)- limitations.push(- `Signature state could not be classified for Mach-O slices: ${unclassified.join(", ")}.`,- );- if (aggregateExits.requirements !== 0)- limitations.push(- "The aggregate designated requirement is unavailable because Mach-O slices have mixed signing states.",- );- if (aggregateExits.entitlements !== 0)- limitations.push(- "The aggregate entitlements are unavailable because Mach-O slices have mixed signing states.",+ const failure = codeSignCaptureFailure(+ slice.value,+ binding.snapshotPath,+ executablePaths,);- return ok({ captures, limitations });+ if (failure !== null) return err(failure);+ unsigned.push(architecture);+ limitations[unsignedNote] =+ `Unsigned Mach-O slices: ${unsigned.join(", ")}.`;+ }+ return ok(undefined);}async #captureSignature(@@ -1131,11 +1159,6 @@ interface NativeObservation {readonly locations: readonly EvidenceLocation[];}-interface MixedSignatureSlices {- readonly captures: readonly NativeCommandCapture[];- readonly limitations: readonly string[];-}-const isNativeOperation = (operation: AnalysisOperation,): operation is NativeToolName =>@@ -1318,13 +1341,15 @@ const translateCodeSignExitFailure = ();/**- * Accept only codesign's exact unsigned diagnostic for the bound snapshot.+ * Accept only codesign's exact unsigned diagnostic for the bound snapshot,+ * optionally preceded by its verified Executable path echo.* The operand is framed byte-for-byte so caller-controlled path text cannot* supply the phrase that determines signature state.*/const isNonzeroUnsignedObservation = (capture: NativeCommandCapture,snapshotPath: string,+ executablePaths: readonly string[],): boolean => {if (capture.exitCode === null ||@@ -1335,8 +1360,16 @@ const isNonzeroUnsignedObservation = ()return false;const diagnostic = `${snapshotPath}: code object is not signed at all`;- return [diagnostic, `${diagnostic}\n`, `${diagnostic}\r\n`].includes(- capture.stderr,+ return [+ "",+ ...executablePaths.flatMap((path) => [+ `Executable=${path}\n`,+ `Executable=${path}\r\n`,+ ]),+ ].some((prefix) =>+ [diagnostic, `${diagnostic}\n`, `${diagnostic}\r\n`].some(+ (body) => capture.stderr === `${prefix}${body}`,+ ),);};@@ -1351,8 +1384,10 @@ const canonicalPath = async (path: string): Promise<string[]> => {const codeSignCaptureFailure = (capture: NativeCommandCapture,snapshotPath: string,+ executablePaths: readonly string[],): AnalysisError | null =>- capture.exitCode === 0 || isNonzeroUnsignedObservation(capture, snapshotPath)+ capture.exitCode === 0 ||+ isNonzeroUnsignedObservation(capture, snapshotPath, executablePaths)? null: translateCodeSignExitFailure(capture);diff --git a/tests/boundary/providers/native/nativeInventory.golden.test.ts b/tests/boundary/providers/native/nativeInventory.golden.test.tsindex 5e1824e80..cee8136c3 100644--- a/tests/boundary/providers/native/nativeInventory.golden.test.ts+++ b/tests/boundary/providers/native/nativeInventory.golden.test.ts@@ -1,4 +1,5 @@-import { writeFile } from "node:fs/promises";+import { inspectSignatureSchema } from "../../../../src/domain/native/nativeInspection.js";+import { realpath, writeFile } from "node:fs/promises";import { join } from "node:path";import { expect, it } from "vitest";import {@@ -96,7 +97,7 @@ it("reports unsigned slices when a universal Mach-O has mixed signatures", async);const client = new NativeMacOSProvider({},- signatureRunner({ signed, unsigned, entitlements }),+ signatureRunner({ signed, unsigned, entitlements, unsignedHeader: true }),"darwin",).createClient(await signatureTarget(signedArchitecture));@@ -110,6 +111,7 @@ it("reports unsigned slices when a universal Mach-O has mixed signatures", asyncdesignated_requirement: null,entitlements: { "com.apple.security.app-sandbox": true },limitations: expect.arrayContaining([+ "Partial signature coverage: aggregate signing metadata describes codesign’s default slice; Mach-O slices have mixed signing states.","Unsigned Mach-O slices: x86_64.","The aggregate designated requirement is unavailable because Mach-O slices have mixed signing states.",]),@@ -155,6 +157,99 @@ it("rejects nonzero supplemental codesign output that is not an unsigned observa});});+it.each([+ "extra diagnostic",+ "foreign executable",+ "slice diagnostic",+ "later slice diagnostic",+])("rejects an unsigned response with %s", async (kind) => {+ const signed = (await fixture("codesign.txt")).replace(+ /^Format=.*$/mu,+ "Format=Mach-O universal (x86_64 arm64)",+ );+ const replay = signatureRunner({+ signed,+ unsigned: "code object is not signed at all",+ entitlements: await fixture("entitlements.xml"),+ unsignedHeader: true,+ });+ const runner: NativeCommandRunner = {+ async run(tool, args, options) {+ const result = await replay.run(tool, args, options);+ if (!result.ok) return result;+ if (kind === "later slice diagnostic") {+ if (!args.includes("arm64")) return result;+ const stderr = "later architecture probe failed\n";+ return ok({+ ...result.value,+ exitCode: 1,+ stderr,+ stderrBytes: Buffer.byteLength(stderr),+ });+ }+ if (result.value.exitCode === 0) return result;+ const isSlice = args.includes("-a");+ if ((kind === "slice diagnostic") !== isSlice) return result;+ const stderr =+ kind === "foreign executable"+ ? result.value.stderr.replace(+ /^Executable=.*\n/u,+ "Executable=/foreign/program\n",+ )+ : `${result.value.stderr}additional codesign failure\n`;+ return ok({+ ...result.value,+ stderr,+ stderrBytes: Buffer.byteLength(stderr),+ });+ },+ };+ const result = await new NativeMacOSProvider({}, runner, "darwin")+ .createClient(await signatureTarget())+ .execute("inspect_signature", {});+ expect(result).toMatchObject({+ ok: false,+ error: { _tag: "ProviderAdapterError" },+ });+ if (kind.endsWith("slice diagnostic") && !result.ok) {+ const partial = inspectSignatureSchema.parse(+ result.error.partialObservation,+ );+ expect(partial).toMatchObject({+ signed: true,+ identifier: "com.example.fixture",+ entitlements: { "com.apple.security.app-sandbox": true },+ designated_requirement: null,+ limitations: expect.arrayContaining([+ expect.stringContaining("Partial signature coverage"),+ expect.stringContaining("did not complete"),+ ]),+ });+ expect(partial.provenance).toHaveLength(+ kind === "later slice diagnostic" ? 5 : 4,+ );+ expect(partial.provenance[0]?.command).toContain("--verbose=4");+ expect(partial.provenance[1]?.command).toContain("-r-");+ expect(partial.provenance[2]?.command).toContain("--entitlements");+ if (kind === "later slice diagnostic") {+ expect(partial.limitations).toEqual(+ expect.arrayContaining([+ "Unsigned Mach-O slices: x86_64.",+ "The aggregate designated requirement is unavailable because Mach-O slices have mixed signing states.",+ ]),+ );+ expect(partial.provenance[4]).toMatchObject({+ command: expect.arrayContaining(["-a", "arm64"]),+ exit: { code: 1, signal: null },+ });+ }+ expect(partial.provenance[3]).toMatchObject({+ command: expect.arrayContaining(["-a", "x86_64"]),+ exit: { code: 1, signal: null },+ });+ }+});+it("retains native inventory facts from captured Apple tool output", async () => {const outputs: Record<string, string> = {};for (const tool of ["lipo", "otool", "nm", "dwarfdump", "vtool"])@@ -403,8 +498,9 @@ const signatureRunner = (outputs: {readonly signed: string;readonly unsigned: string;readonly entitlements: string;+ readonly unsignedHeader?: boolean;}): NativeCommandRunner => ({- run(+ async run(tool: string,arguments_: readonly string[],options: NativeCommandOptions,@@ -424,7 +520,7 @@ const signatureRunner = (outputs: {selectedResponse.output.includes("code object is not signed at all")? {...selectedResponse,- output: `${arguments_.at(-1)}: code object is not signed at all\n`,+ output: `${outputs.unsignedHeader ? `Executable=${await realpath(arguments_.at(-1)!)}\n` : ""}${arguments_.at(-1)}: code object is not signed at all\n`,}: selectedResponse;const capture: NativeCommandCapture = {