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)
__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["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)
