| |
| """Bounded adaptive Huffman insertion and recursive increment compositions.""" |
| import copy |
| import gzip |
| import hashlib |
| import json |
| from pathlib import Path |
| from analyze_bsp_references import trace_fields |
| from analyze_collision_composition import evaluate,get_word,put_word |
| from analyze_engine_control import control_flow |
| from analyze_qvm import write_json |
| from analyze_vm_extensions import native_functions,verified |
|
|
| BASE=0x10000 |
|
|
|
|
| def run(g,start,stops,m,regs):return evaluate(g,start,stops,m,regs,limit=10000,capture_registers=True) |
|
|
|
|
| def increment(g,m,obj,node,depth=1): |
| if depth>64:raise ValueError('synthetic increment recursion bound') |
| graph=copy.deepcopy(g) |
| for x in graph['instructions']: |
| if x['opcode']=='pushq':x['opcode']='nop';x['operands']='' |
| rows=graph['instructions'];ends=[x['address'] for x in rows if x['opcode']=='popq'];idx=next(i for i,x in enumerate(rows) if x['opcode']=='callq');call=rows[idx]['address'];start=rows[0]['address'];regs={'%rdi':obj,'%rsi':node};trace=[];maximum=depth;frames=1 |
| while True: |
| t=run(graph,start,ends+[call],m,regs);m=t['memory'];regs=t['registers'];trace+=t['trace'] |
| if t['stop'] in ends:break |
| child=increment(g,m,regs['rdi'],regs['rsi'],depth+1);m=child['memory'];trace+=child['trace'];frames+=child['frames'];maximum=max(maximum,child['maximum_depth']);start=rows[idx+1]['address'] |
| return {'memory':m,'trace':trace,'frames':frames,'maximum_depth':maximum} |
|
|
|
|
| def state(m,obj=BASE): |
| count=get_word(m,obj);nodes=[] |
| if count>513:raise ValueError('fixture node capacity') |
| for i in range(count): |
| addr=obj+0x830+56*i;nodes.append({'index':i,'address':addr,'left':get_word(m,addr,8),'right':get_word(m,addr+8,8),'parent':get_word(m,addr+16,8),'next':get_word(m,addr+24,8),'previous':get_word(m,addr+32,8),'head_cell':get_word(m,addr+40,8),'weight':get_word(m,addr+48),'symbol':get_word(m,addr+52)}) |
| heads=sorted({n['head_cell'] for n in nodes if n['head_cell']});pool=get_word(m,obj+4) |
| return {'node_count':count,'pointer_cell_count':pool,'root':get_word(m,obj+8,8),'list_start':get_word(m,obj+16,8),'tail_slot':get_word(m,obj+24,8),'free_head':get_word(m,obj+0x828,8),'nodes':nodes,'heads':[[p,get_word(m,p,8)] for p in heads],'pointer_cells':[get_word(m,obj+0xb030+8*i,8) for i in range(pool)],'lookup':[[i,get_word(m,obj+32+8*i,8)] for i in range(257) if get_word(m,obj+32+8*i,8)]} |
|
|
|
|
| def main(): |
| seeds=json.loads(Path('docs/research/huffman-initialization.json').read_text());out={'native':{},'limitations':'Two Linux ELF64 engines, bounded synthetic adaptive instruction compositions. Initial object bytes supplied from hash-matched prior initialization report; original memset/process/native callees never execute. increment PUSH omitted, POP/RET stopped; recursive callers restored explicitly. Full real million-repetition seed training, actual game codewords/messages, malformed/cyclic/overflow/all-platform/ABI/runtime invariants remain open.'} |
| sequences=[[],[0],[255],[0]*16,[0,1],[0,1]*8,list(range(8)),list(reversed(range(8))),list(range(16))+list(range(16)),[255,0,128,127,1,254]*4,list(range(256))] |
| for label in ['linux--Quake3-UrT-Ded.x86_64','linux--Quake3-UrT.x86_64']: |
| r=json.loads(Path(f'docs/research/native/{label}.json').read_text());verified((Path('.cache/UrbanTerror43')/r['source']['path']).read_bytes(),r['source']['sha256']);a=r['artifacts']['disassembly.txt'];fs=native_functions(verified(gzip.open(a['path'],'rb').read(),a['uncompressed_sha256']).decode());graphs={n:control_flow(fs[n]) for n in ['Huff_addRef','increment']};g=graphs['Huff_addRef'];end=graphs['increment']['instructions'][0]['address'] |
| prior=seeds['native'][label] |
| if prior['source']!=r['source'] or prior['disassembly_sha256']!=a['uncompressed_sha256']:raise ValueError('initialization provenance mismatch') |
| seed=prior['initialization_probes'][0]['objects'][0];memory={BASE+i:0 for i in range(0xc830)} |
| for offset,value in seed['nonzero_bytes']:memory[BASE+offset]=value |
| memory[BASE-1]=memory[BASE+0xc830]=0x7b;records=[] |
| for sequence in sequences: |
| m=dict(memory);trace=[];steps=[];maximum=0;frames=0;dispatch=[] |
| for symbol in sequence: |
| before=get_word(m,BASE+32+8*(symbol&255),8);t=run(g,g['instructions'][0]['address'],[end],m,{'%rdi':BASE,'%rsi':symbol});m=t['memory'];trace+=t['trace'];regs=t['registers'];dispatch.append([symbol,'existing' if before else 'new',regs['rsi']]) |
| c=increment(graphs['increment'],m,regs['rdi'],regs['rsi']);m=c['memory'];trace+=c['trace'];maximum=max(maximum,c['maximum_depth']);frames+=c['frames'] |
| if len(sequence)<=24:steps.append(state(m)) |
| records.append({'symbols':sequence,'dispatch':dispatch,'steps':steps,'final_state':state(m),'increment_frames':frames,'maximum_increment_depth':maximum,'canaries':[m[BASE-1],m[BASE+0xc830]],**trace_fields({'trace':trace},False)}) |
| |
| aliases=[] |
| for word in [0,1,255,256,257,0xffffffff]: |
| m=dict(memory);target=BASE+0x830;put_word(m,BASE+32+8*(word&255),target,8);before=dict(m);t=run(g,g['instructions'][0]['address'],[end],m,{'%rdi':BASE,'%rsi':word}) |
| aliases.append({'input_word':word,'normalized_byte':word&255,'increment_node':t['registers']['rsi'],'memory_unchanged':t['memory']==before,**trace_fields(t,True)}) |
| null=increment(graphs['increment'],memory,BASE,0) |
| out['native'][label]={'source':r['source'],'disassembly_sha256':a['uncompressed_sha256'],'seed_report_sha256':hashlib.sha256(Path('docs/research/huffman-initialization.json').read_bytes()).hexdigest(),'graphs':graphs,'sequences':records,'existing_alias_probes':aliases,'null_increment_probe':{'memory_unchanged':null['memory']==memory,**trace_fields(null,True)}} |
| write_json(Path('docs/research/huffman-updates.json'),out);print('Recovered 22 adaptive sequences, twelve byte-normalized dispatch and two null-increment probes') |
|
|
|
|
| if __name__=='__main__':main() |
|
|
