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:
@@ -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(
|
||||
|
||||
@@ -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" },
|
||||
|
||||
@@ -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
|
||||
? [
|
||||
|
||||
@@ -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[] = [];
|
||||
|
||||
@@ -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 }),
|
||||
|
||||
@@ -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"]]);
|
||||
|
||||
@@ -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
@@ -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)
|
||||
|
||||
Reference in New Issue
Block a user