Skip to content

👾 Open Computer Use – Open-Source Alternative to Codex Computer Use

15.3 KB
Raw Blame
// Minimal remote mechanism. No credential context/hints are read or written.
// The diagnostic deny-only plugin remains a separate artifact/right.
#import <Foundation/Foundation.h>
#import <Security/AuthorizationPlugin.h>
#import <Security/Security.h>
#include "LockedUseNative.h"
#include <arpa/inet.h>
#include <fcntl.h>
#include <poll.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <time.h>
#include <unistd.h>
#include <os/log.h>
#include <bsm/libbsm.h>

#ifndef OCU_SIGNING_TEAM
#error "Remote mechanism requires a fixed Developer ID signing team"
#endif

extern int32_t ocu_verify_broker_task(const void *auditToken, const char *team);

static const char *socketPath = "/Library/Application Support/OpenComputerUse/LockedUse/run/plugin.sock";
static double monotonic(void) {
    struct timespec value;
    if (clock_gettime(CLOCK_MONOTONIC, &value) != 0) return -1;
    return value.tv_sec + value.tv_nsec / 1e9;
}

static bool ready(int fd, short events, double deadline) {
    for (;;) {
        double remaining = deadline - monotonic();
        if (remaining <= 0 || remaining > 3) return false;
        struct pollfd entry = {.fd = fd, .events = events};
        int result = poll(&entry, 1, (int)(remaining * 1000 + 1));
        if (result < 0 && errno == EINTR) continue;
        return result > 0 && !(entry.revents & POLLNVAL);
    }
}

static bool transfer(int fd, void *bytes, size_t length, bool sending, double deadline) {
    size_t offset = 0;
    while (offset < length) {
        if (!ready(fd, sending ? POLLOUT : POLLIN, deadline)) return false;
        ssize_t count = sending ? write(fd, (char *)bytes + offset, length - offset)
                                : read(fd, (char *)bytes + offset, length - offset);
        if (count < 0 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK)) continue;
        if (count <= 0) return false;
        offset += (size_t)count;
    }
    return true;
}

static bool verifyBroker(int fd) {
    OCUPeerIdentity peer;
    if (ocu_copy_peer_identity(fd, &peer) != 0 || peer.effective_user_id != 0) return false;
    int32_t taskStatus = ocu_verify_broker_task(peer.audit_token, OCU_SIGNING_TEAM);
    os_log_t taskLogger = os_log_create("dev.opencomputeruse.locked-use", "AuthorizationMechanism");
    os_log_with_type(taskLogger, OS_LOG_TYPE_DEFAULT, "brokerTaskVerification status=%{public}d", taskStatus);
    // Older systems retain the legacy verifier. A modern failure never falls
    // back to a weaker identifier-only or on-disk check.
    if (taskStatus != -1) return taskStatus == 1;
    NSData *audit = [NSData dataWithBytes:peer.audit_token length:sizeof(peer.audit_token)];
    NSDictionary *attributes = @{(__bridge NSString *)kSecGuestAttributeAudit: audit};
    SecCodeRef guest = NULL;
    SecRequirementRef requirement = NULL;
    SecStaticCodeRef staticCode = NULL;
    CFDictionaryRef info = NULL;
    CFStringRef text = CFSTR("identifier \"dev.opencomputeruse.locked-use.broker\" and anchor apple generic and certificate leaf[subject.OU] = \"" OCU_SIGNING_TEAM "\"");
    os_log_t logger = os_log_create("dev.opencomputeruse.locked-use", "AuthorizationMechanism");
    OSStatus guestStatus = SecCodeCopyGuestWithAttributes(NULL, (__bridge CFDictionaryRef)attributes, kSecCSDefaultFlags, &guest);
    OSStatus requirementStatus = errAuthorizationInternal, validityStatus = errAuthorizationInternal;
    OSStatus staticStatus = errAuthorizationInternal, infoStatus = errAuthorizationInternal;
    if (guestStatus == errSecSuccess) requirementStatus = SecRequirementCreateWithString(text, kSecCSDefaultFlags, &requirement);
    if (requirementStatus == errSecSuccess) validityStatus = SecCodeCheckValidity(guest, kSecCSDefaultFlags, requirement);
    if (validityStatus == errSecSuccess) staticStatus = SecCodeCopyStaticCode(guest, kSecCSDefaultFlags, &staticCode);
    if (staticStatus == errSecSuccess) infoStatus = SecCodeCopySigningInformation(staticCode, kSecCSSigningInformation, &info);
    os_log_with_type(logger, OS_LOG_TYPE_DEFAULT, "brokerVerification guest=%{public}d requirement=%{public}d validity=%{public}d static=%{public}d info=%{public}d",
        (int)guestStatus, (int)requirementStatus, (int)validityStatus, (int)staticStatus, (int)infoStatus);
    bool valid = infoStatus == errSecSuccess;
    if (valid) {
        NSDictionary *metadata = (__bridge NSDictionary *)info;
        unsigned int flags = [metadata[(__bridge NSString *)kSecCodeInfoFlags] unsignedIntValue];
        NSDictionary *entitlements = metadata[(__bridge NSString *)kSecCodeInfoEntitlementsDict];
        valid = (flags & kSecCodeSignatureRuntime) != 0;
        for (NSString *key in @[@"get-task-allow", @"com.apple.security.get-task-allow",
            @"com.apple.security.cs.disable-library-validation", @"com.apple.security.cs.allow-dyld-environment-variables",
            @"com.apple.security.cs.allow-unsigned-executable-memory"]) {
            if ([entitlements[key] boolValue]) valid = false;
        }
        valid = valid && SecCodeCheckValidity(guest, kSecCSDefaultFlags, requirement) == errSecSuccess;
    }
    if (info) CFRelease(info);
    if (staticCode) CFRelease(staticCode);
    if (requirement) CFRelease(requirement);
    if (guest) CFRelease(guest);
    return valid;
}

