diff options
Diffstat (limited to '')
| -rwxr-xr-x | miasm/tools/emul_helper.py | 116 | ||||
| -rw-r--r-- | miasm/tools/to_c_helper.py | 122 |
2 files changed, 119 insertions, 119 deletions
diff --git a/miasm/tools/emul_helper.py b/miasm/tools/emul_helper.py index ba16eabf..72a88e98 100755 --- a/miasm/tools/emul_helper.py +++ b/miasm/tools/emul_helper.py @@ -33,17 +33,17 @@ log_emu_helper.addHandler(console_handler) log_emu_helper.setLevel(logging.WARN) def hexdump(a, offset = 0): - out ="" + out ="" for i,c in enumerate(a): if i%0x10==0: out+="\n%.8X "%(offset+i) - + out+="%.2X "%ord(c) return out - + def tohex(a): - + try: a = int(a) except: @@ -54,7 +54,7 @@ def tohex(a): a = struct.pack('L', a) a = struct.unpack('L', a)[0] return hex(a) - + jcc = ['jz', 'je', 'jnz', 'jp', 'jnp', 'jg', 'jge', 'ja', 'jae', 'jb', 'jbe', 'jl', 'jle', 'js', 'jns', 'jo', 'jno', 'loop', 'loopne', 'jecxz'] @@ -71,7 +71,7 @@ def dump_reg(p): out+=str(x)+' %.8X '%int(p[x].arg) else: out+=str(x)+' %s '%p[x] - + return out @@ -86,7 +86,7 @@ def dump_mem(p): todo.sort() for x in todo: out.append('%s %s'%(str(x), str(p[x]))) - + return "\n".join(out) def mem_read(evaluator, env, src_address, mem_size): @@ -95,7 +95,7 @@ def mem_read(evaluator, env, src_address, mem_size): raise "cannot read", str(src_address) src_address_l = int(src_address.arg) try: - + if mem_size == 32: ret = uint32(env.get_d(src_address_l)) elif mem_size == 16: @@ -236,13 +236,13 @@ def emul_imp_init(machine, libbase = 0xCCC00000, malloc_next_ad = 0xEEE00000): #for loadlibrary & getprocaddress emul machine.lib_bases = {} machine.lib_bases_func_index = {} - machine.lib_base = libbase + machine.lib_base = libbase machine.func_loaded = {} #for malloc & free emul machine.malloc_next_ad = malloc_next_ad; - - + + def emul_loadlibrary(machine, env): my_esp = machine.eval_expr(machine.pool[esp], {}) libname_ad = env.get_d(my_esp+4) @@ -285,7 +285,7 @@ def emul_getprocaddress(machine, env): log.debug(machine.lib_bases) raise 'unknown base lib! %s'%str(libbase_ad) func_ad = machine.lib_bases_func_index[libbase_ad] - + machine.lib_bases_func_index[libbase_ad]+=1 machine.eval_instr(mov(eax, ExprInt(uint32(func_ad)))) @@ -302,7 +302,7 @@ def hook_import_func(env, imported_func, start_address_hook = 0xAABB0000): env.set_d(f, start_address_hook) func_hook_ptr[start_address_hook] = imported_func[f] start_address_hook+=0x10000 - + return func_hook_ptr def dump_imp(machine): @@ -321,18 +321,18 @@ def emul_malloc(machine, env): pool_type =env.get_d(my_esp+0x4) alloc_size =env.get_d(my_esp+0x8) tag =env.get_d(my_esp+0xc) - + machine.eval_instr(ret(ExprInt(uint32(0xc)))) my_eip = machine.eval_expr(machine.pool[eip], {}) del machine.pool[eip] - + ret_alloc_ad = machine.malloc_next_ad m_data = mempool(machine.malloc_next_ad, machine.malloc_next_ad+alloc_size, 'RW', name = "malloc %.8X"%alloc_size) machine.malloc_next_ad += ((alloc_size+0xFFF)&(~0xFFF)) - + log.warn('alloc(%X) tag %X poolt %X from %X esp %X ret %X:'%(int(alloc_size), int(tag), int(pool_type), int(my_eip), int(my_esp), int(machine.malloc_next_ad))) machine.eval_instr(mov(eax, ExprInt(uint32(ret_alloc_ad)))) - + env.mems.append(m_data) log.warn(str(env)) return my_eip @@ -365,34 +365,34 @@ def emul_heapcreate(machine, env): floptions =env.get_d(my_esp+4) dwinitialsize =env.get_d(my_esp+8) dwmaximumsize =env.get_d(my_esp+12) - + machine.eval_instr(ret(ExprInt(uint32(12)))) my_eip = machine.eval_expr(machine.pool[eip], {}) del machine.pool[eip] - - + + log.warn('heapcreate(%X %X %X) from %X esp %X ret %X:'%(floptions, dwinitialsize, dwmaximumsize, int(my_eip), my_esp, 0xdeadcafe)) machine.eval_instr(mov(eax, ExprInt(uint32(0xdeadcafe)))) - + return my_eip - + def emul_heapalloc(machine, env): my_esp = machine.get_reg(esp) hheap =env.get_d(my_esp+4) dwflags =env.get_d(my_esp+8) - alloc_size =env.get_d(my_esp+12) - + alloc_size =env.get_d(my_esp+12) + machine.eval_instr(ret(ExprInt(uint32(12)))) my_eip = machine.eval_expr(machine.pool[eip], {}) del machine.pool[eip] - + ret_alloc_ad = machine.malloc_next_ad m_data = mempool(machine.malloc_next_ad, machine.malloc_next_ad+alloc_size, 'RW', name = "heapalloc %.8X"%alloc_size) machine.malloc_next_ad += ((alloc_size+0xFFF)&(~0xFFF)) - + log.warn('heapalloc(%X %X %X) from %X esp %X ret %X:'%(hheap, dwflags, alloc_size, int(my_eip), my_esp, machine.malloc_next_ad)) machine.eval_instr(mov(eax, ExprInt(uint32(ret_alloc_ad)))) - + env.mems.append(m_data) log.warn(str(env)) return my_eip @@ -419,20 +419,20 @@ def emul_virtualalloc(machine, env): my_esp = machine.get_reg(esp) lpaddress =env.get_d(my_esp+4) alloc_size =env.get_d(my_esp+8) - flallocationtype =env.get_d(my_esp+12) - flprotect =env.get_d(my_esp+16) - + flallocationtype =env.get_d(my_esp+12) + flprotect =env.get_d(my_esp+16) + machine.eval_instr(ret(ExprInt(uint32(16)))) my_eip = machine.eval_expr(machine.pool[eip], {}) del machine.pool[eip] - + ret_alloc_ad = machine.malloc_next_ad m_data = mempool(machine.malloc_next_ad, machine.malloc_next_ad+alloc_size, 'RW', name = "virtualalloc %.8X"%alloc_size) machine.malloc_next_ad += ((alloc_size+0xFFF)&(~0xFFF)) - + log.warn('virtualalloc(%X %X %X %X) from %X esp %X ret %X:'%(lpaddress, alloc_size, flallocationtype, flprotect, int(my_eip), my_esp, machine.malloc_next_ad)) machine.eval_instr(mov(eax, ExprInt(uint32(ret_alloc_ad)))) - + env.mems.append(m_data) log.warn(str(env)) return my_eip @@ -443,8 +443,8 @@ def emul_virtualfree(machine, env): address_free =env.get_d(my_esp+4) dwsize =env.get_d(my_esp+8) dwfreetype =env.get_d(my_esp+12) - - + + machine.eval_instr(ret(ExprInt(uint32(12)))) my_eip = machine.eval_expr(machine.pool[eip], {}) @@ -486,27 +486,27 @@ def emul_getmodulehandlea(machine, env): else: machine.eval_instr(mov(eax, ExprInt(uint32(0x0)))) log.warn("unknown lib: %s"%str(libname)) - + log.warn(str(env)) return my_eip def emul_kddisabledebugger(machine, env): my_esp = machine.get_reg(esp) - + machine.eval_instr(ret()) my_eip = machine.eval_expr(machine.pool[eip], {}) del machine.pool[eip] - - + + log.warn('emul_kddisabledebugger from %X esp %X '%(int(my_eip), int(my_esp))) machine.eval_instr(mov(eax, ExprInt(uint32(0)))) - + log.warn(str(env)) return my_eip - - - + + + def sav_machine(machine, env, my_eip, snap_fmt_name): print 'SAVE**************tsc: %.10d***************'%machine.pool[tsc1].arg @@ -514,7 +514,7 @@ def sav_machine(machine, env, my_eip, snap_fmt_name): env_s = StringIO.StringIO() env.to_file(env_s) env_s.flush() - fname = snap_fmt_name+".env" + fname = snap_fmt_name+".env" open(fname%(machine.pool[tsc1].arg), 'wb').write(zlib.compress(env_s.getvalue(), 9)) machine_s = StringIO.StringIO() machine.to_file(machine_s) @@ -522,23 +522,23 @@ def sav_machine(machine, env, my_eip, snap_fmt_name): fname = snap_fmt_name+".machine" open(fname%(machine.pool[tsc1].arg), 'wb').write(zlib.compress(machine_s.getvalue(), 9)) del machine.pool[eip] - - + + def load_machine(snap_fmt_name, step): - fname = snap_fmt_name+".env" + fname = snap_fmt_name+".env" env_s = StringIO.StringIO(zlib.decompress(open(fname%step, 'rb').read())) env = mempool_manager.from_file(env_s) - fname = snap_fmt_name+".machine" + fname = snap_fmt_name+".machine" machine_s = StringIO.StringIO(zlib.decompress(open(fname%step, 'rb').read())) machine = eval_int.from_file(machine_s, globals()) my_eip = machine.pool[eip] del machine.pool[eip] print 'LOAD**************tsc: %.10X***************'%machine.pool[tsc1].arg print "machine eip: %.8X"%int(my_eip.arg) - + return machine, env, my_eip - + def emul_full_expr(e, l, my_eip, env, machine): if ((not 0xF2 in l.prefix) and (not 0xF3 in l.prefix)) or \ not l.m.name[:-1] in ["ins", "outs", "movs", "lods", "stos", "cmps", "scas"]: @@ -549,7 +549,7 @@ def emul_full_expr(e, l, my_eip, env, machine): if 0x66 in l.prefix and l.m.name[-1]== "d": raise "not impl 16 bit string" zf_w = zf in reduce(lambda x,y:x+y, [list(x.get_w()) for x in e], []) - + while True: my_ecx = machine.eval_expr(machine.pool[ecx], {}) @@ -563,7 +563,7 @@ def emul_full_expr(e, l, my_eip, env, machine): my_esi = machine.eval_expr(machine.pool[esi], {}) my_edi = machine.eval_expr(machine.pool[edi], {}) tmp,mem_dst = emul_expr(machine, e, my_eip) - + info = l.opmode, l.admode machine.eval_instr(mov(info, ecx, ExprOp('-', my_ecx, ExprInt(uint32(1))))) machine.eval_expr(machine.pool[ecx], {}) @@ -578,7 +578,7 @@ def emul_full_expr(e, l, my_eip, env, machine): machine.pool[tsc1].arg+=uint32(1) return my_eip, mem_dst - + def guess_func_destack(all_bloc): ret_destack = None @@ -587,7 +587,7 @@ def guess_func_destack(all_bloc): if not l.m.name.startswith('ret'): continue if len(l.arg) == 0: - a = 0 + a = 0 elif len(l.arg) ==1: a = l.arg[0][x86_afs.imm] else: @@ -644,7 +644,7 @@ def digest_allbloc_instr(all_bloc, segm_to_do = {}): print b raise ValueError('diff bloc in same label') all_bloc.remove(b) - + for b in all_bloc: for l in b.lines: if l.offset in instrs: @@ -654,7 +654,7 @@ def digest_allbloc_instr(all_bloc, segm_to_do = {}): args = [] ex = get_instr_expr(l, ExprInt(uint32(l.offset+l.l)), args, segm_to_do = segm_to_do) - + instrs[l.offset] = (l, ex) return instrs @@ -672,10 +672,10 @@ def x86_machine(mem_read_wrap = None, mem_write_wrap = None): dr7:ExprInt(uint32(0)), cr0:init_cr0, #my_ret_addr:my_ret_addri - + }, mem_read_wrap, mem_write_wrap, - + ) return machine diff --git a/miasm/tools/to_c_helper.py b/miasm/tools/to_c_helper.py index 3fa44b99..5ae2e2a9 100644 --- a/miasm/tools/to_c_helper.py +++ b/miasm/tools/to_c_helper.py @@ -392,7 +392,7 @@ def Exp2C(exprs, l = None, addr2label = None, gen_exception_code = False): post_instr.append("if (vmcpu.vm_exception_flags) { /*eip = 0x%X; */return vmcpu.eip; }"%(l.offset)) else: post_instr.append(code_deal_exception_post_instr % (patch_c_id(eip), (l.offset&mask_int), (l.offset + l.l)&mask_int)) - + """ print "1" print out @@ -401,8 +401,8 @@ def Exp2C(exprs, l = None, addr2label = None, gen_exception_code = False): print "3" print post_instr """ - - + + #eip manip after all modifications return out+out_eip, post_instr @@ -424,8 +424,8 @@ def bloc2C(all_bloc, addr2label = None, gen_exception_code = False, dbg_instr = if tick_dbg!=None: out.append('if (my_tick > %d)'%tick_dbg) out.append(r'fprintf(stdout, "%s\n");'%str(b.label.name)) - - + + for l in b.lines: if l.offset in label_done: continue @@ -435,17 +435,17 @@ def bloc2C(all_bloc, addr2label = None, gen_exception_code = False, dbg_instr = out.append("%s:"%addr2label(l.offset)) else: out.append("loc_%.16X:"%(l.offset&mask_int)) - + o, post_instr = Exp2C(ex, l, addr2label, gen_exception_code) - - + + #if add_return: # o.append('return;'); #if add_call: # o.append('%s();'%add_call); - + if (0xF2 in l.prefix or 0xF3 in l.prefix) and l.m.name in ["ins", "outs", "movsb", "movsw", "movsd", "lodsb", "lodsw", "lodsd", "stosb", "stosw", "stosd" ]+ [ "cmpsb", "cmpsw", "cmpsd", "scasb", "scasw", "scasd" ]: zf_w = zf in reduce(lambda x,y:x+y, [list(x.get_w()) for x in ex], []) my_o = ["while (1){"] @@ -454,7 +454,7 @@ def bloc2C(all_bloc, addr2label = None, gen_exception_code = False, dbg_instr = my_o.append(code_deal_exception_post_instr % (patch_c_id(eip), (l.offset&mask_int), (l.offset&mask_int))) - #my_o.append(r'fprintf(stderr, "ecx %.8X\n", ecx );') + #my_o.append(r'fprintf(stderr, "ecx %.8X\n", ecx );') my_o+= ['if (%s==0) break;'%patch_c_id(ecx)] my_o+=o my_o+= ['%s--;'%patch_c_id(ecx)] @@ -466,7 +466,7 @@ def bloc2C(all_bloc, addr2label = None, gen_exception_code = False, dbg_instr = my_o += ["}"] - + o = my_o o+= post_instr @@ -486,15 +486,15 @@ def bloc2C(all_bloc, addr2label = None, gen_exception_code = False, dbg_instr = out+=o - + for c in b.bto: if c.c_t == asmbloc.asm_constraint.c_next: out.append("GOTO_STATIC(0x%.16X);"%(c.label.offset&mask_int)) - + """ #in case of bad disasm, no next, so default next instr #XXX BUG if no line!!! - + if b.lines: l = b.lines[-1] out.append("GOTO_STATIC(%s);"%(addr2label(l.offset + l.l))) @@ -531,7 +531,7 @@ def gen_x86_core(): txt += '#include "%s/libcodenat.h"\n'%lib_dir txt += r''' - + //#define RAISE(errtype,msg) { PyErr_SetString(errtype,msg); RE_RAISE; } //#define RE_RAISE { return NULL; } @@ -541,12 +541,12 @@ def gen_x86_core(): ''' return txt - + def gen_C_source(funcs_code, known_mems, dyn_dispatcher): c_source = dyn_dispatcher c_source+= "\n".join(funcs_code) - + kmems = gen_known_mems_code(known_mems) c_source = gen_x86_core()+"\n".join(kmems)+c_source return c_source @@ -567,14 +567,14 @@ def del_bloc_in_range(all_blocs, ad1, ad2): # XXX no lines in bloc? if not b.lines: continue - + if b.lines[0].offset>=ad2 or b.lines[-1].offset + b.lines[-1].l <= ad1: bloc_out.append(b) else: #print 'inv bloc', b.label pass return bloc_out - + def merge_memory_ranges(t): i = 0 while i < len(t)-1: @@ -609,7 +609,7 @@ def merge_memory_ranges(t): t[i] = rA1, rA2 else: i+=1 - + def gen_code_addr_tab(t): out = [] @@ -618,10 +618,10 @@ def gen_code_addr_tab(t): out += ["unsigned int code_addr_tab[2*%d] = {"%len(t)] for r in t: out += ["\t0x%.8X, 0x%.8X,"%(r)] - + out += ['};'] return '\n'.join(out)+'\n' - + def asm2C(f_name, known_mems, dyn_func, in_str, x86_mn, symbol_pool, func_to_dis, dont_dis = [], follow_call = False, dontdis_retcall = False, log_mn = False, log_reg = False, log_lbl = False, filtered_ad = [], tick_dbg = None, code_addr = [], all_bloc_funcs = []): funcs_code = [] @@ -629,8 +629,8 @@ def asm2C(f_name, known_mems, dyn_func, in_str, x86_mn, symbol_pool, func_to_dis all_bloc_funcs+=asmbloc.dis_multi_func(in_str, x86_mn, symbol_pool, func_to_dis, dont_dis, follow_call, dontdis_retcall) - - + + for b in all_bloc_funcs: if b.label.offset in dont_dis: continue @@ -645,7 +645,7 @@ def asm2C(f_name, known_mems, dyn_func, in_str, x86_mn, symbol_pool, func_to_dis if (l.m.name.startswith('call') or l.m.name.startswith('jmp')) and not x86_afs.symb in l.arg[0]: #print "TOTO", hex(l.offset), l, l.arg[0] - + #deal dyn call instr = x86_mn.dis(x86_mn.asm('mov eax, eax')[0]) #XXX HACK to be unik address @@ -655,16 +655,16 @@ def asm2C(f_name, known_mems, dyn_func, in_str, x86_mn, symbol_pool, func_to_dis #print instr, str(instr) #instr.offset = 0x1337beef - + #b.lines[-1:-1] = [instr] #l.arg[0] = {x86_afs.symb:func_deal_dyn} #if dyn func is not in ref, add it (todo in gen C) ''' - + for l in b.lines: - + #test imm redirect mem ad for a in l.arg: if not x86_afs.imm in a: continue @@ -687,16 +687,16 @@ def asm2C(f_name, known_mems, dyn_func, in_str, x86_mn, symbol_pool, func_to_dis if not l_name: continue - + label = asmbloc.asm_label(l_name, i) a[x86_afs.symb] = {label:1} del a[x86_afs.imm] - + code_addr += blocs_to_memory_ranges(all_bloc_funcs) merge_memory_ranges(code_addr) - - + + allb = all_bloc_funcs#reduce(lambda x,y:x+y, all_bloc_funcs.values(), []) f_dec, out = bloc_gen_C_func(allb, f_name, None, True, log_mn, log_reg, log_lbl, filtered_ad, tick_dbg) funcs_dec.append(f_dec) @@ -759,7 +759,7 @@ def dispatch_table_from_f_blocs(all_f_b): def gen_dynamic_dispatcher(dispatch_table): offsets = dispatch_table.keys() offsets.sort() - + out1 = [] out1 += ["#define FUNC_DYNAMIC"] out1 += ['void* tab_eip_label[(%d+1)*2] = '%len(dispatch_table)] @@ -773,9 +773,9 @@ def gen_dynamic_dispatcher(dispatch_table): out2 = [] out2 += ["void * get_label_from_eip(void** tab_eip_label)"] out2 += ['{'] - + out2 += ['\tvoid *labelref = NULL;'] - + out2 += ['\tunsigned int i = 0;'] out2 += ['\twhile (tab_eip_label[2*i]!= NULL && tab_eip_label[2*i+1]!=NULL){'] out2 += ['\t\tif (tab_eip_label[i*2] == (void*)vmcpu.eip){'] @@ -789,7 +789,7 @@ def gen_dynamic_dispatcher(dispatch_table): #out2 += [r'exit(0);'] out2 += ['return labelref;'] out2 += ['}'] - + out = [] @@ -801,17 +801,17 @@ def gen_dynamic_dispatcher(dispatch_table): out += ["return (PyObject*)vm_get_exception(vm_exception_flags);"] out += ['}'] out += ['goto *labelref;'] - + """ out += ['{'] #out += [r'fprintf(stderr, "search dst: %X\n", eip);'] - + out += ['switch(eip){'] for o in offsets: out+=['case 0x%.8X:'%o] out+=['goto %s;'%dispatch_table[o]] out+=['break;'] - + out += ['case 0x1337beef:'] out += [r'fprintf(stderr, "return reached %X\n", eip);'] out += ['return NULL;'] @@ -822,9 +822,9 @@ def gen_dynamic_dispatcher(dispatch_table): out += ['break;'] out += ['}'] out += ['}'] - """ + """ return out1, out2 - + def gen_dyn_func_manager(dyn_func, dis_func): total_func_num = len(dyn_func)+len(dis_func) out = "int (*tab_func[%d][2])(void) = {"%(total_func_num) @@ -835,12 +835,12 @@ def gen_dyn_func_manager(dyn_func, dis_func): dec_f_ptr += "unsigned int dyn_func_%.8X;\n"%(f_ad) init_f_ptr+= "dyn_func_%.8X = (unsigned int)&%s;\n"%(f_ad, f_name) - + for f_ad in dis_func: out+="{0x%.8X, func_%.8X},"%(f_ad, f_ad) out+="};" - - + + code = "\n" code += "#define DYN_FUNC_NUM %d"%total_func_num code += r""" @@ -849,7 +849,7 @@ void func_dyn_manager(void) { unsigned int i; """ + out + r""" - + for (i=0;i<DYN_FUNC_NUM;i++){ if (dyn_dst == tab_func[i][0]){ fprintf(stderr, "i %d v@%X r@%X\n", i, tab_func[i][0], tab_func[i][1]); @@ -857,7 +857,7 @@ void func_dyn_manager(void) return; } } - + fprintf(stderr, "unknown dyn dst!\n"); exit(0); } @@ -872,26 +872,26 @@ def insert_printf(c_source, label): print l if l.startswith(label): c_source[i+1:i+1] = ['printf("reached %s\\n");'%label] - + def gen_label_declaration(known_mems): lab_dec = [] - + for m_ad, m_val in known_mems.items(): dec_name = "char tab_%.8X[0x%X]"%(m_ad, len(m_val)) data = m_val dec_name+=' = {'+', '.join(["0x%.2X"%ord(x) for x in data])+'};' lab_dec.append(dec_name) - + return lab_dec def gen_call_func(funcname, args, precode = "", postcode = ""): out = "" - + def gen_known_mems_code(known_mems): code = [] for m_ad, m_val in known_mems.items(): @@ -907,7 +907,7 @@ def gen_known_mems_code(known_mems): code.append("void init_tab_mem(void)") code.append("{") code.append("unsigned int ret;") - + for m_ad, m_val in known_mems.items(): #code.append("tab_%.8X = malloc(0x%.8X);\n"%(m_ad, len(m_val))) code.append("ret = posix_memalign(&tab_%.8X, 0x10000, 0x%.8X);"%(m_ad, len(m_val))) @@ -915,13 +915,13 @@ def gen_known_mems_code(known_mems): code.append(r' fprintf(stderr, "cannot alloc");') code.append(r' exit(-1);') code.append(r'}') - + code.append("memcpy(tab_%.8X, tab_data_%.8X, 0x%.8X);"%(m_ad, m_ad, len(m_val))) code.append("}\n") """ - - + + return code @@ -944,7 +944,7 @@ if __name__ == '__main__': print x print '#'*80 - + def _compile(self): @@ -974,11 +974,11 @@ def _compile(self): ) except SystemExit, e: raise BuildError(e) - + os.chdir(self._homeDir) - - + + from miasm.tools.codenat import * @@ -1006,14 +1006,14 @@ def updt_bloc_emul(known_blocs, in_str, my_eip, symbol_pool, code_blocs_mem_rang known_blocs[my_eip] = bn ###### update code ranges ### - + code_addr = blocs_to_memory_ranges([bn.b]) code_blocs_mem_range += code_addr merge_memory_ranges(code_blocs_mem_range) reset_code_bloc_pool_py() for a, b in code_blocs_mem_range: vm_add_code_bloc(a, b) -''' +''' ttt = 0 def updt_bloc_emul(known_blocs, in_str, my_eip, symbol_pool, code_blocs_mem_range, dont_dis = [], job_done = None, log_mn = False, log_regs = False, segm_to_do = {}, **kargs): @@ -1134,7 +1134,7 @@ upw = lambda x: struct.unpack('H', x)[0] #try: if True: from emul_lib.libcodenat_interface import * - + #vm_init_regs = libcodenat.vm_init_regs #except: # print "WARNING! unable to build libcodenat C interface!!" |