Skip to content

๐Ÿ‘พ Open Computer Use โ€“ Open-Source Alternative to Codex Computer Use

11.2 KB
Raw Blame
"""Report privacy filters; no desktop, daemon, lock or authentication calls."""
import importlib.util
from pathlib import Path
import unittest
from unittest.mock import patch
import json
import subprocess
import sys

spec = importlib.util.spec_from_file_location("report", Path(__file__).resolve().parents[1]/"locked_use_report.py")
report = importlib.util.module_from_spec(spec)
spec.loader.exec_module(report)


class ReportTests(unittest.TestCase):
    def entry(self, message, category="UnlockTrigger", process="OCUGuardian"):
        return {"eventMessage": message, "category": category, "processImagePath": "/private/"+process,
                "timestamp": "2026-10-05T10:00:00+00:00", "privateData": "must never be retained"}

    def testRenamedAndLegacyComponentsKeepNormalizedDiagnostics(self):
        for process in ['OCUGuardian', 'OpenComputerUseGuardian']:
            result = report.curate([self.entry('AXTrigger returnPairQueued=true authenticationEvidence=false', process=process)], 0)
            self.assertEqual(len(result), 1)
        for plugin in ['OCULockAuth', 'OpenComputerUseLockedUseAuthorizationPlugin']:
            result = report.curate([self.entry('running mechanism '+plugin+':remote', process='authd')], 0)
            self.assertEqual(result[0]['message'], 'remoteMechanismRunning')

    def testReturnSubmissionMarkersAreCuratedWithoutContext(self):
        entries = [self.entry('AXTrigger returnDispatching=true keyCode=36 tap=hid'),
                   self.entry('AXTrigger returnPairQueued=true authenticationEvidence=false'),
                   self.entry('keyPressed: return in secure textfield private-context', process='loginwindow'),
                   self.entry('authBegan private-context', process='loginwindow'),
                   self.entry('_authCopyRightsWithUsername private-context', process='loginwindow')]
        result = report.curate(entries, 0)
        self.assertEqual(len(result), 5)
        self.assertEqual([e['message'] for e in result[2:]],
                         ['secureReturnObserved', 'localAuthenticationBegan', 'loginwindowRightsRequested'])
        self.assertNotIn('private-context', str(result))

    def testKeepsCodesAndBooleansWithoutRawMetadata(self):
        result = report.curate([self.entry("AXProbe nodes=14 primaryMatches=0 fallbackMatches=1 complete=true")], 0)
        self.assertEqual(len(result), 1)
        self.assertEqual(set(result[0]), {"elapsedSeconds", "category", "message"})
        self.assertNotIn("privateData", str(result))

    def testUnknownAXContentAndTrailingFieldsAreDiscarded(self):
        for message in ["AXValue=user-secret", "AXProbe nodes=14 primaryMatches=0 fallbackMatches=1 complete=true password=user-secret",
                        "AXProbe writable=true status=0 AXTitle=User Name"]:
            self.assertEqual(report.curate([self.entry(message)], 0), [])

    def testSystemRuleEventsDoNotRetainCallerOrAccount(self):
        entry = self.entry("Succeeded authorizing right 'system.login.screensaver' by client /private/example user=secret-account", process="authd")
        result = report.curate([entry], 0)
        self.assertEqual(result[0]["message"], "systemRightSucceeded")
        self.assertNotIn("secret-account", str(result))

    def testPluginPositiveAndNegativeResultsArePreserved(self):
        for message in ["brokerTaskVerification status=1", "pluginConsume replied=1 allowed=1", "resultDelivered allowed=1 status=0"]:
            self.assertEqual(len(report.curate([self.entry(message, "AuthorizationMechanism")], 0)), 1)

    def testConfirmationAndAllWatchdogStopReasonsRemainVisible(self):
        for message in ['AXTrigger passwordConfirmSupported=true status=0',
                        'AXTrigger passwordConfirm status=0 authenticationEvidence=false',
                        'AXTrigger passwordConfirmTimeout milliseconds=2000 status=0',
                        'AXTrigger passwordConfirmElapsed milliseconds=80 status=-25204',
                        'AXTrigger passwordConfirmDispatching=true',
                        'AXTrigger passwordConfirmSkipped=deadline',
                        'AXProbe passwordUI enabledButtons=1 disabledButtons=1 unknownButtons=0',
                        'AXProbe passwordFocused=true status=0']:
            self.assertEqual(len(report.curate([self.entry(message)], 0)), 1)
            self.assertEqual(report.curate([self.entry(message + ' secret=private')], 0), [])
        for reason in ['filterEvent', 'hardwareActivity', 'parentHeartbeatExpired',
                       'shieldNotVisible', 'parentDisconnected']:
            self.assertEqual(len(report.curate([self.entry('stopping reason=' + reason, 'Watchdog')], 0)), 1)

    def testProtectionAgeEvidenceRejectsExtraFields(self):
        message = 'guardLostEvidence guardianAgeMilliseconds=20 watchdogAgeMilliseconds=1501 watchdogProtected=true'
        self.assertEqual(len(report.curate([self.entry(message, 'Broker')], 0)), 1)
        self.assertEqual(report.curate([self.entry(message + ' user=private', 'Broker')], 0), [])

    def testMalformedLogsAreDiscarded(self):
        self.assertEqual(report.curate({"unexpected": "object"}, 0), [])
        self.assertEqual(report.curate([None, {"processImagePath": 3}, {"timestamp": []}], 0), [])

    def testOfflineABIAndPreviousRunsCannotCountAsLiveResults(self):
        self.assertEqual(report.curate([self.entry("resultDelivered allowed=1 status=0", "AuthorizationMechanism", "remote-plugin-abi-tests")], 0), [])
        self.assertEqual(report.curate([self.entry("AXProbe writable=true status=0")], 9999999999), [])

    def testSystemStartAndInputMarkersRetainNoCredentials(self):
        for message, process, expected in [
            ('engine 77 evaluates 1 rights "system.login.screensaver" username=secret', 'authd', 'systemRightEvaluationObserved'),
            ('loginPressed password=secret', 'loginwindow', 'localSubmitObserved'),
            ('APEventTouchIDMatch user=secret', 'loginwindow', 'touchIDMatchObserved'),
            ('attempting to unlock with empty might rekey secret', 'loginwindow', 'emptyInputKeychainPathObserved')]:
            result = report.curate([self.entry(message, process=process)], 0)
            self.assertEqual(result[0]['message'], expected)
            self.assertNotIn('secret', str(result))
        self.assertEqual(report.curate([self.entry('loginPressed', process='fake-loginwindow')], 0), [])

    def testManualRecoveryCannotCountAsAutomaticAuthorization(self):
        def event(at, category, message):
            return {'elapsedSeconds': at, 'category': category, 'message': message}
        events = [event(1, 'Broker', 'phase=authorizing stopReason=none'),
                  event(6, 'Broker', 'phase=relocking stopReason=unlockTimeout'),
                  event(10, 'LoginWindow', 'localSubmitObserved'),
                  event(11, 'AuthorizationMechanism', 'mechanismInvoked'),
                  event(12, 'SystemAuthorization', 'systemRightSucceeded')]
        window = report.authentication_windows(events)[0]
        self.assertEqual(window['endedAt'], 6)
        self.assertFalse(window['rightEvaluationObserved'])
        self.assertFalse(window['mechanismObserved'])
        self.assertFalse(window['localAuthenticationObserved'])
        # Root transitions before SetResult; do not drop the actual Allow.
        events = [event(1, 'Broker', 'phase=authorizing stopReason=none'),
                  event(2, 'Broker', 'phase=unlocking stopReason=none'),
                  event(3, 'AuthorizationMechanism', 'resultDelivered allowed=1 status=0')]
        self.assertTrue(report.authentication_windows(events)[0]['allowObserved'])

    def testRepeatedAuthorizingTransitionDoesNotLeaveAnOpenWindow(self):
        def event(at, message):
            return {'elapsedSeconds': at, 'category': 'Broker', 'message': message}
        windows = report.authentication_windows([
            event(1, 'phase=authorizing stopReason=none'),
            event(1.012, 'phase=authorizing stopReason=none'),
            event(6, 'phase=relocking stopReason=unlockTimeout'),
            event(6.012, 'phase=relocking stopReason=unlockTimeout')])
        self.assertEqual(len(windows), 1)
        self.assertEqual(windows[0]['startedAt'], 1)
        self.assertEqual(windows[0]['endedAt'], 6)

    def testTriggerLogsNeverRetainFieldContentsOrClickCoordinates(self):
        for message in ['AXTrigger emptyValueWrite status=0',
                        'AXTrigger focusedUserPress status=-25206 authenticationEvidence=false',
                        'AXTrigger targetedClickQueued=true authenticationEvidence=false',
                        'AXTrigger annotatedClickQueued=true']:
            self.assertEqual(len(report.curate([self.entry(message)], 0)), 1)
            self.assertEqual(report.curate([self.entry(message+' value=private')], 0), [])
            self.assertEqual(report.curate([self.entry(message+' x=123 y=456')], 0), [])

    def testClickCapabilityAndIdentityAreNeverIncluded(self):
        for category, message in [('LockUIClickFilter', 'clickAdmitted filter=watchdog type=down'),
                                  ('Broker', 'verificationSlow endpoint=guardian elapsedMilliseconds=300'),
                                  ('UnlockTrigger', 'AXTrigger sessionClickQueued=true')]:
            self.assertEqual(len(report.curate([self.entry(message, category)], 0)), 1)
            self.assertEqual(report.curate([self.entry(message+' clickTag=123', category)], 0), [])

    def testProtectedWaitingDoesNotImplyPermitIssued(self):
        events = [{'elapsedSeconds': 1, 'category': 'Broker', 'message': 'phase=authorizing stopReason=none'},
                  {'elapsedSeconds': 4, 'category': 'Broker', 'message': 'permitIssued maximumLifetimeSeconds=5'},
                  {'elapsedSeconds': 5, 'category': 'Broker', 'message': 'phase=relocking stopReason=unlockTimeout'}]
        window = report.authentication_windows(events)[0]
        self.assertEqual(window['startedAt'], 1)
        self.assertEqual(window['permitIssuedObservedAt'], 4)
        self.assertIsNone(report.authentication_windows([events[0], events[2]])[0]['permitIssuedObservedAt'])

    def testUnavailableStreamRemainsDiagnosticOnly(self):
        trace = report.LiveAuthenticationTrace(0)
        with patch.object(report.subprocess, 'Popen', side_effect=OSError): trace.start()
        events, status = trace.finish()
        self.assertEqual(events, [])
        self.assertEqual(status, 'unavailable')

    def testStreamDiscardsOversizedRawRecordsAndResumes(self):
        # A synthetic pipe exercises framing/lifecycle without invoking OS logs.
        record = self.entry('loginPressed credential=must_not_persist', process='loginwindow')
        code = 'import sys; sys.stdout.write("x"*70000+"\\n"+' + repr(json.dumps(record)+'\n') + '); sys.stdout.flush()'
        child = subprocess.Popen([sys.executable, '-c', code], stdout=subprocess.PIPE)
        trace = report.LiveAuthenticationTrace(0, max_seconds=1)
        with patch.object(report.subprocess, 'Popen', return_value=child): trace.start()
        trace.thread.join(timeout=2)
        events, status = trace.finish()
        self.assertEqual(len(events), 1)
        self.assertEqual(events[0]['message'], 'localSubmitObserved')
        self.assertNotIn('must_not_persist', str(events))
        self.assertEqual(status, 'ended')


if __name__ == "__main__": unittest.main()