static NSDictionary *exchange(int fd, NSString *operation, NSDictionary *extra, double deadline) {
    NSString *identifier = NSUUID.UUID.UUIDString;
    NSMutableDictionary *request = [@{@"version": @1, @"id": identifier, @"operation": operation} mutableCopy];
    [request addEntriesFromDictionary:extra ?: @{}];
    NSData *payload = [NSJSONSerialization dataWithJSONObject:request options:0 error:NULL];
    if (!payload || payload.length == 0 || payload.length > 16384) return nil;
    uint32_t size = htonl((uint32_t)payload.length);
    if (!transfer(fd, &size, sizeof(size), true, deadline)
        || !transfer(fd, (void *)payload.bytes, payload.length, true, deadline)
        || !transfer(fd, &size, sizeof(size), false, deadline)) return nil;
    size = ntohl(size);
    if (size == 0 || size > 16384) return nil;
    NSMutableData *response = [NSMutableData dataWithLength:size];
    if (!transfer(fd, response.mutableBytes, size, false, deadline)) return nil;
    id decoded = [NSJSONSerialization JSONObjectWithData:response options:0 error:NULL];
    if (![decoded isKindOfClass:NSDictionary.class] || ![decoded[@"id"] isEqual:identifier]
        || ![decoded[@"version"] isEqual:@1]) return nil;
    return decoded;
}

@interface OCUPlugin : NSObject
@property(nonatomic, assign) const AuthorizationCallbacks *callbacks;
@end
@implementation OCUPlugin
@end

@interface OCUMechanism : NSObject
@property(nonatomic, strong) OCUPlugin *plugin;
@property(nonatomic, strong) NSRecursiveLock *mutex;
@property(nonatomic, assign) AuthorizationEngineRef engine;
@property(nonatomic, assign) int descriptor;
@property(nonatomic, assign) BOOL cancelled;
@property(nonatomic, assign) BOOL invoked;
@property(nonatomic, assign) BOOL loadCheck;
@end
@implementation OCUMechanism
@end

static OSStatus pluginDestroy(AuthorizationPluginRef ref) {
    if (!ref) return errAuthorizationInvalidRef;
    (void)CFBridgingRelease(ref);
    return errAuthorizationSuccess;
}

static OSStatus mechanismCreate(AuthorizationPluginRef pluginRef, AuthorizationEngineRef engine,
                               AuthorizationMechanismId name, AuthorizationMechanismRef *out) {
    if (!out) return errAuthorizationInvalidPointer;
    *out = NULL;
    if (!pluginRef || !engine || !name) return errAuthorizationInvalidRef;
    if (strcmp(name, "remote") != 0 && strcmp(name, "load-check") != 0) return errAuthorizationInternal;
    OCUMechanism *mechanism = [OCUMechanism new];
    mechanism.plugin = (__bridge OCUPlugin *)pluginRef;
    mechanism.mutex = [NSRecursiveLock new];
    mechanism.engine = engine;
    mechanism.descriptor = -1;
    mechanism.loadCheck = strcmp(name, "load-check") == 0;
    *out = (AuthorizationMechanismRef)CFBridgingRetain(mechanism);
    return errAuthorizationSuccess;
}

