File size: 6,129 Bytes
d14d999 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 | #!/usr/bin/env python3
"""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)})
# Existing-entry normalization is isolated from increment effects.
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()
|