Files
VCCPlusOSS/platforms/macos/Companion/CompanionTransport.swift
T

472 lines
26 KiB
Swift

// SPDX-License-Identifier: GPL-3.0-or-later
import Foundation
import Darwin
import Security
/// Private, authenticated, one-request-per-connection companion IPC. Both apps
/// compile this exact source; no database, disk, or emulator commands live here.
enum CompanionTransport {
static var publisherTeamID: String {
(Bundle.main.object(forInfoDictionaryKey: "VCCCompanionTeamIdentifier") as? String ?? "")
.trimmingCharacters(in: .whitespacesAndNewlines)
}
static let protocolVersion = 1
static let maximumPayloadBytes = 24 * 1024 * 1024
private static let maximumFrameBytes = 32 * 1024 * 1024 + 4096
struct Configuration: Sendable {
var directory: URL
var timeout: TimeInterval = 120
var socketName = "service.sock"
var teamID = CompanionTransport.publisherTeamID
var serverBundleIDs: Set<String> = ["com.brianholman.vccplus.oss.mac"]
var clientBundleIDs: Set<String> = ["com.brianholman.vccplus.oss.drivewire"]
#if VCC_COMPANION_TESTING
var allowUnsignedTestPeers = false
#endif
static var production: Configuration {
Configuration(directory: URL(fileURLWithPath: "/private/tmp/vccplus-oss-companion-\(geteuid())", isDirectory: true))
}
static var vccPlus: Configuration { .production }
static var driveWire: Configuration {
var configuration = production
configuration.socketName = "drivewire.sock"
configuration.serverBundleIDs = ["com.brianholman.vccplus.oss.drivewire"]
configuration.clientBundleIDs = ["com.brianholman.vccplus.oss.mac"]
return configuration
}
var expectedServerBundleIDs: Set<String> {
get { serverBundleIDs }
set { serverBundleIDs = newValue }
}
var expectedClientBundleIDs: Set<String> {
get { clientBundleIDs }
set { clientBundleIDs = newValue }
}
var socketPath: String { directory.appendingPathComponent(socketName).path }
}
enum Failure: LocalizedError {
case unavailable, busy, untrustedPeer, unsafeEndpoint, unsupportedVersion, malformedFrame, tooLarge, timedOut, startupTimedOut
case remote(String)
var errorDescription: String? {
switch self {
case .unavailable: "VCC Plus's companion service is not available."
case .busy: "Another VCC Plus companion service is already running."
case .untrustedPeer: "The companion application's identity could not be verified."
case .unsafeEndpoint: "The companion service location is not private or has changed."
case .unsupportedVersion: "These application versions do not support the same companion protocol."
case .malformedFrame: "The companion service returned an invalid response."
case .tooLarge: "The companion request or response exceeds the supported size."
case .timedOut: "The companion operation timed out."
case .startupTimedOut: "VCC Plus did not finish starting. Check for a macOS permission prompt, then try opening the Software Library again."
case .remote(let message): message
}
}
}
/// Launch Services can return before a cold app finishes macOS startup
/// checks. Retry only a missing listener, with a monotonic deadline and
/// cancellation; identity/protocol/permission failures remain immediate.
static func waitForService(timeout: TimeInterval = 45, retryInterval: TimeInterval = 0.1,
now: () -> TimeInterval = { ProcessInfo.processInfo.systemUptime },
sleep: (TimeInterval) async throws -> Void = { try await Task.sleep(for: .seconds($0)) },
probe: (TimeInterval) async throws -> Void) async throws {
let deadline = now() + timeout
while true {
try Task.checkCancellation()
let remaining = deadline - now()
guard remaining > 0 else { throw Failure.startupTimedOut }
do {
try await probe(remaining)
try Task.checkCancellation()
return
} catch Failure.unavailable {
let remaining = deadline - now()
guard remaining > 0 else { throw Failure.startupTimedOut }
try await sleep(min(retryInterval, remaining))
}
}
}
private struct Request: Codable {
let version: Int
let id: UUID
let method: String
let payload: Data
}
private struct Response: Codable {
let version: Int
let id: UUID
let payload: Data?
let error: String?
}
struct Client: Sendable {
let configuration: Configuration
init(configuration: Configuration = .production) { self.configuration = configuration }
func request(method: String, payload: Data = Data()) async throws -> Data {
guard !method.isEmpty, method.utf8.count <= 128 else { throw Failure.malformedFrame }
guard payload.count <= maximumPayloadBytes else { throw Failure.tooLarge }
let state = Connection()
return try await withTaskCancellationHandler {
try Task.checkCancellation()
return try await withCheckedThrowingContinuation { continuation in
DispatchQueue.global(qos: .userInitiated).async {
defer { state.finish() }
do {
let fd = try makeSocket()
try state.attach(fd)
try checkDirectory(configuration.directory, create: false)
try checkSocket(configuration.socketPath)
let deadline = Date().addingTimeInterval(configuration.timeout)
try connect(fd, path: configuration.socketPath, deadline: deadline, state: state)
try authenticate(fd, configuration: configuration, permittedIDs: configuration.serverBundleIDs)
let id = UUID()
try writeFrame(JSONEncoder().encode(Request(version: protocolVersion, id: id, method: method, payload: payload)), fd: fd, deadline: deadline, state: state)
let result = try JSONDecoder().decode(Response.self, from: readFrame(fd, deadline: deadline, state: state))
guard result.version == protocolVersion else { throw Failure.unsupportedVersion }
guard result.id == id else { throw Failure.malformedFrame }
if let error = result.error { throw Failure.remote(error) }
guard let data = result.payload, data.count <= maximumPayloadBytes else { throw Failure.malformedFrame }
continuation.resume(returning: data)
} catch { continuation.resume(throwing: state.isCancelled ? CancellationError() : error) }
}
}
} onCancel: { state.cancel() }
}
}
final class Server: @unchecked Sendable {
typealias Handler = @Sendable (String, Data) async throws -> Data
let configuration: Configuration
private let handler: Handler
private let stateLock = NSLock()
private let queue = DispatchQueue(label: "com.brianholman.vccplus.companion.accept")
private let slots = DispatchSemaphore(value: 4)
private var listener: DispatchSourceRead?
private var lockFD: Int32 = -1
private var endpoint: (dev_t, ino_t)?
private var connections: [UUID: Connection] = [:]
private var stopped = false
init(configuration: Configuration = .production, handler: @escaping Handler) throws {
self.configuration = configuration; self.handler = handler
try checkDirectory(configuration.directory, create: true)
let lockPath = configuration.directory.appendingPathComponent(configuration.socketName + ".lock").path
lockFD = open(lockPath, O_CREAT | O_RDWR | O_NOFOLLOW | O_CLOEXEC, 0o600)
guard lockFD >= 0 else { throw Failure.unsafeEndpoint }
var lockInfo = stat()
guard fstat(lockFD, &lockInfo) == 0, lockInfo.st_uid == geteuid(),
lockInfo.st_mode & S_IFMT == S_IFREG, lockInfo.st_mode & 0o777 == 0o600 else {
close(lockFD); lockFD = -1; throw Failure.unsafeEndpoint
}
guard flock(lockFD, LOCK_EX | LOCK_NB) == 0 else {
close(lockFD); lockFD = -1; throw Failure.busy
}
var fd: Int32 = -1
do {
try removeStaleSocket(configuration.socketPath)
fd = try makeSocket()
var address = try unixAddress(configuration.socketPath)
try checked(withUnsafePointer(to: &address) {
$0.withMemoryRebound(to: sockaddr.self, capacity: 1) { Darwin.bind(fd, $0, socklen_t(MemoryLayout<sockaddr_un>.size)) }
})
guard chmod(configuration.socketPath, 0o600) == 0 else { throw Failure.unsafeEndpoint }
var info = stat(); guard lstat(configuration.socketPath, &info) == 0 else { throw Failure.unsafeEndpoint }
endpoint = (info.st_dev, info.st_ino)
try checked(Darwin.listen(fd, 8))
let source = DispatchSource.makeReadSource(fileDescriptor: fd, queue: queue)
let socketFD = fd
source.setEventHandler { [weak self] in self?.acceptConnection(socketFD) }
source.setCancelHandler { close(socketFD) }
listener = source; source.resume()
} catch {
if fd >= 0 { close(fd) }
removeOwnedEndpoint()
flock(lockFD, LOCK_UN); close(lockFD); lockFD = -1
throw error
}
}
private func acceptConnection(_ fd: Int32) {
while true {
let peer = Darwin.accept(fd, nil, nil)
guard peer >= 0 else { return }
guard slots.wait(timeout: .now()) == .success else { close(peer); continue }
let connection = Connection(), id = UUID()
do { try configureSocket(peer); try connection.attach(peer) }
catch { close(peer); slots.signal(); continue }
stateLock.lock()
let accepting = !stopped
if accepting { connections[id] = connection }
stateLock.unlock()
guard accepting else { connection.finish(); slots.signal(); return }
DispatchQueue.global(qos: .utility).async { [self] in
do {
try authenticate(peer, configuration: configuration, permittedIDs: configuration.clientBundleIDs)
let deadline = Date().addingTimeInterval(configuration.timeout)
let request = try JSONDecoder().decode(Request.self, from: readFrame(peer, deadline: deadline, state: connection))
guard request.version == protocolVersion else { throw Failure.unsupportedVersion }
guard !request.method.isEmpty, request.method.utf8.count <= 128,
request.payload.count <= maximumPayloadBytes else { throw Failure.malformedFrame }
let task = Task { [self] in
let response: Response
do {
let payload = try await withThrowingTaskGroup(of: Data.self) { group in
group.addTask { try await self.handler(request.method, request.payload) }
group.addTask {
while true {
try Task.checkCancellation()
if Date() >= deadline { throw Failure.timedOut }
if connection.isCancelled { throw CancellationError() }
var byte: UInt8 = 0
let count = recv(peer, &byte, 1, MSG_PEEK | MSG_DONTWAIT)
if count == 0 { throw CancellationError() }
if count > 0 { throw Failure.malformedFrame } // exactly one request per connection
if errno != EAGAIN && errno != EWOULDBLOCK && errno != EINTR { throw Failure.unavailable }
try await Task.sleep(nanoseconds: 100_000_000)
}
}
defer { group.cancelAll() }
return try await group.next()!
}
guard payload.count <= maximumPayloadBytes else { throw Failure.tooLarge }
response = Response(version: protocolVersion, id: request.id, payload: payload, error: nil)
} catch {
response = Response(version: protocolVersion, id: request.id, payload: nil, error: String(error.localizedDescription.prefix(2048)))
}
await withCheckedContinuation { (done: CheckedContinuation<Void, Never>) in
DispatchQueue.global(qos: .utility).async { [self] in
defer { finish(id, connection: connection); done.resume() }
if let bytes = try? JSONEncoder().encode(response) {
try? writeFrame(bytes, fd: peer, deadline: deadline, state: connection)
}
}
}
}
connection.setTask(task)
} catch { finish(id, connection: connection) }
}
}
}
private func finish(_ id: UUID, connection: Connection) {
connection.finish()
stateLock.lock(); let removed = connections.removeValue(forKey: id); stateLock.unlock()
if removed != nil { slots.signal() }
}
func stop() {
stateLock.lock()
guard !stopped else { stateLock.unlock(); return }
stopped = true
let source = listener; listener = nil
let active = Array(connections.values)
stateLock.unlock()
source?.cancel()
for connection in active { connection.cancel() }
removeOwnedEndpoint()
if lockFD >= 0 { flock(lockFD, LOCK_UN); close(lockFD); lockFD = -1 }
}
private func removeOwnedEndpoint() {
guard let endpoint else { return }
var info = stat()
if lstat(configuration.socketPath, &info) == 0, info.st_uid == geteuid(),
info.st_mode & S_IFMT == S_IFSOCK, info.st_dev == endpoint.0, info.st_ino == endpoint.1 {
_ = unlink(configuration.socketPath)
}
self.endpoint = nil
}
deinit { stop() }
}
/// A descriptor is closed once, by its IO worker. Cancellation only shuts it
/// down under a lock so a recycled descriptor can never be closed by a task.
private final class Connection: @unchecked Sendable {
private let lock = NSLock()
private var fd: Int32 = -1
private var cancelled = false
private var finished = false
private var task: Task<Void, Never>?
var isCancelled: Bool { lock.lock(); defer { lock.unlock() }; return cancelled }
func attach(_ value: Int32) throws {
lock.lock(); defer { lock.unlock() }
if cancelled { close(value); throw CancellationError() }
fd = value
}
func setTask(_ value: Task<Void, Never>) {
lock.lock(); let cancel = cancelled || finished
if !cancel { task = value }
lock.unlock()
if cancel { value.cancel() }
}
func cancel() {
lock.lock(); cancelled = true
if fd >= 0 { _ = shutdown(fd, SHUT_RDWR) }
let running = task; lock.unlock(); running?.cancel()
}
func finish() {
lock.lock(); let value = fd; fd = -1; task = nil; finished = true; lock.unlock()
if value >= 0 { close(value) }
}
}
private static func checked(_ value: Int32) throws {
guard value >= 0 else { throw POSIXError(POSIXErrorCode(rawValue: errno) ?? .EIO) }
}
private static func makeSocket() throws -> Int32 {
let fd = socket(AF_UNIX, SOCK_STREAM, 0)
guard fd >= 0 else { throw Failure.unavailable }
do { try configureSocket(fd); return fd } catch { close(fd); throw error }
}
private static func configureSocket(_ fd: Int32) throws {
try checked(fcntl(fd, F_SETFL, O_NONBLOCK)); try checked(fcntl(fd, F_SETFD, FD_CLOEXEC))
var yes: Int32 = 1
try checked(setsockopt(fd, SOL_SOCKET, SO_NOSIGPIPE, &yes, socklen_t(MemoryLayout.size(ofValue: yes))))
}
private static func unixAddress(_ path: String) throws -> sockaddr_un {
var address = sockaddr_un()
address.sun_family = sa_family_t(AF_UNIX); address.sun_len = UInt8(MemoryLayout<sockaddr_un>.size)
let bytes = Array(path.utf8CString)
guard bytes.count <= MemoryLayout.size(ofValue: address.sun_path) else { throw Failure.unsafeEndpoint }
withUnsafeMutableBytes(of: &address.sun_path) { target in bytes.withUnsafeBytes { target.copyBytes(from: $0) } }
return address
}
private static func checkDirectory(_ url: URL, create: Bool) throws {
if create, mkdir(url.path, 0o700) != 0, errno != EEXIST { throw Failure.unsafeEndpoint }
var info = stat()
guard lstat(url.path, &info) == 0, info.st_uid == geteuid(), info.st_mode & S_IFMT == S_IFDIR,
info.st_mode & 0o777 == 0o700 else { throw Failure.unsafeEndpoint }
}
private static func checkSocket(_ path: String) throws {
var info = stat()
guard lstat(path, &info) == 0 else { throw Failure.unavailable }
guard info.st_uid == geteuid(), info.st_mode & S_IFMT == S_IFSOCK,
info.st_mode & 0o777 == 0o600 else { throw Failure.unsafeEndpoint }
}
private static func removeStaleSocket(_ path: String) throws {
var before = stat()
guard lstat(path, &before) == 0 else {
if errno == ENOENT { return }; throw Failure.unsafeEndpoint
}
try checkSocket(path)
let fd = try makeSocket(); defer { close(fd) }
var address = try unixAddress(path)
let rc = withUnsafePointer(to: &address) {
$0.withMemoryRebound(to: sockaddr.self, capacity: 1) { Darwin.connect(fd, $0, socklen_t(MemoryLayout<sockaddr_un>.size)) }
}
guard rc < 0, errno == ECONNREFUSED || errno == ENOENT else { throw Failure.busy }
var after = stat()
guard lstat(path, &after) == 0, after.st_uid == geteuid(), after.st_mode & S_IFMT == S_IFSOCK,
before.st_dev == after.st_dev, before.st_ino == after.st_ino else { throw Failure.unsafeEndpoint }
try checked(unlink(path))
}
private static func connect(_ fd: Int32, path: String, deadline: Date, state: Connection) throws {
var address = try unixAddress(path)
let rc = withUnsafePointer(to: &address) {
$0.withMemoryRebound(to: sockaddr.self, capacity: 1) { Darwin.connect(fd, $0, socklen_t(MemoryLayout<sockaddr_un>.size)) }
}
if rc < 0 {
guard errno == EINPROGRESS || errno == EAGAIN else { throw Failure.unavailable }
try wait(fd, events: Int16(POLLOUT), deadline: deadline, state: state)
var error: Int32 = 0, length = socklen_t(MemoryLayout<Int32>.size)
guard getsockopt(fd, SOL_SOCKET, SO_ERROR, &error, &length) == 0, error == 0 else { throw Failure.unavailable }
}
}
private static func wait(_ fd: Int32, events: Int16, deadline: Date, state: Connection) throws {
while true {
if state.isCancelled { throw CancellationError() }
guard Date() < deadline else { throw Failure.timedOut }
var descriptor = pollfd(fd: fd, events: events, revents: 0)
let rc = poll(&descriptor, 1, 100)
if rc > 0 {
if descriptor.revents & events != 0 { return }
throw Failure.unavailable
}
if rc < 0 && errno != EINTR { throw Failure.unavailable }
}
}
private static func readBytes(_ count: Int, fd: Int32, deadline: Date, state: Connection) throws -> Data {
var result = Data(count: count)
try result.withUnsafeMutableBytes { buffer in
var offset = 0
while offset < count {
try wait(fd, events: Int16(POLLIN), deadline: deadline, state: state)
let size = recv(fd, buffer.baseAddress! + offset, count - offset, 0)
if size > 0 { offset += size }
else if size == 0 { throw Failure.unavailable }
else if errno != EINTR && errno != EAGAIN && errno != EWOULDBLOCK { throw Failure.unavailable }
}
}
return result
}
private static func readFrame(_ fd: Int32, deadline: Date, state: Connection) throws -> Data {
let prefix = try readBytes(4, fd: fd, deadline: deadline, state: state)
let size = prefix.reduce(UInt32(0)) { ($0 << 8) | UInt32($1) }
guard size > 0, size <= maximumFrameBytes else { throw Failure.tooLarge }
return try readBytes(Int(size), fd: fd, deadline: deadline, state: state)
}
private static func writeFrame(_ data: Data, fd: Int32, deadline: Date, state: Connection) throws {
guard data.count <= maximumFrameBytes else { throw Failure.tooLarge }
var size = UInt32(data.count).bigEndian
let frame = withUnsafeBytes(of: &size) { Data($0) } + data
try frame.withUnsafeBytes { buffer in
var offset = 0
while offset < frame.count {
try wait(fd, events: Int16(POLLOUT), deadline: deadline, state: state)
let sent = send(fd, buffer.baseAddress! + offset, frame.count - offset, 0)
if sent > 0 { offset += sent }
else if sent == 0 { throw Failure.unavailable }
else if errno != EINTR && errno != EAGAIN && errno != EWOULDBLOCK { throw Failure.unavailable }
}
}
}
/// Validate a discovered/selected companion before asking Launch Services to
/// run it. Bundle metadata alone is not authorization to execute an app.
/// This reads and verifies code on disk; callers should run it off the main actor.
static func validateApplication(at url: URL, permittedBundleIDs: Set<String>,
teamID: String = CompanionTransport.publisherTeamID) throws {
guard !teamID.isEmpty, url.isFileURL, !permittedBundleIDs.isEmpty else { throw Failure.untrustedPeer }
var code: SecStaticCode?
guard SecStaticCodeCreateWithPath(url as CFURL, [], &code) == errSecSuccess, let code else { throw Failure.untrustedPeer }
var info: CFDictionary?
guard SecCodeCopySigningInformation(code, SecCSFlags(rawValue: kSecCSSigningInformation), &info) == errSecSuccess,
let values = info as? [String: Any], let identifier = values[kSecCodeInfoIdentifier as String] as? String,
permittedBundleIDs.contains(identifier), values[kSecCodeInfoTeamIdentifier as String] as? String == teamID else {
throw Failure.untrustedPeer
}
var requirement: SecRequirement?
guard SecRequirementCreateWithString("anchor apple generic" as CFString, [], &requirement) == errSecSuccess,
SecStaticCodeCheckValidity(code, SecCSFlags(rawValue: kSecCSStrictValidate | kSecCSCheckAllArchitectures), requirement) == errSecSuccess else {
throw Failure.untrustedPeer
}
}
private static func authenticate(_ fd: Int32, configuration: Configuration, permittedIDs: Set<String>) throws {
var uid: uid_t = 0, gid: gid_t = 0
guard getpeereid(fd, &uid, &gid) == 0, uid == geteuid() else { throw Failure.untrustedPeer }
#if VCC_COMPANION_TESTING
if configuration.allowUnsignedTestPeers { return }
#endif
guard !configuration.teamID.isEmpty else { throw Failure.untrustedPeer }
var pid: pid_t = 0, length = socklen_t(MemoryLayout<pid_t>.size)
guard getsockopt(fd, SOL_LOCAL, LOCAL_PEERPID, &pid, &length) == 0, pid > 0 else { throw Failure.untrustedPeer }
var guest: SecCode?
let attributes = [kSecGuestAttributePid: NSNumber(value: pid)] as CFDictionary
guard SecCodeCopyGuestWithAttributes(nil, attributes, [], &guest) == errSecSuccess, let guest else { throw Failure.untrustedPeer }
var staticCode: SecStaticCode?
guard SecCodeCopyStaticCode(guest, [], &staticCode) == errSecSuccess, let staticCode else { throw Failure.untrustedPeer }
var info: CFDictionary?
guard SecCodeCopySigningInformation(staticCode, SecCSFlags(rawValue: kSecCSSigningInformation), &info) == errSecSuccess,
let values = info as? [String: Any], let identifier = values[kSecCodeInfoIdentifier as String] as? String,
permittedIDs.contains(identifier), values[kSecCodeInfoTeamIdentifier as String] as? String == configuration.teamID else { throw Failure.untrustedPeer }
// A matching string in an unsigned plist or an ad-hoc signature is not trust.
var requirement: SecRequirement?
guard SecRequirementCreateWithString("anchor apple generic" as CFString, [], &requirement) == errSecSuccess,
SecCodeCheckValidity(guest, SecCSFlags(rawValue: kSecCSStrictValidate), requirement) == errSecSuccess else { throw Failure.untrustedPeer }
}
}