Codex 69521e54e0 Add 15 embedded repair tasks and correct grader-read controls
Complete batch 20261016-C-embedded-2: 45 verified GLM/Pi samples, independent regrades and archives; preserve difficulty misses and Salty blockage.
2026-10-16 14:23:48 +08:00

616 lines
32 KiB
Python

"""Firmware family checker: candidate subprocesses expose observations only."""
import json
import pathlib
import random
import shutil
import struct
import subprocess
import sys
import tempfile
import zlib
def crc(raw):
return zlib.crc32(raw) & 0xffffffff
def image_frame(payload, seq=1, board=42, rollback=5, entry=0, extra=(), fields=None):
records = [(1, 0, struct.pack('<I', rollback)), (2, 0, struct.pack('<I', entry))] + list(extra)
tail = b''.join(bytes([t, f]) + struct.pack('<H', len(v)) + v + b'\0' * (-len(v) % 4)
for t, f, v in records)
head = bytearray(struct.pack('<4sBBHIIHHIII', b'FWI2', 2, 32 + len(tail), 1,
32 + len(tail) + len(payload), seq, board,
len(records), len(payload), crc(payload), 0) + tail)
if fields:
for offset, raw in fields.items():
head[offset:offset + len(raw)] = raw
head[28:32] = struct.pack('<I', crc(head))
return bytes(head) + payload
def image_decode(raw, board, floor):
magic, version, size, flags, total, seq, target, ntlv, n, checksum, hcrc = struct.unpack('<4sBBHIIHHIII', raw[:32])
if target != board or crc(raw[:28] + b'\0' * 4 + raw[32:size]) != hcrc:
return None
values = {}
pos = 32
for _ in range(ntlv):
if pos + 4 > size:
return None
tag, attr, length = struct.unpack('<BBH', raw[pos:pos + 4])
pos += 4
if attr & ~1 or pos + length > size:
return None
value = raw[pos:pos + length]
if tag in (1, 2, 3):
if tag in values or length != 4:
return None
values[tag] = int.from_bytes(value, 'little')
elif attr & 1:
return None
pos += length
padded = pos + (-length % 4)
if padded > size or any(raw[pos:padded]):
return None
pos = padded
if pos != size or 1 not in values or 2 not in values:
return None
if values[1] < floor or values[2] % 4 or values[2] >= n:
return None
if 3 in values and values[3] > values[1]:
return None
payload = raw[size:total]
if crc(payload) != checksum:
return None
return 'V %d %d %d %d %d %s' % (seq, values[1], values[2], flags, n, payload.hex())
def image_oracle(commands):
out = []
pending = b''
board, floor, accepted = 42, 0, 0
for cmd in commands:
if cmd[0] == 'I':
board, floor = cmd[1:]
pending, accepted = b'', 0
out.append('I %d %d' % (board, floor))
continue
if cmd[0] == 'R':
pending, floor = b'', cmd[1]
elif cmd[0] == 'F':
pending += cmd[1]
while pending:
start = pending.find(b'FWI2')
if start < 0:
keep = next((i for i in (3, 2, 1) if pending.endswith(b'FWI2'[:i])), 0)
pending = pending[-keep:] if keep else b''
break
pending = pending[start:]
if len(pending) < 32:
break
_, v, h, flags, total, _, _, _, n, _, _ = struct.unpack('<4sBBHIIHHIII', pending[:32])
if v != 2 or not 32 <= h <= 96 or h % 4 or not 1 <= n <= 128 or total != h + n or flags != 1:
pending = pending[1:]
continue
if len(pending) < total:
break
event = image_decode(pending[:total], board, floor)
if event is None:
pending = pending[1:]
continue
out.append(event)
accepted += 1
pending = pending[total:]
if cmd[0]=='F':out.append('A '+str(crc(cmd[1])))
out.append('S %d %d' % (accepted, len(pending)))
return out
def image_cases(seed):
rng = random.Random(seed)
cases = []
good = image_frame(b'abcdefgh', seq=41)
cases.append(('single-complete', [('I', 42, 0), ('F', good), ('Q',)]))
cases.append(('split-header-and-payload', [('I', 42, 0)] + [('F', good[i:i + 7]) for i in range(0, len(good), 7)]))
cases.append(('rollback-equality', [('I', 42, 5), ('F', good)]))
cases.append(('duplicate-options', [('I', 42, 0), ('F', image_frame(b'abcd', extra=[(1, 0, struct.pack('<I', 8))])), ('F', good)]))
cases.append(('unknown-critical', [('I', 42, 0), ('F', image_frame(b'abcd', extra=[(29, 1, b'xyz')])), ('F', good)]))
cases.append(('reset-floor-transition', [('I', 42, 1), ('F', good), ('R', 9), ('F', good), ('F', image_frame(b'new!', rollback=9))]))
bad_header = bytearray(good); bad_header[12] ^= 2
bad_payload = bytearray(good); bad_payload[-1] ^= 4
cases.append(('crc-not-self-report', [('I', 42, 0), ('F', bytes(bad_header)), ('F', bytes(bad_payload)), ('F', good)]))
cases.append(('resync-inside-bad-payload', [('I', 42, 0), ('F', image_frame(b'x' + good + b'z', fields={24:struct.pack('<I', 0)})), ('F', good)]))
cases.append(('unknown-noncritical-padding', [('I', 42, 0), ('F', image_frame(bytes(range(128)), extra=[(99, 0, b'x'), (3, 0, struct.pack('<I', 4))], entry=124))]))
malformed=[]
for fields in ({4:b'\x03'}, {5:b'\x21'}, {5:b'\x64'}, {6:b'\0\0'}, {8:b'\xff'*4}, {20:b'\0'*4}, {18:b'\0\0'}):
malformed.append(image_frame(b'abcd',fields=fields))
malformed += [image_frame(b'abcd',board=43), image_frame(b'abcd',rollback=0), image_frame(b'abcd',entry=4), image_frame(b'abcd',entry=2), image_frame(b'abcd',extra=[(3,0,struct.pack('<I',6))])]
cases.append(('header-and-policy-invalid', [('I',42,1)] + [('F', x+good) for x in malformed]))
cases.append(('reset-partial-and-noise-suffix', [('I',42,0),('F',b'junkFW'),('F',b'I2'+good[4:22]),('R',0),('F',good[22:]),('F',good)]))
for k in range(24):
board = rng.randrange(1, 65536); floor = rng.randrange(0, 100)
cmds=[('I',board,floor)]
for step in range(24):
n=rng.randrange(1,129); payload=bytes(rng.randrange(256) for _ in range(n))
rb=floor+rng.randrange(0,8); extra=[]
if rng.randrange(3)==0:extra=[(91,0,bytes(rng.randrange(256) for _ in range(rng.randrange(1,8))))]
raw=image_frame(payload,seq=(k<<16)+step,board=board,rollback=rb,entry=4*rng.randrange((n+3)//4),extra=extra)
mode=rng.randrange(8)
if mode==0:raw=raw[:-1]+bytes([raw[-1]^1])
elif mode==1:raw=image_frame(payload,seq=step,board=board,rollback=rb,extra=[(2,0,struct.pack('<I',0))])
elif mode==2:raw=b'noiseFW'+raw
elif mode==3:
floor+=1;cmds.append(('R',floor))
offset=0
while offset<len(raw):
take=rng.randrange(1,30);cmds.append(('F',raw[offset:offset+take]));offset+=take
if rng.randrange(3)==0:cmds.append(('F',b''))
cases.append(('mixed-%d'%k,cmds))
stdin=[];truth=[];labels=[]
for label,commands in cases:
expected=image_oracle(commands)
labels.extend([label]*len(expected));truth.extend(expected)
for command in commands:
if command[0]=='F':stdin.append('F %d %s'%(len(command[1]),' '.join(map(str,command[1]))))
else:stdin.append(' '.join(map(str,command)))
return '\n'.join(stdin)+'\n',truth,labels
def slot_record(slot):
gen,rb,valid,confirmed,tries=slot
raw=struct.pack('<4sBBBBIII',b'BSL2',2,valid,confirmed,tries,gen,rb,0)
return raw+struct.pack('<I',crc(raw))
def slot_record_valid(raw):
return (len(raw)==24 and raw[:5]==b'BSL2\x02' and raw[5]<=1 and raw[6]<=1
and raw[7]<=3 and raw[16:20]==b'\0'*4
and crc(raw[:20])==int.from_bytes(raw[20:],'little'))
def slot_oracle(commands,stored=None):
slots=[[0,0,0,0,0] for _ in range(2)];floor=0;serial=0;active=-1;ticket=0;out=[]
def newer(a,b):return 0<((a-b)&0xffffffff)<0x80000000
for cmd in commands:
op=cmd[0];rc=0
if op=='I':
floor=cmd[1];serial=0;active=-1;ticket=0;slots=[[0,0,0,0,0] for _ in range(2)]
elif op=='U':
i,g,r,v=cmd[1:]
if i not in (0,1) or v not in (0,1):rc=-1
elif active==i:rc=-2
else:slots[i]=[g,r,v,0,3]
elif op=='B':
eligible=[i for i,s in enumerate(slots) if s[2] and s[1]>=floor and (s[3] or s[4])]
if not eligible:active=-1;ticket=0;rc=-1
else:
best=eligible[0]
if len(eligible)==2:
a,b=slots[0],slots[1]
if newer(b[0],a[0]) or (not newer(a[0],b[0]) and b[3]>a[3]):best=1
if not slots[best][3]:slots[best][4]-=1
serial=(serial+1)&0xffffffff
if serial==0:serial=1
active=best;ticket=serial;rc=best
elif op in ('C','F'):
i,t=cmd[1:]
if i not in (0,1) or active!=i or t==0 or ticket!=t:rc=-1
elif op=='C':
if not slots[i][2] or slots[i][1]<floor:rc=-1
else:
slots[i][3]=1;slots[i][4]=3;floor=max(floor,slots[i][1]);active=-1;ticket=0
else:slots[i][2]=0;active=-1;ticket=0
elif op=='T':
if cmd[1]<floor:rc=-1
else:floor=cmd[1]
elif op=='D':
i=cmd[1]
out.append('D -1' if i not in (0,1) else 'D 0 '+slot_record(slots[i]).hex())
continue
elif op=='L':
i,raw=cmd[1:]
if i not in (0,1):rc=-1
elif i==active:rc=-2
elif not slot_record_valid(raw):rc=-1
else:
g,r=struct.unpack('<II',raw[8:16]);slots[i]=[g,r,raw[5],raw[6],raw[7]]
elif op=='Z':
raw=b'BSM2'+struct.pack('<II',floor,serial)+slot_record(slots[0])+slot_record(slots[1])
stored=raw+struct.pack('<I',crc(raw))
elif op=='Y':
if (stored is None or len(stored)!=64 or stored[:4]!=b'BSM2' or
crc(stored[:60])!=int.from_bytes(stored[60:],'little') or
not all(slot_record_valid(stored[pos:pos+24]) for pos in (12,36))):rc=-1
else:
floor,serial=struct.unpack('<II',stored[4:12]);slots=[]
for pos in (12,36):
r=stored[pos:pos+24];g,rb=struct.unpack('<II',r[8:16]);slots.append([g,rb,r[5],r[6],r[7]])
active=-1;ticket=0
elif op=='K':
offset,value=cmd[1:]
if stored is None or not 0<=offset<64 or not 0<=value<256:rc=-1
else:stored=stored[:offset]+bytes([value])+stored[offset+1:]
out.append(' '.join(map(str,[op,rc,floor,active,ticket,serial,*slots[0],*slots[1]])))
return out,stored
def slot_cases(seed):
rng=random.Random(seed)
cases=[
('basic',[('I',0),('U',0,10,2,1),('B',),('C',0,1),('B',),('Q',)]),
('generation-wrap',[('I',0),('U',0,0xfffffff0,3,1),('U',1,4,4,1),('B',)]),
('rollback-floor-equality',[('I',7),('U',0,1,7,1),('B',)]),
('trial-exhaustion-fallback',[('I',0),('U',0,1,1,1),('B',),('C',0,1),('U',1,2,2,1),('B',),('B',),('B',),('B',),('B',)]),
('stale-ticket-after-next-boot',[('I',0),('U',0,1,3,1),('B',),('B',),('C',0,1),('F',0,1),('C',0,2),('C',0,2)]),
('floor-decrease-is-atomic',[('I',8),('T',7),('Q',),('U',0,1,7,1),('B',),('T',8)]),
('busy-replacement-and-confirm',[('I',1),('U',0,1,3,1),('B',),('U',0,2,5,1),('U',1,2,4,1),('C',1,1),('C',0,1),('B',)]),
('raised-floor-invalidates-confirmation',[('I',0),('U',0,1,5,1),('B',),('T',6),('C',0,1),('Q',)]),
('reject-no-refund',[('I',0),('U',0,7,8,1),('B',),('F',0,1),('B',),('C',0,1)]),
('ambiguous-serial-and-confirmed-tie',[('I',0),('L',0,slot_record([0,3,1,0,3])),('L',1,slot_record([0x80000000,3,1,1,3])),('B',),('D',0),('D',1)]),
('save-resume-retains-budget',[('I',0),('U',0,1,1,1),('B',),('Z',),('B',),('Y',),('B',),('B',),('B',),('Z',),('K',4,77),('Y',)]),
('record-invalid-and-busy',[('I',0),('L',0,b'bad'),('L',0,slot_record([12,4,1,0,2])),('B',),('L',0,slot_record([13,5,1,0,3])),('D',0),('D',2),('L',-1,b'')]),
]
for mode in ('field','inner-crc'):
body=bytearray(b'BSM2'+struct.pack('<II',0,0)+slot_record([1,2,1,0,3])+slot_record([0,0,0,0,0]))
if mode=='field':
body[19]=9
body[32:36]=struct.pack('<I',crc(body[12:32]))
else:
body[20]^=1
wanted=bytes(body)+struct.pack('<I',crc(body))
original=b'BSM2'+struct.pack('<II',0,0)+slot_record([1,2,1,0,3])+slot_record([0,0,0,0,0])
original+=struct.pack('<I',crc(original))
commands=[('I',0),('U',0,1,2,1),('Z',)]
commands.extend(('K',i,value) for i,value in enumerate(wanted) if value!=original[i])
commands.extend([('Y',),('Q',)])
cases.append(('inner-record-invalid-top-CRC-valid-'+mode,commands))
for k in range(28):
cmds=[('I',rng.randrange(10))]
# Saved states, confirmation tokens, wraps and replacement form independent state histories.
for step in range(80):
choice=rng.randrange(12)
if choice<3:cmds.append(('U',rng.randrange(2),rng.choice([step,0xfffffff0+step%16,0x80000000+step]),rng.randrange(30),rng.randrange(2)))
elif choice<6:cmds.append(('B',))
elif choice==6:cmds.append(('C',rng.randrange(2),rng.randrange(1,30)))
elif choice==7:cmds.append(('F',rng.randrange(2),rng.randrange(1,30)))
elif choice==8:cmds.append(('T',rng.randrange(30)))
elif choice==9:cmds.append(('L',rng.randrange(2),slot_record([rng.getrandbits(32),rng.randrange(30),rng.randrange(2),rng.randrange(2),rng.randrange(4)])))
elif choice==10:cmds.append(('Z',));cmds.append(('Y',))
else:cmds.append(('D',rng.randrange(2)))
cases.append(('mixed-slot-%d'%k,cmds))
stdin=[];truth=[];labels=[];stored=None
for label,commands in cases:
expected,stored=slot_oracle(commands,stored)
labels.extend([label]*len(expected));truth.extend(expected)
for cmd in commands:
if cmd[0]=='L':stdin.append('L %d %d %s'%(cmd[1],len(cmd[2]),' '.join(map(str,cmd[2]))))
else:stdin.append(' '.join(map(str,cmd)))
return '\n'.join(stdin)+'\n',truth,labels
def flash_oracle(commands):
memory=bytearray([255]*2048);powered=1;remaining=-1
opened,total,checksum,nextoff,finished=0,0,0,0,0
out=[]
def mutate(offset,raw):
nonlocal powered,remaining
if not powered:return -9
if remaining==0:powered=0;return -9
if remaining>0:remaining-=1
memory[offset:offset+len(raw)]=raw
return 0
def program(offset,raw):
n=len(raw)
if n==0 or n>32 or offset<128 or offset+n>1920 or offset//64!=(offset+n-1)//64:return -3
if not powered:return -9
if any((a&b)!=b for a,b in zip(memory[offset:offset+n],raw)):return -3
return mutate(offset,raw)
def erase(offset,n):
if n!=64 or offset%64 or offset<128 or offset+n>1920:return -3
return mutate(offset,b'\xff'*n)
def payload():
return b''.join(bytes(memory[256+(i//32)*64:256+(i//32)*64+min(32,total-i)]) for i in range(0,total,32))
for cmd in commands:
op=cmd[0];rc=0
if op=='I':
memory=bytearray((i*13+17)&255 if i<128 or i>=1920 else 255 for i in range(2048))
powered=1;remaining=-1;opened,total,checksum,nextoff,finished=0,0,0,0,0
elif op=='B':
n,c=cmd[1:]
if not 1<=n<=512:rc=-1
else:
powered=1;remaining=-1;memory[128:1920]=b'\xff'*(1920-128)
h=b'UPD2'+struct.pack('<II',n,c);memory[128:144]=h+struct.pack('<I',crc(h))
opened,total,checksum,nextoff,finished=1,n,c,0,0
elif op=='W':
off,raw=cmd[1:];n=len(raw)
expected=min(32,total-off) if off<total else 0
if not opened or finished or off>=total or off%32 or off>nextoff or n!=expected:rc=-2
elif off<nextoff:
if not powered:rc=-9
elif bytes(memory[256+(off//32)*64:256+(off//32)*64+n])!=raw:rc=-2
else:
cell=256+(off//32)*64;record=b'CHK2'+struct.pack('<III',off,n,crc(raw))
for address,part in [(cell,raw),(cell+32,record),(cell+63,b'\0')]:
rc=program(address,part)
if rc:break
if not rc:nextoff+=n
elif op=='F':
if not opened or nextoff!=total:rc=-2
elif not powered:rc=-9
elif crc(payload())!=checksum:rc=-1
elif not finished:
rc=program(159,b'\0')
if not rc:finished=1
elif op=='A':remaining=cmd[1]
elif op=='R':
powered=1;remaining=-1;opened,total,checksum,nextoff,finished=0,0,0,0,0
h=bytes(memory[128:160]);n=int.from_bytes(h[4:8],'little')
if h[:4]!=b'UPD2' or not 1<=n<=512 or crc(h[:12])!=int.from_bytes(h[12:16],'little') or h[31] not in (0,255) or h[16:31]!=b'\xff'*15:rc=-1
else:
opened=1;total=n;checksum=int.from_bytes(h[8:12],'little')
for off in range(0,total,32):
cell=256+(off//32)*64;r=bytes(memory[cell:cell+64]);n=min(32,total-off)
if r[63]!=0 or r[32:36]!=b'CHK2' or int.from_bytes(r[36:40],'little')!=off or int.from_bytes(r[40:44],'little')!=n or crc(r[:n])!=int.from_bytes(r[44:48],'little'):break
nextoff+=n
if h[31]==0 and nextoff==total and crc(payload())==checksum:finished=1
elif op=='K':
off,value=cmd[1:]
if off>=2048:rc=-3
else:memory[off]=value
elif op=='D':
off,n=cmd[1:];out.append('D -3' if off>2048 or n>2048-off else 'D 0 '+(bytes(memory[off:off+n]).hex() or '-'));continue
elif op=='J':
off,n=cmd[1:];out.append('J -3' if off>2048 or n>2048-off else 'J 0 '+str(crc(memory[off:off+n])));continue
elif op=='G':out.append('G -9' if not powered and total else 'G 0 '+(payload().hex() or '-'));continue
elif op=='P':rc=program(cmd[1],cmd[2])
elif op=='E':rc=erase(cmd[1],cmd[2])
if op=='W':out.append('N '+str(crc(cmd[2])))
out.append(' '.join(map(str,[op,rc,opened,total,nextoff,finished,powered])))
return out
def flash_cases(seed):
rng=random.Random(seed);raw=bytes(range(65));chunk=raw[:32]
cases=[
('basic-flash',[('I',),('B',65,crc(raw)),('W',0,chunk),('W',32,raw[32:64]),('W',64,raw[64:]),('F',),('R',),('G',),('D',0,128),('D',1920,128)]),
('committed-replay-identity',[('I',),('B',32,crc(chunk)),('W',0,chunk),('W',0,bytes([255])*32),('W',0,chunk),('F',)]),
('incomplete-chunk-rejected',[('I',),('B',65,crc(raw)),('W',0,chunk[:7]),('S',),('W',0,chunk),('W',32,raw[32:64]),('F',)]),
('image-crc-before-finish',[('I',),('B',32,0),('W',0,chunk),('F',),('R',),('G',)]),
('closed-and-invalid-begin',[('I',),('F',),('W',0,chunk),('B',0,0),('B',513,0),('R',)]),
('erase-and-program-protection',[('I',),('E',0,64),('P',127,b'\0'),('E',1920,64),('E',129,64),('E',128,32),('P',1919,b'\0\0'),('P',1887,b'\0\0'),('P',256,b'\0'),('P',256,b'\xff'),('D',0,128),('D',1920,128)]),
]
for cut in range(4):
cases.append(('cut-window-%d'%cut,[('I',),('B',65,crc(raw)),('W',0,chunk),('A',cut),('W',32,raw[32:64]),('S',),('R',),('G',),('W',32,raw[32:64]),('W',64,raw[64:]),('F',),('R',),('J',0,2048)]))
cases.append(('committed-cell-corruption',[('I',),('B',65,crc(raw)),('W',0,chunk),('W',32,raw[32:64]),('K',256,99),('F',),('R',),('S',)]))
cases.append(('finish-cut-and-retry',[('I',),('B',32,crc(chunk)),('W',0,chunk),('A',0),('F',),('R',),('F',),('F',),('R',),('G',)]))
for k in range(24):
n=rng.randrange(1,513);raw=bytes(rng.randrange(256) for _ in range(n));cmds=[('I',),('B',n,crc(raw))]
for off in range(0,n,32):
data=raw[off:off+32]
if rng.randrange(3)==0:cmds.extend([('A',rng.randrange(4)),('W',off,data),('R',)])
cmds.append(('W',off,data))
if rng.randrange(4)==0:cmds.append(('W',off,data));cmds.append(('R',))
cmds.extend([('F',),('R',),('G',),('J',128,1792),('D',0,128),('D',1920,128)])
cases.append(('mixed-flash-%d'%k,cmds))
stdin=[];truth=[];labels=[]
for label,commands in cases:
expected=flash_oracle(commands);truth.extend(expected);labels.extend([label]*len(expected))
for cmd in commands:
if cmd[0] in ('W','P'):stdin.append('%s %d %d %s'%(cmd[0],cmd[1],len(cmd[2]),' '.join(map(str,cmd[2]))))
else:stdin.append(' '.join(map(str,cmd)))
return '\n'.join(stdin)+'\n',truth,labels
def manifest_oracle(commands):
base=0;span=0;entry=0;segments={};relocations=[];out=[]
for cmd in commands:
op=cmd[0];rc=0
if op=='I':base,span,entry=cmd[1:];segments={};relocations=[]
elif op=='S':
idx,off,address,length,flags,checksum,raw=cmd[1:]
if idx not in range(8) or idx in segments or len(raw)>64 or len(segments)==8:rc=-2
else:segments[idx]=(off,address,length,flags,checksum,raw)
elif op=='R':
if len(relocations)==32:rc=-2
else:relocations.append(cmd[1:])
elif op=='V':
valid=bool(segments) and span>0 and base+span<=2**32 and entry%4==0
images={};address_ranges=[];file_ranges=[];executables=0
for idx,(off,addr,n,flags,checksum,raw) in segments.items():
zero=bool(flags&4)
valid &= 1<=n<=64 and flags&~7==0 and addr%4==0 and off%4==0
valid &= addr>=base and addr+n<=base+span and addr+n<=2**32
valid &= (len(raw)==0 if zero else len(raw)==n)
value=b'\0'*n if zero else raw
valid &= crc(value)==checksum
for a,b in address_ranges:valid &= addr+n<=a or b<=addr
address_ranges.append((addr,addr+n))
if not zero:
valid &= off+n<=2**32
for a,b in file_ranges:valid &= off+n<=a or b<=off
file_ranges.append((off,off+n))
if flags&1 and addr<=entry<addr+n:executables+=1
images[idx]=bytearray(value)
valid &= executables==1
writes=set()
for target,offset,kind,source,addend in relocations:
if target not in segments or source not in segments or kind not in (0,1):valid=False;continue
_,addr,n,flags,_,_=segments[target]
if not flags&2 or offset%4 or offset+4>n or (target,offset) in writes:valid=False;continue
writes.add((target,offset));value=segments[source][1]+addend
if kind==1:value-=addr+offset
images[target][offset:offset+4]=struct.pack('<I',value&0xffffffff)
out.append('V 0' if valid else 'V -1')
if valid:
for idx in sorted(images):out.append('D %d %s'%(idx,images[idx].hex()))
continue
out.append('%s %d %d %d'%(op,rc,len(segments),len(relocations)))
return out
def manifest_cases(seed):
rng=random.Random(seed)
def seg(i,off,addr,raw,flags=3):return ('S',i,off,addr,len(raw),flags,crc(raw),raw)
basic=[('I',0x1000,0x400,0x1000),seg(0,0,0x1000,bytes(range(16))),seg(1,32,0x1100,b'abcdefgh',2),('R',1,0,0,0,4),('V',),('V',)]
cases=[('basic-relocations',basic),('reset-clears-plan',basic+[('I',0x2000,32,0x2000),seg(3,0,0x2000,b'abcd'),('V',)]),
('overlap-address',[('I',4096,256,4096),seg(0,0,4096,b'abcdefgh'),seg(1,16,4100,b'ijklmnop'),('V',)]),
('overlap-file',[('I',4096,256,4096),seg(0,0,4096,b'abcdefgh'),seg(1,4,4128,b'ijklmnop'),('V',)]),
('zero-fill-no-file-overlap',[('I',4096,256,4096),seg(0,0,4096,b'abcd',1),('S',1,0,4128,16,6,crc(bytes(16)),b''),('R',1,12,1,0,-4),('V',)]),
('bad-pre-relocation-crc',[('I',4096,256,4096),('S',0,0,4096,4,3,0,b'abcd'),('R',0,0,0,0,0),('V',)]),
('duplicate-relocation',[('I',4096,256,4096),seg(0,0,4096,b'abcdefgh'),('R',0,0,0,0,0),('R',0,0,1,0,0),('V',)]),
('deferred-reference',[('I',4096,256,4096),('R',1,0,0,0,8),seg(1,16,4128,b'abcdefgh',2),('V',),seg(0,0,4096,b'ijklmnop',1),('V',)]),
('relocation-permissions-and-boundary',[('I',4096,256,4096),seg(0,0,4096,b'abcd',1),('R',0,0,0,0,0),('V',)]),
('relocation-offset-and-kind',[('I',4096,256,4096),seg(0,0,4096,b'abcdefgh'),('R',0,6,0,0,0),('V',)]),
('bad-entry-alignment',[('I',4096,256,4097),seg(0,0,4096,b'abcdefgh'),('V',)]),
('no-executable-entry',[('I',4096,256,4100),seg(0,0,4096,b'abcd',2),('V',)]),
('adjacent-ranges-valid',[('I',4096,256,4096),seg(0,0,4096,b'abcd',1),seg(1,4,4100,b'efgh',2),('V',)]),
('invalid-flags-and-length',[('I',4096,256,4096),('S',0,0,4096,0,9,0,b''),('V',)]),
('window-overflow',[('I',0xfffffff0,64,0xfffffff0),seg(0,0,0xfffffff0,b'abcd',1),('V',)]),
]
for k in range(40):
base=rng.randrange(1,0x10000)*0x1000;cmds=[('I',base,2048,base)]
count=rng.randrange(2,8)
for i in range(count):
n=4*rng.randrange(1,17);raw=bytes(rng.randrange(256) for _ in range(n));flags=3 if i==0 else rng.choice([2,6])
cmds.append(('S',i,i*128,base+i*128,n,flags,crc(bytes(n) if flags&4 else raw),b'' if flags&4 else raw))
for i in range(1,count):
cmds.append(('R',i,0,rng.randrange(2),rng.randrange(count),rng.randrange(-1000,1001)))
cmds.extend([('V',),('V',)])
cases.append(('mixed-manifest-%d'%k,cmds))
stdin=[];truth=[];labels=[]
for label,commands in cases:
expected=manifest_oracle(commands);truth.extend(expected);labels.extend([label]*len(expected))
for cmd in commands:
if cmd[0]=='S':stdin.append(' '.join(map(str,cmd[:-1]))+' '+str(len(cmd[-1]))+' '+' '.join(map(str,cmd[-1])))
else:stdin.append(' '.join(map(str,cmd)))
return '\n'.join(stdin)+'\n',truth,labels
def ledger_record(generation,floor,image):
body=b'LGR2'+struct.pack('<III',generation,floor,image)
return body+struct.pack('<I',crc(body))+b'\xff'*11+b'\0'
def ledger_oracle(commands):
memory=bytearray([255]*512);powered=1;remaining=-1
valid,generation,floor,image,bank=0,0,0,0,-1;out=[]
def program(address,raw):
nonlocal powered,remaining
if not raw or len(raw)>32 or address<64 or address+len(raw)>448 or address//64!=(address+len(raw)-1)//64:return -3
if not powered:return -9
if any((a&b)!=b for a,b in zip(memory[address:address+len(raw)],raw)):return -3
if remaining==0:powered=0;return -9
if remaining>0:remaining-=1
memory[address:address+len(raw)]=raw;return 0
def erase(address):
nonlocal powered,remaining
if not powered:return -9
if remaining==0:powered=0;return -9
if remaining>0:remaining-=1
memory[address:address+64]=b'\xff'*64;return 0
for cmd in commands:
op=cmd[0];rc=0
if op=='I':
memory=bytearray((i*7+3)&255 if i<64 or i>=448 else 255 for i in range(512));powered=1;remaining=-1
valid,generation,floor,image,bank=0,0,0,0,-1
elif op=='A':remaining=cmd[1]
elif op=='R':
powered=1;remaining=-1;records=[]
for b,address in enumerate((64,256)):
raw=bytes(memory[address:address+32])
if raw[:4]==b'LGR2' and raw[31]==0 and raw[20:31]==b'\xff'*11 and crc(raw[:16])==int.from_bytes(raw[16:20],'little'):
g,f,i=struct.unpack('<III',raw[4:16]);records.append((b,g,f,i))
if not records:valid,generation,floor,image,bank=0,0,0,0,-1;rc=-1
else:
chosen=records[0]
if len(records)==2 and 0<((records[1][1]-chosen[1])&0xffffffff)<0x80000000:chosen=records[1]
bank,generation,floor,image=chosen;valid=1
elif op=='T':
f,i=cmd[1:]
if valid and f<floor:rc=-2
else:
target=1-bank if valid else 0;address=(64,256)[target];g=(generation+1)&0xffffffff if valid else 0;raw=ledger_record(g,f,i)
for action in [(0,address),(0,address+64),(1,address,raw[:31]),(1,address+31,b'\0')]:
rc=erase(action[1]) if action[0]==0 else program(action[1],action[2])
if rc:break
if not rc:valid,generation,floor,image,bank=1,g,f,i,target
elif op=='K':
address,value=cmd[1:]
if address>=512:rc=-3
else:memory[address]=value
elif op=='P':rc=program(cmd[1],cmd[2])
elif op=='D':
address,n=cmd[1:];out.append('D -3' if address>512 or n>512-address else 'D 0 '+(bytes(memory[address:address+n]).hex() or '-'));continue
out.append(' '.join(map(str,[op,rc,valid,generation,floor,image,bank,powered])))
return out
def ledger_cases(seed):
rng=random.Random(seed)
cases=[('basic-ledger',[('I',),('R',),('T',2,11),('T',3,12),('R',),('T',2,13),('D',0,64),('D',448,64)]),
('equal-floor-image-change',[('I',),('T',5,1),('T',5,2),('R',)]),
('generation-wrap',[('I',),('P',64,ledger_record(0xffffffff,5,90)),('R',),('T',6,91),('R',)]),
('record-CRC-and-marker',[('I',),('T',2,11),('T',3,12),('K',260,99),('R',),('T',4,13),('K',287,255),('R',)]),
('ambiguous-generation-tie',[('I',),('P',64,ledger_record(0,5,90)),('P',256,ledger_record(0x80000000,6,91)),('R',)]),
]
for cut in range(5):cases.append(('metadata-cut-%d'%cut,[('I',),('T',3,1),('A',cut),('T',4,2),('S',),('R',),('T',5,3),('R',),('D',64,128),('D',256,128)]))
for k in range(32):
cmds=[('I',)];floor=0
for step in range(24):
floor+=rng.randrange(3)
if rng.randrange(3)==0:cmds.append(('A',rng.randrange(5)))
cmds.extend([('T',floor,rng.getrandbits(32)),('R',)])
cmds.extend([('D',0,64),('D',448,64)])
cases.append(('mixed-ledger-%d'%k,cmds))
stdin=[];truth=[];labels=[]
for label,commands in cases:
expected=ledger_oracle(commands);truth.extend(expected);labels.extend([label]*len(expected))
for cmd in commands:
if cmd[0]=='P':stdin.append('P %d %d %s'%(cmd[1],len(cmd[2]),' '.join(map(str,cmd[2]))))
else:stdin.append(' '.join(map(str,cmd)))
return '\n'.join(stdin)+'\n',truth,labels
def run():
data=json.loads(pathlib.Path(__file__).with_name('cases.json').read_text())
makers={'image':image_cases,'slot':slot_cases,'flash':flash_cases,'manifest':manifest_cases,'ledger':ledger_cases}
stdin,truth,labels=makers[data['kind']](data['seed'])
scratch=pathlib.Path(tempfile.mkdtemp(prefix='embedded2-fw-'+data['kind']+'-',dir='/tmp'))
sys.stderr.write('scratch-owned: '+str(scratch)+'\n')
for name,content in data['context'].items():
(scratch/name).write_text(content)
candidate=pathlib.Path(sys.argv[1])
for name in data['candidates']:
source=candidate/name
if source.is_symlink() or not source.is_file():
raise AssertionError('missing candidate '+name)
shutil.copyfile(source,scratch/name)
result=subprocess.run(['gcc','-std=c11','-O2','-Wall','-Wextra','-Werror','-pedantic',*data['sources'],'-o','observe'],cwd=scratch,capture_output=True,text=True,timeout=20)
if result.returncode:
sys.stderr.write(result.stderr[-2500:])
raise AssertionError('candidate did not compile')
# Everything, including file-backed flash inputs, is ready before candidate execution.
# After this point the root checker never reads, writes, walks or removes scratch.
result=subprocess.run([str(scratch/'observe')],cwd=scratch,input=stdin,capture_output=True,text=True,timeout=12)
if 'read-grader:' in result.stderr:
sys.stderr.write(result.stderr[-2000:])
if result.returncode:
raise AssertionError('candidate execution exit '+str(result.returncode))
actual=result.stdout.splitlines()
if actual!=truth:
idx=next((i for i,(a,b) in enumerate(zip(actual,truth)) if a!=b),min(len(actual),len(truth)))
label=labels[min(idx,len(labels)-1)]
observed=actual[idx] if idx<len(actual) else '<missing>'
expected=truth[idx] if idx<len(truth) else '<end>'
raise AssertionError('behavior mismatch '+label+' at '+str(idx)+': '+observed[:120]+' expected '+expected[:120])
print('PASS')
if __name__=='__main__':
try:
run()
except Exception as exc:
print('FAIL:',type(exc).__name__,str(exc)[:300])
sys.exit(1)