def get_bininfo(bv):
if bv is None:
filename = ""
if len(sys.argv) > 1:
filename = sys.argv[1]
else:
filename = interaction.get_open_filename_input("Filename:")
if filename is None:
log.log_warn("No file specified")
sys.exit(1)
bv = BinaryViewType.get_view_of_file(filename)
log.redirect_output_to_log()
log.log_to_stdout(True)
contents = "## %s ##\n" % bv.file.filename
contents += "- START: 0x%x\n\n" % bv.start
contents += "- ENTRY: 0x%x\n\n" % bv.entry_point
contents += "- ARCH: %s\n\n" % bv.arch.name
contents += "### First 10 Functions ###\n"
contents += "| Start | Name |\n"
contents += "|------:|:-------|\n"
for i in xrange(min(10, len(bv.functions))):
contents += "| 0x%x | %s |\n" % (bv.functions[i].start, bv.functions[i].symbol.full_name)
contents += "### First 10 Strings ###\n"
contents += "| Start | Length | String |\n"
contents += "|------:|-------:|:-------|\n"
for i in xrange(min(10, len(bv.strings))):
start = bv.strings[i].start
length = bv.strings[i].length
string = bv.read(start, length)
contents += "| 0x%x |%d | %s |\n" % (start, length, string)
return contents
def command_load_mapfile(view):
filename = interaction.get_open_filename_input('Map File', '*.map')
if filename is not None:
task = RunInBackground('Loading map file', load_map_file, view,
filename)
task.start()
def command_load_idcfile(view):
filename = interaction.get_open_filename_input('IDC File', '*.idc')
if filename is not None:
task = RunInBackground('Loading idc file', load_idc_file, view,
filename)
task.start()
def trace_detect_function(bv):
path = get_open_filename_input("Select a ppsspp trace file", ext="*.txt")
if not path:
return
functions = 0
duplicates = 0
fp = open(path, "r")
for line in fp.readlines():
line = line.strip()
chks = line.split(" ")
if len(chks) != 3:
print("Invalid file format")
return
if chks[0] != "CALL":
continue
addr = int(chks[1], 16)
fns = bv.get_functions_containing(addr)
if not fns:
bv.create_user_function(addr, plat=bv.platform)
functions += 1
else:
duplicates += 1
print(f"Loading {functions} functions. Found {duplicates} duplicates")
def get_bininfo(bv):
if bv is None:
filename = ""
if len(sys.argv) > 1:
filename = sys.argv[1]
else:
filename = interaction.get_open_filename_input("Filename:")
if filename is None:
log.log_warn("No file specified")
sys.exit(1)
bv = BinaryViewType.get_view_of_file(filename)
log.log_to_stdout(True)
contents = "## %s ##\n" % os.path.basename(bv.file.filename)
contents += "- START: 0x%x\n\n" % bv.start
contents += "- ENTRY: 0x%x\n\n" % bv.entry_point
contents += "- ARCH: %s\n\n" % bv.arch.name
contents += "### First 10 Functions ###\n"
contents += "| Start | Name |\n"
contents += "|------:|:-------|\n"
for i in range(min(10, len(bv.functions))):
contents += "| 0x%x | %s |\n" % (bv.functions[i].start,
bv.functions[i].symbol.full_name)
contents += "### First 10 Strings ###\n"
contents += "| Start | Length | String |\n"
contents += "|------:|-------:|:-------|\n"
for i in range(min(10, len(bv.strings))):
start = bv.strings[i].start
length = bv.strings[i].length
string = bv.read(start, length)
contents += "| 0x%x |%d | %s |\n" % (start, length, string)
return contents
def md380r2symbols(view):
"""This loads an MD380Tools symbols file in Radare2 format."""
filename=get_open_filename_input("Select GNU LD symbols file from MD380Tools.")
if filename:
print("Opening: %s"%filename);
importr2symbols(view,filename);
else:
print("Aborting.");
def get_workspace():
choice = get_choice_input("Select Trace Type", "Input",
["Trace File", "Manticore Workspace"])
if choice == 0:
workspace = get_open_filename_input("Trace File")
else:
workspace = get_directory_name_input("Workspace Directory")
return workspace
def get_filename():
global FILENAME
if FILENAME == None:
FILENAME = os.getenv("BINARY_NINJA_FILENAME")
if FILENAME == None:
FILENAME = interaction.get_open_filename_input(
"File to disassemble (please select it again)")
return FILENAME
def function_source_code_start(view):
filename_asm_json = get_open_filename_input('Asm-json file', "*.asm.json")
workspace = os.path.dirname(filename_asm_json)
solidity_ln = SolidityLineNumber(filename_asm_json, workspace=workspace)
contracts = solidity_ln.contracts.keys()
contract_index = get_choice_input('Name of the contract',
'Name of the contract', contracts)
contract_name = contracts[contract_index]
PrintSourceCode(solidity_ln, contract_name, view)
def get_bin_view(bv):
if bv is None:
filename = ""
if len(sys.argv) > 1:
filename = sys.argv[1]
else:
filename = interaction.get_open_filename_input("Filename:")
if filename is None:
log.log_warn("No file specified")
sys.exit(1)
bv = BinaryViewType.get_view_of_file(filename)
log.log_to_stdout(True)
return bv
def _load_db(bv):
path = get_open_filename_input("Select trace database")
if not path:
return None
path = path.decode("UTF-8")
try:
db = TraceDB(bv, path)
return db
except TraceDBError as e:
_print_error("Database error", "Loading error: {}".format(e))
except sqlite3.Error as e:
_print_error("Database error", "sqlite error: {}".format(e))
def map_ovl(bv):
path = get_open_filename_input("Select an ovl file", ext="*.ovl")
if not path:
return
ovl = _parse_ovl_file(path)
if not ovl:
return
data, load_addr = ovl
print("Loading ovl at address: 0x{:08x}".format(load_addr))
bv.add_user_segment(load_addr, len(data), 0, len(data),
SegmentFlag.SegmentReadable | SegmentFlag.SegmentExecutable)
bv.write(load_addr, data)
def browse_type_library(ctx):
view = ctx.binaryView
if view is None:
return
lib_path: bytes = get_open_filename_input("typelibrary filename:", "*.bntl")
if lib_path is None:
return
lib_path = lib_path.decode("utf-8")
lib = TypeLibrary.load_from_file(lib_path)
browser = TypeLibraryBrowser(view, lib)
browser.exec_()
def load_virtual_calls(self):
json_file = interaction.get_open_filename_input(
"Load virtual calls", "*.json")
with open(json_file.decode("utf-8")) as f:
devi_json_data = json.load(f)
if self.version < devi_json_data["deviVersion"]:
print(
"[!] devi JSON file has a more recent version than IDA plugin!"
)
print("[!] we try parsing anyway!")
if self.version > devi_json_data["deviVersion"]:
print(
"[!] Your devi_ida and devi_frida versions are out of sync. Update your devi_ida!"
)
if self.version == devi_json_data["deviVersion"]:
self.devirtualize_calls(devi_json_data["calls"],
devi_json_data["modules"])
elif devi_json_data["deviVersion"] == 0.1:
self.devirtualize_calls_v01(devi_json_data["calls"])
def load_svd(bv, svd_file=None):
if not svd_file:
svd_file = get_open_filename_input("SVD File")
if isinstance(svd_file, str):
svd_file = bytes(svd_file, encoding="utf-8")
if not os.access(svd_file, os.R_OK):
log_error(f"SVD Browser: Unable to open {svd_file}")
return
log_info(f"SVD Loader: Loading {svd_file}")
device = parse(svd_file)
peripherals = device['peripherals'].values()
base_peripherals = [p for p in peripherals if 'derives' not in p]
derived_peripherals = [p for p in peripherals if 'derives' in p]
def register_peripheral(p, struct_type):
bv.add_user_section(p['name'], p['base'], p['size'],
SectionSemantics.ReadWriteDataSectionSemantics)
bv.add_user_segment(
p['base'], p['size'], 0, 0, SegmentFlag.SegmentContainsData
| SegmentFlag.SegmentReadable | SegmentFlag.SegmentWritable)
bv.define_data_var(p['base'], struct_type)
bv.define_user_symbol(
Symbol(SymbolType.ImportedDataSymbol, p['base'], p['name']))
for p in base_peripherals:
s = Structure()
for r in p['registers'].values():
if r['size'] is None:
s.insert(r['offset'], Type.int(4, False), r['name'])
else:
s.insert(r['offset'], Type.int(int(r['size'] / 8), False),
r['name'])
struct_type = Type.structure_type(s)
bv.define_user_type(p['name'], struct_type)
register_peripheral(p, struct_type)
for p in derived_peripherals:
struct_type = bv.get_type_by_name(
device['peripherals'][p['derives']]['name'])
register_peripheral(p, struct_type)
def load_data(self, bv):
prompt_file = get_open_filename_input("filename")
if(not prompt_file):
return
input_file = open(prompt_file)
try:
harness_data = json.loads(input_file.read())
except json.decoder.JSONDecodeError:
show_message_box("Afl-Unicorn", "Invalid json file",
MessageBoxButtonSet.OKButtonSet, MessageBoxIcon.ErrorIcon)
return
if self.start != None or self.end != None or len(self.avoid_addresses) > 0:
self.clear_data(bv)
binja.log_info("JSON data: start: 0x{0:08x}, end: 0x{1:08x}, avoided addresses: {2}".format(
harness_data['start'], harness_data['end'], [hex(x) for x in harness_data['avoid_addresses']]))
self.start = harness_data['start']
self.end = harness_data['end']
self.set_start_address(bv, self.start)
self.set_end_address(bv, self.end)
for addr in harness_data['avoid_addresses']:
self.avoid_address(bv, addr)
input_file.close()
def db_load(bv):
global LOADED_DB
if LOADED_DB:
res = show_message_box(
"Database loading",
"A trace is already loaded. Do you want to overwrite it ?",
buttons=MessageBoxButtonSet.YesNoButtonSet,
icon=MessageBoxIcon.WarningIcon)
if not res:
return
LOADED_DB = None
path = get_open_filename_input("Select trace database")
if not path:
return
path = path.decode("UTF-8")
try:
LOADED_DB = TraceDB(bv, path)
text = ""
text += "Mappings: {:n}\n".format(LOADED_DB.mapping_count)
text += "Branches: {:n}\n".format(LOADED_DB.branch_count)
text += "bb hits : {:n}\n".format(LOADED_DB.hitcount_count)
show_message_box("Trace info", text)
except sqlite3.Error as e:
_print_error("Database error", "sqlite error: {}".format(e))
LOADED_DB = None
except TraceDBError as e:
_print_error("Database error", "Loading error: {}".format(e))
LOADED_DB = None
def load_virtual_calls(self):
json_file = interaction.get_open_filename_input("Load virtual calls", "*.json")
with open(json_file.decode("utf-8")) as f:
json_objects = json.load(f)
self.devirtualize_calls(json_objects["calls"])
def function_coverage_start(view):
visited = get_open_filename_input('Visited file', "visited.txt")
Coverage(view, visited)
def function_coverage_start(view):
visited = get_open_filename_input('visited.txt or *.trace')
if visited:
colorer = GraphColorer(view)
colorer.color(visited)