static OSStatus mechanismInvoke(AuthorizationMechanismRef ref) {
    if (!ref) return errAuthorizationInvalidRef;
    @autoreleasepool {
        OCUMechanism *mechanism = (__bridge OCUMechanism *)ref;
        os_log_t logger = os_log_create("dev.opencomputeruse.locked-use", "AuthorizationMechanism");
        os_log_with_type(logger, OS_LOG_TYPE_DEFAULT, "mechanismInvoked");
        [mechanism.mutex lock];
        if (mechanism.cancelled || mechanism.invoked) {
            [mechanism.mutex unlock]; return errAuthorizationInternal;
        }
        mechanism.invoked = YES;
        if (mechanism.loadCheck) {
            // Installer-only, separate right. Context is exported by authd
            // only on success: grant this load-check right, never a session
            // unlock right or reusable credential. Remote still requires a
            // guard-bound Broker permit; this mechanism is not its fallback.
            const char marker[] = "OCULockAuth-loaded-v1";
            AuthorizationValue value = {.length = sizeof(marker), .data = (void *)marker};
            OSStatus markerStatus = mechanism.plugin.callbacks->SetContextValue
                ? mechanism.plugin.callbacks->SetContextValue(mechanism.engine,
                    "dev.opencomputeruse.locked-use.load-check", kAuthorizationContextFlagExtractable, &value)
                : errAuthorizationInternal;
            auditinfo_addr_t audit = {0};
            if (markerStatus == errAuthorizationSuccess && getaudit_addr(&audit, sizeof(audit)) == 0) {
                uint32_t session = (uint32_t)audit.ai_asid;
                AuthorizationValue sessionValue = {.length = sizeof(session), .data = &session};
                (void)mechanism.plugin.callbacks->SetContextValue(mechanism.engine,
                    "dev.opencomputeruse.locked-use.load-check.audit-session", kAuthorizationContextFlagExtractable, &sessionValue);
            }
            OSStatus result = mechanism.plugin.callbacks->SetResult(mechanism.engine,
                markerStatus == errAuthorizationSuccess ? kAuthorizationResultAllow : kAuthorizationResultDeny);
            os_log_with_type(logger, OS_LOG_TYPE_DEFAULT, "loadCheck markerStatus=%{public}d resultStatus=%{public}d", (int)markerStatus, (int)result);
            [mechanism.mutex unlock];
            return result;
        }
        int fd = socket(AF_UNIX, SOCK_STREAM, 0);
        mechanism.descriptor = fd;
        [mechanism.mutex unlock];
        BOOL allowed = NO;
        double deadline = monotonic() + 2;
        if (fd >= 0) {
            int value = 1;
            struct sockaddr_un address = {.sun_family = AF_UNIX, .sun_len = sizeof(struct sockaddr_un)};
            strlcpy(address.sun_path, socketPath, sizeof(address.sun_path));
            BOOL configured = fcntl(fd, F_SETFD, FD_CLOEXEC) == 0 && fcntl(fd, F_SETFL, O_NONBLOCK) == 0
                && setsockopt(fd, SOL_SOCKET, SO_NOSIGPIPE, &value, sizeof(value)) == 0;
            int result = configured ? connect(fd, (struct sockaddr *)&address, sizeof(address)) : -1;
            if (result < 0 && configured && errno == EINPROGRESS && ready(fd, POLLOUT, deadline)) {
                int failure = 0;
                socklen_t size = sizeof(failure);
                if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &failure, &size) == 0 && failure == 0) result = 0;
            }
            os_log_with_type(logger, OS_LOG_TYPE_DEFAULT, "brokerConnect connected=%{public}d", result == 0);
            if (result == 0 && verifyBroker(fd)) {
                os_log_with_type(logger, OS_LOG_TYPE_DEFAULT, "brokerVerified");
                NSDictionary *claim = exchange(fd, @"pluginClaim", nil, deadline);
                os_log_with_type(logger, OS_LOG_TYPE_DEFAULT, "pluginClaim replied=%{public}d authorizing=%{public}d denied=%{public}d", claim != nil, [claim[@"phase"] isEqual:@"authorizing"], [claim[@"result"] isEqual:@"denied"]);
                NSString *lease = [claim[@"leaseID"] isKindOfClass:NSString.class] ? claim[@"leaseID"] : nil;
                NSString *token = [claim[@"token"] isKindOfClass:NSString.class] ? claim[@"token"] : nil;
                NSData *nonce = token ? [[NSData alloc] initWithBase64EncodedString:token options:0] : nil;
                if ([claim[@"phase"] isEqual:@"authorizing"] && lease && [[NSUUID alloc] initWithUUIDString:lease] && nonce.length == 32) {
                    NSDictionary *reply = exchange(fd, @"pluginConsume", @{@"leaseID": lease, @"token": token}, deadline);
                    allowed = [reply[@"result"] isEqual:@"authorized"] && [reply[@"phase"] isEqual:@"unlocking"];
                    os_log_with_type(logger, OS_LOG_TYPE_DEFAULT, "pluginConsume replied=%{public}d allowed=%{public}d", reply != nil, allowed);
                }
            }
        }
        [mechanism.mutex lock];
        OSStatus status = errAuthorizationSuccess;
        if (!mechanism.cancelled) {
            status = mechanism.plugin.callbacks->SetResult(mechanism.engine,
                allowed ? kAuthorizationResultAllow : kAuthorizationResultDeny);
            os_log_with_type(logger, OS_LOG_TYPE_DEFAULT, "resultDelivered allowed=%{public}d status=%{public}d", allowed, (int)status);
        }
        [mechanism.mutex unlock];
        if (fd >= 0) {
            // Best effort completion, bounded by the same absolute deadline.
            (void)exchange(fd, @"pluginFinished", allowed && status == errAuthorizationSuccess
                ? nil : @{@"stopReason": @"operationFailed"}, deadline);
            [mechanism.mutex lock];
            mechanism.descriptor = -1;
            close(fd);
            [mechanism.mutex unlock];
        }
        return status;
    }
}

