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

310 lines
35 KiB
Python

HEADER='#ifndef FILLED_RECORD_H\n#define FILLED_RECORD_H\n#include <stddef.h>\n#include <stdint.h>\n#include <sys/types.h>\n#define RF_STORAGE 160\n#define RF_PAYLOAD 96\n#define RF_SLOTS 4\n#define RF_HEADER 20\n#define RF_TRAILER 4\n#define RF_OK 0\n#define RF_INVALID 1\n#define RF_STATE 2\n#define RF_FULL 3\n#define RF_CORRUPT 4\n#define RF_IDLE 0\n#define RF_PROGRESS 1\n#define RF_BLOCKED 2\n#define RF_STALLED 3\n#define RF_FAILED 4\ntypedef struct {\n unsigned alignment;\n unsigned max_payload;\n unsigned fill;\n unsigned flags;\n unsigned poison;\n} rf_config;\ntypedef struct {\n uint8_t bytes[RF_STORAGE];\n uint8_t defined[RF_STORAGE];\n rf_config config;\n uint32_t sequence;\n unsigned kind;\n unsigned payload;\n unsigned items;\n unsigned length;\n unsigned state;\n unsigned mark_payload;\n unsigned mark_items;\n unsigned marked;\n} rf_record;\ntypedef struct {\n rf_record slots[RF_SLOTS];\n unsigned head;\n unsigned count;\n unsigned offset;\n unsigned failed;\n int error_number;\n uint64_t accepted;\n uint64_t calls;\n uint64_t completed;\n uint64_t discarded;\n} rf_port;\ntypedef ssize_t (*rf_write_fn)(void *, const uint8_t *, const uint8_t *, size_t);\nint rf_config_check(const rf_config *config);\nint rf_begin(rf_record *record, const rf_config *config, uint32_t sequence, unsigned kind);\nint rf_u8(rf_record *record, unsigned tag, unsigned value);\nint rf_u16(rf_record *record, unsigned tag, unsigned value);\nint rf_u32(rf_record *record, unsigned tag, uint32_t value);\nint rf_bytes(rf_record *record, unsigned tag, const uint8_t *data, size_t size);\nint rf_text(rf_record *record, unsigned tag, const uint8_t *data, size_t size);\nint rf_repeat(rf_record *record, unsigned tag, unsigned value, unsigned count);\nint rf_mark(rf_record *record);\nint rf_rollback(rf_record *record);\nint rf_seal(rf_record *record);\nint rf_import(rf_record *record, const rf_config *config, const uint8_t *data, size_t size);\nint rf_validate(const rf_record *record);\nint rf_payload_size(const rf_record *record, unsigned *size);\nint rf_item(const rf_record *record, unsigned index, unsigned *tag, unsigned *type,\n const uint8_t **data, unsigned *size);\nvoid rf_port_init(rf_port *port);\nint rf_enqueue(rf_port *port, const rf_record *record);\nint rf_pump(rf_port *port, rf_write_fn writer, void *context, unsigned budget);\nunsigned rf_pending(const rf_port *port);\nuint64_t rf_buffered(const rf_port *port);\nint rf_front(const rf_port *port, uint32_t *sequence, unsigned *remaining);\nvoid rf_cancel(rf_port *port);\nint rf_recover(rf_port *port);\ntypedef struct {\n unsigned items;\n unsigned payload_bytes;\n unsigned numeric_items;\n uint64_t numeric_sum;\n unsigned binary_xor;\n uint32_t tag_fold;\n} rf_summary;\nint rf_summarize(const rf_record *record, rf_summary *summary);\nint rf_find(const rf_record *record, unsigned tag, unsigned occurrence, unsigned *index);\nint rf_project(rf_record *destination, const rf_record *source, unsigned first, unsigned count);\nint rf_sum_tag(const rf_record *record, unsigned tag, uint64_t *sum, unsigned *matches);\n#endif\n'
HARNESS='#include "filled_record.h"\n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <errno.h>\nstatic void hex(const uint8_t *data, unsigned size)\n{\n unsigned i;\n if (size == 0) { putchar(\'-\'); }\n for (i = 0; i < size; ++i) { printf("%02x", data[i]); }\n}\nstatic unsigned unhex(const char *text, uint8_t *data)\n{\n unsigned size = 0;\n if (strcmp(text, "-") == 0) { return 0; }\n while (text[0] && text[1] && size < RF_STORAGE) {\n unsigned value = 0;\n if (sscanf(text, "%2x", &value) != 1) { break; }\n data[size++] = (uint8_t)value;\n text += 2;\n }\n return size;\n}\ntypedef struct { int actions[64]; unsigned count; unsigned at; } script;\nstatic ssize_t sink(void *context, const uint8_t *data, const uint8_t *defined, size_t size)\n{\n script *s = context;\n int action = s->at < s->count ? s->actions[s->at] : 1000;\n unsigned i;\n ssize_t result;\n int error_number = 0;\n s->at += 1;\n result = action > 0 ? (ssize_t)((size_t)action < size ? (size_t)action : size) : 0;\n if (action == -1) { result = -1; error_number = EINTR; }\n if (action == -2) { result = -1; error_number = EAGAIN; }\n if (action == -3) { result = -1; error_number = EIO; }\n if (action == -4) { result = (ssize_t)size + 1; }\n for (i = 0; i < size; ++i) {\n if (!defined[i]) { result = -1; error_number = EINVAL; break; }\n }\n printf("call %zu %d %zd %d ", size, action, result, error_number);\n hex(data, (unsigned)size); putchar(\' \'); hex(defined, (unsigned)size); putchar(\' \');\n hex(data, result > 0 && (size_t)result <= size ? (unsigned)result : 0); putchar(\'\\n\');\n errno = error_number;\n return result;\n}\nint main(void)\n{\n rf_config config = {8,96,161,5,211};\n rf_record record;\n rf_port port;\n char line[4096];\n memset(&record, 0, sizeof(record));\n rf_port_init(&port);\n while (fgets(line, sizeof(line), stdin)) {\n char command = line[0];\n unsigned long a=0,b=0,c=0,d=0,e=0;\n char text[1024] = "-";\n uint8_t data[RF_STORAGE] = {0};\n unsigned size;\n int result = 0;\n sscanf(line+1, "%lu %lu %lu %lu %lu", &a,&b,&c,&d,&e);\n switch (command) {\n case \'C\':\n config = (rf_config){(unsigned)a,(unsigned)b,(unsigned)c,(unsigned)d,(unsigned)e};\n memset(&record,0,sizeof(record)); rf_port_init(&port);\n result = rf_config_check(&config); break;\n case \'B\': result=rf_begin(&record,&config,(uint32_t)a,(unsigned)b); break;\n case \'U\': result=rf_u8(&record,(unsigned)a,(unsigned)b); break;\n case \'V\': result=rf_u16(&record,(unsigned)a,(unsigned)b); break;\n case \'W\': result=rf_u32(&record,(unsigned)a,(uint32_t)b); break;\n case \'X\': case \'T\':\n sscanf(line+1,"%lu %1023s",&a,text); size=unhex(text,data);\n result=command==\'X\'?rf_bytes(&record,(unsigned)a,data,size):rf_text(&record,(unsigned)a,data,size); break;\n case \'R\': result=rf_repeat(&record,(unsigned)a,(unsigned)b,(unsigned)c); break;\n case \'M\': result=rf_mark(&record); break;\n case \'Z\': result=rf_rollback(&record); break;\n case \'S\': result=rf_seal(&record); break;\n case \'I\': sscanf(line+1,"%1023s",text);size=unhex(text,data);result=rf_import(&record,&config,data,size);break;\n case \'E\': result=rf_enqueue(&port,&record);break;\n case \'K\': rf_cancel(&port);break;\n case \'N\': result=rf_recover(&port);break;\n case \'A\': {\n rf_summary s = {999,999,999,999,999,999};\n result=rf_summarize(&record,&s);\n printf("summary %d %u %u %u %llu %u %u\\n",result,s.items,s.payload_bytes,s.numeric_items,(unsigned long long)s.numeric_sum,s.binary_xor,s.tag_fold);continue;\n }\n case \'F\': {\n unsigned index=999;\n result=rf_find(&record,(unsigned)a,(unsigned)b,&index);\n printf("find %d %u\\n",result,index);continue;\n }\n case \'L\': {\n uint64_t sum=999;unsigned matches=999;\n result=rf_sum_tag(&record,(unsigned)a,&sum,&matches);\n printf("sum %d %llu %u\\n",result,(unsigned long long)sum,matches);continue;\n }\n case \'O\': result=rf_project(&record,&record,(unsigned)a,(unsigned)b);break;\n case \'D\':\n printf("record %u %u %u %u %d ",record.state,record.payload,record.items,record.length,rf_validate(&record));\n hex(record.bytes,record.length<=RF_STORAGE?record.length:0);putchar(\' \');\n hex(record.defined,record.length<=RF_STORAGE?record.length:0);putchar(\'\\n\');continue;\n case \'J\': {\n unsigned tag=999,type=999,n=999,payload=999;\n const uint8_t *value=NULL;\n int item=rf_item(&record,(unsigned)a,&tag,&type,&value,&n);\n int count=rf_payload_size(&record,&payload);\n printf("item %d %u %u %u %d %u ",item,tag,type,n,count,payload);\n hex(value,item==RF_OK?n:0);putchar(\'\\n\');continue;\n }\n case \'Q\': {\n uint32_t sequence=999;\n unsigned remaining=999;\n int front=rf_front(&port,&sequence,&remaining);\n printf("queue %u %u %u %d %llu %llu %llu %llu %llu %d %u %u\\n",\n rf_pending(&port),port.offset,port.failed,port.error_number,\n (unsigned long long)port.accepted,(unsigned long long)port.calls,\n (unsigned long long)port.completed,(unsigned long long)port.discarded,\n (unsigned long long)rf_buffered(&port),front,sequence,remaining);continue;\n }\n case \'P\': {\n script s = {{0},0,0};\n char *token=strtok(line+1," \\t\\r\\n");\n unsigned budget=token?(unsigned)strtoul(token,NULL,10):0;\n while ((token=strtok(NULL," \\t\\r\\n")) && s.count<64) { s.actions[s.count++]=atoi(token); }\n result=rf_pump(&port,sink,&s,budget);break;\n }\n default: return 64;\n }\n printf("op %c %d\\n",command,result);\n }\n return 0;\n}\n'
SUPERVISOR="import base64,ctypes,hashlib,json,os,selectors,signal,subprocess,sys,time\n\ndef proc(pid):\n try:\n with open('/proc/%d/stat'%pid) as stream:text=stream.read()\n except (FileNotFoundError,ProcessLookupError):return None\n tail=text[text.rfind(')')+2:].split()\n return {'pid':pid,'start':int(tail[19]),'ppid':int(tail[1]),'pgid':int(tail[2]),'state':tail[0]}\ndef table():\n result={}\n for name in os.listdir('/proc'):\n if name.isdecimal():\n info=proc(int(name))\n if info is not None:result[info['pid']]=info\n return result\ndef closure(rows,root,tracked):\n # An old numeric PID is never a root unless its exact start token still lives.\n roots={root['pid']} if rows.get(root['pid'],{}).get('start')==root['start'] else set()\n roots|={pid for pid,start in tracked if rows.get(pid,{}).get('start')==start and rows[pid]['state'] not in ('Z','X')}\n found={}\n changed=True\n while changed:\n changed=False\n for pid,row in rows.items():\n if pid!=root['pid'] and row['ppid'] in roots and pid not in found:\n found[pid]=row;roots.add(pid);changed=True\n # Only live tracked tokens extend ownership; current ancestry still records dead children for wait.\n for pid,start in tracked:\n if rows.get(pid,{}).get('start')==start and rows[pid]['state'] not in ('Z','X') and pid!=root['pid']:found[pid]=rows[pid]\n return found\ndef identity(pid=None):\n if pid is None:return {'uid':os.getuid(),'euid':os.geteuid(),'gid':os.getgid(),'egid':os.getegid(),'groups':sorted(os.getgroups())}\n with open('/proc/%d/status'%pid) as stream:\n fields=dict((line.split(':',1)[0],line.split(':',1)[1].split()) for line in stream if ':' in line)\n return {'uid':int(fields['Uid'][0]),'euid':int(fields['Uid'][1]),'gid':int(fields['Gid'][0]),'egid':int(fields['Gid'][1]),'groups':sorted(map(int,fields['Groups']))}\ndef execute(ctx):\n started=time.monotonic();root=proc(os.getpid());tracked=set();reaped=[];exceptions=[]\n out=bytearray();err=bytearray();leader=None;leader_start=None;leader_id=None;timed=False;rc=None;reclaim=None\n sel=selectors.DefaultSelector();stream=None\n try:\n if ctypes.CDLL(None,use_errno=True).prctl(36,1,0,0,0)!=0:raise OSError(ctypes.get_errno(),'subreaper')\n stream=open(ctx['stdin'],'rb') if ctx.get('stdin') else subprocess.DEVNULL\n leader=subprocess.Popen(ctx['argv'],cwd=ctx['cwd'],stdin=stream,stdout=subprocess.PIPE,stderr=subprocess.PIPE,start_new_session=True)\n info=proc(leader.pid)\n if info is None:raise RuntimeError('missing leader identity before wait')\n leader_start=info['start'];leader_id=identity(leader.pid);tracked.add((leader.pid,leader_start))\n for pipe,which in ((leader.stdout,out),(leader.stderr,err)):\n os.set_blocking(pipe.fileno(),False);sel.register(pipe,selectors.EVENT_READ,which)\n while True:\n # Popen exclusively owns the leader's wait status. Adopted children are reaped separately.\n rc=leader.poll()\n rows=table();found=closure(rows,root,tracked)\n tracked.update((p,r['start']) for p,r in found.items())\n now=time.monotonic()\n if rc is None and now-started>=ctx['deadline']:timed=True\n if (timed or rc is not None) and reclaim is None:reclaim=now\n if reclaim is not None:\n live=proc(leader.pid)\n if live and live['start']==leader_start and live['pgid']==leader.pid:\n try:os.killpg(leader.pid,signal.SIGKILL)\n except ProcessLookupError:pass\n for pid,row in found.items():\n current=proc(pid)\n if current is not None and current['start']==row['start']:\n try:os.kill(pid,signal.SIGKILL)\n except ProcessLookupError:pass\n for key,events in sel.select(0.01):\n try:data=os.read(key.fileobj.fileno(),65536)\n except BlockingIOError:continue\n if data:key.data.extend(data)\n else:sel.unregister(key.fileobj);key.fileobj.close()\n rc=leader.poll()\n for pid,row in found.items():\n if pid==leader.pid or row['ppid']!=root['pid']:continue\n current=proc(pid)\n if current is None or current['start']!=row['start']:continue\n try:\n waited,status=os.waitpid(pid,os.WNOHANG)\n if waited:reaped.append([pid,row['start'],status])\n except ChildProcessError:pass\n remaining=closure(table(),root,tracked)\n if rc is not None and not remaining and not sel.get_map():break\n if reclaim is not None and time.monotonic()-reclaim>=3:\n exceptions.append('reclamation deadline');break\n rc=leader.poll()\n if rc is not None:leader.wait()\n except BaseException as error:\n exceptions.append(type(error).__name__+':'+repr(error))\n # Even setup/IO exceptions make a bounded best effort at owned-token cleanup.\n until=time.monotonic()+3\n while time.monotonic()<until:\n rows=table();found=closure(rows,root,tracked)\n tracked.update((p,r['start']) for p,r in found.items())\n if leader is not None:rc=leader.poll()\n for pid,row in found.items():\n current=proc(pid)\n if current and current['start']==row['start']:\n try:os.kill(pid,signal.SIGKILL)\n except ProcessLookupError:pass\n if leader is None or pid!=leader.pid:\n try:os.waitpid(pid,os.WNOHANG)\n except ChildProcessError:pass\n if not found:break\n time.sleep(.01)\n finally:\n if stream is not None and stream!=subprocess.DEVNULL:stream.close()\n sel.close()\n remaining=closure(table(),root,tracked)\n rawout=bytes(out);rawerr=bytes(err)\n metadata={'phase':ctx['phase'],'nonce':ctx['nonce'],'argv':ctx['argv'],'deadline':ctx['deadline'],\n 'supervisor_pid':root['pid'],'supervisor_start':root['start'],'identity':identity(),\n 'leader_pid':None if leader is None else leader.pid,'leader_start':leader_start,'leader_identity':leader_id,\n 'leader_rc':rc,'leader_reaped':leader is not None and rc is not None,'timeout':timed,\n 'controlled_rc':124 if timed else rc,'elapsed':time.monotonic()-started,\n 'descendants_absent':not remaining,'remaining':list(remaining.values()),'tracked':sorted(map(list,tracked)),\n 'adopted_reaped':reaped,'exceptions':exceptions,'stdout_length':len(rawout),'stderr_length':len(rawerr),\n 'stdout_sha256':hashlib.sha256(rawout).hexdigest(),'stderr_sha256':hashlib.sha256(rawerr).hexdigest()}\n return {'meta':metadata,'stdout':base64.b64encode(rawout).decode(),'stderr':base64.b64encode(rawerr).decode()}\nif __name__=='__main__':\n print(json.dumps(execute(json.loads(sys.argv[1])),separators=(',',':')))\n"
import copy
import random
import struct
def hx(data):
return bytes(data).hex() or '-'
def fnv(data):
value=2166136261
for byte in data:
value=((value^byte)*16777619)&0xffffffff
return value
def wire(cfg,seq,kind,items):
payload=b''.join(bytes([tag,typ])+struct.pack('<H',len(value))+value for tag,typ,value in items)
alignment,maximum,fill,flags,poison=cfg
total=((24+len(payload)+alignment-1)//alignment)*alignment
header=b'RF1\x01'+bytes([kind,flags])+struct.pack('<HIHH',len(items),seq,len(payload),total)+bytes([fill,0,0,0])
image=header+payload+bytes((fill+i)&255 for i in range(total-24-len(payload)))
return image+struct.pack('<I',fnv(image))
def decode(cfg,image):
a,m,f,g,p=cfg
if len(image)<24 or len(image)>160 or len(image)%a: return None
if image[:4]!=b'RF1\x01' or image[5]!=g or image[16:] [:4]!=bytes([f,0,0,0]): return None
count,seq,used,total=struct.unpack('<HIHH',image[6:16])
if used>m or total!=len(image) or used>len(image)-24: return None
if ((24+used+a-1)//a)*a!=total: return None
if image[20+used:-4]!=bytes((f+i)&255 for i in range(total-used-24)): return None
if fnv(image[:-4])!=int.from_bytes(image[-4:],'little'): return None
items=[];at=20
while at<20+used:
if 20+used-at<4:return None
tag,typ=image[at:at+2];n=int.from_bytes(image[at+2:at+4],'little')
if typ not in range(1,6) or at+4+n>20+used:return None
value=image[at+4:at+4+n]
if typ<4 and n!={1:1,2:2,3:4}[typ]:return None
if typ==5 and any(v<32 or v>126 for v in value):return None
items.append((tag,typ,value));at+=4+n
if len(items)!=count:return None
return seq,image[4],items
class Model:
def __init__(self):self.config=(8,96,161,5,211);self.reset()
def reset(self):
self.state=0;self.seq=0;self.kind=0;self.items=[];self.mark=None;self.image=b'';self.queue=[];self.offset=0;self.failed=0;self.error=0;self.accepted=0;self.calls=0;self.completed=0;self.discarded=0
def used(self):return sum(4+len(v) for t,k,v in self.items)
def cfgok(self):
a,m,f,g,p=self.config
return a in (1,2,4,8,16) and 0<=m<=96 and all(0<=v<=255 for v in (f,g,p))
def run(self,commands):
out=[]
for line in commands:
parts=line.split();op=parts[0];args=parts[1:];nums=[int(v) for v in args] if op not in ('X','T','I') else []
result=0
if op=='C':self.config=tuple(nums);self.reset();result=0 if self.cfgok() else 1
elif op=='B':
if not self.cfgok() or nums[1]>255:result=1
else:self.state=1;self.seq,self.kind=nums;self.items=[];self.mark=None;self.image=b''
elif op in ('U','V','W','X','T','R'):
tag=int(args[0]);value=b'';typ=4;invalid=tag>255
if op in ('U','V','W'):
n={'U':1,'V':2,'W':4}[op];v=nums[1];typ={'U':1,'V':2,'W':3}[op]
invalid|=v>2**(8*n)-1
value=(v%(2**(8*n))).to_bytes(n,'little')
elif op in ('X','T'):
value=b'' if args[1]=='-' else bytes.fromhex(args[1]);typ=4 if op=='X' else 5
invalid|=len(value)>96 or typ==5 and any(v<32 or v>126 for v in value)
else:
invalid|=nums[1]>255 or nums[2]>96;value=bytes([nums[1]&255])*min(nums[2],96)
if invalid:result=1
elif self.state!=1:result=2
elif self.used()+4+len(value)>self.config[1]:result=3
else:self.items.append((tag,typ,value))
elif op=='M':
if self.state!=1:result=2
else:self.mark=len(self.items)
elif op=='Z':
if self.state!=1 or self.mark is None:result=2
else:self.items=self.items[:self.mark];self.mark=None
elif op=='S':
if self.state!=1:result=2
else:self.image=wire(self.config,self.seq,self.kind,self.items);self.state=2;self.mark=None
elif op=='I':
image=b'' if args[0]=='-' else bytes.fromhex(args[0]);decoded=decode(self.config,image) if self.cfgok() else None
if not self.cfgok() or len(image)>160:result=1
elif decoded is None:result=4
else:self.seq,self.kind,self.items=decoded;self.image=image;self.state=2;self.mark=None
elif op=='A':
if self.state!=2:out.append('summary 2 999 999 999 999 999 999')
else:
fold=2166136261;binary=0;total=0;count=0
for tag,typ,value in self.items:
fold=((fold^tag)*16777619)&0xffffffff;fold=((fold^typ)*16777619)&0xffffffff
if typ<=3:total+=int.from_bytes(value,'little');count+=1
else:
for v in value:binary^=v
out.append(f'summary 0 {len(self.items)} {sum(len(v) for t,k,v in self.items)} {count} {total} {binary} {fold}')
continue
elif op=='F':
if nums[0]>255:out.append('find 1 999')
elif self.state!=2:out.append('find 2 999')
else:
matches=[i for i,(t,k,v) in enumerate(self.items) if t==nums[0]]
out.append(f'find 0 {matches[nums[1]]}' if nums[1]<len(matches) else 'find 2 999')
continue
elif op=='L':
if nums[0]>255:out.append('sum 1 999 999')
elif self.state!=2:out.append('sum 2 999 999')
else:
values=[int.from_bytes(v,'little') for t,k,v in self.items if t==nums[0] and k<=3]
out.append(f'sum 0 {sum(values)} {len(values)}')
continue
elif op=='O':
first,count=nums
if self.state!=2:result=2
elif first>len(self.items) or count>len(self.items)-first:result=1
else:self.items=self.items[first:first+count];self.image=wire(self.config,self.seq,self.kind,self.items)
elif op=='D':
out.append(f'record {self.state} {self.used()} {len(self.items)} {len(self.image)} {0 if self.state==2 else 2} {hx(self.image)} {hx([1]*len(self.image))}');continue
elif op=='J':
if self.state!=2:out.append('item 2 999 999 999 2 999 -')
elif nums[0]>=len(self.items):out.append(f'item 1 999 999 999 0 {self.used()} -')
else:
t,k,v=self.items[nums[0]];out.append(f'item 0 {t} {k} {len(v)} 0 {self.used()} {hx(v)}')
continue
elif op=='E':
if self.failed or self.state!=2:result=2
elif len(self.queue)==4:result=3
else:self.queue.append((self.seq,self.image))
elif op=='K':self.discarded+=len(self.queue);self.queue=[];self.offset=0
elif op=='N':
if self.queue:result=2
else:self.failed=0;self.error=0
elif op=='Q':
buffered=sum(len(v) for s,v in self.queue)-self.offset
front=f'0 {self.queue[0][0]} {len(self.queue[0][1])-self.offset}' if self.queue else '2 999 999'
out.append(f'queue {len(self.queue)} {self.offset} {self.failed} {self.error} {self.accepted} {self.calls} {self.completed} {self.discarded} {buffered} {front}');continue
elif op=='P':
budget=nums[0];actions=nums[1:];progress=False
result=4 if self.failed else 0 if not self.queue else 2
if self.queue and not self.failed:
for i in range(budget):
if not self.queue:break
image=self.queue[0][1][self.offset:];action=actions[i] if i<len(actions) else 1000
n=min(action,len(image)) if action>0 else 0;err=0
if action in (-1,-2,-3):n=-1;err={-1:4,-2:11,-3:5}[action]
if action==-4:n=len(image)+1
out.append(f'call {len(image)} {action} {n} {err} {hx(image)} {hx([1]*len(image))} {hx(image[:n]) if 0<n<=len(image) else "-"}')
self.calls+=1
if n<0:
if err==4:continue
if err==11:result=2;break
self.failed=1;self.error=err;result=4;break
if n>len(image):self.failed=1;self.error=5;result=4;break
if n==0:result=3;break
self.accepted+=n;self.offset+=n;progress=True
if self.offset==len(self.queue[0][1]):self.queue.pop(0);self.offset=0;self.completed+=1
else:result=1 if progress else 2
if not self.queue:result=1 if progress else 0
out.append(f'op {op} {result}')
return ('\n'.join(out)+'\n').encode()
def cases():
commands=[]
def add(*lines):commands.extend(lines)
add('C 8 96 161 5 211','B 7 2','U 1 65','S','D','J 0','E','P 4 1000 1000 1000 1000','Q')
for alignment in (1,2,4,8,16):
for fill in (0,13,255):
add(f'C {alignment} 96 {fill} 255 3','B 4294967295 255','M','U 0 0','V 255 65535','W 9 4294967295','X 10 00ff0102','T 11 207e','Z','X 5 -','T 6 -','R 13 255 7','S','D','J 0','J 2','E','P 2 1 2','Q','P 64','Q','S','U 1 2','M','Z')
for maximum in (0,3,4,5,6,8,24,95,96):
add(f'C 16 {maximum} 65 0 255','B 0 0','Z','M','X 2 -','U 5 255','V 5 65535','R 7 12 96','Z','U 1 256','V 1 65536','X 256 -','T 2 00','R 2 256 1','R 3 1 97','S','D','J 0','J 99')
for action in (-1,-2,-3,-4,0,1,8,1000):
add('C 8 96 77 12 9','P 0','E','N')
for seq in range(5):add(f'B {seq+100} 8',f'W 9 {seq*123}','S','E')
add('Q','N',f'P 3 {action} -1 2','Q','P 1','Q','K','Q','E','N','K','N','E','P 64','Q')
for config in ('0 96 1 1 1','3 96 1 1 1','32 96 1 1 1','8 97 1 1 1','8 96 256 1 1','8 96 1 256 1','8 96 1 1 256'):
add('C '+config,'B 1 1','D')
cfg=(8,96,200,7,33);image=wire(cfg,987654321,17,[(4,1,b'\xaa'),(6,5,b'Test')])
add('C 8 96 200 7 33','I '+image.hex(),'D','J 1','E','P 64','Q')
for index in (0,3,5,6,12,14,16,17,20,21,22,len(image)-5,len(image)-1):
mutated=bytearray(image);mutated[index]^=1
if index<len(image)-4:mutated[-4:]=struct.pack('<I',fnv(mutated[:-4]))
add('I '+mutated.hex(),'D')
add('I -','I '+image[:-1].hex(),'D')
rng=random.Random(744703)
for case in range(70):
alignment=rng.choice((1,2,4,8,16));fill=rng.randrange(256)
add(f'C {alignment} 96 {fill} {rng.randrange(256)} {rng.randrange(256)}')
for seq in range(rng.randint(1,4)):
add(f'B {rng.randrange(2**32)} {rng.randrange(256)}','M')
for _ in range(rng.randint(0,8)):
op=rng.choice(('U','V','W','X','T','R'));tag=rng.randrange(256)
if op in ('U','V','W'):add(f'{op} {tag} {rng.randrange({"U":256,"V":65536,"W":2**32}[op])}')
elif op=='X':add(f'X {tag} '+(rng.randbytes(rng.randrange(16)).hex() or '-'))
elif op=='T':add(f'T {tag} '+(bytes(rng.randrange(32,127) for _ in range(rng.randrange(12))).hex() or '-'))
else:add(f'R {tag} {rng.randrange(256)} {rng.randrange(16)}')
if rng.randrange(3)==0:add('Z','U 8 9')
add('S','D','J 0','E')
for _ in range(6):add('P '+str(rng.randrange(5))+' '+' '.join(str(rng.choice((-1,-2,0,1,2,7,1000))) for _ in range(5)),'Q')
add('P 64','Q','K','N')
enriched=[]
for line in commands:
enriched.append(line)
if line=='D':enriched.extend(['A','F 5 0','F 256 0','L 9','L 256','O 999 1'])
enriched.extend(['C 8 96 12 7 99','B 333 8','U 5 255','V 5 65535','W 5 4294967295','T 5 4142','S','A','L 5','F 5 3','O 1 2','D','A','F 5 1','O 0 0','D','A'])
return enriched
import base64,hashlib,json,math,os,pathlib,shutil,subprocess,sys,tempfile,uuid,zlib
COMPILE_DEADLINE=25
CANDIDATE_DEADLINE=12
CLEANUP_DEADLINE=5
ABSENCE_DEADLINE=5
REAP_ALLOWANCE=4
def strict_int(value,minimum=None):
return type(value) is int and (minimum is None or value>=minimum)
def metadata_valid(meta,ctx,out,err):
if type(meta) is not dict:return False
for key in ('phase','nonce','argv','deadline'):
if key not in meta or meta[key]!=ctx[key]:return False
if any(not strict_int(meta.get(k),1) for k in ('supervisor_pid','supervisor_start','leader_pid','leader_start')):return False
if meta['leader_pid']==meta['supervisor_pid']:return False
elapsed=meta.get('elapsed')
if type(elapsed) not in (int,float) or not math.isfinite(elapsed) or not 0<=elapsed<=ctx['deadline']+REAP_ALLOWANCE:return False
expected={'uid':os.getuid(),'euid':os.geteuid(),'gid':os.getgid(),'egid':os.getegid(),'groups':sorted(os.getgroups())}
if os.environ.get('ROLLOUT_GRADE_ISOLATION')=='uid65534':expected={'uid':65534,'euid':65534,'gid':65534,'egid':65534,'groups':[]}
for key in ('identity','leader_identity'):
actual=meta.get(key)
if type(actual) is not dict or set(actual)!=set(expected):return False
if any(type(actual[k]) is not int or actual[k]!=expected[k] for k in ('uid','euid','gid','egid')):return False
if type(actual['groups']) is not list or any(type(v) is not int for v in actual['groups']) or actual['groups']!=expected['groups']:return False
if type(meta.get('timeout')) is not bool:return False
if not strict_int(meta.get('leader_rc')) or not strict_int(meta.get('controlled_rc')):return False
if meta['controlled_rc']!=(124 if meta['timeout'] else meta['leader_rc']):return False
if meta.get('leader_reaped') is not True or meta.get('descendants_absent') is not True:return False
if meta.get('remaining')!=[] or meta.get('exceptions')!=[]:return False
for key in ('tracked','adopted_reaped'):
if type(meta.get(key)) is not list:return False
width=2 if key=='tracked' else 3
if any(type(row) is not list or len(row)!=width or any(not strict_int(v,1 if i<2 else None) for i,v in enumerate(row)) for row in meta[key]):return False
if [meta['leader_pid'],meta['leader_start']] not in meta['tracked']:return False
for which,data in (('stdout',out),('stderr',err)):
if not strict_int(meta.get(which+'_length'),0) or meta[which+'_length']!=len(data):return False
if meta.get(which+'_sha256')!=hashlib.sha256(data).hexdigest():return False
return True
def run_phase(phase,argv,cwd,deadline,observations,stdin=None):
ctx={'phase':phase,'nonce':uuid.uuid4().hex,'argv':argv,'cwd':cwd,'deadline':deadline,'stdin':stdin}
entry={'context':ctx}
observations.append(entry)
try:
completed=subprocess.run([sys.executable,'-I','-c',SUPERVISOR,json.dumps(ctx,separators=(',',':'))],capture_output=True,timeout=deadline+REAP_ALLOWANCE+3)
# Preserve actual wrapper facts before parsing an untrusted/malformed wire.
entry.update(wrapper_rc=completed.returncode,wire_length=len(completed.stdout),wire_sha256=hashlib.sha256(completed.stdout).hexdigest(),wrapper_stderr_length=len(completed.stderr),wrapper_stderr_sha256=hashlib.sha256(completed.stderr).hexdigest())
wire=json.loads(completed.stdout)
out=base64.b64decode(wire['stdout'],validate=True);err=base64.b64decode(wire['stderr'],validate=True)
entry['meta']=wire['meta']
valid=metadata_valid(wire['meta'],ctx,out,err)
entry['metadata_valid']=valid
if completed.returncode!=0 or completed.stderr or not valid:raise RuntimeError('invalid execution wire '+phase)
return wire['meta'],out,err
except BaseException as error:
entry['exception']=type(error).__name__+':'+repr(error)
raise
def phase_ok(meta):
return meta['leader_rc']==0 and meta['controlled_rc']==0 and not meta['timeout'] and meta['exceptions']==[]
def main(candidate):
observations=[];errors=[];scratch=None;business=False;cleanup=False;absence=False
commands=cases();expected=Model().run(commands)
try:
scratch=tempfile.mkdtemp(prefix='protocol-filled-record-')
job=pathlib.Path(scratch)/'work';job.mkdir(mode=0o777);job.chmod(0o777)
for name in ('record.c','port.c','query.c'):(job/name).write_bytes((candidate/name).read_bytes())
(job/'filled_record.h').write_text(HEADER)
(job/'inspect.c').write_text(HARNESS)
(job/'input.txt').write_text('\n'.join(commands)+'\n')
argv=['gcc','-std=c11','-O2','-Wall','-Wextra','-Werror','-I',str(job),str(job/'record.c'),str(job/'port.c'),str(job/'query.c'),str(job/'inspect.c'),'-o',str(job/'inspect')]
# All preparation ends before the first untrusted identity is started.
compiler,_,_=run_phase('compiler',argv,'/tmp',COMPILE_DEADLINE,observations)
if not phase_ok(compiler):raise RuntimeError('compiler controlled rc '+str(compiler['controlled_rc']))
execution,raw,_=run_phase('candidate',[str(job/'inspect')],'/tmp',CANDIDATE_DEADLINE,observations,str(job/'input.txt'))
if not phase_ok(execution):raise RuntimeError('candidate controlled rc '+str(execution['controlled_rc']))
if raw!=expected:
actual=raw.splitlines();wanted=expected.splitlines();index=next((i for i,(a,b) in enumerate(zip(actual,wanted)) if a!=b),min(len(actual),len(wanted)))
errors.append('raw observation differs at row '+str(index)+': '+repr(actual[index:index+1])[:250])
else:business=True
except BaseException as error:
errors.append(type(error).__name__+':'+repr(error))
finally:
if scratch is not None:
try:
cleaner,_,_=run_phase('cleanup',[sys.executable,'-I','-c','import shutil,sys;shutil.rmtree(sys.argv[1])',scratch],'/tmp',CLEANUP_DEADLINE,observations)
cleanup=phase_ok(cleaner)
if not cleanup:errors.append('cleanup controlled rc '+str(cleaner['controlled_rc']))
except BaseException as error:errors.append('cleanup '+type(error).__name__+':'+repr(error))
try:
probe="import os,sys\ntry: os.lstat(sys.argv[1])\nexcept FileNotFoundError: sys.exit(0)\nsys.exit(1)"
absent,_,_=run_phase('absence',[sys.executable,'-I','-c',probe,scratch],'/tmp',ABSENCE_DEADLINE,observations)
absence=phase_ok(absent)
if not absence:errors.append('absence controlled rc '+str(absent['controlled_rc']))
except BaseException as error:errors.append('absence '+type(error).__name__+':'+repr(error))
payload={'scratch':scratch,'observations':observations,'errors':errors,'business':business,'cleanup':cleanup,'absence':absence,'commands':len(commands),'rows':len(expected.splitlines())}
encoded=base64.b85encode(zlib.compress(json.dumps(payload,separators=(',',':')).encode(),9)).decode()
print('EXEC '+encoded,file=sys.stderr)
okay=business and cleanup and absence and not errors and all(row.get('metadata_valid') is True and 'exception' not in row for row in observations)
print('PASS' if okay else 'FAIL')
return 0 if okay else 1
if __name__=='__main__':sys.exit(main(pathlib.Path(sys.argv[1])))