diff options
Diffstat (limited to 'suite/testcommon.py')
| -rw-r--r-- | suite/testcommon.py | 744 |
1 files changed, 744 insertions, 0 deletions
diff --git a/suite/testcommon.py b/suite/testcommon.py new file mode 100644 index 00000000..4e004630 --- /dev/null +++ b/suite/testcommon.py @@ -0,0 +1,744 @@ +import tempfile +import pickle +import os +import zipfile +import inspect +import binaryninja as binja +from binaryninja.binaryview import BinaryViewType, BinaryView +from binaryninja.filemetadata import FileMetadata +import subprocess +import traceback +import types + + +def get_file_list(test_store): + all_files = [] + for root, dir, files in os.walk(test_store): + for file in files: + all_files.append(os.path.join(root, file)) + + return all_files + + +class Builder(object): + def __init__(self, test_store): + self.test_store = test_store + self.examples_dir = os.path.join(self.test_store, "..", "..", "..", "python", "examples") + + def methods(self): + methodnames = [] + for methodname, method in inspect.getmembers(self, predicate=inspect.ismethod): + if methodname.startswith("test_"): + methodnames.append(methodname) + return methodnames + + def unpackage_file(self, file): + if not os.path.exists(file): + with zipfile.ZipFile(file + ".zip", "r") as zf: + zf.extractall() + assert os.path.exists(file) + + +class BinaryViewTestBuilder(Builder): + """ The BinaryViewTestBuilder is for test that are verified against a binary. + The tests are first run on your dev machine to base line then run again + on the build machine to verify they are correct. + + - Function that are tests should start with 'test_' + - Function doc string used as 'on error' message + - Should return: list of strings + """ + def __init__(self, filename, test_store): + self.filename = filename + self.bv = BinaryViewType.get_view_of_file(filename) + if self.bv is None: + print("%s is not an executable format" % filename) + return + + def test_available_types(self): + """Available types don't match""" + return [x.name for x in BinaryView(FileMetadata()).open(self.filename).available_view_types] + + def test_function_starts(self): + """Function starts list doesnt match""" + return [hex(x.start) for x in self.bv.functions] + + def test_function_symbol_names(self): + """Function.symbol.name list doesnt match""" + return [x.symbol.name + ' ' + str(x.symbol.type) + ' ' + hex(x.symbol.address) for x in self.bv.functions] + + def test_function_can_return(self): + """Function.can_return list doesnt match""" + return [x.symbol.name + ' ' + str(x.symbol.type) + ' ' + hex(x.symbol.address) + ' ' + str(bool(x.can_return)) for x in self.bv.functions] + + def test_function_basic_blocks(self): + """Function basic_block list doesnt match (start, end, has_undetermined_outgoing_edges)""" + bblist = [] + for func in self.bv.functions: + for bb in func.basic_blocks: + bblist.append(hex(bb.start) + ' ' + hex(bb.end) + ' ' + str(bb.has_undetermined_outgoing_edges)) + return bblist + + def test_function_low_il_basic_blocks(self): + """"Function low_il_basic_block list doesnt match""" + ilbblist = [] + for func in self.bv.functions: + for bb in func.low_level_il.basic_blocks: + ilbblist.append(hex(bb.start) + ' ' + hex(bb.end) + ' ' + str(len(bb.outgoing_edges))) + return ilbblist + + def test_function_med_il_basic_blocks(self): + """"Function med_il_basic_block list doesn't match""" + ilbblist = [] + for func in self.bv.functions: + for bb in func.medium_level_il.basic_blocks: + ilbblist.append(hex(bb.start) + ' ' + hex(bb.end) + ' ' + str(len(bb.outgoing_edges))) + return ilbblist + + def test_symbols(self): + """"Symbols list doesn't match""" + return [str(i) for i in sorted(self.bv.symbols)] + + def test_strings(self): + """Strings list doesn't match""" + return [x.value + ' ' + str(x.type) + ' ' + hex(x.start) for x in self.bv.strings] + + + def test_low_il_instructions(self): + """LLIL instructions produced different output""" + retinfo = [] + for func in self.bv.functions: + for bb in func.low_level_il.basic_blocks: + for ins in bb: + retinfo.append(str(ins.medium_level_il)) + retinfo.append(str(ins.mapped_medium_level_il)) + retinfo.append(str(ins.value)) + retinfo.append(str(ins.possible_values)) + retinfo.append(str(ins.prefix_operands)) + retinfo.append(str(ins.postfix_operands)) + retinfo.append(str(ins.ssa_form)) + retinfo.append(str(ins.non_ssa_form)) + + return retinfo + + + def test_low_il_ssa(self): + """LLIL ssa produced different output""" + retinfo = [] + reg_list = [binja.SSARegister(i,1) for i in self.bv.arch.regs] + flag_list = [binja.SSAFlag(i,1) for i in self.bv.arch.flags] + for func in self.bv.functions: + func = func.low_level_il + for reg in reg_list: + retinfo.append(str(func.get_ssa_reg_definition(reg))) + retinfo.append(str(func.get_ssa_reg_uses(reg))) + retinfo.append(str(func.get_ssa_reg_value(reg))) + for flag in flag_list: + retinfo.append(str(func.get_ssa_flag_uses(flag))) + retinfo.append(str(func.get_ssa_flag_value(flag))) + for bb in func.basic_blocks: + for ins in bb: + tempind = func.get_non_ssa_instruction_index(ins.instr_index) + retinfo.append(str(tempind)) + retinfo.append(str(func.get_ssa_instruction_index(tempind))) + retinfo.append(str(func.get_medium_level_il_instruction_index(ins.instr_index))) + retinfo.append(str(func.get_mapped_medium_level_il_instruction_index(ins.instr_index))) + + return retinfo + + + def test_med_il_instructions(self): + """MLIL instructions produced different output""" + retinfo = [] + for func in self.bv.functions: + for bb in func.medium_level_il.basic_blocks: + for ins in bb: + retinfo.append(str(ins.expr_type)) + retinfo.append(str(ins.low_level_il)) + retinfo.append(str(ins.value)) + retinfo.append(str(ins.possible_values)) + retinfo.append(str(ins.branch_dependence)) + retinfo.append(str(sorted([str(i) for i in ins.prefix_operands]))) + retinfo.append(str(sorted([str(i) for i in ins.postfix_operands]))) + retinfo.append(str(ins.ssa_form)) + retinfo.append(str(ins.non_ssa_form)) + + return retinfo + + + + def test_med_il_vars(self): + """"Function med_il_vars doesn't match""" + varlist = [] + for func in self.bv.functions: + func = func.medium_level_il + for bb in func.basic_blocks: + for instruction in bb: + instruction = instruction.ssa_form + for var in (instruction.vars_read + instruction.vars_written): + #varlist.append((func.get_var_uses(var), func.get_var_definitions(var))) + if hasattr(var, "var"): + varlist.append(str(func.get_ssa_var_definition(var)) + ' ' + \ + str(func.get_ssa_var_uses(var)) + ' ' + \ + str(func.get_ssa_var_value(var)) + ' ' + \ + str(instruction.get_ssa_var_possible_values(var)) + ' ' + \ + str(instruction.get_ssa_var_version)) + return varlist + + def test_function_stack(self): + """Function stack produced different output""" + funcinfo = [] + for func in self.bv.functions: + func.stack_adjustment = func.stack_adjustment + func.reg_stack_adjustments = func.reg_stack_adjustments + func.create_user_stack_var(0, binja.Type.int(4), "testuservar") + func.create_auto_stack_var(4, binja.Type.int(4), "testautovar") + + temp = [] + for i in func.stack_layout: + temp.append(str(i)) + funcinfo.append(str(temp)) + + funcinfo.append(str(func.get_stack_contents_at(func.start + 0x10, 0, 0x10))) + funcinfo.append(str(func.get_stack_contents_after(func.start + 0x10, 0, 0x10))) + funcinfo.append(str(func.get_stack_var_at_frame_offset(0, 0))) + func.delete_user_stack_var(0) + func.delete_auto_stack_var(0) + + return funcinfo + + def test_function_llil(self): + """Function LLIL produced different output""" + retinfo = [] + + for func in self.bv.functions: + for llilbb in func.llil_basic_blocks: + retinfo.append(str(llilbb)) + for llilins in func.llil_instructions: + retinfo.append(str(llilins)) + + for mlilbb in func.mlil_basic_blocks: + retinfo.append(str(mlilbb)) + for mlilins in func.mlil_instructions: + retinfo.append(str(mlilins)) + + for ins in func.instructions: + retinfo.append(str(ins)) + + return retinfo + + + def test_functions_attributes(self): + """"Function attributes don't match""" + funcinfo = [] + for func in self.bv.functions: + func.comment = "testcomment " + func.name + func.name = func.name + func.can_return = func.can_return + func.function_type = func.function_type + func.return_type = func.return_type + func.return_regs = func.return_regs + func.calling_convention = func.calling_convention + func.parameter_vars = func.parameter_vars + func.has_variable_arguments = func.has_variable_arguments + func.analysis_skipped = func.analysis_skipped + func.clobbered_regs = func.clobbered_regs + func.set_user_instr_highlight(func.start, binja.highlight.HighlightColor(red=0xff, blue=0xff, green=0)) + func.set_auto_instr_highlight(func.start, binja.highlight.HighlightColor(red=0xff, blue=0xfe, green=0)) + + funcinfo.append(str([str(i) for i in func.vars])) + funcinfo.append(str(func.indirect_branches)) + funcinfo.append(str(func.session_data)) + funcinfo.append(len(func.analysis_performance_info)) + funcinfo.append(str(func.clobbered_regs)) + funcinfo.append(str(func.explicitly_defined_type)) + funcinfo.append(str(func.needs_update)) + funcinfo.append(len(func.lifted_il)) + funcinfo.append(str(func.global_pointer_value)) + funcinfo.append(str(func.comment)) + funcinfo.append(str(func.too_large)) + funcinfo.append(str(func.analysis_skipped)) + funcinfo.append(str(func.get_low_level_il_at(func.start))) + funcinfo.append(str(func.get_low_level_il_exits_at(func.start+0x100))) + funcinfo.append(str(func.get_regs_read_by(func.start))) + funcinfo.append(str(func.get_regs_written_by(func.start))) + funcinfo.append(str(func.get_stack_vars_referenced_by(func.start))) + funcinfo.append(str(func.get_constants_referenced_by(func.start))) + funcinfo.append(str(func.get_lifted_il_at(func.start))) + funcinfo.append(str(func.get_flags_read_by_lifted_il_instruction(0))) + funcinfo.append(str(func.get_flags_written_by_lifted_il_instruction(0))) + funcinfo.append(str(func.create_graph())) + funcinfo.append(str(func.get_indirect_branches_at(func.start+0x10))) + funcinfo.append(str(func.get_block_annotations(func.start))) + funcinfo.append(str(func.get_basic_block_at(func.start))) + funcinfo.append(str(func.get_instr_highlight(func.start))) + funcinfo.append(str(func.get_type_tokens())) + + + return funcinfo + + def test_BinaryView(self): + """BinaryView produced different results""" + retinfo = [] + + retinfo += [str(i[1]) for i in self.bv.types.items()] + retinfo.append(str(self.bv.segments)) + retinfo.append(str(self.bv.sections)) + retinfo.append(str(self.bv.allocated_ranges)) + retinfo.append(str(self.bv.session_data)) + for var in self.bv.data_vars: + retinfo.append(str(var)) + retinfo.append(str(self.bv.entry_function)) + for i in self.bv: + retinfo.append(str(i)) + retinfo.append(hex(self.bv.entry_point)) + retinfo.append(hex(self.bv.start)) + retinfo.append("length: " + hex(len(self.bv))) + return retinfo + + + + +class TestBuilder(Builder): + """ The TestBuilder is for tests that need to be checked against + stored oracle data that isn't from a binary. These test are + generated on your local machine then run again on the build + machine to verify correctness. + + - Function that are tests should start with 'test_' + - Function doc string used as 'on error' message + - Should return: list of strings + """ + + def test_BinaryViewType_list(self): + """BinaryViewType list doesnt match""" + return [x.name for x in binja.BinaryViewType.list] + + def test_Architecture_list(self): + """Architecture list doesnt match""" + return [x.name for x in binja.Architecture.list] + + def test_Assemble(self): + """unexpected assemble result""" + result = [] + # success cases + result.append(binja.Architecture["x86"].assemble("xor eax, eax")) + result.append(binja.Architecture["x86_64"].assemble("xor rax, rax")) + result.append(binja.Architecture["mips32"].assemble("move $ra, $zero")) + result.append(binja.Architecture["mipsel32"].assemble("move $ra, $zero")) + result.append(binja.Architecture["armv7"].assemble("str r2, [sp, #-0x4]!")) + result.append(binja.Architecture["aarch64"].assemble("mov x0, x0")) + result.append(binja.Architecture["thumb2"].assemble("ldr r4, [r4]")) + result.append(binja.Architecture["thumb2eb"].assemble("ldr r4, [r4]")) + # fail cases + result.append(binja.Architecture["x86"].assemble("thisisnotaninstruction")) + result.append(binja.Architecture["x86_64"].assemble("thisisnotaninstruction")) + result.append(binja.Architecture["mips32"].assemble("thisisnotaninstruction")) + result.append(binja.Architecture["mipsel32"].assemble("thisisnotaninstruction")) + result.append(binja.Architecture["armv7"].assemble("thisisnotaninstruction")) + result.append(binja.Architecture["aarch64"].assemble("thisisnotaninstruction")) + result.append(binja.Architecture["thumb2"].assemble("thisisnotaninstruction")) + result.append(binja.Architecture["thumb2eb"].assemble("thisisnotaninstruction")) + return result + + def test_Architecture(self): + """Architecture failure""" + if not os.path.exists(os.path.join(os.path.expanduser("~"), '.binaryninja', 'plugins', 'nes.py')): + return + + retinfo = [] + file_name = os.path.join(self.test_store, "..", "pwnadventurez.nes") + bv = binja.BinaryViewType["NES Bank 0"].open(file_name) + + retinfo.append(str([str(i) for i in bv.platform.arch.calling_conventions])) + retinfo.append(str(bv.platform.arch.full_width_regs)) + + reg = binja.RegisterValue() + retinfo.append(str(reg.entry_value(bv.platform.arch, 'x'))) + retinfo.append(str(reg.constant(0xfe))) + retinfo.append(str(reg.constant_ptr(0xcafebabe))) + retinfo.append(str(reg.stack_frame_offset(0x10))) + retinfo.append(str(reg.imported_address(0xdeadbeef))) + retinfo.append(str(reg.return_address())) + + bv.update_analysis_and_wait() + for func in bv.functions: + for bb in func.low_level_il.basic_blocks: + for ins in bb: + retinfo.append(str(bv.platform.arch.get_instruction_info(0x10, ins.address))) + retinfo.append(str(bv.platform.arch.get_instruction_text(0x10, ins.address))) + retinfo.append(str(ins)) + return retinfo + + + + def test_Function(self): + """Function produced different result""" + inttype = binja.Type.int(4) + testfunction = binja.Type.function(inttype, [inttype, inttype, inttype]) + return [str(testfunction.parameters), str(testfunction.pointer(binja.Architecture["x86"], testfunction))] + + def test_Struct(self): + """Struct produced different result""" + inttype = binja.Type.int(4) + struct = binja.Structure() + struct.a = 1 + struct.insert(0, inttype) + struct.append(inttype) + struct.replace(0, inttype) + struct.remove(1) + retinfo = [str(i) for i in struct.members] + retinfo += [struct.width] + struct.width = 16 + retinfo += [struct.width] + retinfo += [struct.alignment] + struct.alignment = 8 + retinfo += [struct.alignment] + retinfo += [struct.packed] + struct.packed = 1 + retinfo += [struct.packed] + retinfo += [struct.type] + retinfo = [str(i) for i in retinfo] + return retinfo + + def test_Enumeration(self): + """Enumeration produced different result""" + inttype = binja.Type.int(4) + enum = binja.Enumeration() + enum.a = 1 + enum.append("a", 1) + enum.append("b", 2) + enum.replace(0, "a", 2) + enum.remove(0) + retinfo = [str(enum)] + retinfo += [str((enum == enum) and not (enum != enum))] + return retinfo + + def test_Types(self): + """Types produced different result""" + + file_name = os.path.join(self.test_store, "helloworld") + bv = binja.BinaryViewType.get_view_of_file(file_name) + + preprocessed = binja.preprocess_source(""" + #ifdef nonexistant + int foo = 1; + long long foo1 = 1; + #else + int bar = 2; + long long bar1 = 2; + #endif + """) + source = '\n'.join([i.decode("utf-8") for i in preprocessed[0].split('\n') if not b"#line" in i and len(i) > 0]) + typelist = bv.platform.parse_types_from_source(source) + inttype = binja.Type.int(4) + + tokens = inttype.get_tokens() + inttype.get_tokens_before_name() + inttype.get_tokens_after_name() + namedtype = binja.NamedTypeReference() + + retinfo = [[str(i) for i in typelist.variables.popitem()][::-1] for i in range(len(typelist.variables))] + retinfo += [str(namedtype)] + + equalcheck = (inttype == inttype) and not (inttype != inttype) + retinfo += [str(equalcheck)] + return retinfo + + + def test_Plugin_bin_info(self): + """print_syscalls plugin produced different result""" + + file_name = os.path.join(self.test_store, "helloworld") + self.unpackage_file(file_name) + result = subprocess.Popen(["python", os.path.join(self.examples_dir, "bin_info.py"), file_name], stdout=subprocess.PIPE).communicate()[0] + # normalize line endings and path sep + return [result.replace(b"\\", b"/").replace(b"\r\n", b"\n")] + + def test_linear_disassembly(self): + """linear_disassembly produced different result""" + file = os.path.join(self.test_store, "helloworld") + self.unpackage_file(file) + bv = binja.BinaryViewType['ELF'].open(file) + settings = binja.DisassemblySettings() + disass = bv.linear_disassembly + res = [] + for i in disass: + res.append(str(i)) + #return res + + def test_partial_register_dataflow(self): + """partial_register_dataflow produced different results""" + + file_name = os.path.join(self.test_store, "partial_register_dataflow") + self.unpackage_file(file_name) + result = [] + try: + reg_list = ['ch', 'cl', 'ah', 'edi', 'al', 'cx', 'ebp', 'ax', 'edx', 'ebx', 'esp', 'esi', 'dl', 'dh', 'di', 'bl', 'bh', 'eax', 'dx', 'bx', 'ecx', 'sp', 'si'] + bv = binja.BinaryViewType.get_view_of_file(file_name) + for func in bv.functions: + llil = func.low_level_il + for i in range(0, llil.__len__()-1): + result.append(["LLIL:" + str(i).replace('L', '') + ":" + x + ":" + str(llil[i].get_reg_value(x)).replace('L', '') for x in reg_list]) + result.append(["LLIL:" + str(i).replace('L', '') + ":" + x + ":" + str(llil[i].get_possible_reg_values(x)).replace('L', '') for x in reg_list]) + result.append(["LLIL:" + str(i).replace('L', '') + ":" + x + ":" + str(llil[i].get_reg_value_after(x)).replace('L', '') for x in reg_list]) + result.append(["LLIL:" + str(i).replace('L', '') + ":" + x + ":" + str(llil[i].get_possible_reg_values_after(x)).replace('L', '') for x in reg_list]) + bv.file.close() + del bv + finally: + os.unlink(file_name) + + return result + + + def test_low_il_stack(self): + """LLIL stack produced different output""" + file_name = os.path.join(self.test_store, "jumptable_reordered") + self.unpackage_file(file_name) + bv = binja.BinaryViewType.get_view_of_file(file_name) + reg_list = ['ch', 'cl', 'ah', 'edi', 'al', 'cx', 'ebp', 'ax', 'edx', 'ebx', 'esp', 'esi', 'dl', 'dh', 'di', 'bl', 'bh', 'eax', 'dx', 'bx', 'ecx', 'sp', 'si'] + flag_list = ['c', 'p', 'a', 'z', 's', 'o'] + retinfo = [] + for func in bv.functions: + for bb in func.low_level_il.basic_blocks: + for ins in bb: + retinfo.append(str(ins.get_stack_contents(0,1))) + retinfo.append(str(ins.get_stack_contents_after(0,1))) + retinfo.append(str(ins.get_possible_stack_contents(0,1))) + retinfo.append(str(ins.get_possible_stack_contents_after(0,1))) + + + for flag in flag_list: + retinfo.append(str(ins.get_flag_value(flag))) + retinfo.append(str(ins.get_flag_value_after(flag))) + retinfo.append(str(ins.get_possible_flag_values(flag))) + retinfo.append(str(ins.get_possible_flag_values_after(flag))) + + os.unlink(file_name) + + return retinfo + + def test_med_il_stack(self): + """MLIL stack produced different output""" + file_name = os.path.join(self.test_store, "jumptable_reordered") + self.unpackage_file(file_name) + bv = binja.BinaryViewType.get_view_of_file(file_name) + reg_list = ['ch', 'cl', 'ah', 'edi', 'al', 'cx', 'ebp', 'ax', 'edx', 'ebx', 'esp', 'esi', 'dl', 'dh', 'di', 'bl', 'bh', 'eax', 'dx', 'bx', 'ecx', 'sp', 'si'] + flag_list = ['c', 'p', 'a', 'z', 's', 'o'] + retinfo = [] + for func in bv.functions: + for bb in func.medium_level_il.basic_blocks: + for ins in bb: + retinfo.append(str(ins.get_var_for_stack_location(0))) + retinfo.append(str(ins.get_stack_contents(0, 0x10))) + retinfo.append(str(ins.get_stack_contents_after(0, 0x10))) + retinfo.append(str(ins.get_possible_stack_contents(0, 0x10))) + retinfo.append(str(ins.get_possible_stack_contents_after(0, 0x10))) + + for reg in reg_list: + retinfo.append(str(ins.get_var_for_reg(reg))) + retinfo.append(str(ins.get_reg_value(reg))) + retinfo.append(str(ins.get_reg_value_after(reg))) + retinfo.append(str(ins.get_possible_reg_values(reg))) + retinfo.append(str(ins.get_possible_reg_values_after(reg))) + + + for flag in flag_list: + retinfo.append(str(ins.get_flag_value(flag))) + retinfo.append(str(ins.get_flag_value_after(flag))) + retinfo.append(str(ins.get_possible_flag_values(flag))) + retinfo.append(str(ins.get_possible_flag_values_after(flag))) + + os.unlink(file_name) + + return retinfo + + + def test_events(self): + """Event failure""" + file_name = os.path.join(self.test_store, "helloworld") + self.unpackage_file(file_name) + bv = binja.BinaryViewType['ELF'].open(file_name) + + results = [] + + + def simple_complete(self): + results.append("analysis complete") + + evt = binja.AnalysisCompletionEvent(bv, simple_complete) + + class NotifyTest(binja.BinaryDataNotification): + + def data_written(self, view, offset, length): + def data_written_complete(self): + results.append("data written {0} {1}".format(offset, length)) + evt = binja.AnalysisCompletionEvent(bv, data_written_complete) + + def data_inserted(self, view, offset, length): + def data_inserted_complete(self): + results.append("data inserted {0} {1}".format(offset, length)) + evt = binja.AnalysisCompletionEvent(bv, data_inserted_complete) + + def data_removed(self, view, offset, length): + def data_removed_complete(self): + results.append("data removed {0} {1}".format(offset, length)) + evt = binja.AnalysisCompletionEvent(bv, data_removed_complete) + + def function_added(self, view, func): + def function_added_complete(self): + results.append("function added {0}".format(func.name)) + evt = binja.AnalysisCompletionEvent(bv, function_added_complete) + + def function_removed(self, view, func): + def function_removed_complete(self): + results.append("function removed {0}".format(func.name)) + evt = binja.AnalysisCompletionEvent(bv, function_removed_complete) + + def function_updated(self, view, func): + def function_updated_complete(self): + results.append("function updated {0}".format(func.name)) + evt = binja.AnalysisCompletionEvent(bv, function_updated_complete) + + def function_update_requested(self, view, func): + def function_update_requested_complete(self): + results.append("function update requested {0}".format(func.name)) + evt = binja.AnalysisCompletionEvent(bv, function_update_requested_complete) + + def data_var_added(self, view, var): + def data_var_added_complete(self): + results.append("data var added {0}".format(var.name)) + evt = binja.AnalysisCompletionEvent(bv, data_var_added_complete) + + def data_var_removed(self, view, var): + def data_var_removed_complete(self): + results.append("data var removed {0}".format(var.name)) + evt = binja.AnalysisCompletionEvent(bv, data_var_removed_complete) + + def data_var_updated(self, view, var): + def data_var_updated_complete(self): + results.append("data var updated {0}".format(var.name)) + evt = binja.AnalysisCompletionEvent(bv, data_var_updated_complete) + + def string_found(self, view, string_type, offset, length): + def string_found_complete(self): + results.append("string found {0} {1}".format(offset, length)) + evt = binja.AnalysisCompletionEvent(bv, string_found_complete) + + def string_removed(self, view, string_type, offset, length): + def string_removed_complete(self): + results.append("string removed {0} {1}".format(offset, length)) + evt = binja.AnalysisCompletionEvent(bv, string_removed_complete) + + def type_defined(self, view, name, type): + def type_defined_complete(self): + results.append("type defined {0} {1}".format(name)) + evt = binja.AnalysisCompletionEvent(bv, type_defined_complete) + + def type_undefined(self, view, name, type): + def type_undefined_complete(self): + results.append("type undefined {0} {1}".format(name)) + evt = binja.AnalysisCompletionEvent(bv, type_undefined_complete) + + + test = NotifyTest() + bv.register_notification(test) + sacrificial_addr = 0x84fc + + + type, name = bv.parse_type_string("int foo") + type_id = type.generate_auto_type_id("source", name) + bv.define_type(type_id, name, type) + bv.undefine_type(type_id) + + bv.insert(sacrificial_addr, "AAAA") + bv.define_data_var(sacrificial_addr, binja.types.Type.int(4)) + + bv.write(sacrificial_addr, "BBBB") + + bv.add_function(sacrificial_addr) + bv.remove_function(bv.get_function_at(sacrificial_addr)) + + bv.undefine_data_var(sacrificial_addr) + bv.remove(sacrificial_addr, 4) + + bv.update_analysis_and_wait() + + bv.unregister_notification(test) + + return str(sorted(results)) + + def unpackage(self, fileName): + testname = None + with zipfile.ZipFile(fileName, "r") as zf: + testname = zf.namelist()[0] + zf.extractall() + + if not os.path.exists(testname + ".pkl"): + return None, None + binary_oracle = pickle.load(open(testname + ".pkl", "rb")) + return binary_oracle.oracle_test_data, testname + + def cleanup_package(self, fileName): + if fileName.endswith(".zip"): + os.unlink(fileName[:-4]) + + +class VerifyBuilder(Builder): + """ The VerifyBuilder is for tests that verify + Binary Ninja against expected output. + + - Function that are tests should start with 'test_' + - Function doc string used as 'on error' message + - Should return: boolean + """ + def __init__(self, test_store): + super(VerifyBuilder, self).__init__(test_store) + + def get_functions(self, bv): + return [x.start for x in bv.functions] + + def get_comments(self, bv): + return bv.functions[0].comments + + def test_verify_BNDB_round_trip(self): + """Binary Ninja Database output doesn't match its input""" + # This will test Binja's ability to save and restore databases + # By: + # - Creating a binary view + # - Make modification that impact the database + # - Record those modification + # - Save the database + # - Restore the datbase + # - Validate that the modifications are present + file = os.path.join(self.test_store, "helloworld") + self.unpackage_file(file) + try: + bv = binja.BinaryViewType['ELF'].open(file) + bv.update_analysis_and_wait() + # Make some modifications to the binary view + + # Add a comment + bv.functions[0].set_comment(bv.functions[0].start, "Function start") + # Add a new function + bv.add_function(bv.functions[0].start + 4) + temp_name = next(tempfile._get_candidate_names()) + ".bndb" + + comments = self.get_comments(bv) + functions = self.get_functions(bv) + bv.create_database(temp_name) + bv.file.close() + del bv + finally: + os.unlink(file) + + try: + bv = binja.FileMetadata(temp_name).open_existing_database(temp_name).get_view_of_type('ELF') + bv.update_analysis_and_wait() + bndb_functions = self.get_functions(bv) + bndb_comments = self.get_comments(bv) + # force windows to close the handle to the bndb that we want to delete + bv.file.close() + del bv + return [str(functions == bndb_functions and comments == bndb_comments)] + finally: + os.unlink(temp_name) + |