amos 9d633e9e67 Batch 15 (20261023-C-hwe-scale-15): 320 HWE-derived repair tasks
One user-space repair task per eligible HWE debug-diag / compile-deploy base
ID: 320 admitted (C 218, C++ 97, build scripts 5), 1 skipped by the content
filter. Each ships a public spec with a check-to-basis table, at least two
defects with single-fix fixtures, a symptom-masking fixture and an alternative
correct implementation. Claude re-checked all 320: structure, the HWE quality
items and trace6 Docker calibration receipts against current digests
(320/320 USABLE). Difficulty is unmeasured. Known follow-up: 212 tasks use 120
ad-hoc family names; the next batch maps them to the canonical list.
The batch's 1,256-line progress log stays in its factory report and the
36-local branch batch15-hwe.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 01:55:56 +08:00

379 lines
31 KiB
Python

"""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 <stddef.h>\n#include <stdint.h>\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 <stdio.h>\n#include <stdlib.h>\n#include <string.h>\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]<values[i-1] and values[i]<values[i+1] for i in range(1,n-1)),
sum(a==b for a,b in zip(values,values[1:])),sum(a*b for a,b in zip(values,values[1:]))]
gaps = [b[1]-a[1]-1 for a,b in zip(selected,selected[1:])]
report[46:48] = [max([0]+gaps),sum(gaps)]
for field,sign in [(48,1),(49,-1)]:
tails=[]
for value in values:
i=bisect.bisect_left(tails,value*sign)
if i==len(tails):tails.append(value*sign)
else:tails[i]=value*sign
report[field]=len(tails)
if n:
winner=max(values,key=lambda v:values.count(v))
report[50:53]=[winner,values.count(winner),sum(values[a]==values[b] for a in range(n) for b in range(a+1,n))]
report[53]=sum(v if i%2==0 else -v for i,v in enumerate(values))
nonzero=[1 if v>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<len(observed) else None,
'expected':expected[first] if first<len(expected) else None}
raise ValueError('normal-exit observation mismatch')
evidence['observations']=len(observed)
success=True
except BaseException as error:
evidence['exceptions'].append(type(error).__name__+':'+repr(error))
finally:
if scratch is not None:
try:
cleaned,_=stage('cleanup',[sys.executable,'-I','-c',CLEANUP,scratch],'/',b'',evidence)
cleanup_ok=cleaned==b'0\n'
if not cleanup_ok:raise ValueError('cleanup output')
except BaseException as error:
evidence['exceptions'].append('cleanup:'+type(error).__name__+':'+repr(error))
try:
absent,_=stage('absence',[sys.executable,'-I','-c',ABSENCE,scratch],'/',b'',evidence)
absence_ok=absent==b'0\n'
if not absence_ok:raise ValueError('scratch remains')
except BaseException as error:
evidence['exceptions'].append('absence:'+type(error).__name__+':'+repr(error))
evidence.update(success=success,cleanup_ok=cleanup_ok,absence_ok=absence_ok)
emit_evidence(evidence)
if success and cleanup_ok and absence_ok and not evidence['exceptions'] and all(not s['exceptions'] for s in evidence['stages']):
print('PASS')
return 0
print('FAIL resource report, execution or cleanup')
return 1
if __name__=='__main__':
sys.exit(main(sys.argv[1]))