"""Private independent oracle and candidate-identity execution; no hidden child assertions.""" import base64 import hashlib import json import lzma import math import os from pathlib import Path import re import stat import subprocess import sys import tempfile import time import uuid SUPERVISOR = "# Candidate-identity execution only: no expected values or grading assertions.\nimport base64\nimport ctypes\nimport hashlib\nimport json\nimport os\nimport signal\nimport subprocess\nimport sys\nimport time\n\n\ndef read_stat(pid):\n try:\n with open('/proc/%d/stat' % pid, 'rb') as stream:\n raw = stream.read()\n except (FileNotFoundError, ProcessLookupError):\n return None\n fields = raw[raw.rfind(b')') + 2:].split()\n return {'pid': int(pid), 'state': fields[0].decode('ascii'),\n 'ppid': int(fields[1]), 'pgid': int(fields[2]), 'start': int(fields[19])}\n\n\ndef closure(table, supervisor, tracked):\n roots = {supervisor}\n for pid, start in tracked.items():\n row = table.get(pid)\n if row and row['start'] == start and row['state'] not in ('Z', 'X'):\n roots.add(pid)\n included = set(roots)\n while True:\n added = {pid for pid, row in table.items() if row['ppid'] in included} - included\n if not added:\n break\n included.update(added)\n return {pid: table[pid]['start'] for pid in included if pid != supervisor and pid in table}\n\n\ndef group_members(table, pgid):\n return {pid: row['start'] for pid, row in table.items() if row['pgid'] == pgid}\n\n\ndef fresh_signal(pid, start, exceptions):\n try:\n row = read_stat(pid)\n if row and row['start'] == start and row['state'] not in ('Z', 'X'):\n os.kill(pid, signal.SIGKILL)\n except (FileNotFoundError, ProcessLookupError):\n pass\n except BaseException as error:\n exceptions.append('signal:' + type(error).__name__ + ':' + repr(error))\n\n\ndef table_now(exceptions):\n table = {}\n try:\n names = os.listdir('/proc')\n except BaseException as error:\n exceptions.append('proc-list:' + type(error).__name__ + ':' + repr(error))\n return table\n for name in names:\n if name.isascii() and name.isdigit():\n try:\n row = read_stat(int(name))\n if row is not None:\n table[int(name)] = row\n except BaseException as error:\n exceptions.append('proc-stat:' + type(error).__name__ + ':' + repr(error))\n return table\n\n\ndef digest_bytes(raw):\n return {'bytes': base64.b64encode(raw).decode('ascii'), 'length': len(raw),\n 'sha256': hashlib.sha256(raw).hexdigest()}\n\n\ndef main():\n begun = time.monotonic()\n exceptions = []\n proc = None\n tracked = {}\n stdout = b''\n stderr = b''\n timedout = False\n descendants = None\n members = None\n result = {'exceptions': exceptions, 'uid': os.getuid(), 'gid': os.getgid(),\n 'groups': os.getgroups(), 'supervisor_pid': os.getpid()}\n request = {}\n try:\n own = read_stat(os.getpid())\n result['supervisor_start'] = own['start']\n request_raw = sys.stdin.buffer.read()\n request = json.loads(request_raw)\n result.update(request_length=len(request_raw), request_sha256=hashlib.sha256(request_raw).hexdigest())\n result.update(nonce=request['nonce'], argv=request['argv'], cwd=request['cwd'],\n deadline=request['deadline'])\n libc = ctypes.CDLL(None, use_errno=True)\n if libc.prctl(36, 1, 0, 0, 0) != 0:\n raise OSError(ctypes.get_errno(), 'subreaper')\n proc = subprocess.Popen(request['argv'], cwd=request['cwd'], stdin=subprocess.PIPE,\n stdout=subprocess.PIPE, stderr=subprocess.PIPE,\n start_new_session=True)\n leader = read_stat(proc.pid)\n if leader is None:\n raise RuntimeError('leader stat missing before first poll')\n tracked[proc.pid] = leader['start']\n result.update(leader_pid=proc.pid, leader_start=leader['start'], leader_pgid=leader['pgid'])\n payload = base64.b64decode(request['input'], validate=True)\n result.update(input_length=len(payload), input_sha256=hashlib.sha256(payload).hexdigest())\n deadline = begun + request['deadline']\n while True:\n tracked.update(closure(table_now(exceptions), os.getpid(), tracked))\n remaining = deadline - time.monotonic()\n if remaining <= 0:\n timedout = True\n break\n try:\n stdout, stderr = proc.communicate(payload, timeout=min(0.05, remaining))\n break\n except subprocess.TimeoutExpired as error:\n if error.output is not None:\n stdout = error.output\n if error.stderr is not None:\n stderr = error.stderr\n payload = None\n except BaseException as error:\n exceptions.append('execute:' + type(error).__name__ + ':' + repr(error))\n finally:\n recovery = time.monotonic() + 3.0\n empty_rounds = 0\n while proc is not None:\n try:\n # Own Popen always receives its exit status before adopted waitpid calls.\n proc.poll()\n if proc.returncode is not None:\n proc.wait(timeout=0)\n while True:\n try:\n adopted, status = os.waitpid(-1, os.WNOHANG)\n except ChildProcessError:\n break\n if adopted == 0:\n break\n table = table_now(exceptions)\n descendants = closure(table, os.getpid(), tracked)\n tracked.update(descendants)\n members = group_members(table, result.get('leader_pgid'))\n if proc.returncode is not None and not descendants and not members:\n empty_rounds += 1\n if empty_rounds >= 2:\n break\n else:\n empty_rounds = 0\n for pid, start in descendants.items():\n fresh_signal(pid, start, exceptions)\n if time.monotonic() >= recovery:\n exceptions.append('recovery:deadline')\n break\n time.sleep(0.01)\n except BaseException as error:\n exceptions.append('recover:' + type(error).__name__ + ':' + repr(error))\n if time.monotonic() >= recovery:\n break\n time.sleep(0.01)\n if proc is not None:\n try:\n stdout, stderr = proc.communicate(timeout=max(0.01, recovery - time.monotonic()))\n except subprocess.TimeoutExpired as error:\n if error.output is not None:\n stdout = error.output\n if error.stderr is not None:\n stderr = error.stderr\n exceptions.append('final-communicate:TimeoutExpired')\n except BaseException as error:\n exceptions.append('final-communicate:' + type(error).__name__ + ':' + repr(error))\n try:\n proc.poll()\n except BaseException as error:\n exceptions.append('final-poll:' + type(error).__name__ + ':' + repr(error))\n result.update(real_rc=proc.returncode if proc else None,\n leader_reaped=proc is not None and proc.returncode is not None,\n timeout=timedout, controlled_rc=124 if timedout else (proc.returncode if proc else None),\n descendants_absent=descendants == {}, pg_absent=members == {},\n tracked=tracked, remaining_descendants=descendants, remaining_pg=members,\n elapsed=time.monotonic() - begun, stdout=digest_bytes(stdout), stderr=digest_bytes(stderr))\n sys.stdout.buffer.write(json.dumps(result, separators=(',', ':'), sort_keys=True).encode('ascii'))\n\n\nif __name__ == '__main__':\n main()\n" HEADER = '#ifndef ARRAY_REPORT_H\n#define ARRAY_REPORT_H\n#include \n#include \n#define RA_LIMIT 128\n#define RA_FIELDS 56\ntypedef struct {\n int count;\n unsigned seed;\n int base;\n int step;\n int mode;\n int cutoff;\n int window;\n int bins;\n int fail_at;\n} ra_request;\ntypedef struct { int value; unsigned position; } ra_cell;\ntypedef struct { long long v[RA_FIELDS]; } ra_report;\ntypedef struct {\n void *context;\n void *(*allocate)(void *, size_t);\n void (*release)(void *, void *);\n void (*publish)(void *, const ra_report *);\n} ra_port;\nvoid ra_trends(const ra_cell *, size_t, ra_report *);\nint ra_process(const ra_request *, const ra_port *);\nint ra_valid(const ra_request *);\nint ra_transform(int, int);\nsize_t ra_generate(const ra_request *, ra_cell *);\nvoid ra_analyse(const ra_request *, const ra_cell *, size_t, ra_report *);\nvoid ra_order(const ra_cell *, size_t, unsigned *);\nvoid ra_rank(const ra_request *, const ra_cell *, const unsigned *, size_t, ra_report *);\n#endif\n' OBSERVER = '#include "array_report.h"\n#include \n#include \n#include \ntypedef struct {\n void *blocks[2];\n size_t sizes[2];\n int fail_at;\n int calls;\n int releases;\n int live;\n int invalid;\n int publications;\n ra_report report;\n} observer;\nstatic void *allocate(void *context, size_t bytes)\n{\n observer *state = context;\n state->calls += 1;\n if (state->calls <= 2) {\n state->sizes[state->calls - 1] = bytes;\n }\n if (state->fail_at == state->calls || state->calls > 2) {\n return NULL;\n }\n void *block = malloc(bytes);\n if (block != NULL) {\n state->blocks[state->calls - 1] = block;\n state->live += 1;\n }\n return block;\n}\nstatic void release(void *context, void *block)\n{\n observer *state = context;\n state->releases += 1;\n for (int index = 0; index < 2; ++index) {\n if (block != NULL && block == state->blocks[index]) {\n free(block);\n state->blocks[index] = NULL;\n state->live -= 1;\n return;\n }\n }\n state->invalid += 1;\n}\nstatic void publish(void *context, const ra_report *report)\n{\n observer *state = context;\n state->publications += 1;\n if (state->live != 2) {\n state->invalid += 1;\n }\n state->report = *report;\n}\nint main(void)\n{\n for (;;) {\n ra_request request;\n int got = scanf("%d %u %d %d %d %d %d %d %d", &request.count,\n &request.seed, &request.base, &request.step, &request.mode,\n &request.cutoff, &request.window, &request.bins, &request.fail_at);\n if (got == EOF) {\n return 0;\n }\n if (got != 9) {\n return 2;\n }\n observer state;\n memset(&state, 0, sizeof(state));\n state.fail_at = request.fail_at;\n ra_port port = {&state, allocate, release, publish};\n const ra_request *selected_request = &request;\n const ra_port *selected_port = &port;\n int probe = request.count;\n if (probe <= -2 && probe >= -6) {\n request.count = 1;\n if (probe == -2) selected_request = NULL;\n if (probe == -3) selected_port = NULL;\n if (probe == -4) port.allocate = NULL;\n if (probe == -5) port.release = NULL;\n if (probe == -6) port.publish = NULL;\n }\n ra_request saved = request;\n ra_port saved_port = port;\n int rc = ra_process(selected_request, selected_port);\n if (request.count != saved.count || request.seed != saved.seed ||\n request.base != saved.base || request.step != saved.step ||\n request.mode != saved.mode || request.cutoff != saved.cutoff ||\n request.window != saved.window || request.bins != saved.bins ||\n request.fail_at != saved.fail_at ||\n port.context != saved_port.context ||\n port.allocate != saved_port.allocate ||\n port.release != saved_port.release ||\n port.publish != saved_port.publish) {\n state.invalid += 1;\n }\n printf("%d %d %d %d %d %zu %zu %d", rc, state.calls, state.releases,\n state.live, state.invalid, state.sizes[0], state.sizes[1], state.publications);\n for (int field = 0; field < RA_FIELDS; ++field) {\n printf(" %lld", state.report.v[field]);\n }\n putchar(\'\\n\');\n for (int index = 0; index < 2; ++index) {\n free(state.blocks[index]);\n }\n }\n}\n' import bisect import re def cells(request): count, seed, base, step, mode, cutoff, window, bins, fail_at = request result = [] for position in range(count): seed = (1664525 * seed + 1013904223) & 0xffffffff value = base + position % 11 * step + (seed >> 16) % 101 - 50 if mode == 1: value = abs(value) if mode == 2: value = max(-25, min(25, value)) if mode == 3: value = value * abs(value) if abs(value) >= cutoff: result.append((value, position)) return result def oracle(request): count, seed, base, step, mode, cutoff, window, bins, fail_at = request valid = (0 <= count <= 128 and 0 <= seed <= 65535 and -100 <= base <= 100 and -7 <= step <= 7 and 0 <= mode <= 3 and 0 <= cutoff <= 100 and 1 <= window <= 16 and 1 <= bins <= 8 and 0 <= fail_at <= 2) zero = [0]*56 if not valid: return [-2,0,0,0,0,0,0,0] + zero if count == 0: return [1,0,0,0,0,0,0,0] + zero if fail_at == 1: return [-1,1,0,0,0,count*8,0,0] + zero if fail_at == 2: return [-1,2,1,0,0,count*8,count*4,0] + zero selected = cells(request); values = [v for v,p in selected]; n = len(values) report = zero[:]; report[:7] = [count,n,count-n,sum(values),sum(map(abs,values)), sum(v*v for v in values),sum(v*(p+1) for v,p in selected)] if n: report[7:11] = [min(values),max(values),next(p for v,p in selected if v==min(values)), next(p for v,p in selected if v==max(values))] report[11:16] = [sum(v<0 for v in values), values.count(0), sum(v>0 for v in values), sum(v for v in values if v%2==0),sum(v for v in values if v%2)] for field, direction in [(16,1),(17,-1)]: report[field] = max([0]+[end-start for start in range(n) for end in range(start+1,n+1) if all(direction*values[j] <= direction*values[j+1] for j in range(start,end-1))]) report[18] = sum(abs(a-b) for a,b in zip(values,values[1:])) width = min(window,n) if n: sums = [sum(values[i:i+width]) for i in range(n-width+1)] report[19:22] = [max(sums),sums.index(max(sums)), max(sum(values[a:b]) for a in range(n) for b in range(a+1,n+1))] checksum = 2166136261 for value,position in selected: checksum = ((checksum ^ (value & 0xffffffff)) * 16777619) & 0xffffffff checksum = ((checksum ^ position) * 16777619) & 0xffffffff report[22] = checksum ordered = sorted(selected) if n: ranked = [v for v,p in ordered]; median = ranked[(n-1)//2] report[23:31] = [len(set(values)), ranked[(n-1)//4],median,ranked[(n-1)*3//4], sum((i+1)*v for i,v in enumerate(ranked)), max([0]+[b-a for a,b in zip(ranked,ranked[1:])]), sum(abs(v-median) for v in values),ordered[0][1]] buckets = [0]*bins for value in values: k = (value-min(values))*bins//(max(values)-min(values)+1) buckets[k] += 1 report[31:35] = [buckets.index(max(buckets)),max(buckets),sum(c>0 for c in buckets), sum((i+1)*c for i,c in enumerate(buckets))] report[35] = sum(values[a]>values[b] for a in range(n) for b in range(a+1,n)) prefixes = [sum(values[:i]) for i in range(n+1)] report[36:38] = [min(prefixes),max(prefixes)] for startfield, sign in [(38,1),(39,-1)]: lengths=[];current=0 for value in values+[0]: if value*sign>0: current+=1 elif current: lengths.append(current);current=0 report[startfield] = len(lengths) report[startfield+2] = max([0]+lengths) report[42:46] = [sum(values[i]>values[i-1] and values[i]>values[i+1] for i in range(1,n-1)), sum(values[i]0 else -1 for v in values if v] report[54]=sum(a!=b for a,b in zip(nonzero,nonzero[1:])) report[55]=max([0]+[end-start for start in range(n) for end in range(start+1,n+1) if len(set(values[start:end]))==1]) return [0,2,2,0,0,count*8,count*4,1]+report def scenarios(): rows = [[100,1,0,1,0,0,4,4,0],[128,65535,-30,7,1,17,16,8,0], [128,22222,30,-7,2,25,1,1,0],[128,119,-100,-7,3,100,16,8,0], [1,0,0,0,0,100,1,8,0],[1,1,0,0,0,0,16,2,0], [8,123,0,0,0,0,2,4,1],[8,123,0,0,0,0,2,4,2],[0,0,0,0,0,0,1,1,2]] basic=[9,17,0,0,0,0,1,4,0] for index,value in [(0,-1),(0,129),(1,65536),(2,-101),(2,101),(3,8),(4,4), (5,-1),(5,101),(6,0),(6,17),(7,0),(7,9),(8,3)]: row=basic[:];row[index]=value;rows.append(row) for probe in range(-6,-1): row=basic[:];row[0]=probe;rows.append(row) return rows def decimal(token): if not re.fullmatch(rb'[+-]?[0-9]+',token): raise ValueError('decimal token') negative=token[:1]==b'-' digits=token.lstrip(b'+-').lstrip(b'0') or b'0' if len(digits)>19: raise ValueError('signed64 range') value=int(digits)*(-1 if negative else 1) if not -2**63 <= value < 2**63: raise ValueError('signed64 range') return value def observations(raw): rows=raw.split(b'\n') if rows[-1:]==[b'']: rows.pop() result=[] for row in rows: tokens=re.split(rb'[ \t\r]+',row.strip(b' \t\r')) if len(tokens)!=64:raise ValueError('observation field count') result.append([decimal(t) for t in tokens]) return result DEADLINES = {'compiler': 12, 'candidate': 6, 'cleanup': 6, 'absence': 6} OUTER_MARGIN = 8 RECLAIM_MARGIN = 4 CANDIDATES = ['engine.c','analyse.c','ordering.c','trends.c'] CLEANUP = "import shutil,sys; shutil.rmtree(sys.argv[1]); print(0)" ABSENCE = "import os,sys\ntry: os.lstat(sys.argv[1])\nexcept FileNotFoundError: print(0)\nelse: print(1)" def blob(raw): return {'length': len(raw), 'sha256': hashlib.sha256(raw).hexdigest(), 'latin1': raw.decode('latin1')} def proc_token(pid): try: with open('/proc/%d/stat' % pid,'rb') as stream: raw=stream.read() except (FileNotFoundError,ProcessLookupError): return None parts=raw[raw.rfind(b')')+2:].split() return int(parts[19]) def source_bytes(root, relative): # All ancestor directories and the leaf are opened without following symlinks. parts=Path(os.path.abspath(root)).parts fd=os.open('/',os.O_RDONLY|os.O_DIRECTORY|os.O_NOFOLLOW) try: for part in [*parts[1:],*Path(relative).parts[:-1]]: child=os.open(part,os.O_RDONLY|os.O_DIRECTORY|os.O_NOFOLLOW,dir_fd=fd) os.close(fd);fd=child leaf=os.open(Path(relative).name,os.O_RDONLY|os.O_NOFOLLOW|os.O_NONBLOCK,dir_fd=fd) try: identity=os.fstat(leaf) if not stat.S_ISREG(identity.st_mode) or identity.st_size>1048576: raise ValueError('source is not a bounded regular file') with os.fdopen(leaf,'rb',closefd=False) as stream: data=stream.read(1048577) if len(data)>1048576: raise ValueError('source too large') return data finally: os.close(leaf) finally: os.close(fd) def valid_int(value, lower=None): return type(value) is int and (lower is None or value>=lower) def unblob(value): if not isinstance(value,dict) or set(value)!={'bytes','length','sha256'}: raise ValueError('IO structure') if not valid_int(value['length'],0):raise ValueError('IO length') raw=base64.b64decode(value['bytes'],validate=True) if len(raw)!=value['length'] or hashlib.sha256(raw).hexdigest()!=value['sha256']: raise ValueError('IO binding') return raw def verify_wire(wire, request, expected_pid, expected_start, wrapper_rc, raw_request): if wrapper_rc!=0:raise ValueError('wrapper nonzero') required={'exceptions','uid','gid','groups','supervisor_pid','supervisor_start','nonce','argv','cwd', 'deadline','leader_pid','leader_start','leader_pgid','real_rc','leader_reaped','timeout', 'controlled_rc','descendants_absent','pg_absent','tracked','remaining_descendants', 'remaining_pg','elapsed','stdout','stderr','request_length','request_sha256','input_length','input_sha256'} if not isinstance(wire,dict) or set(wire)!=required:raise ValueError('wire fields') for name in ('uid','gid'): if not valid_int(wire[name],0):raise ValueError('identity type') if not isinstance(wire['groups'],list) or any(not valid_int(g,0) for g in wire['groups']): raise ValueError('groups type') expected=(65534,65534,[]) if os.environ.get('ROLLOUT_GRADE_ISOLATION')=='uid65534' else (os.getuid(),os.getgid(),os.getgroups()) if (wire['uid'],wire['gid'],wire['groups'])!=expected:raise ValueError('execution identity') for name in ('supervisor_pid','supervisor_start','leader_pid','leader_start','leader_pgid'): if not valid_int(wire[name],1):raise ValueError('PID/start type') if wire['supervisor_pid']!=expected_pid or wire['supervisor_start']!=expected_start: raise ValueError('Popen/supervisor binding') if wire['supervisor_pid']==wire['leader_pid'] or wire['leader_pgid']!=wire['leader_pid']: raise ValueError('leader/session identity') if any(wire[name]!=request[name] for name in ('nonce','argv','cwd','deadline')): raise ValueError('request binding') for prefix,actual in [('request',raw_request),('input',base64.b64decode(request['input']))]: if not valid_int(wire[prefix+'_length'],0) or wire[prefix+'_length']!=len(actual) or wire[prefix+'_sha256']!=hashlib.sha256(actual).hexdigest(): raise ValueError('inner raw request/input binding') if type(wire['deadline']) is not int or wire['deadline']!=request['deadline']: raise ValueError('deadline type') elapsed=wire['elapsed'] if type(elapsed) not in (int,float) or not math.isfinite(elapsed) or not 0<=elapsed<=request['deadline']+RECLAIM_MARGIN: raise ValueError('elapsed type/range') for name in ('timeout','leader_reaped','descendants_absent','pg_absent'): if type(wire[name]) is not bool:raise ValueError('flag type') if not valid_int(wire['real_rc']) or not valid_int(wire['controlled_rc']): raise ValueError('returncode type') if wire['controlled_rc']!=(124 if wire['timeout'] else wire['real_rc']): raise ValueError('controlled returncode conflict') if type(wire['exceptions']) is not list or wire['exceptions']: raise ValueError('supervisor exception presence') if not isinstance(wire['tracked'],dict) or any(not k.isascii() or not k.isdigit() or not valid_int(v,1) for k,v in wire['tracked'].items()): raise ValueError('tracked type') if wire['remaining_descendants']!={} or wire['remaining_pg']!={}: raise ValueError('remaining process presence') if not wire['leader_reaped'] or not wire['descendants_absent'] or not wire['pg_absent']: raise ValueError('process absence unconfirmed') out=unblob(wire['stdout']);err=unblob(wire['stderr']) return out,err def stage(name, argv, cwd, payload, evidence): request={'nonce':uuid.uuid4().hex,'argv':argv,'cwd':cwd,'deadline':DEADLINES[name], 'input':base64.b64encode(payload).decode('ascii')} raw_request=json.dumps(request,separators=(',',':'),sort_keys=True).encode('ascii') wrapper_argv=[sys.executable,'-I','-c',SUPERVISOR] record={'stage':name,'wrapper_argv':[sys.executable,'-I','-c',{'check_constant':'SUPERVISOR','sha256':hashlib.sha256(SUPERVISOR.encode()).hexdigest()}],'wrapper_cwd':'/', 'request':blob(raw_request),'wrapper_rc':None,'wire':None,'wrapper_stderr':None, 'inner_cleanup':'unknown','exceptions':[]} evidence['stages'].append(record) begun=time.monotonic() process=None try: process=subprocess.Popen(wrapper_argv,cwd='/',stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE) record['popen_pid']=process.pid record['popen_start']=proc_token(process.pid) if not valid_int(record['popen_start'],1):raise ValueError('observed Popen start missing') try: wire_raw,wrapper_err=process.communicate(raw_request,timeout=DEADLINES[name]+OUTER_MARGIN) except subprocess.TimeoutExpired as error: # Bos parent cannot kill another UID. Retain partial wire; never fabricate inner cleanup. record.update(wire=blob(error.output or b''),wrapper_stderr=blob(error.stderr or b''), wrapper_rc=None,outer_timeout=True,elapsed=time.monotonic()-begun) raise RuntimeError('outer deadline; inner_cleanup=unknown') # Save actual raw observation BEFORE JSON parsing/field validation. record.update(wrapper_rc=process.returncode,wire=blob(wire_raw),wrapper_stderr=blob(wrapper_err), outer_timeout=False,elapsed=time.monotonic()-begun) parsed=json.loads(wire_raw) result=verify_wire(parsed,request,process.pid,record['popen_start'],process.returncode,raw_request) record['inner_cleanup']='confirmed' if parsed['timeout'] or parsed['real_rc']!=0: raise ValueError('controlled failure/timeout') return result except BaseException as error: if process is not None and record['wire'] is None: buffered=getattr(process,'_fileobj2output',{}) partial=getattr(error,'output',None) or b''.join(buffered.get(process.stdout,[])) partial_err=getattr(error,'stderr',None) or b''.join(buffered.get(process.stderr,[])) record.update(wire=blob(partial),wrapper_stderr=blob(partial_err),wrapper_rc=process.returncode, elapsed=time.monotonic()-begun,outer_error=type(error).__name__,inner_cleanup='unknown') record['exceptions'].append(type(error).__name__+':'+repr(error)) raise def emit_evidence(evidence): # Lossless wire codec: canonical JSON is recoverable byte for byte; raw IO may use an exact repeated block. for record in evidence['stages']: saved=record.get('wire') if not saved or 'latin1' not in saved: continue captured=saved['latin1'].encode('latin1') try: obj=json.loads(captured) if json.dumps(obj,separators=(',',':'),sort_keys=True).encode('ascii')!=captured: continue for channel in ('stdout','stderr'): io=obj[channel] payload=base64.b64decode(io['bytes'],validate=True) if len(payload)>=256 and len(payload)%256==0 and payload==payload[:256]*(len(payload)//256): io['capture']={'repeat':len(payload)//256,'block':payload[:256].decode('latin1')} else: io['capture']={'latin1':payload.decode('latin1')} del io['bytes'] saved.update(encoding='canonical-json-io',object=obj) del saved['latin1'] except (ValueError,KeyError,TypeError): pass raw=json.dumps(evidence,separators=(',',':'),sort_keys=True).encode('ascii') packed=lzma.compress(raw,preset=6) text=base64.b85encode(packed).decode('ascii') sys.stderr.write('RRA1 '+text+'\n') def main(candidate): evidence={'schema':'resource-array-allocation/1','stages':[],'exceptions':[], 'check_sha256':hashlib.sha256(Path(__file__).read_bytes()).hexdigest()} scratch=None success=False cleanup_ok=False absence_ok=False try: scratch=tempfile.mkdtemp(prefix='rra-') evidence['scratch']=scratch # Bos's mkdtemp hook has already handed this only directory to the candidate identity. source={name:source_bytes(candidate,name) for name in CANDIDATES} source.update({'array_report.h':HEADER.encode(),'observer.c':OBSERVER.encode()}) cases=scenarios() input_raw=(''.join(' '.join(map(str,row))+'\n' for row in cases)).encode('ascii') expected=[oracle(row) for row in cases] for name,raw in source.items(): Path(scratch,name).write_bytes(raw) compile_argv=['gcc','-std=c11','-O2','-Wall','-Wextra',*CANDIDATES,'observer.c','-o','app'] stage('compiler',compile_argv,scratch,b'',evidence) output,diagnostic=stage('candidate',[scratch+'/app'],scratch,input_raw,evidence) observed=observations(output) if observed!=expected: first=next((i for i,(a,b) in enumerate(zip(observed,expected)) if a!=b),min(len(observed),len(expected))) evidence['first_difference']={'row':first,'actual':observed[first] if first