From 80e40a3d2ca735db955807ad0605b43ca22e4e35 Mon Sep 17 00:00:00 2001 From: Fabrice Desclaux Date: Sat, 22 Aug 2020 12:47:01 +0200 Subject: Avoid generate default locationdb --- example/asm/shellcode.py | 2 +- example/asm/simple.py | 10 +++++++--- example/disasm/callback.py | 6 ++++-- example/disasm/dis_binary.py | 4 +++- example/disasm/dis_binary_ir.py | 4 +++- example/disasm/dis_binary_ira.py | 4 +++- example/disasm/dis_x86_string.py | 9 +++++++-- example/disasm/full.py | 14 +++++++++++--- example/expression/access_c.py | 9 ++++++--- example/expression/asm_to_ir.py | 9 +++++++-- example/expression/constant_propagation.py | 7 +++++-- example/expression/export_llvm.py | 9 +++++---- example/expression/graph_dataflow.py | 9 +++++---- example/expression/solve_condition_stp.py | 13 ++++++++----- example/jitter/arm.py | 4 +++- example/jitter/arm_sc.py | 4 +++- example/jitter/example_types.py | 5 ++++- example/jitter/mips32.py | 5 ++++- example/jitter/msp430.py | 4 +++- example/jitter/run_with_linuxenv.py | 6 ++++-- example/jitter/sandbox_call.py | 6 ++++-- example/jitter/sandbox_elf_aarch64l.py | 4 +++- example/jitter/sandbox_elf_ppc32.py | 4 +++- example/jitter/sandbox_pe_x86_32.py | 5 +++-- example/jitter/sandbox_pe_x86_64.py | 4 +++- example/jitter/test_x86_32_seh.py | 4 +++- example/jitter/trace.py | 4 +++- example/jitter/unpack_upx.py | 10 +++++++--- example/jitter/x86_32.py | 4 +++- example/jitter/x86_64.py | 4 +++- example/symbol_exec/depgraph.py | 9 +++++---- example/symbol_exec/dse_crackme.py | 6 ++++-- example/symbol_exec/dse_strategies.py | 7 +++++-- 33 files changed, 145 insertions(+), 63 deletions(-) (limited to 'example') diff --git a/example/asm/shellcode.py b/example/asm/shellcode.py index 67c882e9..d33d6231 100755 --- a/example/asm/shellcode.py +++ b/example/asm/shellcode.py @@ -83,7 +83,7 @@ with open(args.source) as fstream: loc_db = LocationDB() -asmcfg, loc_db = parse_asm.parse_txt(machine.mn, attrib, source, loc_db) +asmcfg = parse_asm.parse_txt(machine.mn, attrib, source, loc_db) # Fix shellcode addrs loc_db.set_location_offset(loc_db.get_name_location("main"), addr_main) diff --git a/example/asm/simple.py b/example/asm/simple.py index 8f6aac92..6197556b 100644 --- a/example/asm/simple.py +++ b/example/asm/simple.py @@ -4,10 +4,12 @@ from pprint import pprint from miasm.arch.x86.arch import mn_x86 from miasm.core import parse_asm, asmblock - +from miasm.core.locationdb import LocationDB # Assemble code -asmcfg, loc_db = parse_asm.parse_txt(mn_x86, 32, ''' +loc_db = LocationDB() +asmcfg = parse_asm.parse_txt( + mn_x86, 32, ''' main: MOV EAX, 1 MOV EBX, 2 @@ -20,7 +22,9 @@ loop: ADD EAX, ECX JZ loop RET -''') +''', + loc_db +) # Set 'main' loc_key's offset loc_db.set_location_offset(loc_db.get_name_location("main"), 0x0) diff --git a/example/disasm/callback.py b/example/disasm/callback.py index 1498b11e..eb999738 100644 --- a/example/disasm/callback.py +++ b/example/disasm/callback.py @@ -2,6 +2,7 @@ from __future__ import print_function from miasm.analysis.binary import Container from miasm.analysis.machine import Machine from miasm.core.asmblock import AsmConstraint +from miasm.core.locationdb import LocationDB def cb_x86_callpop(mdis, cur_bloc, offset_to_dis): @@ -50,8 +51,9 @@ shellcode = ( # Instantiate a x86 32 bit architecture machine = Machine("x86_32") -cont = Container.from_string(shellcode) -mdis = machine.dis_engine(cont.bin_stream, loc_db=cont.loc_db) +loc_db = LocationDB() +cont = Container.from_string(shellcode, loc_db) +mdis = machine.dis_engine(cont.bin_stream, loc_db=loc_db) print("Without callback:\n") asmcfg = mdis.dis_multiblock(0) diff --git a/example/disasm/dis_binary.py b/example/disasm/dis_binary.py index 37eabb14..af140f28 100644 --- a/example/disasm/dis_binary.py +++ b/example/disasm/dis_binary.py @@ -2,12 +2,14 @@ from __future__ import print_function import sys from miasm.analysis.binary import Container from miasm.analysis.machine import Machine +from miasm.core.locationdb import LocationDB fdesc = open(sys.argv[1], 'rb') +loc_db = LocationDB() # The Container will provide a *bin_stream*, bytes source for the disasm engine # It will prodive a view from a PE or an ELF. -cont = Container.from_stream(fdesc) +cont = Container.from_stream(fdesc, loc_db) # The Machine, instantiated with the detected architecture, will provide tools # (disassembler, etc.) to work with this architecture diff --git a/example/disasm/dis_binary_ir.py b/example/disasm/dis_binary_ir.py index ff7a0d36..3facd74b 100644 --- a/example/disasm/dis_binary_ir.py +++ b/example/disasm/dis_binary_ir.py @@ -3,14 +3,16 @@ import sys from future.utils import viewvalues from miasm.analysis.binary import Container from miasm.analysis.machine import Machine +from miasm.core.locationdb import LocationDB ##################################### # Common section from dis_binary.py # ##################################### fdesc = open(sys.argv[1], 'rb') +loc_db = LocationDB() -cont = Container.from_stream(fdesc) +cont = Container.from_stream(fdesc, loc_db) machine = Machine(cont.arch) diff --git a/example/disasm/dis_binary_ira.py b/example/disasm/dis_binary_ira.py index 3ecd5349..bfed3497 100644 --- a/example/disasm/dis_binary_ira.py +++ b/example/disasm/dis_binary_ira.py @@ -4,14 +4,16 @@ import sys from future.utils import viewvalues from miasm.analysis.binary import Container from miasm.analysis.machine import Machine +from miasm.core.locationdb import LocationDB ##################################### # Common section from dis_binary.py # ##################################### fdesc = open(sys.argv[1], 'rb') +loc_db = LocationDB() -cont = Container.from_stream(fdesc) +cont = Container.from_stream(fdesc, loc_db) machine = Machine(cont.arch) diff --git a/example/disasm/dis_x86_string.py b/example/disasm/dis_x86_string.py index 6d4e2c84..b944c6ad 100644 --- a/example/disasm/dis_x86_string.py +++ b/example/disasm/dis_x86_string.py @@ -1,16 +1,21 @@ from __future__ import print_function from miasm.analysis.binary import Container from miasm.analysis.machine import Machine +from miasm.core.locationdb import LocationDB # The Container will provide a *bin_stream*, bytes source for the disasm engine -cont = Container.from_string(b"\x83\xf8\x10\x74\x07\x89\xc6\x0f\x47\xc3\xeb\x08\x89\xc8\xe8\x31\x33\x22\x11\x40\xc3") +loc_db = LocationDB() +cont = Container.from_string( + b"\x83\xf8\x10\x74\x07\x89\xc6\x0f\x47\xc3\xeb\x08\x89\xc8\xe8\x31\x33\x22\x11\x40\xc3", + loc_db +) # Instantiate a x86 32 bit architecture machine = Machine("x86_32") # Instantiate a disassembler engine, using the previous bin_stream and its # associated location DB. -mdis = machine.dis_engine(cont.bin_stream, loc_db=cont.loc_db) +mdis = machine.dis_engine(cont.bin_stream, loc_db=loc_db) # Run a recursive traversal disassembling from address 0 asmcfg = mdis.dis_multiblock(0) diff --git a/example/disasm/full.py b/example/disasm/full.py index 57263a6f..9e739109 100644 --- a/example/disasm/full.py +++ b/example/disasm/full.py @@ -15,6 +15,7 @@ from miasm.expression.simplifications import expr_simp from miasm.analysis.ssa import SSADiGraph from miasm.ir.ir import AssignBlock, IRBlock from miasm.analysis.simplifier import IRCFGSimplifierCommon, IRCFGSimplifierSSA +from miasm.core.locationdb import LocationDB log = logging.getLogger("dis") console_handler = logging.StreamHandler() @@ -75,13 +76,20 @@ args = parser.parse_args() if args.verbose: log_asmblock.setLevel(logging.DEBUG) +loc_db = LocationDB() log.info('Load binary') if args.rawbinary: - cont = Container.fallback_container(open(args.filename, "rb").read(), - vm=None, addr=args.base_address) + cont = Container.fallback_container( + open(args.filename, "rb").read(), + vm=None, addr=args.base_address, + loc_db=loc_db, + ) else: with open(args.filename, "rb") as fdesc: - cont = Container.from_stream(fdesc, addr=args.base_address) + cont = Container.from_stream( + fdesc, addr=args.base_address, + loc_db=loc_db, + ) default_addr = cont.entry_point bs = cont.bin_stream diff --git a/example/expression/access_c.py b/example/expression/access_c.py index c604a0bd..3cc8e6a2 100644 --- a/example/expression/access_c.py +++ b/example/expression/access_c.py @@ -55,6 +55,8 @@ from miasm.arch.x86.ctype import CTypeAMD64_unk from miasm.core.objc import ExprToAccessC, CHandler from miasm.core.objc import CTypesManagerNotPacked from miasm.core.ctypesmngr import CAstTypes, CTypePtr, CTypeStruct +from miasm.core.locationdb import LocationDB + def find_call(ircfg): """Returns (irb, index) which call""" @@ -116,6 +118,7 @@ class MyCHandler(CHandler): +loc_db = LocationDB() data = open(sys.argv[1], 'rb').read() # Digest C information text = """ @@ -143,12 +146,12 @@ cont = Container.fallback_container(data, None, addr=0) machine = Machine("x86_64") dis_engine, ira = machine.dis_engine, machine.ira -mdis = dis_engine(cont.bin_stream, loc_db=cont.loc_db) +mdis = dis_engine(cont.bin_stream, loc_db=loc_db) addr_head = 0 asmcfg = mdis.dis_multiblock(addr_head) -lbl_head = mdis.loc_db.get_offset_location(addr_head) +lbl_head = loc_db.get_offset_location(addr_head) -ir_arch_a = ira(mdis.loc_db) +ir_arch_a = ira(loc_db) ircfg = ir_arch_a.new_ircfg_from_asmcfg(asmcfg) open('graph_irflow.dot', 'w').write(ircfg.dot()) diff --git a/example/expression/asm_to_ir.py b/example/expression/asm_to_ir.py index 83eac728..edc23437 100644 --- a/example/expression/asm_to_ir.py +++ b/example/expression/asm_to_ir.py @@ -9,10 +9,13 @@ from miasm.expression.expression import * from miasm.core import asmblock from miasm.arch.x86.ira import ir_a_x86_32 from miasm.analysis.data_flow import DeadRemoval +from miasm.core.locationdb import LocationDB # First, asm code -asmcfg, loc_db = parse_asm.parse_txt(mn_x86, 32, ''' +loc_db = LocationDB() +asmcfg = parse_asm.parse_txt( + mn_x86, 32, ''' main: MOV EAX, 1 MOV EBX, 2 @@ -25,7 +28,9 @@ loop: ADD EAX, ECX JZ loop RET -''') +''', + loc_db +) loc_db.set_location_offset(loc_db.get_name_location("main"), 0x0) diff --git a/example/expression/constant_propagation.py b/example/expression/constant_propagation.py index 36a548c5..a5929eed 100644 --- a/example/expression/constant_propagation.py +++ b/example/expression/constant_propagation.py @@ -12,6 +12,8 @@ from miasm.analysis.cst_propag import propagate_cst_expr from miasm.analysis.data_flow import DeadRemoval, \ merge_blocks, remove_empty_assignblks from miasm.expression.simplifications import expr_simp +from miasm.core.locationdb import LocationDB + parser = ArgumentParser("Constant expression propagation") @@ -25,8 +27,9 @@ args = parser.parse_args() machine = Machine("x86_32") -cont = Container.from_stream(open(args.filename, 'rb')) -mdis = machine.dis_engine(cont.bin_stream, loc_db=cont.loc_db) +loc_db = LocationDB() +cont = Container.from_stream(open(args.filename, 'rb'), loc_db) +mdis = machine.dis_engine(cont.bin_stream, loc_db=loc_db) ir_arch = machine.ira(mdis.loc_db) addr = int(args.address, 0) deadrm = DeadRemoval(ir_arch) diff --git a/example/expression/export_llvm.py b/example/expression/export_llvm.py index 241a907d..a4c65787 100644 --- a/example/expression/export_llvm.py +++ b/example/expression/export_llvm.py @@ -6,18 +6,19 @@ from miasm.analysis.machine import Machine from miasm.jitter.llvmconvert import LLVMType, LLVMContext_IRCompilation, LLVMFunction_IRCompilation from llvmlite import ir as llvm_ir from miasm.expression.simplifications import expr_simp_high_to_explicit +from miasm.core.locationdb import LocationDB parser = ArgumentParser("LLVM export example") parser.add_argument("target", help="Target binary") parser.add_argument("addr", help="Target address") parser.add_argument("--architecture", "-a", help="Force architecture") args = parser.parse_args() - +loc_db = LocationDB() # This part focus on obtaining an IRCFG to transform # -cont = Container.from_stream(open(args.target, 'rb')) +cont = Container.from_stream(open(args.target, 'rb'), loc_db) machine = Machine(args.architecture if args.architecture else cont.arch) -ir = machine.ir(cont.loc_db) -dis = machine.dis_engine(cont.bin_stream, loc_db=cont.loc_db) +ir = machine.ir(loc_db) +dis = machine.dis_engine(cont.bin_stream, loc_db=loc_db) asmcfg = dis.dis_multiblock(int(args.addr, 0)) ircfg = ir.new_ircfg_from_asmcfg(asmcfg) ircfg.simplify(expr_simp_high_to_explicit) diff --git a/example/expression/graph_dataflow.py b/example/expression/graph_dataflow.py index e7386e9e..4b428df7 100644 --- a/example/expression/graph_dataflow.py +++ b/example/expression/graph_dataflow.py @@ -10,6 +10,7 @@ from miasm.analysis.data_analysis import intra_block_flow_raw, inter_block_flow from miasm.core.graph import DiGraph from miasm.ir.symbexec import SymbolicExecutionEngine from miasm.analysis.data_flow import DeadRemoval +from miasm.core.locationdb import LocationDB parser = ArgumentParser("Simple expression use for generating dataflow graph") @@ -126,19 +127,19 @@ def gen_block_data_flow_graph(ir_arch, ircfg, ad, block_flow_cb): ad = int(args.addr, 16) - +loc_db = LocationDB() print('disasm...') -cont = Container.from_stream(open(args.filename, 'rb')) +cont = Container.from_stream(open(args.filename, 'rb'), loc_db) machine = Machine("x86_32") -mdis = machine.dis_engine(cont.bin_stream, loc_db=cont.loc_db) +mdis = machine.dis_engine(cont.bin_stream, loc_db=loc_db) mdis.follow_call = True asmcfg = mdis.dis_multiblock(ad) print('ok') print('generating dataflow graph for:') -ir_arch_analysis = machine.ira(mdis.loc_db) +ir_arch_analysis = machine.ira(loc_db) ircfg = ir_arch_analysis.new_ircfg_from_asmcfg(asmcfg) deadrm = DeadRemoval(ir_arch_analysis) diff --git a/example/expression/solve_condition_stp.py b/example/expression/solve_condition_stp.py index 2c654b77..3743bfad 100644 --- a/example/expression/solve_condition_stp.py +++ b/example/expression/solve_condition_stp.py @@ -15,6 +15,7 @@ from miasm.ir.symbexec import SymbolicExecutionEngine, get_block from miasm.expression.simplifications import expr_simp from miasm.core import parse_asm from miasm.ir.translators.translator import Translator +from miasm.core.locationdb import LocationDB machine = Machine("x86_32") @@ -79,24 +80,26 @@ def emul_symb(ir_arch, ircfg, mdis, states_todo, states_done): if __name__ == '__main__': - + loc_db = LocationDB() translator_smt2 = Translator.to_language("smt2") addr = int(options.address, 16) - cont = Container.from_stream(open(args[0], 'rb')) - mdis = machine.dis_engine(cont.bin_stream, loc_db=cont.loc_db) + cont = Container.from_stream(open(args[0], 'rb'), loc_db) + mdis = machine.dis_engine(cont.bin_stream, loc_db=loc_db) ir_arch = machine.ir(mdis.loc_db) ircfg = ir_arch.new_ircfg() symbexec = SymbolicExecutionEngine(ir_arch) - asmcfg, loc_db = parse_asm.parse_txt(machine.mn, 32, ''' + asmcfg = parse_asm.parse_txt( + machine.mn, 32, ''' init: PUSH argv PUSH argc PUSH ret_addr ''', - loc_db=mdis.loc_db) + loc_db + ) argc_lbl = loc_db.get_name_location('argc') diff --git a/example/jitter/arm.py b/example/jitter/arm.py index daea2428..72fcbc49 100755 --- a/example/jitter/arm.py +++ b/example/jitter/arm.py @@ -5,6 +5,7 @@ import logging from pdb import pm from miasm.analysis.sandbox import Sandbox_Linux_arml +from miasm.core.locationdb import LocationDB # Get arguments parser = Sandbox_Linux_arml.parser(description="""Sandbox an elf binary with arm @@ -14,7 +15,8 @@ parser.add_argument('-v', "--verbose", help="verbose mode", action="store_true") options = parser.parse_args() # Prepare the sandbox -sb = Sandbox_Linux_arml(options.filename, options, globals()) +loc_db = LocationDB() +sb = Sandbox_Linux_arml(loc_db, options.filename, options, globals()) # Handle 'verbose' option if options.verbose is True: diff --git a/example/jitter/arm_sc.py b/example/jitter/arm_sc.py index 9ff770ff..20118429 100755 --- a/example/jitter/arm_sc.py +++ b/example/jitter/arm_sc.py @@ -4,6 +4,7 @@ from miasm.core.utils import int_to_byte from miasm.analysis.sandbox import Sandbox_Linux_armb_str from miasm.analysis.sandbox import Sandbox_Linux_arml_str from miasm.loader.strpatchwork import StrPatchwork +from miasm.core.locationdb import LocationDB from pdb import pm @@ -23,7 +24,8 @@ elif options.endianness == 'l': else: raise ValueError("Bad endianness!") -sb = sandbox(options.filename, options, globals()) +loc_db = LocationDB() +sb = sandbox(loc_db, options.filename, options, globals()) if options.address is None: raise ValueError('invalid address') diff --git a/example/jitter/example_types.py b/example/jitter/example_types.py index 653adaf9..af44c6d8 100755 --- a/example/jitter/example_types.py +++ b/example/jitter/example_types.py @@ -11,6 +11,9 @@ from miasm.analysis.machine import Machine from miasm.core.types import MemStruct, Self, Void, Str, Array, Ptr, \ Num, Array, set_allocator from miasm.os_dep.common import heap +from miasm.core.locationdb import LocationDB + +loc_db = LocationDB() # Instantiate a heap my_heap = heap() @@ -154,7 +157,7 @@ print() # A random jitter # You can also use miasm.jitter.VmMngr.Vm(), but it does not happen in real # life scripts, so here is the usual way: -jitter = Machine("x86_32").jitter("python") +jitter = Machine("x86_32").jitter(loc_db, "python") vm = jitter.vm # Auto-allocated by my_heap. If you allocate memory at `addr`, diff --git a/example/jitter/mips32.py b/example/jitter/mips32.py index 4aeb576f..b84dc4e5 100755 --- a/example/jitter/mips32.py +++ b/example/jitter/mips32.py @@ -5,6 +5,8 @@ from argparse import ArgumentParser from miasm.analysis import debugging from miasm.jitter.csts import * from miasm.analysis.machine import Machine +from miasm.core.locationdb import LocationDB + parser = ArgumentParser( description="""Sandbox raw binary with mips32 engine @@ -34,8 +36,9 @@ def code_sentinelle(jitter): return True def jit_mips32_binary(args): + loc_db = LocationDB() filepath, entryp = args.binary, int(args.addr, 0) - myjit = machine.jitter(jit_type = args.jitter) + myjit = machine.jitter(loc_db, jit_type = args.jitter) myjit.init_stack() # Log level (if available with jitter engine) diff --git a/example/jitter/msp430.py b/example/jitter/msp430.py index 927fb47b..887985ba 100755 --- a/example/jitter/msp430.py +++ b/example/jitter/msp430.py @@ -5,6 +5,7 @@ from argparse import ArgumentParser from miasm.analysis import debugging from miasm.jitter.csts import * from miasm.analysis.machine import Machine +from miasm.core.locationdb import LocationDB parser = ArgumentParser( description="""Sandbox raw binary with msp430 engine @@ -29,8 +30,9 @@ parser.add_argument("addr", machine = Machine("msp430") def jit_msp430_binary(args): + loc_db = LocationDB() filepath, entryp = args.binary, int(args.addr, 0) - myjit = machine.jitter(jit_type = args.jitter) + myjit = machine.jitter(loc_db, jit_type = args.jitter) # Log level (if available with jitter engine) myjit.set_trace_log( diff --git a/example/jitter/run_with_linuxenv.py b/example/jitter/run_with_linuxenv.py index 9b17b172..9290e6a8 100644 --- a/example/jitter/run_with_linuxenv.py +++ b/example/jitter/run_with_linuxenv.py @@ -7,6 +7,7 @@ from miasm.loader import elf as elf_csts from miasm.os_dep.linux import environment, syscall from miasm.analysis.machine import Machine from miasm.analysis.binary import Container +from miasm.core.locationdb import LocationDB parser = ArgumentParser("Run an ELF in a Linux-like environment") parser.add_argument("target", help="Target ELF") @@ -23,8 +24,9 @@ args = parser.parse_args() if args.verbose: syscall.log.setLevel(logging.DEBUG) +loc_db = LocationDB() # Get corresponding interpreter and reloc address -cont_target_tmp = Container.from_stream(open(args.target, 'rb')) +cont_target_tmp = Container.from_stream(open(args.target, 'rb'), loc_db) ld_path = bytes(cont_target_tmp.executable.getsectionbyname(".interp").content).strip(b"\x00") if cont_target_tmp.executable.Ehdr.type in [elf_csts.ET_REL, elf_csts.ET_DYN]: elf_base_addr = 0x40000000 @@ -35,7 +37,7 @@ else: # Instantiate a jitter machine = Machine(cont_target_tmp.arch) -jitter = machine.jitter(args.jitter) +jitter = machine.jitter(loc_db, args.jitter) jitter.init_stack() # Get elements for the target architecture diff --git a/example/jitter/sandbox_call.py b/example/jitter/sandbox_call.py index 7d400b7d..6d24777a 100644 --- a/example/jitter/sandbox_call.py +++ b/example/jitter/sandbox_call.py @@ -5,16 +5,18 @@ from miasm.analysis.sandbox import Sandbox_Linux_arml from miasm.analysis.binary import Container from miasm.os_dep.linux_stdlib import linobjs from miasm.core.utils import hexdump +from miasm.core.locationdb import LocationDB # Parse arguments parser = Sandbox_Linux_arml.parser(description="ELF sandboxer") parser.add_argument("filename", help="ELF Filename") options = parser.parse_args() -sb = Sandbox_Linux_arml(options.filename, options, globals()) +loc_db = LocationDB() +sb = Sandbox_Linux_arml(loc_db, options.filename, options, globals()) with open(options.filename, "rb") as fdesc: - cont = Container.from_stream(fdesc) + cont = Container.from_stream(fdesc, loc_db) loc_key = cont.loc_db.get_name_location("md5_starts") addr_to_call = cont.loc_db.get_location_offset(loc_key) diff --git a/example/jitter/sandbox_elf_aarch64l.py b/example/jitter/sandbox_elf_aarch64l.py index 472b2354..7ad91118 100644 --- a/example/jitter/sandbox_elf_aarch64l.py +++ b/example/jitter/sandbox_elf_aarch64l.py @@ -1,6 +1,7 @@ import logging from pdb import pm from miasm.analysis.sandbox import Sandbox_Linux_aarch64l +from miasm.core.locationdb import LocationDB from miasm.jitter.jitload import log_func # Insert here user defined methods @@ -11,7 +12,8 @@ parser.add_argument("filename", help="ELF Filename") options = parser.parse_args() # Create sandbox -sb = Sandbox_Linux_aarch64l(options.filename, options, globals()) +loc_db = LocationDB() +sb = Sandbox_Linux_aarch64l(loc_db, options.filename, options, globals()) log_func.setLevel(logging.ERROR) diff --git a/example/jitter/sandbox_elf_ppc32.py b/example/jitter/sandbox_elf_ppc32.py index 829381fc..d59181de 100644 --- a/example/jitter/sandbox_elf_ppc32.py +++ b/example/jitter/sandbox_elf_ppc32.py @@ -1,6 +1,7 @@ import os from pdb import pm from miasm.analysis.sandbox import Sandbox_Linux_ppc32b +from miasm.core.locationdb import LocationDB from miasm.jitter.csts import * from miasm.jitter.jitload import log_func import logging @@ -13,7 +14,8 @@ parser.add_argument("filename", help="ELF Filename") options = parser.parse_args() # Create sandbox -sb = Sandbox_Linux_ppc32b(options.filename, options, globals()) +loc_db = LocationDB() +sb = Sandbox_Linux_ppc32b(loc_db, options.filename, options, globals()) log_func.setLevel(logging.ERROR) sb.run() diff --git a/example/jitter/sandbox_pe_x86_32.py b/example/jitter/sandbox_pe_x86_32.py index 263fad94..de7af95d 100644 --- a/example/jitter/sandbox_pe_x86_32.py +++ b/example/jitter/sandbox_pe_x86_32.py @@ -1,6 +1,6 @@ from pdb import pm from miasm.analysis.sandbox import Sandbox_Win_x86_32 - +from miasm.core.locationdb import LocationDB # Insert here user defined methods # Parse arguments @@ -9,7 +9,8 @@ parser.add_argument("filename", help="PE Filename") options = parser.parse_args() # Create sandbox -sb = Sandbox_Win_x86_32(options.filename, options, globals()) +loc_db = LocationDB() +sb = Sandbox_Win_x86_32(loc_db, options.filename, options, globals()) # Run sb.run() diff --git a/example/jitter/sandbox_pe_x86_64.py b/example/jitter/sandbox_pe_x86_64.py index 4d8f00ce..a168c325 100644 --- a/example/jitter/sandbox_pe_x86_64.py +++ b/example/jitter/sandbox_pe_x86_64.py @@ -1,5 +1,6 @@ from pdb import pm from miasm.analysis.sandbox import Sandbox_Win_x86_64 +from miasm.core.locationdb import LocationDB # Insert here user defined methods @@ -9,7 +10,8 @@ parser.add_argument("filename", help="PE Filename") options = parser.parse_args() # Create sandbox -sb = Sandbox_Win_x86_64(options.filename, options, globals()) +loc_db = LocationDB() +sb = Sandbox_Win_x86_64(loc_db, options.filename, options, globals()) # Run sb.run() diff --git a/example/jitter/test_x86_32_seh.py b/example/jitter/test_x86_32_seh.py index d29d3a22..e2c354a0 100644 --- a/example/jitter/test_x86_32_seh.py +++ b/example/jitter/test_x86_32_seh.py @@ -1,6 +1,7 @@ import os from pdb import pm from miasm.analysis.sandbox import Sandbox_Win_x86_32 +from miasm.core.locationdb import LocationDB from miasm.os_dep import win_api_x86_32_seh from miasm.jitter.csts import * @@ -42,7 +43,8 @@ options.usesegm = True options.use_windows_structs = True # Create sandbox -sb = Sandbox_Win_x86_32(options.filename, options, globals()) +loc_db = LocationDB() +sb = Sandbox_Win_x86_32(loc_db, options.filename, options, globals()) # Install Windows SEH callbacks sb.jitter.add_exception_handler(EXCEPT_ACCESS_VIOL, deal_exception_access_violation) diff --git a/example/jitter/trace.py b/example/jitter/trace.py index 46b313c1..968626f4 100644 --- a/example/jitter/trace.py +++ b/example/jitter/trace.py @@ -14,6 +14,7 @@ from pdb import pm from miasm.analysis.sandbox import Sandbox_Linux_arml from miasm.jitter.emulatedsymbexec import EmulatedSymbExec from miasm.jitter.jitcore_python import JitCore_Python +from miasm.core.locationdb import LocationDB # Function called at each instruction instr_count = 0 @@ -45,7 +46,8 @@ JitCore_Python.SymbExecClass = ESETrackMemory # Create sandbox, forcing Python jitter options.jitter = "python" -sb = Sandbox_Linux_arml(options.filename, options, globals()) +loc_db = LocationDB() +sb = Sandbox_Linux_arml(loc_db, options.filename, options, globals()) # Force jit one instr per call, and register our callback sb.jitter.jit.set_options(jit_maxline=1, max_exec_per_call=1) diff --git a/example/jitter/unpack_upx.py b/example/jitter/unpack_upx.py index 2527f0c4..59f7389a 100644 --- a/example/jitter/unpack_upx.py +++ b/example/jitter/unpack_upx.py @@ -3,6 +3,7 @@ import os import logging from miasm.analysis.sandbox import Sandbox_Win_x86_32 from miasm.jitter.loader.pe import vm2pe +from miasm.core.locationdb import LocationDB from miasm.os_dep.common import get_win_str_a @@ -41,8 +42,11 @@ parser.add_argument("--graph", options = parser.parse_args() options.load_hdr = True -sb = Sandbox_Win_x86_32(options.filename, options, globals(), - parse_reloc=False) +loc_db = LocationDB() +sb = Sandbox_Win_x86_32( + loc_db, options.filename, options, globals(), + parse_reloc=False +) if options.verbose is True: @@ -54,7 +58,7 @@ if options.verbose is True: print(sb.jitter.vm) # Ensure there is one and only one leave (for OEP discovering) -mdis = sb.machine.dis_engine(sb.jitter.bs) +mdis = sb.machine.dis_engine(sb.jitter.bs, loc_db=loc_db) mdis.dont_dis_nulstart_bloc = True asmcfg = mdis.dis_multiblock(sb.entry_point) diff --git a/example/jitter/x86_32.py b/example/jitter/x86_32.py index cee9241a..427cd021 100644 --- a/example/jitter/x86_32.py +++ b/example/jitter/x86_32.py @@ -1,6 +1,7 @@ from argparse import ArgumentParser from miasm.jitter.csts import PAGE_READ, PAGE_WRITE from miasm.analysis.machine import Machine +from miasm.core.locationdb import LocationDB from pdb import pm @@ -16,8 +17,9 @@ def code_sentinelle(jitter): jitter.pc = 0 return True +loc_db = LocationDB() -myjit = Machine("x86_32").jitter(args.jitter) +myjit = Machine("x86_32").jitter(loc_db, args.jitter) myjit.init_stack() data = open(args.filename, 'rb').read() diff --git a/example/jitter/x86_64.py b/example/jitter/x86_64.py index 78d88c18..943f5624 100644 --- a/example/jitter/x86_64.py +++ b/example/jitter/x86_64.py @@ -2,6 +2,7 @@ from argparse import ArgumentParser from pdb import pm from miasm.jitter.csts import PAGE_READ, PAGE_WRITE, EXCEPT_SYSCALL from miasm.analysis.machine import Machine +from miasm.core.locationdb import LocationDB # Some syscalls often used by shellcodes @@ -76,8 +77,9 @@ if __name__ == "__main__": parser.add_argument("--verbose", "-v", action="store_true", help="Verbose mode") args = parser.parse_args() + loc_db = LocationDB() - myjit = Machine("x86_64").jitter(args.jitter) + myjit = Machine("x86_64").jitter(loc_db, args.jitter) myjit.init_stack() with open(args.filename, 'rb') as f: diff --git a/example/symbol_exec/depgraph.py b/example/symbol_exec/depgraph.py index c7b9017f..8285452e 100644 --- a/example/symbol_exec/depgraph.py +++ b/example/symbol_exec/depgraph.py @@ -10,6 +10,7 @@ from miasm.analysis.machine import Machine from miasm.analysis.binary import Container from miasm.analysis.depgraph import DependencyGraph from miasm.expression.expression import ExprMem, ExprId, ExprInt +from miasm.core.locationdb import LocationDB parser = ArgumentParser("Dependency grapher") parser.add_argument("filename", help="Binary to analyse") @@ -33,10 +34,10 @@ parser.add_argument("--json", help="Output solution in JSON", action="store_true") args = parser.parse_args() - +loc_db = LocationDB() # Get architecture with open(args.filename, "rb") as fstream: - cont = Container.from_stream(fstream) + cont = Container.from_stream(fstream, loc_db) arch = args.architecture if args.architecture else cont.arch machine = Machine(arch) @@ -50,8 +51,8 @@ for element in args.element: except KeyError: raise ValueError("Unknown element '%s'" % element) -mdis = machine.dis_engine(cont.bin_stream, dont_dis_nulstart_bloc=True) -ir_arch = machine.ira(mdis.loc_db) +mdis = machine.dis_engine(cont.bin_stream, dont_dis_nulstart_bloc=True, loc_db=loc_db) +ir_arch = machine.ira(loc_db) # Common argument forms init_ctx = {} diff --git a/example/symbol_exec/dse_crackme.py b/example/symbol_exec/dse_crackme.py index 82a7af08..e014ada2 100644 --- a/example/symbol_exec/dse_crackme.py +++ b/example/symbol_exec/dse_crackme.py @@ -21,6 +21,7 @@ from miasm.jitter.csts import PAGE_READ, PAGE_WRITE from miasm.analysis.sandbox import Sandbox_Linux_x86_64 from miasm.expression.expression import * from miasm.os_dep.win_api_x86_32 import get_win_str_a +from miasm.core.locationdb import LocationDB is_win = platform.system() == "Windows" @@ -75,7 +76,8 @@ parser.add_argument("--strategy", options = parser.parse_args() options.mimic_env = True options.command_line = ["%s" % TEMP_FILE.name] -sb = Sandbox_Linux_x86_64(options.filename, options, globals()) +loc_db = LocationDB() +sb = Sandbox_Linux_x86_64(loc_db, options.filename, options, globals()) # Init segment sb.jitter.ir_arch.do_stk_segm = True @@ -238,7 +240,7 @@ strategy = { "branch-cov": DSEPathConstraint.PRODUCE_SOLUTION_BRANCH_COV, "path-cov": DSEPathConstraint.PRODUCE_SOLUTION_PATH_COV, }[options.strategy] -dse = DSEPathConstraint(machine, produce_solution=strategy) +dse = DSEPathConstraint(machine, loc_db, produce_solution=strategy) # Attach to the jitter dse.attach(sb.jitter) diff --git a/example/symbol_exec/dse_strategies.py b/example/symbol_exec/dse_strategies.py index 3f968215..bcea2329 100644 --- a/example/symbol_exec/dse_strategies.py +++ b/example/symbol_exec/dse_strategies.py @@ -26,6 +26,7 @@ from miasm.analysis.machine import Machine from miasm.jitter.csts import PAGE_READ, PAGE_WRITE from miasm.analysis.dse import DSEPathConstraint from miasm.expression.expression import ExprMem, ExprId, ExprInt, ExprAssign +from miasm.core.locationdb import LocationDB # Argument handling parser = ArgumentParser("DSE Example") @@ -41,10 +42,12 @@ strategy = { "path-cov": DSEPathConstraint.PRODUCE_SOLUTION_PATH_COV, }[args.strategy] +loc_db = LocationDB() + # Map the shellcode run_addr = 0x40000 machine = Machine("x86_32") -jitter = machine.jitter("python") +jitter = machine.jitter(loc_db, "python") with open(args.filename, "rb") as fdesc: jitter.vm.add_memory_page( run_addr, @@ -72,7 +75,7 @@ jitter.push_uint32_t(ret_addr) jitter.init_run(run_addr) # Init a DSE instance with a given strategy -dse = DSEPathConstraint(machine, produce_solution=strategy) +dse = DSEPathConstraint(machine, loc_db, produce_solution=strategy) dse.attach(jitter) # Concretize everything except the argument dse.update_state_from_concrete() -- cgit 1.4.1 From 6f5cb3bef180400001541f56f704f77da0d73429 Mon Sep 17 00:00:00 2001 From: Fabrice Desclaux Date: Wed, 26 Aug 2020 06:57:39 +0200 Subject: IRBlock take loc_db --- example/ida/depgraph.py | 2 +- example/ida/graph_ir.py | 4 +-- miasm/analysis/cst_propag.py | 2 +- miasm/analysis/data_flow.py | 20 +++++++------- miasm/analysis/depgraph.py | 4 +-- miasm/analysis/outofssa.py | 8 +++--- miasm/analysis/ssa.py | 12 ++++----- miasm/arch/aarch64/sem.py | 8 +++--- miasm/arch/arm/sem.py | 22 ++++++++-------- miasm/arch/mips32/ira.py | 4 +-- miasm/arch/mips32/jit.py | 2 +- miasm/arch/mips32/sem.py | 4 +-- miasm/arch/ppc/sem.py | 4 +-- miasm/arch/x86/sem.py | 62 ++++++++++++++++++++++---------------------- miasm/core/sembuilder.py | 10 +++++-- miasm/ir/ir.py | 24 ++++++++++------- miasm/jitter/codegen.py | 2 +- test/analysis/data_flow.py | 2 +- test/analysis/depgraph.py | 2 +- test/analysis/unssa.py | 4 +-- test/ir/reduce_graph.py | 2 +- 21 files changed, 107 insertions(+), 97 deletions(-) (limited to 'example') diff --git a/example/ida/depgraph.py b/example/ida/depgraph.py index d607fe96..65b57e89 100644 --- a/example/ida/depgraph.py +++ b/example/ida/depgraph.py @@ -254,7 +254,7 @@ def launch_depgraph(): dst, src = expr_simp(dst), expr_simp(src) new_assignblk[dst] = src irs.append(AssignBlock(new_assignblk, instr=assignblk.instr)) - ircfg.blocks[irb.loc_key] = IRBlock(irb.loc_key, irs) + ircfg.blocks[irb.loc_key] = IRBlock(irb.loc_db, irb.loc_key, irs) # Get dependency graphs dg = settings.depgraph diff --git a/example/ida/graph_ir.py b/example/ida/graph_ir.py index dee4e281..29f91efa 100644 --- a/example/ida/graph_ir.py +++ b/example/ida/graph_ir.py @@ -239,7 +239,7 @@ def build_graph(start_addr, type_graph, simplify=False, dontmodstack=True, loadi for dst, src in viewitems(assignblk) } irs.append(AssignBlock(new_assignblk, instr=assignblk.instr)) - ircfg.blocks[irb.loc_key] = IRBlock(irb.loc_key, irs) + ircfg.blocks[irb.loc_key] = IRBlock(irb.loc_db, irb.loc_key, irs) if verbose: out = ircfg.dot() @@ -286,7 +286,7 @@ def build_graph(start_addr, type_graph, simplify=False, dontmodstack=True, loadi assignblks = list(irblock) new_assiblk = AssignBlock(regs, assignblks[-1].instr) assignblks.append(new_assiblk) - new_irblock = IRBlock(irblock.loc_key, assignblks) + new_irblock = IRBlock(irblock.loc_db, irblock.loc_key, assignblks) ircfg.blocks[loc] = new_irblock diff --git a/miasm/analysis/cst_propag.py b/miasm/analysis/cst_propag.py index 4b040763..ba9b3aee 100644 --- a/miasm/analysis/cst_propag.py +++ b/miasm/analysis/cst_propag.py @@ -113,7 +113,7 @@ class SymbExecStateFix(SymbolicExecutionEngine): self.eval_updt_assignblk(assignblk) assignblks.append(AssignBlock(new_assignblk, assignblk.instr)) - self.ircfg.blocks[irb.loc_key] = IRBlock(irb.loc_key, assignblks) + self.ircfg.blocks[irb.loc_key] = IRBlock(irb.loc_db, irb.loc_key, assignblks) def compute_cst_propagation_states(ir_arch, ircfg, init_addr, init_infos): diff --git a/miasm/analysis/data_flow.py b/miasm/analysis/data_flow.py index 7340c023..49384a8b 100644 --- a/miasm/analysis/data_flow.py +++ b/miasm/analysis/data_flow.py @@ -387,7 +387,7 @@ class DeadRemoval(object): del new_assignblk[lval] modified = True irs.append(AssignBlock(new_assignblk, assignblk.instr)) - ircfg.blocks[block.loc_key] = IRBlock(block.loc_key, irs) + ircfg.blocks[block.loc_key] = IRBlock(block.loc_db, block.loc_key, irs) return modified def __call__(self, ircfg): @@ -438,7 +438,7 @@ def _do_merge_blocks(ircfg, loc_key, son_loc_key): assignblks.append(AssignBlock(affs, assignblk.instr)) assignblks += ircfg.blocks[son_loc_key].assignblks - new_block = IRBlock(loc_key, assignblks) + new_block = IRBlock(ircfg.loc_db, loc_key, assignblks) ircfg.discard_edge(loc_key, son_loc_key) @@ -564,7 +564,7 @@ def _remove_to_parent(ircfg, loc_key, son_loc_key): ircfg.del_edge(loc_key, son_loc_key) old_irblock = ircfg.blocks[son_loc_key] - new_irblock = IRBlock(loc_key, old_irblock.assignblks) + new_irblock = IRBlock(ircfg.loc_db, loc_key, old_irblock.assignblks) ircfg.blocks[son_loc_key] = new_irblock @@ -657,7 +657,7 @@ def remove_empty_assignblks(ircfg): else: block_modified = True if block_modified: - new_irblock = IRBlock(loc_key, irs) + new_irblock = IRBlock(ircfg.loc_db, loc_key, irs) ircfg.blocks[loc_key] = new_irblock modified = True return modified @@ -909,7 +909,7 @@ def replace_stack_vars(ir_arch_a, ircfg): out = AssignBlock(out, assignblk.instr) assignblks.append(out) - new_block = IRBlock(block.loc_key, assignblks) + new_block = IRBlock(block.loc_db, block.loc_key, assignblks) ircfg.blocks[block.loc_key] = new_block return modified @@ -987,7 +987,7 @@ def load_from_int(ir_arch, bs, is_addr_ro_variable): out[dst] = src_new out = AssignBlock(out, assignblk.instr) assignblks.append(out) - block = IRBlock(block.loc_key, assignblks) + block = IRBlock(block.loc_db, block.loc_key, assignblks) ir_arch.blocks[block.loc_key] = block return modified @@ -1233,7 +1233,7 @@ def discard_phi_sources(ircfg, deleted_vars): assignblk.update(todo) assignblk = AssignBlock(assignblk, assignblks[0].instr) assignblks[0] = assignblk - new_irblock = IRBlock(block.loc_key, assignblks) + new_irblock = IRBlock(block.loc_db, block.loc_key, assignblks) ircfg.blocks[block.loc_key] = new_irblock return True @@ -1312,7 +1312,7 @@ def update_phi_with_deleted_edges(ircfg, edges_to_del): out[dst] = ExprOp('Phi', *to_keep) assignblk = AssignBlock(out, assignblks[0].instr) assignblks[0] = assignblk - new_irblock = IRBlock(loc_dst, assignblks) + new_irblock = IRBlock(block.loc_db, loc_dst, assignblks) blocks[block.loc_key] = new_irblock for loc_key, block in viewitems(blocks): @@ -1490,7 +1490,7 @@ class DelDummyPhi(object): assignblks = list(block) assignblks[0] = AssignBlock(fixed_phis, assignblk.instr) assignblks[1:1] = [AssignBlock({dst: true_value}, assignblk.instr)] - new_irblock = IRBlock(block.loc_key, assignblks) + new_irblock = IRBlock(block.loc_db, block.loc_key, assignblks) ssa.graph.blocks[block.loc_key] = new_irblock return modified @@ -2152,7 +2152,7 @@ class PropagateExpressions(object): if new_assignblk != assignblock: modified = True - new_irblock = IRBlock(irblock.loc_key, new_assignblocks) + new_irblock = IRBlock(irblock.loc_db, irblock.loc_key, new_assignblocks) return new_irblock, modified diff --git a/miasm/analysis/depgraph.py b/miasm/analysis/depgraph.py index 0b370f61..ae853756 100644 --- a/miasm/analysis/depgraph.py +++ b/miasm/analysis/depgraph.py @@ -280,7 +280,7 @@ class DependencyResult(DependencyState): assignmnts[element] = irb[line_nb][element] assignblks.append(AssignBlock(assignmnts)) - return IRBlock(irb.loc_key, assignblks) + return IRBlock(irb.loc_db, irb.loc_key, assignblks) def emul(self, ir_arch, ctx=None, step=False): """Symbolic execution of relevant nodes according to the history @@ -311,7 +311,7 @@ class DependencyResult(DependencyState): loc_db = ir_arch.loc_db temp_loc = loc_db.get_or_create_name_location("Temp") symb_exec = SymbolicExecutionEngine(ir_arch, ctx_init) - symb_exec.eval_updt_irblock(IRBlock(temp_loc, assignblks), step=step) + symb_exec.eval_updt_irblock(IRBlock(loc_db, temp_loc, assignblks), step=step) # Return only inputs values (others could be wrongs) return {element: symb_exec.symbols[element] diff --git a/miasm/analysis/outofssa.py b/miasm/analysis/outofssa.py index c52b3250..2f2b185c 100644 --- a/miasm/analysis/outofssa.py +++ b/miasm/analysis/outofssa.py @@ -73,7 +73,7 @@ class UnSSADiGraph(object): assignblks = list(irblock) assignblks[0] = AssignBlock(parallel_copies, irblock[0].instr) - new_irblock = IRBlock(irblock.loc_key, assignblks) + new_irblock = IRBlock(irblock.loc_db, irblock.loc_key, assignblks) ircfg.blocks[irblock.loc_key] = new_irblock # Insert new_var = src in each Phi's parent, at the end of the block @@ -88,7 +88,7 @@ class UnSSADiGraph(object): parent = ircfg.blocks[parent] assignblks = list(parent) assignblks.append(AssignBlock(parallel_copies, parent[-1].instr)) - new_irblock = IRBlock(parent.loc_key, assignblks) + new_irblock = IRBlock(parent.loc_db, parent.loc_key, assignblks) ircfg.blocks[parent.loc_key] = new_irblock def create_copy_var(self, var): @@ -397,7 +397,7 @@ class UnSSADiGraph(object): continue out[dst] = src assignblks[0] = AssignBlock(out, assignblks[0].instr) - self.ssa.graph.blocks[irblock.loc_key] = IRBlock(irblock.loc_key, assignblks) + self.ssa.graph.blocks[irblock.loc_key] = IRBlock(irblock.loc_db, irblock.loc_key, assignblks) def remove_assign_eq(self): """ @@ -412,4 +412,4 @@ class UnSSADiGraph(object): continue out[dst] = src assignblks[i] = AssignBlock(out, assignblk.instr) - self.ssa.graph.blocks[irblock.loc_key] = IRBlock(irblock.loc_key, assignblks) + self.ssa.graph.blocks[irblock.loc_key] = IRBlock(irblock.loc_db, irblock.loc_key, assignblks) diff --git a/miasm/analysis/ssa.py b/miasm/analysis/ssa.py index 7f0b0f13..b9af1033 100644 --- a/miasm/analysis/ssa.py +++ b/miasm/analysis/ssa.py @@ -28,7 +28,7 @@ def sanitize_graph_head(ircfg, head): lambda expr:expr.replace_expr(replaced_expr) ) # Duplicate head block - ircfg.add_irblock(IRBlock(sub_head, list(ircfg.blocks[head]))) + ircfg.add_irblock(IRBlock(ircfg.loc_db, sub_head, list(ircfg.blocks[head]))) # Remove original head block ircfg.del_node(head) @@ -38,7 +38,7 @@ def sanitize_graph_head(ircfg, head): # Create new head, jumping to sub_head assignblk = AssignBlock({ircfg.IRDst:ExprLoc(sub_head, ircfg.IRDst.size)}) - new_irblock = IRBlock(head, [assignblk]) + new_irblock = IRBlock(ircfg.loc_db, head, [assignblk]) ircfg.add_irblock(new_irblock) @@ -246,7 +246,7 @@ class SSA(object): instructions.append(next(ssa_iter)) # replace instructions of assignblock in IRBlock new_irs.append(AssignBlock(instructions, assignblk.instr)) - return IRBlock(irblock.loc_key, new_irs) + return IRBlock(irblock.loc_db, irblock.loc_key, new_irs) def _rename_expressions(self, loc_key): """ @@ -614,10 +614,10 @@ class SSADiGraph(SSA): out = dict(assignblks[0]) out.update(dict(assignblk)) assignblks[0] = AssignBlock(out, assignblk.instr) - new_irblock = IRBlock(loc_key, assignblks) + new_irblock = IRBlock(self.ircfg.loc_db, loc_key, assignblks) else: # insert at the beginning - new_irblock = IRBlock(loc_key, [assignblk] + list(irblock.assignblks)) + new_irblock = IRBlock(self.ircfg.loc_db, loc_key, [assignblk] + list(irblock.assignblks)) self.ircfg.blocks[loc_key] = new_irblock def _fix_no_def_var(self, head): @@ -646,7 +646,7 @@ class SSADiGraph(SSA): irblock = self.ircfg.blocks[head] assignblks = list(irblock) assignblks[0:0] = [AssignBlock(newname_to_var, assignblks[0].instr)] - self.ircfg.blocks[head] = IRBlock(head, assignblks) + self.ircfg.blocks[head] = IRBlock(self.ircfg.loc_db, head, assignblks) # Updt structure for loc_key in self._phinodes: diff --git a/miasm/arch/aarch64/sem.py b/miasm/arch/aarch64/sem.py index 915cd02e..e77df911 100644 --- a/miasm/arch/aarch64/sem.py +++ b/miasm/arch/aarch64/sem.py @@ -2065,13 +2065,13 @@ def casp(ir, instr, arg1, arg2, arg3): e_store = [] e_store.append(ExprAssign(data, new_value)) e_store.append(ExprAssign(ir.IRDst, loc_do)) - blk_store = IRBlock(loc_store.loc_key, [AssignBlock(e_store, instr)]) + blk_store = IRBlock(ir.loc_db, loc_store.loc_key, [AssignBlock(e_store, instr)]) e_do = [] e_do.append(ExprAssign(regs[index1], data[:data.size // 2])) e_do.append(ExprAssign(regs[index1 + 1], data[data.size // 2:])) e_do.append(ExprAssign(ir.IRDst, loc_next)) - blk_do = IRBlock(loc_do.loc_key, [AssignBlock(e_do, instr)]) + blk_do = IRBlock(ir.loc_db, loc_do.loc_key, [AssignBlock(e_do, instr)]) return e, [blk_store, blk_do] @@ -2274,7 +2274,7 @@ class ir_aarch64l(IntermediateRepresentation): src = self.expr_fix_regs_for_mode(src) new_assignblk[dst] = src irs.append(AssignBlock(new_assignblk, assignblk.instr)) - return IRBlock(irblock.loc_key, irs) + return IRBlock(self.loc_db, irblock.loc_key, irs) def mod_pc(self, instr, instr_ir, extra_ir): "Replace PC by the instruction's offset" @@ -2307,7 +2307,7 @@ class ir_aarch64l(IntermediateRepresentation): if dst not in regs_to_fix } irs.append(AssignBlock(new_dsts, assignblk.instr)) - new_irblocks.append(IRBlock(irblock.loc_key, irs)) + new_irblocks.append(IRBlock(self.loc_db, irblock.loc_key, irs)) return instr_ir, new_irblocks diff --git a/miasm/arch/arm/sem.py b/miasm/arch/arm/sem.py index 027c3a6a..1884abe8 100644 --- a/miasm/arch/arm/sem.py +++ b/miasm/arch/arm/sem.py @@ -804,7 +804,7 @@ def sdiv(ir, instr, a, b, c=None): do_except = [] do_except.append(ExprAssign(exception_flags, ExprInt(EXCEPT_DIV_BY_ZERO, exception_flags.size))) do_except.append(ExprAssign(ir.IRDst, loc_next)) - blk_except = IRBlock(loc_except.loc_key, [AssignBlock(do_except, instr)]) + blk_except = IRBlock(ir.loc_db, loc_except.loc_key, [AssignBlock(do_except, instr)]) @@ -816,7 +816,7 @@ def sdiv(ir, instr, a, b, c=None): do_div.append(ExprAssign(ir.IRDst, r)) do_div.append(ExprAssign(ir.IRDst, loc_next)) - blk_div = IRBlock(loc_div.loc_key, [AssignBlock(do_div, instr)]) + blk_div = IRBlock(ir.loc_db, loc_div.loc_key, [AssignBlock(do_div, instr)]) return e, [blk_div, blk_except] @@ -837,7 +837,7 @@ def udiv(ir, instr, a, b, c=None): do_except = [] do_except.append(ExprAssign(exception_flags, ExprInt(EXCEPT_DIV_BY_ZERO, exception_flags.size))) do_except.append(ExprAssign(ir.IRDst, loc_next)) - blk_except = IRBlock(loc_except.loc_key, [AssignBlock(do_except, instr)]) + blk_except = IRBlock(ir.loc_db, loc_except.loc_key, [AssignBlock(do_except, instr)]) r = ExprOp("udiv", b, c) @@ -848,7 +848,7 @@ def udiv(ir, instr, a, b, c=None): do_div.append(ExprAssign(ir.IRDst, r)) do_div.append(ExprAssign(ir.IRDst, loc_next)) - blk_div = IRBlock(loc_div.loc_key, [AssignBlock(do_div, instr)]) + blk_div = IRBlock(ir.loc_db, loc_div.loc_key, [AssignBlock(do_div, instr)]) return e, [blk_div, blk_except] @@ -1723,7 +1723,7 @@ def add_condition_expr(ir, instr, cond, instr_ir, extra_ir): break if not has_irdst: instr_ir.append(ExprAssign(ir.IRDst, loc_next_expr)) - e_do = IRBlock(loc_do, [AssignBlock(instr_ir, instr)]) + e_do = IRBlock(ir.loc_db, loc_do, [AssignBlock(instr_ir, instr)]) e = [ExprAssign(ir.IRDst, dst_cond)] return e, [e_do] + extra_ir @@ -2004,7 +2004,7 @@ class ir_arml(IntermediateRepresentation): dst = ExprAssign(self.IRDst, ExprLoc(loc_next, 32)) dst_blk = AssignBlock([dst], instr) assignments.append(dst_blk) - irblock = IRBlock(loc, assignments) + irblock = IRBlock(self.loc_db, loc, assignments) ir_blocks_all.append([irblock]) loc = loc_next @@ -2025,7 +2025,7 @@ class ir_arml(IntermediateRepresentation): dst = ExprAssign(self.IRDst, ExprCond(local_cond, ExprLoc(loc_do, 32), ExprLoc(loc_next, 32))) dst_blk = AssignBlock([dst], instr) assignments.append(dst_blk) - irblock = IRBlock(loc, assignments) + irblock = IRBlock(self.loc_db, loc, assignments) irblocks.append(irblock) @@ -2070,7 +2070,7 @@ class ir_arml(IntermediateRepresentation): assignment.instr ) out.append(assignment) - new_irblock = IRBlock(irblock.loc_key, out) + new_irblock = IRBlock(self.loc_db, irblock.loc_key, out) new_irblocks.append(new_irblock) it_instr_irblocks = new_irblocks @@ -2078,7 +2078,7 @@ class ir_arml(IntermediateRepresentation): dst = ExprAssign(self.IRDst, ExprLoc(loc_next, 32)) dst_blk = AssignBlock([dst], instr) assignments.append(dst_blk) - irblock = IRBlock(loc, assignments) + irblock = IRBlock(self.loc_db, loc, assignments) irblocks.append(irblock) loc = loc_next assignments = [] @@ -2116,11 +2116,11 @@ class ir_arml(IntermediateRepresentation): ir_blocks_all, gen_pc_updt ) if split: - ir_blocks_all.append(IRBlock(label, assignments)) + ir_blocks_all.append(IRBlock(self.loc_db, label, assignments)) label = None assignments = [] if label is not None: - ir_blocks_all.append(IRBlock(label, assignments)) + ir_blocks_all.append(IRBlock(self.loc_db, label, assignments)) new_ir_blocks_all = self.post_add_asmblock_to_ircfg(block, ircfg, ir_blocks_all) for irblock in new_ir_blocks_all: diff --git a/miasm/arch/mips32/ira.py b/miasm/arch/mips32/ira.py index 04a51c6c..e7b5d7f2 100644 --- a/miasm/arch/mips32/ira.py +++ b/miasm/arch/mips32/ira.py @@ -67,11 +67,11 @@ class ir_a_mips32l(ir_mips32l, ira): ir_blocks_all, gen_pc_updt ) if split: - ir_blocks_all.append(IRBlock(loc_key, assignments)) + ir_blocks_all.append(IRBlock(self.loc_db, loc_key, assignments)) loc_key = None assignments = [] if loc_key is not None: - ir_blocks_all.append(IRBlock(loc_key, assignments)) + ir_blocks_all.append(IRBlock(self.loc_db, loc_key, assignments)) new_ir_blocks_all = self.post_add_asmblock_to_ircfg(block, ircfg, ir_blocks_all) for irblock in new_ir_blocks_all: diff --git a/miasm/arch/mips32/jit.py b/miasm/arch/mips32/jit.py index 1c2c182e..d8bd8c66 100644 --- a/miasm/arch/mips32/jit.py +++ b/miasm/arch/mips32/jit.py @@ -61,7 +61,7 @@ class mipsCGen(CGen): dst_loc_key = self.ir_arch.get_next_instr(assignblock.instr) assignments[self.ir_arch.IRDst] = m2_expr.ExprLoc(dst_loc_key, 32) irs.append(AssignBlock(assignments, assignblock.instr)) - irblocks[blk_idx] = IRBlock(irblock.loc_key, irs) + irblocks[blk_idx] = IRBlock(irblock.loc_db, irblock.loc_key, irs) return irblocks_list diff --git a/miasm/arch/mips32/sem.py b/miasm/arch/mips32/sem.py index 23684a8d..b4252486 100644 --- a/miasm/arch/mips32/sem.py +++ b/miasm/arch/mips32/sem.py @@ -538,7 +538,7 @@ def teq(ir, instr, arg1, arg2): do_except.append(m2_expr.ExprAssign(exception_flags, m2_expr.ExprInt( EXCEPT_DIV_BY_ZERO, exception_flags.size))) do_except.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr)) - blk_except = IRBlock(loc_except, [AssignBlock(do_except, instr)]) + blk_except = IRBlock(ir.loc_db, loc_except, [AssignBlock(do_except, instr)]) cond = arg1 - arg2 @@ -560,7 +560,7 @@ def tne(ir, instr, arg1, arg2): do_except.append(m2_expr.ExprAssign(exception_flags, m2_expr.ExprInt( EXCEPT_DIV_BY_ZERO, exception_flags.size))) do_except.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr)) - blk_except = IRBlock(loc_except, [AssignBlock(do_except, instr)]) + blk_except = IRBlock(ir.loc_db, loc_except, [AssignBlock(do_except, instr)]) cond = arg1 ^ arg2 diff --git a/miasm/arch/ppc/sem.py b/miasm/arch/ppc/sem.py index 7ca7e3e1..26b3d84b 100644 --- a/miasm/arch/ppc/sem.py +++ b/miasm/arch/ppc/sem.py @@ -675,8 +675,8 @@ def mn_do_store(ir, instr, arg1, arg2, arg3=None): ret.append(ExprAssign(ir.IRDst, loc_next)) dont = flags + [ ExprAssign(CR0_EQ, ExprInt(0,1)), ExprAssign(ir.IRDst, loc_next) ] - additional_ir = [ IRBlock(loc_do.loc_key, [ AssignBlock(ret) ]), - IRBlock(loc_dont.loc_key, [ AssignBlock(dont) ]) ] + additional_ir = [ IRBlock(ir.loc_db, loc_do.loc_key, [ AssignBlock(ret) ]), + IRBlock(ir.loc_db, loc_dont.loc_key, [ AssignBlock(dont) ]) ] ret = [ ExprAssign(reserve, ExprInt(0, 1)), ExprAssign(ir.IRDst, ExprCond(reserve, loc_do, loc_dont)) ] diff --git a/miasm/arch/x86/sem.py b/miasm/arch/x86/sem.py index cf58079c..723272d5 100644 --- a/miasm/arch/x86/sem.py +++ b/miasm/arch/x86/sem.py @@ -386,7 +386,7 @@ def gen_fcmov(ir, instr, cond, arg1, arg2, mov_if): e_do, extra_irs = [m2_expr.ExprAssign(arg1, arg2)], [] e_do.append(m2_expr.ExprAssign(ir.IRDst, loc_skip_expr)) e.append(m2_expr.ExprAssign(ir.IRDst, m2_expr.ExprCond(cond, dstA, dstB))) - return e, [IRBlock(loc_do, [AssignBlock(e_do, instr)])] + return e, [IRBlock(ir.loc_db, loc_do, [AssignBlock(e_do, instr)])] def gen_cmov(ir, instr, cond, dst, src, mov_if): @@ -408,7 +408,7 @@ def gen_cmov(ir, instr, cond, dst, src, mov_if): e_do.append(m2_expr.ExprAssign(ir.IRDst, loc_skip_expr)) e.append(m2_expr.ExprAssign(ir.IRDst, m2_expr.ExprCond(cond, dstA, dstB))) e += set_float_cs_eip(instr) - return e, [IRBlock(loc_do, [AssignBlock(e_do, instr)])] + return e, [IRBlock(ir.loc_db, loc_do, [AssignBlock(e_do, instr)])] def mov(_, instr, dst, src): @@ -655,7 +655,7 @@ def _rotate_tpl(ir, instr, dst, src, op, left=False): e_do.append(m2_expr.ExprAssign(ir.IRDst, loc_skip_expr)) e.append(m2_expr.ExprAssign( ir.IRDst, m2_expr.ExprCond(shifter, loc_do_expr, loc_skip_expr))) - return (e, [IRBlock(loc_do, [AssignBlock(e_do, instr)])]) + return (e, [IRBlock(ir.loc_db, loc_do, [AssignBlock(e_do, instr)])]) def l_rol(ir, instr, dst, src): @@ -703,7 +703,7 @@ def rotate_with_carry_tpl(ir, instr, op, dst, src): e_do.append(m2_expr.ExprAssign(ir.IRDst, loc_skip_expr)) e.append(m2_expr.ExprAssign( ir.IRDst, m2_expr.ExprCond(shifter, loc_do_expr, loc_skip_expr))) - return (e, [IRBlock(loc_do, [AssignBlock(e_do, instr)])]) + return (e, [IRBlock(ir.loc_db, loc_do, [AssignBlock(e_do, instr)])]) def rcl(ir, instr, dst, src): return rotate_with_carry_tpl(ir, instr, '<<<', dst, src) @@ -789,7 +789,7 @@ def _shift_tpl(op, ir, instr, a, b, c=None, op_inv=None, left=False, e_do.append(m2_expr.ExprAssign(ir.IRDst, loc_skip_expr)) e.append(m2_expr.ExprAssign(ir.IRDst, m2_expr.ExprCond(shifter, loc_do_expr, loc_skip_expr))) - return e, [IRBlock(loc_do, [AssignBlock(e_do, instr)])] + return e, [IRBlock(ir.loc_db, loc_do, [AssignBlock(e_do, instr)])] def sar(ir, instr, dst, src): @@ -1206,13 +1206,13 @@ def cmps(ir, instr, size): e0.append(m2_expr.ExprAssign(src1, src1 + offset)) e0.append(m2_expr.ExprAssign(src2, src2 + offset)) e0.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr)) - e0 = IRBlock(loc_df_0, [AssignBlock(e0, instr)]) + e0 = IRBlock(ir.loc_db, loc_df_0, [AssignBlock(e0, instr)]) e1 = [] e1.append(m2_expr.ExprAssign(src1, src1 - offset)) e1.append(m2_expr.ExprAssign(src2, src2 - offset)) e1.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr)) - e1 = IRBlock(loc_df_1, [AssignBlock(e1, instr)]) + e1 = IRBlock(ir.loc_db, loc_df_1, [AssignBlock(e1, instr)]) e.append(m2_expr.ExprAssign(ir.IRDst, m2_expr.ExprCond(df, loc_df_1_expr, loc_df_0_expr))) @@ -1243,12 +1243,12 @@ def scas(ir, instr, size): e0.append(m2_expr.ExprAssign(src, src + offset)) e0.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr)) - e0 = IRBlock(loc_df_0, [AssignBlock(e0, instr)]) + e0 = IRBlock(ir.loc_db, loc_df_0, [AssignBlock(e0, instr)]) e1 = [] e1.append(m2_expr.ExprAssign(src, src - offset)) e1.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr)) - e1 = IRBlock(loc_df_1, [AssignBlock(e1, instr)]) + e1 = IRBlock(ir.loc_db, loc_df_1, [AssignBlock(e1, instr)]) e.append(m2_expr.ExprAssign(ir.IRDst, m2_expr.ExprCond(df, loc_df_1_expr, loc_df_0_expr))) @@ -1733,13 +1733,13 @@ def div(ir, instr, src1): do_div = [] do_div += e do_div.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr)) - blk_div = IRBlock(loc_div, [AssignBlock(do_div, instr)]) + blk_div = IRBlock(ir.loc_db, loc_div, [AssignBlock(do_div, instr)]) do_except = [] do_except.append(m2_expr.ExprAssign(exception_flags, m2_expr.ExprInt( EXCEPT_DIV_BY_ZERO, exception_flags.size))) do_except.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr)) - blk_except = IRBlock(loc_except, [AssignBlock(do_except, instr)]) + blk_except = IRBlock(ir.loc_db, loc_except, [AssignBlock(do_except, instr)]) e = [] e.append(m2_expr.ExprAssign(ir.IRDst, @@ -1780,13 +1780,13 @@ def idiv(ir, instr, src1): do_div = [] do_div += e do_div.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr)) - blk_div = IRBlock(loc_div, [AssignBlock(do_div, instr)]) + blk_div = IRBlock(ir.loc_db, loc_div, [AssignBlock(do_div, instr)]) do_except = [] do_except.append(m2_expr.ExprAssign(exception_flags, m2_expr.ExprInt( EXCEPT_DIV_BY_ZERO, exception_flags.size))) do_except.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr)) - blk_except = IRBlock(loc_except, [AssignBlock(do_except, instr)]) + blk_except = IRBlock(ir.loc_db, loc_except, [AssignBlock(do_except, instr)]) e = [] e.append(m2_expr.ExprAssign(ir.IRDst, @@ -1952,12 +1952,12 @@ def stos(ir, instr, size): e0 = [] e0.append(m2_expr.ExprAssign(addr_o, addr_p)) e0.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr)) - e0 = IRBlock(loc_df_0, [AssignBlock(e0, instr)]) + e0 = IRBlock(ir.loc_db, loc_df_0, [AssignBlock(e0, instr)]) e1 = [] e1.append(m2_expr.ExprAssign(addr_o, addr_m)) e1.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr)) - e1 = IRBlock(loc_df_1, [AssignBlock(e1, instr)]) + e1 = IRBlock(ir.loc_db, loc_df_1, [AssignBlock(e1, instr)]) e = [] e.append(m2_expr.ExprAssign(ir.ExprMem(addr, size), b)) @@ -1988,12 +1988,12 @@ def lods(ir, instr, size): e0 = [] e0.append(m2_expr.ExprAssign(addr_o, addr_p)) e0.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr)) - e0 = IRBlock(loc_df_0, [AssignBlock(e0, instr)]) + e0 = IRBlock(ir.loc_db, loc_df_0, [AssignBlock(e0, instr)]) e1 = [] e1.append(m2_expr.ExprAssign(addr_o, addr_m)) e1.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr)) - e1 = IRBlock(loc_df_1, [AssignBlock(e1, instr)]) + e1 = IRBlock(ir.loc_db, loc_df_1, [AssignBlock(e1, instr)]) e = [] if instr.mode == 64 and b.size == 32: @@ -2035,13 +2035,13 @@ def movs(ir, instr, size): e0.append(m2_expr.ExprAssign(src, src + offset)) e0.append(m2_expr.ExprAssign(dst, dst + offset)) e0.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr)) - e0 = IRBlock(loc_df_0, [AssignBlock(e0, instr)]) + e0 = IRBlock(ir.loc_db, loc_df_0, [AssignBlock(e0, instr)]) e1 = [] e1.append(m2_expr.ExprAssign(src, src - offset)) e1.append(m2_expr.ExprAssign(dst, dst - offset)) e1.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr)) - e1 = IRBlock(loc_df_1, [AssignBlock(e1, instr)]) + e1 = IRBlock(ir.loc_db, loc_df_1, [AssignBlock(e1, instr)]) e.append(m2_expr.ExprAssign(ir.IRDst, m2_expr.ExprCond(df, loc_df_1_expr, loc_df_0_expr))) @@ -2198,31 +2198,31 @@ def fxam(ir, instr): base += set_float_cs_eip(instr) out = [ - IRBlock(locs["Zero"][0], [AssignBlock({ + IRBlock(ir.loc_db, locs["Zero"][0], [AssignBlock({ float_c0: m2_expr.ExprInt(0, float_c0.size), float_c2: m2_expr.ExprInt(0, float_c2.size), float_c3: m2_expr.ExprInt(1, float_c3.size), ir.IRDst: loc_next_expr, }, instr)]), - IRBlock(locs["Denormal"][0], [AssignBlock({ + IRBlock(ir.loc_db, locs["Denormal"][0], [AssignBlock({ float_c0: m2_expr.ExprInt(0, float_c0.size), float_c2: m2_expr.ExprInt(1, float_c2.size), float_c3: m2_expr.ExprInt(1, float_c3.size), ir.IRDst: loc_next_expr, }, instr)]), - IRBlock(locs["NaN"][0], [AssignBlock({ + IRBlock(ir.loc_db, locs["NaN"][0], [AssignBlock({ float_c0: m2_expr.ExprInt(1, float_c0.size), float_c2: m2_expr.ExprInt(0, float_c2.size), float_c3: m2_expr.ExprInt(0, float_c3.size), ir.IRDst: loc_next_expr, }, instr)]), - IRBlock(locs["Infinity"][0], [AssignBlock({ + IRBlock(ir.loc_db, locs["Infinity"][0], [AssignBlock({ float_c0: m2_expr.ExprInt(1, float_c0.size), float_c2: m2_expr.ExprInt(1, float_c2.size), float_c3: m2_expr.ExprInt(0, float_c3.size), ir.IRDst: loc_next_expr, }, instr)]), - IRBlock(locs["Normal"][0], [AssignBlock({ + IRBlock(ir.loc_db, locs["Normal"][0], [AssignBlock({ float_c0: m2_expr.ExprInt(0, float_c0.size), float_c2: m2_expr.ExprInt(1, float_c2.size), float_c3: m2_expr.ExprInt(0, float_c3.size), @@ -3255,8 +3255,8 @@ def bsr_bsf(ir, instr, dst, src, op_func): e_src_not_null.append(m2_expr.ExprAssign(dst, op_func(src))) e_src_not_null.append(aff_dst) - return e, [IRBlock(loc_src_null, [AssignBlock(e_src_null, instr)]), - IRBlock(loc_src_not_null, [AssignBlock(e_src_not_null, instr)])] + return e, [IRBlock(ir.loc_db, loc_src_null, [AssignBlock(e_src_null, instr)]), + IRBlock(ir.loc_db, loc_src_not_null, [AssignBlock(e_src_not_null, instr)])] def bsf(ir, instr, dst, src): @@ -4963,7 +4963,7 @@ def maskmovq(ir, instr, src, mask): m2_expr.ExprCond(bit, write_label, next_check_label)) - blks.append(IRBlock(cur_label.loc_key, [AssignBlock([check], instr)])) + blks.append(IRBlock(ir.loc_db, cur_label.loc_key, [AssignBlock([check], instr)])) # Build write blocks dst_addr = mRDI[instr.mode] @@ -4976,7 +4976,7 @@ def maskmovq(ir, instr, src, mask): write_mem = m2_expr.ExprAssign(m2_expr.ExprMem(write_addr, 8), src[start: start + 8]) jump = m2_expr.ExprAssign(ir.IRDst, next_check_label) - blks.append(IRBlock(cur_label.loc_key, [AssignBlock([write_mem, jump], instr)])) + blks.append(IRBlock(ir.loc_db, cur_label.loc_key, [AssignBlock([write_mem, jump], instr)])) # If mask is null, bypass all e = [m2_expr.ExprAssign(ir.IRDst, m2_expr.ExprCond(mask, @@ -5837,10 +5837,10 @@ class ir_x86_16(IntermediateRepresentation): cond_bloc.append(m2_expr.ExprAssign(self.IRDst, m2_expr.ExprCond(c_cond, loc_skip_expr, loc_do_expr))) - cond_bloc = IRBlock(loc_end, [AssignBlock(cond_bloc, instr)]) + cond_bloc = IRBlock(self.loc_db, loc_end, [AssignBlock(cond_bloc, instr)]) e_do = instr_ir - c = IRBlock(loc_do, [AssignBlock(e_do, instr)]) + c = IRBlock(self.loc_db, loc_do, [AssignBlock(e_do, instr)]) e_n = [m2_expr.ExprAssign(self.IRDst, m2_expr.ExprCond(c_reg, loc_do_expr, loc_skip_expr))] return e_n, [cond_bloc, c] + new_extra_ir @@ -5871,7 +5871,7 @@ class ir_x86_16(IntermediateRepresentation): src = self.expr_fix_regs_for_mode(src, mode) new_assignblk[dst] = src irs.append(AssignBlock(new_assignblk, assignblk.instr)) - return IRBlock(irblock.loc_key, irs) + return IRBlock(self.loc_db, irblock.loc_key, irs) class ir_x86_32(ir_x86_16): diff --git a/miasm/core/sembuilder.py b/miasm/core/sembuilder.py index efd80ce4..653ac46b 100644 --- a/miasm/core/sembuilder.py +++ b/miasm/core/sembuilder.py @@ -242,6 +242,9 @@ class SemBuilder(object): IRDst = ast.Attribute(value=ast.Name(id='ir', ctx=ast.Load()), attr='IRDst', ctx=ast.Load()) + loc_db = ast.Attribute(value=ast.Name(id='ir', + ctx=ast.Load()), + attr='loc_db', ctx=ast.Load()) blocks[-1][-1].append(ast.Call(func=ast.Name(id='ExprAssign', ctx=ast.Load()), args=[IRDst, dst], @@ -288,8 +291,11 @@ class SemBuilder(object): sub_blocks[-1] = ast.Call(func=ast.Name(id='IRBlock', ctx=ast.Load()), - args=[loc_if_name, - assignblks], + args=[ + loc_db, + loc_if_name, + assignblks + ], keywords=[], starargs=None, kwargs=None) diff --git a/miasm/ir/ir.py b/miasm/ir/ir.py index 1da907ef..00c73d09 100644 --- a/miasm/ir/ir.py +++ b/miasm/ir/ir.py @@ -316,9 +316,9 @@ class IRBlock(object): Stand for an intermediate representation basic block. """ - __slots__ = ["_loc_key", "_assignblks", "_dst", "_dst_linenb"] + __slots__ = ["_loc_db", "_loc_key", "_assignblks", "_dst", "_dst_linenb"] - def __init__(self, loc_key, assignblks): + def __init__(self, loc_db, loc_key, assignblks): """ @loc_key: LocKey of the IR basic block @assignblks: list of AssignBlock @@ -326,6 +326,7 @@ class IRBlock(object): assert isinstance(loc_key, m2_expr.LocKey) self._loc_key = loc_key + self._loc_db = loc_db for assignblk in assignblks: assert isinstance(assignblk, AssignBlock) self._assignblks = tuple(assignblks) @@ -337,6 +338,8 @@ class IRBlock(object): return False if self.loc_key != other.loc_key: return False + if self.loc_db != other.loc_db: + return False if len(self.assignblks) != len(other.assignblks): return False for assignblk1, assignblk2 in zip(self.assignblks, other.assignblks): @@ -352,6 +355,7 @@ class IRBlock(object): return self.loc_key loc_key = property(lambda self:self._loc_key) + loc_db = property(lambda self:self._loc_db) label = property(get_label) @property @@ -413,7 +417,7 @@ class IRBlock(object): else: new_assignblk[dst] = src irs.append(AssignBlock(new_assignblk, assignblk.instr)) - return IRBlock(self.loc_key, irs) + return IRBlock(self.loc_db, self.loc_key, irs) @property def dst_linenb(self): @@ -451,7 +455,7 @@ class IRBlock(object): for dst, src in viewitems(assignblk): new_assignblk[mod_dst(dst)] = mod_src(src) assignblks.append(AssignBlock(new_assignblk, assignblk.instr)) - return IRBlock(self.loc_key, assignblks) + return IRBlock(self.loc_db, self.loc_key, assignblks) def to_string(self, loc_db=None): out = [] @@ -482,7 +486,7 @@ class IRBlock(object): if assignblk != new_assignblk: modified = True assignblks.append(new_assignblk) - return modified, IRBlock(self.loc_key, assignblks) + return modified, IRBlock(self.loc_db, self.loc_key, assignblks) class irbloc(IRBlock): @@ -656,7 +660,7 @@ class IRCFG(DiGraph): if assignblk != new_assignblk: modified = True assignblks.append(new_assignblk) - self.blocks[loc_key] = IRBlock(loc_key, assignblks) + self.blocks[loc_key] = IRBlock(self.loc_db, loc_key, assignblks) return modified def _extract_dst(self, todo, done): @@ -757,7 +761,7 @@ class IntermediateRepresentation(object): irs = [] for assignblk in irb: irs.append(AssignBlock(assignblk, instr)) - extra_irblocks[index] = IRBlock(irb.loc_key, irs) + extra_irblocks[index] = IRBlock(self.loc_db, irb.loc_key, irs) assignblk = AssignBlock(ir_bloc_cur, instr) return assignblk, extra_irblocks @@ -827,11 +831,11 @@ class IntermediateRepresentation(object): ir_blocks_all, gen_pc_updt ) if split: - ir_blocks_all.append(IRBlock(loc_key, assignments)) + ir_blocks_all.append(IRBlock(self.loc_db, loc_key, assignments)) loc_key = None assignments = [] if loc_key is not None: - ir_blocks_all.append(IRBlock(loc_key, assignments)) + ir_blocks_all.append(IRBlock(self.loc_db, loc_key, assignments)) new_ir_blocks_all = self.post_add_asmblock_to_ircfg(block, ircfg, ir_blocks_all) for irblock in new_ir_blocks_all: @@ -915,7 +919,7 @@ class IntermediateRepresentation(object): else: instr = None assignblk = AssignBlock({self.IRDst: dst}, instr) - ir_blocks[index] = IRBlock(irblock.loc_key, list(irblock.assignblks) + [assignblk]) + ir_blocks[index] = IRBlock(self.loc_db, irblock.loc_key, list(irblock.assignblks) + [assignblk]) def post_add_asmblock_to_ircfg(self, block, ircfg, ir_blocks): self.set_empty_dst_to_next(block, ir_blocks) diff --git a/miasm/jitter/codegen.py b/miasm/jitter/codegen.py index 0b5b7961..d05865f2 100644 --- a/miasm/jitter/codegen.py +++ b/miasm/jitter/codegen.py @@ -156,7 +156,7 @@ class CGen(object): dst = ExprLoc(loc_key, self.ir_arch.IRDst.size) new_assignblk[self.ir_arch.IRDst] = dst irs = [AssignBlock(new_assignblk, instr)] - return IRBlock(self.ir_arch.get_loc_key_for_instr(instr), irs) + return IRBlock(self.ir_arch.loc_db, self.ir_arch.get_loc_key_for_instr(instr), irs) def block2assignblks(self, block): """ diff --git a/test/analysis/data_flow.py b/test/analysis/data_flow.py index 98efecbe..47d521bc 100644 --- a/test/analysis/data_flow.py +++ b/test/analysis/data_flow.py @@ -51,7 +51,7 @@ def gen_irblock(label, exprs_list): irs.append(AssignBlock(exprs)) irs.append(AssignBlock({IRDst:dummy})) - irbl = IRBlock(label, irs) + irbl = IRBlock(loc_db, label, irs) return irbl diff --git a/test/analysis/depgraph.py b/test/analysis/depgraph.py index eb6507dc..a458e533 100644 --- a/test/analysis/depgraph.py +++ b/test/analysis/depgraph.py @@ -68,7 +68,7 @@ def gen_irblock(label, exprs_list): else: irs.append(AssignBlock(exprs)) - irbl = IRBlock(label, irs) + irbl = IRBlock(loc_db, label, irs) return irbl diff --git a/test/analysis/unssa.py b/test/analysis/unssa.py index 2bfe9254..5844bfb4 100644 --- a/test/analysis/unssa.py +++ b/test/analysis/unssa.py @@ -56,7 +56,7 @@ def gen_irblock(label, exprs_list): else: irs.append(AssignBlock(exprs)) - irbl = IRBlock(label, irs) + irbl = IRBlock(loc_db, label, irs) return irbl @@ -587,7 +587,7 @@ def add_out_reg_end(ir_arch_a, ircfg_a): assignblks = list(irblock) new_assiblk = AssignBlock(regs, assignblks[-1].instr) assignblks.append(new_assiblk) - new_irblock = IRBlock(irblock.loc_key, assignblks) + new_irblock = IRBlock(loc_db, irblock.loc_key, assignblks) ircfg_a.blocks[loc] = new_irblock diff --git a/test/ir/reduce_graph.py b/test/ir/reduce_graph.py index 8835b4aa..73af4860 100644 --- a/test/ir/reduce_graph.py +++ b/test/ir/reduce_graph.py @@ -95,7 +95,7 @@ def gen_irblock(label, exprs_list): else: irs.append(AssignBlock(exprs)) - irbl = IRBlock(label, irs) + irbl = IRBlock(loc_db, label, irs) return irbl -- cgit 1.4.1 From 24ce193b8bad352853a9c5589f6fdcf5177d5466 Mon Sep 17 00:00:00 2001 From: Fabrice Desclaux Date: Wed, 26 Aug 2020 14:36:46 +0200 Subject: Update api according to loc_db update --- README.md | 10 ++--- example/asm/shellcode.py | 1 - example/asm/simple.py | 2 +- example/expression/asm_to_ir.py | 2 +- miasm/analysis/data_flow.py | 15 +++----- miasm/arch/aarch64/ira.py | 8 ++-- miasm/arch/aarch64/sem.py | 4 +- miasm/arch/arm/ira.py | 12 +++--- miasm/arch/arm/sem.py | 8 ++-- miasm/arch/mep/ira.py | 4 +- miasm/arch/mep/sem.py | 4 +- miasm/arch/mips32/ira.py | 4 +- miasm/arch/mips32/sem.py | 4 +- miasm/arch/msp430/ira.py | 4 +- miasm/arch/msp430/sem.py | 2 +- miasm/arch/ppc/ira.py | 4 +- miasm/arch/ppc/sem.py | 2 +- miasm/arch/x86/ira.py | 6 +-- miasm/arch/x86/sem.py | 6 +-- miasm/core/asmblock.py | 69 +++++++++++++++-------------------- miasm/ir/ir.py | 40 +++++++------------- miasm/jitter/jitcore.py | 2 +- test/analysis/data_flow.py | 2 +- test/analysis/depgraph.py | 2 +- test/analysis/dse.py | 6 +-- test/arch/aarch64/unit/asm_test.py | 4 +- test/arch/arm/sem.py | 3 +- test/arch/mep/ir/test_ir.py | 5 ++- test/arch/mips32/unit/asm_test.py | 4 +- test/arch/msp430/sem.py | 3 +- test/arch/ppc32/sem.py | 3 +- test/arch/x86/sem.py | 6 +-- test/arch/x86/unit/asm_test.py | 4 +- test/arch/x86/unit/test_asm_x86_64.py | 1 - test/core/parse_asm.py | 2 +- test/ir/reduce_graph.py | 2 +- 36 files changed, 117 insertions(+), 143 deletions(-) (limited to 'example') diff --git a/README.md b/README.md index c31bdc26..dd956254 100644 --- a/README.md +++ b/README.md @@ -125,7 +125,7 @@ Add instruction to the pool: Print current pool: ```pycon >>> for lbl, irblock in ircfg.blocks.items(): -... print(irblock.to_string(loc_db)) +... print(irblock) loc_0: R2 = R8 + R0 @@ -134,10 +134,10 @@ IRDst = loc_4 ``` Working with IR, for instance by getting side effects: ```pycon ->>> for lbl, irblock in ircfg.blocks.iteritems(): +>>> for lbl, irblock in ircfg.blocks.items(): ... for assignblk in irblock: ... rw = assignblk.get_rw() -... for dst, reads in rw.iteritems(): +... for dst, reads in rw.items(): ... print('read: ', [str(x) for x in reads]) ... print('written:', dst) ... print() @@ -166,7 +166,7 @@ Giving a shellcode: 00000010 8d5b01 lea ebx, [ebx+0x1] 00000013 89d8 mov eax, ebx 00000015 c3 ret ->>> s = '\x8dI\x04\x8d[\x01\x80\xf9\x01t\x05\x8d[\xff\xeb\x03\x8d[\x01\x89\xd8\xc3' +>>> s = b'\x8dI\x04\x8d[\x01\x80\xf9\x01t\x05\x8d[\xff\xeb\x03\x8d[\x01\x89\xd8\xc3' ``` Import the shellcode thanks to the `Container` abstraction: @@ -185,7 +185,7 @@ Disassembling the shellcode at address `0`: >>> mdis = machine.dis_engine(c.bin_stream, loc_db=loc_db) >>> asmcfg = mdis.dis_multiblock(0) >>> for block in asmcfg.blocks: -... print(block.to_string(asmcfg.loc_db)) +... print(block) ... loc_0 LEA ECX, DWORD PTR [ECX + 0x4] diff --git a/example/asm/shellcode.py b/example/asm/shellcode.py index d33d6231..70d844a9 100755 --- a/example/asm/shellcode.py +++ b/example/asm/shellcode.py @@ -106,7 +106,6 @@ open("graph.dot", "w").write(asmcfg.dot()) patches = asmblock.asm_resolve_final( machine.mn, asmcfg, - loc_db, dst_interval ) if args.encrypt: diff --git a/example/asm/simple.py b/example/asm/simple.py index 6197556b..bfa3ace6 100644 --- a/example/asm/simple.py +++ b/example/asm/simple.py @@ -30,7 +30,7 @@ loop: loc_db.set_location_offset(loc_db.get_name_location("main"), 0x0) # Spread information and resolve instructions offset -patches = asmblock.asm_resolve_final(mn_x86, asmcfg, loc_db) +patches = asmblock.asm_resolve_final(mn_x86, asmcfg) # Show resolved asmcfg for block in asmcfg.blocks: diff --git a/example/expression/asm_to_ir.py b/example/expression/asm_to_ir.py index edc23437..8ecc4f24 100644 --- a/example/expression/asm_to_ir.py +++ b/example/expression/asm_to_ir.py @@ -40,7 +40,7 @@ for block in asmcfg.blocks: print("symbols:") print(loc_db) -patches = asmblock.asm_resolve_final(mn_x86, asmcfg, loc_db) +patches = asmblock.asm_resolve_final(mn_x86, asmcfg) # Translate to IR ir_arch = ir_a_x86_32(loc_db) diff --git a/miasm/analysis/data_flow.py b/miasm/analysis/data_flow.py index 49384a8b..40153f8b 100644 --- a/miasm/analysis/data_flow.py +++ b/miasm/analysis/data_flow.py @@ -1062,10 +1062,10 @@ class DiGraphLiveness(DiGraph): DiGraph representing variable liveness """ - def __init__(self, ircfg, loc_db=None): + def __init__(self, ircfg): super(DiGraphLiveness, self).__init__() self.ircfg = ircfg - self.loc_db = loc_db + self.loc_db = ircfg.loc_db self._blocks = {} # Add irblocks gen/kill for node in ircfg.nodes(): @@ -1092,14 +1092,11 @@ class DiGraphLiveness(DiGraph): """ Output liveness information in dot format """ - if self.loc_db is None: - node_name = str(node) + names = self.loc_db.get_location_names(node) + if not names: + node_name = self.loc_db.pretty_str(node) else: - names = self.loc_db.get_location_names(node) - if not names: - node_name = self.loc_db.pretty_str(node) - else: - node_name = "".join("%s:\n" % name for name in names) + node_name = "".join("%s:\n" % name for name in names) yield self.DotCellDescription( text="%s" % node_name, attr={ diff --git a/miasm/arch/aarch64/ira.py b/miasm/arch/aarch64/ira.py index e20a0943..aded3dd1 100644 --- a/miasm/arch/aarch64/ira.py +++ b/miasm/arch/aarch64/ira.py @@ -6,21 +6,21 @@ from miasm.arch.aarch64.sem import ir_aarch64l, ir_aarch64b class ir_a_aarch64l_base(ir_aarch64l, ira): - def __init__(self, loc_db=None): + def __init__(self, loc_db): ir_aarch64l.__init__(self, loc_db) self.ret_reg = self.arch.regs.X0 class ir_a_aarch64b_base(ir_aarch64b, ira): - def __init__(self, loc_db=None): + def __init__(self, loc_db): ir_aarch64b.__init__(self, loc_db) self.ret_reg = self.arch.regs.X0 class ir_a_aarch64l(ir_a_aarch64l_base): - def __init__(self, loc_db=None): + def __init__(self, loc_db): ir_a_aarch64l_base.__init__(self, loc_db) self.ret_reg = self.arch.regs.X0 @@ -45,6 +45,6 @@ class ir_a_aarch64l(ir_a_aarch64l_base): class ir_a_aarch64b(ir_a_aarch64b_base, ir_a_aarch64l): - def __init__(self, loc_db=None): + def __init__(self, loc_db): ir_a_aarch64b_base.__init__(self, loc_db) self.ret_reg = self.arch.regs.X0 diff --git a/miasm/arch/aarch64/sem.py b/miasm/arch/aarch64/sem.py index e77df911..8ce72638 100644 --- a/miasm/arch/aarch64/sem.py +++ b/miasm/arch/aarch64/sem.py @@ -2228,7 +2228,7 @@ class aarch64info(object): class ir_aarch64l(IntermediateRepresentation): - def __init__(self, loc_db=None): + def __init__(self, loc_db): IntermediateRepresentation.__init__(self, mn_aarch64, "l", loc_db) self.pc = PC self.sp = SP @@ -2314,7 +2314,7 @@ class ir_aarch64l(IntermediateRepresentation): class ir_aarch64b(ir_aarch64l): - def __init__(self, loc_db=None): + def __init__(self, loc_db): IntermediateRepresentation.__init__(self, mn_aarch64, "b", loc_db) self.pc = PC self.sp = SP diff --git a/miasm/arch/arm/ira.py b/miasm/arch/arm/ira.py index 178e8abc..f2d8d44b 100644 --- a/miasm/arch/arm/ira.py +++ b/miasm/arch/arm/ira.py @@ -7,19 +7,19 @@ from miasm.expression.expression import ExprAssign, ExprOp, ExprLoc, ExprCond from miasm.ir.ir import AssignBlock class ir_a_arml_base(ir_arml, ira): - def __init__(self, loc_db=None): + def __init__(self, loc_db): ir_arml.__init__(self, loc_db) self.ret_reg = self.arch.regs.R0 class ir_a_armb_base(ir_armb, ira): - def __init__(self, loc_db=None): + def __init__(self, loc_db): ir_armb.__init__(self, loc_db) self.ret_reg = self.arch.regs.R0 class ir_a_arml(ir_a_arml_base): - def __init__(self, loc_db=None): + def __init__(self, loc_db): ir_a_arml_base.__init__(self, loc_db) self.ret_reg = self.arch.regs.R0 @@ -90,17 +90,17 @@ class ir_a_arml(ir_a_arml_base): class ir_a_armb(ir_a_armb_base, ir_a_arml): - def __init__(self, loc_db=None): + def __init__(self, loc_db): ir_a_armb_base.__init__(self, loc_db) self.ret_reg = self.arch.regs.R0 class ir_a_armtl(ir_armtl, ir_a_arml): - def __init__(self, loc_db=None): + def __init__(self, loc_db): ir_armtl.__init__(self, loc_db) self.ret_reg = self.arch.regs.R0 class ir_a_armtb(ir_a_armtl, ir_armtb, ir_a_armb): - def __init__(self, loc_db=None): + def __init__(self, loc_db): ir_armtb.__init__(self, loc_db) self.ret_reg = self.arch.regs.R0 diff --git a/miasm/arch/arm/sem.py b/miasm/arch/arm/sem.py index 1884abe8..fd82df23 100644 --- a/miasm/arch/arm/sem.py +++ b/miasm/arch/arm/sem.py @@ -1933,7 +1933,7 @@ class arminfo(object): class ir_arml(IntermediateRepresentation): - def __init__(self, loc_db=None): + def __init__(self, loc_db): IntermediateRepresentation.__init__(self, mn_arm, "l", loc_db) self.pc = PC self.sp = SP @@ -2130,7 +2130,7 @@ class ir_arml(IntermediateRepresentation): class ir_armb(ir_arml): - def __init__(self, loc_db=None): + def __init__(self, loc_db): IntermediateRepresentation.__init__(self, mn_arm, "b", loc_db) self.pc = PC self.sp = SP @@ -2139,7 +2139,7 @@ class ir_armb(ir_arml): class ir_armtl(ir_arml): - def __init__(self, loc_db=None): + def __init__(self, loc_db): IntermediateRepresentation.__init__(self, mn_armt, "l", loc_db) self.pc = PC self.sp = SP @@ -2165,7 +2165,7 @@ class ir_armtl(ir_arml): class ir_armtb(ir_armtl): - def __init__(self, loc_db=None): + def __init__(self, loc_db): IntermediateRepresentation.__init__(self, mn_armt, "b", loc_db) self.pc = PC self.sp = SP diff --git a/miasm/arch/mep/ira.py b/miasm/arch/mep/ira.py index 2de4b5ae..eac4f6e9 100644 --- a/miasm/arch/mep/ira.py +++ b/miasm/arch/mep/ira.py @@ -12,7 +12,7 @@ class ir_a_mepb(ir_mepb, ira): - it is mandatory for symbolic execution. """ - def __init__(self, loc_db=None): + def __init__(self, loc_db): ir_mepb.__init__(self, loc_db) self.ret_reg = self.arch.regs.R0 @@ -41,5 +41,5 @@ class ir_a_mepb(ir_mepb, ira): class ir_a_mepl(ir_mepl, ir_a_mepb): """MeP high level IR manipulations - Little Endian""" - def __init__(self, loc_db=None): + def __init__(self, loc_db): ir_a_mepb.__init__(self, loc_db) diff --git a/miasm/arch/mep/sem.py b/miasm/arch/mep/sem.py index df484ab5..dccfc20d 100644 --- a/miasm/arch/mep/sem.py +++ b/miasm/arch/mep/sem.py @@ -1146,7 +1146,7 @@ class ir_mepb(IntermediateRepresentation): addrsize = 32 - def __init__(self, loc_db=None): + def __init__(self, loc_db): IntermediateRepresentation.__init__(self, mn_mep, "b", loc_db) self.pc = mn_mep.getpc() self.sp = mn_mep.getsp() @@ -1172,7 +1172,7 @@ class ir_mepb(IntermediateRepresentation): class ir_mepl(ir_mepb): """Toshiba MeP miasm IR - Little Endian""" - def __init__(self, loc_db=None): + def __init__(self, loc_db): IntermediateRepresentation.__init__(self, mn_mep, "l", loc_db) self.pc = mn_mep.getpc() self.sp = mn_mep.getsp() diff --git a/miasm/arch/mips32/ira.py b/miasm/arch/mips32/ira.py index e7b5d7f2..e57e3a36 100644 --- a/miasm/arch/mips32/ira.py +++ b/miasm/arch/mips32/ira.py @@ -6,7 +6,7 @@ from miasm.ir.analysis import ira from miasm.arch.mips32.sem import ir_mips32l, ir_mips32b class ir_a_mips32l(ir_mips32l, ira): - def __init__(self, loc_db=None): + def __init__(self, loc_db): ir_mips32l.__init__(self, loc_db) self.ret_reg = self.arch.regs.V0 @@ -99,6 +99,6 @@ class ir_a_mips32l(ir_mips32l, ira): class ir_a_mips32b(ir_mips32b, ir_a_mips32l): - def __init__(self, loc_db=None): + def __init__(self, loc_db): ir_mips32b.__init__(self, loc_db) self.ret_reg = self.arch.regs.V0 diff --git a/miasm/arch/mips32/sem.py b/miasm/arch/mips32/sem.py index b4252486..20ef007a 100644 --- a/miasm/arch/mips32/sem.py +++ b/miasm/arch/mips32/sem.py @@ -608,7 +608,7 @@ def get_mnemo_expr(ir, instr, *args): class ir_mips32l(IntermediateRepresentation): - def __init__(self, loc_db=None): + def __init__(self, loc_db): IntermediateRepresentation.__init__(self, mn_mips32, 'l', loc_db) self.pc = mn_mips32.getpc() self.sp = mn_mips32.getsp() @@ -641,7 +641,7 @@ class ir_mips32l(IntermediateRepresentation): return self.loc_db.get_or_create_offset_location(instr.offset + 16) class ir_mips32b(ir_mips32l): - def __init__(self, loc_db=None): + def __init__(self, loc_db): self.addrsize = 32 IntermediateRepresentation.__init__(self, mn_mips32, 'b', loc_db) self.pc = mn_mips32.getpc() diff --git a/miasm/arch/msp430/ira.py b/miasm/arch/msp430/ira.py index 72889149..264de12c 100644 --- a/miasm/arch/msp430/ira.py +++ b/miasm/arch/msp430/ira.py @@ -7,7 +7,7 @@ from miasm.expression.expression import * class ir_a_msp430_base(ir_msp430, ira): - def __init__(self, loc_db=None): + def __init__(self, loc_db): ir_msp430.__init__(self, loc_db) self.ret_reg = self.arch.regs.R15 @@ -23,7 +23,7 @@ class ir_a_msp430_base(ir_msp430, ira): class ir_a_msp430(ir_a_msp430_base): - def __init__(self, loc_db=None): + def __init__(self, loc_db): ir_a_msp430_base.__init__(self, loc_db) def get_out_regs(self, _): diff --git a/miasm/arch/msp430/sem.py b/miasm/arch/msp430/sem.py index 68605ae4..196e09f1 100644 --- a/miasm/arch/msp430/sem.py +++ b/miasm/arch/msp430/sem.py @@ -475,7 +475,7 @@ def ComposeExprAssign(dst, src): class ir_msp430(IntermediateRepresentation): - def __init__(self, loc_db=None): + def __init__(self, loc_db): IntermediateRepresentation.__init__(self, mn_msp430, None, loc_db) self.pc = PC self.sp = SP diff --git a/miasm/arch/ppc/ira.py b/miasm/arch/ppc/ira.py index 953c5a86..72bf7d7c 100644 --- a/miasm/arch/ppc/ira.py +++ b/miasm/arch/ppc/ira.py @@ -6,8 +6,8 @@ from miasm.arch.ppc.sem import ir_ppc32b class ir_a_ppc32b(ir_ppc32b, ira): - def __init__(self, *args): - super(ir_a_ppc32b, self).__init__(*args) + def __init__(self, loc_db, *args): + super(ir_a_ppc32b, self).__init__(loc_db, *args) self.ret_reg = self.arch.regs.R3 # for test XXX TODO diff --git a/miasm/arch/ppc/sem.py b/miasm/arch/ppc/sem.py index 26b3d84b..b05348f7 100644 --- a/miasm/arch/ppc/sem.py +++ b/miasm/arch/ppc/sem.py @@ -899,7 +899,7 @@ sem_dir = { class ir_ppc32b(IntermediateRepresentation): - def __init__(self, loc_db=None): + def __init__(self, loc_db): super(ir_ppc32b, self).__init__(mn_ppc, 'b', loc_db) self.pc = mn_ppc.getpc() self.sp = mn_ppc.getsp() diff --git a/miasm/arch/x86/ira.py b/miasm/arch/x86/ira.py index dc6db273..1615622b 100644 --- a/miasm/arch/x86/ira.py +++ b/miasm/arch/x86/ira.py @@ -8,7 +8,7 @@ from miasm.arch.x86.sem import ir_x86_16, ir_x86_32, ir_x86_64 class ir_a_x86_16(ir_x86_16, ira): - def __init__(self, loc_db=None): + def __init__(self, loc_db): ir_x86_16.__init__(self, loc_db) self.ret_reg = self.arch.regs.AX @@ -17,7 +17,7 @@ class ir_a_x86_16(ir_x86_16, ira): class ir_a_x86_32(ir_x86_32, ir_a_x86_16): - def __init__(self, loc_db=None): + def __init__(self, loc_db): ir_x86_32.__init__(self, loc_db) self.ret_reg = self.arch.regs.EAX @@ -39,7 +39,7 @@ class ir_a_x86_32(ir_x86_32, ir_a_x86_16): class ir_a_x86_64(ir_x86_64, ir_a_x86_16): - def __init__(self, loc_db=None): + def __init__(self, loc_db): ir_x86_64.__init__(self, loc_db) self.ret_reg = self.arch.regs.RAX diff --git a/miasm/arch/x86/sem.py b/miasm/arch/x86/sem.py index 723272d5..6e593f51 100644 --- a/miasm/arch/x86/sem.py +++ b/miasm/arch/x86/sem.py @@ -5733,7 +5733,7 @@ mnemo_func = {'mov': mov, class ir_x86_16(IntermediateRepresentation): - def __init__(self, loc_db=None): + def __init__(self, loc_db): IntermediateRepresentation.__init__(self, mn_x86, 16, loc_db) self.do_stk_segm = False self.do_ds_segm = False @@ -5876,7 +5876,7 @@ class ir_x86_16(IntermediateRepresentation): class ir_x86_32(ir_x86_16): - def __init__(self, loc_db=None): + def __init__(self, loc_db): IntermediateRepresentation.__init__(self, mn_x86, 32, loc_db) self.do_stk_segm = False self.do_ds_segm = False @@ -5890,7 +5890,7 @@ class ir_x86_32(ir_x86_16): class ir_x86_64(ir_x86_16): - def __init__(self, loc_db=None): + def __init__(self, loc_db): IntermediateRepresentation.__init__(self, mn_x86, 64, loc_db) self.do_stk_segm = False self.do_ds_segm = False diff --git a/miasm/core/asmblock.py b/miasm/core/asmblock.py index e293ffda..47bffb34 100644 --- a/miasm/core/asmblock.py +++ b/miasm/core/asmblock.py @@ -91,22 +91,19 @@ class AsmBlock(object): loc_key = property(lambda self:self._loc_key) - def to_string(self, loc_db=None): + def to_string(self): out = [] - if loc_db is None: - out.append(str(self.loc_key)) - else: - out.append(loc_db.pretty_str(self.loc_key)) + out.append(self.loc_db.pretty_str(self.loc_key)) for instr in self.lines: - out.append(instr.to_string(loc_db)) + out.append(instr.to_string(self.loc_db)) if self.bto: lbls = ["->"] for dst in self.bto: if dst is None: lbls.append("Unknown? ") else: - lbls.append(dst.to_string(loc_db) + " ") + lbls.append(dst.to_string(self.loc_db) + " ") lbls = '\t'.join(sorted(lbls)) out.append(lbls) return '\n'.join(out) @@ -121,18 +118,18 @@ class AsmBlock(object): assert isinstance(self.bto, set) self.bto.add(c) - def split(self, loc_db, offset): - loc_key = loc_db.get_or_create_offset_location(offset) + def split(self, offset): + loc_key = self.loc_db.get_or_create_offset_location(offset) log_asmblock.debug('split at %x', offset) offsets = [x.offset for x in self.lines] - offset = loc_db.get_location_offset(loc_key) + offset = self.loc_db.get_location_offset(loc_key) if offset not in offsets: log_asmblock.warning( 'cannot split block at %X ' % offset + 'middle instruction? default middle') offsets.sort() return None - new_block = AsmBlock(loc_db, loc_key) + new_block = AsmBlock(self.loc_db, loc_key) i = offsets.index(offset) self.lines, new_block.lines = self.lines[:i], self.lines[i:] @@ -444,10 +441,7 @@ class AsmCFG(DiGraph): def node2lines(self, node): - if self.loc_db is None: - loc_key_name = node - else: - loc_key_name = self.loc_db.pretty_str(node) + loc_key_name = self.loc_db.pretty_str(node) yield self.DotCellDescription(text=loc_key_name, attr={'align': 'center', 'colspan': 2, @@ -903,7 +897,7 @@ class BlockChainWedge(object): return [self, chain] -def group_constrained_blocks(loc_db, asmcfg): +def group_constrained_blocks(asmcfg): """ Return the BlockChains list built from grouped blocks in asmcfg linked by asm_constraint_next @@ -942,7 +936,7 @@ def group_constrained_blocks(loc_db, asmcfg): out_block_chains = [] for loc_key in known_block_chains: - chain = BlockChain(loc_db, known_block_chains[loc_key]) + chain = BlockChain(asmcfg.loc_db, known_block_chains[loc_key]) out_block_chains.append(chain) return out_block_chains @@ -1023,8 +1017,8 @@ def get_block_loc_keys(block): return symbols -def assemble_block(mnemo, block, loc_db, conservative=False): - """Assemble a @block using @loc_db +def assemble_block(mnemo, block, conservative=False): + """Assemble a @block @conservative: (optional) use original bytes when possible """ offset_i = 0 @@ -1035,7 +1029,7 @@ def assemble_block(mnemo, block, loc_db, conservative=False): # Fix special AsmRaw data = b"" for expr in instr.raw: - expr_int = fix_expr_val(expr, loc_db) + expr_int = fix_expr_val(expr, block.loc_db) data += pck[expr_int.size](int(expr_int)) instr.data = data @@ -1045,17 +1039,17 @@ def assemble_block(mnemo, block, loc_db, conservative=False): # Assemble an instruction saved_args = list(instr.args) - instr.offset = loc_db.get_location_offset(block.loc_key) + offset_i + instr.offset = block.loc_db.get_location_offset(block.loc_key) + offset_i # Replace instruction's arguments by resolved ones - instr.args = instr.resolve_args_with_symbols(loc_db) + instr.args = instr.resolve_args_with_symbols(block.loc_db) if instr.dstflow(): instr.fixDstOffset() old_l = instr.l cached_candidate, _ = conservative_asm( - mnemo, instr, loc_db, + mnemo, instr, block.loc_db, conservative ) if len(cached_candidate) != instr.l: @@ -1063,11 +1057,11 @@ def assemble_block(mnemo, block, loc_db, conservative=False): # Retry assembly with updated length instr.l = len(cached_candidate) instr.args = saved_args - instr.args = instr.resolve_args_with_symbols(loc_db) + instr.args = instr.resolve_args_with_symbols(block.loc_db) if instr.dstflow(): instr.fixDstOffset() cached_candidate, _ = conservative_asm( - mnemo, instr, loc_db, + mnemo, instr, block.loc_db, conservative ) assert len(cached_candidate) == instr.l @@ -1083,8 +1077,8 @@ def assemble_block(mnemo, block, loc_db, conservative=False): offset_i += instr.l -def asmblock_final(mnemo, asmcfg, blockChains, loc_db, conservative=False): - """Resolve and assemble @blockChains using @loc_db until fixed point is +def asmblock_final(mnemo, asmcfg, blockChains, conservative=False): + """Resolve and assemble @blockChains until fixed point is reached""" log_asmblock.debug("asmbloc_final") @@ -1131,29 +1125,24 @@ def asmblock_final(mnemo, asmcfg, blockChains, loc_db, conservative=False): while blocks_to_rework: block = blocks_to_rework.pop() - assemble_block(mnemo, block, loc_db, conservative) + assemble_block(mnemo, block, conservative) -def asm_resolve_final(mnemo, asmcfg, loc_db, dst_interval=None): - """Resolve and assemble @asmcfg using @loc_db into interval +def asm_resolve_final(mnemo, asmcfg, dst_interval=None): + """Resolve and assemble @asmcfg into interval @dst_interval""" asmcfg.sanity_check() asmcfg.guess_blocks_size(mnemo) - blockChains = group_constrained_blocks(loc_db, asmcfg) - resolved_blockChains = resolve_symbol( - blockChains, - loc_db, - dst_interval - ) - - asmblock_final(mnemo, asmcfg, resolved_blockChains, loc_db) + blockChains = group_constrained_blocks(asmcfg) + resolved_blockChains = resolve_symbol(blockChains, asmcfg.loc_db, dst_interval) + asmblock_final(mnemo, asmcfg, resolved_blockChains) patches = {} output_interval = interval() for block in asmcfg.blocks: - offset = loc_db.get_location_offset(block.loc_key) + offset = asmcfg.loc_db.get_location_offset(block.loc_key) for instr in block.lines: if not instr.data: # Empty line @@ -1429,7 +1418,7 @@ class disasmEngine(object): # `cur_block` must be split at offset `off`from miasm.core.locationdb import LocationDB - new_b = cur_block.split(self.loc_db, off) + new_b = cur_block.split(off) log_asmblock.debug("Split block %x", off) if new_b is None: log_asmblock.error("Cannot split %x!!", off) diff --git a/miasm/ir/ir.py b/miasm/ir/ir.py index 00c73d09..aa04c54f 100644 --- a/miasm/ir/ir.py +++ b/miasm/ir/ir.py @@ -426,15 +426,21 @@ class IRBlock(object): self.cache_dst() return self._dst_linenb - def __str__(self): + def to_string(self): out = [] - out.append(str(self.loc_key)) + names = self.loc_db.get_location_names(self.loc_key) + if not names: + node_name = "%s:" % self.loc_db.pretty_str(self.loc_key) + else: + node_name = "".join("%s:\n" % name for name in names) + out.append(node_name) + for assignblk in self: - for dst, src in viewitems(assignblk): - out.append('\t%s = %s' % (dst, src)) - out.append("") - return "\n".join(out) + out.append(assignblk.to_string(self.loc_db)) + return '\n'.join(out) + def __str__(self): + return self.to_string() def modify_exprs(self, mod_dst=None, mod_src=None): """ @@ -457,23 +463,6 @@ class IRBlock(object): assignblks.append(AssignBlock(new_assignblk, assignblk.instr)) return IRBlock(self.loc_db, self.loc_key, assignblks) - def to_string(self, loc_db=None): - out = [] - if loc_db is None: - node_name = "%s:" % self.loc_key - else: - names = loc_db.get_location_names(self.loc_key) - if not names: - node_name = "%s:" % loc_db.pretty_str(self.loc_key) - else: - node_name = "".join("%s:\n" % name for name in names) - out.append(node_name) - - for assignblk in self: - out.append(assignblk.to_string(loc_db)) - return '\n'.join(out) - - def simplify(self, simplifier): """ Simplify expressions in each assignblock @@ -540,10 +529,7 @@ class IRCFG(DiGraph): self.add_uniq_edge(irblock.loc_key, dst.loc_key) def node2lines(self, node): - if self.loc_db is None: - node_name = str(node) - else: - node_name = self.loc_db.pretty_str(node) + node_name = self.loc_db.pretty_str(node) yield self.DotCellDescription( text="%s" % node_name, attr={ diff --git a/miasm/jitter/jitcore.py b/miasm/jitter/jitcore.py index cc531cf5..a6c9dda6 100644 --- a/miasm/jitter/jitcore.py +++ b/miasm/jitter/jitcore.py @@ -144,7 +144,7 @@ class JitCore(object): return cur_block # Logging if self.log_newbloc: - print(cur_block.to_string(self.mdis.loc_db)) + print(cur_block) # Update label -> block self.loc_key_to_block[cur_block.loc_key] = cur_block diff --git a/test/analysis/data_flow.py b/test/analysis/data_flow.py index 47d521bc..840bf9ce 100644 --- a/test/analysis/data_flow.py +++ b/test/analysis/data_flow.py @@ -72,7 +72,7 @@ class IRATest(ira): """Fake IRA class for tests""" - def __init__(self, loc_db=None): + def __init__(self, loc_db): arch = Arch() super(IRATest, self).__init__(arch, 32, loc_db) self.IRDst = IRDst diff --git a/test/analysis/depgraph.py b/test/analysis/depgraph.py index a458e533..49a395a1 100644 --- a/test/analysis/depgraph.py +++ b/test/analysis/depgraph.py @@ -95,7 +95,7 @@ class IRATest(ira): """Fake IRA class for tests""" - def __init__(self, loc_db=None): + def __init__(self, loc_db): arch = Arch() super(IRATest, self).__init__(arch, 32, loc_db) self.IRDst = ExprId("IRDst", 32) diff --git a/test/analysis/dse.py b/test/analysis/dse.py index cd813d2c..570860e4 100644 --- a/test/analysis/dse.py +++ b/test/analysis/dse.py @@ -73,7 +73,7 @@ class DSETest(object): def asm(self): mn_x86 = self.machine.mn - blocks = parse_asm.parse_txt( + asmcfg = parse_asm.parse_txt( mn_x86, self.arch_attrib, self.TXT, @@ -83,7 +83,7 @@ class DSETest(object): # fix shellcode addr self.loc_db.set_location_offset(self.loc_db.get_name_location("main"), 0x0) output = StrPatchwork() - patches = asm_resolve_final(mn_x86, blocks, self.loc_db) + patches = asm_resolve_final(mn_x86, asmcfg) for offset, raw in viewitems(patches): output[offset] = raw @@ -117,7 +117,7 @@ class DSEAttachInBreakpoint(DSETest): super(DSEAttachInBreakpoint, self).__init__(*args, **kwargs) self._dse = None ircls = self.machine.ir - self._regs = ircls().arch.regs + self._regs = ircls(self.loc_db).arch.regs self._testid = ExprId("TEST", self._regs.EBX.size) def bp_attach(self, jitter): diff --git a/test/arch/aarch64/unit/asm_test.py b/test/arch/aarch64/unit/asm_test.py index d6ed5223..d9a484b7 100644 --- a/test/arch/aarch64/unit/asm_test.py +++ b/test/arch/aarch64/unit/asm_test.py @@ -26,11 +26,11 @@ class Asm_Test(object): self.check() def asm(self): - blocks = parse_asm.parse_txt(mn_aarch64, 'l', self.TXT, self.loc_db) + asmcfg = parse_asm.parse_txt(mn_aarch64, 'l', self.TXT, self.loc_db) # fix shellcode addr self.loc_db.set_location_offset(self.loc_db.get_name_location("main"), 0x0) s = StrPatchwork() - patches = asmblock.asm_resolve_final(mn_aarch64, blocks, self.loc_db) + patches = asmblock.asm_resolve_final(mn_aarch64, asmcfg) for offset, raw in viewitems(patches): s[offset] = raw diff --git a/test/arch/arm/sem.py b/test/arch/arm/sem.py index f38d48e9..49d46a4d 100755 --- a/test/arch/arm/sem.py +++ b/test/arch/arm/sem.py @@ -16,7 +16,8 @@ from miasm.core.locationdb import LocationDB from pdb import pm logging.getLogger('cpuhelper').setLevel(logging.ERROR) -EXCLUDE_REGS = set([ir_arch().IRDst]) +loc_db = LocationDB() +EXCLUDE_REGS = set([ir_arch(loc_db).IRDst]) def M(addr): diff --git a/test/arch/mep/ir/test_ir.py b/test/arch/mep/ir/test_ir.py index be8e24e1..97a3ec1e 100644 --- a/test/arch/mep/ir/test_ir.py +++ b/test/arch/mep/ir/test_ir.py @@ -27,13 +27,14 @@ class TestMisc(object): mn = mn_mep.dis(decode_hex(hex_asm), "b") print("Dis:", mn) + loc_db = LocationDB() + # Get the IR - im = ir_mepb() + im = ir_mepb(loc_db) iir, eiir, = im.get_ir(mn) print("\nInternal representation:", iir) # Symbolic execution - loc_db = LocationDB() sb = SymbolicExecutionEngine(ir_a_mepb(loc_db), regs_init) # Assign register values before symbolic evaluation diff --git a/test/arch/mips32/unit/asm_test.py b/test/arch/mips32/unit/asm_test.py index 164cc143..d6194b00 100644 --- a/test/arch/mips32/unit/asm_test.py +++ b/test/arch/mips32/unit/asm_test.py @@ -28,11 +28,11 @@ class Asm_Test(object): self.check() def asm(self): - blocks = parse_asm.parse_txt(mn_mips32, 'l', self.TXT, self.loc_db) + asmcfg = parse_asm.parse_txt(mn_mips32, 'l', self.TXT, self.loc_db) # fix shellcode addr self.loc_db.set_location_offset(self.loc_db.get_name_location("main"), 0x0) s = StrPatchwork() - patches = asmblock.asm_resolve_final(mn_mips32, blocks, self.loc_db) + patches = asmblock.asm_resolve_final(mn_mips32, asmcfg) for offset, raw in viewitems(patches): s[offset] = raw diff --git a/test/arch/msp430/sem.py b/test/arch/msp430/sem.py index cb101937..2b3c4afe 100755 --- a/test/arch/msp430/sem.py +++ b/test/arch/msp430/sem.py @@ -15,7 +15,8 @@ from miasm.expression.expression import * from miasm.core.locationdb import LocationDB logging.getLogger('cpuhelper').setLevel(logging.ERROR) -EXCLUDE_REGS = set([res, ir_arch().IRDst]) +loc_db = LocationDB() +EXCLUDE_REGS = set([res, ir_arch(loc_db).IRDst]) def M(addr): diff --git a/test/arch/ppc32/sem.py b/test/arch/ppc32/sem.py index 95ef08c8..53c93369 100644 --- a/test/arch/ppc32/sem.py +++ b/test/arch/ppc32/sem.py @@ -16,7 +16,8 @@ from miasm.core.locationdb import LocationDB from pdb import pm logging.getLogger('cpuhelper').setLevel(logging.ERROR) -EXCLUDE_REGS = set([ir_arch().IRDst]) +loc_db = LocationDB() +EXCLUDE_REGS = set([ir_arch(loc_db).IRDst]) def M(addr): diff --git a/test/arch/x86/sem.py b/test/arch/x86/sem.py index 3d40d44c..9c7e972b 100755 --- a/test/arch/x86/sem.py +++ b/test/arch/x86/sem.py @@ -21,9 +21,9 @@ from miasm.expression.simplifications import expr_simp from miasm.core import parse_asm, asmblock from miasm.core.locationdb import LocationDB - logging.getLogger('cpuhelper').setLevel(logging.ERROR) -EXCLUDE_REGS = set([ir_32().IRDst, ir_64().IRDst]) +loc_db = LocationDB() +EXCLUDE_REGS = set([ir_32(loc_db).IRDst, ir_64(loc_db).IRDst]) m32 = 32 @@ -59,7 +59,7 @@ def compute_txt(ir, mode, txt, inputstate={}, debug=False): loc_db = LocationDB() asmcfg = parse_asm.parse_txt(mn, mode, txt, loc_db) loc_db.set_location_offset(loc_db.get_name_location("main"), 0x0) - patches = asmblock.asm_resolve_final(mn, asmcfg, loc_db) + patches = asmblock.asm_resolve_final(mn, asmcfg) ir_arch = ir(loc_db) lbl = loc_db.get_name_location("main") ircfg = ir_arch.new_ircfg_from_asmcfg(asmcfg) diff --git a/test/arch/x86/unit/asm_test.py b/test/arch/x86/unit/asm_test.py index d3ecf660..62923310 100644 --- a/test/arch/x86/unit/asm_test.py +++ b/test/arch/x86/unit/asm_test.py @@ -45,11 +45,11 @@ class Asm_Test(object): assert(self.myjit.pc == self.ret_addr) def asm(self): - blocks = parse_asm.parse_txt(mn_x86, self.arch_attrib, self.TXT, self.loc_db) + asmcfg = parse_asm.parse_txt(mn_x86, self.arch_attrib, self.TXT, self.loc_db) # fix shellcode addr self.loc_db.set_location_offset(self.loc_db.get_name_location("main"), 0x0) s = StrPatchwork() - patches = asmblock.asm_resolve_final(mn_x86, blocks, self.loc_db) + patches = asmblock.asm_resolve_final(mn_x86, asmcfg) for offset, raw in viewitems(patches): s[offset] = raw diff --git a/test/arch/x86/unit/test_asm_x86_64.py b/test/arch/x86/unit/test_asm_x86_64.py index e1d99ec1..f56770dc 100644 --- a/test/arch/x86/unit/test_asm_x86_64.py +++ b/test/arch/x86/unit/test_asm_x86_64.py @@ -29,6 +29,5 @@ dst_interval = interval([(0x100001000, 0x100002000)]) patches = asmblock.asm_resolve_final( my_mn, asmcfg, - loc_db, dst_interval ) diff --git a/test/core/parse_asm.py b/test/core/parse_asm.py index fdf1fbb8..5619f5c1 100755 --- a/test/core/parse_asm.py +++ b/test/core/parse_asm.py @@ -69,7 +69,7 @@ class TestParseAsm(unittest.TestCase): ''' asmcfg = parse_txt(mn_x86, 32, ASM0, loc_db) - patches = asm_resolve_final(mn_x86, asmcfg, loc_db) + patches = asm_resolve_final(mn_x86, asmcfg) lbls = [] for i in range(6): lbls.append(loc_db.get_name_location('lbl%d' % i)) diff --git a/test/ir/reduce_graph.py b/test/ir/reduce_graph.py index 73af4860..4aa2d5ef 100644 --- a/test/ir/reduce_graph.py +++ b/test/ir/reduce_graph.py @@ -74,7 +74,7 @@ class IRATest(ira): """Fake IRA class for tests""" - def __init__(self, loc_db=None): + def __init__(self, loc_db): arch = Arch() super(IRATest, self).__init__(arch, 32, loc_db) self.IRDst = IRDst -- cgit 1.4.1