def __init__(self, data): BinaryView.__init__(self, file_metadata=data.file, parent_view=data) self.raw = data self.platform = Architecture['Tiamat'].standalone_platform self.add_auto_segment( BASE_ADDR, BASE_ADDR + 0x404 * 4, 0, len(data), SegmentFlag.SegmentReadable | SegmentFlag.SegmentExecutable)
def _check_breakpoints(bv: BinaryView, dbg: DebugAdapter, addr: int, function_breakpoints: dict, call_breakpoints: dict) -> List[str]: """Return [name,] on function start or [caller, callee] on intermodular calls. Returns [] otherwise. """ retval = [] if addr in function_breakpoints: cur_func = function_breakpoints[addr] #print('[DBG] START function %s @ 0x%x' % (cur_func, addr)) retval = [ cur_func, ] # intentional: this may be overridden below if addr in call_breakpoints: cur_func = call_breakpoints[addr] call_target = _get_pc(dbg) target_func_obj = bv.get_function_at(call_target) if target_func_obj is None: offset = call_target if bv.is_valid_offset(offset): print('[!] Unknown function at offset 0x%x' % offset) target_func = "UNK_%x" % offset else: target_func = "EXTERNAL_%x" % call_target else: target_func = target_func_obj.name #print('[DBG] CALL from 0x%x in %s -> 0x%x in %s' % (addr, cur_func, call_target, target_func)) if not target_func.startswith('EXTERNAL_'): retval = [cur_func, target_func] return retval
def __init__(self, data): BinaryView.__init__(self, parent_view=data, file_metadata=data.file) # Playstation 1 used a little endian MIPS R3000a # without floating point support, but with some # extended instructions for triangle transformation # and lighting. mipsel32 will do for now. self.platform = Architecture['mipsel32'].standalone_platform
def __init__(self, data): BinaryView.__init__(self, parent_view = data, file_metadata = data.file) #Cortex-M vectors should always be Thumb-2 self.platform= Architecture['thumb2'].standalone_platform #Create a new segment, set the base address to 0x37FC0, and read the data file self.add_auto_segment(0x37FC0, 0x200000, 0, 0x200000, SegmentFlag.SegmentReadable | SegmentFlag.SegmentExecutable)
def __init__(self, data): BinaryView.__init__(self, parent_view=data, file_metadata=data.file) # TODO: allow different bits self.data = data self.disassembler = HsqDisassembler(self.data[:], 8) HigherSubleq64.disassembler = self.disassembler self.arch = Architecture["hsq64"] self.platform = Architecture["hsq64"].standalone_platform
def __init__(self, parent, view: BinaryView): self.view = view if view.entry_function: self.graph = CallGraph(view.entry_function) elif view.functions: self.graph = CallGraph(view.functions[0]) else: self.graph = None FlowGraphWidget.__init__(self, parent, view, self.graph) BinaryDataNotification.__init__(self) view.register_notification(self)
def __init__(self, data): if data.read(0,16)[8:12] == 'sAP4': # read and unpack the packed data packed_offset = 0x37e70 packed_size = struct.unpack('<L', data.read(packed_offset, 4))[0] unpacked_data = ROM.unpack(data.read(packed_offset + 4, packed_size)) # substitute a new parent view with the unpacked data appended replacement_parent = BinaryView.new(data = data.read(0, len(data)) + unpacked_data) BinaryView.__init__(self, file_metadata=data.file, parent_view = replacement_parent) self.data = data else: BinaryView.__init__(self, parent_view = data, file_metadata = data.file)
def test_load_settings(self): bvt_name = "Mapped (Python)" if "Mapped (Python)" in map( lambda bvt: bvt.name, list(BinaryViewType)) else "Mapped" raw_view = BinaryView.new(b'0x55') assert raw_view.view_type == "Raw", "test_load_settings failed" mapped_view = BinaryViewType[bvt_name].create(raw_view) assert mapped_view.view_type == bvt_name, "test_load_settings failed" assert mapped_view.segments[0].start == 0, "test_load_settings failed" assert len(mapped_view) == 4, "test_load_settings failed" load_settings = BinaryViewType[bvt_name].get_load_settings_for_data( raw_view) assert load_settings is not None, "test_load_settings failed" assert load_settings.contains( "loader.architecture"), "test_load_settings failed" assert load_settings.contains( "loader.platform"), "test_load_settings failed" assert load_settings.contains( "loader.imageBase"), "test_load_settings failed" assert load_settings.contains( "loader.entryPointOffset"), "test_load_settings failed" load_settings.set_string("loader.architecture", 'x86_64') load_settings.set_integer("loader.imageBase", 0x500000) load_settings.set_integer("loader.entryPointOffset", 0) raw_view.set_load_settings(bvt_name, load_settings) mapped_view = BinaryViewType[bvt_name].create(raw_view) assert mapped_view.view_type == bvt_name, "test_load_settings failed" assert mapped_view.segments[ 0].start == 0x500000, "test_load_settings failed" assert len(mapped_view) == 4, "test_load_settings failed" assert raw_view.get_load_settings(bvt_name) == load_settings raw_view.set_load_settings(bvt_name, None) assert raw_view.get_load_settings(bvt_name) is None
def __init__(self, data): BinaryView.__init__(self, parent_view=data, file_metadata=data.file) # not sure what this is for, copied from somewhere: self.platform = Architecture['8051'].standalone_platform # See https://github.com/Vector35/binaryninja-api/issues/645 # This ensures endianness is propagated; not a huge deal. # While SFRs are arranged in LE order, compilers often store things in # BE order. May be worth having 8051-LE and 8051-BE archs in the # future. self.arch = Architecture['8051'] # Don't think this package uses them - leaving them for easy access # from REPL. self.CODE = mem.CODE self.SFRs = mem.SFRs self.IRAM = mem.IRAM self.XRAM = mem.XRAM
def _get_lines_for_data(self, ctxt, view, addr, type, prefix, prefixCount, width, count, typeCtx, ctxCount): try: file_metadata = FileMetadata(handle=core.BNGetFileForView(view)) view = BinaryView(file_metadata=file_metadata, handle=core.BNNewViewReference(view)) type = Type(handle=core.BNNewTypeReference(type)) prefixTokens = InstructionTextToken.get_instruction_lines( prefix, prefixCount) pycontext = [] for i in range(ctxCount): pycontext.append(Type(core.BNNewTypeReference(typeCtx[i]))) result = self.perform_get_lines_for_data(ctxt, view, addr, type, prefixTokens, width, pycontext) count[0] = len(result) line_buf = (core.BNDisassemblyTextLine * len(result))() for i in range(len(result)): line = result[i] color = line.highlight if not isinstance(color, HighlightStandardColor) and not isinstance( color, highlight.HighlightColor): raise ValueError( "Specified color is not one of HighlightStandardColor, highlight.HighlightColor" ) if isinstance(color, HighlightStandardColor): color = highlight.HighlightColor(color) line_buf[i].highlight = color._get_core_struct() if line.address is None: if len(line.tokens) > 0: line_buf[i].addr = line.tokens[0].address else: line_buf[i].addr = 0 else: line_buf[i].addr = line.address if line.il_instruction is not None: line_buf[i].instrIndex = line.il_instruction.instr_index else: line_buf[i].instrIndex = 0xffffffffffffffff line_buf[i].count = len(line.tokens) line_buf[ i].tokens = InstructionTextToken.get_instruction_lines( line.tokens) return ctypes.cast(line_buf, ctypes.c_void_p).value except: log_error(traceback.format_exc()) return None
def _is_valid_for_data(self, ctxt, view, addr, type, context, ctxCount): try: file_metadata = FileMetadata(handle=core.BNGetFileForView(view)) view = BinaryView(file_metadata=file_metadata, handle=core.BNNewViewReference(view)) type = Type(handle=core.BNNewTypeReference(type)) pycontext = [] for i in range(0, ctxCount): pycontext.append(Type(core.BNNewTypeReference(context[i]))) return self.perform_is_valid_for_data(ctxt, view, addr, type, pycontext) except: log_error(traceback.format_exc()) return False
def _rebase_bv(bv: BinaryView, dbg: DebugAdapter.DebugAdapter) -> BinaryView: """Get a rebased BinaryView for support of ASLR compatible binaries.""" new_base = dbg.target_base() if core_ui_enabled() and new_base != bv.start: dbg.quit() raise Exception('[!] Can\'t do necessary rebase in GUI, try headless operation') new_bv = bv.rebase(new_base) if new_bv is None: # None if rebasing is unecessary return bv print('[*] Rebasing bv from 0x%x to 0x%x' % (bv.start, new_base)) new_bv.update_analysis_and_wait() # required after rebase return new_bv
def __init__(self, data): BinaryView.__init__(self, parent_view=data, file_metadata=data.file) self.platform = Architecture['thumb2'].standalone_platform self.MCUS = [ "STM32F0", "STM32F1", "STM32F2", "STM32F3", "STM32F4", "STM32F7", "STM32L0", "STM32L1", "STM32L4", "EFM32TG", "EFM32G", "EFM32LG", "EFM32GG", "EFM32HG", "EFM32WG", "EZR32WG", "LPC13XX", "LPC17XX", "LPC43XX_M4", "LPC43XX_M0", "SAM3A", "SAM3N", "SAM3S", "SAM3U", "SAM3X", "SAM4L", "SAMD", "LM3S", "LM4F", "MSP432E4", "VF6XX", ]
def perform_get_lines_for_data( self, _, bv: BinaryView, addr: int, type: Type, prefix: List[InstructionTextToken], width: int, context: List[str]) -> List[DisassemblyTextLine]: end = addr + len(type) result: List[DisassemblyTextLine] = [] for tokens, size in bv.disassembly_tokens(addr, bv.arch): if addr + size > end: break result.append( DisassemblyTextLine( [*tokens], addr, color=HighlightStandardColor.RedHighlightColor)) addr += size return result
def make_code(bv: BinaryView, start: int, end: int) -> None: if bv.get_basic_blocks_at(start): return if end - start <= 1: # find the next basic block, data variable, or segment/section end data_var = bv.get_next_data_var_after(start) if data_var is not None: end = data_var.address else: end = bv.end end = min(bv.get_next_basic_block_start_after(start), end) seg = bv.get_segment_at(start) if seg is not None: end = min(seg.end, end) section_ends = [s.end for s in bv.get_sections_at(start)] end = min(*section_ends, end) bv.define_data_var(start, Type.array(Type.int(1, False), end - start), f"CODE_{start:08x}")
__name__ = "__console__" # angr looks for this, it won't load from within a UI without it import angr # For the lazy instead you can just import everything 'from binaryninja import *'' from binaryninja.binaryview import BinaryView from binaryninja.plugin import BackgroundTaskThread, PluginCommand from binaryninja.interaction import show_plain_text_report, show_message_box from binaryninja.highlight import HighlightColor from binaryninja.enums import HighlightStandardColor, MessageBoxButtonSet, MessageBoxIcon # Disable warning logs as they show up as errors in the UI logging.disable(logging.WARNING) # Create sets in the BinaryView's data field to store the desired path for each view BinaryView.set_default_session_data("angr_find", set()) BinaryView.set_default_session_data("angr_avoid", set()) def escaped_output(str): return '\n'.join([s.encode("string_escape") for s in str.split('\n')]) # Define a background thread object for solving in the background class Solver(BackgroundTaskThread): def __init__(self, find, avoid, view): BackgroundTaskThread.__init__(self, "Solving with angr...", True) self.find = tuple(find) self.avoid = tuple(avoid) self.view = view
def __init__(self, data): BinaryView.__init__(self, parent_view=data, file_metadata=data.file) self.platform = Architecture["armv7"].standalone_platform self.data = data self.offt = 0
def __init__(self, data): # data is a binaryninja.binaryview.BinaryView BinaryView.__init__(self, parent_view = data, file_metadata = data.file) self.platform = Architecture['Z80'].standalone_platform self.data = data
def __init__(self, data): BinaryView.__init__(self, parent_view=data, file_metadata=data.file) self.platform = Architecture[GB.name].standalone_platform self.raw = data
def test_available_types(self): """Available types don't match""" return [ "Available Type: " + x.name for x in BinaryView( FileMetadata()).open(self.filename).available_view_types ]
def __init__(self, binaryView): # data is a binaryninja.binaryview.BinaryView BinaryView.__init__(self, parent_view=binaryView, file_metadata=binaryView.file)
def __init__(self, data): super().__init__(data) self.hdr_read_offset = 0x4 self.app_name = self.hdr_read(0xC) self.titleID = self.hdr_read(0x8) self.hdr_read_offset = 0x1F flags = self.hdr_read(1) compressed = [] for segm in range(3): compressed.append(((flags >> segm) & 1) == 1) offset = 0 self.text_offset = self.base + self.hdr_read(4) self.text_size = self.hdr_read(4) text_bin_size = self.hdr_read(4) self.hdr_read_offset += 4 self.rodata_offset = self.base + self.hdr_read(4) self.rodata_size = self.hdr_read(4) rodata_bin_size = self.hdr_read(4) self.hdr_read_offset += 4 self.data_offset = self.base + self.hdr_read(4) self.data_size = self.hdr_read(4) data_bin_size = self.hdr_read(4) self.hdr_read_offset += 4 self.bss_offset = self.base + self.hdr_read(4) self.bss_size = self.hdr_read(4) text_raw = self.raw.read(self.HDR_SIZE, text_bin_size) if compressed[self.TEXT]: self.log("Decompressing .text") text_raw = kip1_blz_decompress(text_raw) flags &= 0b0011_1110 self.hdr_write(4, 0x24, self.page_align_up(self.text_size)) self.hdr_write(4, 0x28, self.page_align_up(self.text_size)) rodata_raw = self.raw.read(self.HDR_SIZE + text_bin_size, rodata_bin_size) if compressed[self.RODATA]: self.log("Decompressing .rodata") rodata_raw = kip1_blz_decompress(rodata_raw) flags &= 0b0011_1101 self.hdr_write(4, 0x34, self.page_align_up(self.rodata_size)) self.hdr_write(4, 0x38, self.page_align_up(self.rodata_size)) data_raw = self.raw.read( self.HDR_SIZE + text_bin_size + rodata_bin_size, data_bin_size) if compressed[self.DATA]: self.log("Decompressing .data") data_raw = kip1_blz_decompress(data_raw) flags &= 0b0011_1011 self.hdr_write(4, 0x44, self.page_align_up(self.data_size)) self.hdr_write(4, 0x48, self.page_align_up(self.data_size)) self.hdr_write(1, 0x1F, flags) binary = self.hdr binary += self.page_pad(text_raw) binary += self.page_pad(rodata_raw) binary += self.page_pad(data_raw) binary += b'\x00' * self.bss_size self.raw = binary data.write(0, binary) BinaryView.__init__(self, file_metadata=data.file, parent_view=data)
def __init__(self, data): BinaryView.__init__(self, parent_view=data, file_metadata=data.file) self.platform = Architecture['vmndh-2k12'].standalone_platform
def __init__(self, data): super().__init__(data) self.reader.seek(4) self.app_name = self.reader.read(0xC).decode('ascii') self.titleID = self.reader.read64() self.reader.seek(0x1F) flags = self.reader.read8() compressed = [] for segm in range(3): compressed.append(((flags >> segm) & 1) == 1) self.text_offset = self.reader.read32() self.text_size = self.reader.read32() text_bin_size = self.reader.read32() self.reader.seek_relative(4) self.rodata_offset = self.reader.read32() self.rodata_size = self.reader.read32() rodata_bin_size = self.reader.read32() self.reader.seek_relative(4) self.data_offset = self.reader.read32() self.data_size = self.reader.read32() data_bin_size = self.reader.read32() self.reader.seek_relative(4) self.bss_offset = self.reader.read32() self.bss_size = self.reader.read32() self.reader.seek(self.HDR_SIZE) text_raw = self.reader.read(text_bin_size) if compressed[self.TEXT]: self.log("Decompressing .text") text_raw = kip1_blz_decompress(text_raw) flags &= 0b0011_1110 text_raw = self.page_pad(text_raw) self.text_size = len(text_raw) self.writer.seek(0x24) for x in range(2): self.writer.write32(self.text_size) rodata_raw = self.reader.read(rodata_bin_size) if compressed[self.RODATA]: self.log("Decompressing .rodata") rodata_raw = kip1_blz_decompress(rodata_raw) flags &= 0b0011_1101 rodata_raw = self.page_pad(rodata_raw) self.rodata_size = len(rodata_raw) self.writer.seek(0x34) for x in range(2): self.writer.write32(self.rodata_size) data_raw = self.reader.read(data_bin_size) if compressed[self.DATA]: self.log("Decompressing .data") data_raw = kip1_blz_decompress(data_raw) flags &= 0b0011_1011 data_raw = self.page_pad(data_raw) self.data_size = len(data_raw) self.writer.seek(0x44) for x in range(2): self.writer.write32(self.data_size) self.writer.seek(0x1F) self.writer.write8(flags) self.reader.seek(0) self.raw = self.reader.read(self.HDR_SIZE) self.raw += text_raw self.raw += rodata_raw self.raw += data_raw data.write(0, self.raw) BinaryView.__init__(self, file_metadata=data.file, parent_view=data)
def __init__(self, data): BinaryView.__init__(self, parent_view=data, file_metadata=data.file) self._lief_handler: lief.ELF.Binary = lief.parse(data.file.filename)
def __init__(self, data): BinaryView.__init__(self, parent_view=data, file_metadata=data.file) self.platform = Architecture[ "6502"].standalone_platform # type: ignore
def test_settings_usage(self): settings = Settings("test") assert not settings.contains( "testGroup.testSetting"), "test_settings_types failed" assert settings.register_group("testGroup", "Title"), "test_settings_types failed" assert not settings.register_setting( "testGroup.boolSetting", '{"description" : "Test description.", "title" : "Test Title", "default" : 500, "type" : "boolean", "id" : "boolSetting"}' ), "test_settings_types failed" assert settings.register_setting( "testGroup.boolSetting", '{"description" : "Test description.", "title" : "Test Title", "default" : true, "type" : "boolean", "id" : "boolSetting"}' ), "test_settings_types failed" assert not settings.register_setting( "testGroup.doubleSetting", '{"description" : "Test description.", "title" : "Test Title", "default" : true, "type" : "number", "id" : "doubleSetting"}' ), "test_settings_types failed" assert settings.register_setting( "testGroup.doubleSetting", '{"description" : "Test description.", "title" : "Test Title", "default" : 500, "type" : "number", "id" : "doubleSetting"}' ), "test_settings_types failed" assert settings.register_setting( "testGroup.integerSetting", '{"description" : "Test description.", "title" : "Test Title", "default" : 500, "type" : "number", "id" : "integerSetting"}' ), "test_settings_types failed" assert not settings.register_setting( "testGroup.stringSetting", '{"description" : "Test description.", "title" : "Test Title", "default" : 500, "type" : "string", "id" : "stringSetting"}' ), "test_settings_types failed" assert settings.register_setting( "testGroup.stringSetting", '{"description" : "Test description.", "title" : "Test Title", "default" : "value", "type" : "string", "id" : "stringSetting"}' ), "test_settings_types failed" assert not settings.register_setting( "testGroup.stringListSetting", '{"description" : "Test description.", "title" : "Test Title", "default" : true, "type" : "array", "id" : "stringListSetting"}' ), "test_settings_types failed" assert settings.register_setting( "testGroup.stringListSetting", '{"description" : "Test description.", "title" : "Test Title", "default" : ["value1", "value2"], "type" : "array", "id" : "stringListSetting"}' ), "test_settings_types failed" assert settings.register_setting( "testGroup.ignoreResourceBoolSetting", '{"description" : "Test description.", "title" : "Test Title", "default" : true, "type" : "boolean", "id" : "boolSetting", "ignore" : ["SettingsResourceScope"]}' ), "test_settings_types failed" assert settings.register_setting( "testGroup.ignoreUserBoolSetting", '{"description" : "Test description.", "title" : "Test Title", "default" : true, "type" : "boolean", "id" : "boolSetting", "ignore" : ["SettingsUserScope"]}' ), "test_settings_types failed" assert settings.register_setting( "testGroup.readOnlyBoolSetting", '{"description" : "Test description.", "title" : "Test Title", "default" : true, "type" : "boolean", "id" : "boolSetting", "ignore" : ["SettingsResourceScope", "SettingsUserScope"]}' ), "test_settings_types failed" assert settings.contains( "testGroup.boolSetting"), "test_settings_types failed" assert settings.contains( "testGroup.doubleSetting"), "test_settings_types failed" assert settings.contains( "testGroup.integerSetting"), "test_settings_types failed" assert settings.contains( "testGroup.stringSetting"), "test_settings_types failed" assert settings.contains( "testGroup.stringListSetting"), "test_settings_types failed" assert settings.get_bool( "testGroup.boolSetting") == True, "test_settings_types failed" assert settings.get_double( "testGroup.doubleSetting") == 500, "test_settings_types failed" assert settings.get_integer( "testGroup.integerSetting") == 500, "test_settings_types failed" assert settings.get_string( "testGroup.stringSetting") == "value", "test_settings_types failed" assert settings.get_string_list("testGroup.stringListSetting") == [ "value1", "value2" ], "test_settings_types failed" assert settings.set_bool("testGroup.boolSetting", False), "test_settings_types failed" assert settings.set_double("testGroup.doubleSetting", 700), "test_settings_types failed" assert settings.set_integer("testGroup.integerSetting", 700), "test_settings_types failed" assert settings.set_string("testGroup.stringSetting", "value_user"), "test_settings_types failed" assert settings.set_string_list( "testGroup.stringListSetting", ["value3", "value4"]), "test_settings_types failed" assert settings.get_bool( "testGroup.boolSetting") == False, "test_settings_types failed" assert settings.get_double( "testGroup.doubleSetting") == 700, "test_settings_types failed" assert settings.get_integer( "testGroup.integerSetting") == 700, "test_settings_types failed" assert settings.get_string( "testGroup.stringSetting" ) == "value_user", "test_settings_types failed" assert settings.get_string_list("testGroup.stringListSetting") == [ "value3", "value4" ], "test_settings_types failed" assert settings.get_bool_with_scope( "testGroup.boolSetting", scope=SettingsScope.SettingsDefaultScope )[0] == True, "test_settings_types failed" assert settings.get_double_with_scope( "testGroup.doubleSetting", scope=SettingsScope.SettingsDefaultScope )[0] == 500, "test_settings_types failed" assert settings.get_integer_with_scope( "testGroup.integerSetting", scope=SettingsScope.SettingsDefaultScope )[0] == 500, "test_settings_types failed" assert settings.get_string_with_scope( "testGroup.stringSetting", scope=SettingsScope.SettingsDefaultScope )[0] == "value", "test_settings_types failed" assert settings.get_string_list_with_scope( "testGroup.stringListSetting", scope=SettingsScope.SettingsDefaultScope)[0] == [ "value1", "value2" ], "test_settings_types failed" assert settings.get_bool_with_scope( "testGroup.boolSetting", scope=SettingsScope.SettingsUserScope )[0] == False, "test_settings_types failed" assert settings.get_double_with_scope( "testGroup.doubleSetting", scope=SettingsScope.SettingsUserScope )[0] == 700, "test_settings_types failed" assert settings.get_integer_with_scope( "testGroup.integerSetting", scope=SettingsScope.SettingsUserScope )[0] == 700, "test_settings_types failed" assert settings.get_string_with_scope( "testGroup.stringSetting", scope=SettingsScope.SettingsUserScope )[0] == "value_user", "test_settings_types failed" assert settings.get_string_list_with_scope( "testGroup.stringListSetting", scope=SettingsScope.SettingsUserScope)[0] == [ "value3", "value4" ], "test_settings_types failed" raw_view = BinaryView.new(b'0x55') assert not settings.set_bool("testGroup.ignoreResourceBoolSetting", False, scope=SettingsScope.SettingsDefaultScope ), "test_settings_types failed" assert not settings.set_bool("testGroup.ignoreResourceBoolSetting", False, scope=SettingsScope.SettingsResourceScope ), "test_settings_types failed" assert not settings.set_bool("testGroup.ignoreResourceBoolSetting", False, raw_view, scope=SettingsScope.SettingsResourceScope ), "test_settings_types failed" assert settings.set_bool("testGroup.ignoreResourceBoolSetting", False, scope=SettingsScope.SettingsUserScope ), "test_settings_types failed" assert not settings.set_bool("testGroup.ignoreUserBoolSetting", False), "test_settings_types failed" assert settings.set_bool("testGroup.ignoreUserBoolSetting", False, raw_view), "test_settings_types failed" assert settings.set_bool("testGroup.ignoreUserBoolSetting", False, raw_view, scope=SettingsScope.SettingsResourceScope ), "test_settings_types failed" assert not settings.set_bool("testGroup.readOnlyBoolSetting", False), "test_settings_types failed" assert not settings.set_bool("testGroup.readOnlyBoolSetting", False, scope=SettingsScope.SettingsResourceScope ), "test_settings_types failed" assert not settings.set_bool("testGroup.readOnlyBoolSetting", False, scope=SettingsScope.SettingsUserScope ), "test_settings_types failed" s2 = Settings("test2") assert s2.serialize_schema() == "", "test_settings_types failed" test_schema = settings.serialize_schema() assert test_schema != "", "test_settings_types failed" assert s2.deserialize_schema(test_schema), "test_settings_types failed" assert s2.get_bool( "testGroup.boolSetting") == True, "test_settings_types failed" assert s2.get_double( "testGroup.doubleSetting") == 500, "test_settings_types failed" assert s2.get_integer( "testGroup.integerSetting") == 500, "test_settings_types failed" assert s2.get_string( "testGroup.stringSetting") == "value", "test_settings_types failed" assert s2.get_string_list("testGroup.stringListSetting") == [ "value1", "value2" ], "test_settings_types failed" assert s2.deserialize_settings( settings.serialize_settings(scope=SettingsScope.SettingsUserScope), raw_view, SettingsScope.SettingsResourceScope), "test_settings_types failed" assert s2.get_bool("testGroup.boolSetting", raw_view) == False, "test_settings_types failed" assert s2.get_double("testGroup.doubleSetting", raw_view) == 700, "test_settings_types failed" assert s2.get_integer("testGroup.integerSetting", raw_view) == 700, "test_settings_types failed" assert s2.get_string( "testGroup.stringSetting", raw_view) == "value_user", "test_settings_types failed" assert s2.get_string_list("testGroup.stringListSetting", raw_view) == ["value3", "value4" ], "test_settings_types failed" assert s2.reset_all(), "test_settings_types failed" assert s2.get_bool( "testGroup.boolSetting") == True, "test_settings_types failed" assert s2.get_double( "testGroup.doubleSetting") == 500, "test_settings_types failed" assert s2.get_integer( "testGroup.integerSetting") == 500, "test_settings_types failed" assert s2.get_string( "testGroup.stringSetting") == "value", "test_settings_types failed" assert s2.get_string_list("testGroup.stringListSetting") == [ "value1", "value2" ], "test_settings_types failed" s3 = Settings("test3") assert s3.deserialize_schema(test_schema, SettingsScope.SettingsResourceScope) assert not s3.contains("testGroup.ignoreResourceBoolSetting" ), "test_settings_types failed" assert s3.contains( "testGroup.ignoreUserBoolSetting"), "test_settings_types failed" assert not s3.contains( "testGroup.readOnlyBoolSetting"), "test_settings_types failed" assert s3.deserialize_schema(test_schema, SettingsScope.SettingsUserScope, False) assert s3.contains("testGroup.ignoreResourceBoolSetting" ), "test_settings_types failed" assert not s3.contains( "testGroup.ignoreUserBoolSetting"), "test_settings_types failed" assert not s3.contains( "testGroup.readOnlyBoolSetting"), "test_settings_types failed" assert s3.deserialize_schema(test_schema, SettingsScope.SettingsUserScope, False) assert s3.deserialize_schema(s3.serialize_schema(), SettingsScope.SettingsResourceScope, False) assert not s3.contains("testGroup.ignoreResourceBoolSetting" ), "test_settings_types failed" assert not s3.contains( "testGroup.ignoreUserBoolSetting"), "test_settings_types failed" assert not s3.contains( "testGroup.readOnlyBoolSetting"), "test_settings_types failed"
def __init__(self, data): BinaryView.__init__(self, file_metadata = data.file, parent_view = data) self.raw = data
def test_internal_external_namespaces(self): """Symbol namespaces don't match""" return [BinaryView.internal_namespace(), BinaryView.external_namespace()]
def is_valid_for_data(cls, data: BinaryView) -> bool: return data.read(0, 8) in cls.DEX_FILE_MAGICS
def __init__(self, data): BinaryView.__init__(self, parent_view=data, file_metadata=data.file)
def __init__(self, data): BinaryView.__init__(self, parent_view=data, file_metadata=data.file) self.platform = Architecture["6502"].standalone_platform
def __init__(self, data): super().__init__(data) self.reader.seek(0xC) flags = self.reader.read32() compressed = [] for segm in range(3): compressed.append(((flags >> segm) & 1) == 1) flags &= 0b0111 self.reader.seek(0x10) text_file_offset = self.reader.read32() self.text_offset = self.reader.read32() self.text_size = self.reader.read32() self.reader.seek(0x20) rodata_file_offset = self.reader.read32() self.rodata_offset = self.reader.read32() self.rodata_size = self.reader.read32() self.reader.seek(0x30) data_file_offset = self.reader.read32() self.data_offset = self.reader.read32() self.data_size = self.reader.read32() self.bss_size = self.reader.read32() self.reader.seek(0x60) text_file_size = self.reader.read32() rodata_file_size = self.reader.read32() data_file_size = self.reader.read32() offset = self.HDR_SIZE self.reader.seek(text_file_offset) text_raw = self.reader.read(text_file_size) if compressed[self.TEXT]: self.log(f"Decompressing .text") text_raw = decompress(text_raw, uncompressed_size=self.text_size) flags &= 0b0011_1110 text_raw = self.page_pad(text_raw) self.text_size = len(text_raw) self.writer.seek(0x18) self.writer.write32(self.text_size) self.writer.seek(0x60) self.writer.write32(self.text_size) self.writer.seek(0x10) self.writer.write32(offset) offset += self.text_size self.reader.seek(rodata_file_offset) rodata_raw = self.reader.read(rodata_file_size) if compressed[self.RODATA]: self.log("Decompressing .rodata") rodata_raw = decompress(rodata_raw, uncompressed_size=self.rodata_size) flags &= 0b0011_1101 rodata_raw = self.page_pad(rodata_raw) self.rodata_size = len(rodata_raw) self.writer.seek(0x28) self.writer.write32(self.rodata_size) self.writer.seek(0x64) self.writer.write32(self.rodata_size) self.writer.seek(0x20) self.writer.write32(offset) offset += self.rodata_size self.reader.seek(data_file_offset) data_raw = self.reader.read(data_file_size) if compressed[self.DATA]: self.log("Decompressing .data") data_raw = decompress(data_raw, uncompressed_size=self.data_size) flags &= 0b0011_1011 data_raw = self.page_pad(data_raw) self.data_size = len(data_raw) self.writer.seek(0x38) self.writer.write32(self.data_size) self.writer.seek(0x68) self.writer.write32(self.data_size) self.writer.seek(0x30) self.writer.write32(offset) offset += self.data_size self.writer.seek(0xC) self.writer.write8(flags) self.reader.seek(0) self.raw = self.reader.read(self.HDR_SIZE) self.raw += text_raw self.raw += rodata_raw self.raw += data_raw text_raw = b'' rodata_raw = b'' data_raw = b'' data.write(0, self.raw) BinaryView.__init__(self, file_metadata=data.file, parent_view=data)