BinaryView API

from binaryninja import load

# Basic loading
bv = load("/bin/ls")

# With options
bv = load("/path/to/binary", options={
    'analysis.mode': 'full',
    'analysis.linearSweep.autorun': True
})

# Always close when done (headless scripts)
bv.file.close()

# Read bytes
data = bv.read(address, length)

# Read integer (respects endianness)
value = bv.read_int(address, size=4, sign=False)

# Read pointer
ptr = bv.read_pointer(address)

# Check if address is valid
if bv.is_valid_offset(address):
    data = bv.read(address, 16)

# Write bytes
bv.write(address, b"\x90\x90\x90\x90")

# Write integer
bv.write_int(address, 0x12345678, size=4, sign=False)

# Write pointer
bv.write_pointer(address, 0x401000)

# Get all functions
for func in bv.functions:
    print(f"{func.name} @ {func.start:#x}")

# Get function at address
func = bv.get_function_at(0x401000)

# Get functions by name
funcs = bv.get_functions_by_name("main")

# Create a new function
bv.add_function(0x402000)

# Remove a function
bv.remove_function(func)

# Get symbol by name
sym = bv.symbols['main']
print(f"Symbol: {sym.name} at {sym.address:#x}")

# Get symbol at address
sym = bv.get_symbol_at(0x401000)

# Define a new symbol
from binaryninja.types import Symbol, SymbolType
sym = Symbol(SymbolType.FunctionSymbol, 0x402000, "my_function")
bv.define_user_symbol(sym)

# Get all symbols
for sym in bv.get_symbols():
    print(f"{sym.type.name}: {sym.name} @ {sym.address:#x}")

# Define a structure type
from binaryninja import Type

struct = Type.structure([
    (Type.int(4), "field1"),
    (Type.pointer(bv.arch, Type.char()), "field2")
])
bv.define_user_type("MyStruct", struct)

# Get a type
my_type = bv.types['MyStruct']

# Apply type to data
bv.define_user_data_var(0x404000, my_type)

# Get segments
for segment in bv.segments:
    print(f"Segment: {segment.start:#x}-{segment.end:#x}")
    print(f"  Readable: {segment.readable}")
    print(f"  Writable: {segment.writable}")
    print(f"  Executable: {segment.executable}")

# Get sections
for section in bv.sections:
    print(f"Section: {section.name}")
    print(f"  Start: {section.start:#x}")
    print(f"  Length: {section.length:#x}")

# Get all strings
for string_ref in bv.strings:
    print(f"{string_ref.start:#x}: {string_ref.value}")

# Search for specific string
for string_ref in bv.strings:
    if "password" in string_ref.value.lower():
        print(f"Found at {string_ref.start:#x}: {string_ref.value}")

# Get data variable at address
data_var = bv.get_data_var_at(0x404000)

# Set name (new in 3.0)
data_var.name = "global_config"

# Set type
data_var.type = Type.int(4)

# Read value (new in 3.0)
value = data_var.value
print(f"Value: {value}")

# For structures, access fields
if data_var.type.type_class == TypeClass.StructureTypeClass:
    field_value = data_var['field_name'].value

from binaryninja import BinaryDataNotification, NotificationType

class MyNotification(BinaryDataNotification):
    def __init__(self):
        super().__init__(
            NotificationType.FunctionAdded | 
            NotificationType.DataVariableAdded
        )
    
    def function_added(self, view, func):
        print(f"Function added: {func.name}")
    
    def data_var_added(self, view, var):
        print(f"Data variable added at {var.address:#x}")

bv.register_notification(MyNotification())

from binaryninja import load, LogLevel, log_to_stdout

def analyze_binary(path):
    # Enable logging
    log_to_stdout(LogLevel.InfoLog)
    
    # Load binary
    bv = load(path)
    if not bv:
        print(f"Failed to load {path}")
        return
    
    print(f"Binary: {bv.file.filename}")
    print(f"Architecture: {bv.arch.name}")
    print(f"Platform: {bv.platform.name}")
    print(f"Entry point: {bv.entry_point:#x}")
    print(f"Functions: {len(bv.functions)}")
    print(f"Strings: {len(bv.strings)}")
    
    # Find interesting functions
    for func in bv.functions:
        if any(call in func.name.lower() 
               for call in ['system', 'exec', 'strcpy']):
            print(f"Interesting function: {func.name} @ {func.start:#x}")
    
    # Find strings
    for string_ref in bv.strings:
        if any(keyword in string_ref.value.lower() 
               for keyword in ['password', 'key', 'secret']):
            print(f"Interesting string at {string_ref.start:#x}: "
                  f"{string_ref.value}")
    
    bv.file.close()

if __name__ == "__main__":
    analyze_binary("/bin/ls")