fix(evidence): retain unreadable PE and Darwin process facts

Distinguish absent CLI directories from unreadable directory counts and truncated slots while preserving known PE headers and readable CLI data.

Retain environment-entry coverage in the Darwin parser and classify restricted empty, unavailable and ambiguous environments at the native boundary. Keep cleanup fail-closed; code-signing flags do not establish ownership.

Validation: 116 managed source tests, 13 ownership tests, native Swift parser probe and two live Darwin run-token tests; build, static checks and docs checks pass. Restricted-flag cases use parser fixtures; no real restricted capture is claimed. Related to #2035.
This commit is contained in:
morluto
2026-10-12 11:59:23 +08:00
parent d0249282c6
commit 4a4d36f881
9 changed files with 426 additions and 84 deletions
+76 -34
View File
@@ -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 = 0
private 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 = 0
let result = withUnsafeMutablePointer(to: &flags) { pointer in
csops(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(
+157
View File
@@ -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" },
+1 -1
View File
@@ -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
? [
+1 -1
View File
@@ -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[] = [];
+46 -16
View File
@@ -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 }),
+7 -6
View File
@@ -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"]]);
+2
View File
@@ -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 ?? "",
);
@@ -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,
+104 -26
View File
@@ -26,38 +26,42 @@ func fixture(
@main
struct 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: Bool
do {
_ = 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: Bool
do {
_ = 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: Bool
do {
_ = 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: Bool
do {
_ = try token(in: truncatedArgv)
_ = try parseProcessEnvironment(in: truncatedArgv)
truncatedArgvFailsClosed = false
} catch {
truncatedArgvFailsClosed = true
}
let duplicateTokenFailsClosed: Bool
do {
_ = 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: Bool
do {
_ = 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)