"""Independent, read-only verification of the bounded ordinary relative-look proof. Raw native records prove pose changes; helper timestamps only bind requested input ordering. Display/session/process ownership and complete keyboard delivery remain separate runner checks. This module never sends input or opens a native process. """ import math import re NUMBER = r'-?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?' LOOK = 'ERR LOOK OBSERVE: ' INPUT = 'ERR INPUT OBSERVE: ' SCOPE = 'two fixed relative mouse requests with native camera yaw response and return; stationary body; no visual, aiming, multiplayer or general input qualification' CANCEL_REASONS = {'menu-opened', 'original-binding-changed', 'sample-or-clock-bound', 'native-camera-or-player-context-lost', 'invalid-native-pose', 'explicit-scope-lost'} def _require(condition, reason): if not condition: raise ValueError(reason) def _number(value): _require(type(value) in (int, float) and math.isfinite(value) and value >= 0, 'invalid nonnegative numeric timestamp') return value def _index(value): _require(type(value) is int and 1 <= value <= 450, 'invalid sample reference') return value def _vector(value): if value.startswith('<') and value.endswith('>'): value = value[1:-1] _require(re.fullmatch(NUMBER + r'(?:\s*,\s*|\s+)' + NUMBER + r'(?:\s*,\s*|\s+)' + NUMBER, value.strip()), 'malformed native vector') result = tuple(float(v) for v in re.findall(NUMBER, value)) _require(all(math.isfinite(v) and abs(v) <= 10000000 for v in result), 'nonfinite or unbounded native vector') return result def _norm(v): return math.sqrt(sum(x*x for x in v)) def _distance(a, b): return _norm(tuple(x-y for x, y in zip(a, b))) def _yaw(v): _require(.95 <= _norm(v) <= 1.05 and math.hypot(v[0], v[2]) > .1, 'native camera direction is not unit or has no usable horizontal direction') return math.degrees(math.atan2(v[0], v[2])) def _delta(a, b): return (a-b+180) % 360-180 def _native(content, nonce): _require(type(content) is str and len(content) <= 32*1024*1024, 'console content exceeds bound or is not text') _require(type(nonce) is str and re.fullmatch(r'[A-Za-z0-9]{1,32}', nonce), 'invalid expected nonce') look_header = re.compile(r'run=([A-Za-z0-9]{1,32}) sample=(\d+) real=(\d+) (.+)') input_header = re.compile(r'run=([A-Za-z0-9]{1,32}) sample=(\d+) real=(\d+) world=('+NUMBER+r') (.+)') pose_pattern = re.compile(r'SAMPLE direction=(.+?) camera=(.+?) body=(.+?) bodyForward=(.+?) turn=(.+)') input_pattern = re.compile(r'SAMPLE origin=(.+?) forward=('+NUMBER+r') input=(.+?) velocity=(.+?) inventory=(0|1|true|false)') poses, samples = {}, {} basis = None; cancelled = None; ready = None; queued = None last_look = (-1, -1); last_input = (-1, -1, -1) look_count = input_count = 0 input_events = set(); input_terminal = False for ordinal, line in enumerate(content.splitlines()): if LOOK.rstrip() in line: _require(LOOK in line, 'malformed look prefix') look_count += 1 _require(look_count <= 452 and line.count(LOOK) == 1, 'look record count or prefix invalid') match = look_header.fullmatch(line.split(LOOK, 1)[1].strip()) _require(match is not None, 'malformed look record') actual, sample, real, event = match.groups(); sample, real = int(sample), int(real) _require(actual == nonce, 'foreign look nonce') _require(1 <= sample <= 450 and real <= 2147483647, 'look clock/sample outside bound') _require(sample >= last_look[0] and real >= last_look[1], 'look records reversed') _require(cancelled is None, 'look records after cancellation') last_look = sample, real if event == 'BASIS native-player-camera-world-transform': _require(basis is None and not poses and sample == 1, 'duplicate or late native camera acknowledgement') basis = (sample, real, ordinal) elif event.startswith('SAMPLE '): _require(basis is not None, 'missing native camera acknowledgement') match = pose_pattern.fullmatch(event) _require(match is not None, 'malformed native look sample') _require(sample == len(poses)+1, 'look samples missing or duplicated') values = [_vector(v) for v in match.groups()] direction, camera, body, facing, turn = values _yaw(direction) _require(.95 <= _norm(facing) <= 1.05 and math.hypot(facing[0], facing[2]) > .1 and turn[2] == 0, 'invalid body forward or native turn vector') poses[sample] = dict(sample=sample, real_ms=real, ordinal=ordinal, direction=direction, camera=camera, body=body, body_forward=facing, turn=turn) if sample == 1: _require(real == basis[1], 'native acknowledgement does not bind first camera sample') elif event.startswith('CANCELLED '): _require(event[10:] in CANCEL_REASONS, 'unknown look cancellation') cancelled = dict(sample=sample, real_ms=real, reason=event[10:], ordinal=ordinal) else: raise ValueError('unknown look event') if INPUT.rstrip() in line: _require(INPUT in line, 'malformed input prefix') input_count += 1 _require(input_count <= 460 and line.count(INPUT) == 1, 'input record count or prefix invalid') match = input_header.fullmatch(line.split(INPUT, 1)[1].strip()) _require(match is not None, 'malformed input record') actual, sample, real, world, event = match.groups() _require(not input_terminal, 'input records after terminal event') if not event.startswith('SAMPLE '): _require(event not in input_events, 'duplicate input event') input_events.add(event) sample, real, world = int(sample), int(real), float(world) _require(actual == nonce, 'foreign input nonce') _require(0 <= sample <= 450 and real <= 2147483647 and math.isfinite(world) and world >= 0, 'input clock/sample outside bound') _require(sample >= last_input[0] and real >= last_input[1] and world >= last_input[2], 'input records reversed') last_input = sample, real, world if event == 'QUEUED': _require(queued is None and not samples and sample == 0, 'duplicate or late input queued event') queued = (sample, real, world) elif event == 'READY': # Record() reads the process clock again after the SAMPLE/LOOK # writes. Bind READY to the latest emitted sample, not to an # unrealistically identical millisecond. Later sample ordering # still rejects a READY timestamp beyond the next sample. _require(ready is None and sample == len(samples) and sample in samples and 0 <= real-samples[sample]['real_ms'] <= 500 and world == samples[sample]['world_ms'], 'duplicate or unbound input READY') ready = dict(sample=sample, real_ms=real, ordinal=ordinal) elif event.startswith('SAMPLE '): _require(queued is not None and sample == len(samples)+1, 'input samples missing, duplicated or unqueued') match = input_pattern.fullmatch(event) _require(match is not None, 'malformed native input sample') origin, forward, movement, velocity, inventory = match.groups() forward = float(forward) _require(math.isfinite(forward), 'nonfinite input forward') samples[sample] = dict(sample=sample, real_ms=real, world_ms=world, ordinal=ordinal, origin=_vector(origin), forward=forward, input=_vector(movement), velocity=_vector(velocity), inventory=inventory in ('1', 'true')) elif event in ('INVENTORY_OPEN', 'INVENTORY_CLOSED', 'CAPTURE_REQUEST baseline', 'CAPTURE_REQUEST open', 'CAPTURE_REQUEST closed', 'FINISHED observation-bound'): input_terminal = event == 'FINISHED observation-bound' # Complete menu sequencing is independently checked by the runner. elif event.startswith('CANCELLED '): _require(bool(event[10:].strip()), 'empty input cancellation') input_terminal = True # A later shutdown is outside the look proof, but cannot erase an earlier loss. for pose in poses.values(): _require(pose['real_ms'] < real, 'input cancellation overlaps native look samples') else: raise ValueError('unknown input event') _require(basis is not None and poses and ready is not None and queued is not None, 'missing native camera acknowledgement, samples or input READY') _require(ready['real_ms']-queued[1] >= 2000, 'input READY has no stationary baseline duration') for index, pose in poses.items(): _require(index in samples and samples[index]['real_ms'] == pose['real_ms'], 'native pose/input sample binding mismatch') _require(0 <= pose['real_ms']-queued[1] < 45000, 'native pose outside original observation lifetime') return poses, samples, ready, cancelled def validate_look_evidence(content, nonce, look_proof, keyboard_events=None): """Fail closed; recompute native geometry independently of helper claims.""" result = {'verified': False, 'errors': [], 'scope': SCOPE} try: _require(type(look_proof) is dict and set(look_proof) == { 'requested', 'completed', 'started_monotonic', 'finished_monotonic', 'baseline_samples', 'response_sample', 'return_sample', 'motions'}, 'unknown or missing look proof fields') _require(look_proof['requested'] is True and look_proof['completed'] is True, 'look proof not explicitly requested and completed') start = _number(look_proof['started_monotonic']); finish = _number(look_proof['finished_monotonic']) _require(0 < finish-start <= 4, 'helper look interval outside four-second bound') baseline = look_proof['baseline_samples'] _require(type(baseline) is list and len(baseline) == 2, 'exactly two baseline sample references required') first, base = [_index(i) for i in baseline] response = _index(look_proof['response_sample']); returned = _index(look_proof['return_sample']) _require(base == first+1 and base < response < returned, 'baseline/response/return sample ordering invalid') poses, samples, ready, cancelled = _native(content, nonce) _require(first >= ready['sample'] and all(i in poses for i in (first, base, response, returned)), 'native ready baseline/response/return missing') _require(cancelled is None or cancelled['sample'] > returned, 'native camera context cancelled before return') motions = look_proof['motions'] _require(type(motions) is list and len(motions) == 2, 'exactly two relative motions required') times = [] for event, dx, after in zip(motions, (24, -24), (base, response)): _require(type(event) is dict and set(event) == {'dx', 'dy', 'monotonic', 'after_sample', 'after_real_ms'}, 'unknown or missing motion fields') _require(type(event['dx']) is int and event['dx'] == dx and type(event['dy']) is int and event['dy'] == 0, 'motion differs from fixed relative request') _require(type(event['after_sample']) is int and event['after_sample'] == after and type(event['after_real_ms']) is int and event['after_real_ms'] == poses[after]['real_ms'], 'motion native reference mismatch') times.append(_number(event['monotonic'])) _require(start <= times[0] < times[1] <= finish, 'motion timestamps reversed or outside proof') _require(0 < poses[returned]['real_ms']-poses[first]['real_ms'] <= 4000, 'native look interval outside four-second bound') _require(poses[response]['real_ms'] > poses[base]['real_ms'] and poses[returned]['real_ms'] > poses[response]['real_ms'], 'native response/return clocks did not advance') for index in range(ready['sample'], returned+1): _require(index in poses and index in samples, 'missing native observation during look proof') pose, sample = poses[index], samples[index] _require(index == ready['sample'] or 0 < pose['real_ms']-poses[index-1]['real_ms'] <= 500, 'native look sampling gap or duplicate clock') _require(not sample['inventory'] and abs(sample['forward']) <= .01 and _norm(sample['input']) <= .01 and _norm(sample['velocity']) <= .05, 'body input, velocity or inventory changed during look proof') _require(_distance(sample['origin'], samples[ready['sample']]['origin']) <= .05 and _distance(pose['body'], samples[ready['sample']]['origin']) <= .05 and _distance(pose['body'], sample['origin']) <= .01, 'body moved or native body/input positions disagree') base_yaw = _yaw(poses[base]['direction']) stable = abs(_delta(base_yaw, _yaw(poses[first]['direction']))) response_yaw = _delta(_yaw(poses[response]['direction']), base_yaw) return_yaw = _delta(_yaw(poses[returned]['direction']), base_yaw) _require(stable <= .1, 'camera baseline not stable') _require(.25 <= abs(response_yaw) <= 30, 'native camera yaw did not show bounded response') _require(abs(return_yaw) <= .35 and abs(return_yaw) < abs(response_yaw)/2, 'native camera did not return near baseline') if keyboard_events is not None: _require(type(keyboard_events) is list and 1 <= len(keyboard_events) <= 8, 'invalid keyboard event list') previous = -1; first_w = None for event in keyboard_events: _require(type(event) is dict and set(event) <= {'key', 'down', 'monotonic', 'finally'} and {'key', 'down', 'monotonic'} <= set(event), 'malformed keyboard event') _require(event['key'] in ('W', 'Tab') and type(event['down']) is bool and ('finally' not in event or type(event['finally']) is bool), 'unknown keyboard event') at = _number(event['monotonic']); _require(at >= previous, 'keyboard timestamps reversed'); previous = at _require(at > finish, 'keyboard request overlaps or precedes look completion') if first_w is None and event['key'] == 'W' and event['down']: first_w = at _require(first_w is not None and keyboard_events[0]['key'] == 'W' and keyboard_events[0]['down'] is True, 'first W press missing or not first keyboard event') result.update(verified=True, baseline_samples=baseline, response_sample=response, return_sample=returned, baseline_yaw_delta_degrees=stable, response_yaw_degrees=response_yaw, return_yaw_degrees=return_yaw, native_duration_ms=poses[returned]['real_ms']-poses[first]['real_ms'], motion_count=2, keyboard_order_verified=keyboard_events is not None) except (ValueError, TypeError, KeyError, OverflowError) as error: result['errors'].append(str(error)) return result