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(evidence): retain unreadable PE and Darwin process facts
morluto4a4d36f88186
diff --git a/bridge/process/ProcessRunTokenReader.swift b/bridge/process/ProcessRunTokenReader.swiftindex 21a2726fb..d4b21fe51 100644--- a/bridge/process/ProcessRunTokenReader.swift+++ b/bridge/process/ProcessRunTokenReader.swift@@ -112,6 +112,11 @@ enum RunTokenReadError: Error {case ambiguousEnvironmentBoundary}+struct ParsedRunToken {+ let runId: String?+ let environmentEntryCount: Int+}+@_silgen_name("csops")private func csops(_ pid: Int32,@@ -122,19 +127,67 @@ private func csops(private let csOpsStatus: UInt32 = 0private let csPlatformBinary: UInt32 = 0x0400_0000+private let csRestrict: UInt32 = 0x0000_0800-/**- * Whether the target image is an Apple platform binary. Current macOS omits- * the environment of platform binaries from KERN_PROCARGS2 for every caller,- * so this distinguishes a policy-withheld environment from a process whose- * environment is genuinely absent or transiently unreadable.- */-func isPlatformBinary(pid: Int32) -> Bool {+/** Read the target's current code-signing flags when csops permits inspection. */+private func codeSigningFlags(pid: Int32) -> UInt32? {var flags: UInt32 = 0let result = withUnsafeMutablePointer(to: &flags) { pointer incsops(pid, csOpsStatus, UnsafeMutableRawPointer(pointer), MemoryLayout<UInt32>.size)}- return result == 0 && (flags & csPlatformBinary) != 0+ return result == 0 ? flags : nil+}++/** Derive one process-token observation from parser facts and native flags. */+func processRunTokenObservation(+ pid: Int32,+ parse: Result<ParsedRunToken, RunTokenReadError>,+ codeSigningFlags: () -> UInt32?+) -> RunTokenObservation {+ switch parse {+ case .success(let parsed):+ if let runId = parsed.runId {+ return RunTokenObservation(pid: pid, state: "readable", run_id: runId, reason: nil)+ }+ // A non-empty environment without REA's token proves this candidate is+ // unrelated. CS_RESTRICT cannot turn that readable fact into uncertainty.+ if parsed.environmentEntryCount > 0 {+ return RunTokenObservation(pid: pid, state: "readable", run_id: nil, reason: nil)+ }+ let flags = codeSigningFlags()+ if let flags, (flags & csPlatformBinary) != 0 {+ return unavailable(pid: pid, reason: "platform_binary_environment_withheld")+ }+ if let flags, (flags & csRestrict) != 0 {+ return unavailable(pid: pid, reason: "restricted_process_environment_withheld")+ }+ return RunTokenObservation(pid: pid, state: "readable", run_id: nil, reason: nil)+ case .failure(let failure):+ switch failure {+ case .environmentUnavailable:+ let flags = codeSigningFlags()+ if let flags, (flags & csPlatformBinary) != 0 {+ return unavailable(pid: pid, reason: "platform_binary_environment_withheld")+ }+ if let flags, (flags & csRestrict) != 0 {+ return unavailable(pid: pid, reason: "restricted_process_environment_withheld")+ }+ return unavailable(pid: pid, reason: "environment_unavailable")+ case .ambiguousEnvironmentBoundary:+ if let flags = codeSigningFlags(), (flags & csRestrict) != 0 {+ return unavailable(pid: pid, reason: "restricted_process_environment_withheld")+ }+ return unavailable(pid: pid, reason: "ambiguous_environment_boundary")+ case .duplicateToken:+ return unavailable(pid: pid, reason: "duplicate_run_token")+ case .invalidTokenEncoding:+ return unavailable(pid: pid, reason: "invalid_run_token_encoding")+ case .appleVectorUnavailable:+ return unavailable(pid: pid, reason: "apple_vector_unavailable")+ case .invalidBuffer:+ return unavailable(pid: pid, reason: "malformed_procargs")+ }+ }}private func readRunToken(pid: Int32, pointerSize: Int) -> RunTokenObservation {@@ -151,33 +204,19 @@ private func readRunToken(pid: Int32, pointerSize: Int) -> RunTokenObservation {return unavailable(pid: pid, reason: "sysctl_failed_\(errno)")}bytes = Array(bytes.prefix(size))+ let parse: Result<ParsedRunToken, RunTokenReadError>do {- let runId = try token(in: bytes, pointerSize: pointerSize)- // A complete empty environment is readable for an ordinary image. Apple- // platform images can expose the same layout after the kernel withholds- // their environment, so they remain explicitly unverified without a token.- if runId == nil && isPlatformBinary(pid: pid) {- return unavailable(pid: pid, reason: "platform_binary_environment_withheld")- }- return RunTokenObservation(pid: pid, state: "readable", run_id: runId, reason: nil)- } catch RunTokenReadError.duplicateToken {- return unavailable(pid: pid, reason: "duplicate_run_token")- } catch RunTokenReadError.invalidTokenEncoding {- return unavailable(pid: pid, reason: "invalid_run_token_encoding")- } catch RunTokenReadError.environmentUnavailable {- return unavailable(- pid: pid,- reason: isPlatformBinary(pid: pid)- ? "platform_binary_environment_withheld"- : "environment_unavailable"- )- } catch RunTokenReadError.appleVectorUnavailable {- return unavailable(pid: pid, reason: "apple_vector_unavailable")- } catch RunTokenReadError.ambiguousEnvironmentBoundary {- return unavailable(pid: pid, reason: "ambiguous_environment_boundary")+ parse = .success(try parseProcessEnvironment(in: bytes, pointerSize: pointerSize))+ } catch let failure as RunTokenReadError {+ parse = .failure(failure)} catch {- return unavailable(pid: pid, reason: "malformed_procargs")+ parse = .failure(.invalidBuffer)}+ return processRunTokenObservation(+ pid: pid,+ parse: parse,+ codeSigningFlags: { codeSigningFlags(pid: pid) }+ )}func readRunTokens(pids: [Int32]) -> [RunTokenObservation] {@@ -201,7 +240,10 @@ func readRunTokens(pids: [Int32]) -> [RunTokenObservation] {}}-func token(in bytes: [UInt8], pointerSize: Int = MemoryLayout<UnsafeRawPointer>.size) throws -> String? {+func parseProcessEnvironment(+ in bytes: [UInt8],+ pointerSize: Int = MemoryLayout<UnsafeRawPointer>.size+) throws -> ParsedRunToken {guard bytes.count >= MemoryLayout<Int32>.size else { throw RunTokenReadError.invalidBuffer }let argc = bytes.withUnsafeBytes { $0.loadUnaligned(as: Int32.self).littleEndian }guard argc >= 0, Int(argc) <= bytes.count else { throw RunTokenReadError.invalidBuffer }@@ -277,7 +319,7 @@ func token(in bytes: [UInt8], pointerSize: Int = MemoryLayout<UnsafeRawPointer>.found = decoded}}- return found+ return ParsedRunToken(runId: found, environmentEntryCount: environmentEntries.count)}private func readString(diff --git a/src/dotnet/ManagedArtifactInspector.test.ts b/src/dotnet/ManagedArtifactInspector.test.tsindex 3fc74337e..2d30bf580 100644--- a/src/dotnet/ManagedArtifactInspector.test.ts+++ b/src/dotnet/ManagedArtifactInspector.test.ts@@ -22,6 +22,163 @@ const metadataLayoutFor = (bytes: Buffer) => {);};+const resizedOptionalHeader = (+ size: number,+ magic: number,+): { readonly bytes: Buffer; readonly optional: number } => {+ const bytes = buildManagedPeFixture();+ const coff = bytes.readUInt32LE(0x3c) + 4;+ const optional = coff + 20;+ const originalSize = bytes.readUInt16LE(coff + 16);+ const section = Buffer.from(+ bytes.subarray(optional + originalSize, optional + originalSize + 40),+ );+ section.copy(bytes, optional + size);+ bytes.writeUInt16LE(size, coff + 16);+ bytes.writeUInt16LE(magic, optional);+ return { bytes, optional };+};++describe("managed PE optional-header directory count", () => {+ it.each([96, 108, 111])(+ "retains an unreadable PE32+ directory count at optional size %i",+ (optionalSize) => {+ const { bytes, optional } = resizedOptionalHeader(optionalSize, 0x020b);+ // The section's first four bytes look like a count that excludes CLI.+ bytes.writeUInt32LE(14, optional + optionalSize);++ const layout = readManagedPeLayout(bytes);+ expect(layout).toMatchObject({+ optionalHeader: "pe32-plus",+ machine: 0x014c,+ cli: null,+ cliDirectoryState: "unreadable",+ cliIssue: {+ code: "invalid-directory",+ scope: "pe.optional-header",+ },+ });+ const result = inspectManagedArtifactBytes(+ bytes,+ managedPeFixtureTarget(bytes),+ );+ expect(result.classification.status).toBe("malformed");+ expect(result.metadata.status).toBe("malformed");+ expect(result.coverage.issues).toContainEqual(+ expect.objectContaining({+ code: "invalid-directory",+ scope: "pe.optional-header",+ }),+ );+ },+ );++ it.each([+ { size: 96, magic: 0x010b, countOffset: 92, header: "pe32" },+ { size: 112, magic: 0x020b, countOffset: 108, header: "pe32-plus" },+ ])("accepts a minimum $header header with no CLI directory", (fixture) => {+ const { bytes, optional } = resizedOptionalHeader(+ fixture.size,+ fixture.magic,+ );+ bytes.writeUInt32LE(0, optional + fixture.countOffset);++ expect(readManagedPeLayout(bytes)).toMatchObject({+ optionalHeader: fixture.header,+ cli: null,+ cliDirectoryState: "absent",+ cliIssue: null,+ });+ });+});++describe("managed CLI directory availability", () => {+ it("keeps a declared but truncated CLI directory malformed", () => {+ const bytes = buildManagedPeFixture();+ const peOffset = bytes.readUInt32LE(0x3c);+ const coff = peOffset + 4;+ const optional = coff + 20;+ const originalOptionalSize = bytes.readUInt16LE(coff + 16);+ const truncatedOptionalSize = 96 + 14 * 8 + 7;+ const sectionHeader = Buffer.from(+ bytes.subarray(+ optional + originalOptionalSize,+ optional + originalOptionalSize + 40,+ ),+ );+ sectionHeader.copy(bytes, optional + truncatedOptionalSize);+ bytes.writeUInt16LE(truncatedOptionalSize, coff + 16);+ bytes.writeUInt32LE(15, optional + 92);++ const layout = readManagedPeLayout(bytes);+ expect(layout).toMatchObject({+ cli: null,+ cliDirectoryState: "unreadable",+ cliIssue: {+ code: "invalid-directory",+ scope: "pe.data-directories",+ },+ });++ const target = managedPeFixtureTarget(bytes);+ const results = [+ inspectManagedArtifactBytes(bytes, target),+ inspectManagedMembersBytes(bytes, target),+ inspectManagedNativeBoundariesBytes(bytes, target),+ ];+ for (const [index, result] of results.entries()) {+ expect(result.metadata.status).toBe("malformed");+ expect(result.coverage).toMatchObject({+ state: index === 0 ? "partial" : "unavailable",+ issues: [+ expect.objectContaining({+ code: "invalid-directory",+ scope: "pe.data-directories",+ }),+ ],+ });+ }+ });++ it("treats a CLI directory excluded by NumberOfRvaAndSizes as absent", () => {+ const bytes = buildManagedPeFixture();+ const peOffset = bytes.readUInt32LE(0x3c);+ const optional = peOffset + 4 + 20;+ bytes.writeUInt32LE(14, optional + 92);++ const layout = readManagedPeLayout(bytes);+ expect(layout).toMatchObject({+ cli: null,+ cliDirectoryState: "absent",+ cliIssue: null,+ });+ const result = inspectManagedArtifactBytes(+ bytes,+ managedPeFixtureTarget(bytes),+ );+ expect(result.classification.status).toBe("not-managed");+ expect(result.metadata.status).toBe("absent");+ });++ it("retains an in-range CLI directory when the count overstates later entries", () => {+ const bytes = buildManagedPeFixture();+ const peOffset = bytes.readUInt32LE(0x3c);+ const optional = peOffset + 4 + 20;+ bytes.writeUInt32LE(17, optional + 92);++ const layout = readManagedPeLayout(bytes);+ expect(layout.cliDirectoryState).toBe("present");+ expect(layout.cliIssue).toBeNull();+ expect(layout.cli).not.toBeNull();+ const result = inspectManagedArtifactBytes(+ bytes,+ managedPeFixtureTarget(bytes),+ );+ expect(result.classification.status).toBe("managed");+ expect(result.metadata.status).toBe("complete");+ });+});+describe("managed artifact inventory", () => {it.each([{ moduleRowCount: 0, assemblyRowCount: 1, scope: "metadata.Module" },diff --git a/src/dotnet/ManagedArtifactInspector.ts b/src/dotnet/ManagedArtifactInspector.tsindex cd0d627b0..7df8aae83 100644--- a/src/dotnet/ManagedArtifactInspector.ts+++ b/src/dotnet/ManagedArtifactInspector.ts@@ -102,7 +102,7 @@ const unavailableResult = (bytes: Buffer,layout: ManagedPeLayout,): ManagedArtifactInspection => {- const malformed = layout.cliDirectoryPresent;+ const malformed = layout.cliDirectoryState !== "absent";const issues = layout.cliIssue === null ? [] : [layout.cliIssue];const limitations = malformed? [diff --git a/src/dotnet/ManagedNativeBoundaryInspector.ts b/src/dotnet/ManagedNativeBoundaryInspector.tsindex 22fd92ea0..773a95c07 100644--- a/src/dotnet/ManagedNativeBoundaryInspector.ts+++ b/src/dotnet/ManagedNativeBoundaryInspector.ts@@ -134,7 +134,7 @@ export const inspectManagedNativeBoundariesBytes = (return emptyInspection(target,bytes,- pe.cliDirectoryPresent ? "malformed" : "not-managed",+ pe.cliDirectoryState !== "absent" ? "malformed" : "not-managed",{ issues: pe.cliIssue === null ? [] : [pe.cliIssue] },);const issues: ManagedParseIssue[] = [];diff --git a/src/dotnet/ManagedPeReader.ts b/src/dotnet/ManagedPeReader.tsindex 6f11cc491..2f9bc3151 100644--- a/src/dotnet/ManagedPeReader.ts+++ b/src/dotnet/ManagedPeReader.ts@@ -39,7 +39,7 @@ export interface ManagedPeLayout {readonly characteristics: number;readonly sections: readonly PeSection[];readonly cli: ManagedCliHeader | null;- readonly cliDirectoryPresent: boolean;+ readonly cliDirectoryState: "absent" | "present" | "unreadable";readonly cliIssue: ManagedParseIssue | null;rvaToOffset(rva: number, size: number, scope: string): number;rvaAvailableBytes(rva: number, scope: string): number;@@ -68,6 +68,11 @@ interface OptionalHeader {readonly directoryOffset: number;}+type CliDirectoryRead =+ | { readonly kind: "absent" }+ | { readonly kind: "present"; readonly directory: PeDataDirectory }+ | { readonly kind: "unreadable"; readonly issue: ManagedParseIssue };+const requireRange = (bytes: Buffer,offset: number,@@ -355,15 +360,38 @@ const readCliDirectory = (bytes: Buffer,coff: CoffHeader,optional: OptionalHeader,-): PeDataDirectory => {- requireRange(bytes, optional.directoryCountOffset, 4, "pe.data-directories");+): CliDirectoryRead => {+ const countOffset = optional.directoryCountOffset - optional.optionalOffset;+ if (countOffset + 4 > coff.optionalSize)+ return {+ kind: "unreadable",+ issue: {+ code: "invalid-directory",+ scope: "pe.optional-header",+ detail: "PE optional header does not contain its directory count",+ offset: optional.directoryCountOffset,+ },+ };const directoryCount = bytes.readUInt32LE(optional.directoryCountOffset);- if (- directoryCount <= 14 ||- coff.optionalSize < optional.directoryOffset - optional.optionalOffset + 120- )- return { rva: 0, size: 0 };- return readDirectory(bytes, optional.directoryOffset + 14 * 8);+ if (directoryCount <= 14) return { kind: "absent" };+ const availableDirectoryCount = Math.floor(+ (coff.optionalSize - (optional.directoryOffset - optional.optionalOffset)) /+ 8,+ );+ if (availableDirectoryCount < 15)+ return {+ kind: "unreadable",+ issue: {+ code: "invalid-directory",+ scope: "pe.data-directories",+ detail: "PE data-directory count exceeds the optional-header extent",+ offset: optional.directoryCountOffset,+ },+ };+ const directory = readDirectory(bytes, optional.directoryOffset + 14 * 8);+ return directory.rva !== 0 || directory.size !== 0+ ? { kind: "present", directory }+ : { kind: "absent" };};/** Parse the file-backed PE and CLI layout without loading target code. */@@ -379,26 +407,28 @@ export const readManagedPeLayout = (bytes: Buffer): ManagedPeLayout => {const coff = readCoffHeader(bytes);const optional = readOptionalHeader(bytes, coff);const sections = readSections(bytes, coff, optional);- const cliDirectory = readCliDirectory(bytes, coff, optional);- const cliDirectoryPresent = cliDirectory.rva !== 0 || cliDirectory.size !== 0;+ const cliDirectoryRead = readCliDirectory(bytes, coff, optional);+ const cliDirectoryState = cliDirectoryRead.kind;let cli: ManagedCliHeader | null = null;- let cliIssue: ManagedParseIssue | null = null;- if (cliDirectoryPresent)+ let cliIssue: ManagedParseIssue | null =+ cliDirectoryRead.kind === "unreadable" ? cliDirectoryRead.issue : null;+ if (cliDirectoryRead.kind === "present") {try {- cli = readCliHeader(bytes, sections, cliDirectory);+ cli = readCliHeader(bytes, sections, cliDirectoryRead.directory);} catch (cause: unknown) {if (!(cause instanceof ManagedReaderFailure)) throw cause;cliIssue = cause.issue;}+ }return {machine: coff.machine,- architecture: architectureFor(coff.machine, cliDirectoryPresent),+ architecture: architectureFor(coff.machine, cliDirectoryState !== "absent"),optionalHeader: optional.optionalHeader,sectionCount: coff.sectionCount,characteristics: coff.characteristics,sections,cli,- cliDirectoryPresent,+ cliDirectoryState,cliIssue,rvaToOffset: (rva, size, scope) =>mapRva({ bytes, sections, rva, size, scope }),diff --git a/src/process/ProcessOwnership.test.ts b/src/process/ProcessOwnership.test.tsindex 5f1906a3a..0aa644add 100644--- a/src/process/ProcessOwnership.test.ts+++ b/src/process/ProcessOwnership.test.ts@@ -138,7 +138,10 @@ describe("opaque process neighbors during cleanup", () => {expect(signalGroup).not.toHaveBeenCalledWith(900, "SIGKILL");});- it("fails closed for an unrelated unreadable candidate the OS should expose", async () => {+ it.each([+ "environment_unavailable",+ "restricted_process_environment_withheld",+ ])("fails closed for an unrelated candidate with %s", async (diagnostic) => {const processes = [{ pid: 100, parentPid: 1, processGroupId: 100, command: "capture" },{@@ -171,7 +174,7 @@ describe("opaque process neighbors during cleanup", () => {pid === 900? {state: "unavailable" as const,- reason: "environment_unavailable",+ reason: diagnostic,}: { state: "readable" as const, runId: "run-token" },]),@@ -191,13 +194,11 @@ describe("opaque process neighbors during cleanup", () => {expect(result).toMatchObject({cleaned: false,- reason: expect.stringContaining("environment_unavailable=1"),+ reason: expect.stringContaining(`${diagnostic}=1`),});if (result.cleaned)throw new Error("Expected unknown ownership to fail closed");- expect(result.reason).toContain(- "live candidates 900=environment_unavailable",- );+ expect(result.reason).toContain(`live candidates 900=${diagnostic}`);expect(result.reason).not.toContain("unowned");expect(result.reason).not.toContain("run-token");expect(signalGroup.mock.calls).toEqual([[100, "SIGKILL"]]);diff --git a/src/process/ProcessOwnership.ts b/src/process/ProcessOwnership.tsindex 983d840e5..5b181fe76 100644--- a/src/process/ProcessOwnership.ts+++ b/src/process/ProcessOwnership.ts@@ -642,6 +642,8 @@ const cleanupValidationFailure = (const sanitizedTokenReadFailure = (diagnostic: string | undefined): string => {if (diagnostic === "environment_unavailable") return diagnostic;if (diagnostic === "platform_binary_environment_withheld") return diagnostic;+ if (diagnostic === "restricted_process_environment_withheld")+ return diagnostic;const environmentErrno = /^(EACCES|EPERM|ENOENT|ESRCH):/u.exec(diagnostic ?? "",);diff --git a/tests/boundary/process/darwinProcessRunTokenReader.test.ts b/tests/boundary/process/darwinProcessRunTokenReader.test.tsindex db492df83..caae8b2be 100644--- a/tests/boundary/process/darwinProcessRunTokenReader.test.ts+++ b/tests/boundary/process/darwinProcessRunTokenReader.test.ts@@ -875,6 +875,38 @@ it.skipIf(!onDarwin)(});expect(JSON.parse(stdout)).toEqual({argvDecoyIgnored: true,+ readableEnvironmentWithoutToken: {+ runId: null,+ environmentEntryCount: 1,+ },+ restrictedReadableEnvironmentWithoutToken: {+ state: "readable",+ reason: null,+ },+ restrictedEmptyEnvironment: {+ state: "unavailable",+ reason: "restricted_process_environment_withheld",+ },+ platformEmptyEnvironment: {+ state: "unavailable",+ reason: "platform_binary_environment_withheld",+ },+ restrictedUnavailableEnvironment: {+ state: "unavailable",+ reason: "restricted_process_environment_withheld",+ },+ restrictedAmbiguousEnvironment: {+ state: "unavailable",+ reason: "restricted_process_environment_withheld",+ },+ ordinaryAmbiguousEnvironment: {+ state: "unavailable",+ reason: "ambiguous_environment_boundary",+ },+ ordinaryUnavailableEnvironment: {+ state: "unavailable",+ reason: "environment_unavailable",+ },alternatePaddingRead: true,appleVectorTokenFailsClosed: true,clearedAppleVectorTokenFailsClosed: true,diff --git a/tests/fixtures/processRunTokenParserProbe.swift b/tests/fixtures/processRunTokenParserProbe.swiftindex a753511f9..db046ea09 100644--- a/tests/fixtures/processRunTokenParserProbe.swift+++ b/tests/fixtures/processRunTokenParserProbe.swift@@ -26,38 +26,42 @@ func fixture(@mainstruct ProcessRunTokenParserProbe {static func main() throws {- let argvDecoy = try token(in: fixture(+ let argvDecoy = try parseProcessEnvironment(in: fixture(arguments: ["/fixture/executable", "REA_PROCESS_RUN_ID=argv-decoy", "trailing"],environment: ["DECOY=words REA_PROCESS_RUN_ID=synthetic-decoy"]))- let realToken = try token(in: fixture(+ let realToken = try parseProcessEnvironment(in: fixture(arguments: ["/fixture/executable"],environment: ["DECOY=words REA_PROCESS_RUN_ID=synthetic-decoy", "REA_PROCESS_RUN_ID=owned-token"]))- let emptyLaterArgument = try token(in: fixture(+ let readableNoToken = try parseProcessEnvironment(in: fixture(+ arguments: ["/fixture/executable"],+ environment: ["PATH=/usr/bin"]+ ))+ let emptyLaterArgument = try parseProcessEnvironment(in: fixture(arguments: ["/fixture/executable", "", "after-empty"],environment: ["REA_PROCESS_RUN_ID=empty-argument-token"],pointerSize: 8))- let alternatePadding = try token(in: fixture(+ let alternatePadding = try parseProcessEnvironment(in: fixture(arguments: ["/fixture/executable", "argument"],environment: ["REA_PROCESS_RUN_ID=alternate-padding-token"],pointerSize: 4), pointerSize: 4)- let emptyArgv0Read = try token(in: fixture(+ let emptyArgv0Read = try parseProcessEnvironment(in: fixture(arguments: ["", "", "after-empty"],environment: ["REA_PROCESS_RUN_ID=empty-argv0-token"],pointerSize: 8))- let finalAssignmentArgumentRead = try token(in: fixture(+ let finalAssignmentArgumentRead = try parseProcessEnvironment(in: fixture(arguments: ["/fixture/executable", "FOO=bar"],environment: ["REA_PROCESS_RUN_ID=final-assignment-token"]))- let reservedArgumentIgnored = try token(in: fixture(+ let reservedArgumentIgnored = try parseProcessEnvironment(in: fixture(arguments: ["/fixture/executable", "REA_PROCESS_RUN_ID=argv-decoy"],environment: ["DECOY=words REA_PROCESS_RUN_ID=synthetic-decoy"]))- let nonAsciiPathRead = try token(in: fixture(+ let nonAsciiPathRead = try parseProcessEnvironment(in: fixture(arguments: ["/fixture/é", "FOO=bar"],environment: ["REA_PROCESS_RUN_ID=utf8-path-token"],pointerSize: 8,@@ -65,7 +69,7 @@ struct ProcessRunTokenParserProbe {))let appleVectorTokenFailsClosed: Booldo {- _ = try token(in: fixture(+ _ = try parseProcessEnvironment(in: fixture(arguments: ["/fixture/executable"],environment: ["pfz=user-value", "PATH=/usr/bin"],appleRecords: ["pfz=synthetic", "REA_PROCESS_RUN_ID=apple-decoy"]@@ -76,7 +80,7 @@ struct ProcessRunTokenParserProbe {}let clearedAppleVectorTokenFailsClosed: Booldo {- _ = try token(in: fixture(+ _ = try parseProcessEnvironment(in: fixture(arguments: ["/fixture/executable"],environment: ["REA_PROCESS_RUN_ID=cleared-pfz-owned-token"],appleRecords: ["REA_PROCESS_RUN_ID=apple-decoy"],@@ -86,14 +90,14 @@ struct ProcessRunTokenParserProbe {} catch RunTokenReadError.ambiguousEnvironmentBoundary {clearedAppleVectorTokenFailsClosed = true}- let callerPfzBeforeTokenRead = try token(in: fixture(+ let callerPfzBeforeTokenRead = try parseProcessEnvironment(in: fixture(arguments: ["/fixture/executable"],environment: ["pfz=caller-value", "REA_PROCESS_RUN_ID=cleared-pfz-owned-token"],zeroedPfz: true))let emptyEnvironmentRecordsBeforeTokenFailClosed: Booldo {- _ = try token(in: fixture(+ _ = try parseProcessEnvironment(in: fixture(arguments: ["/fixture/executable"],environment: ["DECOY=value", "", "", "REA_PROCESS_RUN_ID=synthetic-decoy"],appleRecords: [],@@ -103,7 +107,7 @@ struct ProcessRunTokenParserProbe {} catch RunTokenReadError.ambiguousEnvironmentBoundary {emptyEnvironmentRecordsBeforeTokenFailClosed = true}- let zeroArgumentsRead = try token(in: fixture(+ let zeroArgumentsRead = try parseProcessEnvironment(in: fixture(arguments: [],environment: ["REA_PROCESS_RUN_ID=zero-argc-token"],pointerSize: 4@@ -117,14 +121,14 @@ struct ProcessRunTokenParserProbe {truncatedArgv.append(contentsOf: Array("REA_PROCESS_RUN_ID=synthetic-decoy".utf8))let truncatedArgvFailsClosed: Booldo {- _ = try token(in: truncatedArgv)+ _ = try parseProcessEnvironment(in: truncatedArgv)truncatedArgvFailsClosed = false} catch {truncatedArgvFailsClosed = true}let duplicateTokenFailsClosed: Booldo {- _ = try token(in: fixture(+ _ = try parseProcessEnvironment(in: fixture(arguments: ["/fixture/executable"],environment: ["REA_PROCESS_RUN_ID=first", "REA_PROCESS_RUN_ID=second"]))@@ -134,7 +138,7 @@ struct ProcessRunTokenParserProbe {}let missingAppleBoundaryFailsClosed: Booldo {- _ = try token(in: fixture(+ _ = try parseProcessEnvironment(in: fixture(arguments: ["/fixture/executable"],environment: ["REA_PROCESS_RUN_ID=synthetic-decoy"],appleRecords: []@@ -144,23 +148,97 @@ struct ProcessRunTokenParserProbe {missingAppleBoundaryFailsClosed = true}+ let restrictedReadableNoToken = processRunTokenObservation(+ pid: 1,+ parse: .success(readableNoToken),+ codeSigningFlags: { 0x0000_0800 }+ )+ let restrictedEmptyEnvironment = processRunTokenObservation(+ pid: 1,+ parse: .success(try parseProcessEnvironment(in: fixture(+ arguments: ["/fixture/executable"],+ environment: []+ ))),+ codeSigningFlags: { 0x0000_0800 }+ )+ let platformEmptyEnvironment = processRunTokenObservation(+ pid: 1,+ parse: .success(try parseProcessEnvironment(in: fixture(+ arguments: ["/fixture/executable"],+ environment: []+ ))),+ codeSigningFlags: { 0x0400_0000 }+ )+ let restrictedUnavailableEnvironment = processRunTokenObservation(+ pid: 1,+ parse: .failure(.environmentUnavailable),+ codeSigningFlags: { 0x0000_0800 }+ )+ let restrictedAmbiguousEnvironment = processRunTokenObservation(+ pid: 1,+ parse: .failure(.ambiguousEnvironmentBoundary),+ codeSigningFlags: { 0x0000_0800 }+ )+ let ordinaryAmbiguousEnvironment = processRunTokenObservation(+ pid: 1,+ parse: .failure(.ambiguousEnvironmentBoundary),+ codeSigningFlags: { 0 }+ )+ let ordinaryUnavailableEnvironment = processRunTokenObservation(+ pid: 1,+ parse: .failure(.environmentUnavailable),+ codeSigningFlags: { 0 }+ )+let result: [String: Any] = [- "argvDecoyIgnored": argvDecoy == nil,- "realTokenRead": realToken == "owned-token",- "emptyLaterArgumentRead": emptyLaterArgument == "empty-argument-token",- "alternatePaddingRead": alternatePadding == "alternate-padding-token",+ "argvDecoyIgnored": argvDecoy.runId == nil && argvDecoy.environmentEntryCount == 1,+ "realTokenRead": realToken.runId == "owned-token",+ "readableEnvironmentWithoutToken": [+ "runId": readableNoToken.runId as Any? ?? NSNull(),+ "environmentEntryCount": readableNoToken.environmentEntryCount,+ ],+ "restrictedReadableEnvironmentWithoutToken": [+ "state": restrictedReadableNoToken.state,+ "reason": restrictedReadableNoToken.reason as Any? ?? NSNull(),+ ],+ "restrictedEmptyEnvironment": [+ "state": restrictedEmptyEnvironment.state,+ "reason": restrictedEmptyEnvironment.reason as Any? ?? NSNull(),+ ],+ "platformEmptyEnvironment": [+ "state": platformEmptyEnvironment.state,+ "reason": platformEmptyEnvironment.reason as Any? ?? NSNull(),+ ],+ "restrictedUnavailableEnvironment": [+ "state": restrictedUnavailableEnvironment.state,+ "reason": restrictedUnavailableEnvironment.reason as Any? ?? NSNull(),+ ],+ "restrictedAmbiguousEnvironment": [+ "state": restrictedAmbiguousEnvironment.state,+ "reason": restrictedAmbiguousEnvironment.reason as Any? ?? NSNull(),+ ],+ "ordinaryAmbiguousEnvironment": [+ "state": ordinaryAmbiguousEnvironment.state,+ "reason": ordinaryAmbiguousEnvironment.reason as Any? ?? NSNull(),+ ],+ "ordinaryUnavailableEnvironment": [+ "state": ordinaryUnavailableEnvironment.state,+ "reason": ordinaryUnavailableEnvironment.reason as Any? ?? NSNull(),+ ],+ "emptyLaterArgumentRead": emptyLaterArgument.runId == "empty-argument-token",+ "alternatePaddingRead": alternatePadding.runId == "alternate-padding-token","truncatedArgvFailsClosed": truncatedArgvFailsClosed,"duplicateTokenFailsClosed": duplicateTokenFailsClosed,"missingAppleBoundaryFailsClosed": missingAppleBoundaryFailsClosed,- "emptyArgv0Read": emptyArgv0Read == "empty-argv0-token",- "finalAssignmentArgumentRead": finalAssignmentArgumentRead == "final-assignment-token",- "reservedArgumentIgnored": reservedArgumentIgnored == nil,- "nonAsciiPathRead": nonAsciiPathRead == "utf8-path-token",+ "emptyArgv0Read": emptyArgv0Read.runId == "empty-argv0-token",+ "finalAssignmentArgumentRead": finalAssignmentArgumentRead.runId == "final-assignment-token",+ "reservedArgumentIgnored": reservedArgumentIgnored.runId == nil && reservedArgumentIgnored.environmentEntryCount == 1,+ "nonAsciiPathRead": nonAsciiPathRead.runId == "utf8-path-token","appleVectorTokenFailsClosed": appleVectorTokenFailsClosed,"clearedAppleVectorTokenFailsClosed": clearedAppleVectorTokenFailsClosed,- "callerPfzBeforeTokenRead": callerPfzBeforeTokenRead == "cleared-pfz-owned-token",+ "callerPfzBeforeTokenRead": callerPfzBeforeTokenRead.runId == "cleared-pfz-owned-token","emptyEnvironmentRecordsBeforeTokenFailClosed": emptyEnvironmentRecordsBeforeTokenFailClosed,- "zeroArgumentsRead": zeroArgumentsRead == "zero-argc-token",+ "zeroArgumentsRead": zeroArgumentsRead.runId == "zero-argc-token",]let output = try JSONSerialization.data(withJSONObject: result, options: [.sortedKeys])FileHandle.standardOutput.write(output)