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, 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 __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, 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 __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 __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 __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, file_metadata = data.file, parent_view = data)
self.raw = data
def __init__(self, binaryView):
# data is a binaryninja.binaryview.BinaryView
BinaryView.__init__(self, parent_view=binaryView, file_metadata=binaryView.file)
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):
BinaryView.__init__(self, parent_view=data, file_metadata=data.file)
self.platform = Architecture[
"6502"].standalone_platform # type: ignore
def __init__(self, data):
# data is a binaryninja.binaryview.BinaryView
BinaryView.__init__(self, parent_view=data, file_metadata=data.file)
self.data = data
self.romType = self.get_rom_type(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 __init__(self, data: BinaryView):
BinaryView.__init__(self, parent_view=data, file_metadata=data.file)
self.platform = Architecture['s1c88:s1c88'].standalone_platform
self.data = data
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):
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) -> None:
BinaryView.__init__(self, parent_view=data, file_metadata=data.file)
self.raw = data
def __init__(self, data):
BinaryView.__init__(self, parent_view=data, file_metadata=data.file)
self.platform = Architecture["VTIL"].standalone_platform
self.vtil = VTILParser.from_file(data.file.filename)
set_active_vtil_file(self.vtil)
def __init__(self, data):
self.reader = BinaryReader(data, Endianness.LittleEndian)
BinaryView.__init__(self, parent_view=data, file_metadata=data.file)
self.data = 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):
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)
def __init__(self, data):
BinaryView.__init__(self, parent_view=data, file_metadata=data.file)
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["6502"].standalone_platform
def __init__(self, data):
super().__init__(data)
self.hdr_read_offset = 0xC
flags = self.hdr_read(4)
compressed = []
for segm in range(3):
compressed.append(((flags >> segm) & 1) == 1)
flags &= 0b0111
self.hdr_read_offset = 0x10
text_file_offset, self.text_offset, self.text_size = self.hdr_read(
0x4, times=3)
self.hdr_read_offset = 0x20
rodata_file_offset, self.rodata_offset, self.rodata_size = self.hdr_read(
0x4, times=3)
self.hdr_read_offset = 0x30
data_file_offset, self.data_offset, self.data_size, self.bss_size = self.hdr_read(
0x4, times=4)
self.hdr_read_offset = 0x60
text_file_size, rodata_file_size, data_file_size = self.hdr_read(
0x4, times=3)
offset = self.HDR_SIZE
text_raw = self.raw.read(text_file_offset, 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
self.hdr_write(4, 0x18, self.page_align_up(self.text_size))
self.hdr_write(4, 0x60, self.page_align_up(self.text_size))
self.hdr_write(4, 0x10, offset)
offset += self.page_align_up(self.text_size)
rodata_raw = self.raw.read(rodata_file_offset, rodata_file_size)
if compressed[self.RODATA]:
self.log("Decompressing .rodata")
rodata_raw = decompress(rodata_raw,
uncompressed_size=self.rodata_size)
flags &= 0b0011_1101
self.hdr_write(4, 0x28, self.page_align_up(self.rodata_size))
self.hdr_write(4, 0x64, self.page_align_up(self.rodata_size))
self.hdr_write(4, 0x20, offset)
offset += self.page_align_up(self.rodata_size)
data_raw = self.raw.read(data_file_offset, data_file_size)
if compressed[self.DATA]:
self.log("Decompressing .data")
data_raw = decompress(data_raw, uncompressed_size=self.data_size)
flags &= 0b0011_1011
self.hdr_write(4, 0x38, self.page_align_up(self.data_size))
self.hdr_write(4, 0x68, self.page_align_up(self.data_size))
self.hdr_write(4, 0x30, offset)
offset += self.page_align_up(self.data_size)
self.hdr_write(1, 0xC, 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.page_align_up(self.bss_size)
self.text_offset += self.base
self.rodata_offset += self.base
self.data_offset += self.base
self.raw = binary
data.write(0, binary)
BinaryView.__init__(self, file_metadata=data.file, parent_view=data)