static OSStatus mechanismDeactivate(AuthorizationMechanismRef ref) {
    if (!ref) return errAuthorizationInvalidRef;
    OCUMechanism *mechanism = (__bridge OCUMechanism *)ref;
    [mechanism.mutex lock];
    mechanism.cancelled = YES;
    if (mechanism.descriptor >= 0) shutdown(mechanism.descriptor, SHUT_RDWR);
    OSStatus status = mechanism.plugin.callbacks->DidDeactivate(mechanism.engine);
    [mechanism.mutex unlock];
    return status;
}

static OSStatus mechanismDestroy(AuthorizationMechanismRef ref) {
    if (!ref) return errAuthorizationInvalidRef;
    OCUMechanism *mechanism = CFBridgingRelease(ref);
    [mechanism.mutex lock];
    mechanism.cancelled = YES;
    if (mechanism.descriptor >= 0) shutdown(mechanism.descriptor, SHUT_RDWR);
    [mechanism.mutex unlock];
    return errAuthorizationSuccess;
}

static const AuthorizationPluginInterface interface = {
    .version = kAuthorizationPluginInterfaceVersion,
    .PluginDestroy = pluginDestroy, .MechanismCreate = mechanismCreate,
    .MechanismInvoke = mechanismInvoke, .MechanismDeactivate = mechanismDeactivate,
    .MechanismDestroy = mechanismDestroy
};

__attribute__((visibility("default")))
OSStatus AuthorizationPluginCreate(const AuthorizationCallbacks *callbacks,
                                   AuthorizationPluginRef *out, const AuthorizationPluginInterface **outInterface) {
    if (out) *out = NULL;
    if (outInterface) *outInterface = NULL;
    if (!callbacks || !out || !outInterface || callbacks->version < 1 || !callbacks->SetResult || !callbacks->DidDeactivate)
        return errAuthorizationInvalidPointer;
    OCUPlugin *plugin = [OCUPlugin new];
    plugin.callbacks = callbacks;
    *out = (AuthorizationPluginRef)CFBridgingRetain(plugin);
    *outInterface = &interface;
    return errAuthorizationSuccess;
}