mirror of
https://github.com/morluto/rea.git
synced 2026-11-21 14:05:49 +00:00
341 lines
14 KiB
Swift
341 lines
14 KiB
Swift
import Foundation
|
|
|
|
func fixture(
|
|
arguments: [String],
|
|
environment: [String],
|
|
pointerSize: Int = 8,
|
|
executablePath: String = "/fixture/executable",
|
|
appleRecords: [String] = ["pfz=synthetic"],
|
|
zeroedPfz: Bool = false
|
|
) -> [UInt8] {
|
|
var bytes = withUnsafeBytes(of: Int32(arguments.count).littleEndian, Array.init)
|
|
let pathBytes = Array(executablePath.utf8)
|
|
bytes.append(contentsOf: pathBytes + [0])
|
|
let prefixLength = Array("executable_path=".utf8).count
|
|
let padding = (pointerSize - ((prefixLength + pathBytes.count + 1) % pointerSize)) % pointerSize
|
|
bytes.append(contentsOf: repeatElement(UInt8(0), count: padding))
|
|
for argument in arguments { bytes.append(contentsOf: Array(argument.utf8) + [0]) }
|
|
for entry in environment { bytes.append(contentsOf: Array(entry.utf8) + [0]) }
|
|
if zeroedPfz {
|
|
bytes.append(contentsOf: repeatElement(UInt8(0), count: Array("pfz=synthetic".utf8).count + 1))
|
|
}
|
|
for record in appleRecords { bytes.append(contentsOf: Array(record.utf8) + [0]) }
|
|
return bytes
|
|
}
|
|
|
|
func parseFixture(
|
|
_ bytes: [UInt8], pointerSize: Int = 8
|
|
) throws -> Result<ParsedRunToken, RunTokenReadError> {
|
|
do {
|
|
return .success(try parseProcessEnvironment(in: bytes, pointerSize: pointerSize))
|
|
} catch let reason as RunTokenReadError {
|
|
return .failure(reason)
|
|
}
|
|
}
|
|
|
|
@main
|
|
struct ProcessRunTokenParserProbe {
|
|
static func main() throws {
|
|
let argvDecoyFailsClosed: Bool
|
|
do {
|
|
_ = try parseProcessEnvironment(in: fixture(
|
|
arguments: ["/fixture/executable", "REA_PROCESS_RUN_ID=argv-decoy", "trailing"],
|
|
environment: ["DECOY=words REA_PROCESS_RUN_ID=synthetic-decoy"]
|
|
))
|
|
argvDecoyFailsClosed = false
|
|
} catch RunTokenReadError.ambiguousEnvironmentBoundary {
|
|
argvDecoyFailsClosed = true
|
|
}
|
|
// This layout matches the observed long-title overwrite: a former
|
|
// environment entry is consumed as an argv slot before the cleared pfz.
|
|
let titleOverwriteFailsClosed: Bool
|
|
do {
|
|
_ = try parseProcessEnvironment(in: fixture(
|
|
arguments: [String(repeating: "n", count: 248), "REA_PROCESS_RUN_ID=owned-token", "a", "b", "c", "d"],
|
|
environment: ["PATH=/usr/bin"],
|
|
zeroedPfz: true
|
|
))
|
|
titleOverwriteFailsClosed = false
|
|
} catch RunTokenReadError.ambiguousEnvironmentBoundary {
|
|
titleOverwriteFailsClosed = true
|
|
}
|
|
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 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 parseProcessEnvironment(in: fixture(
|
|
arguments: ["/fixture/executable", "argument"],
|
|
environment: ["REA_PROCESS_RUN_ID=alternate-padding-token"],
|
|
pointerSize: 4
|
|
), pointerSize: 4)
|
|
let emptyArgv0Read = try parseProcessEnvironment(in: fixture(
|
|
arguments: ["", "", "after-empty"],
|
|
environment: ["REA_PROCESS_RUN_ID=empty-argv0-token"],
|
|
pointerSize: 8
|
|
))
|
|
let finalAssignmentArgumentRead = try parseProcessEnvironment(in: fixture(
|
|
arguments: ["/fixture/executable", "FOO=bar"],
|
|
environment: ["REA_PROCESS_RUN_ID=final-assignment-token"]
|
|
))
|
|
let reservedArgumentWithRealTokenFailsClosed: Bool
|
|
do {
|
|
_ = try parseProcessEnvironment(in: fixture(
|
|
arguments: ["/fixture/executable", "REA_PROCESS_RUN_ID=argv-decoy"],
|
|
environment: ["REA_PROCESS_RUN_ID=actual-token"]
|
|
))
|
|
reservedArgumentWithRealTokenFailsClosed = false
|
|
} catch RunTokenReadError.ambiguousEnvironmentBoundary {
|
|
reservedArgumentWithRealTokenFailsClosed = true
|
|
}
|
|
let nonAsciiPathRead = try parseProcessEnvironment(in: fixture(
|
|
arguments: ["/fixture/é", "FOO=bar"],
|
|
environment: ["REA_PROCESS_RUN_ID=utf8-path-token"],
|
|
pointerSize: 8,
|
|
executablePath: "/fixture/é"
|
|
))
|
|
let appleVectorTokenFailsClosed: Bool
|
|
do {
|
|
_ = try parseProcessEnvironment(in: fixture(
|
|
arguments: ["/fixture/executable"],
|
|
environment: ["pfz=user-value", "PATH=/usr/bin"],
|
|
appleRecords: ["pfz=synthetic", "REA_PROCESS_RUN_ID=apple-decoy"]
|
|
))
|
|
appleVectorTokenFailsClosed = false
|
|
} catch RunTokenReadError.ambiguousEnvironmentBoundary {
|
|
appleVectorTokenFailsClosed = true
|
|
}
|
|
let clearedAppleVectorTokenFailsClosed: Bool
|
|
do {
|
|
_ = try parseProcessEnvironment(in: fixture(
|
|
arguments: ["/fixture/executable"],
|
|
environment: ["REA_PROCESS_RUN_ID=cleared-pfz-owned-token"],
|
|
appleRecords: ["REA_PROCESS_RUN_ID=apple-decoy"],
|
|
zeroedPfz: true
|
|
))
|
|
clearedAppleVectorTokenFailsClosed = false
|
|
} catch RunTokenReadError.ambiguousEnvironmentBoundary {
|
|
clearedAppleVectorTokenFailsClosed = true
|
|
}
|
|
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 parseProcessEnvironment(in: fixture(
|
|
arguments: ["/fixture/executable"],
|
|
environment: ["DECOY=value", "", "", "REA_PROCESS_RUN_ID=synthetic-decoy"],
|
|
appleRecords: [],
|
|
zeroedPfz: true
|
|
))
|
|
emptyEnvironmentRecordsBeforeTokenFailClosed = false
|
|
} catch RunTokenReadError.ambiguousEnvironmentBoundary {
|
|
emptyEnvironmentRecordsBeforeTokenFailClosed = true
|
|
}
|
|
let zeroArgumentsRead = try parseProcessEnvironment(in: fixture(
|
|
arguments: [],
|
|
environment: ["REA_PROCESS_RUN_ID=zero-argc-token"],
|
|
pointerSize: 4
|
|
), pointerSize: 4)
|
|
var truncatedArgv = fixture(
|
|
arguments: ["/fixture/executable", "REA_PROCESS_RUN_ID=synthetic-decoy"],
|
|
environment: [],
|
|
appleRecords: []
|
|
)
|
|
truncatedArgv.removeLast()
|
|
var invalidPadding = fixture(arguments: ["x"], environment: [], executablePath: "x")
|
|
invalidPadding[6] = 1 // argc (4 bytes), path and its NUL precede the padding.
|
|
var unterminated = fixture(arguments: ["REA_PROCESS_RUN_ID=argv-decoy"], environment: [], executablePath: "x")
|
|
unterminated.removeLast()
|
|
let malformedBuffers: [([UInt8], Int)] = [
|
|
([0, 0, 0], 8),
|
|
([255, 255, 255, 255], 8),
|
|
([0, 0, 0, 0, 120], 8),
|
|
(fixture(arguments: [], environment: []), 3),
|
|
(invalidPadding, 8),
|
|
(truncatedArgv, 8),
|
|
(unterminated, 8),
|
|
]
|
|
let parsedMalformedBuffers = try malformedBuffers.map { bytes, pointerSize in
|
|
try parseFixture(bytes, pointerSize: pointerSize)
|
|
}
|
|
// An unterminated trailing record is already rejected by the terminator check.
|
|
let malformedStages = (parsedMalformedBuffers + [.failure(.invalidBufferAt(.trailingEntries))]).map { parse in
|
|
let observation = processRunTokenObservation(
|
|
pid: 1,
|
|
parse: parse,
|
|
codeSigningFlags: { 0 }
|
|
)
|
|
return ["state": observation.state, "reason": observation.reason ?? ""]
|
|
}
|
|
let malformedObservation = processRunTokenObservation(
|
|
pid: 1,
|
|
parse: .failure(.invalidBuffer),
|
|
codeSigningFlags: { 0 }
|
|
)
|
|
// A restricted native process can expose an incomplete argv layout before
|
|
// the parser reaches the withheld environment (CI observed mdworker here).
|
|
let incompleteRestrictedArguments = [
|
|
RunTokenReadError.invalidBufferAt(.pathPadding),
|
|
.invalidBufferAt(.arguments),
|
|
.appleVectorUnavailable,
|
|
].map { failure in
|
|
[UInt32(0x0400_0000), UInt32(0x0000_0800), nil].map { flags in
|
|
let observation = processRunTokenObservation(
|
|
pid: 1,
|
|
parse: .failure(failure),
|
|
codeSigningFlags: { flags }
|
|
)
|
|
return ["state": observation.state, "reason": observation.reason ?? ""]
|
|
}
|
|
}
|
|
let signedReadableTokens = [UInt32(0x0400_0000), UInt32(0x0000_0800)].map { flags in
|
|
let observation = processRunTokenObservation(
|
|
pid: 1,
|
|
parse: .success(realToken),
|
|
codeSigningFlags: { flags }
|
|
)
|
|
return observation.state == "readable" && observation.run_id == "owned-token"
|
|
}
|
|
let duplicateToken = fixture(
|
|
arguments: ["/fixture/executable", "REA_PROCESS_RUN_ID=argv-decoy"],
|
|
environment: ["REA_PROCESS_RUN_ID=first", "REA_PROCESS_RUN_ID=second"]
|
|
)
|
|
var invalidTokenEncoding = fixture(
|
|
arguments: ["/fixture/executable", "REA_PROCESS_RUN_ID=argv-decoy"],
|
|
environment: ["REA_PROCESS_RUN_ID=é"]
|
|
)
|
|
invalidTokenEncoding[invalidTokenEncoding.firstIndex(of: 0xc3)!] = 0xff
|
|
let invalidTokens = try [duplicateToken, invalidTokenEncoding].map { bytes in
|
|
let parse = try parseFixture(bytes)
|
|
return [UInt32(0), UInt32(0x0400_0000), UInt32(0x0000_0800)].map { flags in
|
|
let observation = processRunTokenObservation(pid: 1, parse: parse, codeSigningFlags: { flags })
|
|
return ["state": observation.state, "reason": observation.reason ?? ""]
|
|
}
|
|
}
|
|
let missingAppleBoundaryFailsClosed: Bool
|
|
do {
|
|
_ = try parseProcessEnvironment(in: fixture(
|
|
arguments: ["/fixture/executable"],
|
|
environment: ["REA_PROCESS_RUN_ID=synthetic-decoy"],
|
|
appleRecords: []
|
|
))
|
|
missingAppleBoundaryFailsClosed = false
|
|
} catch RunTokenReadError.appleVectorUnavailable {
|
|
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] = [
|
|
"argvDecoyFailsClosed": argvDecoyFailsClosed,
|
|
"titleOverwriteFailsClosed": titleOverwriteFailsClosed,
|
|
"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",
|
|
"malformedStages": malformedStages,
|
|
"incompleteRestrictedArguments": incompleteRestrictedArguments,
|
|
"signedReadableTokens": signedReadableTokens,
|
|
"invalidTokens": invalidTokens,
|
|
"malformedObservation": [
|
|
"state": malformedObservation.state,
|
|
"reason": malformedObservation.reason as Any? ?? NSNull(),
|
|
],
|
|
"missingAppleBoundaryFailsClosed": missingAppleBoundaryFailsClosed,
|
|
"emptyArgv0Read": emptyArgv0Read.runId == "empty-argv0-token",
|
|
"finalAssignmentArgumentRead": finalAssignmentArgumentRead.runId == "final-assignment-token",
|
|
"reservedArgumentWithRealTokenFailsClosed": reservedArgumentWithRealTokenFailsClosed,
|
|
"nonAsciiPathRead": nonAsciiPathRead.runId == "utf8-path-token",
|
|
"appleVectorTokenFailsClosed": appleVectorTokenFailsClosed,
|
|
"clearedAppleVectorTokenFailsClosed": clearedAppleVectorTokenFailsClosed,
|
|
"callerPfzBeforeTokenRead": callerPfzBeforeTokenRead.runId == "cleared-pfz-owned-token",
|
|
"emptyEnvironmentRecordsBeforeTokenFailClosed": emptyEnvironmentRecordsBeforeTokenFailClosed,
|
|
"zeroArgumentsRead": zeroArgumentsRead.runId == "zero-argc-token",
|
|
]
|
|
let output = try JSONSerialization.data(withJSONObject: result, options: [.sortedKeys])
|
|
FileHandle.standardOutput.write(output)
|
|
}
|
|
}
|