From 5e4cca1f1796bec109adacdb049d9e34c17656eb Mon Sep 17 00:00:00 2001 From: plafosse Date: Fri, 28 Oct 2016 20:16:37 -0400 Subject: Refactor python api into separate files and add Enumeration support. Also fixed bugs found with pyflakes --- python/__init__.py | 11172 +-------------------------------------------------- 1 file changed, 28 insertions(+), 11144 deletions(-) (limited to 'python/__init__.py') diff --git a/python/__init__.py b/python/__init__.py index 0ba0f1a5..402c8526 100644 --- a/python/__init__.py +++ b/python/__init__.py @@ -18,10725 +18,34 @@ # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS # IN THE SOFTWARE. -import _binaryninjacore as core -import abc -import ctypes -import traceback -import json -import struct -import threading -import code -import sys -import copy - -_plugin_init = False -def _init_plugins(): - global _plugin_init - if not _plugin_init: - _plugin_init = True - core.BNInitCorePlugins() - core.BNInitUserPlugins() - if not core.BNIsLicenseValidated(): - raise RuntimeError, "License is not valid. Please supply a valid license." - -class DataBuffer(object): - def __init__(self, contents="", handle=None): - if handle is not None: - self.handle = core.handle_of_type(handle, core.BNDataBuffer) - elif isinstance(contents, int) or isinstance(contents, long): - self.handle = core.BNCreateDataBuffer(None, contents) - elif isinstance(contents, DataBuffer): - self.handle = core.BNDuplicateDataBuffer(contents.handle) - else: - self.handle = core.BNCreateDataBuffer(contents, len(contents)) - - def __del__(self): - core.BNFreeDataBuffer(self.handle) - - def __len__(self): - return int(core.BNGetDataBufferLength(self.handle)) - - def __getitem__(self, i): - if isinstance(i, tuple): - result = "" - source = str(self) - for s in i: - result += source[s] - return result - elif isinstance(i, slice): - if i.step is not None: - i = i.indices(len(self)) - start = i[0] - stop = i[1] - if stop <= start: - return "" - buf = ctypes.create_string_buffer(stop - start) - ctypes.memmove(buf, core.BNGetDataBufferContentsAt(self.handle, start), stop - start) - return buf.raw - else: - return str(self)[i] - elif i < 0: - if i >= -len(self): - return chr(core.BNGetDataBufferByte(self.handle, int(len(self) + i))) - raise IndexError, "index out of range" - elif i < len(self): - return chr(core.BNGetDataBufferByte(self.handle, int(i))) - else: - raise IndexError, "index out of range" - - def __setitem__(self, i, value): - if isinstance(i, slice): - if i.step is not None: - raise IndexError, "step not supported on assignment" - i = i.indices(len(self)) - start = i[0] - stop = i[1] - if stop < start: - stop = start - if len(value) != (stop - start): - data = str(self) - data = data[0:start] + value + data[stop:] - core.BNSetDataBufferContents(self.handle, data, len(data)) - else: - value = str(value) - buf = ctypes.create_string_buffer(value) - ctypes.memmove(core.BNGetDataBufferContentsAt(self.handle, start), buf, len(value)) - elif i < 0: - if i >= -len(self): - if len(value) != 1: - raise ValueError, "expected single byte for assignment" - value = str(value) - buf = ctypes.create_string_buffer(value) - ctypes.memmove(core.BNGetDataBufferContentsAt(self.handle, int(len(self) + i)), buf, 1) - else: - raise IndexError, "index out of range" - elif i < len(self): - if len(value) != 1: - raise ValueError, "expected single byte for assignment" - value = str(value) - buf = ctypes.create_string_buffer(value) - ctypes.memmove(core.BNGetDataBufferContentsAt(self.handle, int(i)), buf, 1) - else: - raise IndexError, "index out of range" - - def __str__(self): - buf = ctypes.create_string_buffer(len(self)) - ctypes.memmove(buf, core.BNGetDataBufferContents(self.handle), len(self)) - return buf.raw - - def __repr__(self): - return repr(str(self)) - - def escape(self): - return core.BNDataBufferToEscapedString(self.handle) - - def unescape(self): - return DataBuffer(handle=core.BNDecodeEscapedString(str(self))) - - def base64_encode(self): - return core.BNDataBufferToBase64(self.handle) - - def base64_decode(self): - return DataBuffer(handle = core.BNDecodeBase64(str(self))) - - def zlib_compress(self): - buf = core.BNZlibCompress(self.handle) - if buf is None: - return None - return DataBuffer(handle = buf) - - def zlib_decompress(self): - buf = core.BNZlibDecompress(self.handle) - if buf is None: - return None - return DataBuffer(handle = buf) - -class NavigationHandler(object): - def _register(self, handle): - self._cb = core.BNNavigationHandler() - self._cb.context = 0 - self._cb.getCurrentView = self._cb.getCurrentView.__class__(self._get_current_view) - self._cb.getCurrentOffset = self._cb.getCurrentOffset.__class__(self._get_current_offset) - self._cb.navigate = self._cb.navigate.__class__(self._navigate) - core.BNSetFileMetadataNavigationHandler(handle, self._cb) - - def _get_current_view(self, ctxt): - try: - view = self.get_current_view() - except: - log_error(traceback.format_exc()) - view = "" - return core.BNAllocString(view) - - def _get_current_offset(self, ctxt): - try: - return self.get_current_offset() - except: - log_error(traceback.format_exc()) - return 0 - - def _navigate(self, ctxt, view, offset): - try: - return self.navigate(view, offset) - except: - log_error(traceback.format_exc()) - return False - -class _AssociatedDataStore(dict): - _defaults = {} - - @classmethod - def set_default(cls, name, value): - cls._defaults[name] = value - - def __getattr__(self, name): - if name in self.__dict__: - return self.__dict__[name] - if name not in self: - if name in self.__class__._defaults: - result = copy.copy(self.__class__._defaults[name]) - self[name] = result - return result - return self.__getitem__(name) - - def __setattr__(self, name, value): - self.__setitem__(name, value) - - def __delattr__(self, name): - self.__delitem__(name) - -class _FileMetadataAssociatedDataStore(_AssociatedDataStore): - _defaults = {} - -class FileMetadata(object): - _associated_data = {} - - """ - ``class FileMetadata`` represents the file being analyzed by Binary Ninja. It is responsible for opening, - closing, creating the database (.bndb) files, and is used to keep track of undoable actions. - """ - def __init__(self, filename = None, handle = None): - """ - Instantiates a new FileMetadata class. - - :param filename: The string path to the file to be opened. Defaults to None. - :param handle: A handle to the underlying C FileMetadata object. Defaults to None. - """ - if handle is not None: - self.handle = core.handle_of_type(handle, core.BNFileMetadata) - else: - _init_plugins() - self.handle = core.BNCreateFileMetadata() - if filename is not None: - core.BNSetFilename(self.handle, str(filename)) - self.nav = None - - def __del__(self): - if self.navigation is not None: - core.BNSetFileMetadataNavigationHandler(self.handle, None) - core.BNFreeFileMetadata(self.handle) - - @classmethod - def _unregister(cls, f): - handle = ctypes.cast(f, ctypes.c_void_p) - if handle.value in cls._associated_data: - del cls._associated_data[handle.value] - - @classmethod - def set_default_session_data(cls, name, value): - _FileMetadataAssociatedDataStore.set_default(name, value) - - @property - def filename(self): - """The name of the file (read/write)""" - return core.BNGetFilename(self.handle) - - @filename.setter - def filename(self, value): - core.BNSetFilename(self.handle, str(value)) - - @property - def modified(self): - """Boolean result of whether the file is modified (Inverse of 'saved' property) (read/write)""" - return core.BNIsFileModified(self.handle) - - @modified.setter - def modified(self, value): - if value: - core.BNMarkFileModified(self.handle) - else: - core.BNMarkFileSaved(self.handle) - - @property - def analysis_changed(self): - """Boolean result of whether the auto-analysis results have changed (read-only)""" - return core.BNIsAnalysisChanged(self.handle) - - @property - def has_database(self): - """Whether the FileMetadata is backed by a database (read-only)""" - return core.BNIsBackedByDatabase(self.handle) - - @property - def view(self): - return core.BNGetCurrentView(self.handle) - - @view.setter - def view(self, value): - core.BNNavigate(self.handle, str(value), core.BNGetCurrentOffset(self.handle)) - - @property - def offset(self): - """The current offset into the file (read/write)""" - return core.BNGetCurrentOffset(self.handle) - - @offset.setter - def offset(self, value): - core.BNNavigate(self.handle, core.BNGetCurrentView(self.handle), value) - - @property - def raw(self): - """Gets the "Raw" BinaryView of the file""" - view = core.BNGetFileViewOfType(self.handle, "Raw") - if view is None: - return None - return BinaryView(file_metadata = self, handle = view) - - @property - def saved(self): - """Boolean result of whether the file has been saved (Inverse of 'modified' property) (read/write)""" - return not core.BNIsFileModified(self.handle) - - @saved.setter - def saved(self, value): - if value: - core.BNMarkFileSaved(self.handle) - else: - core.BNMarkFileModified(self.handle) - - @property - def navigation(self): - return self.nav - - @navigation.setter - def navigation(self, value): - value._register(self.handle) - self.nav = value - - @property - def session_data(self): - """Dictionary object where plugins can store arbitrary data associated with the file""" - handle = ctypes.cast(self.handle, ctypes.c_void_p) - if handle.value not in FileMetadata._associated_data: - obj = _FileMetadataAssociatedDataStore() - FileMetadata._associated_data[handle.value] = obj - return obj - else: - return FileMetadata._associated_data[handle.value] - - def close(self): - """ - Closes the underlying file handle. It is recommended that this is done in a - `finally` clause to avoid handle leaks. - """ - core.BNCloseFile(self.handle) - - def begin_undo_actions(self): - """ - ``begin_undo_actions`` start recording actions taken so the can be undone at some point. - - :rtype: None - :Example: - - >>> bv.get_disassembly(0x100012f1) - 'xor eax, eax' - >>> bv.begin_undo_actions() - >>> bv.convert_to_nop(bv.arch, 0x100012f1) - True - >>> bv.commit_undo_actions() - >>> bv.get_disassembly(0x100012f1) - 'nop' - >>> bv.undo() - >>> bv.get_disassembly(0x100012f1) - 'xor eax, eax' - >>> - """ - core.BNBeginUndoActions(self.handle) - - def commit_undo_actions(self): - """ - ``commit_undo_actions`` commit the actions taken since the last commit to the undo database. - - :rtype: None - :Example: - - >>> bv.get_disassembly(0x100012f1) - 'xor eax, eax' - >>> bv.begin_undo_actions() - >>> bv.convert_to_nop(bv.arch, 0x100012f1) - True - >>> bv.commit_undo_actions() - >>> bv.get_disassembly(0x100012f1) - 'nop' - >>> bv.undo() - >>> bv.get_disassembly(0x100012f1) - 'xor eax, eax' - >>> - """ - core.BNCommitUndoActions(self.handle) - - def undo(self): - """ - ``undo`` undo the last commited action in the undo database. - - :rtype: None - :Example: - - >>> bv.get_disassembly(0x100012f1) - 'xor eax, eax' - >>> bv.begin_undo_actions() - >>> bv.convert_to_nop(bv.arch, 0x100012f1) - True - >>> bv.commit_undo_actions() - >>> bv.get_disassembly(0x100012f1) - 'nop' - >>> bv.undo() - >>> bv.get_disassembly(0x100012f1) - 'xor eax, eax' - >>> bv.redo() - >>> bv.get_disassembly(0x100012f1) - 'nop' - >>> - """ - core.BNUndo(self.handle) - - def redo(self): - """ - ``redo`` redo the last commited action in the undo database. - - :rtype: None - :Example: - - >>> bv.get_disassembly(0x100012f1) - 'xor eax, eax' - >>> bv.begin_undo_actions() - >>> bv.convert_to_nop(bv.arch, 0x100012f1) - True - >>> bv.commit_undo_actions() - >>> bv.get_disassembly(0x100012f1) - 'nop' - >>> bv.undo() - >>> bv.get_disassembly(0x100012f1) - 'xor eax, eax' - >>> bv.redo() - >>> bv.get_disassembly(0x100012f1) - 'nop' - >>> - """ - core.BNRedo(self.handle) - - def navigate(self, view, offset): - return core.BNNavigate(self.handle, str(view), offset) - - def create_database(self, filename, progress_func = None): - if progress_func is None: - return core.BNCreateDatabase(self.raw.handle, str(filename)) - else: - return core.BNCreateDatabaseWithProgress(self.raw.handle, str(filename), None, - ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)( - lambda ctxt, cur, total: progress_func(cur, total))) - - def open_existing_database(self, filename, progress_func = None): - if progress_func is None: - view = core.BNOpenExistingDatabase(self.handle, str(filename)) - else: - view = core.BNOpenExistingDatabaseWithProgress(self.handle, str(filename), None, - ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)( - lambda ctxt, cur, total: progress_func(cur, total))) - if view is None: - return None - return BinaryView(file_metadata = self, handle = view) - - def save_auto_snapshot(self, progress_func = None): - if progress_func is None: - return core.BNSaveAutoSnapshot(self.raw.handle) - else: - return core.BNSaveAutoSnapshotWithProgress(self.raw.handle, None, - ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)( - lambda ctxt, cur, total: progress_func(cur, total))) - - def get_view_of_type(self, name): - view = core.BNGetFileViewOfType(self.handle, str(name)) - if view is None: - view_type = core.BNGetBinaryViewTypeByName(str(name)) - if view_type is None: - return None - view = core.BNCreateBinaryViewOfType(view_type, self.raw.handle) - if view is None: - return None - return BinaryView(file_metadata = self, handle = view) - - def __setattr__(self, name, value): - try: - object.__setattr__(self,name,value) - except AttributeError: - raise AttributeError, "attribute '%s' is read only" % name - -class FileAccessor: - def __init__(self): - self._cb = core.BNFileAccessor() - self._cb.context = 0 - self._cb.getLength = self._cb.getLength.__class__(self._get_length) - self._cb.read = self._cb.read.__class__(self._read) - self._cb.write = self._cb.write.__class__(self._write) - - def __len__(self): - return self.get_length() - - def _get_length(self, ctxt): - try: - return self.get_length() - except: - log_error(traceback.format_exc()) - return 0 - - def _read(self, ctxt, dest, offset, length): - try: - data = self.read(offset, length) - if data is None: - return 0 - if len(data) > length: - data = data[0:length] - ctypes.memmove(dest, data, len(data)) - return len(data) - except: - log_error(traceback.format_exc()) - return 0 - - def _write(self, ctxt, offset, src, length): - try: - data = ctypes.create_string_buffer(length) - ctypes.memmove(data, src, length) - return self.write(offset, data.raw) - except: - log_error(traceback.format_exc()) - return 0 - -class CoreFileAccessor(FileAccessor): - def __init__(self, accessor): - self._cb.context = accessor.context - self._cb.getLength = accessor.getLength - self._cb.read = accessor.read - self._cb.write = accessor.write - - def get_length(self): - return self._cb.getLength(self._cb.context) - - def read(self, offset, length): - data = ctypes.create_string_buffer(length) - length = self._cb.read(self._cb.context, data, offset, length) - return data.raw[0:length] - - def write(self, offset, value): - value = str(value) - data = ctypes.create_string_buffer(value) - return self._cb.write(self._cb.context, offset, data, len(value)) - -class BinaryDataNotification: - def data_written(self, view, offset, length): - pass - - def data_inserted(self, view, offset, length): - pass - - def data_removed(self, view, offset, length): - pass - - def function_added(self, view, func): - pass - - def function_removed(self, view, func): - pass - - def function_updated(self, view, func): - pass - - def data_var_added(self, view, var): - pass - - def data_var_removed(self, view, var): - pass - - def data_var_updated(self, view, var): - pass - - def string_found(self, view, string_type, offset, length): - pass - - def string_removed(self, view, string_type, offset, length): - pass - -class UndoAction: - name = None - action_type = None - _registered = False - _registered_cb = None - - def __init__(self, view): - self._cb = core.BNUndoAction() - if not self.__class__._registered: - raise TypeError, "undo action type not registered" - action_type = self.__class__.action_type - if isinstance(action_type, str): - self._cb.type = core.BNActionType_by_name[action_type] - else: - self._cb.type = action_type - self._cb.context = 0 - self._cb.undo = self._cb.undo.__class__(self._undo) - self._cb.redo = self._cb.redo.__class__(self._redo) - self._cb.serialize = self._cb.serialize.__class__(self._serialize) - self.view = view - - @classmethod - def register(cls): - _init_plugins() - if cls.name is None: - raise ValueError, "undo action 'name' not defined" - if cls.action_type is None: - raise ValueError, "undo action 'action_type' not defined" - cb_type = ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p, ctypes.POINTER(core.BNUndoAction)) - cls._registered_cb = cb_type(cls._deserialize) - core.BNRegisterUndoActionType(cls.name, 0, cls._registered_cb) - cls._registered = True - - @classmethod - def _deserialize(cls, ctxt, data, result): - try: - action = cls.deserialize(json.loads(data)) - if action is None: - return False - result.context = action._cb.context - result.undo = action._cb.undo - result.redo = action._cb.redo - result.serialize = action._cb.serialize - return True - except: - log_error(traceback.format_exc()) - return False - - def _undo(self, ctxt, view): - try: - self.undo() - except: - log_error(traceback.format_exc()) - return False - - def _redo(self, ctxt, view): - try: - self.redo() - except: - log_error(traceback.format_exc()) - return False - - def _serialize(self, ctxt): - try: - return json.dumps(self.serialize()) - except: - log_error(traceback.format_exc()) - return "null" - -class StringReference(object): - def __init__(self, string_type, start, length): - self.type = string_type - self.start = start - self.length = length - - def __repr__(self): - return "<%s: %#x, len %#x>" % (self.type, self.start, self.length) - -class BinaryDataNotificationCallbacks(object): - def __init__(self, view, notify): - self.view = view - self.notify = notify - self._cb = core.BNBinaryDataNotification() - self._cb.context = 0 - self._cb.dataWritten = self._cb.dataWritten.__class__(self._data_written) - self._cb.dataInserted = self._cb.dataInserted.__class__(self._data_inserted) - self._cb.dataRemoved = self._cb.dataRemoved.__class__(self._data_removed) - self._cb.functionAdded = self._cb.functionAdded.__class__(self._function_added) - self._cb.functionRemoved = self._cb.functionRemoved.__class__(self._function_removed) - self._cb.functionUpdated = self._cb.functionUpdated.__class__(self._function_updated) - self._cb.dataVariableAdded = self._cb.dataVariableAdded.__class__(self._data_var_added) - self._cb.dataVariableRemoved = self._cb.dataVariableRemoved.__class__(self._data_var_removed) - self._cb.dataVariableUpdated = self._cb.dataVariableUpdated.__class__(self._data_var_updated) - self._cb.stringFound = self._cb.stringFound.__class__(self._string_found) - self._cb.stringRemoved = self._cb.stringRemoved.__class__(self._string_removed) - - def _register(self): - core.BNRegisterDataNotification(self.view.handle, self._cb) - - def _unregister(self): - core.BNUnregisterDataNotification(self.view.handle, self._cb) - - def _data_written(self, ctxt, view, offset, length): - try: - self.notify.data_written(self.view, offset, length) - except OSError: - log_error(traceback.format_exc()) - - def _data_inserted(self, ctxt, view, offset, length): - try: - self.notify.data_inserted(self.view, offset, length) - except: - log_error(traceback.format_exc()) - - def _data_removed(self, ctxt, view, offset, length): - try: - self.notify.data_removed(self.view, offset, length) - except: - log_error(traceback.format_exc()) - - def _function_added(self, ctxt, view, func): - try: - self.notify.function_added(self.view, Function(self.view, core.BNNewFunctionReference(func))) - except: - log_error(traceback.format_exc()) - - def _function_removed(self, ctxt, view, func): - try: - self.notify.function_removed(self.view, Function(self.view, core.BNNewFunctionReference(func))) - except: - log_error(traceback.format_exc()) - - def _function_updated(self, ctxt, view, func): - try: - self.notify.function_updated(self.view, Function(self.view, core.BNNewFunctionReference(func))) - except: - log_error(traceback.format_exc()) - - def _data_var_added(self, ctxt, view, var): - try: - address = var.address - var_type = Type(core.BNNewTypeReference(var.type)) - auto_discovered = var.autoDiscovered - self.notify.data_var_added(self.view, DataVariable(address, var_type, auto_discovered)) - except: - log_error(traceback.format_exc()) - - def _data_var_removed(self, ctxt, view, var): - try: - address = var.address - var_type = Type(core.BNNewTypeReference(var.type)) - auto_discovered = var.autoDiscovered - self.notify.data_var_removed(self.view, DataVariable(address, var_type, auto_discovered)) - except: - log_error(traceback.format_exc()) - - def _data_var_updated(self, ctxt, view, var): - try: - address = var.address - var_type = Type(core.BNNewTypeReference(var.type)) - auto_discovered = var.autoDiscovered - self.notify.data_var_updated(self.view, DataVariable(address, var_type, auto_discovered)) - except: - log_error(traceback.format_exc()) - - def _string_found(self, ctxt, view, string_type, offset, length): - try: - self.notify.string_found(self.view, core.BNStringType_names[string_type], offset, length) - except: - log_error(traceback.format_exc()) - - def _string_removed(self, ctxt, view, string_type, offset, length): - try: - self.notify.string_removed(self.view, core.BNStringType_names[string_type], offset, length) - except: - log_error(traceback.format_exc()) - -class _BinaryViewTypeMetaclass(type): - @property - def list(self): - """List all BinaryView types (read-only)""" - _init_plugins() - count = ctypes.c_ulonglong() - types = core.BNGetBinaryViewTypes(count) - result = [] - for i in xrange(0, count.value): - result.append(BinaryViewType(types[i])) - core.BNFreeBinaryViewTypeList(types) - return result - - def __iter__(self): - _init_plugins() - count = ctypes.c_ulonglong() - types = core.BNGetBinaryViewTypes(count) - try: - for i in xrange(0, count.value): - yield BinaryViewType(types[i]) - finally: - core.BNFreeBinaryViewTypeList(types) - - def __getitem__(self, value): - _init_plugins() - view_type = core.BNGetBinaryViewTypeByName(str(value)) - if view_type is None: - raise KeyError, "'%s' is not a valid view type" % str(value) - return BinaryViewType(view_type) - - def __setattr__(self, name, value): - try: - type.__setattr__(self, name, value) - except AttributeError: - raise AttributeError, "attribute '%s' is read only" % name - -class BinaryViewType(object): - __metaclass__ = _BinaryViewTypeMetaclass - - def __init__(self, handle): - self.handle = core.handle_of_type(handle, core.BNBinaryViewType) - - @property - def name(self): - """Binary View name (read-only)""" - return core.BNGetBinaryViewTypeName(self.handle) - - @property - def long_name(self): - """BinaryView long name (read-only)""" - return core.BNGetBinaryViewTypeLongName(self.handle) - - def __repr__(self): - return "" % self.name - - def create(self, data): - view = core.BNCreateBinaryViewOfType(self.handle, data.handle) - if view is None: - return None - return BinaryView(file_metadata = data.file, handle = view) - - def open(self, src, file_metadata = None): - data = BinaryView.open(src, file_metadata) - if data is None: - return None - return self.create(data) - - def is_valid_for_data(self, data): - return core.BNIsBinaryViewTypeValidForData(self.handle, data.handle) - - def register_arch(self, ident, endian, arch): - core.BNRegisterArchitectureForViewType(self.handle, ident, endian, arch.handle) - - def get_arch(self, ident, endian): - arch = core.BNGetArchitectureForViewType(self.handle, ident, endian) - if arch is None: - return None - return Architecture(arch) - - def register_platform(self, ident, arch, platform): - core.BNRegisterPlatformForViewType(self.handle, ident, arch.handle, platform.handle) - - def register_default_platform(self, arch, platform): - core.BNRegisterDefaultPlatformForViewType(self.handle, arch.handle, platform.handle) - - def get_platform(self, ident, arch): - platform = core.BNGetPlatformForViewType(self.handle, ident, arch.handle) - if platform is None: - return None - return Platform(None, platform) - - def __setattr__(self, name, value): - try: - object.__setattr__(self, name, value) - except AttributeError: - raise AttributeError, "attribute '%s' is read only" % name - -class AnalysisCompletionEvent(object): - def __init__(self, view, callback): - self.view = view - self.callback = callback - self._cb = ctypes.CFUNCTYPE(None, ctypes.c_void_p)(self._notify) - self.handle = core.BNAddAnalysisCompletionEvent(self.view.handle, None, self._cb) - - def __del__(self): - core.BNFreeAnalysisCompletionEvent(self.handle) - - def _notify(self, ctxt): - try: - self.callback() - except: - log_error(traceback.format_exc()) - - def _empty_callback(self): - pass - - def cancel(self): - self.callback = self._empty_callback - core.BNCancelAnalysisCompletionEvent(self.handle) - -class AnalysisProgress(object): - def __init__(self, state, count, total): - self.state = state - self.count = count - self.total = total - - def __str__(self): - if self.state == core.DisassembleState: - return "Disassembling (%d/%d)" % (self.count, self.total) - if self.state == core.AnalyzeState: - return "Analyzing (%d/%d)" % (self.count, self.total) - return "Idle" - - def __repr__(self): - return "" % str(self) - -class LinearDisassemblyPosition(object): - """ - ``class LinearDisassemblyPosition`` is a helper object containing the position of the current Linear Disassembly. - - .. note:: This object should not be instantiated directly. Rather call \ - :py:method:`get_linear_disassembly_position_at` which instantiates this object. - """ - def __init__(self, func, block, addr): - self.function = func - self.block = block - self.address = addr - -class LinearDisassemblyLine(object): - def __init__(self, line_type, func, block, line_offset, contents): - self.type = line_type - self.function = func - self.block = block - self.line_offset = line_offset - self.contents = contents - - def __str__(self): - return str(self.contents) - - def __repr__(self): - return repr(self.contents) - -class DataVariable(object): - def __init__(self, addr, var_type, auto_discovered): - self.address = addr - self.type = var_type - self.auto_discovered = auto_discovered - - def __repr__(self): - return "" % (self.address, str(self.type)) - -class Segment(object): - def __init__(self, start, length, data_offset, data_length, flags): - self.start = start - self.length = length - self.data_offset = data_offset - self.data_length = data_length - self.flags = flags - - @property - def end(self): - return self.start + self.length - - def __len__(self): - return self.length - - def __repr__(self): - return "" % (self.start, self.end, - "r" if (self.flags & core.SegmentReadable) != 0 else "-", - "w" if (self.flags & core.SegmentWritable) != 0 else "-", - "x" if (self.flags & core.SegmentExecutable) != 0 else "-") - -class Section(object): - def __init__(self, name, section_type, start, length, linked_section, info_section, info_data, align, entry_size): - self.name = name - self.type = section_type - self.start = start - self.length = length - self.linked_section = linked_section - self.info_section = info_section - self.info_data = info_data - self.align = align - self.entry_size = entry_size - - @property - def end(self): - return self.start + self.length - - def __len__(self): - return self.length - - def __repr__(self): - return "
" % (self.name, self.start, self.end) - -class AddressRange(object): - def __init__(self, start, end): - self.start = start - self.end = end - - @property - def length(self): - return self.end - self.start - - def __len__(self): - return self.end - self.start - - def __repr__(self): - return "<%#x-%#x>" % (self.start, self.end) - -class _BinaryViewAssociatedDataStore(_AssociatedDataStore): - _defaults = {} - -class BinaryView(object): - """ - ``class BinaryView`` implements a view on binary data, and presents a queryable interface of a binary file. One key - job of BinaryView is file format parsing which allows Binary Ninja to read, write, insert, remove portions - of the file given a virtual address. For the purposes of this documentation we define a virtual address as the - memory address that the various pieces of the physical file will be loaded at. - - A binary file does not have to have just one BinaryView, thus much of the interface to manipulate disassembly exists - within or is accessed through a BinaryView. All files are guaranteed to have at least the ``Raw`` BinaryView. The - ``Raw`` BinaryView is simply a hex editor, but is helpful for manipulating binary files via their absolute addresses. - - BinaryViews are plugins and thus registered with Binary Ninja at startup, and thus should **never** be instantiated - directly as this is already done. The list of available BinaryViews can be seen in the BinaryViewType class which - provides an iterator and map of the various installed BinaryViews:: - - >>> list(BinaryViewType) - [, , , ] - >>> BinaryViewType['ELF'] - - - To open a file with a given BinaryView the following code can be used:: - - >>> bv = BinaryViewType['Mach-O'].open("/bin/ls") - >>> bv - - - `By convention in the rest of this document we will use bv to mean an open BinaryView of an executable file.` - When a BinaryView is open on an executable view, analysis does not automatically run, this can be done by running - the ``update_analysis_and_wait()`` method which disassembles the executable and returns when all disassembly is - finished:: - - >>> bv.update_analysis_and_wait() - >>> - - Since BinaryNinja's analysis is multi-threaded (depending on version) this can also be done in the background by - using the ``update_analysis()`` method instead. - - By standard python convention methods which start with '_' should be considered private and should not be called - externally. Additionanlly, methods which begin with ``perform_`` should not be called either and are - used explicitly for subclassing the BinaryView. - - .. note:: An important note on the ``*_user_*()`` methods. Binary Ninja makes a distinction between edits \ - performed by the user and actions performed by auto analysis. Auto analysis actions that can quickly be recalculated \ - are not saved to the database. Auto analysis actions that take a long time and all user edits are stored in the \ - database (e.g. ``remove_user_function()`` rather than ``remove_function()``). Thus use ``_user_`` methods if saving \ - to the database is desired. - """ - name = None - long_name = None - _registered = False - _registered_cb = None - registered_view_type = None - next_address = 0 - _associated_data = {} - - def __init__(self, file_metadata = None, parent_view = None, handle = None): - if handle is not None: - self.handle = core.handle_of_type(handle, core.BNBinaryView) - if file_metadata is None: - self.file = FileMetadata(handle = core.BNGetFileForView(handle)) - else: - self.file = file_metadata - elif self.__class__ is BinaryView: - _init_plugins() - if file_metadata is None: - file_metadata = FileMetadata() - self.handle = core.BNCreateBinaryDataView(file_metadata.handle) - self.file = FileMetadata(handle = core.BNNewFileReference(file_metadata)) - else: - _init_plugins() - if not self.__class__._registered: - raise TypeError, "view type not registered" - self._cb = core.BNCustomBinaryView() - self._cb.context = 0 - self._cb.init = self._cb.init.__class__(self._init) - self._cb.read = self._cb.read.__class__(self._read) - self._cb.write = self._cb.write.__class__(self._write) - self._cb.insert = self._cb.insert.__class__(self._insert) - self._cb.remove = self._cb.remove.__class__(self._remove) - self._cb.getModification = self._cb.getModification.__class__(self._get_modification) - self._cb.isValidOffset = self._cb.isValidOffset.__class__(self._is_valid_offset) - self._cb.isOffsetReadable = self._cb.isOffsetReadable.__class__(self._is_offset_readable) - self._cb.isOffsetWritable = self._cb.isOffsetWritable.__class__(self._is_offset_writable) - self._cb.isOffsetExecutable = self._cb.isOffsetExecutable.__class__(self._is_offset_executable) - self._cb.getNextValidOffset = self._cb.getNextValidOffset.__class__(self._get_next_valid_offset) - self._cb.getStart = self._cb.getStart.__class__(self._get_start) - self._cb.getLength = self._cb.getLength.__class__(self._get_length) - self._cb.getEntryPoint = self._cb.getEntryPoint.__class__(self._get_entry_point) - self._cb.isExecutable = self._cb.isExecutable.__class__(self._is_executable) - self._cb.getDefaultEndianness = self._cb.getDefaultEndianness.__class__(self._get_default_endianness) - self._cb.getAddressSize = self._cb.getAddressSize.__class__(self._get_address_size) - self._cb.save = self._cb.save.__class__(self._save) - self.file = file_metadata - if parent_view is not None: - parent_view = parent_view.handle - self.handle = core.BNCreateCustomBinaryView(self.__class__.name, file_metadata.handle, parent_view, self._cb) - self.notifications = {} - self.next_address = None # Do NOT try to access view before init() is called, use placeholder - - @classmethod - def register(cls): - _init_plugins() - if cls.name is None: - raise ValueError, "view 'name' not defined" - if cls.long_name is None: - cls.long_name = cls.name - cls._registered_cb = core.BNCustomBinaryViewType() - cls._registered_cb.context = 0 - cls._registered_cb.create = cls._registered_cb.create.__class__(cls._create) - cls._registered_cb.isValidForData = cls._registered_cb.isValidForData.__class__(cls._is_valid_for_data) - cls.registered_view_type = BinaryViewType(core.BNRegisterBinaryViewType(cls.name, cls.long_name, cls._registered_cb)) - cls._registered = True - - @classmethod - def _create(cls, ctxt, data): - try: - file_metadata = FileMetadata(handle = core.BNGetFileForView(data)) - view = cls(BinaryView(file_metadata = file_metadata, handle = core.BNNewViewReference(data))) - if view is None: - return None - return ctypes.cast(core.BNNewViewReference(view.handle), ctypes.c_void_p).value - except: - log_error(traceback.format_exc()) - return None - - @classmethod - def _is_valid_for_data(cls, ctxt, data): - try: - return cls.is_valid_for_data(BinaryView(handle = core.BNNewViewReference(data))) - except: - log_error(traceback.format_exc()) - return False - - @classmethod - def open(cls, src, file_metadata = None): - _init_plugins() - if isinstance(src, FileAccessor): - if file_metadata is None: - file_metadata = FileMetadata() - view = core.BNCreateBinaryDataViewFromFile(file_metadata.handle, src._cb) - else: - if file_metadata is None: - file_metadata = FileMetadata(str(src)) - view = core.BNCreateBinaryDataViewFromFilename(file_metadata.handle, str(src)) - if view is None: - return None - result = BinaryView(file_metadata = file_metadata, handle = view) - return result - - @classmethod - def new(cls, data = None, file_metadata = None): - _init_plugins() - if file_metadata is None: - file_metadata = FileMetadata() - if data is None: - view = core.BNCreateBinaryDataView(file_metadata.handle) - else: - buf = DataBuffer(data) - view = core.BNCreateBinaryDataViewFromBuffer(file_metadata.handle, buf.handle) - if view is None: - return None - result = BinaryView(file_metadata = file_metadata, handle = view) - return result - - @classmethod - def _unregister(cls, view): - handle = ctypes.cast(view, ctypes.c_void_p) - if handle.value in cls._associated_data: - del cls._associated_data[handle.value] - - @classmethod - def set_default_session_data(cls, name, value): - _BinaryViewAssociatedDataStore.set_default(name, value) - - def __del__(self): - for i in self.notifications.values(): - i._unregister() - core.BNFreeBinaryView(self.handle) - - def __iter__(self): - count = ctypes.c_ulonglong(0) - funcs = core.BNGetAnalysisFunctionList(self.handle, count) - try: - for i in xrange(0, count.value): - yield Function(self, core.BNNewFunctionReference(funcs[i])) - finally: - core.BNFreeFunctionList(funcs, count.value) - - @property - def parent_view(self): - """View that contains the raw data used by this view (read-only)""" - result = core.BNGetParentView(self.handle) - if result is None: - return None - return BinaryView(handle = result) - - @property - def modified(self): - """boolean modification state of the BinaryView (read/write)""" - return self.file.modified - - @modified.setter - def modified(self, value): - self.file.modified = value - - @property - def analysis_changed(self): - """boolean analysis state changed of the currently running analysis (read-only)""" - return self.file.analysis_changed - - @property - def has_database(self): - """boolean has a database been written to disk (read-only)""" - return self.file.has_database - - @property - def view(self): - return self.file.view - - @view.setter - def view(self, value): - self.file.view = value - - @property - def offset(self): - return self.file.offset - - @offset.setter - def offset(self, value): - self.file.offset = value - - @property - def start(self): - """Start offset of the binary (read-only)""" - return core.BNGetStartOffset(self.handle) - - @property - def end(self): - """End offset of the binary (read-only)""" - return core.BNGetEndOffset(self.handle) - - @property - def entry_point(self): - """Entry point of the binary (read-only)""" - return core.BNGetEntryPoint(self.handle) - - @property - def arch(self): - """The architecture associated with the current BinaryView (read/write)""" - arch = core.BNGetDefaultArchitecture(self.handle) - if arch is None: - return None - return Architecture(handle = arch) - - @arch.setter - def arch(self, value): - if value is None: - core.BNSetDefaultArchitecture(self.handle, None) - else: - core.BNSetDefaultArchitecture(self.handle, value.handle) - - @property - def platform(self): - """The platform associated with the current BinaryView (read/write)""" - platform = core.BNGetDefaultPlatform(self.handle) - if platform is None: - return None - return Platform(self.arch, handle = platform) - - @platform.setter - def platform(self, value): - if value is None: - core.BNSetDefaultPlatform(self.handle, None) - else: - core.BNSetDefaultPlatform(self.handle, value.handle) - - @property - def endianness(self): - """Endianness of the binary (read-only)""" - return core.BNGetDefaultEndianness(self.handle) - - @property - def address_size(self): - """Address size of the binary (read-only)""" - return core.BNGetViewAddressSize(self.handle) - - @property - def executable(self): - """Whether the binary is an executable (read-only)""" - return core.BNIsExecutableView(self.handle) - - @property - def functions(self): - """List of functions (read-only)""" - count = ctypes.c_ulonglong(0) - funcs = core.BNGetAnalysisFunctionList(self.handle, count) - result = [] - for i in xrange(0, count.value): - result.append(Function(self, core.BNNewFunctionReference(funcs[i]))) - core.BNFreeFunctionList(funcs, count.value) - return result - - @property - def has_functions(self): - """Boolean whether the binary has functions (read-only)""" - return core.BNHasFunctions(self.handle) - - @property - def entry_function(self): - """Entry function (read-only)""" - func = core.BNGetAnalysisEntryPoint(self.handle) - if func is None: - return None - return Function(self, func) - - @property - def symbols(self): - """Dict of symbols (read-only)""" - count = ctypes.c_ulonglong(0) - syms = core.BNGetSymbols(self.handle, count) - result = {} - for i in xrange(0, count.value): - sym = Symbol(None, None, None, handle = core.BNNewSymbolReference(syms[i])) - result[sym.raw_name] = sym - core.BNFreeSymbolList(syms, count.value) - return result - - @property - def view_type(self): - """View type (read-only)""" - return core.BNGetViewType(self.handle) - - @property - def available_view_types(self): - """Available view types (read-only)""" - count = ctypes.c_ulonglong(0) - types = core.BNGetBinaryViewTypesForData(self.handle, count) - result = [] - for i in xrange(0, count.value): - result.append(BinaryViewType(types[i])) - core.BNFreeBinaryViewTypeList(types) - return result - - @property - def strings(self): - """List of strings (read-only)""" - return self.get_strings() - - @property - def saved(self): - """boolean state of whether or not the file has been saved (read/write)""" - return self.file.saved - - @saved.setter - def saved(self, value): - self.file.saved = value - - @property - def analysis_progress(self): - """Status of current analysis (read-only)""" - result = core.BNGetAnalysisProgress(self.handle) - return AnalysisProgress(result.state, result.count, result.total) - - @property - def linear_disassembly(self): - """Iterator for all lines in the linear disassembly of the view""" - return self.get_linear_disassembly(None) - - @property - def data_vars(self): - """List of data variables (read-only)""" - count = ctypes.c_ulonglong(0) - var_list = core.BNGetDataVariables(self.handle, count) - result = {} - for i in xrange(0, count.value): - addr = var_list[i].address - var_type = Type(core.BNNewTypeReference(var_list[i].type)) - auto_discovered = var_list[i].autoDiscovered - result[addr] = DataVariable(addr, var_type, auto_discovered) - core.BNFreeDataVariables(var_list, count.value) - return result - - @property - def types(self): - """List of defined types (read-only)""" - count = ctypes.c_ulonglong(0) - type_list = core.BNGetAnalysisTypeList(self.handle, count) - result = {} - for i in xrange(0, count.value): - result[type_list[i].name] = Type(core.BNNewTypeReference(type_list[i].type)) - core.BNFreeTypeList(type_list, count.value) - return result - - @property - def segments(self): - """List of segments (read-only)""" - count = ctypes.c_ulonglong(0) - segment_list = core.BNGetSegments(self.handle, count) - result = [] - for i in xrange(0, count.value): - result.append(Segment(segment_list[i].start, segment_list[i].length, - segment_list[i].dataOffset, segment_list[i].dataLength, segment_list[i].flags)) - core.BNFreeSegmentList(segment_list) - return result - - @property - def sections(self): - """List of sections (read-only)""" - count = ctypes.c_ulonglong(0) - section_list = core.BNGetSections(self.handle, count) - result = {} - for i in xrange(0, count.value): - result[section_list[i].name] = Section(section_list[i].name, section_list[i].type, section_list[i].start, - section_list[i].length, section_list[i].linkedSection, section_list[i].infoSection, - section_list[i].infoData, section_list[i].align, section_list[i].entrySize) - core.BNFreeSectionList(section_list, count.value) - return result - - @property - def allocated_ranges(self): - """List of valid address ranges for this view (read-only)""" - count = ctypes.c_ulonglong(0) - range_list = core.BNGetAllocatedRanges(self.handle, count) - result = [] - for i in xrange(0, count.value): - result.append(AddressRange(range_list[i].start, range_list[i].end)) - core.BNFreeAddressRanges(range_list) - return result - - @property - def session_data(self): - """Dictionary object where plugins can store arbitrary data associated with the view""" - handle = ctypes.cast(self.handle, ctypes.c_void_p) - if handle.value not in BinaryView._associated_data: - obj = _BinaryViewAssociatedDataStore() - BinaryView._associated_data[handle.value] = obj - return obj - else: - return BinaryView._associated_data[handle.value] - - def __len__(self): - return int(core.BNGetViewLength(self.handle)) - - def __getitem__(self, i): - if isinstance(i, tuple): - result = "" - for s in i: - result += self.__getitem__(s) - return result - elif isinstance(i, slice): - if i.step is not None: - raise IndexError, "step not implemented" - i = i.indices(self.end) - start = i[0] - stop = i[1] - if stop <= start: - return "" - return str(self.read(start, stop - start)) - elif i < 0: - if i >= -len(self): - value = str(self.read(int(len(self) + i), 1)) - if len(value) == 0: - return IndexError, "index not readable" - return value - raise IndexError, "index out of range" - elif (i >= self.start) and (i < self.end): - value = str(self.read(int(i), 1)) - if len(value) == 0: - return IndexError, "index not readable" - return value - else: - raise IndexError, "index out of range" - - def __setitem__(self, i, value): - if isinstance(i, slice): - if i.step is not None: - raise IndexError, "step not supported on assignment" - i = i.indices(self.end) - start = i[0] - stop = i[1] - if stop < start: - stop = start - if len(value) != (stop - start): - self.remove(start, stop - start) - self.insert(start, value) - else: - self.write(start, value) - elif i < 0: - if i >= -len(self): - if len(value) != 1: - raise ValueError, "expected single byte for assignment" - if self.write(int(len(self) + i), value) != 1: - raise IndexError, "index not writable" - else: - raise IndexError, "index out of range" - elif (i >= self.start) and (i < self.end): - if len(value) != 1: - raise ValueError, "expected single byte for assignment" - if self.write(int(i), value) != 1: - raise IndexError, "index not writable" - else: - raise IndexError, "index out of range" - - def __repr__(self): - start = self.start - length = len(self) - if start != 0: - size = "start %#x, len %#x" % (start, length) - else: - size = "len %#x" % length - filename = self.file.filename - if len(filename) > 0: - return "" % (filename, size) - return "" % (size) - - def _init(self, ctxt): - try: - return self.init() - except: - log_error(traceback.format_exc()) - return False - - def _read(self, ctxt, dest, offset, length): - try: - data = self.perform_read(offset, length) - if data is None: - return 0 - if len(data) > length: - data = data[0:length] - ctypes.memmove(dest, str(data), len(data)) - return len(data) - except: - log_error(traceback.format_exc()) - return 0 - - def _write(self, ctxt, offset, src, length): - try: - data = ctypes.create_string_buffer(length) - ctypes.memmove(data, src, length) - return self.perform_write(offset, data.raw) - except: - log_error(traceback.format_exc()) - return 0 - - def _insert(self, ctxt, offset, src, length): - try: - data = ctypes.create_string_buffer(length) - ctypes.memmove(data, src, length) - return self.perform_insert(offset, data.raw) - except: - log_error(traceback.format_exc()) - return 0 - - def _remove(self, ctxt, offset, length): - try: - return self.perform_remove(offset, length) - except: - log_error(traceback.format_exc()) - return 0 - - def _get_modification(self, ctxt, offset): - try: - return self.perform_get_modification(offset) - except: - log_error(traceback.format_exc()) - return core.Original - - def _is_valid_offset(self, ctxt, offset): - try: - return self.perform_is_valid_offset(offset) - except: - log_error(traceback.format_exc()) - return False - - def _is_offset_readable(self, ctxt, offset): - try: - return self.perform_is_offset_readable(offset) - except: - log_error(traceback.format_exc()) - return False - - def _is_offset_writable(self, ctxt, offset): - try: - return self.perform_is_offset_writable(offset) - except: - log_error(traceback.format_exc()) - return False - - def _is_offset_executable(self, ctxt, offset): - try: - return self.perform_is_offset_executable(offset) - except: - log_error(traceback.format_exc()) - return False - - def _get_next_valid_offset(self, ctxt, offset): - try: - return self.perform_get_next_valid_offset(offset) - except: - log_error(traceback.format_exc()) - return offset - - def _get_start(self, ctxt): - try: - return self.perform_get_start() - except: - log_error(traceback.format_exc()) - return 0 - - def _get_length(self, ctxt): - try: - return self.perform_get_length() - except: - log_error(traceback.format_exc()) - return 0 - - def _get_entry_point(self, ctxt): - try: - return self.perform_get_entry_point() - except: - log_error(traceback.format_exc()) - return 0 - - def _is_executable(self, ctxt): - try: - return self.perform_is_executable() - except: - log_error(traceback.format_exc()) - return False - - def _get_default_endianness(self, ctxt): - try: - return self.perform_get_default_endianness() - except: - log_error(traceback.format_exc()) - return core.LittleEndian - - def _get_address_size(self, ctxt): - try: - return self.perform_get_address_size() - except: - log_error(traceback.format_exc()) - return 8 - - def _save(self, ctxt, file_accessor): - try: - return self.perform_save(CoreFileAccessor(file_accessor)) - except: - log_error(traceback.format_exc()) - return False - - def init(self): - return True - - def get_disassembly(self, addr, arch=None): - """ - ``get_disassembly`` simple helper function for printing disassembly of a given address - - :param int addr: virtual address of instruction - :param Architecture arch: optional Architecture, ``self.arch`` is used if this parameter is None - :return: a str representation of the instruction at virtual address ``addr`` or None - :rtype: str or None - :Example: - - >>> bv.get_disassembly(bv.entry_point) - 'push ebp' - >>> - """ - if arch is None: - arch = self.arch - txt, size = arch.get_instruction_text(self.read(addr, self.arch.max_instr_length), addr) - self.next_address = addr + size - if txt is None: - return None - return ''.join(str(a) for a in txt).strip() - - def get_next_disassembly(self, arch=None): - """ - ``get_next_disassembly`` simple helper function for printing disassembly of the next instruction. - The internal state of the instruction to be printed is stored in the ``next_address`` attribute - - :param Architecture arch: optional Architecture, ``self.arch`` is used if this parameter is None - :return: a str representation of the instruction at virtual address ``self.next_address`` - :rtype: str or None - :Example: - - >>> bv.get_next_disassembly() - 'push ebp' - >>> bv.get_next_disassembly() - 'mov ebp, esp' - >>> #Now reset the starting point back to the entry point - >>> bv.next_address = bv.entry_point - >>> bv.get_next_disassembly() - 'push ebp' - >>> - """ - if arch is None: - arch = self.arch - if self.next_address is None: - self.next_address = self.entry_point - txt, size = arch.get_instruction_text(self.read(self.next_address, self.arch.max_instr_length), self.next_address) - self.next_address += size - if txt is None: - return None - return ''.join(str(a) for a in txt).strip() - - def perform_save(self, accessor): - if self.parent_view is not None: - return self.parent_view.save(accessor) - return False - - @abc.abstractmethod - def perform_get_address_size(self): - raise NotImplementedError - - def perform_get_length(self): - """ - ``perform_get_length`` implements a query for the size of the virtual address range used by - the BinaryView. - - .. note:: This method **may** be overridden by custom BinaryViews. Use ``add_auto_segment`` to provide - data without overriding this method. - .. warning:: This method **must not** be called directly. - - :return: returns the size of the virtual address range used by the BinaryView. - :rtype: int - """ - return 0 - - def perform_read(self, addr, length): - """ - ``perform_read`` implements a mapping between a virtual address and an absolute file offset, reading - ``length`` bytes from the rebased address ``addr``. - - .. note:: This method **may** be overridden by custom BinaryViews. Use ``add_auto_segment`` to provide - data without overriding this method. - .. warning:: This method **must not** be called directly. - - :param int addr: a virtual address to attempt to read from - :param int length: the number of bytes to be read - :return: length bytes read from addr, should return empty string on error - :rtype: str - """ - return "" - - def perform_write(self, addr, data): - """ - ``perform_write`` implements a mapping between a virtual address and an absolute file offset, writing - the bytes ``data`` to rebased address ``addr``. - - .. note:: This method **may** be overridden by custom BinaryViews. Use ``add_auto_segment`` to provide - data without overriding this method. - .. warning:: This method **must not** be called directly. - - :param int addr: a virtual address - :param str data: the data to be written - :return: length of data written, should return 0 on error - :rtype: int - """ - return 0 - - def perform_insert(self, addr, data): - """ - ``perform_insert`` implements a mapping between a virtual address and an absolute file offset, inserting - the bytes ``data`` to rebased address ``addr``. - - .. note:: This method **may** be overridden by custom BinaryViews. If not overridden, inserting is disallowed - .. warning:: This method **must not** be called directly. - - :param int addr: a virtual address - :param str data: the data to be inserted - :return: length of data inserted, should return 0 on error - :rtype: int - """ - return 0 - - def perform_remove(self, addr, length): - """ - ``perform_remove`` implements a mapping between a virtual address and an absolute file offset, removing - ``length`` bytes from the rebased address ``addr``. - - .. note:: This method **may** be overridden by custom BinaryViews. If not overridden, removing data is disallowed - .. warning:: This method **must not** be called directly. - - :param int addr: a virtual address - :param str data: the data to be removed - :return: length of data removed, should return 0 on error - :rtype: int - """ - return 0 - - def perform_get_modification(self, addr): - """ - ``perform_get_modification`` implements query to the whether the virtual address ``addr`` is modified. - - .. note:: This method **may** be overridden by custom BinaryViews. Use ``add_auto_segment`` to provide - data without overriding this method. - .. warning:: This method **must not** be called directly. - - :param int addr: a virtual address to be checked - :return: One of the following: Original = 0, Changed = 1, Inserted = 2 - :rtype: BNModificationStatus - """ - return core.Original - - def perform_is_valid_offset(self, addr): - """ - ``perform_is_valid_offset`` implements a check if an virtual address ``addr`` is valid. - - .. note:: This method **may** be overridden by custom BinaryViews. Use ``add_auto_segment`` to provide - data without overriding this method. - .. warning:: This method **must not** be called directly. - - :param int addr: a virtual address to be checked - :return: true if the virtual address is valid, false if the virtual address is invalid or error - :rtype: bool - """ - data = self.read(addr, 1) - return (data is not None) and (len(data) == 1) - - def perform_is_offset_readable(self, offset): - """ - ``perform_is_offset_readable`` implements a check if an virtual address is readable. - - .. note:: This method **may** be overridden by custom BinaryViews. Use ``add_auto_segment`` to provide - data without overriding this method. - .. warning:: This method **must not** be called directly. - - :param int offset: a virtual address to be checked - :return: true if the virtual address is readable, false if the virtual address is not readable or error - :rtype: bool - """ - return self.is_valid_offset(offset) - - def perform_is_offset_writable(self, addr): - """ - ``perform_is_offset_writable`` implements a check if a virtual address ``addr`` is writable. - - .. note:: This method **may** be overridden by custom BinaryViews. Use ``add_auto_segment`` to provide - data without overriding this method. - .. warning:: This method **must not** be called directly. - - :param int addr: a virtual address to be checked - :return: true if the virtual address is writable, false if the virtual address is not writable or error - :rtype: bool - """ - return self.is_valid_offset(addr) - - def perform_is_offset_executable(self, addr): - """ - ``perform_is_offset_writable`` implements a check if a virtual address ``addr`` is executable. - - .. note:: This method **may** be overridden by custom BinaryViews. Use ``add_auto_segment`` to provide - data without overriding this method. - .. warning:: This method **must not** be called directly. - - :param int addr: a virtual address to be checked - :return: true if the virtual address is executable, false if the virtual address is not executable or error - :rtype: int - """ - return self.is_valid_offset(addr) - - def perform_get_next_valid_offset(self, addr): - """ - ``perform_get_next_valid_offset`` implements a query for the next valid readable, writable, or executable virtual - memory address. - - .. note:: This method **may** be overridden by custom BinaryViews. Use ``add_auto_segment`` to provide - data without overriding this method. - .. warning:: This method **must not** be called directly. - - :param int addr: a virtual address to start checking from. - :return: the next readable, writable, or executable virtual memory address - :rtype: int - """ - if addr < self.perform_get_start(): - return self.perform_get_start() - return addr - - def perform_get_start(self): - """ - ``perform_get_start`` implements a query for the first readable, writable, or executable virtual address in - the BinaryView. - - .. note:: This method **may** be overridden by custom BinaryViews. Use ``add_auto_segment`` to provide - data without overriding this method. - .. warning:: This method **must not** be called directly. - - :return: returns the first virtual address in the BinaryView. - :rtype: int - """ - return 0 - - def perform_get_entry_point(self): - """ - ``perform_get_entry_point`` implements a query for the initial entry point for code execution. - - .. note:: This method **should** be implmented for custom BinaryViews that are executable. - .. warning:: This method **must not** be called directly. - - :return: the virtual address of the entry point - :rtype: int - """ - return 0 - - def perform_is_executable(self): - """ - ``perform_is_executable`` implements a check which returns true if the BinaryView is executable. - - .. note:: This method **must** be implemented for custom BinaryViews that are executable. - .. warning:: This method **must not** be called directly. - - :return: true if the current BinaryView is executable, false if it is not executable or on error - :rtype: bool - """ - return False - - def perform_get_default_endianness(self): - """ - ``perform_get_default_endianness`` implements a check which returns true if the BinaryView is executable. - - .. note:: This method **may** be implemented for custom BinaryViews that are not LittleEndian. - .. warning:: This method **must not** be called directly. - - :return: either ``core.LittleEndian`` or ``core.BigEndian`` - :rtype: BNEndianness - """ - return core.LittleEndian - - def create_database(self, filename, progress_func = None): - """ - ``perform_get_database`` writes the current database (.bndb) file out to the specified file. - - :param str filename: path and filename to write the bndb to, this string `should` have ".bndb" appended to it. - :param callable() progress_func: optional function to be called with the current progress and total count. - :return: true on success, false on failure - :rtype: bool - """ - return self.file.create_database(filename, progress_func) - - def save_auto_snapshot(self, progress_func = None): - """ - ``save_auto_snapshot`` saves the current database to the already created file. - - .. note:: :py:method:`create_database` should have been called prior to executing this method - - :param callable() progress_func: optional function to be called with the current progress and total count. - :return: True if it successfully saved the snapshot, False otherwise - :rtype: bool - """ - return self.file.save_auto_snapshot(progress_func) - - def get_view_of_type(self, name): - """ - ``get_view_of_type`` returns the BinaryView associated with the provided name if it exists. - - :param str name: Name of the view to be retrieved - :return: BinaryView object assocated with the provided name or None on failure - :rtype: BinaryView or None - """ - return self.file.get_view_of_type(name) - - def begin_undo_actions(self): - """ - ``begin_undo_actions`` start recording actions taken so the can be undone at some point. - - :rtype: None - :Example: - - >>> bv.get_disassembly(0x100012f1) - 'xor eax, eax' - >>> bv.begin_undo_actions() - >>> bv.convert_to_nop(bv.arch, 0x100012f1) - True - >>> bv.commit_undo_actions() - >>> bv.get_disassembly(0x100012f1) - 'nop' - >>> bv.undo() - >>> bv.get_disassembly(0x100012f1) - 'xor eax, eax' - >>> - """ - self.file.begin_undo_actions() - - def add_undo_action(self, action): - core.BNAddUndoAction(self.handle, action.__class__.name, action._cb) - - def commit_undo_actions(self): - """ - ``commit_undo_actions`` commit the actions taken since the last commit to the undo database. - - :rtype: None - :Example: - - >>> bv.get_disassembly(0x100012f1) - 'xor eax, eax' - >>> bv.begin_undo_actions() - >>> bv.convert_to_nop(bv.arch, 0x100012f1) - True - >>> bv.commit_undo_actions() - >>> bv.get_disassembly(0x100012f1) - 'nop' - >>> bv.undo() - >>> bv.get_disassembly(0x100012f1) - 'xor eax, eax' - >>> - """ - self.file.commit_undo_actions() - - def undo(self): - """ - ``undo`` undo the last commited action in the undo database. - - :rtype: None - :Example: - - >>> bv.get_disassembly(0x100012f1) - 'xor eax, eax' - >>> bv.begin_undo_actions() - >>> bv.convert_to_nop(bv.arch, 0x100012f1) - True - >>> bv.commit_undo_actions() - >>> bv.get_disassembly(0x100012f1) - 'nop' - >>> bv.undo() - >>> bv.get_disassembly(0x100012f1) - 'xor eax, eax' - >>> bv.redo() - >>> bv.get_disassembly(0x100012f1) - 'nop' - >>> - """ - self.file.undo() - - def redo(self): - """ - ``redo`` redo the last commited action in the undo database. - - :rtype: None - :Example: - - >>> bv.get_disassembly(0x100012f1) - 'xor eax, eax' - >>> bv.begin_undo_actions() - >>> bv.convert_to_nop(bv.arch, 0x100012f1) - True - >>> bv.commit_undo_actions() - >>> bv.get_disassembly(0x100012f1) - 'nop' - >>> bv.undo() - >>> bv.get_disassembly(0x100012f1) - 'xor eax, eax' - >>> bv.redo() - >>> bv.get_disassembly(0x100012f1) - 'nop' - >>> - """ - self.file.redo() - - def navigate(self, view, offset): - self.file.navigate(view, offset) - - def read(self, addr, length): - """ - ``read`` returns the data reads at most ``length`` bytes from virtual address ``addr``. - - :param int addr: virtual address to read from. - :param int length: number of bytes to read. - :return: at most ``length`` bytes from the virtual address ``addr``, empty string on error or no data. - :rtype: str - :Example: - - >>> #Opening a x86_64 Mach-O binary - >>> bv = BinaryViewType['Raw'].open("/bin/ls") - >>> bv.read(0,4) - \'\\xcf\\xfa\\xed\\xfe\' - """ - buf = DataBuffer(handle = core.BNReadViewBuffer(self.handle, addr, length)) - return str(buf) - - def write(self, addr, data): - """ - ``write`` writes the bytes in ``data`` to the virtual address ``addr``. - - :param int addr: virtual address to write to. - :param str data: data to be written at addr. - :return: number of bytes written to virtual address ``addr`` - :rtype: int - :Example: - - >>> bv.read(0,4) - 'BBBB' - >>> bv.write(0, "AAAA") - 4L - >>> bv.read(0,4) - 'AAAA' - """ - buf = DataBuffer(data) - return core.BNWriteViewBuffer(self.handle, addr, buf.handle) - - def insert(self, addr, data): - """ - ``insert`` inserts the bytes in ``data`` to the virtual address ``addr``. - - :param int addr: virtual address to write to. - :param str data: data to be inserted at addr. - :return: number of bytes inserted to virtual address ``addr`` - :rtype: int - :Example: - - >>> bv.insert(0,"BBBB") - 4L - >>> bv.read(0,8) - 'BBBBAAAA' - """ - buf = DataBuffer(data) - return core.BNInsertViewBuffer(self.handle, addr, buf.handle) - - def remove(self, addr, length): - """ - ``remove`` removes at most ``length`` bytes from virtual address ``addr``. - - :param int addr: virtual address to remove from. - :param int length: number of bytes to remove. - :return: number of bytes removed from virtual address ``addr`` - :rtype: int - :Example: - - >>> bv.read(0,8) - 'BBBBAAAA' - >>> bv.remove(0,4) - 4L - >>> bv.read(0,4) - 'AAAA' - """ - return core.BNRemoveViewData(self.handle, addr, length) - - def get_modification(self, addr, length = None): - """ - ``get_modification`` returns the modified bytes of up to ``length`` bytes from virtual address ``addr``, or if - ``length`` is None returns the core.BNModificationStatus. - - :param int addr: virtual address to get modification from - :param int length: optional length of modification - :return: Either core.BNModificationStatus of the byte at ``addr``, or string of modified bytes at ``addr`` - :rtype: core.BNModificationStatus or str - """ - if length is None: - return core.BNGetModification(self.handle, addr) - data = (core.BNModificationStatus * length)() - length = core.BNGetModificationArray(self.handle, addr, data, length) - return data[0:length] - - def is_valid_offset(self, addr): - """ - ``is_valid_offset`` checks if an virtual address ``addr`` is valid . - - :param int addr: a virtual address to be checked - :return: true if the virtual address is valid, false if the virtual address is invalid or error - :rtype: bool - """ - return core.BNIsValidOffset(self.handle, addr) - - def is_offset_readable(self, addr): - """ - ``is_offset_readable`` checks if an virtual address ``addr`` is valid for reading. - - :param int addr: a virtual address to be checked - :return: true if the virtual address is valid for reading, false if the virtual address is invalid or error - :rtype: bool - """ - return core.BNIsOffsetReadable(self.handle, addr) - - def is_offset_writable(self, addr): - """ - ``is_offset_writable`` checks if an virtual address ``addr`` is valid for writing. - - :param int addr: a virtual address to be checked - :return: true if the virtual address is valid for writing, false if the virtual address is invalid or error - :rtype: bool - """ - return core.BNIsOffsetWritable(self.handle, addr) - - def is_offset_executable(self, addr): - """ - ``is_offset_executable`` checks if an virtual address ``addr`` is valid for executing. - - :param int addr: a virtual address to be checked - :return: true if the virtual address is valid for executing, false if the virtual address is invalid or error - :rtype: bool - """ - return core.BNIsOffsetExecutable(self.handle, addr) - - def save(self, dest): - """ - ``save`` saves the original binary file to the provided destination ``dest`` along with any modifications. - - :param str dest: destination path and filename of file to be written - :return: boolean True on success, False on failure - :rtype: bool - """ - if isinstance(dest, FileAccessor): - return core.BNSaveToFile(self.handle, dest._cb) - return core.BNSaveToFilename(self.handle, str(dest)) - - def register_notification(self, notify): - cb = BinaryDataNotificationCallbacks(self, notify) - cb._register() - self.notifications[notify] = cb - - def unregister_notification(self, notify): - if notify in self.notifications: - self.notifications[notify]._unregister() - del self.notifications[notify] - - def add_function(self, platform, addr): - """ - ``add_function`` add a new function of the given ``platform`` at the virtual address ``addr`` - - :param Platform platform: Platform for the function to be added - :param int addr: virtual address of the function to be added - :rtype: None - :Example: - - >>> bv.add_function(bv.platform, 1) - >>> bv.functions - [] - - """ - core.BNAddFunctionForAnalysis(self.handle, platform.handle, addr) - - def add_entry_point(self, platform, addr): - """ - ``add_entry_point`` adds an virtual address to start analysis from for a given platform. - - :param Platform platform: Platform for the entry point analysis - :param int addr: virtual address to start analysis from - :rtype: None - :Example: - >>> bv.add_entry_point(bv.platform, 0xdeadbeef) - >>> - """ - core.BNAddEntryPointForAnalysis(self.handle, platform.handle, addr) - - def remove_function(self, func): - """ - ``remove_function`` removes the function ``func`` from the list of functions - - :param Function func: a Function object. - :rtype: None - :Example: - - >>> bv.functions - [] - >>> bv.remove_function(bv.functions[0]) - >>> bv.functions - [] - """ - core.BNRemoveAnalysisFunction(self.handle, func.handle) - - def create_user_function(self, platform, addr): - """ - ``create_user_function`` add a new *user* function of the given ``platform`` at the virtual address ``addr`` - - :param Platform platform: Platform for the function to be added - :param int addr: virtual address of the *user* function to be added - :rtype: None - :Example: - - >>> bv.create_user_function(bv.platform, 1) - >>> bv.functions - [] - - """ - core.BNCreateUserFunction(self.handle, platform.handle, addr) - - def remove_user_function(self, func): - """ - ``remove_user_function`` removes the *user* function ``func`` from the list of functions - - :param Function func: a Function object. - :rtype: None - :Example: - - >>> bv.functions - [] - >>> bv.remove_user_function(bv.functions[0]) - >>> bv.functions - [] - """ - core.BNRemoveUserFunction(self.handle, func.handle) - - def update_analysis(self): - """ - ``update_analysis`` asynchronously starts the analysis running and returns immediately. Analysis of BinaryViews - does not occur automatically, the user must start analysis by calling either ``update_analysis()`` or - ``update_analysis_and_wait()``. An analysis update **must** be run after changes are made which could change - analysis results such as adding functions. - - :rtype: None - """ - core.BNUpdateAnalysis(self.handle) - - def update_analysis_and_wait(self): - """ - ``update_analysis_and_wait`` blocking call to update the analysis, this call returns when the analysis is - complete. Analysis of BinaryViews does not occur automatically, the user must start analysis by calling either - ``update_analysis()`` or ``update_analysis_and_wait()``. An analysis update **must** be run after changes are - made which could change analysis results such as adding functions. - - :rtype: None - """ - class WaitEvent: - def __init__(self): - self.cond = threading.Condition() - self.done = False - - def complete(self): - self.cond.acquire() - self.done = True - self.cond.notify() - self.cond.release() - - def wait(self): - self.cond.acquire() - while not self.done: - self.cond.wait() - self.cond.release() - - wait = WaitEvent() - event = AnalysisCompletionEvent(self, lambda: wait.complete()) - core.BNUpdateAnalysis(self.handle) - wait.wait() - - def abort_analysis(self): - """ - ``abort_analysis`` will abort the currently running analysis. - - :rtype: None - """ - core.BNAbortAnalysis(self.handle) - - def define_data_var(self, addr, var_type): - """ - ``define_data_var`` defines a non-user data variable ``var_type`` at the virtual address ``addr``. - - :param int addr: virtual address to define the given data variable - :param Type var_type: type to be defined at the given virtual address - :rtype: None - :Example: - - >>> t = bv.parse_type_string("int foo") - >>> t - (, 'foo') - >>> bv.define_data_var(bv.entry_point, t[0]) - >>> - """ - core.BNDefineDataVariable(self.handle, addr, var_type.handle) - - def define_user_data_var(self, addr, var_type): - """ - ``define_data_var`` defines a user data variable ``var_type`` at the virtual address ``addr``. - - :param int addr: virtual address to define the given data variable - :param binaryninja.Type var_type: type to be defined at the given virtual address - :rtype: None - :Example: - - >>> t = bv.parse_type_string("int foo") - >>> t - (, 'foo') - >>> bv.define_user_data_var(bv.entry_point, t[0]) - >>> - """ - core.BNDefineUserDataVariable(self.handle, addr, var_type.handle) - - def undefine_data_var(self, addr): - """ - ``undefine_data_var`` removes the non-user data variable at the virtual address ``addr``. - - :param int addr: virtual address to define the data variable to be removed - :rtype: None - :Example: - - >>> bv.undefine_data_var(bv.entry_point) - >>> - """ - core.BNUndefineDataVariable(self.handle, addr) - - def undefine_user_data_var(self, addr): - """ - ``undefine_data_var`` removes the user data variable at the virtual address ``addr``. - - :param int addr: virtual address to define the data variable to be removed - :rtype: None - :Example: - - >>> bv.undefine_user_data_var(bv.entry_point) - >>> - """ - core.BNUndefineUserDataVariable(self.handle, addr) - - def get_data_var_at(self, addr): - """ - ``get_data_var_at`` returns the data type at a given virtual address. - - :param int addr: virtual address to get the data type from - :return: returns the DataVariable at the given virtual address, None on error. - :rtype: DataVariable - :Example: - - >>> t = bv.parse_type_string("int foo") - >>> bv.define_data_var(bv.entry_point, t[0]) - >>> bv.get_data_var_at(bv.entry_point) - - - """ - var = core.BNDataVariable() - if not core.BNGetDataVariableAtAddress(self.handle, addr, var): - return None - return DataVariable(var.address, Type(var.type), var.autoDiscovered) - - def get_function_at(self, platform, addr): - """ - ``get_function_at`` gets a binaryninja.Function object for the function at the virtual address ``addr``: - - :param binaryninja.Platform platform: platform of the desired function - :param int addr: virtual address of the desired function - :return: returns a Function object or None for the function at the virtual address provided - :rtype: Function - :Example: - - >>> bv.get_function_at(bv.platform, bv.entry_point) - - >>> - """ - func = core.BNGetAnalysisFunction(self.handle, platform.handle, addr) - if func is None: - return None - return Function(self, func) - - def get_functions_at(self, addr): - """ - ``get_functions_at`` get a list of binaryninja.Function objects (one for each valid platform) at the given - virtual address. Binary Ninja does not limit the number of platforms in a given file thus there may be multiple - functions defined from different architectures at the same location. This API allows you to query all of valid - platforms. - - :param int addr: virtual address of the desired Function object list. - :return: a list of binaryninja.Function objects defined at the provided virtual address - :rtype: list(Function) - """ - count = ctypes.c_ulonglong(0) - funcs = core.BNGetAnalysisFunctionsForAddress(self.handle, addr, count) - result = [] - for i in xrange(0, count.value): - result.append(Function(self, core.BNNewFunctionReference(funcs[i]))) - core.BNFreeFunctionList(funcs, count.value) - return result - - def get_recent_function_at(self, addr): - func = core.BNGetRecentAnalysisFunctionForAddress(self.handle, addr) - if func is None: - return None - return Function(self, func) - - def get_basic_blocks_at(self, addr): - """ - ``get_basic_blocks_at`` get a list of :py:Class:`BasicBlock` objects which exist at the provided virtual address. - - :param int addr: virtual address of BasicBlock desired - :return: a list of :py:Class:`BasicBlock` objects - :rtype: list(BasicBlock) - """ - count = ctypes.c_ulonglong(0) - blocks = core.BNGetBasicBlocksForAddress(self.handle, addr, count) - result = [] - for i in xrange(0, count.value): - result.append(BasicBlock(self, core.BNNewBasicBlockReference(blocks[i]))) - core.BNFreeBasicBlockList(blocks, count.value) - return result - - def get_basic_blocks_starting_at(self, addr): - """ - ``get_basic_blocks_at`` get a list of :py:Class:`BasicBlock` objects which start at the provided virtual address. - - :param int addr: virtual address of BasicBlock desired - :return: a list of :py:Class:`BasicBlock` objects - :rtype: list(BasicBlock) - """ - count = ctypes.c_ulonglong(0) - blocks = core.BNGetBasicBlocksStartingAtAddress(self.handle, addr, count) - result = [] - for i in xrange(0, count.value): - result.append(BasicBlock(self, core.BNNewBasicBlockReference(blocks[i]))) - core.BNFreeBasicBlockList(blocks, count.value) - return result - - def get_recent_basic_block_at(self, addr): - block = core.BNGetRecentBasicBlockForAddress(self.handle, addr) - if block is None: - return None - return BasicBlock(self, block) - - def get_code_refs(self, addr, length = None): - count = ctypes.c_ulonglong(0) - if length is None: - refs = core.BNGetCodeReferences(self.handle, addr, count) - else: - refs = core.BNGetCodeReferencesInRange(self.handle, addr, length, count) - result = [] - for i in xrange(0, count.value): - if refs[i].func: - func = Function(self, core.BNNewFunctionReference(refs[i].func)) - else: - func = None - if refs[i].arch: - arch = Architecture(refs[i].arch) - else: - arch = None - addr = refs[i].addr - result.append(ReferenceSource(func, arch, addr)) - core.BNFreeCodeReferences(refs, count.value) - return result - - def get_symbol_at(self, addr): - """ - ``get_symbol_at`` returns the Symbol at the provided virtual address. - - :param int addr: virtual address to query for symbol - :return: Symbol for the given virtual address - :rtype: Symbol - :Example: - - >>> bv.get_symbol_at(bv.entry_point) - - >>> - """ - sym = core.BNGetSymbolByAddress(self.handle, addr) - if sym is None: - return None - return Symbol(None, None, None, handle = sym) - - def get_symbol_by_raw_name(self, name): - """ - ``get_symbol_by_raw_name`` retrieves a Symbol object for the given a raw (mangled) name. - - :param str name: raw (mangled) name of Symbol to be retrieved - :return: Symbol object corresponding to the provided raw name - :rtype: Symbol - :Example: - - >>> bv.get_symbol_by_raw_name('?testf@Foobar@@SA?AW4foo@1@W421@@Z') - - >>> - """ - sym = core.BNGetSymbolByRawName(self.handle, name) - if sym is None: - return None - return Symbol(None, None, None, handle = sym) - - def get_symbols_by_name(self, name): - """ - ``get_symbols_by_name`` retrieves a list of Symbol objects for the given symbol name. - - :param str name: name of Symbol object to be retrieved - :return: Symbol object corresponding to the provided name - :rtype: Symbol - :Example: - - >>> bv.get_symbols_by_name('?testf@Foobar@@SA?AW4foo@1@W421@@Z') - [] - >>> - """ - count = ctypes.c_ulonglong(0) - syms = core.BNGetSymbolsByName(self.handle, name, count) - result = [] - for i in xrange(0, count.value): - result.append(Symbol(None, None, None, handle = core.BNNewSymbolReference(syms[i]))) - core.BNFreeSymbolList(syms, count.value) - return result - - def get_symbols(self, start = None, length = None): - """ - ``get_symbols`` retrieves the list of all Symbol objects in the optionally provided range. - - :param int start: optional start virtual address - :param int length: optional length - :return: list of all Symbol objects, or those Symbol objects in the range of ``start``-``start+length`` - :rtype: list(Symbol) - :Example: - - >>> bv.get_symbols(0x1000200c, 1) - [] - >>> - """ - count = ctypes.c_ulonglong(0) - if start is None: - syms = core.BNGetSymbols(self.handle, count) - else: - syms = core.BNGetSymbolsInRange(self.handle, start, length, count) - result = [] - for i in xrange(0, count.value): - result.append(Symbol(None, None, None, handle = core.BNNewSymbolReference(syms[i]))) - core.BNFreeSymbolList(syms, count.value) - return result - - def get_symbols_of_type(self, sym_type, start = None, length = None): - """ - ``get_symbols_of_type`` retrieves a list of all Symbol objects of the provided symbol type in the optionally - provided range. - - :param SymbolType sym_type: A Symbol type: :py:Class:`Symbol`. - :param int start: optional start virtual address - :param int length: optional length - :return: list of all Symbol objects of type sym_type, or those Symbol objects in the range of ``start``-``start+length`` - :rtype: list(Symbol) - :Example: - - >>> bv.get_symbols_of_type(core.ImportAddressSymbol, 0x10002028, 1) - [] - >>> - """ - if isinstance(sym_type, str): - sym_type = core.BNSymbolType_by_name[sym_type] - count = ctypes.c_ulonglong(0) - if start is None: - syms = core.BNGetSymbolsOfType(self.handle, sym_type, count) - else: - syms = core.BNGetSymbolsOfTypeInRange(self.handle, sym_type, start, length, count) - result = [] - for i in xrange(0, count.value): - result.append(Symbol(None, None, None, handle = core.BNNewSymbolReference(syms[i]))) - core.BNFreeSymbolList(syms, count.value) - return result - - def define_auto_symbol(self, sym): - """ - ``define_auto_symbol`` adds a symbol to the internal list of automatically discovered Symbol objects. - - :param Symbol sym: the symbol to define - :rtype: None - """ - core.BNDefineAutoSymbol(self.handle, sym.handle) - - def undefine_auto_symbol(self, sym): - """ - ``undefine_auto_symbol`` removes a symbol from the internal list of automatically discovered Symbol objects. - - :param Symbol sym: the symbol to undefine - :rtype: None - """ - core.BNUndefineAutoSymbol(self.handle, sym.handle) - - def define_user_symbol(self, sym): - """ - ``define_user_symbol`` adds a symbol to the internal list of user added Symbol objects. - - :param Symbol sym: the symbol to define - :rtype: None - """ - core.BNDefineUserSymbol(self.handle, sym.handle) - - def undefine_user_symbol(self, sym): - """ - ``undefine_user_symbol`` removes a symbol from the internal list of user added Symbol objects. - - :param Symbol sym: the symbol to undefine - :rtype: None - """ - core.BNUndefineUserSymbol(self.handle, sym.handle) - - def define_imported_function(self, import_addr_sym, func): - """ - ``define_imported_function`` defines an imported Function ``func`` with a ImportedFunctionSymbol type. - - :param Symbol import_addr_sym: A Symbol object with type ImportedFunctionSymbol - :param Function func: A Function object to define as an imported function - :rtype: None - """ - core.BNDefineImportedFunction(self.handle, import_addr_sym.handle, func.handle) - - def is_never_branch_patch_available(self, arch, addr): - """ - ``is_never_branch_patch_available`` queries the architecture plugin to determine if the instruction at the - instruction at ``addr`` can be made to **never branch**. The actual logic of which is implemented in the - ``perform_is_never_branch_patch_available`` in the corresponding architecture. - - :param Architecture arch: the architecture for the current view - :param int addr: the virtual address of the instruction to be patched - :return: True if the instruction can be patched, False otherwise - :rtype: bool - :Example: - - >>> bv.get_disassembly(0x100012ed) - 'test eax, eax' - >>> bv.is_never_branch_patch_available(bv.arch, 0x100012ed) - False - >>> bv.get_disassembly(0x100012ef) - 'jg 0x100012f5' - >>> bv.is_never_branch_patch_available(bv.arch, 0x100012ef) - True - >>> - """ - return core.BNIsNeverBranchPatchAvailable(self.handle, arch.handle, addr) - - def is_always_branch_patch_available(self, arch, addr): - """ - ``is_always_branch_patch_available`` queries the architecture plugin to determine if the - instruction at ``addr`` can be made to **always branch**. The actual logic of which is implemented in the - ``perform_is_always_branch_patch_available`` in the corresponding architecture. - - :param Architecture arch: the architecture for the current view - :param int addr: the virtual address of the instruction to be patched - :return: True if the instruction can be patched, False otherwise - :rtype: bool - :Example: - - >>> bv.get_disassembly(0x100012ed) - 'test eax, eax' - >>> bv.is_always_branch_patch_available(bv.arch, 0x100012ed) - False - >>> bv.get_disassembly(0x100012ef) - 'jg 0x100012f5' - >>> bv.is_always_branch_patch_available(bv.arch, 0x100012ef) - True - >>> - """ - return core.BNIsAlwaysBranchPatchAvailable(self.handle, arch.handle, addr) - - def is_invert_branch_patch_available(self, arch, addr): - """ - ``is_invert_branch_patch_available`` queries the architecture plugin to determine if the instruction at ``addr`` - is a branch that can be inverted. The actual logic of which is implemented in the - ``perform_is_invert_branch_patch_available`` in the corresponding architecture. - - :param Architecture arch: the architecture for the current view - :param int addr: the virtual address of the instruction to be patched - :return: True if the instruction can be patched, False otherwise - :rtype: bool - :Example: - - >>> bv.get_disassembly(0x100012ed) - 'test eax, eax' - >>> bv.is_invert_branch_patch_available(bv.arch, 0x100012ed) - False - >>> bv.get_disassembly(0x100012ef) - 'jg 0x100012f5' - >>> bv.is_invert_branch_patch_available(bv.arch, 0x100012ef) - True - >>> - """ - return core.BNIsInvertBranchPatchAvailable(self.handle, arch.handle, addr) - - def is_skip_and_return_zero_patch_available(self, arch, addr): - """ - ``is_skip_and_return_zero_patch_available`` queries the architecture plugin to determine if the - instruction at ``addr`` is similar to an x86 "call" instruction which can be made to return zero. The actual - logic of which is implemented in the ``perform_is_skip_and_return_zero_patch_available`` in the corresponding - architecture. - - :param Architecture arch: the architecture for the current view - :param int addr: the virtual address of the instruction to be patched - :return: True if the instruction can be patched, False otherwise - :rtype: bool - :Example: - - >>> bv.get_disassembly(0x100012f6) - 'mov dword [0x10003020], eax' - >>> bv.is_skip_and_return_zero_patch_available(bv.arch, 0x100012f6) - False - >>> bv.get_disassembly(0x100012fb) - 'call 0x10001629' - >>> bv.is_skip_and_return_zero_patch_available(bv.arch, 0x100012fb) - True - >>> - """ - return core.BNIsSkipAndReturnZeroPatchAvailable(self.handle, arch.handle, addr) - - def is_skip_and_return_value_patch_available(self, arch, addr): - """ - ``is_skip_and_return_value_patch_available`` queries the architecture plugin to determine if the - instruction at ``addr`` is similar to an x86 "call" instruction which can be made to return a value. The actual - logic of which is implemented in the ``perform_is_skip_and_return_value_patch_available`` in the corresponding - architecture. - - :param Architecture arch: the architecture for the current view - :param int addr: the virtual address of the instruction to be patched - :return: True if the instruction can be patched, False otherwise - :rtype: bool - :Example: - - >>> bv.get_disassembly(0x100012f6) - 'mov dword [0x10003020], eax' - >>> bv.is_skip_and_return_value_patch_available(bv.arch, 0x100012f6) - False - >>> bv.get_disassembly(0x100012fb) - 'call 0x10001629' - >>> bv.is_skip_and_return_value_patch_available(bv.arch, 0x100012fb) - True - >>> - """ - return core.BNIsSkipAndReturnValuePatchAvailable(self.handle, arch.handle, addr) - - def convert_to_nop(self, arch, addr): - """ - ``convert_to_nop`` converts the instruction at virtual address ``addr`` to a nop of the provided architecture. - - .. note:: This API performs a binary patch, analysis may need to be updated afterward. Additionally the binary\ - file must be saved in order to preserve the changes made. - - :param Architecture arch: architecture of the current BinaryView - :param int addr: virtual address of the instruction to conver to nops - :return: True on success, False on falure. - :rtype: bool - :Example: - - >>> bv.get_disassembly(0x100012fb) - 'call 0x10001629' - >>> bv.convert_to_nop(bv.arch, 0x100012fb) - True - >>> #The above 'call' instruction is 5 bytes, a nop in x86 is 1 byte, - >>> # thus 5 nops are used: - >>> bv.get_disassembly(0x100012fb) - 'nop' - >>> bv.get_next_disassembly() - 'nop' - >>> bv.get_next_disassembly() - 'nop' - >>> bv.get_next_disassembly() - 'nop' - >>> bv.get_next_disassembly() - 'nop' - >>> bv.get_next_disassembly() - 'mov byte [ebp-0x1c], al' - """ - return core.BNConvertToNop(self.handle, arch.handle, addr) - - def always_branch(self, arch, addr): - """ - ``always_branch`` convert the instruction of architecture ``arch`` at the virtual address ``addr`` to an - unconditional branch. - - .. note:: This API performs a binary patch, analysis may need to be updated afterward. Additionally the binary\ - file must be saved in order to preserve the changes made. - - :param Architecture arch: architecture of the current binary view - :param int addr: virtual address of the instruction to be modified - :return: True on success, False on falure. - :rtype: bool - :Example: - - >>> bv.get_disassembly(0x100012ef) - 'jg 0x100012f5' - >>> bv.always_branch(bv.arch, 0x100012ef) - True - >>> bv.get_disassembly(0x100012ef) - 'jmp 0x100012f5' - >>> - """ - return core.BNAlwaysBranch(self.handle, arch.handle, addr) - - def never_branch(self, arch, addr): - """ - ``never_branch`` convert the branch instruction of architecture ``arch`` at the virtual address ``addr`` to - a fall through. - - .. note:: This API performs a binary patch, analysis may need to be updated afterward. Additionally the binary\ - file must be saved in order to preserve the changes made. - - :param Architecture arch: architecture of the current binary view - :param int addr: virtual address of the instruction to be modified - :return: True on success, False on falure. - :rtype: bool - :Example: - - >>> bv.get_disassembly(0x1000130e) - 'jne 0x10001317' - >>> bv.never_branch(bv.arch, 0x1000130e) - True - >>> bv.get_disassembly(0x1000130e) - 'nop' - >>> - """ - return core.BNConvertToNop(self.handle, arch.handle, addr) - - def invert_branch(self, arch, addr): - """ - ``invert_branch`` convert the branch instruction of architecture ``arch`` at the virtual address ``addr`` to the - inverse branch. - - .. note:: This API performs a binary patch, analysis may need to be updated afterward. Additionally the binary - file must be saved in order to preserve the changes made. - - :param Architecture arch: architecture of the current binary view - :param int addr: virtual address of the instruction to be modified - :return: True on success, False on falure. - :rtype: bool - :Example: - - >>> bv.get_disassembly(0x1000130e) - 'je 0x10001317' - >>> bv.invert_branch(bv.arch, 0x1000130e) - True - >>> - >>> bv.get_disassembly(0x1000130e) - 'jne 0x10001317' - >>> - """ - return core.BNInvertBranch(self.handle, arch.handle, addr) - - def skip_and_return_value(self, arch, addr, value): - """ - ``skip_and_return_value`` convert the ``call`` instruction of architecture ``arch`` at the virtual address - ``addr`` to the equivilent of returning a value. - - :param Architecture arch: architecture of the current binary view - :param int addr: virtual address of the instruction to be modified - :param int value: value to make the instruction *return* - :return: True on success, False on falure. - :rtype: bool - :Example: - - >>> bv.get_disassembly(0x1000132a) - 'call 0x1000134a' - >>> bv.skip_and_return_value(bv.arch, 0x1000132a, 42) - True - >>> #The return value from x86 functions is stored in eax thus: - >>> bv.get_disassembly(0x1000132a) - 'mov eax, 0x2a' - >>> - """ - return core.BNSkipAndReturnValue(self.handle, arch.handle, addr, value) - - def get_instruction_length(self, arch, addr): - """ - ``get_instruction_length`` returns the number of bytes in the instruction of Architecture ``arch`` at the virtual - address ``addr`` - - :param Architecture arch: architecture of the current binary view - :param int addr: virtual address of the instruction query - :return: Number of bytes in instruction - :rtype: int - :Example: - - >>> bv.get_disassembly(0x100012f1) - 'xor eax, eax' - >>> bv.get_instruction_length(bv.arch, 0x100012f1) - 2L - >>> - """ - return core.BNGetInstructionLength(self.handle, arch.handle, addr) - - def notify_data_written(self, offset, length): - core.BNNotifyDataWritten(self.handle, offset, length) - - def notify_data_inserted(self, offset, length): - core.BNNotifyDataInserted(self.handle, offset, length) - - def notify_data_removed(self, offset, length): - core.BNNotifyDataRemoved(self.handle, offset, length) - - def get_strings(self, start = None, length = None): - """ - ``get_strings`` returns a list of strings defined in the binary in the optional virtual address range: - ``start-(start+length)`` - - :param int start: optional virtual address to start the string list from, defaults to start of the binary - :param int length: optional length range to return strings from, defaults to length of the binary - :return: a list of all strings or a list of strings defined between ``start`` and ``start+length`` - :rtype: list(str()) - :Example: - - >>> bv.get_strings(0x1000004d, 1) - [] - >>> - """ - count = ctypes.c_ulonglong(0) - if start is None: - strings = core.BNGetStrings(self.handle, count) - else: - strings = core.BNGetStringsInRange(self.handle, start, length, count) - result = [] - for i in xrange(0, count.value): - result.append(StringReference(core.BNStringType_names[strings[i].type], strings[i].start, strings[i].length)) - core.BNFreeStringReferenceList(strings) - return result - - def add_analysis_completion_event(self, callback): - """ - ``add_analysis_completion_event`` sets up a call back function to be called when analysis has been completed. - This is helpful when using asynchronously analysis. - - :param callable() callback: A function to be called with no parameters when analysis has completed. - :return: An initialized AnalysisCompletionEvent object. - :rtype: AnalysisCompletionEvent - :Example: - - >>> def completionEvent(): - ... print "done" - ... - >>> bv.add_analysis_completion_event(completionEvent) - - >>> bv.update_analysis() - done - >>> - """ - return AnalysisCompletionEvent(self, callback) - - def get_next_function_start_after(self, addr): - """ - ``get_next_function_start_after`` returns the virtual address of the Function that occurs after the virtual address - ``addr`` - - :param int addr: the virtual address to start looking from. - :return: the virtual address of the next Function - :rtype: int - :Example: - - >>> bv.get_next_function_start_after(bv.entry_point) - 268441061L - >>> hex(bv.get_next_function_start_after(bv.entry_point)) - '0x100015e5L' - >>> hex(bv.get_next_function_start_after(0x100015e5)) - '0x10001629L' - >>> hex(bv.get_next_function_start_after(0x10001629)) - '0x1000165eL' - >>> - """ - return core.BNGetNextFunctionStartAfterAddress(self.handle, addr) - - def get_next_basic_block_start_after(self, addr): - """ - ``get_next_basic_block_start_after`` returns the virtual address of the BasicBlock that occurs after the virtual - address ``addr`` - - :param int addr: the virtual address to start looking from. - :return: the virtual address of the next BasicBlock - :rtype: int - :Example: - - >>> hex(bv.get_next_basic_block_start_after(bv.entry_point)) - '0x100014a8L' - >>> hex(bv.get_next_basic_block_start_after(0x100014a8)) - '0x100014adL' - >>> - """ - return core.BNGetNextBasicBlockStartAfterAddress(self.handle, addr) - - def get_next_data_after(self, addr): - """ - ``get_next_data_after`` retrieves the virtual address of the next non-code byte. - - :param int addr: the virtual address to start looking from. - :return: the virtual address of the next data byte which is data, not code - :rtype: int - :Example: - - >>> hex(bv.get_next_data_after(0x10000000)) - '0x10000001L' - """ - return core.BNGetNextDataAfterAddress(self.handle, addr) - - def get_next_data_var_after(self, addr): - """ - ``get_next_data_var_after`` retrieves the next virtual address of the next :py:Class:`DataVariable` - - :param int addr: the virtual address to start looking from. - :return: the virtual address of the next :py:Class:`DataVariable` - :rtype: int - :Example: - - >>> hex(bv.get_next_data_var_after(0x10000000)) - '0x1000003cL' - >>> bv.get_data_var_at(0x1000003c) - - >>> - """ - return core.BNGetNextDataVariableAfterAddress(self.handle, addr) - - def get_previous_function_start_before(self, addr): - """ - ``get_previous_function_start_before`` returns the virtual address of the Function that occurs prior to the - virtual address provided - - :param int addr: the virtual address to start looking from. - :return: the virtual address of the previous Function - :rtype: int - :Example: - - >>> hex(bv.entry_point) - '0x1000149fL' - >>> hex(bv.get_next_function_start_after(bv.entry_point)) - '0x100015e5L' - >>> hex(bv.get_previous_function_start_before(0x100015e5)) - '0x1000149fL' - >>> - """ - return core.BNGetPreviousFunctionStartBeforeAddress(self.handle, addr) - - def get_previous_basic_block_start_before(self, addr): - """ - ``get_previous_basic_block_start_before`` returns the virtual address of the BasicBlock that occurs prior to the - provided virtual address - - :param int addr: the virtual address to start looking from. - :return: the virtual address of the previous BasicBlock - :rtype: int - :Example: - - >>> hex(bv.entry_point) - '0x1000149fL' - >>> hex(bv.get_next_basic_block_start_after(bv.entry_point)) - '0x100014a8L' - >>> hex(bv.get_previous_basic_block_start_before(0x100014a8)) - '0x1000149fL' - >>> - """ - return core.BNGetPreviousBasicBlockStartBeforeAddress(self.handle, addr) - - def get_previous_basic_block_end_before(self, addr): - """ - ``get_previous_basic_block_end_before`` - - :param int addr: the virtual address to start looking from. - :return: the virtual address of the previous BasicBlock end - :rtype: int - :Example: - >>> hex(bv.entry_point) - '0x1000149fL' - >>> hex(bv.get_next_basic_block_start_after(bv.entry_point)) - '0x100014a8L' - >>> hex(bv.get_previous_basic_block_end_before(0x100014a8)) - '0x100014a8L' - """ - return core.BNGetPreviousBasicBlockEndBeforeAddress(self.handle, addr) - - def get_previous_data_before(self, addr): - """ - ``get_previous_data_before`` - - :param int addr: the virtual address to start looking from. - :return: the virtual address of the previous data (non-code) byte - :rtype: int - :Example: - - >>> hex(bv.get_previous_data_before(0x1000001)) - '0x1000000L' - >>> - """ - return core.BNGetPreviousDataBeforeAddress(self.handle, addr) - - def get_previous_data_var_before(self, addr): - """ - ``get_previous_data_var_before`` - - :param int addr: the virtual address to start looking from. - :return: the virtual address of the previous :py:Class:`DataVariable` - :rtype: int - :Example: - - >>> hex(bv.get_previous_data_var_before(0x1000003c)) - '0x10000000L' - >>> bv.get_data_var_at(0x10000000) - - >>> - """ - return core.BNGetPreviousDataVariableBeforeAddress(self.handle, addr) - - def get_linear_disassembly_position_at(self, addr, settings): - """ - ``get_linear_disassembly_position_at`` instantiates a :py:class:`LinearDisassemblyPosition` object for use in - :py:method:`get_previous_linear_disassembly_lines` or :py:method:`get_next_linear_disassembly_lines`. - - :param int addr: virtual address of linear disassembly position - :param DisassemblySettings settings: an instantiated :py:class:`DisassemblySettings` object - :return: An instantied :py:class:`LinearDisassemblyPosition` object for the provided virtual address - :rtype: LinearDisassemblyPosition - :Example: - - >>> settings = DisassemblySettings() - >>> pos = bv.get_linear_disassembly_position_at(0x1000149f, settings) - >>> lines = bv.get_previous_linear_disassembly_lines(pos, settings) - >>> lines - [<0x1000149a: pop esi>, <0x1000149b: pop ebp>, - <0x1000149c: retn 0xc>, <0x1000149f: >] - """ - if settings is not None: - settings = settings.handle - pos = core.BNGetLinearDisassemblyPositionForAddress(self.handle, addr, settings) - func = None - block = None - if pos.function: - func = Function(self, pos.function) - if pos.block: - block = BasicBlock(self, pos.block) - return LinearDisassemblyPosition(func, block, pos.address) - - def _get_linear_disassembly_lines(self, api, pos, settings): - pos_obj = core.BNLinearDisassemblyPosition() - pos_obj.function = None - pos_obj.block = None - pos_obj.address = pos.address - if pos.function is not None: - pos_obj.function = core.BNNewFunctionReference(pos.function.handle) - if pos.block is not None: - pos_obj.block = core.BNNewBasicBlockReference(pos.block.handle) - - if settings is not None: - settings = settings.handle - - count = ctypes.c_ulonglong(0) - lines = api(self.handle, pos_obj, settings, count) - - result = [] - for i in xrange(0, count.value): - func = None - block = None - if lines[i].function: - func = Function(self, core.BNNewFunctionReference(lines[i].function)) - if lines[i].block: - block = BasicBlock(self, core.BNNewBasicBlockReference(lines[i].block)) - addr = lines[i].contents.addr - tokens = [] - for j in xrange(0, lines[i].contents.count): - token_type = core.BNInstructionTextTokenType_names[lines[i].contents.tokens[j].type] - text = lines[i].contents.tokens[j].text - value = lines[i].contents.tokens[j].value - size = lines[i].contents.tokens[j].size - operand = lines[i].contents.tokens[j].operand - tokens.append(InstructionTextToken(token_type, text, value, size, operand)) - contents = DisassemblyTextLine(addr, tokens) - result.append(LinearDisassemblyLine(lines[i].type, func, block, lines[i].lineOffset, contents)) - - func = None - block = None - if pos_obj.function: - func = Function(self, pos_obj.function) - if pos_obj.block: - block = BasicBlock(self, pos_obj.block) - pos.function = func - pos.block = block - pos.address = pos_obj.address - - core.BNFreeLinearDisassemblyLines(lines, count.value) - return result - - def get_previous_linear_disassembly_lines(self, pos, settings): - """ - ``get_previous_linear_disassembly_lines`` retrieves a list of :py:class:`LinearDisassemblyLine` objects for the - previous disassembly lines, and updates the LinearDisassemblyPosition passed in. This function can be called - repeatedly to get more lines of linear disassembly. - - :param LinearDisassemblyPosition pos: Position to start retrieving linear disassembly lines from - :param DisassemblySettings settings: DisassemblySettings display settings for the linear disassembly - :return: a list of :py:class:`LinearDisassemblyLine` objects for the previous lines. - :Example: - - >>> settings = DisassemblySettings() - >>> pos = bv.get_linear_disassembly_position_at(0x1000149a, settings) - >>> bv.get_previous_linear_disassembly_lines(pos, settings) - [<0x10001488: push dword [ebp+0x10 {arg_c}]>, ... , <0x1000149a: >] - >>> bv.get_previous_linear_disassembly_lines(pos, settings) - [<0x10001483: xor eax, eax {0x0}>, ... , <0x10001488: >] - """ - return self._get_linear_disassembly_lines(core.BNGetPreviousLinearDisassemblyLines, pos, settings) - - def get_next_linear_disassembly_lines(self, pos, settings): - """ - ``get_next_linear_disassembly_lines`` retrieves a list of :py:class:`LinearDisassemblyLine` objects for the - next disassembly lines, and updates the LinearDisassemblyPosition passed in. This function can be called - repeatedly to get more lines of linear disassembly. - - :param LinearDisassemblyPosition pos: Position to start retrieving linear disassembly lines from - :param DisassemblySettings settings: DisassemblySettings display settings for the linear disassembly - :return: a list of :py:class:`LinearDisassemblyLine` objects for the next lines. - :Example: - - >>> settings = DisassemblySettings() - >>> pos = bv.get_linear_disassembly_position_at(0x10001483, settings) - >>> bv.get_next_linear_disassembly_lines(pos, settings) - [<0x10001483: xor eax, eax {0x0}>, <0x10001485: inc eax {0x1}>, ... , <0x10001488: >] - >>> bv.get_next_linear_disassembly_lines(pos, settings) - [<0x10001488: push dword [ebp+0x10 {arg_c}]>, ... , <0x1000149a: >] - >>> - """ - return self._get_linear_disassembly_lines(core.BNGetNextLinearDisassemblyLines, pos, settings) - - def get_linear_disassembly(self, settings): - """ - ``get_linear_disassembly`` gets an iterator for all lines in the linear disassembly of the view for the given - disassembly settings. - - .. note:: linear_disassembly doesn't just return disassembly it will return a single line from the linear view,\ - and thus will contain both data views, and disassembly. - - :param DisassemblySettings settings: instance specifying the desired output formatting. - :return: An iterator containing formatted dissassembly lines. - :rtype: LinearDisassemblyIterator - :Example: - - >>> settings = DisassemblySettings() - >>> lines = bv.get_linear_disassembly(settings) - >>> for line in lines: - ... print line - ... break - ... - cf fa ed fe 07 00 00 01 ........ - """ - class LinearDisassemblyIterator(object): - def __init__(self, view, settings): - self.view = view - self.settings = settings - - def __iter__(self): - pos = self.view.get_linear_disassembly_position_at(self.view.start, self.settings) - while True: - lines = self.view.get_next_linear_disassembly_lines(pos, self.settings) - if len(lines) == 0: - break - for line in lines: - yield line - - return iter(LinearDisassemblyIterator(self, settings)) - - def parse_type_string(self, text): - """ - ``parse_type_string`` converts `C-style` string into a :py:Class:`Type`. - - :param str text: `C-style` string of type to create - :return: A tuple of a :py:Class:`Type` and string type name - :rtype: tuple(Type, str) - :Example: - - >>> bv.parse_type_string("int foo") - (, 'foo') - >>> - """ - result = core.BNNameAndType() - errors = ctypes.c_char_p() - if not core.BNParseTypeString(self.handle, text, result, errors): - error_str = errors.value - core.BNFreeString(ctypes.cast(errors, ctypes.POINTER(ctypes.c_byte))) - raise SyntaxError, error_str - type_obj = Type(core.BNNewTypeReference(result.type)) - name = result.name - core.BNFreeNameAndType(result) - return type_obj, name - - def get_type_by_name(self, name): - """ - ``get_type_by_name`` returns the defined type whose name corresponds with the provided ``name`` - - :param str name: Type name to lookup - :return: A :py:Class:`Type` or None if the type does not exist - :rtype: Type or None - :Example: - - >>> type, name = bv.parse_type_string("int foo") - >>> bv.define_type(name, type) - >>> bv.get_type_by_name(name) - - >>> - """ - obj = core.BNGetAnalysisTypeByName(self.handle, name) - if not obj: - return None - return Type(obj) - - def is_type_auto_defined(self, name): - """ - ``is_type_auto_defined`` queries the user type list of name. If name is not in the *user* type list then the name - is considered an *auto* type. - - :param str name: Name of type to query - :return: True if the type is not a *user* type. False if the type is a *user* type. - :Example: - >>> bv.is_type_auto_defined("foo") - True - >>> bv.define_user_type("foo", bv.parse_type_string("struct {int x,y;}")[0]) - >>> bv.is_type_auto_defined("foo") - False - >>> - """ - return core.BNIsAnalysisTypeAutoDefined(self.handle, name) - - def define_type(self, name, type_obj): - """ - ``define_type`` registers a :py:Class:`Type` ``type_obj`` of the given ``name`` in the global list of types for - the current :py:Class:`BinaryView`. - - :param str name: Name of the type to be registered - :param Type type_obj: Type object to be registered - :rtype: None - :Example: - - >>> type, name = bv.parse_type_string("int foo") - >>> bv.define_type(name, type) - >>> bv.get_type_by_name(name) - - """ - core.BNDefineAnalysisType(self.handle, name, type_obj.handle) - - def define_user_type(self, name, type_obj): - """ - ``define_user_type`` registers a :py:Class:`Type` ``type_obj`` of the given ``name`` in the global list of user - types for the current :py:Class:`BinaryView`. - - :param str name: Name of the user type to be registered - :param Type type_obj: Type object to be registered - :rtype: None - :Example: - - >>> type, name = bv.parse_type_string("int foo") - >>> bv.define_user_type(name, type) - >>> bv.get_type_by_name(name) - - """ - core.BNDefineUserAnalysisType(self.handle, name, type_obj.handle) - - def undefine_type(self, name): - """ - ``undefine_type`` removes a :py:Class:`Type` from the global list of types for the current :py:Class:`BinaryView` - - :param str name: Name of type to be undefined - :rtype: None - :Example: - - >>> type, name = bv.parse_type_string("int foo") - >>> bv.define_type(name, type) - >>> bv.get_type_by_name(name) - - >>> bv.undefine_type(name) - >>> bv.get_type_by_name(name) - >>> - """ - core.BNUndefineAnalysisType(self.handle, name) - - def undefine_user_type(self, name): - """ - ``undefine_user_type`` removes a :py:Class:`Type` from the global list of user types for the current - :py:Class:`BinaryView` - - :param str name: Name of user type to be undefined - :rtype: None - :Example: - - >>> type, name = bv.parse_type_string("int foo") - >>> bv.define_type(name, type) - >>> bv.get_type_by_name(name) - - >>> bv.undefine_type(name) - >>> bv.get_type_by_name(name) - >>> - """ - core.BNUndefineUserAnalysisType(self.handle, name) - - def find_next_data(self, start, data, flags = 0): - """ - ``find_next_data`` searchs for the bytes in data starting at the virtual address ``start`` either, case-sensitive, - or case-insensitive. - - :param int start: virtual address to start searching from. - :param str data: bytes to search for - :param FindFlags flags: case-sensitivity flag, one of the following: - - ==================== ====================== - FindFlags Description - ==================== ====================== - NoFindFlags Case-sensitive find - FindCaseInsensitive Case-insensitive find - ==================== ====================== - """ - buf = DataBuffer(str(data)) - result = ctypes.c_ulonglong() - if not core.BNFindNextData(self.handle, start, buf.handle, result, flags): - return None - return result.value - - def reanalyze(self): - """ - ``reanalyze`` causes all functions to be reanalyzed. This function does not wait for the analysis to finish. - - :rtype: None - """ - core.BNReanalyzeAllFunctions(self.handle) - - def show_plain_text_report(self, title, contents): - core.BNShowPlainTextReport(self.handle, title, contents) - - def show_markdown_report(self, title, contents, plaintext = ""): - core.BNShowMarkdownReport(self.handle, title, contents, plaintext) - - def show_html_report(self, title, contents, plaintext = ""): - core.BNShowHTMLReport(self.handle, title, contents, plaintext) - - def get_address_input(self, prompt, title, current_address = None): - if current_address is None: - current_address = self.file.offset - value = ctypes.c_ulonglong() - if not core.BNGetAddressInput(value, prompt, title, self.handle, current_address): - return None - return value.value - - def add_auto_segment(self, start, length, data_offset, data_length, flags): - core.BNAddAutoSegment(self.handle, start, length, data_offset, data_length, flags) - - def remove_auto_segment(self, start, length): - core.BNRemoveAutoSegment(self.handle, start, length) - - def add_user_segment(self, start, length, data_offset, data_length, flags): - core.BNAddUserSegment(self.handle, start, length, data_offset, data_length, flags) - - def remove_user_segment(self, start, length): - core.BNRemoveUserSegment(self.handle, start, length) - - def get_segment_at(self, addr): - segment = core.BNSegment() - if not core.BNGetSegmentAt(self.handle, addr, segment): - return None - result = Segment(segment.start, segment.length, segment.dataOffset, segment.dataLength, - segment.flags) - return result - - def add_auto_section(self, name, start, length, type = "", align = 1, entry_size = 1, linked_section = "", - info_section = "", info_data = 0): - core.BNAddAutoSection(self.handle, name, start, length, type, align, entry_size, linked_section, - info_section, info_data) - - def remove_auto_section(self, name): - core.BNRemoveAutoSection(self.handle, name) - - def add_user_section(self, name, start, length, type = "", align = 1, entry_size = 1, linked_section = "", - info_section = "", info_data = 0): - core.BNAddUserSection(self.handle, name, start, length, type, align, entry_size, linked_section, - info_section, info_data) - - def remove_user_section(self, name): - core.BNRemoveUserSection(self.handle, name) - - def get_sections_at(self, addr): - count = ctypes.c_ulonglong(0) - section_list = core.BNGetSectionsAt(self.handle, addr, count) - result = [] - for i in xrange(0, count.value): - result.append(Section(section_list[i].name, section_list[i].type, section_list[i].start, - section_list[i].length, section_list[i].linkedSection, section_list[i].infoSection, - section_list[i].infoData, section_list[i].align, section_list[i].entrySize)) - core.BNFreeSectionList(section_list, count.value) - return result - - def get_section_by_name(self, name): - section = core.BNSection() - if not core.BNGetSectionByName(self.handle, name, section): - return None - result = Section(section.name, section.type, section.start, section.length, section.linkedSection, - section.infoSection, section.infoData, section.align, section.entrySize) - core.BNFreeSection(section) - return result - - def get_unique_section_names(self, name_list): - incoming_names = (ctypes.c_char_p * len(name_list))() - for i in xrange(0, len(name_list)): - incoming_names[i] = name_list[i] - outgoing_names = core.BNGetUniqueSectionNames(self.handle, incoming_names, len(name_list)) - result = [] - for i in xrange(0, len(name_list)): - result.append(str(outgoing_names[i])) - core.BNFreeStringList(outgoing_names, len(name_list)) - return result - - def __setattr__(self, name, value): - try: - object.__setattr__(self,name,value) - except AttributeError: - raise AttributeError, "attribute '%s' is read only" % name - -class BinaryReader(object): - """ - ``class BinaryReader`` is a convenience class for reading binary data. - - BinaryReader can be instantiated as follows and the rest of the document will start from this context :: - - >>> from binaryninja import * - >>> bv = BinaryViewType['Mach-O'].open("/bin/ls") - >>> br = BinaryReader(bv) - >>> hex(br.read32()) - '0xfeedfacfL' - >>> - - Or using the optional endian parameter :: - - >>> from binaryninja import * - >>> br = BinaryReader(bv, core.BigEndian) - >>> hex(br.read32()) - '0xcffaedfeL' - >>> - """ - def __init__(self, view, endian = None): - self.handle = core.BNCreateBinaryReader(view.handle) - if endian is None: - core.BNSetBinaryReaderEndianness(self.handle, view.endianness) - else: - core.BNSetBinaryReaderEndianness(self.handle, endian) - - def __del__(self): - core.BNFreeBinaryReader(self.handle) - - @property - def endianness(self): - """ - The Endianness to read data. (read/write) - - :getter: returns the endianness of the reader - :setter: sets the endianness of the reader (BigEndian or LittleEndian) - :type: Endianness - """ - return core.BNGetBinaryReaderEndianness(self.handle) - - @endianness.setter - def endianness(self, value): - core.BNSetBinaryReaderEndianness(self.handle, value) - - @property - def offset(self): - """ - The current read offset (read/write). - - :getter: returns the current internal offset - :setter: sets the internal offset - :type: int - """ - return core.BNGetReaderPosition(self.handle) - - @offset.setter - def offset(self, value): - core.BNSeekBinaryReader(self.handle, value) - - @property - def eof(self): - """ - Is end of file (read-only) - - :getter: returns boolean, true if end of file, false otherwise - :type: bool - """ - return core.BNIsEndOfFile(self.handle) - - def read(self, length): - """ - ``read`` returns ``length`` bytes read from the current offset, adding ``length`` to offset. - - :param int length: number of bytes to read. - :return: ``length`` bytes from current offset - :rtype: str, or None on failure - :Example: - - >>> br.read(8) - '\\xcf\\xfa\\xed\\xfe\\x07\\x00\\x00\\x01' - >>> - """ - dest = ctypes.create_string_buffer(length) - if not core.BNReadData(self.handle, dest, length): - return None - return dest.raw - - def read8(self): - """ - ``read8`` returns a one byte integer from offet incrementing the offset. - - :return: byte at offset. - :rtype: int, or None on failure - :Example: - - >>> br.seek(0x100000000) - >>> br.read8() - 207 - >>> - """ - result = ctypes.c_ubyte() - if not core.BNRead8(self.handle, result): - return None - return result.value - - def read16(self): - """ - ``read16`` returns a two byte integer from offet incrementing the offset by two, using specified endianness. - - :return: a two byte integer at offset. - :rtype: int, or None on failure - :Example: - - >>> br.seek(0x100000000) - >>> hex(br.read16()) - '0xfacf' - >>> - """ - result = ctypes.c_ushort() - if not core.BNRead16(self.handle, result): - return None - return result.value - - def read32(self): - """ - ``read32`` returns a four byte integer from offet incrementing the offset by four, using specified endianness. - - :return: a four byte integer at offset. - :rtype: int, or None on failure - :Example: - - >>> br.seek(0x100000000) - >>> hex(br.read32()) - '0xfeedfacfL' - >>> - """ - result = ctypes.c_uint() - if not core.BNRead32(self.handle, result): - return None - return result.value - - def read64(self): - """ - ``read64`` returns an eight byte integer from offet incrementing the offset by eight, using specified endianness. - - :return: an eight byte integer at offset. - :rtype: int, or None on failure - :Example: - - >>> br.seek(0x100000000) - >>> hex(br.read64()) - '0x1000007feedfacfL' - >>> - """ - result = ctypes.c_ulonglong() - if not core.BNRead64(self.handle, result): - return None - return result.value - - def read16le(self): - """ - ``read16le`` returns a two byte little endian integer from offet incrementing the offset by two. - - :return: a two byte integer at offset. - :rtype: int, or None on failure - :Exmaple: - - >>> br.seek(0x100000000) - >>> hex(br.read16le()) - '0xfacf' - >>> - """ - result = self.read(2) - if (result is None) or (len(result) != 2): - return None - return struct.unpack(">> br.seek(0x100000000) - >>> hex(br.read32le()) - '0xfeedfacf' - >>> - """ - result = self.read(4) - if (result is None) or (len(result) != 4): - return None - return struct.unpack(">> br.seek(0x100000000) - >>> hex(br.read64le()) - '0x1000007feedfacf' - >>> - """ - result = self.read(8) - if (result is None) or (len(result) != 8): - return None - return struct.unpack(">> br.seek(0x100000000) - >>> hex(br.read16be()) - '0xcffa' - >>> - """ - result = self.read(2) - if (result is None) or (len(result) != 2): - return None - return struct.unpack(">H", result)[0] - - def read32be(self): - """ - ``read32be`` returns a four byte big endian integer from offet incrementing the offset by four. - - :return: a four byte integer at offset. - :rtype: int, or None on failure - :Example: - - >>> br.seek(0x100000000) - >>> hex(br.read32be()) - '0xcffaedfe' - >>> - """ - result = self.read(4) - if (result is None) or (len(result) != 4): - return None - return struct.unpack(">I", result)[0] - - def read64be(self): - """ - ``read64be`` returns an eight byte big endian integer from offet incrementing the offset by eight. - - :return: a eight byte integer at offset. - :rtype: int, or None on failure - :Example: - - >>> br.seek(0x100000000) - >>> hex(br.read64be()) - '0xcffaedfe07000001L' - """ - result = self.read(8) - if (result is None) or (len(result) != 8): - return None - return struct.unpack(">Q", result)[0] - - def seek(self, offset): - """ - ``seek`` update internal offset to ``offset``. - - :param int offset: offset to set the internal offset to - :rtype: None - :Example: - - >>> hex(br.offset) - '0x100000008L' - >>> br.seek(0x100000000) - >>> hex(br.offset) - '0x100000000L' - >>> - """ - core.BNSeekBinaryReader(self.handle, offset) - - def seek_relative(self, offset): - """ - ``seek_relative`` updates the internal offset by ``offset``. - - :param int offset: offset to add to the internal offset - :rtype: None - :Example: - - >>> hex(br.offset) - '0x100000008L' - >>> br.seek_relative(-8) - >>> hex(br.offset) - '0x100000000L' - >>> - """ - core.BNSeekBinaryReaderRelative(self.handle, offset) - - def __setattr__(self, name, value): - try: - object.__setattr__(self,name,value) - except AttributeError: - raise AttributeError, "attribute '%s' is read only" % name - -class BinaryWriter(object): - """ - ``class BinaryWriter`` is a convenience class for writing binary data. - - BinaryWriter can be instantiated as follows and the rest of the document will start from this context :: - - >>> from binaryninja import * - >>> bv = BinaryViewType['Mach-O'].open("/bin/ls") - >>> br = BinaryReader(bv) - >>> bw = BinaryWriter(bv) - >>> - - Or using the optional endian parameter :: - - >>> from binaryninja import * - >>> br = BinaryReader(bv, core.BigEndian) - >>> bw = BinaryWriter(bv, core.BigEndian) - >>> - """ - def __init__(self, view, endian = None): - self.handle = core.BNCreateBinaryWriter(view.handle) - if endian is None: - core.BNSetBinaryWriterEndianness(self.handle, view.endianness) - else: - core.BNSetBinaryWriterEndianness(self.handle, endian) - - def __del__(self): - core.BNFreeBinaryWriter(self.handle) - - @property - def endianness(self): - """ - The Endianness to written data. (read/write) - - :getter: returns the endianness of the reader - :setter: sets the endianness of the reader (BigEndian or LittleEndian) - :type: Endianness - """ - return core.BNGetBinaryWriterEndianness(self.handle) - - @endianness.setter - def endianness(self, value): - core.BNSetBinaryWriterEndianness(self.handle, value) - - @property - def offset(self): - """ - The current write offset (read/write). - - :getter: returns the current internal offset - :setter: sets the internal offset - :type: int - """ - return core.BNGetWriterPosition(self.handle) - - @offset.setter - def offset(self, value): - core.BNSeekBinaryWriter(self.handle, value) - - def write(self, value): - """ - ``write`` writes ``len(value)`` bytes to the internal offset, without regard to endianness. - - :param str value: bytes to be written at current offset - :return: boolean True on success, False on failure. - :rtype: bool - :Example: - - >>> bw.write("AAAA") - True - >>> br.read(4) - 'AAAA' - >>> - """ - value = str(value) - buf = ctypes.create_string_buffer(len(value)) - ctypes.memmove(buf, value, len(value)) - return core.BNWriteData(self.handle, buf, len(value)) - - def write8(self, value): - """ - ``write8`` lowest order byte from the integer ``value`` to the current offset. - - :param str value: bytes to be written at current offset - :return: boolean - :rtype: int - :Example: - - >>> bw.write8(0x42) - True - >>> br.read(1) - 'B' - >>> - """ - return core.BNWrite8(self.handle, value) - - def write16(self, value): - """ - ```` writes the lowest order two bytes from the integer ``value`` to the current offset, using internal endianness. - - :param int value: integer value to write. - :return: boolean True on success, False on failure. - :rtype: bool - """ - return core.BNWrite16(self.handle, value) - - def write32(self, value): - """ - ```` writes the lowest order four bytes from the integer ``value`` to the current offset, using internal endianness. - - :param int value: integer value to write. - :return: boolean True on success, False on failure. - :rtype: bool - """ - return core.BNWrite32(self.handle, value) - - def write64(self, value): - """ - ```` writes the lowest order eight bytes from the integer ``value`` to the current offset, using internal endianness. - - :param int value: integer value to write. - :return: boolean True on success, False on failure. - :rtype: bool - """ - return core.BNWrite64(self.handle, value) - - def write16le(self, value): - """ - ``write16le`` writes the lowest order two bytes from the little endian integer ``value`` to the current offset. - - :param int value: integer value to write. - :return: boolean True on success, False on failure. - :rtype: bool - """ - value = struct.pack("H", value) - return self.write(value) - - def write32be(self, value): - """ - ``write32be`` writes the lowest order four bytes from the big endian integer ``value`` to the current offset. - - :param int value: integer value to write. - :return: boolean True on success, False on failure. - :rtype: bool - """ - value = struct.pack(">I", value) - return self.write(value) - - def write64be(self, value): - """ - ``write64be`` writes the lowest order eight bytes from the big endian integer ``value`` to the current offset. - - :param int value: integer value to write. - :return: boolean True on success, False on failure. - :rtype: bool - """ - value = struct.pack(">Q", value) - return self.write(value) - - def seek(self, offset): - """ - ``seek`` update internal offset to ``offset``. - - :param int offset: offset to set the internal offset to - :rtype: None - :Example: - - >>> hex(bw.offset) - '0x100000008L' - >>> bw.seek(0x100000000) - >>> hex(br.offset) - '0x100000000L' - >>> - """ - core.BNSeekBinaryWriter(self.handle, offset) - - def seek_relative(self, offset): - """ - ``seek_relative`` updates the internal offset by ``offset``. - - :param int offset: offset to add to the internal offset - :rtype: None - :Example: - - >>> hex(bw.offset) - '0x100000008L' - >>> bw.seek_relative(-8) - >>> hex(br.offset) - '0x100000000L' - >>> - """ - core.BNSeekBinaryWriterRelative(self.handle, offset) - -class Symbol(object): - """ - Symbols are defined as one of the following types: - - =========================== ============================================================== - SymbolType Description - =========================== ============================================================== - FunctionSymbol Symbol for Function that exists in the current binary - ImportAddressSymbol Symbol defined in the Import Address Table - ImportedFunctionSymbol Symbol for Function that is not defined in the current binary - DataSymbol Symbol for Data in the current binary - ImportedDataSymbol Symbol for Data that is not defined in the current binary - =========================== ============================================================== - """ - def __init__(self, sym_type, addr, short_name, full_name = None, raw_name = None, handle = None): - if handle is not None: - self.handle = core.handle_of_type(handle, core.BNSymbol) - else: - if isinstance(sym_type, str): - sym_type = core.BNSymbolType_by_name[sym_type] - if full_name is None: - full_name = short_name - if raw_name is None: - raw_name = full_name - self.handle = core.BNCreateSymbol(sym_type, short_name, full_name, raw_name, addr) - - def __del__(self): - core.BNFreeSymbol(self.handle) - - @property - def type(self): - """Symbol type (read-only)""" - return core.BNSymbolType_names[core.BNGetSymbolType(self.handle)] - - @property - def name(self): - """Symbol name (read-only)""" - return core.BNGetSymbolRawName(self.handle) - - @property - def short_name(self): - """Symbol short name (read-only)""" - return core.BNGetSymbolShortName(self.handle) - - @property - def full_name(self): - """Symbol full name (read-only)""" - return core.BNGetSymbolFullName(self.handle) - - @property - def raw_name(self): - """Symbol raw name (read-only)""" - return core.BNGetSymbolRawName(self.handle) - - @property - def address(self): - """Symbol address (read-only)""" - return core.BNGetSymbolAddress(self.handle) - - @property - def auto(self): - return core.BNIsSymbolAutoDefined(self.handle) - - @auto.setter - def auto(self, value): - core.BNSetSymbolAutoDefined(self.handle, value) - - def __repr__(self): - return "<%s: \"%s\" @ %#x>" % (self.type, self.full_name, self.address) - - def __setattr__(self, name, value): - try: - object.__setattr__(self,name,value) - except AttributeError: - raise AttributeError, "attribute '%s' is read only" % name - -class Type(object): - def __init__(self, handle): - self.handle = handle - - def __del__(self): - core.BNFreeType(self.handle) - - @property - def type_class(self): - """Type class (read-only)""" - return core.BNTypeClass_names[core.BNGetTypeClass(self.handle)] - - @property - def width(self): - """Type width (read-only)""" - return core.BNGetTypeWidth(self.handle) - - @property - def alignment(self): - """Type alignment (read-only)""" - return core.BNGetTypeAlignment(self.handle) - - @property - def signed(self): - """Wether type is signed (read-only)""" - return core.BNIsTypeSigned(self.handle) - - @property - def const(self): - """Whether type is const (read-only)""" - return core.BNIsTypeConst(self.handle) - - @property - def modified(self): - """Whether type is modified (read-only)""" - return core.BNIsTypeFloatingPoint(self.handle) - - @property - def target(self): - """Target (read-only)""" - result = core.BNGetChildType(self.handle) - if result is None: - return None - return Type(result) - - @property - def element_type(self): - """Target (read-only)""" - result = core.BNGetChildType(self.handle) - if result is None: - return None - return Type(result) - - @property - def return_value(self): - """Return value (read-only)""" - result = core.BNGetChildType(self.handle) - if result is None: - return None - return Type(result) - - @property - def calling_convention(self): - """Calling convention (read-only)""" - result = core.BNGetTypeCallingConvention(self.handle) - if result is None: - return None - return CallingConvention(None, result) - - @property - def parameters(self): - """Type parameters list (read-only)""" - count = ctypes.c_ulonglong() - params = core.BNGetTypeParameters(self.handle, count) - result = [] - for i in xrange(0, count.value): - result.append((Type(core.BNNewTypeReference(params[i].type)), params[i].name)) - core.BNFreeTypeParameterList(params, count.value) - return result - - @property - def has_variable_arguments(self): - """Whether type has variable arguments (read-only)""" - return core.BNTypeHasVariableArguments(self.handle) - - @property - def can_return(self): - """Whether type can return (read-only)""" - return core.BNFunctionTypeCanReturn(self.handle) - - @property - def structure(self): - """Structure of the type (read-only)""" - result = core.BNGetTypeStructure(self.handle) - if result is None: - return None - return Structure(result) - - @property - def enumeration(self): - """Type enumeration (read-only)""" - result = core.BNGetTypeEnumeration(self.handle) - if result is None: - return None - return Enumeration(result) - - @property - def count(self): - """Type count (read-only)""" - return core.BNGetTypeElementCount(self.handle) - - def __str__(self): - return core.BNGetTypeString(self.handle) - - def __repr__(self): - return "" % str(self) - - def get_string_before_name(self): - return core.BNGetTypeStringBeforeName(self.handle) - - def get_string_after_name(self): - return core.BNGetTypeStringAfterName(self.handle) - - @classmethod - def void(cls): - return Type(core.BNCreateVoidType()) - - @classmethod - def bool(self): - return Type(core.BNCreateBoolType()) - - @classmethod - def int(self, width, sign = True): - return Type(core.BNCreateIntegerType(width, sign)) - - @classmethod - def float(self, width): - return Type(core.BNCreateFloatType(width)) - - @classmethod - def structure_type(self, structure_type): - return Type(core.BNCreateStructureType(structure_type.handle)) - - @classmethod - def unknown_type(self, unknown_type): - return Type(core.BNCreateUnknownType(unknown_type.handle)) - - @classmethod - def unknown_type(self, s): - return Type(core.BNCreateUnknownType(s.handle)) - - @classmethod - def enumeration_type(self, arch, e, width = None): - if width is None: - width = arch.default_int_size - return Type(core.BNCreateEnumerationType(e.handle, width)) - - @classmethod - def pointer(self, arch, t, const = False): - return Type(core.BNCreatePointerType(arch.handle, t.handle, const)) - - @classmethod - def array(self, t, count): - return Type(core.BNCreateArrayType(t.handle, count)) - - @classmethod - def function(self, ret, params, calling_convention = None, variable_arguments = False): - param_buf = (core.BNNameAndType * len(params))() - for i in xrange(0, len(params)): - if isinstance(params[i], Type): - param_buf[i].name = "" - param_buf[i].type = params[i].handle - else: - param_buf[i].name = params[i][1] - param_buf[i].type = params[i][0] - if calling_convention is not None: - calling_convention = calling_convention.handle - return Type(core.BNCreateFunctionType(ret.handle, calling_convention, param_buf, len(params), - variable_arguments)) - - def __setattr__(self, name, value): - try: - object.__setattr__(self,name,value) - except AttributeError: - raise AttributeError, "attribute '%s' is read only" % name - - -class UnknownType(object): - def __init__(self, handle = None): - if handle is None: - self.handle = core.BNCreateUnknownType() - else: - self.handle = handle - - def __del__(self): - core.BNFreeUnknownType(self.handle) - - @property - def name(self): - count = ctypes.c_ulonglong() - nameList = core.BNGetUnknownTypeName(self.handle, count) - result = [] - for i in xrange(count.value): - result.append(nameList[i]) - return get_qualified_name(result) - - @name.setter - def name(self, value): - core.BNSetUnknownTypeName(self.handle, value) - - -class StructureMember(object): - def __init__(self, t, name, offset): - self.type = t - self.name = name - self.offset = offset - - def __repr__(self): - if len(name) == 0: - return "" % (str(self.type), self.offset) - return "<%s %s%s, offset %#x>" % (self.type.get_string_before_name(), self.name, - self.type.get_string_after_name(), self.offset) - -class Structure(object): - def __init__(self, handle = None): - if handle is None: - self.handle = core.BNCreateStructure() - else: - self.handle = handle - - def __del__(self): - core.BNFreeStructure(self.handle) - - @property - def name(self): - count = ctypes.c_ulonglong() - nameList = core.BNGetStructureName(self.handle, count) - result = [] - for i in xrange(count.value): - result.append(nameList[i]) - return get_qualified_name(result) - - @name.setter - def name(self, value): - core.BNSetStructureName(self.handle, value) - - @property - def members(self): - """Structure member list (read-only)""" - count = ctypes.c_ulonglong() - members = core.BNGetStructureMembers(self.handle, count) - result = [] - for i in xrange(0, count.value): - result.append(StructureMember(Type(core.BNNewTypeReference(members[i].type)), - members[i].name, members[i].offset)) - core.BNFreeStructureMemberList(members, count.value) - return result - - @property - def width(self): - """Structure width (read-only)""" - return core.BNGetStructureWidth(self.handle) - - @property - def alignment(self): - """Structure alignment (read-only)""" - return core.BNGetStructureAlignment(self.handle) - - @property - def packed(self): - return core.BNIsStructurePacked(self.handle) - - @packed.setter - def packed(self, value): - core.BNSetStructurePacked(self.handle, value) - - @property - def union(self): - return core.BNIsStructureUnion(self.handle) - - @union.setter - def union(self, value): - core.BNSetStructureUnion(self.handle, value) - - def __setattr__(self, name, value): - try: - object.__setattr__(self,name,value) - except AttributeError: - raise AttributeError, "attribute '%s' is read only" % name - - def __repr__(self): - if len(self.name) > 0: - return "" % self.name - return "" % self.width - - def append(self, t, name = ""): - core.BNAddStructureMember(self.handle, t.handle, name) - - def insert(self, offset, t, name = ""): - core.BNAddStructureMemberAtOffset(self.handle, t.handle, name, offset) - - def remove(self, i): - core.BNRemoveStructureMember(self.handle, i) - -class EnumerationMember(object): - def __init__(self, name, value, default): - self.name = name - self.value = value - self.default = default - - def __repr__(self): - return "<%s = %#x>" % (self.name, self.value) - -class Enumeration(object): - def __init__(self, handle = None): - if handle is None: - self.handle = core.BNCreateEnumeration() - else: - self.handle = handle - - def __del__(self): - core.BNFreeEnumeration(self.handle) - - @property - def name(self): - return core.BNGetEnumerationName(self.handle) - - @name.setter - def name(self, value): - core.BNSetEnumerationName(self.handle, value) - - @property - def members(self): - """Enumeration member list (read-only)""" - count = ctypes.c_ulonglong() - members = core.BNGetEnumerationMembers(self.handle, count) - result = [] - for i in xrange(0, count.value): - result.append(EnumerationMember(members[i].name, members[i].value, members[i].isDefault)) - core.BNFreeEnumerationMemberList(members, count.value) - return result - - def __setattr__(self, name, value): - try: - object.__setattr__(self,name,value) - except AttributeError: - raise AttributeError, "attribute '%s' is read only" % name - - def __repr__(self): - if len(self.name) > 0: - return "" % self.name - return "" % repr(self.members) - - def append(self, name, value = None): - if value is None: - core.BNAddEnumerationMember(self.handle, name) - else: - core.BNAddEnumerationMemberWithValue(self.handle, name, value) - -class LookupTableEntry(object): - def __init__(self, from_values, to_value): - self.from_values = from_values - self.to_value = to_value - - def __repr__(self): - return "[%s] -> %#x" % (', '.join(["%#x" % i for i in self.from_values]), self.to_value) - -class RegisterValue(object): - def __init__(self, arch, value): - self.type = value.state - if value.state == core.EntryValue: - self.reg = arch.get_reg_name(value.reg) - elif value.state == core.OffsetFromEntryValue: - self.reg = arch.get_reg_name(value.reg) - self.offset = value.value - elif value.state == core.ConstantValue: - self.value = value.value - elif value.state == core.StackFrameOffset: - self.offset = value.value - elif value.state == core.SignedRangeValue: - self.offset = value.value - self.start = value.rangeStart - self.end = value.rangeEnd - self.step = value.rangeStep - if self.start & (1 << 63): - self.start |= ~((1 << 63) - 1) - if self.end & (1 << 63): - self.end |= ~((1 << 63) - 1) - elif value.state == core.UnsignedRangeValue: - self.offset = value.value - self.start = value.rangeStart - self.end = value.rangeEnd - self.step = value.rangeStep - elif value.state == core.LookupTableValue: - self.table = [] - self.mapping = {} - for i in xrange(0, value.rangeEnd): - from_list = [] - for j in xrange(0, value.table[i].fromCount): - from_list.append(value.table[i].fromValues[j]) - self.mapping[value.table[i].fromValues[j]] = value.table[i].toValue - self.table.append(LookupTableEntry(from_list, value.table[i].toValue)) - elif value.state == core.OffsetFromUndeterminedValue: - self.offset = value.value - - def __repr__(self): - if self.type == core.EntryValue: - return "" % self.reg - if self.type == core.OffsetFromEntryValue: - return "" % (self.reg, self.offset) - if self.type == core.ConstantValue: - return "" % self.value - if self.type == core.StackFrameOffset: - return "" % self.offset - if (self.type == core.SignedRangeValue) or (self.type == core.UnsignedRangeValue): - if self.step == 1: - return "" % (self.start, self.end) - return "" % (self.start, self.end, self.step) - if self.type == core.LookupTableValue: - return "" % ', '.join([repr(i) for i in self.table]) - if self.type == core.OffsetFromUndeterminedValue: - return "" % self.offset - return "" - -class StackVariable(object): - def __init__(self, ofs, name, t): - self.offset = ofs - self.name = name - self.type = t - - def __repr__(self): - return "" % (self.offset, self.type, self.name) - - def __str__(self): - return self.name - -class StackVariableReference: - def __init__(self, src_operand, t, name, start_ofs, ref_ofs): - self.source_operand = src_operand - self.type = t - self.name = name - self.starting_offset = start_ofs - self.referenced_offset = ref_ofs - if self.source_operand == 0xffffffff: - self.source_operand = None - - def __repr__(self): - if self.source_operand is None: - if self.referenced_offset != self.starting_offset: - return "" % (self.name, self.referenced_offset - self.starting_offset) - return "" % self.name - if self.referenced_offset != self.starting_offset: - return "" % (self.source_operand, self.name, self.referenced_offset) - return "" % (self.source_operand, self.name) - -class ConstantReference: - def __init__(self, val, size): - self.value = val - self.size = size - - def __repr__(self): - if self.size == 0: - return "" % self.value - return "" % (self.value, self.size) - -class IndirectBranchInfo: - def __init__(self, source_arch, source_addr, dest_arch, dest_addr, auto_defined): - self.source_arch = source_arch - self.source_addr = source_addr - self.dest_arch = dest_arch - self.dest_addr = dest_addr - self.auto_defined = auto_defined - - def __repr__(self): - return " %s:%#x>" % (self.source_arch.name, self.source_addr, self.dest_arch.name, self.dest_addr) - -class HighlightColor(object): - def __init__(self, color = None, mix_color = None, mix = None, red = None, green = None, blue = None, alpha = 255): - if (red is not None) and (green is not None) and (blue is not None): - self.style = core.CustomHighlightColor - self.red = red - self.green = green - self.blue = blue - elif (mix_color is not None) and (mix is not None): - self.style = core.MixedHighlightColor - if color is None: - self.color = core.NoHighlightColor - else: - self.color = color - self.mix_color = mix_color - self.mix = mix - else: - self.style = core.StandardHighlightColor - if color is None: - self.color = core.NoHighlightColor - else: - self.color = color - self.alpha = alpha - - def _standard_color_to_str(self, color): - if color == core.NoHighlightColor: - return "none" - if color == core.BlueHighlightColor: - return "blue" - if color == core.GreenHighlightColor: - return "green" - if color == core.CyanHighlightColor: - return "cyan" - if color == core.RedHighlightColor: - return "red" - if color == core.MagentaHighlightColor: - return "magenta" - if color == core.YellowHighlightColor: - return "yellow" - if color == core.OrangeHighlightColor: - return "orange" - if color == core.WhiteHighlightColor: - return "white" - if color == core.BlackHighlightColor: - return "black" - return "%d" % color - - def __repr__(self): - if self.style == core.StandardHighlightColor: - if self.alpha == 255: - return "" % self._standard_color_to_str(self.color) - return "" % (self._standard_color_to_str(self.color), self.alpha) - if self.style == core.MixedHighlightColor: - if self.alpha == 255: - return "" % (self._standard_color_to_str(self.color), - self._standard_color_to_str(self.mix_color), self.mix) - return "" % (self._standard_color_to_str(self.color), - self._standard_color_to_str(self.mix_color), self.mix, self.alpha) - if self.style == core.CustomHighlightColor: - if self.alpha == 255: - return "" % (self.red, self.green, self.blue) - return "" % (self.red, self.green, self.blue, self.alpha) - return "" - - def _get_core_struct(self): - result = core.BNHighlightColor() - result.style = self.style - result.color = core.NoHighlightColor - result.mix_color = core.NoHighlightColor - result.mix = 0 - result.r = 0 - result.g = 0 - result.b = 0 - result.alpha = self.alpha - - if self.style == core.StandardHighlightColor: - result.color = self.color - elif self.style == core.MixedHighlightColor: - result.color = self.color - result.mixColor = self.mix_color - result.mix = self.mix - elif self.style == core.CustomHighlightColor: - result.r = self.red - result.g = self.green - result.b = self.blue - - return result - -class _FunctionAssociatedDataStore(_AssociatedDataStore): - _defaults = {} - -class Function(object): - _associated_data = {} - - def __init__(self, view, handle): - self._view = view - self.handle = core.handle_of_type(handle, core.BNFunction) - self._advanced_analysis_requests = 0 - - def __del__(self): - if self._advanced_analysis_requests > 0: - core.BNReleaseAdvancedFunctionAnalysisDataMultiple(self.handle, self._advanced_analysis_requests) - core.BNFreeFunction(self.handle) - - @classmethod - def _unregister(cls, func): - handle = ctypes.cast(func, ctypes.c_void_p) - if handle.value in cls._associated_data: - del cls._associated_data[handle.value] - - @classmethod - def set_default_session_data(cls, name, value): - _FunctionAssociatedDataStore.set_default(name, value) - - @property - def name(self): - """Symbol name for the function""" - return self.symbol.name - - @name.setter - def name(self,value): - if value is None: - if self.symbol is not None: - self.view.undefine_user_symbol(self.symbol) - else: - symbol = Symbol(core.FunctionSymbol,self.start,value) - self.view.define_user_symbol(symbol) - - @property - def view(self): - """Function view (read-only)""" - return self._view - - @property - def arch(self): - """Function architecture (read-only)""" - arch = core.BNGetFunctionArchitecture(self.handle) - if arch is None: - return None - return Architecture(arch) - - @property - def start(self): - """Function start (read-only)""" - return core.BNGetFunctionStart(self.handle) - - @property - def symbol(self): - """Function symbol(read-only)""" - sym = core.BNGetFunctionSymbol(self.handle) - if sym is None: - return None - return Symbol(None, None, None, handle = sym) - - @property - def auto(self): - """Whether function was automatically discovered (read-only)""" - return core.BNWasFunctionAutomaticallyDiscovered(self.handle) - - @property - def can_return(self): - """Whether function can return (read-only)""" - return core.BNCanFunctionReturn(self.handle) - - @property - def explicitly_defined_type(self): - """Whether function has explicitly defined types (read-only)""" - return core.BNHasExplicitlyDefinedType(self.handle) - - @property - def needs_update(self): - """Whether the function has analysis that needs to be updated (read-only)""" - return core.BNIsFunctionUpdateNeeded(self.handle) - - @property - def basic_blocks(self): - """List of basic blocks (read-only)""" - count = ctypes.c_ulonglong() - blocks = core.BNGetFunctionBasicBlockList(self.handle, count) - result = [] - for i in xrange(0, count.value): - result.append(BasicBlock(self._view, core.BNNewBasicBlockReference(blocks[i]))) - core.BNFreeBasicBlockList(blocks, count.value) - return result - - @property - def comments(self): - """Dict of comments (read-only)""" - count = ctypes.c_ulonglong() - addrs = core.BNGetCommentedAddresses(self.handle, count) - result = {} - for i in xrange(0, count.value): - result[addrs[i]] = self.get_comment_at(addrs[i]) - core.BNFreeAddressList(addrs) - return result - - @property - def low_level_il(self): - """Function low level IL (read-only)""" - return LowLevelILFunction(self.arch, core.BNGetFunctionLowLevelIL(self.handle), self) - - @property - def lifted_il(self): - """Function lifted IL (read-only)""" - return LowLevelILFunction(self.arch, core.BNGetFunctionLiftedIL(self.handle), self) - - @property - def function_type(self): - """Function type""" - return Type(core.BNGetFunctionType(self.handle)) - - @function_type.setter - def function_type(self, value): - self.set_user_type(value) - - @property - def stack_layout(self): - """List of function stack (read-only)""" - count = ctypes.c_ulonglong() - v = core.BNGetStackLayout(self.handle, count) - result = [] - for i in xrange(0, count.value): - result.append(StackVariable(v[i].offset, v[i].name, Type(handle = core.BNNewTypeReference(v[i].type)))) - result.sort(key = lambda x: x.offset) - core.BNFreeStackLayout(v, count.value) - return result - - @property - def indirect_branches(self): - """List of indirect branches (read-only)""" - count = ctypes.c_ulonglong() - branches = core.BNGetIndirectBranches(self.handle, count) - result = [] - for i in xrange(0, count.value): - result.append(IndirectBranchInfo(Architecture(branches[i].sourceArch), branches[i].sourceAddr, Architecture(branches[i].destArch), branches[i].destAddr, branches[i].autoDefined)) - core.BNFreeIndirectBranchList(branches) - return result - - @property - def session_data(self): - """Dictionary object where plugins can store arbitrary data associated with the function""" - handle = ctypes.cast(self.handle, ctypes.c_void_p) - if handle.value not in Function._associated_data: - obj = _FunctionAssociatedDataStore() - Function._associated_data[handle.value] = obj - return obj - else: - return Function._associated_data[handle.value] - - def __iter__(self): - count = ctypes.c_ulonglong() - blocks = core.BNGetFunctionBasicBlockList(self.handle, count) - try: - for i in xrange(0, count.value): - yield BasicBlock(self._view, core.BNNewBasicBlockReference(blocks[i])) - finally: - core.BNFreeBasicBlockList(blocks, count.value) - - def __setattr__(self, name, value): - try: - object.__setattr__(self,name,value) - except AttributeError: - raise AttributeError, "attribute '%s' is read only" % name - - def __repr__(self): - arch = self.arch - if arch: - return "" % (arch.name, self.start) - else: - return "" % self.start - - def mark_recent_use(self): - core.BNMarkFunctionAsRecentlyUsed(self.handle) - - def get_comment_at(self, addr): - return core.BNGetCommentForAddress(self.handle, addr) - - def set_comment(self, addr, comment): - core.BNSetCommentForAddress(self.handle, addr, comment) - - def get_low_level_il_at(self, arch, addr): - return core.BNGetLowLevelILForInstruction(self.handle, arch.handle, addr) - - def get_low_level_il_exits_at(self, arch, addr): - count = ctypes.c_ulonglong() - exits = core.BNGetLowLevelILExitsForInstruction(self.handle, arch.handle, addr, count) - result = [] - for i in xrange(0, count.value): - result.append(exits[i]) - core.BNFreeLowLevelILInstructionList(exits) - return result - - def get_reg_value_at(self, arch, addr, reg): - if isinstance(reg, str): - reg = arch.regs[reg].index - value = core.BNGetRegisterValueAtInstruction(self.handle, arch.handle, addr, reg) - result = RegisterValue(arch, value) - core.BNFreeRegisterValue(value) - return result - - def get_reg_value_after(self, arch, addr, reg): - if isinstance(reg, str): - reg = arch.regs[reg].index - value = core.BNGetRegisterValueAfterInstruction(self.handle, arch.handle, addr, reg) - result = RegisterValue(arch, value) - core.BNFreeRegisterValue(value) - return result - - def get_reg_value_at_low_level_il_instruction(self, i, reg): - if isinstance(reg, str): - reg = self.arch.regs[reg].index - value = core.BNGetRegisterValueAtLowLevelILInstruction(self.handle, i, reg) - result = RegisterValue(self.arch, value) - core.BNFreeRegisterValue(value) - return result - - def get_reg_value_after_low_level_il_instruction(self, i, reg): - if isinstance(reg, str): - reg = self.arch.regs[reg].index - value = core.BNGetRegisterValueAfterLowLevelILInstruction(self.handle, i, reg) - result = RegisterValue(self.arch, value) - core.BNFreeRegisterValue(value) - return result - - def get_stack_contents_at(self, arch, addr, offset, size): - value = core.BNGetStackContentsAtInstruction(self.handle, arch.handle, addr, offset, size) - result = RegisterValue(arch, value) - core.BNFreeRegisterValue(value) - return result - - def get_stack_contents_after(self, arch, addr, offset, size): - value = core.BNGetStackContentsAfterInstruction(self.handle, arch.handle, addr, offset, size) - result = RegisterValue(arch, value) - core.BNFreeRegisterValue(value) - return result - - def get_stack_contents_at_low_level_il_instruction(self, i, offset, size): - value = core.BNGetStackContentsAtLowLevelILInstruction(self.handle, i, offset, size) - result = RegisterValue(self.arch, value) - core.BNFreeRegisterValue(value) - return result - - def get_stack_contents_after_low_level_il_instruction(self, i, offset, size): - value = core.BNGetStackContentsAfterInstruction(self.handle, i, offset, size) - result = RegisterValue(self.arch, value) - core.BNFreeRegisterValue(value) - return result - - def get_parameter_at(self, arch, addr, func_type, i): - if func_type is not None: - func_type = func_type.handle - value = core.BNGetParameterValueAtInstruction(self.handle, arch.handle, addr, func_type, i) - result = RegisterValue(arch, value) - core.BNFreeRegisterValue(value) - return result - - def get_parameter_at_low_level_il_instruction(self, instr, func_type, i): - if func_type is not None: - func_type = func_type.handle - value = core.BNGetParameterValueAtLowLevelILInstruction(self.handle, instr, func_type, i) - result = RegisterValue(self.arch, value) - core.BNFreeRegisterValue(value) - return result - - def get_regs_read_by(self, arch, addr): - count = ctypes.c_ulonglong() - regs = core.BNGetRegistersReadByInstruction(self.handle, arch.handle, addr, count) - result = [] - for i in xrange(0, count.value): - result.append(arch.get_reg_name(regs[i])) - core.BNFreeRegisterList(regs) - return result - - def get_regs_written_by(self, arch, addr): - count = ctypes.c_ulonglong() - regs = core.BNGetRegistersWrittenByInstruction(self.handle, arch.handle, addr, count) - result = [] - for i in xrange(0, count.value): - result.append(arch.get_reg_name(regs[i])) - core.BNFreeRegisterList(regs) - return result - - def get_stack_vars_referenced_by(self, arch, addr): - count = ctypes.c_ulonglong() - refs = core.BNGetStackVariablesReferencedByInstruction(self.handle, arch.handle, addr, count) - result = [] - for i in xrange(0, count.value): - result.append(StackVariableReference(refs[i].sourceOperand, Type(core.BNNewTypeReference(refs[i].type)), - refs[i].name, refs[i].startingOffset, refs[i].referencedOffset)) - core.BNFreeStackVariableReferenceList(refs, count.value) - return result - - def get_constants_referenced_by(self, arch, addr): - count = ctypes.c_ulonglong() - refs = core.BNGetConstantsReferencedByInstruction(self.handle, arch.handle, addr, count) - result = [] - for i in xrange(0, count.value): - result.append(ConstantReference(refs[i].value, refs[i].size)) - core.BNFreeConstantReferenceList(refs) - return result - - def get_lifted_il_at(self, arch, addr): - return core.BNGetLiftedILForInstruction(self.handle, arch.handle, addr) - - def get_lifted_il_flag_uses_for_definition(self, i, flag): - if isinstance(flag, str): - flag = self.arch._flags[flag] - count = ctypes.c_ulonglong() - instrs = core.BNGetLiftedILFlagUsesForDefinition(self.handle, i, flag, count) - result = [] - for i in xrange(0, count.value): - result.append(instrs[i]) - core.BNFreeLowLevelILInstructionList(instrs) - return result - - def get_lifted_il_flag_definitions_for_use(self, i, flag): - if isinstance(flag, str): - flag = self.arch._flags[flag] - count = ctypes.c_ulonglong() - instrs = core.BNGetLiftedILFlagDefinitionsForUse(self.handle, i, flag, count) - result = [] - for i in xrange(0, count.value): - result.append(instrs[i]) - core.BNFreeLowLevelILInstructionList(instrs) - return result - - def get_flags_read_by_lifted_il_instruction(self, i): - count = ctypes.c_ulonglong() - flags = core.BNGetFlagsReadByLiftedILInstruction(self.handle, i, count) - result = [] - for i in xrange(0, count.value): - result.append(self.arch._flags_by_index[flags[i]]) - core.BNFreeRegisterList(flags) - return result - - def get_flags_written_by_lifted_il_instruction(self, i): - count = ctypes.c_ulonglong() - flags = core.BNGetFlagsWrittenByLiftedILInstruction(self.handle, i, count) - result = [] - for i in xrange(0, count.value): - result.append(self.arch._flags_by_index[flags[i]]) - core.BNFreeRegisterList(flags) - return result - - def create_graph(self): - return FunctionGraph(self._view, core.BNCreateFunctionGraph(self.handle)) - - def apply_imported_types(self, sym): - core.BNApplyImportedTypes(self.handle, sym.handle) - - def apply_auto_discovered_type(self, func_type): - core.BNApplyAutoDiscoveredFunctionType(self.handle, func_type.handle) - - def set_auto_indirect_branches(self, source_arch, source, branches): - branch_list = (core.BNArchitectureAndAddress * len(branches))() - for i in xrange(len(branches)): - branch_list[i].arch = branches[i][0].handle - branch_list[i].address = branches[i][1] - core.BNSetAutoIndirectBranches(self.handle, source_arch.handle, source, branch_list, len(branches)) - - def set_user_indirect_branches(self, source_arch, source, branches): - branch_list = (core.BNArchitectureAndAddress * len(branches))() - for i in xrange(len(branches)): - branch_list[i].arch = branches[i][0].handle - branch_list[i].address = branches[i][1] - core.BNSetUserIndirectBranches(self.handle, source_arch.handle, source, branch_list, len(branches)) - - def get_indirect_branches_at(self, arch, addr): - count = ctypes.c_ulonglong() - branches = core.BNGetIndirectBranchesAt(self.handle, arch.handle, addr, count) - result = [] - for i in xrange(0, count.value): - result.append(IndirectBranchInfo(Architecture(branches[i].sourceArch), branches[i].sourceAddr, Architecture(branches[i].destArch), branches[i].destAddr, branches[i].autoDefined)) - core.BNFreeIndirectBranchList(branches) - return result - - def get_block_annotations(self, arch, addr): - count = ctypes.c_ulonglong(0) - lines = core.BNGetFunctionBlockAnnotations(self.handle, arch.handle, addr, count) - result = [] - for i in xrange(0, count.value): - tokens = [] - for j in xrange(0, lines[i].count): - token_type = core.BNInstructionTextTokenType_names[lines[i].tokens[j].type] - text = lines[i].tokens[j].text - value = lines[i].tokens[j].value - size = lines[i].tokens[j].size - operand = lines[i].tokens[j].operand - tokens.append(InstructionTextToken(token_type, text, value, size, operand)) - result.append(tokens) - core.BNFreeInstructionTextLines(lines, count.value) - return result - - def set_auto_type(self, value): - core.BNSetFunctionAutoType(self.handle, value.handle) - - def set_user_type(self, value): - core.BNSetFunctionUserType(self.handle, value.handle) - - def get_int_display_type(self, arch, instr_addr, value, operand): - return core.BNGetIntegerConstantDisplayType(self.handle, arch.handle, instr_addr, value, operand) - - def set_int_display_type(self, arch, instr_addr, value, operand, display_type): - if isinstance(display_type, str): - display_type = core.BNIntegerDisplayType_by_name[display_type] - core.BNSetIntegerConstantDisplayType(self.handle, arch.handle, instr_addr, value, operand, display_type) - - def reanalyze(self): - """ - ``reanalyze`` causes this functions to be reanalyzed. This function does not wait for the analysis to finish. - - :rtype: None - """ - core.BNReanalyzeFunction(self.handle) - - def request_advanced_analysis_data(self): - core.BNRequestAdvancedFunctionAnalysisData(self.handle) - self._advanced_analysis_requests += 1 - - def release_advanced_analysis_data(self): - core.BNReleaseAdvancedFunctionAnalysisData(self.handle) - self._advanced_analysis_requests -= 1 - - def get_basic_block_at(self, arch, addr): - block = core.BNGetFunctionBasicBlockAtAddress(self.handle, arch.handle, addr) - if not block: - return None - return BasicBlock(self._view, handle = block) - - def get_instr_highlight(self, arch, addr): - color = core.BNGetInstructionHighlight(self.handle, arch.handle, addr) - if color.style == core.StandardHighlightColor: - return HighlightColor(color = color.color, alpha = color.alpha) - elif color.style == core.MixedHighlightColor: - return HighlightColor(color = color.color, mix_color = color.mixColor, mix = color.mix, alpha = color.alpha) - elif color.style == core.CustomHighlightColor: - return HighlightColor(red = color.r, green = color.g, blue = color.b, alpha = color.alpha) - return HighlightColor(color = core.NoHighlightColor) - - def set_auto_instr_highlight(self, arch, addr, color): - if not isinstance(color, HighlightColor): - color = HighlightColor(color = color) - core.BNSetAutoInstructionHighlight(self.handle, arch.handle, addr, color._get_core_struct()) - - def set_user_instr_highlight(self, arch, addr, color): - if not isinstance(color, HighlightColor): - color = HighlightColor(color = color) - core.BNSetUserInstructionHighlight(self.handle, arch.handle, addr, color._get_core_struct()) - -class AdvancedFunctionAnalysisDataRequestor(object): - def __init__(self, func = None): - self._function = func - if self._function is not None: - self._function.request_advanced_analysis_data() - - def __del__(self): - if self._function is not None: - self._function.release_advanced_analysis_data() - - @property - def function(self): - return self._function - - @function.setter - def function(self, func): - if self._function is not None: - self._function.release_advanced_analysis_data() - self._function = func - if self._function is not None: - self._function.request_advanced_analysis_data() - - def close(self): - if self._function is not None: - self._function.release_advanced_analysis_data() - self._function = None - -class BasicBlockEdge(object): - def __init__(self, branch_type, target, arch): - self.type = core.BNBranchType_names[branch_type] - if self.type != "UnresolvedBranch": - self.target = target - self.arch = arch - - def __repr__(self): - if self.type == "UnresolvedBranch": - return "<%s>" % self.type - elif self.arch: - return "<%s: %s@%#x>" % (self.type, self.arch.name, self.target) - else: - return "<%s: %#x>" % (self.type, self.target) - -class BasicBlock(object): - def __init__(self, view, handle): - self.view = view - self.handle = core.handle_of_type(handle, core.BNBasicBlock) - - def __del__(self): - core.BNFreeBasicBlock(self.handle) - - @property - def function(self): - """Basic block function (read-only)""" - func = core.BNGetBasicBlockFunction(self.handle) - if func is None: - return None - return Function(self.view, func) - - @property - def arch(self): - """Basic block architecture (read-only)""" - arch = core.BNGetBasicBlockArchitecture(self.handle) - if arch is None: - return None - return Architecture(arch) - - @property - def start(self): - """Basic block start (read-only)""" - return core.BNGetBasicBlockStart(self.handle) - - @property - def end(self): - """Basic block end (read-only)""" - return core.BNGetBasicBlockEnd(self.handle) - - @property - def length(self): - """Basic block length (read-only)""" - return core.BNGetBasicBlockLength(self.handle) - - @property - def outgoing_edges(self): - """List of basic block outgoing edges (read-only)""" - count = ctypes.c_ulonglong(0) - edges = core.BNGetBasicBlockOutgoingEdges(self.handle, count) - result = [] - for i in xrange(0, count.value): - branch_type = edges[i].type - target = edges[i].target - if edges[i].arch: - arch = Architecture(edges[i].arch) - else: - arch = None - result.append(BasicBlockEdge(branch_type, target, arch)) - core.BNFreeBasicBlockOutgoingEdgeList(edges) - return result - - @property - def has_undetermined_outgoing_edges(self): - """Whether basic block has undetermined outgoing edges (read-only)""" - return core.BNBasicBlockHasUndeterminedOutgoingEdges(self.handle) - - @property - def annotations(self): - """List of automatic annotations for the start of this block (read-only)""" - return self.function.get_block_annotations(self.arch, self.start) - - @property - def disassembly_text(self): - return self.get_disassembly_text() - - @property - def highlight(self): - """Highlight color for basic block""" - color = core.BNGetBasicBlockHighlight(self.handle) - if color.style == core.StandardHighlightColor: - return HighlightColor(color = color.color, alpha = color.alpha) - elif color.style == core.MixedHighlightColor: - return HighlightColor(color = color.color, mix_color = color.mixColor, mix = color.mix, alpha = color.alpha) - elif color.style == core.CustomHighlightColor: - return HighlightColor(red = color.r, green = color.g, blue = color.b, alpha = color.alpha) - return HighlightColor(color = core.NoHighlightColor) - - @highlight.setter - def highlight(self, value): - self.set_user_highlight(value) - - def __setattr__(self, name, value): - try: - object.__setattr__(self,name,value) - except AttributeError: - raise AttributeError, "attribute '%s' is read only" % name - - def __len__(self): - return int(core.BNGetBasicBlockLength(self.handle)) - - def __repr__(self): - arch = self.arch - if arch: - return "" % (arch.name, self.start, self.end) - else: - return "" % (self.start, self.end) - - def __iter__(self): - start = self.start - end = self.end - - idx = start - while idx < end: - data = self.view.read(idx, 16) - inst_info = self.view.arch.get_instruction_info(data, idx) - inst_text = self.view.arch.get_instruction_text(data, idx) - - yield inst_text - idx += inst_info.length - - def mark_recent_use(self): - core.BNMarkBasicBlockAsRecentlyUsed(self.handle) - - def get_disassembly_text(self, settings = None): - settings_obj = None - if settings: - settings_obj = settings.handle - - count = ctypes.c_ulonglong() - lines = core.BNGetBasicBlockDisassemblyText(self.handle, settings_obj, count) - result = [] - for i in xrange(0, count.value): - addr = lines[i].addr - tokens = [] - for j in xrange(0, lines[i].count): - token_type = core.BNInstructionTextTokenType_names[lines[i].tokens[j].type] - text = lines[i].tokens[j].text - value = lines[i].tokens[j].value - size = lines[i].tokens[j].size - operand = lines[i].tokens[j].operand - tokens.append(InstructionTextToken(token_type, text, value, size, operand)) - result.append(DisassemblyTextLine(addr, tokens)) - core.BNFreeDisassemblyTextLines(lines, count.value) - return result - - def set_auto_highlight(self, color): - if not isinstance(color, HighlightColor): - color = HighlightColor(color = color) - core.BNSetAutoBasicBlockHighlight(self.handle, color._get_core_struct()) - - def set_user_highlight(self, color): - if not isinstance(color, HighlightColor): - color = HighlightColor(color = color) - core.BNSetUserBasicBlockHighlight(self.handle, color._get_core_struct()) - -class LowLevelILBasicBlock(BasicBlock): - def __init__(self, view, handle, owner): - super(LowLevelILBasicBlock, self).__init__(view, handle) - self.il_function = owner - - def __iter__(self): - for idx in xrange(self.start, self.end): - yield self.il_function[idx] - -class DisassemblyTextLine(object): - def __init__(self, addr, tokens): - self.address = addr - self.tokens = tokens - - def __str__(self): - result = "" - for token in self.tokens: - result += token.text - return result - - def __repr__(self): - return "<%#x: %s>" % (self.address, str(self)) - -class FunctionGraphEdge: - def __init__(self, branch_type, arch, target, points): - self.type = branch_type - self.arch = arch - self.target = target - self.points = points - - def __repr__(self): - if self.arch: - return "<%s: %s@%#x>" % (self.type, self.arch.name, self.target) - return "<%s: %#x>" % (self.type, self.target) - -class FunctionGraphBlock(object): - def __init__(self, handle): - self.handle = handle - - def __del__(self): - core.BNFreeFunctionGraphBlock(self.handle) - - @property - def basic_block(self): - """Basic block associated with this part of the funciton graph (read-only)""" - block = core.BNGetFunctionGraphBasicBlock(self.handle) - func = core.BNGetBasicBlockFunction(block) - if func is None: - core.BNFreeBasicBlock(block) - block = None - else: - block = BasicBlock(BinaryView(handle = core.BNGetFunctionData(func)), block) - core.BNFreeFunction(func) - return block - - @property - def arch(self): - """Function graph block architecture (read-only)""" - arch = core.BNGetFunctionGraphBlockArchitecture(self.handle) - if arch is None: - return None - return Architecture(arch) - - @property - def start(self): - """Function graph block start (read-only)""" - return core.BNGetFunctionGraphBlockStart(self.handle) - - @property - def end(self): - """Function graph block end (read-only)""" - return core.BNGetFunctionGraphBlockEnd(self.handle) - - @property - def x(self): - """Function graph block X (read-only)""" - return core.BNGetFunctionGraphBlockX(self.handle) - - @property - def y(self): - """Function graph block Y (read-only)""" - return core.BNGetFunctionGraphBlockY(self.handle) - - @property - def width(self): - """Function graph block width (read-only)""" - return core.BNGetFunctionGraphBlockWidth(self.handle) - - @property - def height(self): - """Function graph block height (read-only)""" - return core.BNGetFunctionGraphBlockHeight(self.handle) - - @property - def lines(self): - """Function graph block list of lines (read-only)""" - count = ctypes.c_ulonglong() - lines = core.BNGetFunctionGraphBlockLines(self.handle, count) - result = [] - for i in xrange(0, count.value): - addr = lines[i].addr - tokens = [] - for j in xrange(0, lines[i].count): - token_type = core.BNInstructionTextTokenType_names[lines[i].tokens[j].type] - text = lines[i].tokens[j].text - value = lines[i].tokens[j].value - size = lines[i].tokens[j].size - operand = lines[i].tokens[j].operand - tokens.append(InstructionTextToken(token_type, text, value, size, operand)) - result.append(DisassemblyTextLine(addr, tokens)) - core.BNFreeDisassemblyTextLines(lines, count.value) - return result - - @property - def outgoing_edges(self): - """Function graph block list of outgoing edges (read-only)""" - count = ctypes.c_ulonglong() - edges = core.BNGetFunctionGraphBlockOutgoingEdges(self.handle, count) - result = [] - for i in xrange(0, count.value): - branch_type = core.BNBranchType_names[edges[i].type] - target = edges[i].target - arch = None - if edges[i].arch is not None: - arch = Architecture(edges[i].arch) - points = [] - for j in xrange(0, edges[i].pointCount): - points.append((edges[i].points[j].x, edges[i].points[j].y)) - result.append(FunctionGraphEdge(branch_type, arch, target, points)) - core.BNFreeFunctionGraphBlockOutgoingEdgeList(edges, count.value) - return result - - def __setattr__(self, name, value): - try: - object.__setattr__(self,name,value) - except AttributeError: - raise AttributeError, "attribute '%s' is read only" % name - - def __repr__(self): - arch = self.arch - if arch: - return "" % (arch.name, self.start, self.end) - else: - return "" % (self.start, self.end) - - def __iter__(self): - count = ctypes.c_ulonglong() - lines = core.BNGetFunctionGraphBlockLines(self.handle, count) - try: - for i in xrange(0, count.value): - addr = lines[i].addr - tokens = [] - for j in xrange(0, lines[i].count): - token_type = core.BNInstructionTextTokenType_names[lines[i].tokens[j].type] - text = lines[i].tokens[j].text - value = lines[i].tokens[j].value - size = lines[i].tokens[j].size - operand = lines[i].tokens[j].operand - tokens.append(InstructionTextToken(token_type, text, value, size, operand)) - yield DisassemblyTextLine(addr, tokens) - finally: - core.BNFreeDisassemblyTextLines(lines, count.value) - -class DisassemblySettings(object): - def __init__(self, handle = None): - if handle is None: - self.handle = core.BNCreateDisassemblySettings() - else: - self.handle = handle - - def __del__(self): - core.BNFreeDisassemblySettings(self.handle) - - @property - def width(self): - return core.BNGetDisassemblyWidth(self.handle) - - @width.setter - def width(self, value): - core.BNSetDisassemblyWidth(self.handle, value) - - @property - def max_symbol_width(self): - return core.BNGetDisassemblyMaximumSymbolWidth(self.handle) - - @max_symbol_width.setter - def max_symbol_width(self, value): - core.BNSetDisassemblyMaximumSymbolWidth(self.handle, value) - - def is_option_set(self, option): - if isinstance(option, str): - option = core.BNDisassemblyOption_by_name[option] - return core.BNIsDisassemblySettingsOptionSet(self.handle, option) - - def set_option(self, option, state = True): - if isinstance(option, str): - option = core.BNDisassemblyOption_by_name[option] - core.BNSetDisassemblySettingsOption(self.handle, option, state) - -class FunctionGraph(object): - def __init__(self, view, handle): - self.view = view - self.handle = handle - self._on_complete = None - self._cb = ctypes.CFUNCTYPE(None, ctypes.c_void_p)(self._complete) - - def __del__(self): - self.abort() - core.BNFreeFunctionGraph(self.handle) - - @property - def function(self): - """Function for a function graph (read-only)""" - func = core.BNGetFunctionForFunctionGraph(self.handle) - if func is None: - return None - return Function(self.view, func) - - @property - def complete(self): - """Whether function graph layout is complete (read-only)""" - return core.BNIsFunctionGraphLayoutComplete(self.handle) - - @property - def type(self): - """Function graph type (read-only)""" - return core.BNFunctionGraphType_names[core.BNGetFunctionGraphType(self.handle)] - - @property - def blocks(self): - """List of basic blocks in function (read-only)""" - count = ctypes.c_ulonglong() - blocks = core.BNGetFunctionGraphBlocks(self.handle, count) - result = [] - for i in xrange(0, count.value): - result.append(FunctionGraphBlock(core.BNNewFunctionGraphBlockReference(blocks[i]))) - core.BNFreeFunctionGraphBlockList(blocks, count.value) - return result - - @property - def width(self): - """Function graph width (read-only)""" - return core.BNGetFunctionGraphWidth(self.handle) - - @property - def height(self): - """Function graph height (read-only)""" - return core.BNGetFunctionGraphHeight(self.handle) - - @property - def horizontal_block_margin(self): - return core.BNGetHorizontalFunctionGraphBlockMargin(self.handle) - - @horizontal_block_margin.setter - def horizontal_block_margin(self, value): - core.BNSetFunctionGraphBlockMargins(self.handle, value, self.vertical_block_margin) - - @property - def vertical_block_margin(self): - return core.BNGetVerticalFunctionGraphBlockMargin(self.handle) - - @vertical_block_margin.setter - def vertical_block_margin(self, value): - core.BNSetFunctionGraphBlockMargins(self.handle, self.horizontal_block_margin, value) - - @property - def settings(self): - return DisassemblySettings(core.BNGetFunctionGraphSettings(self.handle)) - - def __setattr__(self, name, value): - try: - object.__setattr__(self,name,value) - except AttributeError: - raise AttributeError, "attribute '%s' is read only" % name - - def __repr__(self): - return "" % repr(self.function) - - def __iter__(self): - count = ctypes.c_ulonglong() - blocks = core.BNGetFunctionGraphBlocks(self.handle, count) - try: - for i in xrange(0, count.value): - yield FunctionGraphBlock(core.BNNewFunctionGraphBlockReference(blocks[i])) - finally: - core.BNFreeFunctionGraphBlockList(blocks, count.value) - - def _complete(self, ctxt): - try: - if self._on_complete is not None: - self._on_complete() - except: - log_error(traceback.format_exc()) - - def layout(self, graph_type = core.NormalFunctionGraph): - if isinstance(graph_type, str): - graph_type = core.BNFunctionGraphType_by_name[graph_type] - core.BNStartFunctionGraphLayout(self.handle, graph_type) - - def _wait_complete(self): - self._wait_cond.acquire() - self._wait_cond.notify() - self._wait_cond.release() - - def layout_and_wait(self, graph_type = core.NormalFunctionGraph): - self._wait_cond = threading.Condition() - self.on_complete(self._wait_complete) - self.layout(graph_type) - - self._wait_cond.acquire() - while not self.complete: - self._wait_cond.wait() - self._wait_cond.release() - - def on_complete(self, callback): - self._on_complete = callback - core.BNSetFunctionGraphCompleteCallback(self.handle, None, self._cb) - - def abort(self): - core.BNAbortFunctionGraph(self.handle) - - def get_blocks_in_region(self, left, top, right, bottom): - count = ctypes.c_ulonglong() - blocks = core.BNGetFunctionGraphBlocksInRegion(self.handle, left, top, right, bottom, count) - result = [] - for i in xrange(0, count.value): - result.append(FunctionGraphBlock(core.BNNewFunctionGraphBlockReference(blocks[i]))) - core.BNFreeFunctionGraphBlockList(blocks, count.value) - return result - - def is_option_set(self, option): - if isinstance(option, str): - option = core.BNDisassemblyOption_by_name(option) - return core.BNIsFunctionGraphOptionSet(self.handle, option) - - def set_option(self, option, state = True): - if isinstance(option, str): - option = core.BNDisassemblyOption_by_name(option) - core.BNSetFunctionGraphOption(self.handle, option, state) - -class RegisterInfo(object): - def __init__(self, full_width_reg, size, offset = 0, extend = core.NoExtend, index = None): - self.full_width_reg = full_width_reg - self.offset = offset - self.size = size - self.extend = extend - self.index = index - - def __repr__(self): - if (self.extend == core.ZeroExtendToFullWidth) or (self.extend == "ZeroExtendToFullWidth"): - extend = ", zero extend" - elif (self.extend == core.SignExtendToFullWidth) or (self.extend == "SignExtendToFullWidth"): - extend = ", sign extend" - else: - extend = "" - return "" % (self.size, self.offset, self.full_width_reg, extend) - -class InstructionBranch(object): - def __init__(self, branch_type, target = 0, arch = None): - self.type = branch_type - self.target = target - self.arch = arch - - def __repr__(self): - branch_type = self.type - if not isinstance(branch_type, str): - branch_type = core.BNBranchType_names[branch_type] - if self.arch is not None: - return "<%s: %s@%#x>" % (branch_type, self.arch.name, self.target) - return "<%s: %#x>" % (branch_type, self.target) - -class InstructionInfo(object): - def __init__(self): - self.length = 0 - self.branch_delay = False - self.branches = [] - - def add_branch(self, branch_type, target = 0, arch = None): - self.branches.append(InstructionBranch(branch_type, target, arch)) - - def __repr__(self): - branch_delay = "" - if self.branch_delay: - branch_delay = ", delay slot" - return "" % (self.length, branch_delay, repr(self.branches)) - -class InstructionTextToken(object): - """ - ``class InstructionTextToken`` is used to tell the core about the various components in the disassembly views. - - ======================== ============================================ - InstructionTextTokenType Description - ======================== ============================================ - TextToken Text that doesn't fit into the other tokens - InstructionToken The instruction mnemonic - OperandSeparatorToken The comma or whatever else separates tokens - RegisterToken Registers - IntegerToken Integers - PossibleAddressToken Integers that are likely addresses - BeginMemoryOperandToken The start of memory operand - EndMemoryOperandToken The end of a memory operand - FloatingPointToken Floating point number - AnnotationToken **For internal use only** - CodeRelativeAddressToken **For internal use only** - StackVariableTypeToken **For internal use only** - DataVariableTypeToken **For internal use only** - FunctionReturnTypeToken **For internal use only** - FunctionAttributeToken **For internal use only** - ArgumentTypeToken **For internal use only** - ArgumentNameToken **For internal use only** - HexDumpByteValueToken **For internal use only** - HexDumpSkippedByteToken **For internal use only** - HexDumpInvalidByteToken **For internal use only** - HexDumpTextToken **For internal use only** - OpcodeToken **For internal use only** - StringToken **For internal use only** - CharacterConstantToken **For internal use only** - CodeSymbolToken **For internal use only** - DataSymbolToken **For internal use only** - StackVariableToken **For internal use only** - ImportToken **For internal use only** - AddressDisplayToken **For internal use only** - ======================== ============================================ - - """ - def __init__(self, token_type, text, value = 0, size = 0, operand = 0xffffffff): - self.type = token_type - self.text = text - self.value = value - self.size = size - self.operand = operand - - def __str__(self): - return self.text - - def __repr__(self): - return repr(self.text) - -class _ArchitectureMetaClass(type): - @property - def list(self): - _init_plugins() - count = ctypes.c_ulonglong() - archs = core.BNGetArchitectureList(count) - result = [] - for i in xrange(0, count.value): - result.append(Architecture(archs[i])) - core.BNFreeArchitectureList(archs) - return result - - def __iter__(self): - _init_plugins() - count = ctypes.c_ulonglong() - archs = core.BNGetArchitectureList(count) - try: - for i in xrange(0, count.value): - yield Architecture(archs[i]) - finally: - core.BNFreeArchitectureList(archs) - - def __getitem__(cls, name): - _init_plugins() - arch = core.BNGetArchitectureByName(name) - if arch is None: - raise KeyError, "'%s' is not a valid architecture" % str(name) - return Architecture(arch) - - def register(cls): - _init_plugins() - if cls.name is None: - raise ValueError, "architecture 'name' is not defined" - arch = cls() - cls._registered_cb = arch._cb - arch.handle = core.BNRegisterArchitecture(cls.name, arch._cb) - - def __setattr__(self, name, value): - try: - type.__setattr__(self,name,value) - except AttributeError: - raise AttributeError, "attribute '%s' is read only" % name - -class Architecture(object): - """ - ``class Architecture`` is the parent class for all CPU architectures. Subclasses of Architecture implement assembly, - disassembly, IL lifting, and patching. - - ``class Architecture`` has a ``__metaclass__`` with the additional methods ``register``, and supports - iteration:: - - >>> #List the architectures - >>> list(Architecture) - [, , , , , , - , ] - >>> #Register a new Architecture - >>> class MyArch(Architecture): - ... name = "MyArch" - ... - >>> MyArch.register() - >>> list(Architecture) - [, , , , , , - , , ] - >>> - - For the purposes of this documentation the variable ``arch`` will be used in the following context :: - - >>> from binaryninja import * - >>> arch = Architecture['x86'] - """ - name = None - endianness = core.LittleEndian - address_size = 8 - default_int_size = 4 - max_instr_length = 16 - opcode_display_length = 8 - regs = {} - stack_pointer = None - link_reg = None - flags = [] - flag_write_types = [] - flag_roles = {} - flags_required_for_flag_condition = {} - flags_written_by_flag_write_type = {} - __metaclass__ = _ArchitectureMetaClass - next_address = 0 - - def __init__(self, handle = None): - if handle is not None: - self.handle = core.handle_of_type(handle, core.BNArchitecture) - self.__dict__["name"] = core.BNGetArchitectureName(self.handle) - self.__dict__["endianness"] = core.BNEndianness_names[core.BNGetArchitectureEndianness(self.handle)] - self.__dict__["address_size"] = core.BNGetArchitectureAddressSize(self.handle) - self.__dict__["default_int_size"] = core.BNGetArchitectureDefaultIntegerSize(self.handle) - self.__dict__["max_instr_length"] = core.BNGetArchitectureMaxInstructionLength(self.handle) - self.__dict__["opcode_display_length"] = core.BNGetArchitectureOpcodeDisplayLength(self.handle) - self.__dict__["stack_pointer"] = core.BNGetArchitectureRegisterName(self.handle, - core.BNGetArchitectureStackPointerRegister(self.handle)) - self.__dict__["link_reg"] = core.BNGetArchitectureRegisterName(self.handle, - core.BNGetArchitectureLinkRegister(self.handle)) - - count = ctypes.c_ulonglong() - regs = core.BNGetAllArchitectureRegisters(self.handle, count) - self.__dict__["regs"] = {} - for i in xrange(0, count.value): - name = core.BNGetArchitectureRegisterName(self.handle, regs[i]) - info = core.BNGetArchitectureRegisterInfo(self.handle, regs[i]) - full_width_reg = core.BNGetArchitectureRegisterName(self.handle, info.fullWidthRegister) - self.regs[name] = RegisterInfo(full_width_reg, info.size, info.offset, - core.BNImplicitRegisterExtend_names[info.extend], regs[i]) - core.BNFreeRegisterList(regs) - - count = ctypes.c_ulonglong() - flags = core.BNGetAllArchitectureFlags(self.handle, count) - self._flags = {} - self._flags_by_index = {} - self.__dict__["flags"] = [] - for i in xrange(0, count.value): - name = core.BNGetArchitectureFlagName(self.handle, flags[i]) - self._flags[name] = flags[i] - self._flags_by_index[flags[i]] = name - self.flags.append(name) - core.BNFreeRegisterList(flags) - - count = ctypes.c_ulonglong() - types = core.BNGetAllArchitectureFlagWriteTypes(self.handle, count) - self._flag_write_types = {} - self._flag_write_types_by_index = {} - self.__dict__["flag_write_types"] = [] - for i in xrange(0, count.value): - name = core.BNGetArchitectureFlagWriteTypeName(self.handle, types[i]) - self._flag_write_types[name] = types[i] - self._flag_write_types_by_index[types[i]] = name - self.flag_write_types.append(name) - core.BNFreeRegisterList(types) - - self._flag_roles = {} - self.__dict__["flag_roles"] = {} - for flag in self.__dict__["flags"]: - role = core.BNGetArchitectureFlagRole(self.handle, self._flags[flag]) - self.__dict__["flag_roles"][flag] = role - self._flag_roles[self._flags[flag]] = role - - self._flags_required_for_flag_condition = {} - self.__dict__["flags_required_for_flag_condition"] = {} - for cond in core.BNLowLevelILFlagCondition_names: - count = ctypes.c_ulonglong() - flags = core.BNGetArchitectureFlagsRequiredForFlagCondition(self.handle, cond, count) - flag_indexes = [] - flag_names = [] - for i in xrange(0, count.value): - flag_indexes.append(flags[i]) - flag_names.append(self._flags_by_index[flags[i]]) - core.BNFreeRegisterList(flags) - self._flags_required_for_flag_condition[cond] = flag_indexes - self.__dict__["flags_required_for_flag_condition"][cond] = flag_names - - self._flags_written_by_flag_write_type = {} - self.__dict__["flags_written_by_flag_write_type"] = {} - for write_type in self.flag_write_types: - count = ctypes.c_ulonglong() - flags = core.BNGetArchitectureFlagsWrittenByFlagWriteType(self.handle, - self._flag_write_types[write_type], count) - flag_indexes = [] - flag_names = [] - for i in xrange(0, count.value): - flag_indexes.append(flags[i]) - flag_names.append(self._flags_by_index[flags[i]]) - core.BNFreeRegisterList(flags) - self._flags_written_by_flag_write_type[self._flag_write_types[write_type]] = flag_indexes - self.__dict__["flags_written_by_flag_write_type"][write_type] = flag_names - else: - _init_plugins() - - if self.__class__.opcode_display_length > self.__class__.max_instr_length: - self.__class__.opcode_display_length = self.__class__.max_instr_length - - self._cb = core.BNCustomArchitecture() - self._cb.context = 0 - self._cb.init = self._cb.init.__class__(self._init) - self._cb.getEndianness = self._cb.getEndianness.__class__(self._get_endianness) - self._cb.getAddressSize = self._cb.getAddressSize.__class__(self._get_address_size) - self._cb.getDefaultIntegerSize = self._cb.getDefaultIntegerSize.__class__(self._get_default_integer_size) - self._cb.getMaxInstructionLength = self._cb.getMaxInstructionLength.__class__(self._get_max_instruction_length) - self._cb.getOpcodeDisplayLength = self._cb.getOpcodeDisplayLength.__class__(self._get_opcode_display_length) - self._cb.getInstructionInfo = self._cb.getInstructionInfo.__class__(self._get_instruction_info) - self._cb.getInstructionText = self._cb.getInstructionText.__class__(self._get_instruction_text) - self._cb.freeInstructionText = self._cb.freeInstructionText.__class__(self._free_instruction_text) - self._cb.getInstructionLowLevelIL = self._cb.getInstructionLowLevelIL.__class__( - self._get_instruction_low_level_il) - self._cb.getRegisterName = self._cb.getRegisterName.__class__(self._get_register_name) - self._cb.getFlagName = self._cb.getFlagName.__class__(self._get_flag_name) - self._cb.getFlagWriteTypeName = self._cb.getFlagWriteTypeName.__class__(self._get_flag_write_type_name) - self._cb.getFullWidthRegisters = self._cb.getFullWidthRegisters.__class__(self._get_full_width_registers) - self._cb.getAllRegisters = self._cb.getAllRegisters.__class__(self._get_all_registers) - self._cb.getAllFlags = self._cb.getAllRegisters.__class__(self._get_all_flags) - self._cb.getAllFlagWriteTypes = self._cb.getAllRegisters.__class__(self._get_all_flag_write_types) - self._cb.getFlagRole = self._cb.getFlagRole.__class__(self._get_flag_role) - self._cb.getFlagsRequiredForFlagCondition = self._cb.getFlagsRequiredForFlagCondition.__class__( - self._get_flags_required_for_flag_condition) - self._cb.getFlagsWrittenByFlagWriteType = self._cb.getFlagsWrittenByFlagWriteType.__class__( - self._get_flags_written_by_flag_write_type) - self._cb.getFlagWriteLowLevelIL = self._cb.getFlagWriteLowLevelIL.__class__( - self._get_flag_write_low_level_il) - self._cb.getFlagConditionLowLevelIL = self._cb.getFlagConditionLowLevelIL.__class__( - self._get_flag_condition_low_level_il) - self._cb.freeRegisterList = self._cb.freeRegisterList.__class__(self._free_register_list) - self._cb.getRegisterInfo = self._cb.getRegisterInfo.__class__(self._get_register_info) - self._cb.getStackPointerRegister = self._cb.getStackPointerRegister.__class__( - self._get_stack_pointer_register) - self._cb.getLinkRegister = self._cb.getLinkRegister.__class__(self._get_link_register) - self._cb.assemble = self._cb.assemble.__class__(self._assemble) - self._cb.isNeverBranchPatchAvailable = self._cb.isNeverBranchPatchAvailable.__class__( - self._is_never_branch_patch_available) - self._cb.isAlwaysBranchPatchAvailable = self._cb.isAlwaysBranchPatchAvailable.__class__( - self._is_always_branch_patch_available) - self._cb.isInvertBranchPatchAvailable = self._cb.isInvertBranchPatchAvailable.__class__( - self._is_invert_branch_patch_available) - self._cb.isSkipAndReturnZeroPatchAvailable = self._cb.isSkipAndReturnZeroPatchAvailable.__class__( - self._is_skip_and_return_zero_patch_available) - self._cb.isSkipAndReturnValuePatchAvailable = self._cb.isSkipAndReturnValuePatchAvailable.__class__( - self._is_skip_and_return_value_patch_available) - self._cb.convertToNop = self._cb.convertToNop.__class__(self._convert_to_nop) - self._cb.alwaysBranch = self._cb.alwaysBranch.__class__(self._always_branch) - self._cb.invertBranch = self._cb.invertBranch.__class__(self._invert_branch) - self._cb.skipAndReturnValue = self._cb.skipAndReturnValue.__class__(self._skip_and_return_value) - - self._all_regs = {} - self._full_width_regs = {} - self._regs_by_index = {} - self.__dict__["regs"] = self.__class__.regs - reg_index = 0 - for reg in self.regs: - info = self.regs[reg] - if reg not in self._all_regs: - self._all_regs[reg] = reg_index - self._regs_by_index[reg_index] = reg - self.regs[reg].index = reg_index - reg_index += 1 - if info.full_width_reg not in self._all_regs: - self._all_regs[info.full_width_reg] = reg_index - self._regs_by_index[reg_index] = info.full_width_reg - self.regs[info.full_width_reg].index = reg_index - reg_index += 1 - if info.full_width_reg not in self._full_width_regs: - self._full_width_regs[info.full_width_reg] = self._all_regs[info.full_width_reg] - - self._flags = {} - self._flags_by_index = {} - self.__dict__["flags"] = self.__class__.flags - flag_index = 0 - for flag in self.__class__.flags: - if flag not in self._flags: - self._flags[flag] = flag_index - self._flags_by_index[flag_index] = flag - flag_index += 1 - - self._flag_write_types = {} - self._flag_write_types_by_index = {} - self.__dict__["flag_write_types"] = self.__class__.flag_write_types - write_type_index = 0 - for write_type in self.__class__.flag_write_types: - if write_type not in self._flag_write_types: - self._flag_write_types[write_type] = write_type_index - self._flag_write_types_by_index[write_type_index] = write_type - write_type_index += 1 - - self._flag_roles = {} - self.__dict__["flag_roles"] = self.__class__.flag_roles - for flag in self.__class__.flag_roles: - role = self.__class__.flag_roles[flag] - if isinstance(role, str): - role = core.BNFlagRole_by_name[role] - self._flag_roles[self._flags[flag]] = role - - self._flags_required_for_flag_condition = {} - self.__dict__["flags_required_for_flag_condition"] = self.__class__.flags_required_for_flag_condition - for cond in self.__class__.flags_required_for_flag_condition: - flags = [] - for flag in self.__class__.flags_required_for_flag_condition[cond]: - flags.append(self._flags[flag]) - self._flags_required_for_flag_condition[cond] = flags - - self._flags_written_by_flag_write_type = {} - self.__dict__["flags_written_by_flag_write_type"] = self.__class__.flags_written_by_flag_write_type - for write_type in self.__class__.flags_written_by_flag_write_type: - flags = [] - for flag in self.__class__.flags_written_by_flag_write_type[write_type]: - flags.append(self._flags[flag]) - self._flags_written_by_flag_write_type[self._flag_write_types[write_type]] = flags - - self._pending_reg_lists = {} - self._pending_token_lists = {} - - @property - def full_width_regs(self): - """List of full width register strings (read-only)""" - count = ctypes.c_ulonglong() - regs = core.BNGetFullWidthArchitectureRegisters(self.handle, count) - result = [] - for i in xrange(0, count.value): - result.append(core.BNGetArchitectureRegisterName(self.handle, regs[i])) - core.BNFreeRegisterList(regs) - return result - - @property - def calling_conventions(self): - """Dict of CallingConvention objects (read-only)""" - count = ctypes.c_ulonglong() - cc = core.BNGetArchitectureCallingConventions(self.handle, count) - result = {} - for i in xrange(0, count.value): - obj = CallingConvention(None, core.BNNewCallingConventionReference(cc[i])) - result[obj.name] = obj - core.BNFreeCallingConventionList(cc, count) - return result - - @property - def standalone_platform(self): - """Architecture standalone platform (read-only)""" - pl = core.BNGetArchitectureStandalonePlatform(self.handle) - return Platform(self, pl) - - def __setattr__(self, name, value): - if ((name == "name") or (name == "endianness") or (name == "address_size") or - (name == "default_int_size") or (name == "regs") or (name == "get_max_instruction_length")): - raise AttributeError, "attribute '%s' is read only" % name - else: - try: - object.__setattr__(self,name,value) - except AttributeError: - raise AttributeError, "attribute '%s' is read only" % name - - def __repr__(self): - return "" % self.name - - def _init(self, ctxt, handle): - self.handle = handle - - def _get_endianness(self, ctxt): - try: - return self.__class__.endianness - except: - log_error(traceback.format_exc()) - return core.LittleEndian - - def _get_address_size(self, ctxt): - try: - return self.__class__.address_size - except: - log_error(traceback.format_exc()) - return 8 - - def _get_default_integer_size(self, ctxt): - try: - return self.__class__.default_int_size - except: - log_error(traceback.format_exc()) - return 4 - - def _get_max_instruction_length(self, ctxt): - try: - return self.__class__.max_instr_length - except: - log_error(traceback.format_exc()) - return 16 - - def _get_opcode_display_length(self, ctxt): - try: - return self.__class__.opcode_display_length - except: - log_error(traceback.format_exc()) - return 8 - - def _get_instruction_info(self, ctxt, data, addr, max_len, result): - try: - buf = ctypes.create_string_buffer(max_len) - ctypes.memmove(buf, data, max_len) - info = self.perform_get_instruction_info(buf.raw, addr) - if info is None: - return False - result[0].length = info.length - result[0].branchDelay = info.branch_delay - result[0].branchCount = len(info.branches) - for i in xrange(0, len(info.branches)): - if isinstance(info.branches[i].type, str): - result[0].branchType[i] = core.BNBranchType_by_name[info.branches[i].type] - else: - result[0].branchType[i] = info.branches[i].type - result[0].branchTarget[i] = info.branches[i].target - if info.branches[i].arch is None: - result[0].branchArch[i] = None - else: - result[0].branchArch[i] = info.branches[i].arch.handle - return True - except (KeyError, OSError): - log_error(traceback.format_exc()) - return False - - def _get_instruction_text(self, ctxt, data, addr, length, result, count): - try: - buf = ctypes.create_string_buffer(length[0]) - ctypes.memmove(buf, data, length[0]) - info = self.perform_get_instruction_text(buf.raw, addr) - if info is None: - return False - tokens = info[0] - length[0] = info[1] - count[0] = len(tokens) - token_buf = (core.BNInstructionTextToken * len(tokens))() - for i in xrange(0, len(tokens)): - if isinstance(tokens[i].type, str): - token_buf[i].type = core.BNInstructionTextTokenType_by_name[tokens[i].type] - else: - token_buf[i].type = tokens[i].type - token_buf[i].text = tokens[i].text - token_buf[i].value = tokens[i].value - token_buf[i].size = tokens[i].size - token_buf[i].operand = tokens[i].operand - result[0] = token_buf - ptr = ctypes.cast(token_buf, ctypes.c_void_p) - self._pending_token_lists[ptr.value] = (ptr.value, token_buf) - return True - except (KeyError, OSError): - log_error(traceback.format_exc()) - return False - - def _free_instruction_text(self, tokens, count): - try: - buf = ctypes.cast(tokens, ctypes.c_void_p) - if buf.value not in self._pending_token_lists: - raise ValueError, "freeing token list that wasn't allocated" - del self._pending_token_lists[buf.value] - except KeyError: - log_error(traceback.format_exc()) - - def _get_instruction_low_level_il(self, ctxt, data, addr, length, il): - try: - buf = ctypes.create_string_buffer(length[0]) - ctypes.memmove(buf, data, length[0]) - result = self.perform_get_instruction_low_level_il(buf.raw, addr, - LowLevelILFunction(self, core.BNNewLowLevelILFunctionReference(il))) - if result is None: - return False - length[0] = result - return True - except OSError: - log_error(traceback.format_exc()) - return False - - def _get_register_name(self, ctxt, reg): - try: - if reg in self._regs_by_index: - return core.BNAllocString(self._regs_by_index[reg]) - return core.BNAllocString("") - except (KeyError, OSError): - log_error(traceback.format_exc()) - return core.BNAllocString("") - - def _get_flag_name(self, ctxt, flag): - try: - if flag in self._flags_by_index: - return core.BNAllocString(self._flags_by_index[flag]) - return core.BNAllocString("") - except (KeyError, OSError): - log_error(traceback.format_exc()) - return core.BNAllocString("") - - def _get_flag_write_type_name(self, ctxt, write_type): - try: - if write_type in self._flag_write_types_by_index: - return core.BNAllocString(self._flag_write_types_by_index[write_type]) - return core.BNAllocString("") - except (KeyError, OSError): - log_error(traceback.format_exc()) - return core.BNAllocString("") - - def _get_full_width_registers(self, ctxt, count): - try: - regs = self._full_width_regs.values() - count[0] = len(regs) - reg_buf = (ctypes.c_uint * len(regs))() - for i in xrange(0, len(regs)): - reg_buf[i] = regs[i] - result = ctypes.cast(reg_buf, ctypes.c_void_p) - self._pending_reg_lists[result.value] = (result, reg_buf) - return result.value - except KeyError: - log_error(traceback.format_exc()) - count[0] = 0 - return None - - def _get_all_registers(self, ctxt, count): - try: - regs = self._regs_by_index.keys() - count[0] = len(regs) - reg_buf = (ctypes.c_uint * len(regs))() - for i in xrange(0, len(regs)): - reg_buf[i] = regs[i] - result = ctypes.cast(reg_buf, ctypes.c_void_p) - self._pending_reg_lists[result.value] = (result, reg_buf) - return result.value - except KeyError: - log_error(traceback.format_exc()) - count[0] = 0 - return None - - def _get_all_flags(self, ctxt, count): - try: - flags = self._flags_by_index.keys() - count[0] = len(flags) - flag_buf = (ctypes.c_uint * len(flags))() - for i in xrange(0, len(flags)): - flag_buf[i] = flags[i] - result = ctypes.cast(flag_buf, ctypes.c_void_p) - self._pending_reg_lists[result.value] = (result, flag_buf) - return result.value - except KeyError: - log_error(traceback.format_exc()) - count[0] = 0 - return None - - def _get_all_flag_write_types(self, ctxt, count): - try: - types = self._flag_write_types_by_index.keys() - count[0] = len(types) - type_buf = (ctypes.c_uint * len(types))() - for i in xrange(0, len(types)): - type_buf[i] = types[i] - result = ctypes.cast(type_buf, ctypes.c_void_p) - self._pending_reg_lists[result.value] = (result, type_buf) - return result.value - except KeyError: - log_error(traceback.format_exc()) - count[0] = 0 - return None - - def _get_flag_role(self, ctxt, flag): - try: - if flag in self._flag_roles: - return self._flag_roles[flag] - return core.SpecialFlagRole - except KeyError: - log_error(traceback.format_exc()) - return None - - def _get_flags_required_for_flag_condition(self, ctxt, cond, count): - try: - if cond in self._flags_required_for_flag_condition: - flags = self._flags_required_for_flag_condition[cond] - else: - flags = [] - count[0] = len(flags) - flag_buf = (ctypes.c_uint * len(flags))() - for i in xrange(0, len(flags)): - flag_buf[i] = flags[i] - result = ctypes.cast(flag_buf, ctypes.c_void_p) - self._pending_reg_lists[result.value] = (result, flag_buf) - return result.value - except KeyError: - log_error(traceback.format_exc()) - count[0] = 0 - return None - - def _get_flags_written_by_flag_write_type(self, ctxt, write_type, count): - try: - if write_type in self._flags_written_by_flag_write_type: - flags = self._flags_written_by_flag_write_type[write_type] - else: - flags = [] - count[0] = len(flags) - flag_buf = (ctypes.c_uint * len(flags))() - for i in xrange(0, len(flags)): - flag_buf[i] = flags[i] - result = ctypes.cast(flag_buf, ctypes.c_void_p) - self._pending_reg_lists[result.value] = (result, flag_buf) - return result.value - except (KeyError, OSError): - log_error(traceback.format_exc()) - count[0] = 0 - return None - - def _get_flag_write_low_level_il(self, ctxt, op, size, write_type, flag, operands, operand_count, il): - try: - write_type_name = None - if write_type != 0: - write_type_name = self._flag_write_types_by_index[write_type] - flag_name = self._flags_by_index[flag] - operand_list = [] - for i in xrange(operand_count): - if operands[i].constant: - operand_list.append(("const", operands[i].value)) - elif LLIL_REG_IS_TEMP(operands[i].reg): - operand_list.append(("reg", operands[i].reg)) - else: - operand_list.append(("reg", self._regs_by_index[operands[i].reg])) - return self.perform_get_flag_write_low_level_il(op, size, write_type_name, flag_name, operand_list, - LowLevelILFunction(self, core.BNNewLowLevelILFunctionReference(il))).index - except (KeyError, OSError): - log_error(traceback.format_exc()) - return False - - def _get_flag_condition_low_level_il(self, ctxt, cond, il): - try: - return self.perform_get_flag_condition_low_level_il(cond, - LowLevelILFunction(self, core.BNNewLowLevelILFunctionReference(il))).index - except OSError: - log_error(traceback.format_exc()) - return 0 - - def _free_register_list(self, ctxt, regs): - try: - buf = ctypes.cast(regs, ctypes.c_void_p) - if buf.value not in self._pending_reg_lists: - raise ValueError, "freeing register list that wasn't allocated" - del self._pending_reg_lists[buf.value] - except (ValueError, KeyError): - log_error(traceback.format_exc()) - - def _get_register_info(self, ctxt, reg, result): - try: - if reg not in self._regs_by_index: - result[0].fullWidthRegister = 0 - result[0].offset = 0 - result[0].size = 0 - result[0].extend = core.NoExtend - return - info = self.__class__.regs[self._regs_by_index[reg]] - result[0].fullWidthRegister = self._all_regs[info.full_width_reg] - result[0].offset = info.offset - result[0].size = info.size - if isinstance(info.extend, str): - result[0].extend = core.BNImplicitRegisterExtend_by_name[info.extend] - else: - result[0].extend = info.extend - except KeyError: - log_error(traceback.format_exc()) - result[0].fullWidthRegister = 0 - result[0].offset = 0 - result[0].size = 0 - result[0].extend = core.NoExtend - - def _get_stack_pointer_register(self, ctxt): - try: - return self._all_regs[self.__class__.stack_pointer] - except KeyError: - log_error(traceback.format_exc()) - return 0 - - def _get_link_register(self, ctxt): - try: - if self.__class__.link_reg is None: - return 0xffffffff - return self._all_regs[self.__class__.link_reg] - except KeyError: - log_error(traceback.format_exc()) - return 0 - - def _assemble(self, ctxt, code, addr, result, errors): - try: - data, error_str = self.perform_assemble(code, addr) - errors[0] = core.BNAllocString(str(error_str)) - if data is None: - return False - data = str(data) - buf = ctypes.create_string_buffer(len(data)) - ctypes.memmove(buf, data, len(data)) - core.BNSetDataBufferContents(result, buf, len(data)) - return True - except: - log_error(traceback.format_exc()) - errors[0] = core.BNAllocString("Unhandled exception during assembly.\n") - return False - - def _is_never_branch_patch_available(self, ctxt, data, addr, length): - try: - buf = ctypes.create_string_buffer(length) - ctypes.memmove(buf, data, length) - return self.perform_is_never_branch_patch_available(buf.raw, addr) - except: - log_error(traceback.format_exc()) - return False - - def _is_always_branch_patch_available(self, ctxt, data, addr, length): - try: - buf = ctypes.create_string_buffer(length) - ctypes.memmove(buf, data, length) - return self.perform_is_always_branch_patch_available(buf.raw, addr) - except: - log_error(traceback.format_exc()) - return False - - def _is_invert_branch_patch_available(self, ctxt, data, addr, length): - try: - buf = ctypes.create_string_buffer(length) - ctypes.memmove(buf, data, length) - return self.perform_is_invert_branch_patch_available(buf.raw, addr) - except: - log_error(traceback.format_exc()) - return False - - def _is_skip_and_return_zero_patch_available(self, ctxt, data, addr, length): - try: - buf = ctypes.create_string_buffer(length) - ctypes.memmove(buf, data, length) - return self.perform_is_skip_and_return_zero_patch_available(buf.raw, addr) - except: - log_error(traceback.format_exc()) - return False - - def _is_skip_and_return_value_patch_available(self, ctxt, data, addr, length): - try: - buf = ctypes.create_string_buffer(length) - ctypes.memmove(buf, data, length) - return self.perform_is_skip_and_return_value_patch_available(buf.raw, addr) - except: - log_error(traceback.format_exc()) - return False - - def _convert_to_nop(self, ctxt, data, addr, length): - try: - buf = ctypes.create_string_buffer(length) - ctypes.memmove(buf, data, length) - result = self.perform_convert_to_nop(buf.raw, addr) - if result is None: - return False - result = str(result) - if len(result) > length: - result = result[0:length] - ctypes.memmove(data, result, len(result)) - return True - except: - log_error(traceback.format_exc()) - return False - - def _always_branch(self, ctxt, data, addr, length): - try: - buf = ctypes.create_string_buffer(length) - ctypes.memmove(buf, data, length) - result = self.perform_always_branch(buf.raw, addr) - if result is None: - return False - result = str(result) - if len(result) > length: - result = result[0:length] - ctypes.memmove(data, result, len(result)) - return True - except: - log_error(traceback.format_exc()) - return False - - def _invert_branch(self, ctxt, data, addr, length): - try: - buf = ctypes.create_string_buffer(length) - ctypes.memmove(buf, data, length) - result = self.perform_invert_branch(buf.raw, addr) - if result is None: - return False - result = str(result) - if len(result) > length: - result = result[0:length] - ctypes.memmove(data, result, len(result)) - return True - except: - log_error(traceback.format_exc()) - return False - - def _skip_and_return_value(self, ctxt, data, addr, length, value): - try: - buf = ctypes.create_string_buffer(length) - ctypes.memmove(buf, data, length) - result = self.perform_skip_and_return_value(buf.raw, addr, value) - if result is None: - return False - result = str(result) - if len(result) > length: - result = result[0:length] - ctypes.memmove(data, result, len(result)) - return True - except: - log_error(traceback.format_exc()) - return False - - @abc.abstractmethod - def perform_get_instruction_info(self, data, addr): - """ - ``perform_get_instruction_info`` implements a method which interpretes the bytes passed in ``data`` as an - :py:Class:`InstructionInfo` object. The InstructionInfo object should have the length of the current instruction. - If the instruction is a branch instruction the method should add a branch of the proper type: - - ===================== =================================================== - BranchType Description - ===================== =================================================== - UnconditionalBranch Branch will always be taken - FalseBranch False branch condition - TrueBranch True branch condition - CallDestination Branch is a call instruction (Branch with Link) - FunctionReturn Branch returns from a function - SystemCall System call instruction - IndirectBranch Branch destination is a memory address or register - UnresolvedBranch Call instruction that isn't - ===================== =================================================== - - :param str data: bytes to decode - :param int addr: virtual address of the byte to be decoded - :return: a :py:class:`InstructionInfo` object containing the length and branche types for the given instruction - :rtype: InstructionInfo - """ - raise NotImplementedError - - @abc.abstractmethod - def perform_get_instruction_text(self, data, addr): - """ - ``perform_get_instruction_text`` implements a method which interpretes the bytes passed in ``data`` as a - list of :py:class:`InstructionTextToken` objects. - - :param str data: bytes to decode - :param int addr: virtual address of the byte to be decoded - :return: a tuple of list(InstructionTextToken) and length of instruction decoded - :rtype: tuple(list(InstructionTextToken), int) - """ - raise NotImplementedError - - @abc.abstractmethod - def perform_get_instruction_low_level_il(self, data, addr, il): - """ - ``perform_get_instruction_low_level_il`` implements a method to interpret the bytes passed in ``data`` to - low-level IL instructions. The il instructions must be appended to the :py:class:`LowLevelILFunction`. - - .. note:: Architecture subclasses should implement this method. - - :param str data: bytes to be interpreted as low-level IL instructions - :param int addr: virtual address of start of ``data`` - :param LowLevelILFunction il: LowLevelILFunction object to append LowLevelILExpr objects to - :rtype: None - """ - raise NotImplementedError - - @abc.abstractmethod - def perform_get_flag_write_low_level_il(self, op, size, write_type, flag, operands, il): - """ - .. note:: Architecture subclasses should implement this method. - .. warning:: This method should never be called directly. - - :param LowLevelILOperation op: - :param int size: - :param int write_type: - :param int flag: - :param list(int_or_str): - :param LowLevelILFunction il: - :rtype: LowLevelILExpr - """ - return il.unimplemented() - - @abc.abstractmethod - def perform_get_flag_condition_low_level_il(self, cond, il): - """ - .. note:: Architecture subclasses should implement this method. - .. warning:: This method should never be called directly. - - :param LowLevelILFlagCondition cond: - :param LowLevelILFunction il: - :rtype: LowLevelILExpr - """ - return il.unimplemented() - - @abc.abstractmethod - def perform_assemble(self, code, addr): - """ - ``perform_assemble`` implements a method to convert the string of assembly instructions ``code`` loaded at - virtual address ``addr`` to the byte representation of those instructions. This can be done by simply shelling - out to an assembler like yasm or llvm-mc, since this method isn't performance sensitive. - - .. note:: Architecture subclasses should implement this method. - .. note :: It is important that the assembler used accepts a syntax identical to the one emitted by the \ - disassembler. This will prevent confusing the user. - .. warning:: This method should never be called directly. - - :param str code: string representation of the instructions to be assembled - :param int addr: virtual address that the instructions will be loaded at - :return: the bytes for the assembled instructions or error string - :rtype: (a tuple of instructions and empty string) or (or None and error string) - """ - return None, "Architecture does not implement an assembler.\n" - - @abc.abstractmethod - def perform_is_never_branch_patch_available(self, data, addr): - """ - ``perform_is_never_branch_patch_available`` implements a check to determine if the instruction represented by - the bytes contained in ``data`` at address addr is a branch instruction that can be made to never branch. - - .. note:: Architecture subclasses should implement this method. - .. warning:: This method should never be called directly. - - :param str data: bytes to be checked - :param int addr: the virtual address of the instruction to be patched - :return: True if the instruction can be patched, False otherwise - :rtype: bool - """ - return False - - @abc.abstractmethod - def perform_is_always_branch_patch_available(self, data, addr): - """ - ``perform_is_always_branch_patch_available`` implements a check to determine if the instruction represented by - the bytes contained in ``data`` at address addr is a conditional branch that can be made unconditional. - - .. note:: Architecture subclasses should implement this method. - .. warning:: This method should never be called directly. - - :param str data: bytes to be checked - :param int addr: the virtual address of the instruction to be patched - :return: True if the instruction can be patched, False otherwise - :rtype: bool - """ - return False - - @abc.abstractmethod - def perform_is_invert_branch_patch_available(self, data, addr): - """ - ``perform_is_invert_branch_patch_available`` implements a check to determine if the instruction represented by - the bytes contained in ``data`` at address addr is a conditional branch which can be inverted. - - .. note:: Architecture subclasses should implement this method. - .. warning:: This method should never be called directly. - - :param int addr: the virtual address of the instruction to be patched - :return: True if the instruction can be patched, False otherwise - :rtype: bool - """ - return False - - @abc.abstractmethod - def perform_is_skip_and_return_zero_patch_available(self, data, addr): - """ - ``perform_is_skip_and_return_zero_patch_available`` implements a check to determine if the instruction represented by - the bytes contained in ``data`` at address addr is a *call-like* instruction which can made into instructions - that are equivilent to "return 0". For example if ``data`` was the x86 instruction ``call eax`` which could be - converted into ``xor eax,eax`` thus this function would return True. - - .. note:: Architecture subclasses should implement this method. - .. warning:: This method should never be called directly. - - :param str data: bytes to be checked - :param int addr: the virtual address of the instruction to be patched - :return: True if the instruction can be patched, False otherwise - :rtype: bool - """ - return False - - @abc.abstractmethod - def perform_is_skip_and_return_value_patch_available(self, data, addr): - """ - ``perform_is_skip_and_return_value_patch_available`` implements a check to determine if the instruction represented by - the bytes contained in ``data`` at address addr is a *call-like* instruction which can made into instructions - that are equivilent to "return 0". For example if ``data`` was the x86 instruction ``call 0xdeadbeef`` which could be - converted into ``mov eax, 42`` thus this function would return True. - - .. note:: Architecture subclasses should implement this method. - .. warning:: This method should never be called directly. - - :param str data: bytes to be checked - :param int addr: the virtual address of the instruction to be patched - :return: True if the instruction can be patched, False otherwise - :rtype: bool - """ - return False - - @abc.abstractmethod - def perform_convert_to_nop(self, data, addr): - """ - ``perform_convert_to_nop`` implements a method which returns a nop sequence of len(data) bytes long. - - .. note:: Architecture subclasses should implement this method. - .. warning:: This method should never be called directly. - - :param str data: bytes at virtual address ``addr`` - :param int addr: the virtual address of the instruction to be patched - :return: nop sequence of same length as ``data`` or None - :rtype: str or None - """ - return None - - @abc.abstractmethod - def perform_always_branch(self, data, addr): - """ - ``perform_always_branch`` implements a method which converts the branch represented by the bytes in ``data`` to - at ``addr`` to an unconditional branch. - - .. note:: Architecture subclasses should implement this method. - .. warning:: This method should never be called directly. - - :param str data: bytes to be checked - :param int addr: the virtual address of the instruction to be patched - :return: The bytes of the replacement unconditional branch instruction - :rtype: str - """ - return None - - @abc.abstractmethod - def perform_invert_branch(self, data, addr): - """ - ``perform_invert_branch`` implements a method which inverts the branch represented by the bytes in ``data`` to - at ``addr``. - - .. note:: Architecture subclasses should implement this method. - .. warning:: This method should never be called directly. - - :param str data: bytes to be checked - :param int addr: the virtual address of the instruction to be patched - :return: The bytes of the replacement unconditional branch instruction - :rtype: str - """ - return None - - @abc.abstractmethod - def perform_skip_and_return_value(self, data, addr, value): - """ - ``perform_skip_and_return_value`` implements a method which converts a *call-like* instruction represented by - the bytes in ``data`` at ``addr`` to one or more instructions that are equivilent to a function returning a - value. - - .. note:: Architecture subclasses should implement this method. - .. warning:: This method should never be called directly. - - :param str data: bytes to be checked - :param int addr: the virtual address of the instruction to be patched - :param int value: value to be returned - :return: The bytes of the replacement unconditional branch instruction - :rtype: str - """ - return None - - def get_instruction_info(self, data, addr): - """ - ``get_instruction_info`` returns an InstructionInfo object for the instruction at the given virtual address - ``addr`` with data ``data``. - - .. note :: The instruction info object should always set the InstructionInfo.length to the instruction length, \ - and the branches of the proper types shoulde be added if the instruction is a branch. - - :param str data: max_instruction_length bytes from the binary at virtual address ``addr`` - :param int addr: virtual address of bytes in ``data`` - :return: the InstructionInfo for the current instruction - :rtype: InstructionInfo - """ - info = core.BNInstructionInfo() - data = str(data) - buf = (ctypes.c_ubyte * len(data))() - ctypes.memmove(buf, data, len(data)) - if not core.BNGetInstructionInfo(self.handle, buf, addr, len(data), info): - return None - result = InstructionInfo() - result.length = info.length - result.branch_delay = info.branchDelay - for i in xrange(0, info.branchCount): - branch_type = core.BNBranchType_names[info.branchType[i]] - target = info.branchTarget[i] - if info.branchArch[i]: - arch = Architecture(info.branchArch[i]) - else: - arch = None - result.add_branch(branch_type, target, arch) - return result - - def get_instruction_text(self, data, addr): - """ - ``get_instruction_text`` returns a list of InstructionTextToken objects for the instruction at the given virtual - address ``addr`` with data ``data``. - - :param str data: max_instruction_length bytes from the binary at virtual address ``addr`` - :param int addr: virtual address of bytes in ``data`` - :return: an InstructionTextToken list for the current instruction - :rtype: list(InstructionTextToken) - """ - data = str(data) - count = ctypes.c_ulonglong() - length = ctypes.c_ulonglong() - length.value = len(data) - buf = (ctypes.c_ubyte * len(data))() - ctypes.memmove(buf, data, len(data)) - tokens = ctypes.POINTER(core.BNInstructionTextToken)() - if not core.BNGetInstructionText(self.handle, buf, addr, length, tokens, count): - return None, 0 - result = [] - for i in xrange(0, count.value): - token_type = core.BNInstructionTextTokenType_names[tokens[i].type] - text = tokens[i].text - value = tokens[i].value - size = tokens[i].size - operand = tokens[i].operand - result.append(InstructionTextToken(token_type, text, value, size, operand)) - core.BNFreeInstructionText(tokens, count.value) - return result, length.value - - def get_instruction_low_level_il(self, data, addr, il): - """ - ``get_instruction_low_level_il`` appends LowLevelILExpr objects for the instruction at the given virtual - address ``addr`` with data ``data``. - - :param str data: max_instruction_length bytes from the binary at virtual address ``addr`` - :param int addr: virtual address of bytes in ``data`` - :param LowLevelILFunction il: The function the current instruction belongs to - :return: the length of the current instruction - :rtype: int - """ - data = str(data) - length = ctypes.c_ulonglong() - length.value = len(data) - buf = (ctypes.c_ubyte * len(data))() - ctypes.memmove(buf, data, len(data)) - core.BNGetInstructionLowLevelIL(self.handle, buf, addr, length, il.handle) - return length.value - - def get_reg_name(self, reg): - """ - ``get_reg_name`` gets a register name from a register number. - - :param int reg: register number - :return: the corresponding register string - :rtype: str - """ - return core.BNGetArchitectureRegisterName(self.handle, reg) - - def get_flag_name(self, flag): - """ - ``get_flag_name`` gets a flag name from a flag number. - - :param int reg: register number - :return: the corresponding register string - :rtype: str - """ - return core.BNGetArchitectureFlagName(self.handle, flag) - - def get_flag_write_type_name(self, write_type): - """ - ``get_flag_write_type_name`` gets the flag write type name for the given flag. - - :param int write_type: flag - :return: flag write type name - :rtype: str - """ - return core.BNGetArchitectureFlagWriteTypeName(self.handle, write_type) - - def get_flag_by_name(self, flag): - """ - ``get_flag_by_name`` get flag name for flag index. - - :param int flag: flag index - :return: flag name for flag index - :rtype: str - """ - return self._flags[flag] - - def get_flag_write_type_by_name(self, write_type): - """ - ``get_flag_write_type_by_name`` gets the flag write type name for the flage write type. - - :param int write_type: flag write type - :return: flag write type - :rtype: str - """ - return self._flag_write_types[write_type] - - def get_flag_write_low_level_il(self, op, size, write_type, operands, il): - """ - :param LowLevelILOperation op: - :param int size: - :param str write_type: - :param list(str or int) operands: a list of either items that are either string register names or constant \ - integer values - :param LowLevelILFunction il: - :rtype: LowLevelILExpr - """ - operand_list = (core.BNRegisterOrConstant * len(operands))() - for i in xrange(len(operands)): - if isinstance(operands[i], str): - operand_list[i].constant = False - operand_list[i].reg = self._flags[operands[i]] - else: - operand_list[i].constant = True - operand_list[i].value = operands[i] - return LowLevelILExpr(core.BNGetArchitectureFlagWriteLowLevelIL(self.handle, op, size, - self._flag_write_types[write_type], operand_list, len(operand_list), il.handle)) - - def get_default_flag_write_low_level_il(self, op, size, write_type, operands, il): - """ - :param LowLevelILOperation op: - :param int size: - :param str write_type: - :param list(str or int) operands: a list of either items that are either string register names or constant \ - integer values - :param LowLevelILFunction il: - :rtype: LowLevelILExpr index - """ - operand_list = (core.BNRegisterOrConstant * len(operands))() - for i in xrange(len(operands)): - if isinstance(operands[i], str): - operand_list[i].constant = False - operand_list[i].reg = self._flags[operands[i]] - else: - operand_list[i].constant = True - operand_list[i].value = operands[i] - return LowLevelILExpr(core.BNGetDefaultArchitectureFlagWriteLowLevelIL(self.handle, op, size, - self._flag_write_types[write_type], operand_list, len(operand_list), il.handle)) - - def get_flag_condition_low_level_il(self, cond, il): - """ - :param LowLevelILFlagCondition cond: - :param LowLevelILFunction il: - :rtype: LowLevelILExpr - """ - return LowLevelILExpr(core.BNGetArchitectureFlagConditionLowLevelIL(self.handle, cond, il.handle)) - - def get_modified_regs_on_write(self, reg): - """ - ``get_modified_regs_on_write`` returns a list of register names that are modified when ``reg`` is written. - - :param str reg: string register name - :return: list of register names - :rtype: list(str) - """ - reg = core.BNGetArchitectureRegisterByName(self.handle, str(reg)) - count = ctypes.c_ulonglong() - regs = core.BNGetModifiedArchitectureRegistersOnWrite(self.handle, reg, count) - result = [] - for i in xrange(0, count.value): - result.append(core.BNGetArchitectureRegisterName(self.handle, regs[i])) - core.BNFreeRegisterList(regs) - return result - - def assemble(self, code, addr = 0): - """ - ``assemble`` converts the string of assembly instructions ``code`` loaded at virtual address ``addr`` to the - byte representation of those instructions. - - :param str code: string representation of the instructions to be assembled - :param int addr: virtual address that the instructions will be loaded at - :return: the bytes for the assembled instructions or error string - :rtype: (a tuple of instructions and empty string) or (or None and error string) - :Example: - - >>> arch.assemble("je 10") - ('\\x0f\\x84\\x04\\x00\\x00\\x00', '') - >>> - """ - result = DataBuffer() - errors = ctypes.c_char_p() - if not core.BNAssemble(self.handle, code, addr, result.handle, errors): - return None, errors.value - return str(result), errors.value - - def is_never_branch_patch_available(self, data, addr): - """ - ``is_never_branch_patch_available`` determines if the instruction ``data`` at ``addr`` can be made to **never branch**. - - :param str data: bytes for the instruction to be checked - :param int addr: the virtual address of the instruction to be patched - :return: True if the instruction can be patched, False otherwise - :rtype: bool - :Example: - - >>> arch.is_never_branch_patch_available(arch.assemble("je 10")[0], 0) - True - >>> arch.is_never_branch_patch_available(arch.assemble("nop")[0], 0) - False - >>> - """ - data = str(data) - buf = (ctypes.c_ubyte * len(data))() - ctypes.memmove(buf, data, len(data)) - return core.BNIsArchitectureNeverBranchPatchAvailable(self.handle, buf, addr, len(data)) - - def is_always_branch_patch_available(self, data, addr): - """ - ``is_always_branch_patch_available`` determines if the instruction ``data`` at ``addr`` can be made to - **always branch**. - - :param str data: bytes for the instruction to be checked - :param int addr: the virtual address of the instruction to be patched - :return: True if the instruction can be patched, False otherwise - :rtype: bool - :Example: - - >>> arch.is_always_branch_patch_available(arch.assemble("je 10")[0], 0) - True - >>> arch.is_always_branch_patch_available(arch.assemble("nop")[0], 0) - False - >>> - """ - data = str(data) - buf = (ctypes.c_ubyte * len(data))() - ctypes.memmove(buf, data, len(data)) - return core.BNIsArchitectureAlwaysBranchPatchAvailable(self.handle, buf, addr, len(data)) - - def is_invert_branch_patch_available(self, data, addr): - """ - ``is_always_branch_patch_available`` determines if the instruction ``data`` at ``addr`` can be inverted. - - :param str data: bytes for the instruction to be checked - :param int addr: the virtual address of the instruction to be patched - :return: True if the instruction can be patched, False otherwise - :rtype: bool - :Example: - - >>> arch.is_invert_branch_patch_available(arch.assemble("je 10")[0], 0) - True - >>> arch.is_invert_branch_patch_available(arch.assemble("nop")[0], 0) - False - >>> - """ - data = str(data) - buf = (ctypes.c_ubyte * len(data))() - ctypes.memmove(buf, data, len(data)) - return core.BNIsArchitectureInvertBranchPatchAvailable(self.handle, buf, addr, len(data)) - - def is_skip_and_return_zero_patch_available(self, data, addr): - """ - ``is_skip_and_return_zero_patch_available`` determines if the instruction ``data`` at ``addr`` is a *call-like* - instruction that can be made into an instruction *returns zero*. - - :param str data: bytes for the instruction to be checked - :param int addr: the virtual address of the instruction to be patched - :return: True if the instruction can be patched, False otherwise - :rtype: bool - :Example: - - >>> arch.is_skip_and_return_zero_patch_available(arch.assemble("call 0")[0], 0) - True - >>> arch.is_skip_and_return_zero_patch_available(arch.assemble("call eax")[0], 0) - True - >>> arch.is_skip_and_return_zero_patch_available(arch.assemble("jmp eax")[0], 0) - False - >>> - """ - data = str(data) - buf = (ctypes.c_ubyte * len(data))() - ctypes.memmove(buf, data, len(data)) - return core.BNIsArchitectureSkipAndReturnZeroPatchAvailable(self.handle, buf, addr, len(data)) - - def is_skip_and_return_value_patch_available(self, data, addr): - """ - ``is_skip_and_return_zero_patch_available`` determines if the instruction ``data`` at ``addr`` is a *call-like* - instruction that can be made into an instruction *returns a value*. - - :param str data: bytes for the instruction to be checked - :param int addr: the virtual address of the instruction to be patched - :return: True if the instruction can be patched, False otherwise - :rtype: bool - :Example: - - >>> arch.is_skip_and_return_zero_patch_available(arch.assemble("call 0")[0], 0) - True - >>> arch.is_skip_and_return_zero_patch_available(arch.assemble("jmp eax")[0], 0) - False - >>> - """ - data = str(data) - buf = (ctypes.c_ubyte * len(data))() - ctypes.memmove(buf, data, len(data)) - return core.BNIsArchitectureSkipAndReturnValuePatchAvailable(self.handle, buf, addr, len(data)) - - def convert_to_nop(self, data, addr): - """ - ``convert_to_nop`` reads the instruction(s) in ``data`` at virtual address ``addr`` and returns a string of nop - instructions of the same length as data. - - :param str data: bytes for the instruction to be converted - :param int addr: the virtual address of the instruction to be patched - :return: string containing len(data) worth of no-operation instructions - :rtype: str - :Example: - - >>> arch.convert_to_nop("\\x00\\x00", 0) - '\\x90\\x90' - >>> - """ - data = str(data) - buf = (ctypes.c_ubyte * len(data))() - ctypes.memmove(buf, data, len(data)) - if not core.BNArchitectureConvertToNop(self.handle, buf, addr, len(data)): - return None - result = ctypes.create_string_buffer(len(data)) - ctypes.memmove(result, buf, len(data)) - return result.raw - - def always_branch(self, data, addr): - """ - ``always_branch`` reads the instruction(s) in ``data`` at virtual address ``addr`` and returns a string of bytes - of the same length which always branches. - - :param str data: bytes for the instruction to be converted - :param int addr: the virtual address of the instruction to be patched - :return: string containing len(data) which always branches to the same location as the provided instruction - :rtype: str - :Example: - - >>> bytes = arch.always_branch(arch.assemble("je 10")[0], 0) - >>> arch.get_instruction_text(bytes, 0) - (['nop '], 1L) - >>> arch.get_instruction_text(bytes[1:], 0) - (['jmp ', '0x9'], 5L) - >>> - """ - data = str(data) - buf = (ctypes.c_ubyte * len(data))() - ctypes.memmove(buf, data, len(data)) - if not core.BNArchitectureAlwaysBranch(self.handle, buf, addr, len(data)): - return None - result = ctypes.create_string_buffer(len(data)) - ctypes.memmove(result, buf, len(data)) - return result.raw - - def invert_branch(self, data, addr): - """ - ``invert_branch`` reads the instruction(s) in ``data`` at virtual address ``addr`` and returns a string of bytes - of the same length which inverts the branch of provided instruction. - - :param str data: bytes for the instruction to be converted - :param int addr: the virtual address of the instruction to be patched - :return: string containing len(data) which always branches to the same location as the provided instruction - :rtype: str - :Example: - - >>> arch.get_instruction_text(arch.invert_branch(arch.assemble("je 10")[0], 0), 0) - (['jne ', '0xa'], 6L) - >>> arch.get_instruction_text(arch.invert_branch(arch.assemble("jo 10")[0], 0), 0) - (['jno ', '0xa'], 6L) - >>> arch.get_instruction_text(arch.invert_branch(arch.assemble("jge 10")[0], 0), 0) - (['jl ', '0xa'], 6L) - >>> - """ - data = str(data) - buf = (ctypes.c_ubyte * len(data))() - ctypes.memmove(buf, data, len(data)) - if not core.BNArchitectureInvertBranch(self.handle, buf, addr, len(data)): - return None - result = ctypes.create_string_buffer(len(data)) - ctypes.memmove(result, buf, len(data)) - return result.raw - - def skip_and_return_value(self, data, addr, value): - """ - ``skip_and_return_value`` reads the instruction(s) in ``data`` at virtual address ``addr`` and returns a string of - bytes of the same length which doesn't call and instead *return a value*. - - :param str data: bytes for the instruction to be converted - :param int addr: the virtual address of the instruction to be patched - :return: string containing len(data) which always branches to the same location as the provided instruction - :rtype: str - :Example: - - >>> arch.get_instruction_text(arch.skip_and_return_value(arch.assemble("call 10")[0], 0, 0), 0) - (['mov ', 'eax', ', ', '0x0'], 5L) - >>> - """ - data = str(data) - buf = (ctypes.c_ubyte * len(data))() - ctypes.memmove(buf, data, len(data)) - if not core.BNArchitectureSkipAndReturnValue(self.handle, buf, addr, len(data), value): - return None - result = ctypes.create_string_buffer(len(data)) - ctypes.memmove(result, buf, len(data)) - return result.raw - - def is_view_type_constant_defined(self, type_name, const_name): - """ - - :param str type_name: the BinaryView type name of the constant to query - :param str const_name: the constant name to query - :rtype: None - :Example: - - >>> arch.set_view_type_constant("ELF", "R_COPY", ELF_RELOC_COPY) - >>> arch.is_view_type_constant_defined("ELF", "R_COPY") - True - >>> arch.is_view_type_constant_defined("ELF", "NOT_THERE") - False - >>> - """ - return core.BNIsBinaryViewTypeArchitectureConstantDefined(self.handle, type_name, const_name) - - def get_view_type_constant(self, type_name, const_name, default_value = 0): - """ - ``get_view_type_constant`` retrieves the view type constant for the given type_name and const_name. - - :param str type_name: the BinaryView type name of the constant to be retrieved - :param str const_name: the constant name to retrieved - :param int value: optional default value if the type_name is not present. default value is zero. - :return: The BinaryView type constant or the default_value if not found - :rtype: int - :Example: - - >>> ELF_RELOC_COPY = 5 - >>> arch.set_view_type_constant("ELF", "R_COPY", ELF_RELOC_COPY) - >>> arch.get_view_type_constant("ELF", "R_COPY") - 5L - >>> arch.get_view_type_constant("ELF", "NOT_HERE", 100) - 100L - """ - return core.BNGetBinaryViewTypeArchitectureConstant(self.handle, type_name, const_name, default_value) - - def set_view_type_constant(self, type_name, const_name, value): - """ - ``set_view_type_constant`` creates a new binaryview type constant. - - :param str type_name: the BinaryView type name of the constant to be registered - :param str const_name: the constant name to register - :param int value: the value of the constant - :rtype: None - :Example: - - >>> ELF_RELOC_COPY = 5 - >>> arch.set_view_type_constant("ELF", "R_COPY", ELF_RELOC_COPY) - >>> - """ - core.BNSetBinaryViewTypeArchitectureConstant(self.handle, type_name, const_name, value) - - def parse_types_from_source(self, source, filename = None, include_dirs = []): - """ - ``parse_types_from_source`` parses the source string and any needed headers searching for them in - the optional list of directories provided in ``include_dirs``. - - :param str source: source string to be parsed - :param str filename: optional source filename - :param list(str) include_dirs: optional list of string filename include directories - :return: a tuple of py:class:`TypeParserResult` and error string - :rtype: tuple(TypeParserResult,str) - :Example: - - >>> arch.parse_types_from_source('int foo;\\nint bar(int x);\\nstruct bas{int x,y;};\\n') - ({types: {'bas': }, variables: {'foo': }, functions:{'bar': - }}, '') - >>> - """ - - if filename is None: - filename = "input" - dir_buf = (ctypes.c_char_p * len(include_dirs))() - for i in xrange(0, len(include_dirs)): - dir_buf[i] = str(include_dirs[i]) - parse = core.BNTypeParserResult() - errors = ctypes.c_char_p() - result = core.BNParseTypesFromSource(self.handle, source, filename, parse, errors, dir_buf, len(include_dirs)) - error_str = errors.value - core.BNFreeString(ctypes.cast(errors, ctypes.POINTER(ctypes.c_byte))) - if not result: - return (None, error_str) - types = {} - variables = {} - functions = {} - for i in xrange(0, parse.typeCount): - types[parse.types[i].name] = Type(core.BNNewTypeReference(parse.types[i].type)) - for i in xrange(0, parse.variableCount): - variables[parse.variables[i].name] = Type(core.BNNewTypeReference(parse.variables[i].type)) - for i in xrange(0, parse.functionCount): - functions[parse.functions[i].name] = Type(core.BNNewTypeReference(parse.functions[i].type)) - BNFreeTypeParserResult(parse) - return (TypeParserResult(types, variables, functions), error_str) - - def parse_types_from_source_file(self, filename, include_dirs = []): - """ - ``parse_types_from_source_file`` parses the source file ``filename`` and any needed headers searching for them in - the optional list of directories provided in ``include_dirs``. - - :param str filename: filename of file to be parsed - :param list(str) include_dirs: optional list of string filename include directories - :return: a tuple of py:class:`TypeParserResult` and error string - :rtype: tuple(TypeParserResult, str) - :Example: - - >>> file = "/Users/binja/tmp.c" - >>> open(file).read() - 'int foo;\\nint bar(int x);\\nstruct bas{int x,y;};\\n' - >>> arch.parse_types_from_source_file(file) - ({types: {'bas': }, variables: {'foo': }, functions: - {'bar': }}, '') - >>> - """ - dir_buf = (ctypes.c_char_p * len(include_dirs))() - for i in xrange(0, len(include_dirs)): - dir_buf[i] = str(include_dirs[i]) - parse = core.BNTypeParserResult() - errors = ctypes.c_char_p() - result = core.BNParseTypesFromSourceFile(self.handle, filename, parse, errors, dir_buf, len(include_dirs)) - error_str = errors.value - core.BNFreeString(ctypes.cast(errors, ctypes.POINTER(ctypes.c_byte))) - if not result: - return (None, error_str) - types = {} - variables = {} - functions = {} - for i in xrange(0, parse.typeCount): - types[parse.types[i].name] = Type(core.BNNewTypeReference(parse.types[i].type)) - for i in xrange(0, parse.variableCount): - variables[parse.variables[i].name] = Type(core.BNNewTypeReference(parse.variables[i].type)) - for i in xrange(0, parse.functionCount): - functions[parse.functions[i].name] = Type(core.BNNewTypeReference(parse.functions[i].type)) - BNFreeTypeParserResult(parse) - return (TypeParserResult(types, variables, functions), error_str) - - def register_calling_convention(self, cc): - """ - ``register_calling_convention`` registers a new calling convention for the Architecture. - - :param CallingConvention cc: CallingConvention object to be registered - :rtype: None - """ - core.BNRegisterCallingConvention(self.handle, cc.handle) - -class ReferenceSource(object): - def __init__(self, func, arch, addr): - self.function = func - self.arch = arch - self.address = addr - - def __repr__(self): - if self.arch: - return "" % (self.arch.name, self.address) - else: - return "" % self.address - -class LowLevelILLabel(object): - def __init__(self, handle = None): - if handle is None: - self.handle = (core.BNLowLevelILLabel * 1)() - core.BNLowLevelILInitLabel(self.handle) - else: - self.handle = handle - -class LowLevelILInstruction(object): - """ - ``class LowLevelILInstruction`` Low Level Intermediate Language Instructions are infinite length tree-based - instructions. Tree-based instructions use infix notation with the left hand operand being the destination operand. - Infix notation is thus more natural to read than other notations (e.g. x86 ``mov eax, 0`` vs. LLIL ``eax = 0``). - """ - - ILOperations = { - core.LLIL_NOP: [], - core.LLIL_SET_REG: [("dest", "reg"), ("src", "expr")], - core.LLIL_SET_REG_SPLIT: [("hi", "reg"), ("lo", "reg"), ("src", "expr")], - core.LLIL_SET_FLAG: [("dest", "flag"), ("src", "expr")], - core.LLIL_LOAD: [("src", "expr")], - core.LLIL_STORE: [("dest", "expr"), ("src", "expr")], - core.LLIL_PUSH: [("src", "expr")], - core.LLIL_POP: [], - core.LLIL_REG: [("src", "reg")], - core.LLIL_CONST: [("value", "int")], - core.LLIL_FLAG: [("src", "flag")], - core.LLIL_FLAG_BIT: [("src", "flag"), ("bit", "int")], - core.LLIL_ADD: [("left", "expr"), ("right", "expr")], - core.LLIL_ADC: [("left", "expr"), ("right", "expr")], - core.LLIL_SUB: [("left", "expr"), ("right", "expr")], - core.LLIL_SBB: [("left", "expr"), ("right", "expr")], - core.LLIL_AND: [("left", "expr"), ("right", "expr")], - core.LLIL_OR: [("left", "expr"), ("right", "expr")], - core.LLIL_XOR: [("left", "expr"), ("right", "expr")], - core.LLIL_LSL: [("left", "expr"), ("right", "expr")], - core.LLIL_LSR: [("left", "expr"), ("right", "expr")], - core.LLIL_ASR: [("left", "expr"), ("right", "expr")], - core.LLIL_ROL: [("left", "expr"), ("right", "expr")], - core.LLIL_RLC: [("left", "expr"), ("right", "expr")], - core.LLIL_ROR: [("left", "expr"), ("right", "expr")], - core.LLIL_RRC: [("left", "expr"), ("right", "expr")], - core.LLIL_MUL: [("left", "expr"), ("right", "expr")], - core.LLIL_MULU_DP: [("left", "expr"), ("right", "expr")], - core.LLIL_MULS_DP: [("left", "expr"), ("right", "expr")], - core.LLIL_DIVU: [("left", "expr"), ("right", "expr")], - core.LLIL_DIVU_DP: [("hi", "expr"), ("lo", "expr"), ("right", "expr")], - core.LLIL_DIVS: [("left", "expr"), ("right", "expr")], - core.LLIL_DIVS_DP: [("hi", "expr"), ("lo", "expr"), ("right", "expr")], - core.LLIL_MODU: [("left", "expr"), ("right", "expr")], - core.LLIL_MODU_DP: [("hi", "expr"), ("lo", "expr"), ("right", "expr")], - core.LLIL_MODS: [("left", "expr"), ("right", "expr")], - core.LLIL_MODS_DP: [("hi", "expr"), ("lo", "expr"), ("right", "expr")], - core.LLIL_NEG: [("src", "expr")], - core.LLIL_NOT: [("src", "expr")], - core.LLIL_SX: [("src", "expr")], - core.LLIL_ZX: [("src", "expr")], - core.LLIL_JUMP: [("dest", "expr")], - core.LLIL_JUMP_TO: [("dest", "expr"), ("targets", "int_list")], - core.LLIL_CALL: [("dest", "expr")], - core.LLIL_RET: [("dest", "expr")], - core.LLIL_NORET: [], - core.LLIL_IF: [("condition", "expr"), ("true", "int"), ("false", "int")], - core.LLIL_GOTO: [("dest", "int")], - core.LLIL_FLAG_COND: [("condition", "cond")], - core.LLIL_CMP_E: [("left", "expr"), ("right", "expr")], - core.LLIL_CMP_NE: [("left", "expr"), ("right", "expr")], - core.LLIL_CMP_SLT: [("left", "expr"), ("right", "expr")], - core.LLIL_CMP_ULT: [("left", "expr"), ("right", "expr")], - core.LLIL_CMP_SLE: [("left", "expr"), ("right", "expr")], - core.LLIL_CMP_ULE: [("left", "expr"), ("right", "expr")], - core.LLIL_CMP_SGE: [("left", "expr"), ("right", "expr")], - core.LLIL_CMP_UGE: [("left", "expr"), ("right", "expr")], - core.LLIL_CMP_SGT: [("left", "expr"), ("right", "expr")], - core.LLIL_CMP_UGT: [("left", "expr"), ("right", "expr")], - core.LLIL_TEST_BIT: [("left", "expr"), ("right", "expr")], - core.LLIL_BOOL_TO_INT: [("src", "expr")], - core.LLIL_SYSCALL: [], - core.LLIL_BP: [], - core.LLIL_TRAP: [("value", "int")], - core.LLIL_UNDEF: [], - core.LLIL_UNIMPL: [], - core.LLIL_UNIMPL_MEM: [("src", "expr")] - } - - def __init__(self, func, expr_index, instr_index = None): - instr = core.BNGetLowLevelILByIndex(func.handle, expr_index) - self.function = func - self.expr_index = expr_index - self.instr_index = instr_index - self.operation = instr.operation - self.operation_name = core.BNLowLevelILOperation_names[instr.operation] - self.size = instr.size - self.address = instr.address - self.source_operand = instr.sourceOperand - if instr.flags == 0: - self.flags = None - else: - self.flags = func.arch.get_flag_write_type_name(instr.flags) - if self.source_operand == 0xffffffff: - self.source_operand = None - operands = LowLevelILInstruction.ILOperations[instr.operation] - self.operands = [] - for i in xrange(0, len(operands)): - name, operand_type = operands[i] - if operand_type == "int": - value = instr.operands[i] - elif operand_type == "expr": - value = LowLevelILInstruction(func, instr.operands[i]) - elif operand_type == "reg": - if (instr.operands[i] & 0x80000000) != 0: - value = instr.operands[i] - else: - value = func.arch.get_reg_name(instr.operands[i]) - elif operand_type == "flag": - value = func.arch.get_flag_name(instr.operands[i]) - elif operand_type == "cond": - value = core.BNLowLevelILFlagCondition_names[instr.operands[i]] - elif operand_type == "int_list": - count = ctypes.c_ulonglong() - operands = core.BNLowLevelILGetOperandList(func.handle, self.expr_index, i, count) - value = [] - for i in xrange(count.value): - value.append(operands[i]) - core.BNLowLevelILFreeOperandList(operands) - self.operands.append(value) - self.__dict__[name] = value - - def __str__(self): - tokens = self.tokens - if tokens is None: - return "invalid" - result = "" - for token in tokens: - result += token.text - return result - - def __repr__(self): - return "" % str(self) - - @property - def tokens(self): - """LLIL tokens (read-only)""" - count = ctypes.c_ulonglong() - tokens = ctypes.POINTER(core.BNInstructionTextToken)() - if (self.instr_index is not None) and (self.function.source_function is not None): - if not core.BNGetLowLevelILInstructionText(self.function.handle, self.function.source_function.handle, - self.function.arch.handle, self.instr_index, tokens, count): - return None - else: - if not core.BNGetLowLevelILExprText(self.function.handle, self.function.arch.handle, - self.expr_index, tokens, count): - return None - result = [] - for i in xrange(0, count.value): - token_type = core.BNInstructionTextTokenType_names[tokens[i].type] - text = tokens[i].text - value = tokens[i].value - size = tokens[i].size - operand = tokens[i].operand - result.append(InstructionTextToken(token_type, text, value, size, operand)) - core.BNFreeInstructionText(tokens, count.value) - return result - - def __setattr__(self, name, value): - try: - object.__setattr__(self,name,value) - except AttributeError: - raise AttributeError, "attribute '%s' is read only" % name - -class LowLevelILExpr(object): - """ - ``class LowLevelILExpr`` hold the index of IL Expressions. - - .. note:: This class shouldn't be instantiated directly. Rather the helper members of LowLevelILFunction should be \ - used instead. - """ - def __init__(self, index): - self.index = index - -class LowLevelILFunction(object): - """ - ``class LowLevelILFunction`` contains the list of LowLevelILExpr objects that make up a function. LowLevelILExpr - objects can be added to the LowLevelILFunction by calling ``append`` and passing the result of the various class - methods which return LowLevelILExpr objects. - - - LowLevelILFlagCondition values used as parameters in the ``flag_condition`` method. - - ======================= ========== =============================== - LowLevelILFlagCondition Operator Description - ======================= ========== =============================== - LLFC_E == Equal - LLFC_NE != Not equal - LLFC_SLT s< Signed less than - LLFC_ULT u< Unsigned less than - LLFC_SLE s<= Signed less than or equal - LLFC_ULE u<= Unsigned less than or equal - LLFC_SGE s>= Signed greater than or equal - LLFC_UGE u>= Unsigned greater than or equal - LLFC_SGT s> Signed greather than - LLFC_UGT u> Unsigned greater than - LLFC_NEG - Negative - LLFC_POS + Positive - LLFC_O overflow Overflow - LLFC_NO !overflow No overflow - ======================= ========== =============================== - """ - def __init__(self, arch, handle = None, source_func = None): - self.arch = arch - self.source_function = source_func - if handle is not None: - self.handle = core.handle_of_type(handle, core.BNLowLevelILFunction) - else: - func_handle = None - if self.source_function is not None: - func_handle = self.source_function.handle - self.handle = core.BNCreateLowLevelILFunction(arch.handle, func_handle) - - def __del__(self): - core.BNFreeLowLevelILFunction(self.handle) - - @property - def current_address(self): - """Current IL Address (read/write)""" - return core.BNLowLevelILGetCurrentAddress(self.handle) - - @current_address.setter - def current_address(self, value): - core.BNLowLevelILSetCurrentAddress(self.handle, value) - - @property - def temp_reg_count(self): - """Number of temporary registers (read-only)""" - return core.BNGetLowLevelILTemporaryRegisterCount(self.handle) - - @property - def temp_flag_count(self): - """Number of temporary flags (read-only)""" - return core.BNGetLowLevelILTemporaryFlagCount(self.handle) - - @property - def basic_blocks(self): - """list of LowLevelILBasicBlock objects (read-only)""" - count = ctypes.c_ulonglong() - blocks = core.BNGetLowLevelILBasicBlockList(self.handle, count) - result = [] - view = None - if self.source_function is not None: - view = self.source_function.view - for i in xrange(0, count.value): - result.append(LowLevelILBasicBlock(view, core.BNNewBasicBlockReference(blocks[i]), self)) - core.BNFreeBasicBlockList(blocks, count.value) - return result - - def __setattr__(self, name, value): - try: - object.__setattr__(self,name,value) - except AttributeError: - raise AttributeError, "attribute '%s' is read only" % name - - def __len__(self): - return int(core.BNGetLowLevelILInstructionCount(self.handle)) - - def __getitem__(self, i): - if isinstance(i, slice) or isinstance(i, tuple): - raise IndexError, "expected integer instruction index" - if isinstance(i, LowLevelILExpr): - return LowLevelILInstruction(self, i.index) - if (i < 0) or (i >= len(self)): - raise IndexError, "index out of range" - return LowLevelILInstruction(self, core.BNGetLowLevelILIndexForInstruction(self.handle, i), i) - - def __setitem__(self, i, j): - raise IndexError, "instruction modification not implemented" - - def __iter__(self): - count = ctypes.c_ulonglong() - blocks = core.BNGetLowLevelILBasicBlockList(self.handle, count) - view = None - if self.source_function is not None: - view = self.source_function.view - try: - for i in xrange(0, count.value): - yield LowLevelILBasicBlock(view, core.BNNewBasicBlockReference(blocks[i]), self) - finally: - core.BNFreeBasicBlockList(blocks, count.value) - - def clear_indirect_branches(self): - core.BNLowLevelILClearIndirectBranches(self.handle) - - def set_indirect_branches(self, branches): - branch_list = (core.BNArchitectureAndAddress * len(branches))() - for i in xrange(len(branches)): - branch_list[i].arch = branches[i][0].handle - branch_list[i].address = branches[i][1] - core.BNLowLevelILSetIndirectBranches(self.handle, branch_list, len(branches)) - - def expr(self, operation, a = 0, b = 0, c = 0, d = 0, size = 0, flags = None): - if isinstance(operation, str): - operation = core.BNLowLevelILOperation_by_name[operation] - if isinstance(flags, str): - flags = self.arch.get_flag_write_type_by_name(flags) - elif flags is None: - flags = 0 - return LowLevelILExpr(core.BNLowLevelILAddExpr(self.handle, operation, size, flags, a, b, c, d)) - - def append(self, expr): - """ - ``append`` adds the LowLevelILExpr ``expr`` to the current LowLevelILFunction. - - :param LowLevelILExpr expr: the LowLevelILExpr to add to the current LowLevelILFunction - :return: number of LowLevelILExpr in the current function - :rtype: int - """ - return core.BNLowLevelILAddInstruction(self.handle, expr.index) - - def nop(self): - """ - ``nop`` no operation, this instruction does nothing - - :return: The no operation expression - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_NOP) - - def set_reg(self, size, reg, value, flags = 0): - """ - ``set_reg`` sets the register ``reg`` of size ``size`` to the expression ``value`` - - :param int size: size of the register parameter in bytes - :param str reg: the register name - :param LowLevelILExpr value: an expression to set the register to - :param str flags: which flags are set by this operation - :return: The expression ``reg = value`` - :rtype: LowLevelILExpr - """ - if isinstance(reg, str): - reg = self.arch.regs[reg].index - return self.expr(core.LLIL_SET_REG, reg, value.index, size = size, flags = flags) - - def set_reg_split(self, size, hi, lo, value, flags = 0): - """ - ``set_reg_split`` uses ``hi`` and ``lo`` as a single extended register setting ``hi:lo`` to the expression - ``value``. - - :param int size: size of the register parameter in bytes - :param str hi: the high register name - :param str lo: the low register name - :param LowLevelILExpr value: an expression to set the split regiters to - :param str flags: which flags are set by this operation - :return: The expression ``hi:lo = value`` - :rtype: LowLevelILExpr - """ - if isinstance(hi, str): - hi = self.arch.regs[hi].index - if isinstance(lo, str): - lo = self.arch.regs[lo].index - return self.expr(core.LLIL_SET_REG_SPLIT, hi, lo, value.index, size = size, flags = flags) - - def set_flag(self, flag, value): - """ - ``set_flag`` sets the flag ``flag`` to the LowLevelILExpr ``value`` - - :param str flag: the low register name - :param LowLevelILExpr value: an expression to set the flag to - :return: The expression FLAG.flag = value - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_SET_FLAG, self.arch.get_flag_by_name(flag), value.index) - - def load(self, size, addr): - """ - ``laod`` Reads ``size`` bytes from the expression ``addr`` - - :param int size: number of bytes to read - :param LowLevelILExpr addr: the expression to read memory from - :return: The expression ``[addr].size`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_LOAD, addr.index, size = size) - - def store(self, size, addr, value): - """ - ``store`` Writes ``size`` bytes to expression ``addr`` read from expression ``value`` - - :param int size: number of bytes to write - :param LowLevelILExpr addr: the expression to write to - :param LowLevelILExpr value: the expression to be written - :return: The expression ``[addr].size = value`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_STORE, addr.index, value.index, size = size) - - def push(self, size, value): - """ - ``push`` writes ``size`` bytes from expression ``value`` to the stack, adjusting the stack by ``size``. - - :param int size: number of bytes to write and adjust the stack by - :param LowLevelILExpr value: the expression to write - :return: The expression push(value) - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_PUSH, value.index, size = size) - - def pop(self, size): - """ - ``pop`` reads ``size`` bytes from the stack, adjusting the stack by ``size``. - - :param int size: number of bytes to read from the stack - :return: The expression ``pop`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_POP, size = size) - - def reg(self, size, reg): - """ - ``reg`` returns a register of size ``size`` with name ``name`` - - :param int size: the size of the register in bytes - :param str reg: the name of the register - :return: A register expression for the given string - :rtype: LowLevelILExpr - """ - if isinstance(reg, str): - reg = self.arch.regs[reg].index - return self.expr(core.LLIL_REG, reg, size = size) - - def const(self, size, value): - """ - ``const`` returns an expression for the constant integer ``value`` with size ``size`` - - :param int size: the size of the constant in bytes - :param int value: integer value of the constant - :return: A constant expression of given value and size - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_CONST, value, size = size) - - def flag(self, reg): - """ - ``flag`` returns a flag expression for the given flag name. - - :param str reg: name of the flag expression to retrieve - :return: A flag expression of given flag name - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_FLAG, self.arch.get_flag_by_name(reg)) - - def flag_bit(self, size, reg, bit): - """ - ``flag_bit`` sets the flag named ``reg`` and size ``size`` to the constant integer value ``bit`` - - :param int size: the size of the flag - :param str reg: flag value - :param int bit: integer value to set the bit to - :return: A constant expression of given value and size ``FLAG.reg = bit`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_FLAG_BIT, self.arch.get_flag_by_name(reg), bit, size = size) - - def add(self, size, a, b, flags = None): - """ - ``add`` adds expression ``a`` to expression ``b`` potentially setting flags ``flags`` and returning - an expression of ``size`` bytes. - - :param int size: the size of the result in bytes - :param LowLevelILExpr a: LHS expression - :param LowLevelILExpr b: RHS expression - :param str flags: flags to set - :return: The expression ``add.{}(a, b)`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_ADD, a.index, b.index, size = size, flags = flags) - - def add_carry(self, size, a, b, flags = None): - """ - ``add_carry`` adds with carry expression ``a`` to expression ``b`` potentially setting flags ``flags`` and returning - an expression of ``size`` bytes. - - :param int size: the size of the result in bytes - :param LowLevelILExpr a: LHS expression - :param LowLevelILExpr b: RHS expression - :param str flags: flags to set - :return: The expression ``adc.{}(a, b)`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_ADC, a.index, b.index, size = size, flags = flags) - - def sub(self, size, a, b, flags = None): - """ - ``sub`` subtracts expression ``b`` from expression ``a`` potentially setting flags ``flags`` and returning - an expression of ``size`` bytes. - - :param int size: the size of the result in bytes - :param LowLevelILExpr a: LHS expression - :param LowLevelILExpr b: RHS expression - :param str flags: flags to set - :return: The expression ``sub.{}(a, b)`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_SUB, a.index, b.index, size = size, flags = flags) - - def sub_borrow(self, size, a, b, flags = None): - """ - ``sub_borrow`` subtracts with borrow expression ``b`` from expression ``a`` potentially setting flags ``flags`` - and returning an expression of ``size`` bytes. - - :param int size: the size of the result in bytes - :param LowLevelILExpr a: LHS expression - :param LowLevelILExpr b: RHS expression - :param str flags: flags to set - :return: The expression ``sbc.{}(a, b)`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_SBB, a.index, b.index, size = size, flags = flags) - - def and_expr(self, size, a, b, flags = None): - """ - ``and_expr`` bitwise and's expression ``a`` and expression ``b`` potentially setting flags ``flags`` - and returning an expression of ``size`` bytes. - - :param int size: the size of the result in bytes - :param LowLevelILExpr a: LHS expression - :param LowLevelILExpr b: RHS expression - :param str flags: optional, flags to set - :return: The expression ``and.{}(a, b)`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_AND, a.index, b.index, size = size, flags = flags) - - def or_expr(self, size, a, b, flags = None): - """ - ``or_expr`` bitwise or's expression ``a`` and expression ``b`` potentially setting flags ``flags`` - and returning an expression of ``size`` bytes. - - :param int size: the size of the result in bytes - :param LowLevelILExpr a: LHS expression - :param LowLevelILExpr b: RHS expression - :param str flags: optional, flags to set - :return: The expression ``or.{}(a, b)`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_OR, a.index, b.index, size = size, flags = flags) - - def xor_expr(self, size, a, b, flags = None): - """ - ``xor_expr`` xor's expression ``a`` with expression ``b`` potentially setting flags ``flags`` - and returning an expression of ``size`` bytes. - - :param int size: the size of the result in bytes - :param LowLevelILExpr a: LHS expression - :param LowLevelILExpr b: RHS expression - :param str flags: optional, flags to set - :return: The expression ``xor.{}(a, b)`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_XOR, a.index, b.index, size = size, flags = flags) - - def shift_left(self, size, a, b, flags = None): - """ - ``shift_left`` subtracts with borrow expression ``b`` from expression ``a`` potentially setting flags ``flags`` - and returning an expression of ``size`` bytes. - - :param int size: the size of the result in bytes - :param LowLevelILExpr a: LHS expression - :param LowLevelILExpr b: RHS expression - :param str flags: optional, flags to set - :return: The expression ``lsl.{}(a, b)`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_LSL, a.index, b.index, size = size, flags = flags) - - def logical_shift_right(self, size, a, b, flags = None): - """ - ``logical_shift_right`` shifts logically right expression ``a`` by expression ``b`` potentially setting flags - ``flags``and returning an expression of ``size`` bytes. - - :param int size: the size of the result in bytes - :param LowLevelILExpr a: LHS expression - :param LowLevelILExpr b: RHS expression - :param str flags: optional, flags to set - :return: The expression ``lsr.{}(a, b)`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_LSR, a.index, b.index, size = size, flags = flags) - - def arith_shift_right(self, size, a, b, flags = None): - """ - ``arith_shift_right`` shifts arithmatic right expression ``a`` by expression ``b`` potentially setting flags - ``flags`` and returning an expression of ``size`` bytes. - - :param int size: the size of the result in bytes - :param LowLevelILExpr a: LHS expression - :param LowLevelILExpr b: RHS expression - :param str flags: optional, flags to set - :return: The expression ``asr.{}(a, b)`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_ASR, a.index, b.index, size = size, flags = flags) - - def rotate_left(self, size, a, b, flags = None): - """ - ``rotate_left`` bitwise rotates left expression ``a`` by expression ``b`` potentially setting flags ``flags`` - and returning an expression of ``size`` bytes. - - :param int size: the size of the result in bytes - :param LowLevelILExpr a: LHS expression - :param LowLevelILExpr b: RHS expression - :param str flags: optional, flags to set - :return: The expression ``rol.{}(a, b)`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_ROL, a.index, b.index, size = size, flags = flags) - - def rotate_left_carry(self, size, a, b, flags = None): - """ - ``rotate_left_carry`` bitwise rotates left with carry expression ``a`` by expression ``b`` potentially setting - flags ``flags`` and returning an expression of ``size`` bytes. - - :param int size: the size of the result in bytes - :param LowLevelILExpr a: LHS expression - :param LowLevelILExpr b: RHS expression - :param str flags: optional, flags to set - :return: The expression ``rcl.{}(a, b)`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_RLC, a.index, b.index, size = size, flags = flags) - - def rotate_right(self, size, a, b, flags = None): - """ - ``rotate_right`` bitwise rotates right expression ``a`` by expression ``b`` potentially setting flags ``flags`` - and returning an expression of ``size`` bytes. - - :param int size: the size of the result in bytes - :param LowLevelILExpr a: LHS expression - :param LowLevelILExpr b: RHS expression - :param str flags: optional, flags to set - :return: The expression ``ror.{}(a, b)`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_ROR, a.index, b.index, size = size, flags = flags) - - def rotate_right_carry(self, size, a, b, flags = None): - """ - ``rotate_right_carry`` bitwise rotates right with carry expression ``a`` by expression ``b`` potentially setting - flags ``flags`` and returning an expression of ``size`` bytes. - - :param int size: the size of the result in bytes - :param LowLevelILExpr a: LHS expression - :param LowLevelILExpr b: RHS expression - :param str flags: optional, flags to set - :return: The expression ``rcr.{}(a, b)`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_RRC, a.index, b.index, size = size, flags = flags) - - def mult(self, size, a, b, flags = None): - """ - ``mult`` multiplies expression ``a`` by expression ``b`` potentially setting flags ``flags`` and returning an - expression of ``size`` bytes. - - :param int size: the size of the result in bytes - :param LowLevelILExpr a: LHS expression - :param LowLevelILExpr b: RHS expression - :param str flags: optional, flags to set - :return: The expression ``sbc.{}(a, b)`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_MUL, a.index, b.index, size = size, flags = flags) - - def mult_double_prec_signed(self, size, a, b, flags = None): - """ - ``mult_double_prec_signed`` multiplies signed with double precision expression ``a`` by expression ``b`` - potentially setting flags ``flags`` and returning an expression of ``size`` bytes. - - :param int size: the size of the result in bytes - :param LowLevelILExpr a: LHS expression - :param LowLevelILExpr b: RHS expression - :param str flags: optional, flags to set - :return: The expression ``muls.dp.{}(a, b)`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_MULS_DP, a.index, b.index, size = size, flags = flags) - - def mult_double_prec_unsigned(self, size, a, b, flags = None): - """ - ``mult_double_prec_unsigned`` multiplies unsigned with double precision expression ``a`` by expression ``b`` - potentially setting flags ``flags`` and returning an expression of ``size`` bytes. - - :param int size: the size of the result in bytes - :param LowLevelILExpr a: LHS expression - :param LowLevelILExpr b: RHS expression - :param str flags: optional, flags to set - :return: The expression ``muls.dp.{}(a, b)`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_MULU_DP, a.index, b.index, size = size, flags = flags) - - def div_signed(self, size, a, b, flags = None): - """ - ``div_signed`` signed divide expression ``a`` by expression ``b`` potentially setting flags ``flags`` - and returning an expression of ``size`` bytes. - - :param int size: the size of the result in bytes - :param LowLevelILExpr a: LHS expression - :param LowLevelILExpr b: RHS expression - :param str flags: optional, flags to set - :return: The expression ``divs.{}(a, b)`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_DIVS, a.index, b.index, size = size, flags = flags) - - def div_double_prec_signed(self, size, hi, lo, b, flags = None): - """ - ``div_double_prec_signed`` signed double precision divide using expression ``hi`` and expression ``lo`` as a single - double precision register by expression ``b`` potentially setting flags ``flags`` and returning an expression - of ``size`` bytes. - - :param int size: the size of the result in bytes - :param LowLevelILExpr hi: high LHS expression - :param LowLevelILExpr lo: low LHS expression - :param LowLevelILExpr b: RHS expression - :param str flags: optional, flags to set - :return: The expression ``divs.dp.{}(hi:lo, b)`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_DIVS_DP, hi.index, lo.index, b.index, size = size, flags = flags) - - def div_unsigned(self, size, a, b, flags = None): - """ - ``div_unsigned`` unsigned divide expression ``a`` by expression ``b`` potentially setting flags ``flags`` - and returning an expression of ``size`` bytes. - - :param int size: the size of the result in bytes - :param LowLevelILExpr a: LHS expression - :param LowLevelILExpr b: RHS expression - :param str flags: optional, flags to set - :return: The expression ``divs.{}(a, b)`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_DIVS, a.index, b.index, size = size, flags = flags) - - def div_double_prec_unsigned(self, size, hi, lo, b, flags = None): - """ - ``div_double_prec_unsigned`` unsigned double precision divide using expression ``hi`` and expression ``lo`` as - a single double precision register by expression ``b`` potentially setting flags ``flags`` and returning an - expression of ``size`` bytes. - - :param int size: the size of the result in bytes - :param LowLevelILExpr hi: high LHS expression - :param LowLevelILExpr lo: low LHS expression - :param LowLevelILExpr b: RHS expression - :param str flags: optional, flags to set - :return: The expression ``divs.dp.{}(hi:lo, b)`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_DIVS_DP, hi.index, lo.index, b.index, size = size, flags = flags) - - def mod_signed(self, size, a, b, flags = None): - """ - ``mod_signed`` signed modulus expression ``a`` by expression ``b`` potentially setting flags ``flags`` - and returning an expression of ``size`` bytes. - - :param int size: the size of the result in bytes - :param LowLevelILExpr a: LHS expression - :param LowLevelILExpr b: RHS expression - :param str flags: optional, flags to set - :return: The expression ``mods.{}(a, b)`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_MODS, a.index, b.index, size = size, flags = flags) - - def mod_double_prec_signed(self, size, hi, lo, b, flags = None): - """ - ``mod_double_prec_signed`` signed double precision modulus using expression ``hi`` and expression ``lo`` as a single - double precision register by expression ``b`` potentially setting flags ``flags`` and returning an expression - of ``size`` bytes. - - :param int size: the size of the result in bytes - :param LowLevelILExpr hi: high LHS expression - :param LowLevelILExpr lo: low LHS expression - :param LowLevelILExpr b: RHS expression - :param str flags: optional, flags to set - :return: The expression ``mods.dp.{}(hi:lo, b)`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_MODS_DP, hi.index, lo.index, b.index, size = size, flags = flags) - - def mod_unsigned(self, size, a, b, flags = None): - """ - ``mod_unsigned`` unsigned modulus expression ``a`` by expression ``b`` potentially setting flags ``flags`` - and returning an expression of ``size`` bytes. - - :param int size: the size of the result in bytes - :param LowLevelILExpr a: LHS expression - :param LowLevelILExpr b: RHS expression - :param str flags: optional, flags to set - :return: The expression ``modu.{}(a, b)`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_MODS, a.index, b.index, size = size, flags = flags) - - def mod_double_prec_unsigned(self, size, hi, lo, b, flags = None): - """ - ``mod_double_prec_unsigned`` unsigned double precision modulus using expression ``hi`` and expression ``lo`` as - a single double precision register by expression ``b`` potentially setting flags ``flags`` and returning an - expression of ``size`` bytes. - - :param int size: the size of the result in bytes - :param LowLevelILExpr hi: high LHS expression - :param LowLevelILExpr lo: low LHS expression - :param LowLevelILExpr b: RHS expression - :param str flags: optional, flags to set - :return: The expression ``modu.dp.{}(hi:lo, b)`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_MODS_DP, hi.index, lo.index, b.index, size = size, flags = flags) - - def neg_expr(self, size, value, flags = None): - """ - ``neg_expr`` two's complement sign negation of expression ``value`` of size ``size`` potentially setting flags - - :param int size: the size of the result in bytes - :param LowLevelILExpr value: the expression to negate - :param str flags: optional, flags to set - :return: The expression ``neg.{}(value)`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_NEG, value.index, size = size, flags = flags) - - def not_expr(self, size, value, flags = None): - """ - ``not_expr`` bitwise inverse of expression ``value`` of size ``size`` potentially setting flags - - :param int size: the size of the result in bytes - :param LowLevelILExpr value: the expression to bitwise invert - :param str flags: optional, flags to set - :return: The expression ``not.{}(value)`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_NOT, value.index, size = size, flags = flags) - - def sign_extend(self, size, value): - """ - ``sign_extend`` two's complement sign-extends the expression in ``value`` to ``size`` bytes - - :param int size: the size of the result in bytes - :param LowLevelILExpr value: the expression to sign extend - :return: The expression ``sx.(value)`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_SX, value.index, size = size) - - def zero_extend(self, size, value): - """ - ``sign_extend`` zero-extends the expression in ``value`` to ``size`` bytes - - :param int size: the size of the result in bytes - :param LowLevelILExpr value: the expression to zero extend - :return: The expression ``sx.(value)`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_ZX, value.index, size = size) - - def jump(self, dest): - """ - ``jump`` returns an expression which jumps (branches) to the expression ``dest`` - - :param LowLevelILExpr dest: the expression to jump to - :return: The expression ``jump(dest)`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_JUMP, dest.index) - - def call(self, dest): - """ - ``call`` returns an expression which first pushes the address of the next instruction onto the stack then jumps - (branches) to the expression ``dest`` - - :param LowLevelILExpr dest: the expression to call - :return: The expression ``call(dest)`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_CALL, dest.index) - - def ret(self, dest): - """ - ``ret`` returns an expression which jumps (branches) to the expression ``dest``. ``ret`` is a special alias for - jump that makes the disassembler top disassembling. - - :param LowLevelILExpr dest: the expression to jump to - :return: The expression ``jump(dest)`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_RET, dest.index) - - def no_ret(self): - """ - ``no_ret`` returns an expression halts disassembly - - :return: The expression ``noreturn`` - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_NORET) - - def flag_condition(self, cond): - """ - ``flag_condition`` returns a flag_condition expression for the given LowLevelILFlagCondition - - :param LowLevelILFlagCondition cond: Flag condition expression to retrieve - :return: A flag_condition expression - :rtype: LowLevelILExpr - """ - if isinstance(cond, str): - cond = core.BNLowLevelILFlagCondition_by_name[cond] - return self.expr(core.LLIL_FLAG_COND, cond) - - def compare_equal(self, size, a, b): - """ - ``compare_equal`` returns comparison expression of size ``size`` checking if expression ``a`` is equal to - expression ``b`` - - :param int size: size in bytes - :param LowLevelILExpr a: LHS of comparison - :param LowLevelILExpr b: RHS of comparison - :return: a comparison expression. - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_CMP_E, a.index, b.index, size = size) - - def compare_not_equal(self, size, a, b): - """ - ``compare_not_equal`` returns comparison expression of size ``size`` checking if expression ``a`` is not equal to - expression ``b`` - - :param int size: size in bytes - :param LowLevelILExpr a: LHS of comparison - :param LowLevelILExpr b: RHS of comparison - :return: a comparison expression. - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_CMP_NE, a.index, b.index, size = size) - - def compare_signed_less_than(self, size, a, b): - """ - ``compare_signed_less_than`` returns comparison expression of size ``size`` checking if expression ``a`` is - signed less than expression ``b`` - - :param int size: size in bytes - :param LowLevelILExpr a: LHS of comparison - :param LowLevelILExpr b: RHS of comparison - :return: a comparison expression. - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_CMP_SLT, a.index, b.index, size = size) - - def compare_unsigned_less_than(self, size, a, b): - """ - ``compare_unsigned_less_than`` returns comparison expression of size ``size`` checking if expression ``a`` is - unsigned less than expression ``b`` - - :param int size: size in bytes - :param LowLevelILExpr a: LHS of comparison - :param LowLevelILExpr b: RHS of comparison - :return: a comparison expression. - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_CMP_ULT, a.index, b.index, size = size) - - def compare_signed_less_equal(self, size, a, b): - """ - ``compare_signed_less_equal`` returns comparison expression of size ``size`` checking if expression ``a`` is - signed less than or equal to expression ``b`` - - :param int size: size in bytes - :param LowLevelILExpr a: LHS of comparison - :param LowLevelILExpr b: RHS of comparison - :return: a comparison expression. - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_CMP_SLE, a.index, b.index, size = size) - - def compare_unsigned_less_equal(self, size, a, b): - """ - ``compare_unsigned_less_equal`` returns comparison expression of size ``size`` checking if expression ``a`` is - unsigned less than or equal to expression ``b`` - - :param int size: size in bytes - :param LowLevelILExpr a: LHS of comparison - :param LowLevelILExpr b: RHS of comparison - :return: a comparison expression. - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_CMP_ULE, a.index, b.index, size = size) - - def compare_signed_greater_equal(self, size, a, b): - """ - ``compare_signed_greater_equal`` returns comparison expression of size ``size`` checking if expression ``a`` is - signed greater than or equal toexpression ``b`` - - :param int size: size in bytes - :param LowLevelILExpr a: LHS of comparison - :param LowLevelILExpr b: RHS of comparison - :return: a comparison expression. - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_CMP_SGE, a.index, b.index, size = size) - - def compare_unsigned_greater_equal(self, size, a, b): - """ - ``compare_unsigned_greater_equal`` returns comparison expression of size ``size`` checking if expression ``a`` - is unsigned greater than or equal to expression ``b`` - - :param int size: size in bytes - :param LowLevelILExpr a: LHS of comparison - :param LowLevelILExpr b: RHS of comparison - :return: a comparison expression. - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_CMP_UGE, a.index, b.index, size = size) - - def compare_signed_greater_than(self, size, a, b): - """ - ``compare_signed_greater_than`` returns comparison expression of size ``size`` checking if expression ``a`` is - signed greater than or equal to expression ``b`` - - :param int size: size in bytes - :param LowLevelILExpr a: LHS of comparison - :param LowLevelILExpr b: RHS of comparison - :return: a comparison expression. - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_CMP_SGT, a.index, b.index, size = size) - - def compare_unsigned_greater_than(self, size, a, b): - """ - ``compare_unsigned_greater_than`` returns comparison expression of size ``size`` checking if expression ``a`` is - unsigned greater than or equal to expression ``b`` - - :param int size: size in bytes - :param LowLevelILExpr a: LHS of comparison - :param LowLevelILExpr b: RHS of comparison - :return: a comparison expression. - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_CMP_UGT, a.index, b.index, size = size) - - def test_bit(self, size, a, b): - return self.expr(core.LLIL_TEST_BIT, a.index, b.index, size = size) - - def system_call(self): - """ - ``system_call`` return a system call expression. - - :return: a system call expression. - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_SYSCALL) - - def breakpoint(self): - """ - ``breakpoint`` returns a processor breakpoint expression. - - :return: a breakpoint expression. - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_BP) - - def trap(self, value): - """ - ``trap`` returns a processor trap (interrupt) expression of the given integer ``value``. - - :param int value: trap (interrupt) number - :return: a trap expression. - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_TRAP, value) - - def undefined(self): - """ - ``undefined`` returns the undefined expression. This should be used for instructions which perform functions but - aren't important for dataflow or partial emulation purposes. - - :return: the unimplemented expression. - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_UNDEF) - - def unimplemented(self): - """ - ``unimplemented`` returns the unimplemented expression. This should be used for all instructions which aren't - implemented. - - :return: the unimplemented expression. - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_UNIMPL) - - def unimplemented_memory_ref(self, size, addr): - """ - ``unimplemented_memory_ref`` a memory reference to expression ``addr`` of size ``size`` with unimplemented operation. - - :param int size: size in bytes of the memory reference - :param LowLevelILExpr addr: expression to reference memory - :return: the unimplemented memory reference expression. - :rtype: LowLevelILExpr - """ - return self.expr(core.LLIL_UNIMPL_MEM, addr.index, size = size) - - def goto(self, label): - """ - ``goto`` returns a goto expression which jumps to the provided LowLevelILLabel. - - :param LowLevelILLabel label: Label to jump to - :return: the LowLevelILExpr that jumps to the provided label - :rtype: LowLevelILExpr - """ - return LowLevelILExpr(core.BNLowLevelILGoto(self.handle, label.handle)) - - def if_expr(self, operand, t, f): - """ - ``if_expr`` returns the ``if`` expression which depending on condition ``operand`` jumps to the LowLevelILLabel - ``t`` when the condition expression ``operand`` is non-zero and ``f`` when it's zero. - - :param LowLevelILExpr operand: comparison expression to evaluate. - :param LowLevelILLabel t: Label for the true branch - :param LowLevelILLabel f: Label for the false branch - :return: the LowLevelILExpr for the if expression - :rtype: LowLevelILExpr - """ - return LowLevelILExpr(core.BNLowLevelILIf(self.handle, operand.index, t.handle, f.handle)) - - def mark_label(self, label): - """ - ``mark_label`` assigns a LowLevelILLabel to the current IL address. - - :param LowLevelILLabel label: - :rtype: None - """ - core.BNLowLevelILMarkLabel(self.handle, label.handle) - - def add_label_list(self, labels): - """ - ``add_label_list`` returns a label list expression for the given list of LowLevelILLabel objects. - - :param list(LowLevelILLabel) lables: the list of LowLevelILLabel to get a label list expression from - :return: the label list expression - :rtype: LowLevelILExpr - """ - label_list = (ctypes.POINTER(core.BNLowLevelILLabel) * len(labels))() - for i in xrange(len(labels)): - label_list[i] = labels[i].handle - return LowLevelILExpr(core.BNLowLevelILAddLabelList(self.handle, label_list, len(labels))) - - def add_operand_list(self, operands): - """ - ``add_operand_list`` returns an operand list expression for the given list of integer operands. - - :param list(int) operands: list of operand numbers - :return: an operand list expression - :rtype: LowLevelILExpr - """ - operand_list = (ctypes.c_ulonglong * len(operands))() - for i in xrange(len(operands)): - operand_list[i] = operands[i] - return LowLevelILExpr(core.BNLowLevelILAddOperandList(self.handle, operand_list, len(operands))) - - def operand(self, n, expr): - """ - ``operand`` sets the operand number of the expression ``expr`` and passes back ``expr`` without modification. - - :param int n: - :param LowLevelILExpr expr: - :return: returns the expression ``expr`` unmodified - :rtype: LowLevelILExpr - """ - core.BNLowLevelILSetExprSourceOperand(self.handle, expr.index, n) - return expr - - def finalize(self): - """ - ``finalize`` ends the function and computes the list of basic blocks. - - :rtype: None - """ - core.BNFinalizeLowLevelILFunction(self.handle) - - def add_label_for_address(self, arch, addr): - """ - ``add_label_for_address`` adds a low-level IL label for the given architecture ``arch`` at the given virtual - address ``addr`` - - :param Architecture arch: Architecture to add labels for - :param int addr: the IL address to add a label at - """ - if arch is not None: - arch = arch.handle - core.BNAddLowLevelILLabelForAddress(self.handle, arch, addr) - - def get_label_for_address(self, arch, addr): - """ - ``get_label_for_address`` returns the LowLevelILLabel for the given Architecture ``arch`` and IL address ``addr``. - - :param Architecture arch: - :param int addr: IL Address label to retrieve - :return: the LowLevelILLabel for the given IL address - :rtype: LowLevelILLabel - """ - if arch is not None: - arch = arch.handle - label = core.BNGetLowLevelILLabelForAddress(self.handle, arch, addr) - if label is None: - return None - return LowLevelILLabel(label) - -class TypeParserResult(object): - def __init__(self, types, variables, functions): - self.types = types - self.variables = variables - self.functions = functions - - def __repr__(self): - return "{types: %s, variables: %s, functions: %s}" % (self.types, self.variables, self.functions) - -class _TransformMetaClass(type): - @property - def list(self): - _init_plugins() - count = ctypes.c_ulonglong() - xforms = core.BNGetTransformTypeList(count) - result = [] - for i in xrange(0, count.value): - result.append(Transform(xforms[i])) - core.BNFreeTransformTypeList(xforms) - return result - - def __iter__(self): - _init_plugins() - count = ctypes.c_ulonglong() - xforms = core.BNGetTransformTypeList(count) - try: - for i in xrange(0, count.value): - yield Transform(xforms[i]) - finally: - core.BNFreeTransformTypeList(xforms) - - def __setattr__(self, name, value): - try: - type.__setattr__(self,name,value) - except AttributeError: - raise AttributeError, "attribute '%s' is read only" % name - - def __getitem__(cls, name): - _init_plugins() - xform = core.BNGetTransformByName(name) - if xform is None: - raise KeyError, "'%s' is not a valid transform" % str(name) - return Transform(xform) - - def register(cls): - _init_plugins() - if cls.name is None: - raise ValueError, "transform 'name' is not defined" - if cls.long_name is None: - cls.long_name = cls.name - if cls.transform_type is None: - raise ValueError, "transform 'transform_type' is not defined" - if cls.group is None: - cls.group = "" - xform = cls(None) - cls._registered_cb = xform._cb - xform.handle = core.BNRegisterTransformType(cls.transform_type, cls.name, cls.long_name, cls.group, xform._cb) - -class TransformParameter(object): - def __init__(self, name, long_name = None, fixed_length = 0): - self.name = name - if long_name is None: - self.long_name = name - else: - self.long_name = long_name - self.fixed_length = fixed_length - -class Transform: - transform_type = None - name = None - long_name = None - group = None - parameters = [] - _registered_cb = None - __metaclass__ = _TransformMetaClass - - def __init__(self, handle): - if handle is None: - self._cb = core.BNCustomTransform() - self._cb.context = 0 - self._cb.getParameters = self._cb.getParameters.__class__(self._get_parameters) - self._cb.freeParameters = self._cb.freeParameters.__class__(self._free_parameters) - self._cb.decode = self._cb.decode.__class__(self._decode) - self._cb.encode = self._cb.encode.__class__(self._encode) - self._pending_param_lists = {} - self.type = self.__class__.transform_type - if not isinstance(self.type, str): - self.type = core.BNTransformType_names[self.type] - self.name = self.__class__.name - self.long_name = self.__class__.long_name - self.group = self.__class__.group - self.parameters = self.__class__.parameters - else: - self.handle = handle - self.type = core.BNTransformType_names[core.BNGetTransformType(self.handle)] - self.name = core.BNGetTransformName(self.handle) - self.long_name = core.BNGetTransformLongName(self.handle) - self.group = core.BNGetTransformGroup(self.handle) - count = ctypes.c_ulonglong() - params = core.BNGetTransformParameterList(self.handle, count) - self.parameters = [] - for i in xrange(0, count.value): - self.parameters.append(TransformParameter(params[i].name, params[i].longName, params[i].fixedLength)) - core.BNFreeTransformParameterList(params, count.value) - - def __repr__(self): - return "" % self.name - - def _get_parameters(self, ctxt, count): - try: - count[0] = len(self.parameters) - param_buf = (core.BNTransformParameterInfo * len(self.parameters))() - for i in xrange(0, len(self.parameters)): - param_buf[i].name = self.parameters[i].name - param_buf[i].longName = self.parameters[i].long_name - param_buf[i].fixedLength = self.parameters[i].fixed_length - result = ctypes.cast(param_buf, ctypes.c_void_p) - self._pending_param_lists[result.value] = (result, param_buf) - return result.value - except: - log_error(traceback.format_exc()) - count[0] = 0 - return None - - def _free_parameters(self, params, count): - try: - buf = ctypes.cast(params, ctypes.c_void_p) - if buf.value not in self._pending_param_lists: - raise ValueError, "freeing parameter list that wasn't allocated" - del self._pending_param_lists[buf.value] - except: - log_error(traceback.format_exc()) - - def _decode(self, ctxt, input_buf, output_buf, params, count): - try: - input_obj = DataBuffer(handle = core.BNDuplicateDataBuffer(input_buf)) - param_map = {} - for i in xrange(0, count): - data = DataBuffer(handle = core.BNDuplicateDataBuffer(params[i].value)) - param_map[params[i].name] = str(data) - result = self.perform_decode(str(input_obj), param_map) - if result is None: - return False - result = str(result) - core.BNSetDataBufferContents(output_buf, result, len(result)) - return True - except: - log_error(traceback.format_exc()) - return False - - def _encode(self, ctxt, input_buf, output_buf, params, count): - try: - input_obj = DataBuffer(handle = core.BNDuplicateDataBuffer(input_buf)) - param_map = {} - for i in xrange(0, count): - data = DataBuffer(handle = core.BNDuplicateDataBuffer(params[i].value)) - param_map[params[i].name] = str(data) - result = self.perform_encode(str(input_obj), param_map) - if result is None: - return False - result = str(result) - core.BNSetDataBufferContents(output_buf, result, len(result)) - return True - except: - log_error(traceback.format_exc()) - return False - - @abc.abstractmethod - def perform_decode(self, data, params): - if self.type == "InvertingTransform": - return self.perform_encode(data, params) - return None - - @abc.abstractmethod - def perform_encode(self, data, params): - return None - - def decode(self, input_buf, params = {}): - input_buf = DataBuffer(input_buf) - output_buf = DataBuffer() - keys = params.keys() - param_buf = (core.BNTransformParameter * len(keys))() - param_data = [] - for i in xrange(0, len(keys)): - data = DataBuffer(params[keys[i]]) - param_buf[i].name = keys[i] - param_buf[i].value = data.handle - if not core.BNDecode(self.handle, input_buf.handle, output_buf.handle, param_buf, len(keys)): - return None - return str(output_buf) - - def encode(self, input_buf, params = {}): - input_buf = DataBuffer(input_buf) - output_buf = DataBuffer() - keys = params.keys() - param_buf = (core.BNTransformParameter * len(keys))() - param_data = [] - for i in xrange(0, len(keys)): - data = DataBuffer(params[keys[i]]) - param_buf[i].name = keys[i] - param_buf[i].value = data.handle - if not core.BNEncode(self.handle, input_buf.handle, output_buf.handle, param_buf, len(keys)): - return None - return str(output_buf) - -class FunctionRecognizer(object): - _instance = None - - def __init__(self): - self._cb = core.BNFunctionRecognizer() - self._cb.context = 0 - self._cb.recognizeLowLevelIL = self._cb.recognizeLowLevelIL.__class__(self._recognize_low_level_il) - - @classmethod - def register_global(cls): - if cls._instance is None: - cls._instance = cls() - core.BNRegisterGlobalFunctionRecognizer(cls._instance._cb) - - @classmethod - def register_arch(cls, arch): - if cls._instance is None: - cls._instance = cls() - core.BNRegisterArchitectureFunctionRecognizer(arch.handle, cls._instance._cb) - - def _recognize_low_level_il(self, ctxt, data, func, il): - try: - file_metadata = FileMetadata(handle = core.BNGetFileForView(data)) - view = BinaryView(file_metadata = file_metadata, handle = core.BNNewViewReference(data)) - func = Function(view, handle = core.BNNewFunctionReference(func)) - il = LowLevelILFunction(func.arch, handle = core.BNNewLowLevelILFunctionReference(il)) - return self.recognize_low_level_il(view, func, il) - except: - log_error(traceback.format_exc()) - return False - - def recognize_low_level_il(self, data, func, il): - return False - -class _UpdateChannelMetaClass(type): - @property - def list(self): - _init_plugins() - count = ctypes.c_ulonglong() - errors = ctypes.c_char_p() - channels = core.BNGetUpdateChannels(count, errors) - if errors: - error_str = errors.value - core.BNFreeString(ctypes.cast(errors, ctypes.POINTER(ctypes.c_byte))) - raise IOError, error_str - result = [] - for i in xrange(0, count.value): - result.append(UpdateChannel(channels[i].name, channels[i].description, channels[i].latestVersion)) - core.BNFreeUpdateChannelList(channels, count.value) - return result - - @property - def active(self): - return core.BNGetActiveUpdateChannel() - - @active.setter - def active(self, value): - return core.BNSetActiveUpdateChannel(value) - - def __iter__(self): - _init_plugins() - count = ctypes.c_ulonglong() - errors = ctypes.c_char_p() - channels = core.BNGetUpdateChannels(count, errors) - if errors: - error_str = errors.value - core.BNFreeString(ctypes.cast(errors, ctypes.POINTER(ctypes.c_byte))) - raise IOError, error_str - try: - for i in xrange(0, count.value): - yield UpdateChannel(channels[i].name, channels[i].description, channels[i].latestVersion) - finally: - core.BNFreeUpdateChannelList(channels, count.value) - - def __setattr__(self, name, value): - try: - type.__setattr__(self,name,value) - except AttributeError: - raise AttributeError, "attribute '%s' is read only" % name - - def __getitem__(cls, name): - _init_plugins() - count = ctypes.c_ulonglong() - errors = ctypes.c_char_p() - channels = core.BNGetUpdateChannels(count, errors) - if errors: - error_str = errors.value - core.BNFreeString(ctypes.cast(errors, ctypes.POINTER(ctypes.c_byte))) - raise IOError, error_str - result = None - for i in xrange(0, count.value): - if channels[i].name == str(name): - result = UpdateChannel(channels[i].name, channels[i].description, channels[i].latestVersion) - break - core.BNFreeUpdateChannelList(channels, count.value) - if result is None: - raise KeyError, "'%s' is not a valid channel" % str(name) - return result - -class UpdateProgressCallback(object): - def __init__(self, func): - self.cb = ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)(self.callback) - self.func = func - - def callback(self, ctxt, progress, total): - try: - if self.func is not None: - return self.func(progress, total) - return True - except: - log_error(traceback.format_exc()) - -class UpdateChannel(object): - __metaclass__ = _UpdateChannelMetaClass - - def __init__(self, name, desc, ver): - self.name = name - self.description = desc - self.latest_version_num = ver - - @property - def versions(self): - """List of versions (read-only)""" - count = ctypes.c_ulonglong() - errors = ctypes.c_char_p() - versions = core.BNGetUpdateChannelVersions(self.name, count, errors) - if errors: - error_str = errors.value - core.BNFreeString(ctypes.cast(errors, ctypes.POINTER(ctypes.c_byte))) - raise IOError, error_str - result = [] - for i in xrange(0, count.value): - result.append(UpdateVersion(self, versions[i].version, versions[i].notes, versions[i].time)) - core.BNFreeUpdateChannelVersionList(versions, count.value) - return result - - @property - def latest_version(self): - """Latest version (read-only)""" - count = ctypes.c_ulonglong() - errors = ctypes.c_char_p() - versions = core.BNGetUpdateChannelVersions(self.name, count, errors) - if errors: - error_str = errors.value - core.BNFreeString(ctypes.cast(errors, ctypes.POINTER(ctypes.c_byte))) - raise IOError, error_str - result = None - for i in xrange(0, count.value): - if versions[i].version == self.latest_version_num: - result = UpdateVersion(self, versions[i].version, versions[i].notes, versions[i].time) - break - core.BNFreeUpdateChannelVersionList(versions, count.value) - return result - - @property - def updates_available(self): - """Whether updates are available (read-only)""" - errors = ctypes.c_char_p() - result = core.BNAreUpdatesAvailable(self.name, errors) - if errors: - error_str = errors.value - core.BNFreeString(ctypes.cast(errors, ctypes.POINTER(ctypes.c_byte))) - raise IOError, error_str - return result - - def __setattr__(self, name, value): - try: - object.__setattr__(self,name,value) - except AttributeError: - raise AttributeError, "attribute '%s' is read only" % name - - def __repr__(self): - return "" % self.name - - def __str__(self): - return self.name - - def update_to_latest(self, progress = None): - cb = UpdateProgressCallback(progress) - errors = ctypes.c_char_p() - result = core.BNUpdateToLatestVersion(self.name, errors, cb.cb, None) - if errors: - error_str = errors.value - core.BNFreeString(ctypes.cast(errors, ctypes.POINTER(ctypes.c_byte))) - raise IOError, error_str - return core.BNUpdateResult_names[result] - -class UpdateVersion(object): - def __init__(self, channel, ver, notes, t): - self.channel = channel - self.version = ver - self.notes = notes - self.time = t - - def __repr__(self): - return "" % self.version - - def __str__(self): - return self.version - - def update(self, progress = None): - cb = UpdateProgressCallback(progress) - errors = ctypes.c_char_p() - result = core.BNUpdateToVersion(self.channel.name, self.version, errors, cb.cb, None) - if errors: - error_str = errors.value - core.BNFreeString(ctypes.cast(errors, ctypes.POINTER(ctypes.c_byte))) - raise IOError, error_str - return core.BNUpdateResult_names[result] - -class PluginCommandContext(object): - def __init__(self, view): - self.view = view - self.address = 0 - self.length = 0 - self.function = None - -class _PluginCommandMetaClass(type): - @property - def list(self): - _init_plugins() - count = ctypes.c_ulonglong() - commands = core.BNGetAllPluginCommands(count) - result = [] - for i in xrange(0, count.value): - result.append(PluginCommand(commands[i])) - core.BNFreePluginCommandList(commands) - return result - - def __iter__(self): - _init_plugins() - count = ctypes.c_ulonglong() - commands = core.BNGetAllPluginCommands(count) - try: - for i in xrange(0, count.value): - yield PluginCommand(commands[i]) - finally: - core.BNFreePluginCommandList(commands) - - def __setattr__(self, name, value): - try: - type.__setattr__(self,name,value) - except AttributeError: - raise AttributeError, "attribute '%s' is read only" % name - -class PluginCommand: - _registered_commands = [] - __metaclass__ = _PluginCommandMetaClass - - def __init__(self, cmd): - self.command = core.BNPluginCommand() - ctypes.memmove(ctypes.byref(self.command), ctypes.byref(cmd), ctypes.sizeof(core.BNPluginCommand)) - self.name = str(cmd.name) - self.description = str(cmd.description) - self.type = core.BNPluginCommandType_names[cmd.type] - - @classmethod - def _default_action(cls, view, action): - try: - file_metadata = FileMetadata(handle = core.BNGetFileForView(view)) - view_obj = BinaryView(file_metadata = file_metadata, handle = core.BNNewViewReference(view)) - action(view_obj) - except: - log_error(traceback.format_exc()) - - @classmethod - def _address_action(cls, view, addr, action): - try: - file_metadata = FileMetadata(handle = core.BNGetFileForView(view)) - view_obj = BinaryView(file_metadata = file_metadata, handle = core.BNNewViewReference(view)) - action(view_obj, addr) - except: - log_error(traceback.format_exc()) - - @classmethod - def _range_action(cls, view, addr, length, action): - try: - file_metadata = FileMetadata(handle = core.BNGetFileForView(view)) - view_obj = BinaryView(file_metadata = file_metadata, handle = core.BNNewViewReference(view)) - action(view_obj, addr, length) - except: - log_error(traceback.format_exc()) - - @classmethod - def _function_action(cls, view, func, action): - try: - file_metadata = FileMetadata(handle = core.BNGetFileForView(view)) - view_obj = BinaryView(file_metadata = file_metadata, handle = core.BNNewViewReference(view)) - func_obj = Function(view_obj, core.BNNewFunctionReference(func)) - action(view_obj, func_obj) - except: - log_error(traceback.format_exc()) - - @classmethod - def _default_is_valid(cls, view, is_valid): - try: - if is_valid is None: - return True - file_metadata = FileMetadata(handle = core.BNGetFileForView(view)) - view_obj = BinaryView(file_metadata = file_metadata, handle = core.BNNewViewReference(view)) - return is_valid(view_obj) - except: - log_error(traceback.format_exc()) - return False - - @classmethod - def _address_is_valid(cls, view, addr, is_valid): - try: - if is_valid is None: - return True - file_metadata = FileMetadata(handle = core.BNGetFileForView(view)) - view_obj = BinaryView(file_metadata = file_metadata, handle = core.BNNewViewReference(view)) - return is_valid(view_obj, addr) - except: - log_error(traceback.format_exc()) - return False - - @classmethod - def _range_is_valid(cls, view, addr, length, is_valid): - try: - if is_valid is None: - return True - file_metadata = FileMetadata(handle = core.BNGetFileForView(view)) - view_obj = BinaryView(file_metadata = file_metadata, handle = core.BNNewViewReference(view)) - return is_valid(view_obj, addr, length) - except: - log_error(traceback.format_exc()) - return False - - @classmethod - def _function_is_valid(cls, view, func, is_valid): - try: - if is_valid is None: - return True - file_metadata = FileMetadata(handle = core.BNGetFileForView(view)) - view_obj = BinaryView(file_metadata = file_metadata, handle = core.BNNewViewReference(view)) - func_obj = Function(view_obj, core.BNNewFunctionReference(func)) - return is_valid(view_obj, func_obj) - except: - log_error(traceback.format_exc()) - return False - - @classmethod - def register(cls, name, description, action, is_valid = None): - _init_plugins() - action_obj = ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(core.BNBinaryView))(lambda ctxt, view: cls._default_action(view, action)) - is_valid_obj = ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(core.BNBinaryView))(lambda ctxt, view: cls._default_is_valid(view, is_valid)) - cls._registered_commands.append((action_obj, is_valid_obj)) - core.BNRegisterPluginCommand(name, description, action_obj, is_valid_obj, None) - - @classmethod - def register_for_address(cls, name, description, action, is_valid = None): - _init_plugins() - action_obj = ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(core.BNBinaryView), ctypes.c_ulonglong)(lambda ctxt, view, addr: cls._address_action(view, addr, action)) - is_valid_obj = ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(core.BNBinaryView), ctypes.c_ulonglong)(lambda ctxt, view, addr: cls._address_is_valid(view, addr, is_valid)) - cls._registered_commands.append((action_obj, is_valid_obj)) - core.BNRegisterPluginCommandForAddress(name, description, action_obj, is_valid_obj, None) - - @classmethod - def register_for_range(cls, name, description, action, is_valid = None): - _init_plugins() - action_obj = ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(core.BNBinaryView), ctypes.c_ulonglong, ctypes.c_ulonglong)(lambda ctxt, view, addr, length: cls._range_action(view, addr, length, action)) - is_valid_obj = ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(core.BNBinaryView), ctypes.c_ulonglong, ctypes.c_ulonglong)(lambda ctxt, view, addr, length: cls._range_is_valid(view, addr, length, is_valid)) - cls._registered_commands.append((action_obj, is_valid_obj)) - core.BNRegisterPluginCommandForRange(name, description, action_obj, is_valid_obj, None) - - @classmethod - def register_for_function(cls, name, description, action, is_valid = None): - _init_plugins() - action_obj = ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(core.BNBinaryView), ctypes.POINTER(core.BNFunction))(lambda ctxt, view, func: cls._function_action(view, func, action)) - is_valid_obj = ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(core.BNBinaryView), ctypes.POINTER(core.BNFunction))(lambda ctxt, view, func: cls._function_is_valid(view, func, is_valid)) - cls._registered_commands.append((action_obj, is_valid_obj)) - core.BNRegisterPluginCommandForFunction(name, description, action_obj, is_valid_obj, None) - - @classmethod - def get_valid_list(cls, context): - commands = cls.list - result = [] - for cmd in commands: - if cmd.is_valid(context): - result.append(cmd) - return result - - def is_valid(self, context): - if context.view is None: - return False - if self.command.type == core.DefaultPluginCommand: - if not self.command.defaultIsValid: - return True - return self.command.defaultIsValid(self.command.context, context.view.handle) - elif self.command.type == core.AddressPluginCommand: - if not self.command.addressIsValid: - return True - return self.command.addressIsValid(self.command.context, context.view.handle, context.address) - elif self.command.type == core.RangePluginCommand: - if context.length == 0: - return False - if not self.command.rangeIsValid: - return True - return self.command.rangeIsValid(self.command.context, context.view.handle, context.address, context.length) - elif self.command.type == core.FunctionPluginCommand: - if context.function is None: - return False - if not self.command.functionIsValid: - return True - return self.command.functionIsValid(self.command.context, context.view.handle, context.function.handle) - return False - - def execute(self, context): - if not self.is_valid(context): - return - if self.command.type == core.DefaultPluginCommand: - self.command.defaultCommand(self.command.context, context.view.handle) - elif self.command.type == core.AddressPluginCommand: - self.command.addressCommand(self.command.context, context.view.handle, context.address) - elif self.command.type == core.RangePluginCommand: - self.command.rangeCommand(self.command.context, context.view.handle, context.address, context.length) - elif self.command.type == core.FunctionPluginCommand: - self.command.functionCommand(self.command.context, context.view.handle, context.function.handle) - - def __repr__(self): - return "" % self.name - -class CallingConvention(object): - name = None - caller_saved_regs = [] - int_arg_regs = [] - float_arg_regs = [] - arg_regs_share_index = False - stack_reserved_for_arg_regs = False - int_return_reg = None - high_int_return_reg = None - float_return_reg = None - - _registered_calling_conventions = [] - - def __init__(self, arch, handle = None): - if handle is None: - self.arch = arch - self._pending_reg_lists = {} - self._cb = core.BNCustomCallingConvention() - self._cb.context = 0 - self._cb.getCallerSavedRegisters = self._cb.getCallerSavedRegisters.__class__(self._get_caller_saved_regs) - self._cb.getIntegerArgumentRegisters = self._cb.getIntegerArgumentRegisters.__class__(self._get_int_arg_regs) - self._cb.getFloatArgumentRegisters = self._cb.getFloatArgumentRegisters.__class__(self._get_float_arg_regs) - self._cb.freeRegisterList = self._cb.freeRegisterList.__class__(self._free_register_list) - self._cb.areArgumentRegistersSharedIndex = self._cb.areArgumentRegistersSharedIndex.__class__(self._arg_regs_share_index) - self._cb.isStackReservedForArgumentRegisters = self._cb.isStackReservedForArgumentRegisters.__class__(self._stack_reserved_for_arg_regs) - self._cb.getIntegerReturnValueRegister = self._cb.getIntegerReturnValueRegister.__class__(self._get_int_return_reg) - self._cb.getHighIntegerReturnValueRegister = self._cb.getHighIntegerReturnValueRegister.__class__(self._get_high_int_return_reg) - self._cb.getFloatReturnValueRegister = self._cb.getFloatReturnValueRegister.__class__(self._get_float_return_reg) - self.handle = core.BNCreateCallingConvention(arch.handle, self.__class__.name, self._cb) - self.__class__._registered_calling_conventions.append(self) - else: - self.handle = handle - self.arch = Architecture(core.BNGetCallingConventionArchitecture(self.handle)) - self.__dict__["name"] = core.BNGetCallingConventionName(self.handle) - self.__dict__["arg_regs_share_index"] = core.BNAreArgumentRegistersSharedIndex(self.handle) - self.__dict__["stack_reserved_for_arg_regs"] = core.BNIsStackReservedForArgumentRegisters(self.handle) - - count = ctypes.c_ulonglong() - regs = core.BNGetCallerSavedRegisters(self.handle, count) - result = [] - arch = self.arch - for i in xrange(0, count.value): - result.append(arch.get_reg_name(regs[i])) - core.BNFreeRegisterList(regs, count.value) - self.__dict__["caller_saved_regs"] = result - - count = ctypes.c_ulonglong() - regs = core.BNGetIntegerArgumentRegisters(self.handle, count) - result = [] - arch = self.arch - for i in xrange(0, count.value): - result.append(arch.get_reg_name(regs[i])) - core.BNFreeRegisterList(regs, count.value) - self.__dict__["int_arg_regs"] = result - - count = ctypes.c_ulonglong() - regs = core.BNGetFloatArgumentRegisters(self.handle, count) - result = [] - arch = self.arch - for i in xrange(0, count.value): - result.append(arch.get_reg_name(regs[i])) - core.BNFreeRegisterList(regs, count.value) - self.__dict__["float_arg_regs"] = result - - reg = core.BNGetIntegerReturnValueRegister(self.handle) - if reg == 0xffffffff: - self.__dict__["int_return_reg"] = None - else: - self.__dict__["int_return_reg"] = self.arch.get_reg_name(reg) - - reg = core.BNGetHighIntegerReturnValueRegister(self.handle) - if reg == 0xffffffff: - self.__dict__["high_int_return_reg"] = None - else: - self.__dict__["high_int_return_reg"] = self.arch.get_reg_name(reg) - - reg = core.BNGetFloatReturnValueRegister(self.handle) - if reg == 0xffffffff: - self.__dict__["float_return_reg"] = None - else: - self.__dict__["float_return_reg"] = self.arch.get_reg_name(reg) - - def __del__(self): - core.BNFreeCallingConvention(self.handle) - - def _get_caller_saved_regs(self, ctxt, count): - try: - regs = self.__class__.caller_saved_regs - count[0] = len(regs) - reg_buf = (ctypes.c_uint * len(regs))() - for i in xrange(0, len(regs)): - reg_buf[i] = self.arch.regs[regs[i]].index - result = ctypes.cast(reg_buf, ctypes.c_void_p) - self._pending_reg_lists[result.value] = (result, reg_buf) - return result.value - except: - log_error(traceback.format_exc()) - count[0] = 0 - return None - - def _get_int_arg_regs(self, ctxt, count): - try: - regs = self.__class__.int_arg_regs - count[0] = len(regs) - reg_buf = (ctypes.c_uint * len(regs))() - for i in xrange(0, len(regs)): - reg_buf[i] = self.arch.regs[regs[i]].index - result = ctypes.cast(reg_buf, ctypes.c_void_p) - self._pending_reg_lists[result.value] = (result, reg_buf) - return result.value - except: - log_error(traceback.format_exc()) - count[0] = 0 - return None - - def _get_float_arg_regs(self, ctxt, count): - try: - regs = self.__class__.float_arg_regs - count[0] = len(regs) - reg_buf = (ctypes.c_uint * len(regs))() - for i in xrange(0, len(regs)): - reg_buf[i] = self.arch.regs[regs[i]].index - result = ctypes.cast(reg_buf, ctypes.c_void_p) - self._pending_reg_lists[result.value] = (result, reg_buf) - return result.value - except: - log_error(traceback.format_exc()) - count[0] = 0 - return None - - def _free_register_list(self, ctxt, regs): - try: - buf = ctypes.cast(regs, ctypes.c_void_p) - if buf.value not in self._pending_reg_lists: - raise ValueError, "freeing register list that wasn't allocated" - del self._pending_reg_lists[buf.value] - except: - log_error(traceback.format_exc()) - - def _arg_regs_share_index(self, ctxt): - try: - return self.__class__.arg_regs_share_index - except: - log_error(traceback.format_exc()) - return False - - def _stack_reserved_for_arg_regs(self, ctxt): - try: - return self.__class__.stack_reserved_for_arg_regs - except: - log_error(traceback.format_exc()) - return False - - def _get_int_return_reg(self, ctxt): - try: - return self.arch.regs[self.__class__.int_return_reg].index - except: - log_error(traceback.format_exc()) - return False - - def _get_high_int_return_reg(self, ctxt): - try: - if self.__class__.high_int_return_reg is None: - return 0xffffffff - return self.arch.regs[self.__class__.high_int_return_reg].index - except: - log_error(traceback.format_exc()) - return False - - def _get_float_return_reg(self, ctxt): - try: - if self.__class__.float_return_reg is None: - return 0xffffffff - return self.arch.regs[self.__class__.float_int_return_reg].index - except: - log_error(traceback.format_exc()) - return False - - def __repr__(self): - return "" % (self.arch.name, self.name) - - def __str__(self): - return self.name - -class _PlatformMetaClass(type): - @property - def list(self): - _init_plugins() - count = ctypes.c_ulonglong() - platforms = core.BNGetPlatformList(count) - result = [] - for i in xrange(0, count.value): - result.append(Platform(None, core.BNNewPlatformReference(platforms[i]))) - core.BNFreePlatformList(platforms, count.value) - return result - - @property - def os_list(self): - _init_plugins() - count = ctypes.c_ulonglong() - platforms = core.BNGetPlatformOSList(count) - result = [] - for i in xrange(0, count.value): - result.append(str(platforms[i])) - core.BNFreePlatformOSList(platforms, count.value) - return result - - def __iter__(self): - _init_plugins() - count = ctypes.c_ulonglong() - platforms = core.BNGetPlatformList(count) - try: - for i in xrange(0, count.value): - yield Platform(None, core.BNNewPlatformReference(platforms[i])) - finally: - core.BNFreePlatformList(platforms, count.value) - - def __setattr__(self, name, value): - try: - type.__setattr__(self,name,value) - except AttributeError: - raise AttributeError, "attribute '%s' is read only" % name - - def __getitem__(cls, value): - _init_plugins() - platform = core.BNGetPlatformByName(str(value)) - if platform is None: - raise KeyError, "'%s' is not a valid platform" % str(value) - return Platform(None, platform) - - def get_list(cls, os = None, arch = None): - _init_plugins() - count = ctypes.c_ulonglong() - if os is None: - platforms = core.BNGetPlatformList(count) - elif arch is None: - platforms = core.BNGetPlatformListByOS(os) - else: - platforms = core.BNGetPlatformListByArchitecture(os, arch.handle) - result = [] - for i in xrange(0, count.value): - result.append(Platform(None, core.BNNewPlatformReference(platforms[i]))) - core.BNFreePlatformList(platforms, count.value) - return result - -class Platform(object): - """ - ``class Platform`` contains all information releated to the execution environment of the binary, mainly the - calling conventions used. - """ - __metaclass__ = _PlatformMetaClass - name = None - - def __init__(self, arch, handle = None): - if handle is None: - self.arch = arch - self.handle = core.BNCreatePlatform(arch.handle, self.__class__.name) - else: - self.handle = handle - self.__dict__["name"] = core.BNGetPlatformName(self.handle) - self.arch = Architecture(core.BNGetPlatformArchitecture(self.handle)) - - def __del__(self): - core.BNFreePlatform(self.handle) - - @property - def default_calling_convention(self): - """ - Default calling convention. - - :getter: returns a CallingConvention object for the default calling convention. - :setter: sets the default calling convention - :type: CallingConvention - """ - result = core.BNGetPlatformDefaultCallingConvention(self.handle) - if result is None: - return None - return CallingConvention(None, result) - - @default_calling_convention.setter - def default_calling_convention(self, value): - core.BNRegisterPlatformDefaultCallingConvention(self.handle, value.handle) - - @property - def cdecl_calling_convention(self): - """ - Cdecl calling convention. - - :getter: returns a CallingConvention object for the cdecl calling convention. - :setter sets the cdecl calling convention - :type: CallingConvention - """ - result = core.BNGetPlatformCdeclCallingConvention(self.handle) - if result is None: - return None - return CallingConvention(None, result) - - @cdecl_calling_convention.setter - def cdecl_calling_convention(self, value): - core.BNRegisterPlatformCdeclCallingConvention(self.handle, value.handle) - - @property - def stdcall_calling_convention(self): - """ - Stdcall calling convention. - - :getter: returns a CallingConvention object for the stdcall calling convention. - :setter sets the stdcall calling convention - :type: CallingConvention - """ - result = core.BNGetPlatformStdcallCallingConvention(self.handle) - if result is None: - return None - return CallingConvention(None, result) - - @stdcall_calling_convention.setter - def stdcall_calling_convention(self, value): - core.BNRegisterPlatformStdcallCallingConvention(self.handle, value.handle) - - @property - def fastcall_calling_convention(self): - """ - Fastcall calling convention. - - :getter: returns a CallingConvention object for the fastcall calling convention. - :setter sets the fastcall calling convention - :type: CallingConvention - """ - result = core.BNGetPlatformFastcallCallingConvention(self.handle) - if result is None: - return None - return CallingConvention(None, result) - - @fastcall_calling_convention.setter - def fastcall_calling_convention(self, value): - core.BNRegisterPlatformFastcallCallingConvention(self.handle, value.handle) - - @property - def system_call_convention(self): - """ - System call convention. - - :getter: returns a CallingConvention object for the system call convention. - :setter sets the system call convention - :type: CallingConvention - """ - result = core.BNGetPlatformSystemCallConvention(self.handle) - if result is None: - return None - return CallingConvention(None, result) - - @system_call_convention.setter - def system_call_convention(self, value): - core.BNSetPlatformSystemCallConvention(self.handle, value.handle) - - @property - def calling_conventions(self): - """ - List of platform CallingConvention objects (read-only) - - :getter: returns the list of supported CallingConvention objects - :type: list(CallingConvention) - """ - count = ctypes.c_ulonglong() - cc = core.BNGetPlatformCallingConventions(self.handle, count) - result = [] - for i in xrange(0, count.value): - result.append(CallingConvention(None, core.BNNewCallingConventionReference(cc[i]))) - core.BNFreeCallingConventionList(cc, count.value) - return result - - def __setattr__(self, name, value): - try: - object.__setattr__(self,name,value) - except AttributeError: - raise AttributeError, "attribute '%s' is read only" % name - - def __repr__(self): - return "" % self.name - - def __str__(self): - return self.name - - def register(self, os): - """ - ``register`` registers the platform for given OS name. - - :param str os: OS name to register - :rtype: None - """ - core.BNRegisterPlatform(os, self.handle) - - def register_calling_convention(self, cc): - """ - ``register_calling_convention`` register a new calling convention. - - :param CallingConvention cc: a CallingConvention object to register - :rtype: None - """ - core.BNRegisterPlatformCallingConvention(self.handle, cc.handle) - -class ScriptingOutputListener(object): - def _register(self, handle): - self._cb = core.BNScriptingOutputListener() - self._cb.context = 0 - self._cb.output = self._cb.output.__class__(self._output) - self._cb.error = self._cb.error.__class__(self._error) - self._cb.inputReadyStateChanged = self._cb.inputReadyStateChanged.__class__(self._input_ready_state_changed) - core.BNRegisterScriptingInstanceOutputListener(handle, self._cb) - - def _unregister(self, handle): - core.BNUnregisterScriptingInstanceOutputListener(handle, self._cb) - - def _output(self, ctxt, text): - try: - self.notify_output(text) - except: - log_error(traceback.format_exc()) - - def _error(self, ctxt, text): - try: - self.notify_error(text) - except: - log_error(traceback.format_exc()) - - def _input_ready_state_changed(self, ctxt, state): - try: - self.notify_input_ready_state_changed(state) - except: - log_error(traceback.format_exc()) - - def notify_output(self, text): - pass - - def notify_error(self, text): - pass - - def notify_input_ready_state_changed(self, state): - pass - -class ScriptingInstance(object): - def __init__(self, provider, handle = None): - if handle is None: - self._cb = core.BNScriptingInstanceCallbacks() - self._cb.context = 0 - self._cb.destroyInstance = self._cb.destroyInstance.__class__(self._destroy_instance) - self._cb.executeScriptInput = self._cb.executeScriptInput.__class__(self._execute_script_input) - self._cb.setCurrentBinaryView = self._cb.setCurrentBinaryView.__class__(self._set_current_binary_view) - self._cb.setCurrentFunction = self._cb.setCurrentFunction.__class__(self._set_current_function) - self._cb.setCurrentBasicBlock = self._cb.setCurrentBasicBlock.__class__(self._set_current_basic_block) - self._cb.setCurrentAddress = self._cb.setCurrentAddress.__class__(self._set_current_address) - self._cb.setCurrentSelection = self._cb.setCurrentSelection.__class__(self._set_current_selection) - self.handle = core.BNInitScriptingInstance(provider.handle, self._cb) - else: - self.handle = core.handle_of_type(handle, core.BNScriptingInstance) - self.listeners = [] - - def __del__(self): - core.BNFreeScriptingInstance(self.handle) - - def _destroy_instance(self, ctxt): - try: - self.perform_destroy_instance() - except: - log_error(traceback.format_exc()) - - def _execute_script_input(self, ctxt, text): - try: - return self.perform_execute_script_input(text) - except: - log_error(traceback.format_exc()) - return core.InvalidScriptInput - - def _set_current_binary_view(self, ctxt, view): - try: - if view: - view = BinaryView(handle = core.BNNewViewReference(view)) - else: - view = None - self.perform_set_current_binary_view(view) - except: - log_error(traceback.format_exc()) - def _set_current_function(self, ctxt, func): - try: - if func: - func = Function(BinaryView(handle = core.BNGetFunctionData(func)), core.BNNewFunctionReference(func)) - else: - func = None - self.perform_set_current_function(func) - except: - log_error(traceback.format_exc()) - - def _set_current_basic_block(self, ctxt, block): - try: - if block: - func = core.BNGetBasicBlockFunction(block) - if func is None: - block = None - else: - block = BasicBlock(BinaryView(handle = core.BNGetFunctionData(func)), core.BNNewBasicBlockReference(block)) - core.BNFreeFunction(func) - else: - block = None - self.perform_set_current_basic_block(block) - except: - log_error(traceback.format_exc()) - - def _set_current_address(self, ctxt, addr): - try: - self.perform_set_current_address(addr) - except: - log_error(traceback.format_exc()) - - def _set_current_selection(self, ctxt, begin, end): - try: - self.perform_set_current_selection(begin, end) - except: - log_error(traceback.format_exc()) - - @abc.abstractmethod - def perform_destroy_instance(self): - raise NotImplementedError - - @abc.abstractmethod - def perform_execute_script_input(self, text): - return core.InvalidScriptInput - - @abc.abstractmethod - def perform_set_current_binary_view(self, view): - raise NotImplementedError - - @abc.abstractmethod - def perform_set_current_function(self, func): - raise NotImplementedError - - @abc.abstractmethod - def perform_set_current_basic_block(self, block): - raise NotImplementedError - - @abc.abstractmethod - def perform_set_current_address(self, addr): - raise NotImplementedError - - @abc.abstractmethod - def perform_set_current_selection(self, begin, end): - raise NotImplementedError - - @property - def input_ready_state(self): - return core.BNGetScriptingInstanceInputReadyState(self.handle) - - @input_ready_state.setter - def input_ready_state(self, value): - core.BNNotifyInputReadyStateForScriptingInstance(self.handle, value) - - def output(self, text): - core.BNNotifyOutputForScriptingInstance(self.handle, text) - - def error(self, text): - core.BNNotifyErrorForScriptingInstance(self.handle, text) - - def execute_script_input(self, text): - return core.BNExecuteScriptInput(self.handle, text) - - def set_current_binary_view(self, view): - if view is not None: - view = view.handle - core.BNSetScriptingInstanceCurrentBinaryView(self.handle, view) - - def set_current_function(self, func): - if func is not None: - func = func.handle - core.BNSetScriptingInstanceCurrentFunction(self.handle, func) - - def set_current_basic_block(self, block): - if block is not None: - block = block.handle - core.BNSetScriptingInstanceCurrentBasicBlock(self.handle, block) - - def set_current_address(self, addr): - core.BNSetScriptingInstanceCurrentAddress(self.handle, addr) - - def set_current_selection(self, begin, end): - core.BNSetScriptingInstanceCurrentSelection(self.handle, begin, end) - - def register_output_listener(self, listener): - listener._register(self.handle) - self.listeners.append(listener) - - def unregister_output_listener(self, listener): - if listener in self.listeners: - listener._unregister(self.handle) - self.listeners.remove(listener) - -class _ScriptingProviderMetaclass(type): - @property - def list(self): - """List all ScriptingProvider types (read-only)""" - _init_plugins() - count = ctypes.c_ulonglong() - types = core.BNGetScriptingProviderList(count) - result = [] - for i in xrange(0, count.value): - result.append(ScriptingProvider(types[i])) - core.BNFreeScriptingProviderList(types) - return result - - def __iter__(self): - _init_plugins() - count = ctypes.c_ulonglong() - types = core.BNGetScriptingProviderList(count) - try: - for i in xrange(0, count.value): - yield ScriptingProvider(types[i]) - finally: - core.BNFreeScriptingProviderList(types) - - def __getitem__(self, value): - _init_plugins() - provider = core.BNGetScriptingProviderByName(str(value)) - if provider is None: - raise KeyError, "'%s' is not a valid scripting provider" % str(value) - return ScriptingProvider(provider) - - def __setattr__(self, name, value): - try: - type.__setattr__(self,name,value) - except AttributeError: - raise AttributeError, "attribute '%s' is read only" % name - -class ScriptingProvider(object): - __metaclass__ = _ScriptingProviderMetaclass - - name = None - instance_class = None - _registered_providers = [] - - def __init__(self, handle = None): - if handle is not None: - self.handle = core.handle_of_type(handle, core.BNScriptingProvider) - self.__dict__["name"] = core.BNGetScriptingProviderName(handle) - - def register(self): - self._cb = core.BNScriptingProviderCallbacks() - self._cb.context = 0 - self._cb.createInstance = self._cb.createInstance.__class__(self._create_instance) - self.handle = core.BNRegisterScriptingProvider(self.__class__.name, self._cb) - self.__class__._registered_providers.append(self) - - def _create_instance(self, ctxt): - try: - result = self.__class__.instance_class(self) - if result is None: - return None - return ctypes.cast(core.BNNewScriptingInstanceReference(result.handle), ctypes.c_void_p).value - except: - log_error(traceback.format_exc()) - return None - - def create_instance(self): - result = core.BNCreateScriptingProviderInstance(self.handle) - if result is None: - return None - return ScriptingInstance(self, handle = result) - -class _PythonScriptingInstanceOutput(object): - def __init__(self, orig, is_error): - self.orig = orig - self.is_error = is_error - self.buffer = "" - - def write(self, data): - global _output_to_log - - interpreter = None - if "value" in dir(PythonScriptingInstance._interpreter): - interpreter = PythonScriptingInstance._interpreter.value - - if interpreter is None: - if _output_to_log: - self.buffer += data - while True: - i = self.buffer.find('\n') - if i == -1: - break - line = self.buffer[:i] - self.buffer = self.buffer[i + 1:] - - if self.is_error: - log_error(line) - else: - log_info(line) - else: - self.orig.write(data) - else: - PythonScriptingInstance._interpreter.value = None - try: - if self.is_error: - interpreter.instance.error(data) - else: - interpreter.instance.output(data) - finally: - PythonScriptingInstance._interpreter.value = interpreter - -class _PythonScriptingInstanceInput(object): - def __init__(self, orig): - self.orig = orig - - def read(self, size): - interpreter = None - if "value" in dir(PythonScriptingInstance._interpreter): - interpreter = PythonScriptingInstance._interpreter.value - - if interpreter is None: - return self.orig.read(size) - else: - PythonScriptingInstance._interpreter.value = None - try: - result = interpreter.read(size) - finally: - PythonScriptingInstance._interpreter.value = interpreter - return result - - def readline(self): - interpreter = None - if "value" in dir(PythonScriptingInstance._interpreter): - interpreter = PythonScriptingInstance._interpreter.value - - if interpreter is None: - return self.orig.readline() - else: - result = "" - while True: - data = interpreter.read(1) - result += data - if (len(data) == 0) or (data == "\n"): - break - return result - -class PythonScriptingInstance(ScriptingInstance): - _interpreter = threading.local() - - class InterpreterThread(threading.Thread): - def __init__(self, instance): - super(PythonScriptingInstance.InterpreterThread, self).__init__() - self.instance = instance - self.locals = {"__name__": "__console__", "__doc__": None, "binaryninja": sys.modules[__name__]} - self.interpreter = code.InteractiveInterpreter(self.locals) - self.event = threading.Event() - self.daemon = True - - # Latest selections from UI - self.current_view = None - self.current_func = None - self.current_block = None - self.current_addr = 0 - self.current_selection_begin = 0 - self.current_selection_end = 0 - - # Selections that were current as of last issued command - self.active_view = None - self.active_func = None - self.active_block = None - self.active_addr = 0 - self.active_selection_begin = 0 - self.active_selection_end = 0 - - self.locals["get_selected_data"] = self.get_selected_data - self.locals["write_at_cursor"] = self.write_at_cursor - - self.exit = False - self.code = None - self.input = "" - - self.interpreter.runsource("from binaryninja import *\n") - - def execute(self, code): - self.code = code - self.event.set() - - def add_input(self, data): - self.input += data - self.event.set() - - def end(self): - self.exit = True - self.event.set() - - def read(self, size): - while not self.exit: - if len(self.input) > size: - result = self.input[:size] - self.input = self.input[size:] - return result - elif len(self.input) > 0: - result = self.input - self.input = "" - return result - self.instance.input_ready_state = core.ReadyForScriptProgramInput - self.event.wait() - self.event.clear() - return "" - - def run(self): - while not self.exit: - self.event.wait() - self.event.clear() - if self.exit: - break - if self.code is not None: - self.instance.input_ready_state = core.NotReadyForInput - code = self.code - self.code = None - - PythonScriptingInstance._interpreter.value = self - try: - self.active_view = self.current_view - self.active_func = self.current_func - self.active_block = self.current_block - self.active_addr = self.current_addr - self.active_selection_begin = self.current_selection_begin - self.active_selection_end = self.current_selection_end - - self.locals["current_view"] = self.active_view - self.locals["bv"] = self.active_view - self.locals["current_function"] = self.active_func - self.locals["current_basic_block"] = self.active_block - self.locals["current_address"] = self.active_addr - self.locals["here"] = self.active_addr - self.locals["current_selection"] = (self.active_selection_begin, self.active_selection_end) - - self.interpreter.runsource(code) - - if self.locals["here"] != self.active_addr: - if not self.active_view.file.navigate(self.active_view.file.view, self.locals["here"]): - sys.stderr.write("Address 0x%x is not valid for the current view\n" % self.locals["here"]) - elif self.locals["current_address"] != self.active_addr: - if not self.active_view.file.navigate(self.active_view.file.view, self.locals["current_address"]): - sys.stderr.write("Address 0x%x is not valid for the current view\n" % self.locals["current_address"]) - except: - traceback.print_exc() - finally: - PythonScriptingInstance._interpreter.value = None - self.instance.input_ready_state = core.ReadyForScriptExecution - - def get_selected_data(self): - if self.active_view is None: - return None - length = self.active_selection_end - self.active_selection_begin - return self.active_view.read(self.active_selection_begin, length) - - def write_at_cursor(self, data): - if self.active_view is None: - return 0 - selected_length = self.active_selection_end - self.active_selection_begin - data = str(data) - if (len(data) == selected_length) or (selected_length == 0): - return self.active_view.write(self.active_selection_begin, data) - else: - self.active_view.remove(self.active_selection_begin, selected_length) - return self.active_view.insert(self.active_selection_begin, data) - - def __init__(self, provider): - super(PythonScriptingInstance, self).__init__(provider) - self.interpreter = PythonScriptingInstance.InterpreterThread(self) - self.interpreter.start() - self.queued_input = "" - self.input_ready_state = core.ReadyForScriptExecution - - @abc.abstractmethod - def perform_destroy_instance(self): - self.interpreter.end() - - @abc.abstractmethod - def perform_execute_script_input(self, text): - if self.input_ready_state == core.NotReadyForInput: - return core.InvalidScriptInput - - if self.input_ready_state == core.ReadyForScriptProgramInput: - if len(text) == 0: - return core.SuccessfulScriptExecution - self.input_ready_state = core.NotReadyForInput - self.interpreter.add_input(text) - return core.SuccessfulScriptExecution - - try: - result = code.compile_command(text) - except: - result = False - - if result is None: - # Command is not complete, ask for more input - return core.IncompleteScriptInput - - self.input_ready_state = core.NotReadyForInput - self.interpreter.execute(text) - return core.SuccessfulScriptExecution - - @abc.abstractmethod - def perform_set_current_binary_view(self, view): - self.interpreter.current_view = view - - @abc.abstractmethod - def perform_set_current_function(self, func): - self.interpreter.current_func = func - - @abc.abstractmethod - def perform_set_current_basic_block(self, block): - self.interpreter.current_block = block - - @abc.abstractmethod - def perform_set_current_address(self, addr): - self.interpreter.current_addr = addr - - @abc.abstractmethod - def perform_set_current_selection(self, begin, end): - self.interpreter.current_selection_begin = begin - self.interpreter.current_selection_end = end - -class PythonScriptingProvider(ScriptingProvider): - name = "Python" - instance_class = PythonScriptingInstance - -class MainThreadAction(object): - def __init__(self, handle): - self.handle = handle - - def __del__(self): - core.BNFreeMainThreadAction(self.handle) - - def execute(self): - core.BNExecuteMainThreadAction(self.handle) - - @property - def done(self): - return core.BNIsMainThreadActionDone(self.handle) - - def wait(self): - core.BNWaitForMainThreadAction(self.handle) - -class MainThreadActionHandler(object): - _main_thread = None - - def __init__(self): - self._cb = core.BNMainThreadCallbacks() - self._cb.context = 0 - self._cb.addAction = self._cb.addAction.__class__(self._add_action) - - def register(self): - self.__class__._main_thread = self - core.BNRegisterMainThread(self._cb) - - def _add_action(self, ctxt, action): - try: - self.add_action(MainThreadAction(action)) - except: - log_error(traceback.format_exc()) - - def add_action(self, action): - pass - -class _BackgroundTaskMetaclass(type): - @property - def list(self): - """List all running background tasks (read-only)""" - count = ctypes.c_ulonglong() - tasks = core.BNGetRunningBackgroundTasks(count) - result = [] - for i in xrange(0, count.value): - result.append(BackgroundTask(core.BNNewBackgroundTaskReference(tasks[i]))) - core.BNFreeBackgroundTaskList(tasks) - return result - - def __iter__(self): - _init_plugins() - count = ctypes.c_ulonglong() - tasks = core.BNGetRunningBackgroundTasks(count) - try: - for i in xrange(0, count.value): - yield BackgroundTask(core.BNNewBackgroundTaskReference(tasks[i])) - finally: - core.BNFreeBackgroundTaskList(tasks) - -class BackgroundTask(object): - __metaclass__ = _BackgroundTaskMetaclass - - def __init__(self, initial_progress_text = "", can_cancel = False, handle = None): - if handle is None: - self.handle = core.BNBeginBackgroundTask(initial_progress_text, can_cancel) - else: - self.handle = handle - - def __del__(self): - core.BNFreeBackgroundTask(self.handle) - - @property - def progress(self): - """Text description of the progress of the background task (displayed in status bar of the UI)""" - return core.BNGetBackgroundTaskProgressText(self.handle) - - @progress.setter - def progress(self, value): - core.BNSetBackgroundTaskProgressText(self.handle, str(value)) - - @property - def can_cancel(self): - """Whether the task can be cancelled (read-only)""" - return core.BNCanCancelBackgroundTask(self.handle) - - @property - def finished(self): - """Whether the task has finished""" - return core.BNIsBackgroundTaskFinished(self.handle) - - @finished.setter - def finished(self, value): - if value: - self.finish() - - def finish(self): - core.BNFinishBackgroundTask(self.handle) - - @property - def cancelled(self): - """Whether the task has been cancelled""" - return core.BNIsBackgroundTaskCancelled(self.handle) - - @cancelled.setter - def cancelled(self, value): - if value: - self.cancel() - - def cancel(self): - core.BNCancelBackgroundTask(self.handle) - -class BackgroundTaskThread(BackgroundTask): - def __init__(self, initial_progress_text = "", can_cancel = False): - class _Thread(threading.Thread): - def __init__(self, task): - threading.Thread.__init__(self) - self.task = task - - def run(self): - self.task.run() - self.task.finish() - self.task = None - - BackgroundTask.__init__(self, initial_progress_text, can_cancel) - self.thread = _Thread(self) - - def run(self): - pass - - def start(self): - self.thread.start() - - def join(self): - self.thread.join() - -class LabelField(object): - def __init__(self, text): - self.text = text - - def _fill_core_struct(self, value): - value.type = core.LabelFormField - value.prompt = self.text - - def _fill_core_result(self, value): - pass - - def _get_result(self, value): - pass - -class SeparatorField(object): - def _fill_core_struct(self, value): - value.type = core.SeparatorFormField - - def _fill_core_result(self, value): - pass - - def _get_result(self, value): - pass - -class TextLineField(object): - def __init__(self, prompt): - self.prompt = prompt - self.result = None - - def _fill_core_struct(self, value): - value.type = core.TextLineFormField - value.prompt = self.prompt - - def _fill_core_result(self, value): - value.stringResult = core.BNAllocString(str(self.result)) - - def _get_result(self, value): - self.result = value.stringResult - -class MultilineTextField(object): - def __init__(self, prompt): - self.prompt = prompt - self.result = None - - def _fill_core_struct(self, value): - value.type = core.MultilineTextFormField - value.prompt = self.prompt - - def _fill_core_result(self, value): - value.stringResult = core.BNAllocString(str(self.result)) - - def _get_result(self, value): - self.result = value.stringResult - -class IntegerField(object): - def __init__(self, prompt): - self.prompt = prompt - self.result = None - - def _fill_core_struct(self, value): - value.type = core.IntegerFormField - value.prompt = self.prompt - - def _fill_core_result(self, value): - value.intResult = self.result - - def _get_result(self, value): - self.result = value.intResult - -class AddressField(object): - def __init__(self, prompt, view = None, current_address = 0): - self.prompt = prompt - self.view = view - self.current_address = current_address - self.result = None - - def _fill_core_struct(self, value): - value.type = core.AddressFormField - value.prompt = self.prompt - value.view = None - if self.view is not None: - value.view = self.view.handle - value.currentAddress = self.current_address - - def _fill_core_result(self, value): - value.addressResult = self.result - - def _get_result(self, value): - self.result = value.addressResult - -class ChoiceField(object): - def __init__(self, prompt, choices): - self.prompt = prompt - self.choices = choices - self.result = None - - def _fill_core_struct(self, value): - value.type = core.ChoiceFormField - value.prompt = self.prompt - choice_buf = (ctypes.c_char_p * len(self.choices))() - for i in xrange(0, len(self.choices)): - choice_buf[i] = str(self.choices[i]) - value.choices = choice_buf - value.count = len(self.choices) - - def _fill_core_result(self, value): - value.indexResult = self.result - - def _get_result(self, value): - self.result = value.indexResult - -class OpenFileNameField(object): - def __init__(self, prompt, ext = ""): - self.prompt = prompt - self.ext = ext - self.result = None - - def _fill_core_struct(self, value): - value.type = core.OpenFileNameFormField - value.prompt = self.prompt - value.ext = self.ext - - def _fill_core_result(self, value): - value.stringResult = core.BNAllocString(str(self.result)) - - def _get_result(self, value): - self.result = value.stringResult - -class SaveFileNameField(object): - def __init__(self, prompt, ext = "", default_name = ""): - self.prompt = prompt - self.ext = ext - self.default_name = default_name - self.result = None - - def _fill_core_struct(self, value): - value.type = core.SaveFileNameFormField - value.prompt = self.prompt - value.ext = self.ext - value.defaultName = self.default_name - - def _fill_core_result(self, value): - value.stringResult = core.BNAllocString(str(self.result)) - - def _get_result(self, value): - self.result = value.stringResult - -class DirectoryNameField(object): - def __init__(self, prompt, default_name = ""): - self.prompt = prompt - self.default_name = default_name - self.result = None - - def _fill_core_struct(self, value): - value.type = core.DirectoryNameField - value.prompt = self.prompt - value.defaultName = self.default_name - - def _fill_core_result(self, value): - value.stringResult = core.BNAllocString(str(self.result)) - - def _get_result(self, value): - self.result = value.stringResult - -class InteractionHandler(object): - _interaction_handler = None - - def __init__(self): - self._cb = core.BNInteractionHandlerCallbacks() - self._cb.context = 0 - self._cb.showPlainTextReport = self._cb.showPlainTextReport.__class__(self._show_plain_text_report) - self._cb.showMarkdownReport = self._cb.showMarkdownReport.__class__(self._show_markdown_report) - self._cb.showHTMLReport = self._cb.showHTMLReport.__class__(self._show_html_report) - self._cb.getTextLineInput = self._cb.getTextLineInput.__class__(self._get_text_line_input) - self._cb.getIntegerInput = self._cb.getIntegerInput.__class__(self._get_int_input) - self._cb.getAddressInput = self._cb.getAddressInput.__class__(self._get_address_input) - self._cb.getChoiceInput = self._cb.getChoiceInput.__class__(self._get_choice_input) - self._cb.getOpenFileNameInput = self._cb.getOpenFileNameInput.__class__(self._get_open_filename_input) - self._cb.getSaveFileNameInput = self._cb.getSaveFileNameInput.__class__(self._get_save_filename_input) - self._cb.getDirectoryNameInput = self._cb.getDirectoryNameInput.__class__(self._get_directory_name_input) - self._cb.getFormInput = self._cb.getFormInput.__class__(self._get_form_input) - self._cb.showMessageBox = self._cb.showMessageBox.__class__(self._show_message_box) - - def register(self): - self.__class__._interaction_handler = self - core.BNRegisterInteractionHandler(self._cb) - - def _show_plain_text_report(self, ctxt, view, title, contents): - try: - if view: - view = BinaryView(handle = core.BNNewViewReference(view)) - else: - view = None - self.show_plain_text_report(view, title, contents) - except: - log_error(traceback.format_exc()) - - def _show_markdown_report(self, ctxt, view, title, contents, plaintext): - try: - if view: - view = BinaryView(handle = core.BNNewViewReference(view)) - else: - view = None - self.show_markdown_report(view, title, contents, plaintext) - except: - log_error(traceback.format_exc()) - - def _show_html_report(self, ctxt, view, title, contents, plaintext): - try: - if view: - view = BinaryView(handle = core.BNNewViewReference(view)) - else: - view = None - self.show_html_report(view, title, contents, plaintext) - except: - log_error(traceback.format_exc()) - - def _get_text_line_input(self, ctxt, result, prompt, title): - try: - value = self.get_text_line_input(prompt, title) - if value is None: - return False - result[0] = core.BNAllocString(str(value)) - return True - except: - log_error(traceback.format_exc()) - - def _get_int_input(self, ctxt, result, prompt, title): - try: - value = self.get_int_input(prompt, title) - if value is None: - return False - result[0] = value - return True - except: - log_error(traceback.format_exc()) - - def _get_address_input(self, ctxt, result, prompt, title, view, current_address): - try: - if view: - view = BinaryView(handle = core.BNNewViewReference(view)) - else: - view = None - value = self.get_address_input(prompt, title, view, current_address) - if value is None: - return False - result[0] = value - return True - except: - log_error(traceback.format_exc()) - - def _get_choice_input(self, ctxt, result, prompt, title, choice_buf, count): - try: - choices = [] - for i in xrange(0, count): - choices.append(choice_buf[i]) - value = self.get_choice_input(prompt, title, choices) - if value is None: - return False - result[0] = value - return True - except: - log_error(traceback.format_exc()) - - def _get_open_filename_input(self, ctxt, result, prompt, ext): - try: - value = self.get_open_filename_input(prompt, ext) - if value is None: - return False - result[0] = core.BNAllocString(str(value)) - return True - except: - log_error(traceback.format_exc()) - - def _get_save_filename_input(self, ctxt, result, prompt, ext, default_name): - try: - value = self.get_save_filename_input(prompt, ext, default_name) - if value is None: - return False - result[0] = core.BNAllocString(str(value)) - return True - except: - log_error(traceback.format_exc()) - - def _get_directory_name_input(self, ctxt, result, prompt, default_name): - try: - value = self.get_directory_name_input(prompt, default_name) - if value is None: - return False - result[0] = core.BNAllocString(str(value)) - return True - except: - log_error(traceback.format_exc()) - - def _get_form_input(self, ctxt, fields, count, title): - try: - field_objs = [] - for i in xrange(0, count): - if fields[i].type == core.LabelFormField: - field_objs.append(LabelField(fields[i].prompt)) - elif fields[i].type == core.SeparatorFormField: - field_objs.append(SeparatorField()) - elif fields[i].type == core.TextLineFormField: - field_objs.append(TextLineField(fields[i].prompt)) - elif fields[i].type == core.MultilineTextFormField: - field_objs.append(MultilineTextField(fields[i].prompt)) - elif fields[i].type == core.IntegerFormField: - field_objs.append(IntegerField(fields[i].prompt)) - elif fields[i].type == core.AddressFormField: - view = None - if fields[i].view: - view = BinaryView(handle = core.BNNewViewReference(fields[i].view)) - field_objs.append(AddressField(fields[i].prompt, view, fields[i].currentAddress)) - elif fields[i].type == core.ChoiceFormField: - choices = [] - for i in xrange(0, fields[i].count): - choices.append(fields[i].choices[i]) - field_objs.append(ChoiceField(fields[i].prompt, choices)) - elif fields[i].type == core.OpenFileNameFormField: - field_objs.append(OpenFileNameField(fields[i].prompt, fields[i].ext)) - elif fields[i].type == core.SaveFileNameFormField: - field_objs.append(SaveFileNameField(fields[i].prompt, fields[i].ext, fields[i].defaultName)) - elif fields[i].type == core.DirectoryNameField: - field_objs.append(DirectoryNameField(fields[i].prompt, fields[i].defaultName)) - else: - field_objs.append(LabelField(fields[i].prompt)) - if not self.get_form_input(field_objs, title): - return False - for i in xrange(0, count): - field_objs[i]._fill_core_result(fields[i]) - return True - except: - log_error(traceback.format_exc()) - - def _show_message_box(self, ctxt, title, text, buttons, icon): - try: - return self.show_message_box(title, text, buttons, icon) - except: - log_error(traceback.format_exc()) - - def show_plain_text_report(self, view, title, contents): - pass - - def show_markdown_report(self, view, title, contents, plaintext): - self.show_html_report(view, title, markdown_to_html(contents), plaintext) - - def show_html_report(self, view, title, contents, plaintext): - if len(plaintext) != 0: - self.show_plain_text_report(view, title, plaintext) - - def get_text_line_input(self, prompt, title): - return None - - def get_int_input(self, prompt, title): - while True: - text = self.get_text_line_input(prompt, title) - if len(text) == 0: - return False - try: - return int(text) - except: - continue - - def get_address_input(self, prompt, title, view, current_address): - return get_int_input(prompt, title) - - def get_choice_input(self, prompt, title, choices): - return None - - def get_open_filename_input(self, prompt, ext): - return get_text_line_input(prompt, "Open File") - - def get_save_filename_input(self, prompt, ext, default_name): - return get_text_line_input(title, "Save File") - - def get_directory_name_input(self, prompt, default_name): - return get_text_line_input(title, "Select Directory") - - def get_form_input(self, fields, title): - return False - - def show_message_box(self, title, text, buttons, icon): - return core.CancelButton - -class _DestructionCallbackHandler: +# Binary Ninja components +import _binaryninjacore as core +from databuffer import * +from filemetadata import * +from fileaccessor import * +from binaryview import * +from transform import * +from architecture import * +from basicblock import * +from function import * +from log import * +from lowlevelil import * +from bntype import * +from functionrecognizer import * +from update import * +from plugin import * +from callingconvention import * +from platform import * +from demangle import * +from mainthread import * +from interaction import * +from lineardisassembly import * +from undoaction import * +from highlight import * + + +class _DestructionCallbackHandler(object): def __init__(self): self._cb = core.BNObjectDestructionCallbacks() self._cb.context = 0 @@ -10754,436 +63,11 @@ class _DestructionCallbackHandler: def destruct_function(self, ctxt, func): Function._unregister(func) -_destruct_callbacks = _DestructionCallbackHandler() - -def LLIL_TEMP(n): - return n | 0x80000000 - -def LLIL_REG_IS_TEMP(n): - return (n & 0x80000000) != 0 - -def LLIL_GET_TEMP_REG_INDEX(n): - return n & 0x7fffffff - -def shutdown(): - core.BNShutdown() - -def log(level, text): - """ - ``log`` writes messages to the log console for the given log level. - - ============ ======== ======================================================================= - LogLevelName LogLevel Description - ============ ======== ======================================================================= - DebugLog 0 Logs debuging information messages to the console. - InfoLog 1 Logs general information messages to the console. - WarningLog 2 Logs message to console with **Warning** icon. - ErrorLog 3 Logs message to console with **Error** icon, focusing the error console. - AlertLog 4 Logs message to pop up window. - ============ ======== ======================================================================= - - :param LogLevel level: Log level to use - :param str text: message to print - :rtype: None - """ - core.BNLog(level, "%s", str(text)) - -def log_debug(text): - """ - ``log_debug`` Logs debuging information messages to the console. - - :param str text: message to print - :rtype: None - :Example: - - >>> log_to_stdout(core.DebugLog) - >>> log_debug("Hotdogs!") - Hotdogs! - """ - core.BNLogDebug("%s", str(text)) - -def log_info(text): - """ - ``log_info`` Logs general information messages to the console. - - :param str text: message to print - :rtype: None - :Example: - - >>> log_info("Saucisson!") - Saucisson! - >>> - """ - core.BNLogInfo("%s", str(text)) - -def log_warn(text): - """ - ``log_warn`` Logs message to console, if run through the GUI it logs with **Warning** icon. - - :param str text: message to print - :rtype: None - :Example: - >>> log_to_stdout(core.DebugLog) - >>> log_info("Chilidogs!") - Chilidogs! - >>> - """ - core.BNLogWarn("%s", str(text)) - -def log_error(text): - """ - ``log_error`` Logs message to console, if run through the GUI it logs with **Error** icon, focusing the error console. - - :param str text: message to print - :rtype: None - :Example: - - >>> log_to_stdout(core.DebugLog) - >>> log_error("Spanferkel!") - Spanferkel! - >>> - """ - core.BNLogError("%s", str(text)) - -def log_alert(text): - """ - ``log_alert`` Logs message console and to a pop up window if run through the GUI. - - :param str text: message to print - :rtype: None - :Example: - - >>> log_to_stdout(core.DebugLog) - >>> log_alert("Kielbasa!") - Kielbasa! - >>> - """ - core.BNLogAlert("%s", str(text)) - -def log_to_stdout(min_level): - """ - ``log_to_stdout`` redirects minimum log level to standard out. - - :param int min_level: minimum level to log to - :rtype: None - :Example: - - >>> log_debug("Hotdogs!") - >>> log_to_stdout(core.DebugLog) - >>> log_debug("Hotdogs!") - Hotdogs! - >>> - """ - core.BNLogToStdout(min_level) - -def log_to_stderr(min_level): - """ - ``log_to_stderr`` redirects minimum log level to standard error. - - :param int min_level: minimum level to log to - :rtype: None - """ - core.BNLogToStderr(min_level) - -def log_to_file(min_level, path, append = False): - """ - ``log_to_file`` redirects minimum log level to a file named ``path``, optionally appending rather than overwritting. - - :param int min_level: minimum level to log to - :param str path: path to log to - :param bool append: optional flag for specifying appending. True = append, False = overwrite. - :rtype: None - """ - core.BNLogToFile(min_level, str(path), append) - -def close_logs(): - """ - ``close_logs`` close all log files. - - :rtype: None - """ - core.BNCloseLogs() - -def escape_string(text): - return DataBuffer(text).escape() - -def unescape_string(text): - return DataBuffer(text).unescape() - -def preprocess_source(source, filename = None, include_dirs = []): - """ - ``preprocess_source`` run the C preprocessor on the given source or source filename. - - :param str source: source to preprocess - :param str filename: optional filename to preprocess - :param list(str) include_dirs: list of string directorires to use as include directories. - :return: returns a tuple of (preprocessed_source, error_string) - :rtype: tuple(str,str) - :Example: - - >>> source = "#define TEN 10\\nint x[TEN];\\n" - >>> preprocess_source(source) - ('#line 1 "input"\\n\\n#line 2 "input"\\n int x [ 10 ] ;\\n', '') - >>> - """ - if filename is None: - filename = "input" - dir_buf = (ctypes.c_char_p * len(include_dirs))() - for i in xrange(0, len(include_dirs)): - dir_buf[i] = str(include_dirs[i]) - output = ctypes.c_char_p() - errors = ctypes.c_char_p() - result = core.BNPreprocessSource(source, filename, output, errors, dir_buf, len(include_dirs)) - output_str = output.value - error_str = errors.value - core.BNFreeString(ctypes.cast(output, ctypes.POINTER(ctypes.c_byte))) - core.BNFreeString(ctypes.cast(errors, ctypes.POINTER(ctypes.c_byte))) - if result: - return (output_str, error_str) - return (None, error_str) - -def are_auto_updates_enabled(): - """ - ``are_auto_updates_enabled`` queries if auto updates are enabled. - - :return: boolean True if auto updates are enabled. False if they are disabled. - :rtype: bool - """ - return core.BNAreAutoUpdatesEnabled() - -def set_auto_updates_enabled(enabled): - """ - ``set_auto_updates_enabled`` sets auto update enabled status. - - :param bool enabled: True to enable update, Flase to disable updates. - :rtype: None - """ - core.BNSetAutoUpdatesEnabled(enabled) - -def get_time_since_last_update_check(): - """ - ``get_time_since_last_update_check`` returns the time stamp for the last time updates were checked. - - :return: time stacmp for last update check - :rtype: int - """ - return core.BNGetTimeSinceLastUpdateCheck() - -def updates_checked(): - core.BNUpdatesChecked() - -def get_qualified_name(names): - """ - ``get_qualified_name`` gets a qualified name for the provied name list. - - :param list(str) names: name list to qualify - :return: a qualified name - :rtype: str - :Example: - - >>> type, name = demangle_ms(Architecture["x86_64"], "?testf@Foobar@@SA?AW4foo@1@W421@@Z") - >>> get_qualified_name(name) - 'Foobar::testf' - >>> - """ - return "::".join(names) - -def demangle_ms(arch, mangled_name): - """ - ``demangle_ms`` demangles a mangled Microsoft Visual Studio C++ name to a Type object. - - :param Architecture arch: Architecture for the symbol. Required for pointer and integer sizes. - :param str mangled_name: a mangled Microsoft Visual Studio C++ name - :return: returns a Type object for the mangled name - :rtype: Type - :Example: - - >>> demangle_ms(Architecture["x86_64"], "?testf@Foobar@@SA?AW4foo@1@W421@@Z") - (, ['Foobar', 'testf']) - >>> - """ - handle = ctypes.POINTER(core.BNType)() - outName = ctypes.POINTER(ctypes.c_char_p)() - outSize = ctypes.c_ulonglong() - names = [] - if core.BNDemangleMS(arch.handle, mangled_name, ctypes.byref(handle), ctypes.byref(outName), ctypes.byref(outSize)): - for i in xrange(outSize.value): - names.append(outName[i]) - #core.BNFreeDemangledName(outName.value, outSize.value) - return (Type(handle), names) - return (None, mangledName) - - -def demangle_gnu3(arch, mangled_name): - handle = ctypes.POINTER(core.BNType)() - outName = ctypes.POINTER(ctypes.c_char_p)() - outSize = ctypes.c_ulonglong() - names = [] - if core.BNDemangleGNU3(arch.handle, mangled_name, ctypes.byref(handle), ctypes.byref(outName), ctypes.byref(outSize)): - for i in xrange(outSize.value): - names.append(outName[i]) - #core.BNFreeDemangledName(outName.value, outSize.value) - if not handle: - return (None, names) - return (Type(handle), names) - return (None, mangled_name) - - -_output_to_log = False -def redirect_output_to_log(): - global _output_to_log - _output_to_log = True - -class _ThreadActionContext(object): - _actions = [] - - def __init__(self, func): - self.func = func - self.interpreter = None - if "value" in dir(PythonScriptingInstance._interpreter): - self.interpreter = PythonScriptingInstance._interpreter.value - self.__class__._actions.append(self) - self.callback = ctypes.CFUNCTYPE(None, ctypes.c_void_p)(lambda ctxt: self.execute()) - - def execute(self): - old_interpreter = None - if "value" in dir(PythonScriptingInstance._interpreter): - old_interpreter = PythonScriptingInstance._interpreter.value - PythonScriptingInstance._interpreter.value = self.interpreter - try: - self.func() - finally: - PythonScriptingInstance._interpreter.value = old_interpreter - self.__class__._actions.remove(self) - -def execute_on_main_thread(func): - action = _ThreadActionContext(func) - obj = core.BNExecuteOnMainThread(0, action.callback) - if obj: - return MainThreadAction(obj) - return None - -def execute_on_main_thread_and_wait(func): - action = _ThreadActionContext(func) - core.BNExecuteOnMainThreadAndWait(0, action.callback) - -def worker_enqueue(func): - action = _ThreadActionContext(func) - core.BNWorkerEnqueue(0, action.callback) - -def worker_priority_enqueue(func): - action = _ThreadActionContext(func) - core.BNWorkerPriorityEnqueue(0, action.callback) - -def worker_interactive_enqueue(func): - action = _ThreadActionContext(func) - core.BNWorkerInteractiveEnqueue(0, action.callback) - -def get_worker_thread_count(): - return core.BNGetWorkerThreadCount() - -def set_worker_thread_count(count): - core.BNSetWorkerThreadCount(count) - -def markdown_to_html(contents): - return core.BNMarkdownToHTML(contents) - -def show_plain_text_report(title, contents): - core.BNShowPlainTextReport(None, title, contents) - -def show_markdown_report(title, contents, plaintext = ""): - core.BNShowMarkdownReport(None, title, contents, plaintext) - -def show_html_report(title, contents, plaintext = ""): - core.BNShowHTMLReport(None, title, contents, plaintext) - -def get_text_line_input(prompt, title): - value = ctypes.c_char_p() - if not core.BNGetTextLineInput(value, prompt, title): - return None - result = value.value - core.BNFreeString(ctypes.cast(value, ctypes.POINTER(ctypes.c_byte))) - return result - -def get_int_input(prompt, title): - value = ctypes.c_longlong() - if not core.BNGetIntegerInput(value, prompt, title): - return None - return value.value - -def get_address_input(prompt, title): - value = ctypes.c_ulonglong() - if not core.BNGetAddressInput(value, prompt, title, None, 0): - return None - return value.value - -def get_choice_input(prompt, title, choices): - choice_buf = (ctypes.c_char_p * len(choices))() - for i in xrange(0, len(choices)): - choice_buf[i] = str(choices[i]) - value = ctypes.c_ulonglong() - if not core.BNGetChoiceInput(value, prompt, title, choice_buf, len(choices)): - return None - return value.value - -def get_open_filename_input(prompt, ext = ""): - value = ctypes.c_char_p() - if not core.BNGetOpenFileNameInput(value, prompt, ext): - return None - result = value.value - core.BNFreeString(ctypes.cast(value, ctypes.POINTER(ctypes.c_byte))) - return result - -def get_save_filename_input(prompt, ext = "", default_name = ""): - value = ctypes.c_char_p() - if not core.BNGetSaveFileNameInput(value, prompt, ext, default_name): - return None - result = value.value - core.BNFreeString(ctypes.cast(value, ctypes.POINTER(ctypes.c_byte))) - return result - -def get_directory_name_input(prompt, default_name = ""): - value = ctypes.c_char_p() - if not core.BNGetDirectoryNameInput(value, prompt, default_name): - return None - result = value.value - core.BNFreeString(ctypes.cast(value, ctypes.POINTER(ctypes.c_byte))) - return result - -def get_form_input(fields, title): - value = (core.BNFormInputField * len(fields))() - for i in xrange(0, len(fields)): - if isinstance(fields[i], str): - LabelField(fields[i])._fill_core_struct(value[i]) - elif fields[i] is None: - SeparatorField()._fill_core_struct(value[i]) - else: - fields[i]._fill_core_struct(value[i]) - if not core.BNGetFormInput(value, len(fields), title): - return False - for i in xrange(0, len(fields)): - if not (isinstance(fields[i], str) or (fields[i] is None)): - fields[i]._get_result(value[i]) - core.BNFreeFormInputResults(value, len(fields)) - return True - -def show_message_box(title, text, buttons = core.OKButtonSet, icon = core.InformationIcon): - return core.BNShowMessageBox(title, text, buttons, icon) +_destruct_callbacks = _DestructionCallbackHandler() bundled_plugin_path = core.BNGetBundledPluginDirectory() user_plugin_path = core.BNGetUserPluginDirectory() core_version = core.BNGetVersionString() core_build_id = core.BNGetBuildId() - -# Ensure all enumeration constants from the core are exposed by this module -for name in core.all_enum_values: - globals()[name] = core.all_enum_values[name] - -PythonScriptingProvider().register() - -# Wrap stdin/stdout/stderr for Python scripting provider implementation -sys.stdin = _PythonScriptingInstanceInput(sys.stdin) -sys.stdout = _PythonScriptingInstanceOutput(sys.stdout, False) -sys.stderr = _PythonScriptingInstanceOutput(sys.stderr, True) -- cgit v1.3.1 From a6842fc4209ed0bc160222ee61b2e6d9741dc9ef Mon Sep 17 00:00:00 2001 From: plafosse Date: Mon, 31 Oct 2016 16:06:34 -0400 Subject: Refactoring and other improvements of the python api --- python/__init__.py | 55 ++- python/architecture.py | 6 + python/binaryview.py | 35 +- python/enum/LICENSE | 32 ++ python/enum/README | 3 + python/enum/__init__.py | 837 ++++++++++++++++++++++++++++++++ python/examples/bin_info.py | 66 ++- python/examples/instruction_iterator.py | 28 +- python/platform.py | 9 + 9 files changed, 994 insertions(+), 77 deletions(-) create mode 100644 python/enum/LICENSE create mode 100644 python/enum/README create mode 100644 python/enum/__init__.py (limited to 'python/__init__.py') diff --git a/python/__init__.py b/python/__init__.py index 402c8526..f38395c8 100644 --- a/python/__init__.py +++ b/python/__init__.py @@ -19,31 +19,38 @@ # IN THE SOFTWARE. -# Binary Ninja components -import _binaryninjacore as core -from databuffer import * -from filemetadata import * -from fileaccessor import * -from binaryview import * -from transform import * -from architecture import * -from basicblock import * -from function import * -from log import * -from lowlevelil import * -from bntype import * -from functionrecognizer import * -from update import * -from plugin import * -from callingconvention import * -from platform import * -from demangle import * -from mainthread import * -from interaction import * -from lineardisassembly import * -from undoaction import * -from highlight import * +import sys + +# Binary Ninja components +try: + import _binaryninjacore as core + from databuffer import * + from filemetadata import * + from fileaccessor import * + from binaryview import * + from transform import * + from architecture import * + from basicblock import * + from function import * + from log import * + from lowlevelil import * + from bntype import * + from functionrecognizer import * + from update import * + from plugin import * + from callingconvention import * + from platform import * + from demangle import * + from mainthread import * + from interaction import * + from lineardisassembly import * + from undoaction import * + from highlight import * +except: + x = open("/Users/peterl/path", "w") + x.write(str(sys.exc_info())) + x.close() class _DestructionCallbackHandler(object): def __init__(self): diff --git a/python/architecture.py b/python/architecture.py index a8aa391b..0cdba6e5 100644 --- a/python/architecture.py +++ b/python/architecture.py @@ -1084,6 +1084,12 @@ class Architecture(object): """ return None + def get_associated_arch_by_address(self, addr): + new_addr = ctypes.c_ulonglong() + new_addr.value = addr + result = core.BNGetAssociatedArchitectureByAddress(self.handle, new_addr) + return Architecture(handle = result), new_addr.value + def get_instruction_info(self, data, addr): """ ``get_instruction_info`` returns an InstructionInfo object for the instruction at the given virtual address diff --git a/python/binaryview.py b/python/binaryview.py index 76def834..e6e0ff61 100644 --- a/python/binaryview.py +++ b/python/binaryview.py @@ -266,12 +266,6 @@ class _BinaryViewTypeMetaclass(type): raise KeyError("'%s' is not a valid view type" % str(value)) return BinaryViewType(view_type) - def __setattr__(self, name, value): - try: - type.__setattr__(self, name, value) - except AttributeError: - raise AttributeError("attribute '%s' is read only" % name) - class BinaryViewType(object): __metaclass__ = _BinaryViewTypeMetaclass @@ -304,6 +298,27 @@ class BinaryViewType(object): return None return self.create(data) + @classmethod + def get_view_of_file(cls, filename, update_analysis=True): + """ + ``get_view_of_file`` returns the first available, non-Raw `BinaryView` available. + + :param str filename: Path to filename + :param bool update_analysis: defaults to True. Pass False to not run update_analysis_and_wait. + :return: returns a BinaryView object for the given filename. + :rtype: BinaryView or None + """ + view = BinaryView.open(filename) + if view is None: + return None + for available in view.available_view_types: + if available.name != "Raw": + bv = cls[available.name].open(filename) + if update_analysis: + bv.update_analysis_and_wait() + return bv + return None + def is_valid_for_data(self, data): return core.BNIsBinaryViewTypeValidForData(self.handle, data.handle) @@ -328,12 +343,6 @@ class BinaryViewType(object): return None return platform.Platform(None, plat) - def __setattr__(self, name, value): - try: - object.__setattr__(self, name, value) - except AttributeError: - raise AttributeError("attribute '%s' is read only" % name) - class Segment(object): def __init__(self, start, length, data_offset, data_length, flags): @@ -467,7 +476,7 @@ class BinaryView(object): if file_metadata is None: file_metadata = filemetadata.FileMetadata() self.handle = core.BNCreateBinaryDataView(file_metadata.handle) - self.file = filemetadata.FileMetadata(handle=core.BNNewFileReference(file_metadata)) + self.file = filemetadata.FileMetadata(handle=core.BNNewFileReference(file_metadata.handle)) else: startup._init_plugins() if not self.__class__._registered: diff --git a/python/enum/LICENSE b/python/enum/LICENSE new file mode 100644 index 00000000..9003b885 --- /dev/null +++ b/python/enum/LICENSE @@ -0,0 +1,32 @@ +Copyright (c) 2013, Ethan Furman. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + + Redistributions of source code must retain the above + copyright notice, this list of conditions and the + following disclaimer. + + Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials + provided with the distribution. + + Neither the name Ethan Furman nor the names of any + contributors may be used to endorse or promote products + derived from this software without specific prior written + permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +POSSIBILITY OF SUCH DAMAGE. diff --git a/python/enum/README b/python/enum/README new file mode 100644 index 00000000..aa2333d8 --- /dev/null +++ b/python/enum/README @@ -0,0 +1,3 @@ +enum34 is the new Python stdlib enum module available in Python 3.4 +backported for previous versions of Python from 2.4 to 3.3. +tested on 2.6, 2.7, and 3.3+ diff --git a/python/enum/__init__.py b/python/enum/__init__.py new file mode 100644 index 00000000..d6ffb3a4 --- /dev/null +++ b/python/enum/__init__.py @@ -0,0 +1,837 @@ +"""Python Enumerations""" + +import sys as _sys + +__all__ = ['Enum', 'IntEnum', 'unique'] + +version = 1, 1, 6 + +pyver = float('%s.%s' % _sys.version_info[:2]) + +try: + any +except NameError: + def any(iterable): + for element in iterable: + if element: + return True + return False + +try: + from collections import OrderedDict +except ImportError: + OrderedDict = None + +try: + basestring +except NameError: + # In Python 2 basestring is the ancestor of both str and unicode + # in Python 3 it's just str, but was missing in 3.1 + basestring = str + +try: + unicode +except NameError: + # In Python 3 unicode no longer exists (it's just str) + unicode = str + +class _RouteClassAttributeToGetattr(object): + """Route attribute access on a class to __getattr__. + + This is a descriptor, used to define attributes that act differently when + accessed through an instance and through a class. Instance access remains + normal, but access to an attribute through a class will be routed to the + class's __getattr__ method; this is done by raising AttributeError. + + """ + def __init__(self, fget=None): + self.fget = fget + + def __get__(self, instance, ownerclass=None): + if instance is None: + raise AttributeError() + return self.fget(instance) + + def __set__(self, instance, value): + raise AttributeError("can't set attribute") + + def __delete__(self, instance): + raise AttributeError("can't delete attribute") + + +def _is_descriptor(obj): + """Returns True if obj is a descriptor, False otherwise.""" + return ( + hasattr(obj, '__get__') or + hasattr(obj, '__set__') or + hasattr(obj, '__delete__')) + + +def _is_dunder(name): + """Returns True if a __dunder__ name, False otherwise.""" + return (name[:2] == name[-2:] == '__' and + name[2:3] != '_' and + name[-3:-2] != '_' and + len(name) > 4) + + +def _is_sunder(name): + """Returns True if a _sunder_ name, False otherwise.""" + return (name[0] == name[-1] == '_' and + name[1:2] != '_' and + name[-2:-1] != '_' and + len(name) > 2) + + +def _make_class_unpicklable(cls): + """Make the given class un-picklable.""" + def _break_on_call_reduce(self, protocol=None): + raise TypeError('%r cannot be pickled' % self) + cls.__reduce_ex__ = _break_on_call_reduce + cls.__module__ = '' + + +class _EnumDict(dict): + """Track enum member order and ensure member names are not reused. + + EnumMeta will use the names found in self._member_names as the + enumeration member names. + + """ + def __init__(self): + super(_EnumDict, self).__init__() + self._member_names = [] + + def __setitem__(self, key, value): + """Changes anything not dundered or not a descriptor. + + If a descriptor is added with the same name as an enum member, the name + is removed from _member_names (this may leave a hole in the numerical + sequence of values). + + If an enum member name is used twice, an error is raised; duplicate + values are not checked for. + + Single underscore (sunder) names are reserved. + + Note: in 3.x __order__ is simply discarded as a not necessary piece + leftover from 2.x + + """ + if pyver >= 3.0 and key in ('_order_', '__order__'): + return + elif key == '__order__': + key = '_order_' + if _is_sunder(key): + if key != '_order_': + raise ValueError('_names_ are reserved for future Enum use') + elif _is_dunder(key): + pass + elif key in self._member_names: + # descriptor overwriting an enum? + raise TypeError('Attempted to reuse key: %r' % key) + elif not _is_descriptor(value): + if key in self: + # enum overwriting a descriptor? + raise TypeError('Key already defined as: %r' % self[key]) + self._member_names.append(key) + super(_EnumDict, self).__setitem__(key, value) + + +# Dummy value for Enum as EnumMeta explicity checks for it, but of course until +# EnumMeta finishes running the first time the Enum class doesn't exist. This +# is also why there are checks in EnumMeta like `if Enum is not None` +Enum = None + + +class EnumMeta(type): + """Metaclass for Enum""" + @classmethod + def __prepare__(metacls, cls, bases): + return _EnumDict() + + def __new__(metacls, cls, bases, classdict): + # an Enum class is final once enumeration items have been defined; it + # cannot be mixed with other types (int, float, etc.) if it has an + # inherited __new__ unless a new __new__ is defined (or the resulting + # class will fail). + if type(classdict) is dict: + original_dict = classdict + classdict = _EnumDict() + for k, v in original_dict.items(): + classdict[k] = v + + member_type, first_enum = metacls._get_mixins_(bases) + __new__, save_new, use_args = metacls._find_new_(classdict, member_type, + first_enum) + # save enum items into separate mapping so they don't get baked into + # the new class + members = dict((k, classdict[k]) for k in classdict._member_names) + for name in classdict._member_names: + del classdict[name] + + # py2 support for definition order + _order_ = classdict.get('_order_') + if _order_ is None: + if pyver < 3.0: + try: + _order_ = [name for (name, value) in sorted(members.items(), key=lambda item: item[1])] + except TypeError: + _order_ = [name for name in sorted(members.keys())] + else: + _order_ = classdict._member_names + else: + del classdict['_order_'] + if pyver < 3.0: + _order_ = _order_.replace(',', ' ').split() + aliases = [name for name in members if name not in _order_] + _order_ += aliases + + # check for illegal enum names (any others?) + invalid_names = set(members) & set(['mro']) + if invalid_names: + raise ValueError('Invalid enum member name(s): %s' % ( + ', '.join(invalid_names), )) + + # save attributes from super classes so we know if we can take + # the shortcut of storing members in the class dict + base_attributes = set([a for b in bases for a in b.__dict__]) + # create our new Enum type + enum_class = super(EnumMeta, metacls).__new__(metacls, cls, bases, classdict) + enum_class._member_names_ = [] # names in random order + if OrderedDict is not None: + enum_class._member_map_ = OrderedDict() + else: + enum_class._member_map_ = {} # name->value map + enum_class._member_type_ = member_type + + # Reverse value->name map for hashable values. + enum_class._value2member_map_ = {} + + # instantiate them, checking for duplicates as we go + # we instantiate first instead of checking for duplicates first in case + # a custom __new__ is doing something funky with the values -- such as + # auto-numbering ;) + if __new__ is None: + __new__ = enum_class.__new__ + for member_name in _order_: + value = members[member_name] + if not isinstance(value, tuple): + args = (value, ) + else: + args = value + if member_type is tuple: # special case for tuple enums + args = (args, ) # wrap it one more time + if not use_args or not args: + enum_member = __new__(enum_class) + if not hasattr(enum_member, '_value_'): + enum_member._value_ = value + else: + enum_member = __new__(enum_class, *args) + if not hasattr(enum_member, '_value_'): + enum_member._value_ = member_type(*args) + value = enum_member._value_ + enum_member._name_ = member_name + enum_member.__objclass__ = enum_class + enum_member.__init__(*args) + # If another member with the same value was already defined, the + # new member becomes an alias to the existing one. + for name, canonical_member in enum_class._member_map_.items(): + if canonical_member.value == enum_member._value_: + enum_member = canonical_member + break + else: + # Aliases don't appear in member names (only in __members__). + enum_class._member_names_.append(member_name) + # performance boost for any member that would not shadow + # a DynamicClassAttribute (aka _RouteClassAttributeToGetattr) + if member_name not in base_attributes: + setattr(enum_class, member_name, enum_member) + # now add to _member_map_ + enum_class._member_map_[member_name] = enum_member + try: + # This may fail if value is not hashable. We can't add the value + # to the map, and by-value lookups for this value will be + # linear. + enum_class._value2member_map_[value] = enum_member + except TypeError: + pass + + + # If a custom type is mixed into the Enum, and it does not know how + # to pickle itself, pickle.dumps will succeed but pickle.loads will + # fail. Rather than have the error show up later and possibly far + # from the source, sabotage the pickle protocol for this class so + # that pickle.dumps also fails. + # + # However, if the new class implements its own __reduce_ex__, do not + # sabotage -- it's on them to make sure it works correctly. We use + # __reduce_ex__ instead of any of the others as it is preferred by + # pickle over __reduce__, and it handles all pickle protocols. + unpicklable = False + if '__reduce_ex__' not in classdict: + if member_type is not object: + methods = ('__getnewargs_ex__', '__getnewargs__', + '__reduce_ex__', '__reduce__') + if not any(m in member_type.__dict__ for m in methods): + _make_class_unpicklable(enum_class) + unpicklable = True + + + # double check that repr and friends are not the mixin's or various + # things break (such as pickle) + for name in ('__repr__', '__str__', '__format__', '__reduce_ex__'): + class_method = getattr(enum_class, name) + obj_method = getattr(member_type, name, None) + enum_method = getattr(first_enum, name, None) + if name not in classdict and class_method is not enum_method: + if name == '__reduce_ex__' and unpicklable: + continue + setattr(enum_class, name, enum_method) + + # method resolution and int's are not playing nice + # Python's less than 2.6 use __cmp__ + + if pyver < 2.6: + + if issubclass(enum_class, int): + setattr(enum_class, '__cmp__', getattr(int, '__cmp__')) + + elif pyver < 3.0: + + if issubclass(enum_class, int): + for method in ( + '__le__', + '__lt__', + '__gt__', + '__ge__', + '__eq__', + '__ne__', + '__hash__', + ): + setattr(enum_class, method, getattr(int, method)) + + # replace any other __new__ with our own (as long as Enum is not None, + # anyway) -- again, this is to support pickle + if Enum is not None: + # if the user defined their own __new__, save it before it gets + # clobbered in case they subclass later + if save_new: + setattr(enum_class, '__member_new__', enum_class.__dict__['__new__']) + setattr(enum_class, '__new__', Enum.__dict__['__new__']) + return enum_class + + def __bool__(cls): + """ + classes/types should always be True. + """ + return True + + def __call__(cls, value, names=None, module=None, type=None, start=1): + """Either returns an existing member, or creates a new enum class. + + This method is used both when an enum class is given a value to match + to an enumeration member (i.e. Color(3)) and for the functional API + (i.e. Color = Enum('Color', names='red green blue')). + + When used for the functional API: `module`, if set, will be stored in + the new class' __module__ attribute; `type`, if set, will be mixed in + as the first base class. + + Note: if `module` is not set this routine will attempt to discover the + calling module by walking the frame stack; if this is unsuccessful + the resulting class will not be pickleable. + + """ + if names is None: # simple value lookup + return cls.__new__(cls, value) + # otherwise, functional API: we're creating a new Enum type + return cls._create_(value, names, module=module, type=type, start=start) + + def __contains__(cls, member): + return isinstance(member, cls) and member.name in cls._member_map_ + + def __delattr__(cls, attr): + # nicer error message when someone tries to delete an attribute + # (see issue19025). + if attr in cls._member_map_: + raise AttributeError( + "%s: cannot delete Enum member." % cls.__name__) + super(EnumMeta, cls).__delattr__(attr) + + def __dir__(self): + return (['__class__', '__doc__', '__members__', '__module__'] + + self._member_names_) + + @property + def __members__(cls): + """Returns a mapping of member name->value. + + This mapping lists all enum members, including aliases. Note that this + is a copy of the internal mapping. + + """ + return cls._member_map_.copy() + + def __getattr__(cls, name): + """Return the enum member matching `name` + + We use __getattr__ instead of descriptors or inserting into the enum + class' __dict__ in order to support `name` and `value` being both + properties for enum members (which live in the class' __dict__) and + enum members themselves. + + """ + if _is_dunder(name): + raise AttributeError(name) + try: + return cls._member_map_[name] + except KeyError: + raise AttributeError(name) + + def __getitem__(cls, name): + return cls._member_map_[name] + + def __iter__(cls): + return (cls._member_map_[name] for name in cls._member_names_) + + def __reversed__(cls): + return (cls._member_map_[name] for name in reversed(cls._member_names_)) + + def __len__(cls): + return len(cls._member_names_) + + __nonzero__ = __bool__ + + def __repr__(cls): + return "" % cls.__name__ + + def __setattr__(cls, name, value): + """Block attempts to reassign Enum members. + + A simple assignment to the class namespace only changes one of the + several possible ways to get an Enum member from the Enum class, + resulting in an inconsistent Enumeration. + + """ + member_map = cls.__dict__.get('_member_map_', {}) + if name in member_map: + raise AttributeError('Cannot reassign members.') + super(EnumMeta, cls).__setattr__(name, value) + + def _create_(cls, class_name, names=None, module=None, type=None, start=1): + """Convenience method to create a new Enum class. + + `names` can be: + + * A string containing member names, separated either with spaces or + commas. Values are auto-numbered from 1. + * An iterable of member names. Values are auto-numbered from 1. + * An iterable of (member name, value) pairs. + * A mapping of member name -> value. + + """ + if pyver < 3.0: + # if class_name is unicode, attempt a conversion to ASCII + if isinstance(class_name, unicode): + try: + class_name = class_name.encode('ascii') + except UnicodeEncodeError: + raise TypeError('%r is not representable in ASCII' % class_name) + metacls = cls.__class__ + if type is None: + bases = (cls, ) + else: + bases = (type, cls) + classdict = metacls.__prepare__(class_name, bases) + _order_ = [] + + # special processing needed for names? + if isinstance(names, basestring): + names = names.replace(',', ' ').split() + if isinstance(names, (tuple, list)) and isinstance(names[0], basestring): + names = [(e, i+start) for (i, e) in enumerate(names)] + + # Here, names is either an iterable of (name, value) or a mapping. + item = None # in case names is empty + for item in names: + if isinstance(item, basestring): + member_name, member_value = item, names[item] + else: + member_name, member_value = item + classdict[member_name] = member_value + _order_.append(member_name) + # only set _order_ in classdict if name/value was not from a mapping + if not isinstance(item, basestring): + classdict['_order_'] = ' '.join(_order_) + enum_class = metacls.__new__(metacls, class_name, bases, classdict) + + # TODO: replace the frame hack if a blessed way to know the calling + # module is ever developed + if module is None: + try: + module = _sys._getframe(2).f_globals['__name__'] + except (AttributeError, ValueError): + pass + if module is None: + _make_class_unpicklable(enum_class) + else: + enum_class.__module__ = module + + return enum_class + + @staticmethod + def _get_mixins_(bases): + """Returns the type for creating enum members, and the first inherited + enum class. + + bases: the tuple of bases that was given to __new__ + + """ + if not bases or Enum is None: + return object, Enum + + + # double check that we are not subclassing a class with existing + # enumeration members; while we're at it, see if any other data + # type has been mixed in so we can use the correct __new__ + member_type = first_enum = None + for base in bases: + if (base is not Enum and + issubclass(base, Enum) and + base._member_names_): + raise TypeError("Cannot extend enumerations") + # base is now the last base in bases + if not issubclass(base, Enum): + raise TypeError("new enumerations must be created as " + "`ClassName([mixin_type,] enum_type)`") + + # get correct mix-in type (either mix-in type of Enum subclass, or + # first base if last base is Enum) + if not issubclass(bases[0], Enum): + member_type = bases[0] # first data type + first_enum = bases[-1] # enum type + else: + for base in bases[0].__mro__: + # most common: (IntEnum, int, Enum, object) + # possible: (, , + # , , + # ) + if issubclass(base, Enum): + if first_enum is None: + first_enum = base + else: + if member_type is None: + member_type = base + + return member_type, first_enum + + if pyver < 3.0: + @staticmethod + def _find_new_(classdict, member_type, first_enum): + """Returns the __new__ to be used for creating the enum members. + + classdict: the class dictionary given to __new__ + member_type: the data type whose __new__ will be used by default + first_enum: enumeration to check for an overriding __new__ + + """ + # now find the correct __new__, checking to see of one was defined + # by the user; also check earlier enum classes in case a __new__ was + # saved as __member_new__ + __new__ = classdict.get('__new__', None) + if __new__: + return None, True, True # __new__, save_new, use_args + + N__new__ = getattr(None, '__new__') + O__new__ = getattr(object, '__new__') + if Enum is None: + E__new__ = N__new__ + else: + E__new__ = Enum.__dict__['__new__'] + # check all possibles for __member_new__ before falling back to + # __new__ + for method in ('__member_new__', '__new__'): + for possible in (member_type, first_enum): + try: + target = possible.__dict__[method] + except (AttributeError, KeyError): + target = getattr(possible, method, None) + if target not in [ + None, + N__new__, + O__new__, + E__new__, + ]: + if method == '__member_new__': + classdict['__new__'] = target + return None, False, True + if isinstance(target, staticmethod): + target = target.__get__(member_type) + __new__ = target + break + if __new__ is not None: + break + else: + __new__ = object.__new__ + + # if a non-object.__new__ is used then whatever value/tuple was + # assigned to the enum member name will be passed to __new__ and to the + # new enum member's __init__ + if __new__ is object.__new__: + use_args = False + else: + use_args = True + + return __new__, False, use_args + else: + @staticmethod + def _find_new_(classdict, member_type, first_enum): + """Returns the __new__ to be used for creating the enum members. + + classdict: the class dictionary given to __new__ + member_type: the data type whose __new__ will be used by default + first_enum: enumeration to check for an overriding __new__ + + """ + # now find the correct __new__, checking to see of one was defined + # by the user; also check earlier enum classes in case a __new__ was + # saved as __member_new__ + __new__ = classdict.get('__new__', None) + + # should __new__ be saved as __member_new__ later? + save_new = __new__ is not None + + if __new__ is None: + # check all possibles for __member_new__ before falling back to + # __new__ + for method in ('__member_new__', '__new__'): + for possible in (member_type, first_enum): + target = getattr(possible, method, None) + if target not in ( + None, + None.__new__, + object.__new__, + Enum.__new__, + ): + __new__ = target + break + if __new__ is not None: + break + else: + __new__ = object.__new__ + + # if a non-object.__new__ is used then whatever value/tuple was + # assigned to the enum member name will be passed to __new__ and to the + # new enum member's __init__ + if __new__ is object.__new__: + use_args = False + else: + use_args = True + + return __new__, save_new, use_args + + +######################################################## +# In order to support Python 2 and 3 with a single +# codebase we have to create the Enum methods separately +# and then use the `type(name, bases, dict)` method to +# create the class. +######################################################## +temp_enum_dict = {} +temp_enum_dict['__doc__'] = "Generic enumeration.\n\n Derive from this class to define new enumerations.\n\n" + +def __new__(cls, value): + # all enum instances are actually created during class construction + # without calling this method; this method is called by the metaclass' + # __call__ (i.e. Color(3) ), and by pickle + if type(value) is cls: + # For lookups like Color(Color.red) + value = value.value + #return value + # by-value search for a matching enum member + # see if it's in the reverse mapping (for hashable values) + try: + if value in cls._value2member_map_: + return cls._value2member_map_[value] + except TypeError: + # not there, now do long search -- O(n) behavior + for member in cls._member_map_.values(): + if member.value == value: + return member + raise ValueError("%s is not a valid %s" % (value, cls.__name__)) +temp_enum_dict['__new__'] = __new__ +del __new__ + +def __repr__(self): + return "<%s.%s: %r>" % ( + self.__class__.__name__, self._name_, self._value_) +temp_enum_dict['__repr__'] = __repr__ +del __repr__ + +def __str__(self): + return "%s.%s" % (self.__class__.__name__, self._name_) +temp_enum_dict['__str__'] = __str__ +del __str__ + +if pyver >= 3.0: + def __dir__(self): + added_behavior = [ + m + for cls in self.__class__.mro() + for m in cls.__dict__ + if m[0] != '_' and m not in self._member_map_ + ] + return (['__class__', '__doc__', '__module__', ] + added_behavior) + temp_enum_dict['__dir__'] = __dir__ + del __dir__ + +def __format__(self, format_spec): + # mixed-in Enums should use the mixed-in type's __format__, otherwise + # we can get strange results with the Enum name showing up instead of + # the value + + # pure Enum branch + if self._member_type_ is object: + cls = str + val = str(self) + # mix-in branch + else: + cls = self._member_type_ + val = self.value + return cls.__format__(val, format_spec) +temp_enum_dict['__format__'] = __format__ +del __format__ + + +#################################### +# Python's less than 2.6 use __cmp__ + +if pyver < 2.6: + + def __cmp__(self, other): + if type(other) is self.__class__: + if self is other: + return 0 + return -1 + return NotImplemented + raise TypeError("unorderable types: %s() and %s()" % (self.__class__.__name__, other.__class__.__name__)) + temp_enum_dict['__cmp__'] = __cmp__ + del __cmp__ + +else: + + def __le__(self, other): + raise TypeError("unorderable types: %s() <= %s()" % (self.__class__.__name__, other.__class__.__name__)) + temp_enum_dict['__le__'] = __le__ + del __le__ + + def __lt__(self, other): + raise TypeError("unorderable types: %s() < %s()" % (self.__class__.__name__, other.__class__.__name__)) + temp_enum_dict['__lt__'] = __lt__ + del __lt__ + + def __ge__(self, other): + raise TypeError("unorderable types: %s() >= %s()" % (self.__class__.__name__, other.__class__.__name__)) + temp_enum_dict['__ge__'] = __ge__ + del __ge__ + + def __gt__(self, other): + raise TypeError("unorderable types: %s() > %s()" % (self.__class__.__name__, other.__class__.__name__)) + temp_enum_dict['__gt__'] = __gt__ + del __gt__ + + +def __eq__(self, other): + if type(other) is self.__class__: + return self is other + return NotImplemented +temp_enum_dict['__eq__'] = __eq__ +del __eq__ + +def __ne__(self, other): + if type(other) is self.__class__: + return self is not other + return NotImplemented +temp_enum_dict['__ne__'] = __ne__ +del __ne__ + +def __hash__(self): + return hash(self._name_) +temp_enum_dict['__hash__'] = __hash__ +del __hash__ + +def __reduce_ex__(self, proto): + return self.__class__, (self._value_, ) +temp_enum_dict['__reduce_ex__'] = __reduce_ex__ +del __reduce_ex__ + +# _RouteClassAttributeToGetattr is used to provide access to the `name` +# and `value` properties of enum members while keeping some measure of +# protection from modification, while still allowing for an enumeration +# to have members named `name` and `value`. This works because enumeration +# members are not set directly on the enum class -- __getattr__ is +# used to look them up. + +@_RouteClassAttributeToGetattr +def name(self): + return self._name_ +temp_enum_dict['name'] = name +del name + +@_RouteClassAttributeToGetattr +def value(self): + return self._value_ +temp_enum_dict['value'] = value +del value + +@classmethod +def _convert(cls, name, module, filter, source=None): + """ + Create a new Enum subclass that replaces a collection of global constants + """ + # convert all constants from source (or module) that pass filter() to + # a new Enum called name, and export the enum and its members back to + # module; + # also, replace the __reduce_ex__ method so unpickling works in + # previous Python versions + module_globals = vars(_sys.modules[module]) + if source: + source = vars(source) + else: + source = module_globals + members = dict((name, value) for name, value in source.items() if filter(name)) + cls = cls(name, members, module=module) + cls.__reduce_ex__ = _reduce_ex_by_name + module_globals.update(cls.__members__) + module_globals[name] = cls + return cls +temp_enum_dict['_convert'] = _convert +del _convert + +Enum = EnumMeta('Enum', (object, ), temp_enum_dict) +del temp_enum_dict + +# Enum has now been created +########################### + +class IntEnum(int, Enum): + """Enum where members are also (and must be) ints""" + +def _reduce_ex_by_name(self, proto): + return self.name + +def unique(enumeration): + """Class decorator that ensures only unique members exist in an enumeration.""" + duplicates = [] + for name, member in enumeration.__members__.items(): + if name != member.name: + duplicates.append((name, member.name)) + if duplicates: + duplicate_names = ', '.join( + ["%s -> %s" % (alias, name) for (alias, name) in duplicates] + ) + raise ValueError('duplicate names found in %r: %s' % + (enumeration, duplicate_names) + ) + return enumeration diff --git a/python/examples/bin_info.py b/python/examples/bin_info.py index a472495a..c574a530 100644 --- a/python/examples/bin_info.py +++ b/python/examples/bin_info.py @@ -20,37 +20,51 @@ # IN THE SOFTWARE. import sys -import binaryninja +import binaryninja.log as log +import binaryninja.binaryview as view +import binaryninja.interaction as interaction +from binaryninja.plugin import PluginCommand -if sys.platform.lower().startswith("linux"): - bintype = "ELF" -elif sys.platform.lower() == "darwin": - bintype = "Mach-O" -else: - raise Exception("%s is not supported on this plugin" % sys.platform) -if len(sys.argv) > 1: - target = sys.argv[1] -else: - target = "/bin/ls" +def 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 = binaryninja.BinaryViewType[bintype].open(target) -bv.update_analysis_and_wait() + bv = view.BinaryViewType.get_view_of_file(filename) + log.redirect_output_to_log() + log.log_to_stdout(True) -log.log_info("-------- %s --------" % target) -log.log_info("START: 0x%x" % bv.start) -log.log_info("ENTRY: 0x%x" % bv.entry_point) -log.log_info("ARCH: %s" % bv.arch.name) -log.log_info("\n-------- Function List --------") + 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" -for func in bv.functions: - log.log_info(func.symbol.name) + 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) -log.log_info("\n-------- First 10 strings --------") + interaction.show_markdown_report("Binary Info Report", contents) -for i in xrange(10): - start = bv.strings[i].start - length = bv.strings[i].length - string = bv.read(start, length) - log.log_info("0x%x (%d):\t%s" % (start, length, string)) + +if __name__ == "__main__": + bininfo(None) +else: + PluginCommand.register("Binary Info", "Display basic info about the binary", bininfo) diff --git a/python/examples/instruction_iterator.py b/python/examples/instruction_iterator.py index 6c9d9653..47717aa0 100644 --- a/python/examples/instruction_iterator.py +++ b/python/examples/instruction_iterator.py @@ -20,7 +20,7 @@ # IN THE SOFTWARE. import sys -import binaryninja +import binaryninja as binja if sys.platform.lower().startswith("linux"): @@ -35,30 +35,30 @@ if len(sys.argv) > 1: else: target = "/bin/ls" -bv = binaryninja.BinaryViewType[bintype].open(target) +bv = binja.BinaryViewType[bintype].open(target) bv.update_analysis_and_wait() - -print "-------- %s --------" % target -print "START: 0x%x" % bv.start -print "ENTRY: 0x%x" % bv.entry_point -print "ARCH: %s" % bv.arch.name -print "\n-------- Function List --------" +binja.log_to_stdout(True) +binja.log_info("-------- %s --------" % target) +binja.log_info("START: 0x%x" % bv.start) +binja.log_info("ENTRY: 0x%x" % bv.entry_point) +binja.log_info("ARCH: %s" % bv.arch.name) +binja.log_info("\n-------- Function List --------") """ print all the functions, their basic blocks, and their il instructions """ for func in bv.functions: - print repr(func) + binja.log_info(repr(func)) for block in func.low_level_il: - print "\t{0}".format(block) + binja.log_info("\t{0}".format(block)) for insn in block: - print "\t\t{0}".format(insn) + binja.log_info("\t\t{0}".format(insn)) """ print all the functions, their basic blocks, and their mc instructions """ for func in bv.functions: - print repr(func) + binja.log_info(repr(func)) for block in func: - print "\t{0}".format(block) + binja.log_info("\t{0}".format(block)) for insn in block: - print "\t\t{0}".format(insn) + binja.log_info("\t\t{0}".format(insn)) diff --git a/python/platform.py b/python/platform.py index d69c38d1..6c3eefea 100644 --- a/python/platform.py +++ b/python/platform.py @@ -241,3 +241,12 @@ class Platform(object): :rtype: None """ core.BNRegisterPlatformCallingConvention(self.handle, cc.handle) + + def get_related_platform(self, arch): + result = core.BNGetRelatedPlatform(self.handle, arch.handle) + if not result: + return None + return Platform(None, handle = result) + + def add_related_platform(self, arch, platform): + core.BNAddRelatedPlatform(self.handle, arch.handle, platform.handle) -- cgit v1.3.1 From 9ad395e9d45d18734f1afbf208c80bdafa6a7a3d Mon Sep 17 00:00:00 2001 From: Peter LaFosse Date: Sat, 19 Nov 2016 14:46:49 -0500 Subject: Remove debuging code --- python/__init__.py | 56 +++++++++++++++++++++++------------------------------- 1 file changed, 24 insertions(+), 32 deletions(-) (limited to 'python/__init__.py') diff --git a/python/__init__.py b/python/__init__.py index f38395c8..2a1139f9 100644 --- a/python/__init__.py +++ b/python/__init__.py @@ -18,39 +18,31 @@ # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS # IN THE SOFTWARE. - -import sys - - # Binary Ninja components -try: - import _binaryninjacore as core - from databuffer import * - from filemetadata import * - from fileaccessor import * - from binaryview import * - from transform import * - from architecture import * - from basicblock import * - from function import * - from log import * - from lowlevelil import * - from bntype import * - from functionrecognizer import * - from update import * - from plugin import * - from callingconvention import * - from platform import * - from demangle import * - from mainthread import * - from interaction import * - from lineardisassembly import * - from undoaction import * - from highlight import * -except: - x = open("/Users/peterl/path", "w") - x.write(str(sys.exc_info())) - x.close() +import _binaryninjacore as core +from databuffer import * +from filemetadata import * +from fileaccessor import * +from binaryview import * +from transform import * +from architecture import * +from basicblock import * +from function import * +from log import * +from lowlevelil import * +from bntype import * +from functionrecognizer import * +from update import * +from plugin import * +from callingconvention import * +from platform import * +from demangle import * +from mainthread import * +from interaction import * +from lineardisassembly import * +from undoaction import * +from highlight import * + class _DestructionCallbackHandler(object): def __init__(self): -- cgit v1.3.1 From 4761ea9c83104b872d8d49fcde45f17d17e7872d Mon Sep 17 00:00:00 2001 From: Peter LaFosse Date: Thu, 5 Jan 2017 09:14:31 -0500 Subject: Modifying how enumerations are exposed and used, and a bunch of cleanup of existing plugins --- python/__init__.py | 51 ++-- python/architecture.py | 54 ++-- python/basicblock.py | 33 +-- python/binaryview.py | 92 ++++--- python/bntype.py | 505 ----------------------------------- python/demangle.py | 6 +- python/examples/angr_plugin.py | 25 +- python/examples/bin_info.py | 15 +- python/examples/breakpoint.py | 28 +- python/examples/export_svg.py | 84 +++--- python/examples/jump_table.py | 8 +- python/examples/nds.py | 225 ++++++++-------- python/examples/nes.py | 430 +++++++++++++++--------------- python/examples/nsf.py | 86 +++--- python/examples/print_syscalls.py | 55 ++-- python/examples/version_switcher.py | 15 +- python/function.py | 98 +++---- python/generator.cpp | 88 ++++--- python/highlight.py | 47 ++-- python/interaction.py | 45 ++-- python/log.py | 10 +- python/lowlevelil.py | 275 ++++++++++---------- python/platform.py | 33 ++- python/plugin.py | 19 +- python/scriptingprovider.py | 35 +-- python/startup.py | 4 - python/transform.py | 7 +- python/types.py | 506 ++++++++++++++++++++++++++++++++++++ python/undoaction.py | 3 +- python/update.py | 5 +- 30 files changed, 1497 insertions(+), 1390 deletions(-) delete mode 100644 python/bntype.py create mode 100644 python/types.py (limited to 'python/__init__.py') diff --git a/python/__init__.py b/python/__init__.py index 2a1139f9..a1ea02f5 100644 --- a/python/__init__.py +++ b/python/__init__.py @@ -18,30 +18,37 @@ # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS # IN THE SOFTWARE. + # Binary Ninja components import _binaryninjacore as core -from databuffer import * -from filemetadata import * -from fileaccessor import * -from binaryview import * -from transform import * -from architecture import * -from basicblock import * -from function import * -from log import * -from lowlevelil import * -from bntype import * -from functionrecognizer import * -from update import * -from plugin import * -from callingconvention import * -from platform import * -from demangle import * -from mainthread import * -from interaction import * -from lineardisassembly import * -from undoaction import * -from highlight import * +from .enums import * +from .databuffer import * +from .filemetadata import * +from .fileaccessor import * +from .binaryview import * +from .transform import * +from .architecture import * +from .basicblock import * +from .function import * +from .log import * +from .lowlevelil import * +from .types import * +from .functionrecognizer import * +from .update import * +from .plugin import * +from .callingconvention import * +from .platform import * +from .demangle import * +from .mainthread import * +from .interaction import * +from .lineardisassembly import * +from .undoaction import * +from .highlight import * +from .scriptingprovider import * + + +def shutdown(): + core.BNShutdown() class _DestructionCallbackHandler(object): diff --git a/python/architecture.py b/python/architecture.py index 5162e58a..5d42ec35 100644 --- a/python/architecture.py +++ b/python/architecture.py @@ -24,8 +24,8 @@ import abc # Binary Ninja components import _binaryninjacore as core -from _binaryninjacore import BNEndianness - +from enums import (Endianness, ImplicitRegisterExtend, BranchType, + InstructionTextTokenType, LowLevelILFlagCondition, FlagRole) import startup import function import lowlevelil @@ -33,7 +33,7 @@ import callingconvention import platform import log import databuffer -import bntype +import types class _ArchitectureMetaClass(type): @@ -108,7 +108,7 @@ class Architecture(object): >>> arch = Architecture['x86'] """ name = None - endianness = BNEndianness.LittleEndian + endianness = Endianness.LittleEndian address_size = 8 default_int_size = 4 max_instr_length = 16 @@ -128,7 +128,7 @@ class Architecture(object): if handle is not None: self.handle = core.handle_of_type(handle, core.BNArchitecture) self.__dict__["name"] = core.BNGetArchitectureName(self.handle) - self.__dict__["endianness"] = core.BNEndianness(core.BNGetArchitectureEndianness(self.handle)).name + self.__dict__["endianness"] = Endianness(core.BNGetArchitectureEndianness(self.handle)).name self.__dict__["address_size"] = core.BNGetArchitectureAddressSize(self.handle) self.__dict__["default_int_size"] = core.BNGetArchitectureDefaultIntegerSize(self.handle) self.__dict__["max_instr_length"] = core.BNGetArchitectureMaxInstructionLength(self.handle) @@ -146,7 +146,7 @@ class Architecture(object): info = core.BNGetArchitectureRegisterInfo(self.handle, regs[i]) full_width_reg = core.BNGetArchitectureRegisterName(self.handle, info.fullWidthRegister) self.regs[name] = function.RegisterInfo(full_width_reg, info.size, info.offset, - core.BNImplicitRegisterExtend(info.extend).name, regs[i]) + ImplicitRegisterExtend(info.extend).name, regs[i]) core.BNFreeRegisterList(regs) count = ctypes.c_ulonglong() @@ -182,7 +182,7 @@ class Architecture(object): self._flags_required_for_flag_condition = {} self.__dict__["flags_required_for_flag_condition"] = {} - for cond in core.BNLowLevelILFlagCondition: + for cond in LowLevelILFlagCondition: count = ctypes.c_ulonglong() flags = core.BNGetArchitectureFlagsRequiredForFlagCondition(self.handle, cond, count) flag_indexes = [] @@ -311,7 +311,7 @@ class Architecture(object): for flag in self.__class__.flag_roles: role = self.__class__.flag_roles[flag] if isinstance(role, str): - role = core.BNFlagRole[role] + role = FlagRole[role] self._flag_roles[self._flags[flag]] = role self._flags_required_for_flag_condition = {} @@ -383,7 +383,7 @@ class Architecture(object): return self.__class__.endianness except: log.log_error(traceback.format_exc()) - return core.BNEndianness.LittleEndian + return Endianness.LittleEndian def _get_address_size(self, ctxt): try: @@ -434,7 +434,7 @@ class Architecture(object): result[0].branchCount = len(info.branches) for i in xrange(0, len(info.branches)): if isinstance(info.branches[i].type, str): - result[0].branchType[i] = core.BNBranchType[info.branches[i].type] + result[0].branchType[i] = BranchType[info.branches[i].type] else: result[0].branchType[i] = info.branches[i].type result[0].branchTarget[i] = info.branches[i].target @@ -460,7 +460,7 @@ class Architecture(object): token_buf = (core.BNInstructionTextToken * len(tokens))() for i in xrange(0, len(tokens)): if isinstance(tokens[i].type, str): - token_buf[i].type = core.BNInstructionTextTokenType[tokens[i].type] + token_buf[i].type = InstructionTextTokenType[tokens[i].type] else: token_buf[i].type = tokens[i].type token_buf[i].text = tokens[i].text @@ -589,7 +589,7 @@ class Architecture(object): try: if flag in self._flag_roles: return self._flag_roles[flag] - return core.BNFlagRole.SpecialFlagRole + return FlagRole.SpecialFlagRole except KeyError: log.log_error(traceback.format_exc()) return None @@ -673,14 +673,14 @@ class Architecture(object): result[0].fullWidthRegister = 0 result[0].offset = 0 result[0].size = 0 - result[0].extend = core.BNImplicitRegisterExtend.NoExtend + result[0].extend = ImplicitRegisterExtend.NoExtend return info = self.__class__.regs[self._regs_by_index[reg]] result[0].fullWidthRegister = self._all_regs[info.full_width_reg] result[0].offset = info.offset result[0].size = info.size if isinstance(info.extend, str): - result[0].extend = core.BNImplicitRegisterExtend[info.extend] + result[0].extend = ImplicitRegisterExtend[info.extend] else: result[0].extend = info.extend except KeyError: @@ -688,7 +688,7 @@ class Architecture(object): result[0].fullWidthRegister = 0 result[0].offset = 0 result[0].size = 0 - result[0].extend = core.BNImplicitRegisterExtend.NoExtend + result[0].extend = ImplicitRegisterExtend.NoExtend def _get_stack_pointer_register(self, ctxt): try: @@ -1113,7 +1113,7 @@ class Architecture(object): result.length = info.length result.branch_delay = info.branchDelay for i in xrange(0, info.branchCount): - branch_type = core.BNBranchType(info.branchType[i]).name + branch_type = BranchType(info.branchType[i]).name target = info.branchTarget[i] if info.branchArch[i]: arch = Architecture(info.branchArch[i]) @@ -1143,7 +1143,7 @@ class Architecture(object): return None, 0 result = [] for i in xrange(0, count.value): - token_type = core.BNInstructionTextTokenType(tokens[i].type).name + token_type = InstructionTextTokenType(tokens[i].type).name text = tokens[i].text value = tokens[i].value size = tokens[i].size @@ -1611,17 +1611,17 @@ class Architecture(object): core.BNFreeString(ctypes.cast(errors, ctypes.POINTER(ctypes.c_byte))) if not result: return (None, error_str) - types = {} + type_dict = {} variables = {} functions = {} for i in xrange(0, parse.typeCount): - types[parse.types[i].name] = bntype.Type(core.BNNewTypeReference(parse.types[i].type)) + types[parse.types[i].name] = types.Type(core.BNNewTypeReference(parse.types[i].type)) for i in xrange(0, parse.variableCount): - variables[parse.variables[i].name] = bntype.Type(core.BNNewTypeReference(parse.variables[i].type)) + variables[parse.variables[i].name] = types.Type(core.BNNewTypeReference(parse.variables[i].type)) for i in xrange(0, parse.functionCount): - functions[parse.functions[i].name] = bntype.Type(core.BNNewTypeReference(parse.functions[i].type)) + functions[parse.functions[i].name] = types.Type(core.BNNewTypeReference(parse.functions[i].type)) core.BNFreeTypeParserResult(parse) - return (bntype.TypeParserResult(types, variables, functions), error_str) + return (types.TypeParserResult(type_dict, variables, functions), error_str) def parse_types_from_source_file(self, filename, include_dirs=[]): """ @@ -1652,17 +1652,17 @@ class Architecture(object): core.BNFreeString(ctypes.cast(errors, ctypes.POINTER(ctypes.c_byte))) if not result: return (None, error_str) - types = {} + type_dict = {} variables = {} functions = {} for i in xrange(0, parse.typeCount): - types[parse.types[i].name] = bntype.Type(core.BNNewTypeReference(parse.types[i].type)) + type_dict[parse.types[i].name] = types.Type(core.BNNewTypeReference(parse.types[i].type)) for i in xrange(0, parse.variableCount): - variables[parse.variables[i].name] = bntype.Type(core.BNNewTypeReference(parse.variables[i].type)) + variables[parse.variables[i].name] = types.Type(core.BNNewTypeReference(parse.variables[i].type)) for i in xrange(0, parse.functionCount): - functions[parse.functions[i].name] = bntype.Type(core.BNNewTypeReference(parse.functions[i].type)) + functions[parse.functions[i].name] = types.Type(core.BNNewTypeReference(parse.functions[i].type)) core.BNFreeTypeParserResult(parse) - return (bntype.TypeParserResult(types, variables, functions), error_str) + return (types.TypeParserResult(type_dict, variables, functions), error_str) def register_calling_convention(self, cc): """ diff --git a/python/basicblock.py b/python/basicblock.py index d728cb8d..ae9889fc 100644 --- a/python/basicblock.py +++ b/python/basicblock.py @@ -22,6 +22,7 @@ import ctypes # Binary Ninja components import _binaryninjacore as core +from enums import BranchType, HighlightColorStyle, HighlightStandardColor, InstructionTextTokenType import architecture import highlight import function @@ -30,13 +31,13 @@ import function class BasicBlockEdge(object): def __init__(self, branch_type, target, arch): self.type = branch_type - if self.type != core.BNBranchType.UnresolvedBranch: + if self.type != BranchType.UnresolvedBranch: self.target = target self.arch = arch def __repr__(self): - if self.type == core.BNBranchType.UnresolvedBranch: - return "<%s>" % core.BNBranchType(self.type).name + if self.type == BranchType.UnresolvedBranch: + return "<%s>" % BranchType(self.type).name elif self.arch: return "<%s: %s@%#x>" % (self.type, self.arch.name, self.target) else: @@ -126,18 +127,18 @@ class BasicBlock(object): :Example: - >>> current_basic_block.highlight = core.BNHighlightStandardColor.BlueHighlightColor + >>> current_basic_block.highlight = HighlightStandardColor.BlueHighlightColor >>> current_basic_block.highlight """ color = core.BNGetBasicBlockHighlight(self.handle) - if color.style == core.BNHighlightColorStyle.StandardHighlightColor: + if color.style == HighlightColorStyle.StandardHighlightColor: return highlight.HighlightColor(color=color.color, alpha=color.alpha) - elif color.style == core.BNHighlightColorStyle.MixedHighlightColor: + elif color.style == HighlightColorStyle.MixedHighlightColor: return highlight.HighlightColor(color=color.color, mix_color=color.mixColor, mix=color.mix, alpha=color.alpha) - elif color.style == core.BNHighlightColorStyle.CustomHighlightColor: + elif color.style == HighlightColorStyle.CustomHighlightColor: return highlight.HighlightColor(red=color.r, green=color.g, blue=color.b, alpha=color.alpha) - return highlight.HighlightColor(color=core.BNHighlightStandardColor.NoHighlightColor) + return highlight.HighlightColor(color=HighlightStandardColor.NoHighlightColor) @highlight.setter def highlight(self, value): @@ -194,7 +195,7 @@ class BasicBlock(object): addr = lines[i].addr tokens = [] for j in xrange(0, lines[i].count): - token_type = core.BNInstructionTextTokenType(lines[i].tokens[j].type) + token_type = InstructionTextTokenType(lines[i].tokens[j].type) text = lines[i].tokens[j].text value = lines[i].tokens[j].value size = lines[i].tokens[j].size @@ -210,22 +211,22 @@ class BasicBlock(object): .warning:: Use only in analysis plugins. Do not use in regular plugins, as colors won't be saved to the database. - :param core.BNHighlightStandardColor or highlight.HighlightColor color: Color value to use for highlighting + :param HighlightStandardColor or highlight.HighlightColor color: Color value to use for highlighting """ - if not isinstance(color, core.BNHighlightStandardColor) and not isinstance(color, highlight.HighlightColor): - raise ValueError("Specified color is not one of core.BNHighlightStandardColor, highlight.HighlightColor") + if not isinstance(color, HighlightStandardColor) and not isinstance(color, highlight.HighlightColor): + raise ValueError("Specified color is not one of HighlightStandardColor, highlight.HighlightColor") core.BNSetAutoBasicBlockHighlight(self.handle, color._get_core_struct()) def set_user_highlight(self, color): """ ``set_user_highlight`` highlights the current BasicBlock with the supplied color - :param core.BNHighlightStandardColor or highlight.HighlightColor color: Color value to use for highlighting + :param HighlightStandardColor or highlight.HighlightColor color: Color value to use for highlighting :Example: >>> current_basic_block.set_user_highlight(highlight.HighlightColor(red=0xff, blue=0xff, green=0)) - >>> current_basic_block.set_user_highlight(core.BNHighlightStandardColor.BlueHighlightColor) + >>> current_basic_block.set_user_highlight(HighlightStandardColor.BlueHighlightColor) """ - if not isinstance(color, core.BNHighlightStandardColor) and not isinstance(color, highlight.HighlightColor): - raise ValueError("Specified color is not one of core.BNHighlightStandardColor, highlight.HighlightColor") + if not isinstance(color, HighlightStandardColor) and not isinstance(color, highlight.HighlightColor): + raise ValueError("Specified color is not one of HighlightStandardColor, highlight.HighlightColor") core.BNSetUserBasicBlockHighlight(self.handle, color._get_core_struct()) diff --git a/python/binaryview.py b/python/binaryview.py index b4be159c..41702dc8 100644 --- a/python/binaryview.py +++ b/python/binaryview.py @@ -26,6 +26,7 @@ import threading # Binary Ninja components import _binaryninjacore as core +from enums import AnalysisState, SymbolType, InstructionTextTokenType, Endianness, ModificationStatus, StringType, SegmentFlag import function import startup import architecture @@ -36,7 +37,7 @@ import filemetadata import log import databuffer import basicblock -import bntype +import types import lineardisassembly @@ -116,9 +117,9 @@ class AnalysisProgress(object): self.total = total def __str__(self): - if self.state == core.BNAnalysisState.DisassembleState: + if self.state == AnalysisState.DisassembleState: return "Disassembling (%d/%d)" % (self.count, self.total) - if self.state == core.BNAnalysisState.AnalyzeState: + if self.state == AnalysisState.AnalyzeState: return "Analyzing (%d/%d)" % (self.count, self.total) return "Idle" @@ -199,7 +200,7 @@ class BinaryDataNotificationCallbacks(object): def _data_var_added(self, ctxt, view, var): try: address = var.address - var_type = bntype.Type(core.BNNewTypeReference(var.type)) + var_type = types.Type(core.BNNewTypeReference(var.type)) auto_discovered = var.autoDiscovered self.notify.data_var_added(self.view, DataVariable(address, var_type, auto_discovered)) except: @@ -208,7 +209,7 @@ class BinaryDataNotificationCallbacks(object): def _data_var_removed(self, ctxt, view, var): try: address = var.address - var_type = bntype.Type(core.BNNewTypeReference(var.type)) + var_type = types.Type(core.BNNewTypeReference(var.type)) auto_discovered = var.autoDiscovered self.notify.data_var_removed(self.view, DataVariable(address, var_type, auto_discovered)) except: @@ -217,7 +218,7 @@ class BinaryDataNotificationCallbacks(object): def _data_var_updated(self, ctxt, view, var): try: address = var.address - var_type = bntype.Type(core.BNNewTypeReference(var.type)) + var_type = types.Type(core.BNNewTypeReference(var.type)) auto_discovered = var.autoDiscovered self.notify.data_var_updated(self.view, DataVariable(address, var_type, auto_discovered)) except: @@ -225,13 +226,13 @@ class BinaryDataNotificationCallbacks(object): def _string_found(self, ctxt, view, string_type, offset, length): try: - self.notify.string_found(self.view, core.BNStringType(string_type), offset, length) + self.notify.string_found(self.view, StringType(string_type), offset, length) except: log.log_error(traceback.format_exc()) def _string_removed(self, ctxt, view, string_type, offset, length): try: - self.notify.string_removed(self.view, core.BNStringType(string_type), offset, length) + self.notify.string_removed(self.view, StringType(string_type), offset, length) except: log.log_error(traceback.format_exc()) @@ -370,9 +371,9 @@ class Segment(object): def __repr__(self): return "" % (self.start, self.end, - "r" if (self.flags & core.BNSegmentFlag.SegmentReadable) != 0 else "-", - "w" if (self.flags & core.BNSegmentFlag.SegmentWritable) != 0 else "-", - "x" if (self.flags & core.BNSegmentFlag.SegmentExecutable) != 0 else "-") + "r" if (self.flags & SegmentFlag.SegmentReadable) != 0 else "-", + "w" if (self.flags & SegmentFlag.SegmentWritable) != 0 else "-", + "x" if (self.flags & SegmentFlag.SegmentExecutable) != 0 else "-") class Section(object): @@ -804,7 +805,7 @@ class BinaryView(object): result = {} for i in xrange(0, count.value): addr = var_list[i].address - var_type = bntype.Type(core.BNNewTypeReference(var_list[i].type)) + var_type = types.Type(core.BNNewTypeReference(var_list[i].type)) auto_discovered = var_list[i].autoDiscovered result[addr] = DataVariable(addr, var_type, auto_discovered) core.BNFreeDataVariables(var_list, count.value) @@ -817,7 +818,7 @@ class BinaryView(object): type_list = core.BNGetAnalysisTypeList(self.handle, count) result = {} for i in xrange(0, count.value): - result[type_list[i].name] = bntype.Type(core.BNNewTypeReference(type_list[i].type)) + result[type_list[i].name] = types.Type(core.BNNewTypeReference(type_list[i].type)) core.BNFreeTypeList(type_list, count.value) return result @@ -993,7 +994,7 @@ class BinaryView(object): return self.perform_get_modification(offset) except: log.log_error(traceback.format_exc()) - return core.BNModificationStatus.Original + return ModificationStatus.Original def _is_valid_offset(self, ctxt, offset): try: @@ -1063,7 +1064,7 @@ class BinaryView(object): return self.perform_get_default_endianness() except: log.log_error(traceback.format_exc()) - return core.BNEndianness.LittleEndian + return Endianness.LittleEndian def _get_address_size(self, ctxt): try: @@ -1229,9 +1230,9 @@ class BinaryView(object): :param int addr: a virtual address to be checked :return: One of the following: Original = 0, Changed = 1, Inserted = 2 - :rtype: BNModificationStatus + :rtype: ModificationStatus """ - return core.BNModificationStatus.Original + return ModificationStatus.Original def perform_is_valid_offset(self, addr): """ @@ -1352,10 +1353,10 @@ class BinaryView(object): .. note:: This method **may** be implemented for custom BinaryViews that are not LittleEndian. .. warning:: This method **must not** be called directly. - :return: either ``core.BNEndianness.LittleEndian`` or ``core.BNEndianness.BigEndian`` - :rtype: BNEndianness + :return: either ``Endianness.LittleEndian`` or ``Endianness.BigEndian`` + :rtype: Endianness """ - return core.BNEndianness.LittleEndian + return Endianness.LittleEndian def create_database(self, filename, progress_func=None): """ @@ -1568,16 +1569,16 @@ class BinaryView(object): def get_modification(self, addr, length=None): """ ``get_modification`` returns the modified bytes of up to ``length`` bytes from virtual address ``addr``, or if - ``length`` is None returns the core.BNModificationStatus. + ``length`` is None returns the ModificationStatus. :param int addr: virtual address to get modification from :param int length: optional length of modification - :return: Either core.BNModificationStatus of the byte at ``addr``, or string of modified bytes at ``addr`` - :rtype: core.BNModificationStatus or str + :return: Either ModificationStatus of the byte at ``addr``, or string of modified bytes at ``addr`` + :rtype: ModificationStatus or str """ if length is None: return core.BNGetModification(self.handle, addr) - data = (core.BNModificationStatus * length)() + data = (ModificationStatus * length)() length = core.BNGetModificationArray(self.handle, addr, data, length) return data[0:length] @@ -1991,7 +1992,7 @@ class BinaryView(object): sym = core.BNGetSymbolByAddress(self.handle, addr) if sym is None: return None - return bntype.Symbol(None, None, None, handle = sym) + return types.Symbol(None, None, None, handle = sym) def get_symbol_by_raw_name(self, name): """ @@ -2009,7 +2010,7 @@ class BinaryView(object): sym = core.BNGetSymbolByRawName(self.handle, name) if sym is None: return None - return bntype.Symbol(None, None, None, handle = sym) + return types.Symbol(None, None, None, handle = sym) def get_symbols_by_name(self, name): """ @@ -2028,7 +2029,7 @@ class BinaryView(object): syms = core.BNGetSymbolsByName(self.handle, name, count) result = [] for i in xrange(0, count.value): - result.append(bntype.Symbol(None, None, None, handle = core.BNNewSymbolReference(syms[i]))) + result.append(types.Symbol(None, None, None, handle = core.BNNewSymbolReference(syms[i]))) core.BNFreeSymbolList(syms, count.value) return result @@ -2053,7 +2054,7 @@ class BinaryView(object): syms = core.BNGetSymbolsInRange(self.handle, start, length, count) result = [] for i in xrange(0, count.value): - result.append(bntype.Symbol(None, None, None, handle = core.BNNewSymbolReference(syms[i]))) + result.append(types.Symbol(None, None, None, handle = core.BNNewSymbolReference(syms[i]))) core.BNFreeSymbolList(syms, count.value) return result @@ -2069,12 +2070,12 @@ class BinaryView(object): :rtype: list(Symbol) :Example: - >>> bv.get_symbols_of_type(core.BNSymbolType.ImportAddressSymbol, 0x10002028, 1) + >>> bv.get_symbols_of_type(SymbolType.ImportAddressSymbol, 0x10002028, 1) [] >>> """ if isinstance(sym_type, str): - sym_type = core.BNSymbolType[sym_type] + sym_type = SymbolType[sym_type] count = ctypes.c_ulonglong(0) if start is None: syms = core.BNGetSymbolsOfType(self.handle, sym_type, count) @@ -2082,7 +2083,7 @@ class BinaryView(object): syms = core.BNGetSymbolsOfTypeInRange(self.handle, sym_type, start, length, count) result = [] for i in xrange(0, count.value): - result.append(bntype.Symbol(None, None, None, handle = core.BNNewSymbolReference(syms[i]))) + result.append(types.Symbol(None, None, None, handle = core.BNNewSymbolReference(syms[i]))) core.BNFreeSymbolList(syms, count.value) return result @@ -2095,6 +2096,21 @@ class BinaryView(object): """ core.BNDefineAutoSymbol(self.handle, sym.handle) + def define_auto_symbol_and_var_or_function(self, sym, sym_type, platform = None): + """ + ``define_auto_symbol`` adds a symbol to the internal list of automatically discovered Symbol objects. + + :param Symbol sym: the symbol to define + :rtype: None + """ + if platform is None: + platform = self.platform + if platform is not None: + platform = platform.handle + if sym_type is not None: + sym_type = sym_type.handle + core.BNDefineAutoSymbolAndVariableOrFunction(self.handle, platform, sym.handle, sym_type) + def undefine_auto_symbol(self, sym): """ ``undefine_auto_symbol`` removes a symbol from the internal list of automatically discovered Symbol objects. @@ -2456,7 +2472,7 @@ class BinaryView(object): strings = core.BNGetStringsInRange(self.handle, start, length, count) result = [] for i in xrange(0, count.value): - result.append(StringReference(core.BNStringType(strings[i].type), strings[i].start, strings[i].length)) + result.append(StringReference(StringType(strings[i].type), strings[i].start, strings[i].length)) core.BNFreeStringReferenceList(strings) return result @@ -2697,7 +2713,7 @@ class BinaryView(object): addr = lines[i].contents.addr tokens = [] for j in xrange(0, lines[i].contents.count): - token_type = core.BNInstructionTextTokenType(lines[i].contents.tokens[j].type) + token_type = InstructionTextTokenType(lines[i].contents.tokens[j].type) text = lines[i].contents.tokens[j].text value = lines[i].contents.tokens[j].value size = lines[i].contents.tokens[j].size @@ -2816,7 +2832,7 @@ class BinaryView(object): error_str = errors.value core.BNFreeString(ctypes.cast(errors, ctypes.POINTER(ctypes.c_byte))) raise SyntaxError(error_str) - type_obj = bntype.Type(core.BNNewTypeReference(result.type)) + type_obj = types.Type(core.BNNewTypeReference(result.type)) name = result.name core.BNFreeNameAndType(result) return type_obj, name @@ -2839,7 +2855,7 @@ class BinaryView(object): obj = core.BNGetAnalysisTypeByName(self.handle, name) if not obj: return None - return bntype.Type(obj) + return types.Type(obj) def is_type_auto_defined(self, name): """ @@ -3066,7 +3082,7 @@ class BinaryReader(object): Or using the optional endian parameter :: >>> from binaryninja import * - >>> br = BinaryReader(bv, core.BNEndianness.BigEndian) + >>> br = BinaryReader(bv, Endianness.BigEndian) >>> hex(br.read32()) '0xcffaedfeL' >>> @@ -3374,8 +3390,8 @@ class BinaryWriter(object): Or using the optional endian parameter :: >>> from binaryninja import * - >>> br = BinaryReader(bv, core.BNEndianness.BigEndian) - >>> bw = BinaryWriter(bv, core.BNEndianness.BigEndian) + >>> br = BinaryReader(bv, Endianness.BigEndian) + >>> bw = BinaryWriter(bv, Endianness.BigEndian) >>> """ def __init__(self, view, endian = None): diff --git a/python/bntype.py b/python/bntype.py deleted file mode 100644 index 1822c5df..00000000 --- a/python/bntype.py +++ /dev/null @@ -1,505 +0,0 @@ -# Copyright (c) 2015-2016 Vector 35 LLC -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to -# deal in the Software without restriction, including without limitation the -# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or -# sell copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in -# all copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS -# IN THE SOFTWARE. - -import ctypes - -# Binary Ninja components -import _binaryninjacore as core -import callingconvention -import demangle - - -class Symbol(object): - """ - Symbols are defined as one of the following types: - - =========================== ============================================================== - BNSymbolType Description - =========================== ============================================================== - FunctionSymbol Symbol for Function that exists in the current binary - ImportAddressSymbol Symbol defined in the Import Address Table - ImportedFunctionSymbol Symbol for Function that is not defined in the current binary - DataSymbol Symbol for Data in the current binary - ImportedDataSymbol Symbol for Data that is not defined in the current binary - =========================== ============================================================== - """ - def __init__(self, sym_type, addr, short_name, full_name = None, raw_name = None, handle = None): - if handle is not None: - self.handle = core.handle_of_type(handle, core.BNSymbol) - else: - if isinstance(sym_type, str): - sym_type = core.BNSymbolType[sym_type] - if full_name is None: - full_name = short_name - if raw_name is None: - raw_name = full_name - self.handle = core.BNCreateSymbol(sym_type, short_name, full_name, raw_name, addr) - - def __del__(self): - core.BNFreeSymbol(self.handle) - - @property - def type(self): - """Symbol type (read-only)""" - return core.BNSymbolType(core.BNGetSymbolType(self.handle)) - - @property - def name(self): - """Symbol name (read-only)""" - return core.BNGetSymbolRawName(self.handle) - - @property - def short_name(self): - """Symbol short name (read-only)""" - return core.BNGetSymbolShortName(self.handle) - - @property - def full_name(self): - """Symbol full name (read-only)""" - return core.BNGetSymbolFullName(self.handle) - - @property - def raw_name(self): - """Symbol raw name (read-only)""" - return core.BNGetSymbolRawName(self.handle) - - @property - def address(self): - """Symbol address (read-only)""" - return core.BNGetSymbolAddress(self.handle) - - @property - def auto(self): - return core.BNIsSymbolAutoDefined(self.handle) - - @auto.setter - def auto(self, value): - core.BNSetSymbolAutoDefined(self.handle, value) - - def __repr__(self): - return "<%s: \"%s\" @ %#x>" % (self.type, self.full_name, self.address) - - def __setattr__(self, name, value): - try: - object.__setattr__(self, name, value) - except AttributeError: - raise AttributeError("attribute '%s' is read only" % name) - - -class Type(object): - def __init__(self, handle): - self.handle = handle - - def __del__(self): - core.BNFreeType(self.handle) - - @property - def type_class(self): - """Type class (read-only)""" - return core.BNTypeClass(core.BNGetTypeClass(self.handle)) - - @property - def width(self): - """Type width (read-only)""" - return core.BNGetTypeWidth(self.handle) - - @property - def alignment(self): - """Type alignment (read-only)""" - return core.BNGetTypeAlignment(self.handle) - - @property - def signed(self): - """Wether type is signed (read-only)""" - return core.BNIsTypeSigned(self.handle) - - @property - def const(self): - """Whether type is const (read-only)""" - return core.BNIsTypeConst(self.handle) - - @property - def modified(self): - """Whether type is modified (read-only)""" - return core.BNIsTypeFloatingPoint(self.handle) - - @property - def target(self): - """Target (read-only)""" - result = core.BNGetChildType(self.handle) - if result is None: - return None - return Type(result) - - @property - def element_type(self): - """Target (read-only)""" - result = core.BNGetChildType(self.handle) - if result is None: - return None - return Type(result) - - @property - def return_value(self): - """Return value (read-only)""" - result = core.BNGetChildType(self.handle) - if result is None: - return None - return Type(result) - - @property - def calling_convention(self): - """Calling convention (read-only)""" - result = core.BNGetTypeCallingConvention(self.handle) - if result is None: - return None - return callingconvention.CallingConvention(None, result) - - @property - def parameters(self): - """Type parameters list (read-only)""" - count = ctypes.c_ulonglong() - params = core.BNGetTypeParameters(self.handle, count) - result = [] - for i in xrange(0, count.value): - result.append((Type(core.BNNewTypeReference(params[i].type)), params[i].name)) - core.BNFreeTypeParameterList(params, count.value) - return result - - @property - def has_variable_arguments(self): - """Whether type has variable arguments (read-only)""" - return core.BNTypeHasVariableArguments(self.handle) - - @property - def can_return(self): - """Whether type can return (read-only)""" - return core.BNFunctionTypeCanReturn(self.handle) - - @property - def structure(self): - """Structure of the type (read-only)""" - result = core.BNGetTypeStructure(self.handle) - if result is None: - return None - return Structure(result) - - @property - def enumeration(self): - """Type enumeration (read-only)""" - result = core.BNGetTypeEnumeration(self.handle) - if result is None: - return None - return Enumeration(result) - - @property - def count(self): - """Type count (read-only)""" - return core.BNGetTypeElementCount(self.handle) - - def __str__(self): - return core.BNGetTypeString(self.handle) - - def __repr__(self): - return "" % str(self) - - def get_string_before_name(self): - return core.BNGetTypeStringBeforeName(self.handle) - - def get_string_after_name(self): - return core.BNGetTypeStringAfterName(self.handle) - - @classmethod - def void(cls): - return Type(core.BNCreateVoidType()) - - @classmethod - def bool(self): - return Type(core.BNCreateBoolType()) - - @classmethod - def int(self, width, sign = True, altname=""): - return Type(core.BNCreateIntegerType(width, sign, altname)) - - @classmethod - def float(self, width): - return Type(core.BNCreateFloatType(width)) - - @classmethod - def structure_type(self, structure_type): - return Type(core.BNCreateStructureType(structure_type.handle)) - - @classmethod - def unknown_type(self, unknown_type): - return Type(core.BNCreateUnknownType(unknown_type.handle)) - - @classmethod - def enumeration_type(self, arch, e, width=None): - if width is None: - width = arch.default_int_size - return Type(core.BNCreateEnumerationType(e.handle, width)) - - @classmethod - def pointer(self, arch, t, const=False): - return Type(core.BNCreatePointerType(arch.handle, t.handle, const)) - - @classmethod - def array(self, t, count): - return Type(core.BNCreateArrayType(t.handle, count)) - - @classmethod - def function(self, ret, params, calling_convention=None, variable_arguments=False): - param_buf = (core.BNNameAndType * len(params))() - for i in xrange(0, len(params)): - if isinstance(params[i], Type): - param_buf[i].name = "" - param_buf[i].type = params[i].handle - else: - param_buf[i].name = params[i][1] - param_buf[i].type = params[i][0] - if calling_convention is not None: - calling_convention = calling_convention.handle - return Type(core.BNCreateFunctionType(ret.handle, calling_convention, param_buf, len(params), - variable_arguments)) - - def __setattr__(self, name, value): - try: - object.__setattr__(self, name, value) - except AttributeError: - raise AttributeError("attribute '%s' is read only" % name) - - -class UnknownType(object): - def __init__(self, handle=None): - if handle is None: - self.handle = core.BNCreateUnknownType() - else: - self.handle = handle - - def __del__(self): - core.BNFreeUnknownType(self.handle) - - @property - def name(self): - count = ctypes.c_ulonglong() - nameList = core.BNGetUnknownTypeName(self.handle, count) - result = [] - for i in xrange(count.value): - result.append(nameList[i]) - return demangle.get_qualified_name(result) - - @name.setter - def name(self, value): - core.BNSetUnknownTypeName(self.handle, value) - - -class StructureMember(object): - def __init__(self, t, name, offset): - self.type = t - self.name = name - self.offset = offset - - def __repr__(self): - if len(self.name) == 0: - return "" % (str(self.type), self.offset) - return "<%s %s%s, offset %#x>" % (self.type.get_string_before_name(), self.name, - self.type.get_string_after_name(), self.offset) - - -class Structure(object): - def __init__(self, handle=None): - if handle is None: - self.handle = core.BNCreateStructure() - else: - self.handle = handle - - def __del__(self): - core.BNFreeStructure(self.handle) - - @property - def name(self): - count = ctypes.c_ulonglong() - nameList = core.BNGetStructureName(self.handle, count) - result = [] - for i in xrange(count.value): - result.append(nameList[i]) - return demangle.get_qualified_name(result) - - @name.setter - def name(self, value): - core.BNSetStructureName(self.handle, value) - - @property - def members(self): - """Structure member list (read-only)""" - count = ctypes.c_ulonglong() - members = core.BNGetStructureMembers(self.handle, count) - result = [] - for i in xrange(0, count.value): - result.append(StructureMember(Type(core.BNNewTypeReference(members[i].type)), - members[i].name, members[i].offset)) - core.BNFreeStructureMemberList(members, count.value) - return result - - @property - def width(self): - """Structure width (read-only)""" - return core.BNGetStructureWidth(self.handle) - - @property - def alignment(self): - """Structure alignment (read-only)""" - return core.BNGetStructureAlignment(self.handle) - - @property - def packed(self): - return core.BNIsStructurePacked(self.handle) - - @packed.setter - def packed(self, value): - core.BNSetStructurePacked(self.handle, value) - - @property - def union(self): - return core.BNIsStructureUnion(self.handle) - - @union.setter - def union(self, value): - core.BNSetStructureUnion(self.handle, value) - - def __setattr__(self, name, value): - try: - object.__setattr__(self, name, value) - except AttributeError: - raise AttributeError("attribute '%s' is read only" % name) - - def __repr__(self): - if len(self.name) > 0: - return "" % self.name - return "" % self.width - - def append(self, t, name = ""): - core.BNAddStructureMember(self.handle, t.handle, name) - - def insert(self, offset, t, name = ""): - core.BNAddStructureMemberAtOffset(self.handle, t.handle, name, offset) - - def remove(self, i): - core.BNRemoveStructureMember(self.handle, i) - - -class EnumerationMember(object): - def __init__(self, name, value, default): - self.name = name - self.value = value - self.default = default - - def __repr__(self): - return "<%s = %#x>" % (self.name, self.value) - - -class Enumeration(object): - def __init__(self, handle=None): - if handle is None: - self.handle = core.BNCreateEnumeration() - else: - self.handle = handle - - def __del__(self): - core.BNFreeEnumeration(self.handle) - - @property - def name(self): - return core.BNGetEnumerationName(self.handle) - - @name.setter - def name(self, value): - core.BNSetEnumerationName(self.handle, value) - - @property - def members(self): - """Enumeration member list (read-only)""" - count = ctypes.c_ulonglong() - members = core.BNGetEnumerationMembers(self.handle, count) - result = [] - for i in xrange(0, count.value): - result.append(EnumerationMember(members[i].name, members[i].value, members[i].isDefault)) - core.BNFreeEnumerationMemberList(members, count.value) - return result - - def __setattr__(self, name, value): - try: - object.__setattr__(self, name, value) - except AttributeError: - raise AttributeError("attribute '%s' is read only" % name) - - def __repr__(self): - if len(self.name) > 0: - return "" % self.name - return "" % repr(self.members) - - def append(self, name, value = None): - if value is None: - core.BNAddEnumerationMember(self.handle, name) - else: - core.BNAddEnumerationMemberWithValue(self.handle, name, value) - - -class TypeParserResult(object): - def __init__(self, types, variables, functions): - self.types = types - self.variables = variables - self.functions = functions - - def __repr__(self): - return "{types: %s, variables: %s, functions: %s}" % (self.types, self.variables, self.functions) - - -def preprocess_source(source, filename=None, include_dirs=[]): - """ - ``preprocess_source`` run the C preprocessor on the given source or source filename. - - :param str source: source to preprocess - :param str filename: optional filename to preprocess - :param list(str) include_dirs: list of string directorires to use as include directories. - :return: returns a tuple of (preprocessed_source, error_string) - :rtype: tuple(str,str) - :Example: - - >>> source = "#define TEN 10\\nint x[TEN];\\n" - >>> preprocess_source(source) - ('#line 1 "input"\\n\\n#line 2 "input"\\n int x [ 10 ] ;\\n', '') - >>> - """ - if filename is None: - filename = "input" - dir_buf = (ctypes.c_char_p * len(include_dirs))() - for i in xrange(0, len(include_dirs)): - dir_buf[i] = str(include_dirs[i]) - output = ctypes.c_char_p() - errors = ctypes.c_char_p() - result = core.BNPreprocessSource(source, filename, output, errors, dir_buf, len(include_dirs)) - output_str = output.value - error_str = errors.value - core.BNFreeString(ctypes.cast(output, ctypes.POINTER(ctypes.c_byte))) - core.BNFreeString(ctypes.cast(errors, ctypes.POINTER(ctypes.c_byte))) - if result: - return (output_str, error_str) - return (None, error_str) diff --git a/python/demangle.py b/python/demangle.py index 75c63f40..520cfbaf 100644 --- a/python/demangle.py +++ b/python/demangle.py @@ -22,7 +22,7 @@ import ctypes # Binary Ninja components import _binaryninjacore as core -import bntype +import types def get_qualified_name(names): @@ -64,7 +64,7 @@ def demangle_ms(arch, mangled_name): for i in xrange(outSize.value): names.append(outName[i]) core.BNFreeDemangledName(outName.value, outSize.value) - return (bntype.Type(handle), names) + return (types.Type(handle), names) return (None, mangled_name) @@ -79,5 +79,5 @@ def demangle_gnu3(arch, mangled_name): core.BNFreeDemangledName(outName.value, outSize.value) if not handle: return (None, names) - return (bntype.Type(handle), names) + return (types.Type(handle), names) return (None, mangled_name) diff --git a/python/examples/angr_plugin.py b/python/examples/angr_plugin.py index 852eff65..9c91d970 100644 --- a/python/examples/angr_plugin.py +++ b/python/examples/angr_plugin.py @@ -30,14 +30,20 @@ # virtual environment. A later update may allow for a manual override to link to the required version # of Python. -__name__ = "__console__" # angr looks for this, it won't load from within a UI without it -import angr -from binaryninja import * - import tempfile import logging import os +__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 + # Disable warning logs as they show up as errors in the UI logging.disable(logging.WARNING) @@ -109,8 +115,8 @@ def find_instr(bv, addr): # Highlight the instruction in green blocks = bv.get_basic_blocks_at(addr) for block in blocks: - block.set_auto_highlight(HighlightColor(core.BNHighlightStandardColor.GreenHighlightColor, alpha = 128)) - block.function.set_auto_instr_highlight(block.arch, addr, core.BNHighlightStandardColor.GreenHighlightColor) + block.set_auto_highlight(HighlightColor(HighlightStandardColor.GreenHighlightColor, alpha = 128)) + block.function.set_auto_instr_highlight(block.arch, addr, HighlightStandardColor.GreenHighlightColor) # Add the instruction to the list associated with the current view bv.session_data.angr_find.add(addr) @@ -120,8 +126,8 @@ def avoid_instr(bv, addr): # Highlight the instruction in red blocks = bv.get_basic_blocks_at(addr) for block in blocks: - block.set_auto_highlight(HighlightColor(core.BNHighlightStandardColor.RedHighlightColor, alpha = 128)) - block.function.set_auto_instr_highlight(block.arch, addr, core.BNHighlightStandardColor.RedHighlightColor) + block.set_auto_highlight(HighlightColor(HighlightStandardColor.RedHighlightColor, alpha = 128)) + block.function.set_auto_instr_highlight(block.arch, addr, HighlightStandardColor.RedHighlightColor) # Add the instruction to the list associated with the current view bv.session_data.angr_avoid.add(addr) @@ -131,13 +137,14 @@ def solve(bv): if len(bv.session_data.angr_find) == 0: show_message_box("Angr Solve", "You have not specified a goal instruction.\n\n" + "Please right click on the goal instruction and select \"Find Path to This Instruction\" to " + - "continue.", core.BNMessageBoxButtonSet.OKButtonSet, core.BNMessageBoxButtonSet.ErrorIcon) + "continue.", MessageBoxButtonSet.OKButtonSet, MessageBoxButtonSet.ErrorIcon) return # Start a solver thread for the path associated with the view s = Solver(bv.session_data.angr_find, bv.session_data.angr_avoid, bv) s.start() + # Register commands for the user to interact with the plugin PluginCommand.register_for_address("Find Path to This Instruction", "When solving, find a path that gets to this instruction", find_instr) diff --git a/python/examples/bin_info.py b/python/examples/bin_info.py index c574a530..4c4ab8fd 100644 --- a/python/examples/bin_info.py +++ b/python/examples/bin_info.py @@ -21,12 +21,12 @@ import sys import binaryninja.log as log -import binaryninja.binaryview as view +from binaryninja.binaryview import BinaryViewType import binaryninja.interaction as interaction from binaryninja.plugin import PluginCommand -def bininfo(bv): +def get_bininfo(bv): if bv is None: filename = "" if len(sys.argv) > 1: @@ -37,7 +37,7 @@ def bininfo(bv): log.log_warn("No file specified") sys.exit(1) - bv = view.BinaryViewType.get_view_of_file(filename) + bv = BinaryViewType.get_view_of_file(filename) log.redirect_output_to_log() log.log_to_stdout(True) @@ -60,11 +60,14 @@ def bininfo(bv): length = bv.strings[i].length string = bv.read(start, length) contents += "| 0x%x |%d | %s |\n" % (start, length, string) + return contents - interaction.show_markdown_report("Binary Info Report", contents) + +def display_bininfo(bv): + interaction.show_markdown_report("Binary Info Report", get_bininfo(bv)) if __name__ == "__main__": - bininfo(None) + print get_bininfo(None) else: - PluginCommand.register("Binary Info", "Display basic info about the binary", bininfo) + PluginCommand.register("Binary Info", "Display basic info about the binary", display_bininfo) diff --git a/python/examples/breakpoint.py b/python/examples/breakpoint.py index 2426e6a1..e694329b 100644 --- a/python/examples/breakpoint.py +++ b/python/examples/breakpoint.py @@ -18,7 +18,11 @@ # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS # IN THE SOFTWARE. -from binaryninja import * + +from binaryninja.plugin import PluginCommand +from binaryninja.log import log_error +from binaryninja.architecture import Architecture + def write_breakpoint(view, start, length): """Sample function to show registering a plugin menu item for a range of bytes. Also possible: @@ -26,11 +30,21 @@ def write_breakpoint(view, start, length): register_for_address register_for_function """ - if view.arch.name.startswith("x86"): - view.write(start, "\xcc" * length) - elif view.arch.name == "armv7": - view.write(start, "\x7a\x00\x20\xe1" * (length/4)) - else: - log_error("No support for breakpoint on %s" % view.arch.name) + bkpt_str = { + "x86": "int3", + "x86_64": "int3", + "armv7": "bkpt", + "aarch64": "brk #0", + "mips32": "break"} + + if view.arch.name not in bkpt_str: + log_error("Architecture %s not supported" % view.arch.name) + return + bkpt, err = Architecture[view.arch.name].assemble(bkpt_str[view.arch.name]) + if bkpt is None: + log_error(err) + return + view.write(start, bkpt * length / len(bkpt)) + PluginCommand.register_for_range("Convert to breakpoint", "Fill region with breakpoint instructions.", write_breakpoint) diff --git a/python/examples/export_svg.py b/python/examples/export_svg.py index 5a4d2982..bab00f5d 100755 --- a/python/examples/export_svg.py +++ b/python/examples/export_svg.py @@ -1,11 +1,14 @@ -from binaryninja import * +# from binaryninja import * import os import webbrowser try: - from urllib import pathname2url # Python 2.x + from urllib import pathname2url # Python 2.x except: - from urllib.request import pathname2url # Python 3.x + from urllib.request import pathname2url # Python 3.x +from binaryninja.interaction import get_save_filename_input, show_message_box +from binaryninja.enums import MessageBoxButtonSet +from binaryninja.plugin import PluginCommand colors = {'green': [162, 217, 175], 'red': [222, 143, 151], 'blue': [128, 198, 233], 'cyan': [142, 230, 237], 'lightCyan': [176, 221, 228], 'orange': [237, 189, 129], 'yellow': [237, 223, 179], 'magenta': [218, 196, 209], 'none': [74, 74, 74]} @@ -17,40 +20,46 @@ escape_table = { ' ': " " } -def escape(string): - string=string.decode('utf-8').encode('ascii','xmlcharrefreplace') #handle extended unicode - return ''.join(escape_table.get(i,i) for i in string) #still escape the basics -def save_svg(bv,function): - address = hex(function.start).replace('L','') +def escape(toescape): + toescape = toescape.decode('utf-8').encode('ascii', 'xmlcharrefreplace') # handle extended unicode + return ''.join(escape_table.get(i, i) for i in toescape) # still escape the basics + + +def save_svg(bv, function): + address = hex(function.start).replace('L', '') path = os.path.dirname(bv.file.filename) origname = os.path.basename(bv.file.filename) - filename = os.path.join(path,'binaryninja-{filename}-{function}.html'.format(filename=origname,function=address)) + filename = os.path.join(path, 'binaryninja-{filename}-{function}.html'.format(filename=origname, function=address)) outputfile = get_save_filename_input('File name for export_svg', 'HTML files (*.html)', filename) if outputfile is None: return content = render_svg(function) - output = open(outputfile,'w') + output = open(outputfile, 'w') output.write(content) output.close() - if show_message_box("Open SVG", "Would you like to view the exported SVG?", buttons = core.YesNoButtonSet, icon = core.QuestionIcon) == core.YesButton: + result = show_message_box("Open SVG", "Would you like to view the exported SVG?", + buttons = MessageBoxButtonSet.YesNoButtonSet, icon = MessageBoxButtonSet.QuestionIcon) + if result == MessageBoxButtonSet.YesButton: url = 'file:{}'.format(pathname2url(outputfile)) webbrowser.open(url) -def instruction_data_flow(function,address): + +def instruction_data_flow(function, address): ''' TODO: Extract data flow information ''' - length = function.view.get_instruction_length(function.arch,address) + length = function.view.get_instruction_length(function.arch, address) bytes = function.view.read(address, length) hex = bytes.encode('hex') - padded = ' '.join([hex[i:i+2] for i in range(0, len(hex), 2)]) + padded = ' '.join([hex[i:i + 2] for i in range(0, len(hex), 2)]) return 'Opcode: {bytes}'.format(bytes=padded) + def render_svg(function): graph = function.create_graph() graph.layout_and_wait() heightconst = 15 ratio = 0.48 - widthconst = heightconst*ratio + widthconst = heightconst * ratio output = ''' @@ -135,63 +144,64 @@ def render_svg(function): - '''.format(width=graph.width*widthconst + 20, height=graph.height*heightconst + 20) + '''.format(width=graph.width * widthconst + 20, height=graph.height * heightconst + 20) output += ''' Function Graph 0 ''' edges = '' - for i,block in enumerate(graph.blocks): + for i, block in enumerate(graph.blocks): - #Calculate basic block location and coordinates + # Calculate basic block location and coordinates x = ((block.x) * widthconst) y = ((block.y) * heightconst) width = ((block.width) * widthconst) height = ((block.height) * heightconst) - #Render block + # Render block output += ' \n'.format(i=i) output += ' Basic Block {i}\n'.format(i=i) - rgb=colors['none'] + rgb = colors['none'] try: bb = block.basic_block color_code = bb.highlight.color color_str = bb.highlight._standard_color_to_str(color_code) if color_str in colors: - rgb=colors[color_str] + rgb = colors[color_str] except: pass - output += ' \n'.format(x=x,y=y,width=width + 16,height=height + 12,r=rgb[0],g=rgb[1],b=rgb[2]) + output += ' \n'.format(x=x, y=y, width=width + 16, height=height + 12, r=rgb[0], g=rgb[1], b=rgb[2]) - #Render instructions, unfortunately tspans don't allow copying/pasting more - #than one line at a time, need SVG 1.2 textarea tags for that it looks like + # Render instructions, unfortunately tspans don't allow copying/pasting more + # than one line at a time, need SVG 1.2 textarea tags for that it looks like - output += ' \n'.format(x=x,y=y + (i + 1) * heightconst) - for i,line in enumerate(block.lines): - output += ' '.format(x=x + 6,y=y + 6 + (i + 0.7) * heightconst,address=hex(line.address)[:-1]) + output += ' \n'.format(x=x, y=y + (i + 1) * heightconst) + for i, line in enumerate(block.lines): + output += ' '.format(x=x + 6, y=y + 6 + (i + 0.7) * heightconst, address=hex(line.address)[:-1]) hover = instruction_data_flow(function, line.address) output += '{hover}'.format(hover=hover) for token in line.tokens: # TODO: add hover for hex, function, and reg tokens - output+='{text}'.format(text=escape(token.text),tokentype=token.type) + output += '{text}'.format(text=escape(token.text), tokentype=token.type) output += '\n' output += ' \n' output += ' \n' - #Edges are rendered in a seperate chunk so they have priority over the - #basic blocks or else they'd render below them + # Edges are rendered in a seperate chunk so they have priority over the + # basic blocks or else they'd render below them for edge in block.outgoing_edges: points = "" - x,y = edge.points[0] - points += str(x*widthconst)+","+str(y*heightconst + 12) + " " - for x,y in edge.points[1:-1]: - points += str(x*widthconst)+","+str(y*heightconst) + " " - x,y = edge.points[-1] - points += str(x*widthconst)+","+str(y*heightconst + 0) + " " - edges += ' \n'.format(type=edge.type,points=points) + x, y = edge.points[0] + points += str(x * widthconst) + "," + str(y * heightconst + 12) + " " + for x, y in edge.points[1:-1]: + points += str(x * widthconst) + "," + str(y * heightconst) + " " + x, y = edge.points[-1] + points += str(x * widthconst) + "," + str(y * heightconst + 0) + " " + edges += ' \n'.format(type=edge.type, points=points) output += ' ' + edges + '\n' output += ' \n' output += '' return output + PluginCommand.register_for_function("Export to SVG", "Exports an SVG of the current function", save_svg) diff --git a/python/examples/jump_table.py b/python/examples/jump_table.py index 0fd0dbab..f24eea12 100644 --- a/python/examples/jump_table.py +++ b/python/examples/jump_table.py @@ -20,7 +20,8 @@ # This plugin will attempt to resolve simple jump tables (an array of code pointers) and add the destinations # as indirect branch targets so that the flow graph reflects the jump table's control flow. -import binaryninja +from binaryninja.plugin import PluginCommand +from binaryninja.enum import InstructionTextTokenType import struct @@ -49,7 +50,7 @@ def find_jump_table(bv, addr): # Collect the branch targets for any tables referenced by the clicked instruction branches = [] for token in tokens: - if token.type == core.BNInstructionTextTokenType.PossibleAddressToken: # Table addresses will be a "possible address" token + if token.type == InstructionTextTokenType.PossibleAddressToken: # Table addresses will be a "possible address" token tbl = token.value print "Found possible table at 0x%x" % tbl i = 0 @@ -79,6 +80,7 @@ def find_jump_table(bv, addr): # Set the indirect branch targets on the jump instruction to be the list of targets discovered func.set_user_indirect_branches(jump_addr, branches) + # Create a plugin command so that the user can right click on an instruction referencing a jump table and # invoke the command -binaryninja.PluginCommand.register_for_address("Process jump table", "Look for jump table destinations", find_jump_table) +PluginCommand.register_for_address("Process jump table", "Look for jump table destinations", find_jump_table) diff --git a/python/examples/nds.py b/python/examples/nds.py index 302bbc0d..ff137b4b 100644 --- a/python/examples/nds.py +++ b/python/examples/nds.py @@ -1,108 +1,117 @@ -# Copyright (c) 2015-2016 Vector 35 LLC -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to -# deal in the Software without restriction, including without limitation the -# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or -# sell copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in -# all copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS -# IN THE SOFTWARE. - -from binaryninja import * -import struct -import traceback -import os - -def crc16(data): - crc = 0xffff - for ch in data: - crc ^= ord(ch) - for bit in xrange(0, 8): - if (crc & 1) == 1: - crc = (crc >> 1) ^ 0xa001 - else: - crc >>= 1 - return crc - -class DSView(BinaryView): - def __init__(self, data): - BinaryView.__init__(self, file_metadata = data.file, parent_view = data) - self.raw = data - - @classmethod - def is_valid_for_data(self, data): - hdr = data.read(0, 0x160) - if len(hdr) < 0x160: - return False - if struct.unpack("> 1) ^ 0xa001 + else: + crc >>= 1 + return crc + + +class DSView(BinaryView): + def __init__(self, data): + BinaryView.__init__(self, file_metadata = data.file, parent_view = data) + self.raw = data + + @classmethod + def is_valid_for_data(self, data): + hdr = data.read(0, 0x160) + if len(hdr) < 0x160: + return False + if struct.unpack("= 0x8000: self.add_function(Architecture['6502'].standalone_platform, addr) @@ -611,6 +618,7 @@ class NESView(BinaryView): def perform_get_entry_point(self): return struct.unpack("'.format(sys.argv[0])) - return -1 - - target = sys.argv[1] - - bv = BinaryView.open(target) - view_type = next(bvt for bvt in bv.available_view_types if bvt.name != 'Raw') - if not view_type: - print('Error: Unable to get any other view type besides Raw') - return -1 - - bv = bv.file.get_view_of_type(view_type.name) - bv.update_analysis_and_wait() - - print_syscalls(bv) + for func in bv.functions: + syscalls = (il for il in chain.from_iterable(func.low_level_il) + if il.operation == LowLevelILOperation.LLIL_SYSCALL) + for il in syscalls: + value = func.get_reg_value_at(il.address, register).value + print("System call address: {:#x} - {:d}".format(il.address, value)) if __name__ == "__main__": - sys.exit(main()) + if len(sys.argv) != 2: + print('Usage: {} '.format(sys.argv[0])) + else: + print_syscalls(sys.argv[1]) diff --git a/python/examples/version_switcher.py b/python/examples/version_switcher.py index e8f8814d..bc4f576c 100644 --- a/python/examples/version_switcher.py +++ b/python/examples/version_switcher.py @@ -27,10 +27,11 @@ chandefault = binaryninja.UpdateChannel.list[0].name channel = None versions = [] + def load_channel(newchannel): global channel global versions - if (channel != None and newchannel == channel.name): + if (channel is None and newchannel == channel.name): print "Same channel, not updating." else: try: @@ -42,6 +43,7 @@ def load_channel(newchannel): print "%s is not a valid channel name. Defaulting to " % chandefault channel = binaryninja.UpdateChannel[chandefault] + def select(version): done = False date = datetime.datetime.fromtimestamp(version.time).strftime('%c') @@ -74,34 +76,37 @@ def select(version): print "binaryninja.core_version %s" % binaryninja.core_version print "Updating..." print version.update() - #forward updating won't work without reloading + # forward updating won't work without reloading sys.exit() else: print "Invalid selection" + def list_channels(): done = False print "\tSelect channel:\n" while not done: channel_list = binaryninja.UpdateChannel.list for index, item in enumerate(channel_list): - print "\t%d)\t%s" % (index+1, item.name) - print "\t%d)\t%s" % (len(channel_list)+1, "Main Menu") + print "\t%d)\t%s" % (index + 1, item.name) + print "\t%d)\t%s" % (len(channel_list) + 1, "Main Menu") selection = raw_input('Choice: ') if selection.isdigit(): selection = int(selection) else: selection = 0 - if (selection <= 0 or selection > len(channel_list)+1): + if (selection <= 0 or selection > len(channel_list) + 1): print "%s is an invalid choice." % selection else: done = True if (selection != len(channel_list) + 1): load_channel(channel_list[selection - 1].name) + def toggle_updates(): binaryninja.set_auto_updates_enabled(not binaryninja.are_auto_updates_enabled()) + def main(): global channel done = False diff --git a/python/function.py b/python/function.py index 16357c3f..e3c79312 100644 --- a/python/function.py +++ b/python/function.py @@ -24,10 +24,12 @@ import ctypes # Binary Ninja components import _binaryninjacore as core +from enums import (FunctionGraphType, BranchType, SymbolType, InstructionTextTokenType, + HighlightStandardColor, RegisterValueType, ImplicitRegisterExtend, DisassemblyOption, IntegerDisplayType) import architecture import highlight import associateddatastore -import bntype +import types import basicblock import lowlevelil import binaryview @@ -46,16 +48,16 @@ class LookupTableEntry(object): class RegisterValue(object): def __init__(self, arch, value): self.type = value.state - if value.state == core.BNRegisterValueType.EntryValue: + if value.state == RegisterValueType.EntryValue: self.reg = arch.get_reg_name(value.reg) - elif value.state == core.BNRegisterValueType.OffsetFromEntryValue: + elif value.state == RegisterValueType.OffsetFromEntryValue: self.reg = arch.get_reg_name(value.reg) self.offset = value.value - elif value.state == core.BNRegisterValueType.ConstantValue: + elif value.state == RegisterValueType.ConstantValue: self.value = value.value - elif value.state == core.BNRegisterValueType.StackFrameOffset: + elif value.state == RegisterValueType.StackFrameOffset: self.offset = value.value - elif value.state == core.BNRegisterValueType.SignedRangeValue: + elif value.state == RegisterValueType.SignedRangeValue: self.offset = value.value self.start = value.rangeStart self.end = value.rangeEnd @@ -64,12 +66,12 @@ class RegisterValue(object): self.start |= ~((1 << 63) - 1) if self.end & (1 << 63): self.end |= ~((1 << 63) - 1) - elif value.state == core.BNRegisterValueType.UnsignedRangeValue: + elif value.state == RegisterValueType.UnsignedRangeValue: self.offset = value.value self.start = value.rangeStart self.end = value.rangeEnd self.step = value.rangeStep - elif value.state == core.BNRegisterValueType.LookupTableValue: + elif value.state == RegisterValueType.LookupTableValue: self.table = [] self.mapping = {} for i in xrange(0, value.rangeEnd): @@ -78,25 +80,25 @@ class RegisterValue(object): from_list.append(value.table[i].fromValues[j]) self.mapping[value.table[i].fromValues[j]] = value.table[i].toValue self.table.append(LookupTableEntry(from_list, value.table[i].toValue)) - elif value.state == core.BNRegisterValueType.OffsetFromUndeterminedValue: + elif value.state == RegisterValueType.OffsetFromUndeterminedValue: self.offset = value.value def __repr__(self): - if self.type == core.BNRegisterValueType.EntryValue: + if self.type == RegisterValueType.EntryValue: return "" % self.reg - if self.type == core.BNRegisterValueType.OffsetFromEntryValue: + if self.type == RegisterValueType.OffsetFromEntryValue: return "" % (self.reg, self.offset) - if self.type == core.BNRegisterValueType.ConstantValue: + if self.type == RegisterValueType.ConstantValue: return "" % self.value - if self.type == core.BNRegisterValueType.StackFrameOffset: + if self.type == RegisterValueType.StackFrameOffset: return "" % self.offset - if (self.type == core.BNRegisterValueType.SignedRangeValue) or (self.type == core.BNRegisterValueType.UnsignedRangeValue): + if (self.type == RegisterValueType.SignedRangeValue) or (self.type == RegisterValueType.UnsignedRangeValue): if self.step == 1: return "" % (self.start, self.end) return "" % (self.start, self.end, self.step) - if self.type == core.BNRegisterValueType.LookupTableValue: + if self.type == RegisterValueType.LookupTableValue: return "" % ', '.join([repr(i) for i in self.table]) - if self.type == core.BNRegisterValueType.OffsetFromUndeterminedValue: + if self.type == RegisterValueType.OffsetFromUndeterminedValue: return "" % self.offset return "" @@ -195,7 +197,7 @@ class Function(object): if self.symbol is not None: self.view.undefine_user_symbol(self.symbol) else: - symbol = bntype.Symbol(core.BNSymbolType.FunctionSymbol, self.start, value) + symbol = types.Symbol(SymbolType.FunctionSymbol, self.start, value) self.view.define_user_symbol(symbol) @property @@ -230,7 +232,7 @@ class Function(object): sym = core.BNGetFunctionSymbol(self.handle) if sym is None: return None - return bntype.Symbol(None, None, None, handle = sym) + return types.Symbol(None, None, None, handle = sym) @property def auto(self): @@ -287,7 +289,7 @@ class Function(object): @property def function_type(self): """Function type object""" - return bntype.Type(core.BNGetFunctionType(self.handle)) + return types.Type(core.BNGetFunctionType(self.handle)) @function_type.setter def function_type(self, value): @@ -300,7 +302,7 @@ class Function(object): v = core.BNGetStackLayout(self.handle, count) result = [] for i in xrange(0, count.value): - result.append(StackVariable(v[i].offset, v[i].name, bntype.Type(handle = core.BNNewTypeReference(v[i].type)))) + result.append(StackVariable(v[i].offset, v[i].name, types.Type(handle = core.BNNewTypeReference(v[i].type)))) result.sort(key = lambda x: x.offset) core.BNFreeStackLayout(v, count.value) return result @@ -553,7 +555,7 @@ class Function(object): refs = core.BNGetStackVariablesReferencedByInstruction(self.handle, arch.handle, addr, count) result = [] for i in xrange(0, count.value): - result.append(StackVariableReference(refs[i].sourceOperand, bntype.Type(core.BNNewTypeReference(refs[i].type)), + result.append(StackVariableReference(refs[i].sourceOperand, types.Type(core.BNNewTypeReference(refs[i].type)), refs[i].name, refs[i].startingOffset, refs[i].referencedOffset)) core.BNFreeStackVariableReferenceList(refs, count.value) return result @@ -661,7 +663,7 @@ class Function(object): for i in xrange(0, count.value): tokens = [] for j in xrange(0, lines[i].count): - token_type = core.BNInstructionTextTokenType(lines[i].tokens[j].type) + token_type = InstructionTextTokenType(lines[i].tokens[j].type) text = lines[i].tokens[j].text value = lines[i].tokens[j].value size = lines[i].tokens[j].size @@ -688,13 +690,13 @@ class Function(object): :param int instr_addr: :param int value: :param int operand: - :param BNIntegerDisplayTypeEnum display_type: + :param IntegerDisplayTypeEnum display_type: :param Architecture arch: (optional) """ if arch is None: arch = self.arch if isinstance(display_type, str): - display_type = core.BNIntegerDisplayType[display_type] + display_type = IntegerDisplayType[display_type] core.BNSetIntegerConstantDisplayType(self.handle, arch.handle, instr_addr, value, operand, display_type) def reanalyze(self): @@ -741,13 +743,13 @@ class Function(object): if arch is None: arch = self.arch color = core.BNGetInstructionHighlight(self.handle, arch.handle, addr) - if color.style == core.BNHighlightColorStyle.StandardHighlightColor: + if color.style == HighlightColorStyle.StandardHighlightColor: return highlight.HighlightColor(color = color.color, alpha = color.alpha) - elif color.style == core.BNHighlightColorStyle.MixedHighlightColor: + elif color.style == HighlightColorStyle.MixedHighlightColor: return highlight.HighlightColor(color = color.color, mix_color = color.mixColor, mix = color.mix, alpha = color.alpha) - elif color.style == core.BNHighlightColorStyle.CustomHighlightColor: + elif color.style == HighlightColorStyle.CustomHighlightColor: return highlight.HighlightColor(red = color.r, green = color.g, blue = color.b, alpha = color.alpha) - return highlight.HighlightColor(color = core.BNHighlightStandardColor.NoHighlightColor) + return highlight.HighlightColor(color = HighlightStandardColor.NoHighlightColor) def set_auto_instr_highlight(self, addr, color, arch=None): """ @@ -756,7 +758,7 @@ class Function(object): .warning:: Use only in analysis plugins. Do not use in regular plugins, as colors won't be saved to the database. :param int addr: virtual address of the instruction to be highlighted - :param core.BNHighlightStandardColor or highlight.HighlightColor color: Color value to use for highlighting + :param HighlightStandardColor or highlight.HighlightColor color: Color value to use for highlighting :param Architecture arch: (optional) Architecture of the instruction if different from self.arch """ if arch is None: @@ -770,17 +772,17 @@ class Function(object): ``set_user_instr_highlight`` highlights the instruction at the specified address with the supplied color :param int addr: virtual address of the instruction to be highlighted - :param core.BNHighlightStandardColor or highlight.HighlightColor color: Color value to use for highlighting + :param HighlightStandardColor or highlight.HighlightColor color: Color value to use for highlighting :param Architecture arch: (optional) Architecture of the instruction if different from self.arch :Example: - >>> current_function.set_user_instr_highlight(here, core.BNHighlightStandardColor.BlueHighlightColor) + >>> current_function.set_user_instr_highlight(here, HighlightStandardColor.BlueHighlightColor) >>> current_function.set_user_instr_highlight(here, highlight.HighlightColor(red=0xff, blue=0xff, green=0)) """ if arch is None: arch = self.arch - if not isinstance(color, core.BNHighlightStandardColor) and not isinstance(color, highlight.HighlightColor): - raise ValueError("Specified color is not one of core.BNHighlightStandardColor, highlight.HighlightColor") + if not isinstance(color, HighlightStandardColor) and not isinstance(color, highlight.HighlightColor): + raise ValueError("Specified color is not one of HighlightStandardColor, highlight.HighlightColor") core.BNSetUserInstructionHighlight(self.handle, arch.handle, addr, color._get_core_struct()) @@ -908,7 +910,7 @@ class FunctionGraphBlock(object): addr = lines[i].addr tokens = [] for j in xrange(0, lines[i].count): - token_type = core.BNInstructionTextTokenType(lines[i].tokens[j].type) + token_type = InstructionTextTokenType(lines[i].tokens[j].type) text = lines[i].tokens[j].text value = lines[i].tokens[j].value size = lines[i].tokens[j].size @@ -925,7 +927,7 @@ class FunctionGraphBlock(object): edges = core.BNGetFunctionGraphBlockOutgoingEdges(self.handle, count) result = [] for i in xrange(0, count.value): - branch_type = core.BNBranchType(edges[i].type) + branch_type = BranchType(edges[i].type) target = edges[i].target arch = None if edges[i].arch is not None: @@ -958,7 +960,7 @@ class FunctionGraphBlock(object): addr = lines[i].addr tokens = [] for j in xrange(0, lines[i].count): - token_type = core.BNInstructionTextTokenType(lines[i].tokens[j].type) + token_type = InstructionTextTokenType(lines[i].tokens[j].type) text = lines[i].tokens[j].text value = lines[i].tokens[j].value size = lines[i].tokens[j].size @@ -997,12 +999,12 @@ class DisassemblySettings(object): def is_option_set(self, option): if isinstance(option, str): - option = core.BNDisassemblyOption[option] + option = DisassemblyOption[option] return core.BNIsDisassemblySettingsOptionSet(self.handle, option) def set_option(self, option, state = True): if isinstance(option, str): - option = core.BNDisassemblyOption[option] + option = DisassemblyOption[option] core.BNSetDisassemblySettingsOption(self.handle, option, state) @@ -1033,7 +1035,7 @@ class FunctionGraph(object): @property def type(self): """Function graph type (read-only)""" - return core.BNFunctionGraphType(core.BNGetFunctionGraphType(self.handle)) + return FunctionGraphType(core.BNGetFunctionGraphType(self.handle)) @property def blocks(self): @@ -1101,9 +1103,9 @@ class FunctionGraph(object): except: log.log_error(traceback.format_exc()) - def layout(self, graph_type = core.BNFunctionGraphType.NormalFunctionGraph): + def layout(self, graph_type = FunctionGraphType.NormalFunctionGraph): if isinstance(graph_type, str): - graph_type = core.BNFunctionGraphType[graph_type] + graph_type = FunctionGraphType[graph_type] core.BNStartFunctionGraphLayout(self.handle, graph_type) def _wait_complete(self): @@ -1111,7 +1113,7 @@ class FunctionGraph(object): self._wait_cond.notify() self._wait_cond.release() - def layout_and_wait(self, graph_type = core.BNFunctionGraphType.NormalFunctionGraph): + def layout_and_wait(self, graph_type=FunctionGraphType.NormalFunctionGraph): self._wait_cond = threading.Condition() self.on_complete(self._wait_complete) self.layout(graph_type) @@ -1139,17 +1141,17 @@ class FunctionGraph(object): def is_option_set(self, option): if isinstance(option, str): - option = core.BNDisassemblyOption[option] + option = DisassemblyOption[option] return core.BNIsFunctionGraphOptionSet(self.handle, option) def set_option(self, option, state = True): if isinstance(option, str): - option = core.BNDisassemblyOption[option] + option = DisassemblyOption[option] core.BNSetFunctionGraphOption(self.handle, option, state) class RegisterInfo(object): - def __init__(self, full_width_reg, size, offset = 0, extend = core.BNImplicitRegisterExtend.NoExtend, index = None): + def __init__(self, full_width_reg, size, offset=0, extend=ImplicitRegisterExtend.NoExtend, index=None): self.full_width_reg = full_width_reg self.offset = offset self.size = size @@ -1157,9 +1159,9 @@ class RegisterInfo(object): self.index = index def __repr__(self): - if self.extend == core.BNImplicitRegisterExtend.ZeroExtendToFullWidth: + if self.extend == ImplicitRegisterExtend.ZeroExtendToFullWidth: extend = ", zero extend" - elif self.extend == core.BNImplicitRegisterExtend.SignExtendToFullWidth: + elif self.extend == ImplicitRegisterExtend.SignExtendToFullWidth: extend = ", sign extend" else: extend = "" @@ -1200,7 +1202,7 @@ class InstructionTextToken(object): ``class InstructionTextToken`` is used to tell the core about the various components in the disassembly views. ========================== ============================================ - BNInstructionTextTokenType Description + InstructionTextTokenType Description ========================== ============================================ TextToken Text that doesn't fit into the other tokens InstructionToken The instruction mnemonic diff --git a/python/generator.cpp b/python/generator.cpp index 730b317c..d3725b6d 100644 --- a/python/generator.cpp +++ b/python/generator.cpp @@ -101,8 +101,13 @@ void OutputType(FILE* out, Type* type, bool isReturnType = false, bool isCallbac fprintf(out, "%s", type->GetQualifiedName(type->GetStructure()->GetName()).c_str()); break; case EnumerationTypeClass: - fprintf(out, "%sEnum", type->GetQualifiedName(type->GetEnumeration()->GetName()).c_str()); + { + string name = type->GetQualifiedName(type->GetEnumeration()->GetName()); + if (name.size() > 2 && name.substr(0, 2) == "BN") + name = name.substr(2); + fprintf(out, "%sEnum", name.c_str()); break; + } case PointerTypeClass: if (isCallback || (type->GetChildType()->GetClass() == VoidTypeClass)) { @@ -147,9 +152,9 @@ void OutputType(FILE* out, Type* type, bool isReturnType = false, bool isCallbac int main(int argc, char* argv[]) { - if (argc < 3) + if (argc < 4) { - fprintf(stderr, "Usage: generator
\n"); + fprintf(stderr, "Usage: generator
\n"); return 1; } @@ -164,23 +169,27 @@ int main(int argc, char* argv[]) return 1; FILE* out = fopen(argv[2], "w"); + FILE* enums = fopen(argv[3], "w"); - fprintf(out, "import ctypes, os, enum\n\n"); + fprintf(out, "from __future__ import absolute_import\n"); + fprintf(out, "import ctypes, os\n\n"); + fprintf(enums, "import enum"); fprintf(out, "# Load core module\n"); -#if defined(__APPLE__) - fprintf(out, "_base_path = os.path.join(os.path.dirname(__file__), \"..\", \"..\", \"..\", \"MacOS\")\n"); -#else - fprintf(out, "_base_path = os.path.join(os.path.dirname(__file__), \"..\", \"..\")\n"); -#endif - -#ifdef WIN32 - fprintf(out, "core = ctypes.CDLL(os.path.join(_base_path, \"binaryninjacore.dll\"))\n\n"); -#elif defined(__APPLE__) - fprintf(out, "core = ctypes.CDLL(os.path.join(_base_path, \"libbinaryninjacore.dylib\"))\n\n"); -#else - fprintf(out, "core = ctypes.CDLL(os.path.join(_base_path, \"libbinaryninjacore.so.1\"))\n\n"); -#endif + fprintf(out, "import platform\n"); + fprintf(out, "core = None\n"); + fprintf(out, "_base_path = None\n"); + fprintf(out, "if platform.system() == \"Darwin\":\n"); + fprintf(out, "\t_base_path = os.path.join(os.path.dirname(__file__), \"..\", \"..\", \"..\", \"MacOS\")\n"); + fprintf(out, "\tcore = ctypes.CDLL(os.path.join(_base_path, \"libbinaryninjacore.dylib\"))\n\n"); + fprintf(out, "elif platform.system() == \"Linux\":\n"); + fprintf(out, "\t_base_path = os.path.join(os.path.dirname(__file__), \"..\", \"..\")\n"); + fprintf(out, "\tcore = ctypes.CDLL(os.path.join(_base_path, \"libbinaryninjacore.so.1\"))\n\n"); + fprintf(out, "elif platform.system() == \"Windows\":\n"); + fprintf(out, "\t_base_path = os.path.join(os.path.dirname(__file__), \"..\", \"..\")\n"); + fprintf(out, "\tcore = ctypes.CDLL(os.path.join(_base_path, \"binaryninjacore.dll\"))\n"); + fprintf(out, "else:\n"); + fprintf(out, "\traise Exception(\"OS not supported\")\n\n"); // Create type objects fprintf(out, "# Type definitions\n"); @@ -189,17 +198,21 @@ int main(int argc, char* argv[]) if (i.second->GetClass() == StructureTypeClass) { fprintf(out, "class %s(ctypes.Structure):\n", i.first.c_str()); - fprintf(out, " pass\n"); + fprintf(out, "\tpass\n"); } else if (i.second->GetClass() == EnumerationTypeClass) { - fprintf(out, "%sEnum = ctypes.c_int\n", i.first.c_str()); - fprintf(out, "class %s(enum.IntEnum):\n", i.first.c_str()); + string name = i.first; + if (name.size() > 2 && name.substr(0, 2) == "BN") + name = name.substr(2); + + fprintf(out, "%sEnum = ctypes.c_int\n", name.c_str()); + + fprintf(enums, "\n\nclass %s(enum.IntEnum):\n", name.c_str()); for (auto& j : i.second->GetEnumeration()->GetMembers()) { - fprintf(out, " %s = %" PRId64 "\n", j.name.c_str(), j.value); + fprintf(enums, "\t%s = %" PRId64 "\n", j.name.c_str(), j.value); } - } else if ((i.second->GetClass() == BoolTypeClass) || (i.second->GetClass() == IntegerTypeClass) || (i.second->GetClass() == FloatTypeClass) || (i.second->GetClass() == ArrayTypeClass)) @@ -219,11 +232,11 @@ int main(int argc, char* argv[]) fprintf(out, "%s._fields_ = [\n", i.first.c_str()); for (auto& j : i.second->GetStructure()->GetMembers()) { - fprintf(out, " (\"%s\", ", j.name.c_str()); + fprintf(out, "\t\t(\"%s\", ", j.name.c_str()); OutputType(out, j.type); fprintf(out, "),\n"); } - fprintf(out, " ]\n"); + fprintf(out, "\t]\n"); } } @@ -260,7 +273,7 @@ int main(int argc, char* argv[]) fprintf(out, "%s.argtypes = [\n", funcName.c_str()); for (auto& j : i.second->GetParameters()) { - fprintf(out, " "); + fprintf(out, "\t\t"); if (i.first == "BNFreeString") { // BNFreeString expects a pointer to a string allocated by the core, so do not use @@ -274,38 +287,39 @@ int main(int argc, char* argv[]) } fprintf(out, ",\n"); } - fprintf(out, " ]\n"); + fprintf(out, "\t]\n"); } if (stringResult) { // Emit wrapper to get Python string and free native memory fprintf(out, "def %s(*args):\n", i.first.c_str()); - fprintf(out, " result = %s(*args)\n", funcName.c_str()); - fprintf(out, " string = ctypes.cast(result, ctypes.c_char_p).value\n"); - fprintf(out, " BNFreeString(result)\n"); - fprintf(out, " return string\n"); + fprintf(out, "\tresult = %s(*args)\n", funcName.c_str()); + fprintf(out, "\tstring = ctypes.cast(result, ctypes.c_char_p).value\n"); + fprintf(out, "\tBNFreeString(result)\n"); + fprintf(out, "\treturn string\n"); } else if (pointerResult) { // Emit wrapper to return None on null pointer fprintf(out, "def %s(*args):\n", i.first.c_str()); - fprintf(out, " result = %s(*args)\n", funcName.c_str()); - fprintf(out, " if not result:\n"); - fprintf(out, " return None\n"); - fprintf(out, " return result\n"); + fprintf(out, "\tresult = %s(*args)\n", funcName.c_str()); + fprintf(out, "\tif not result:\n"); + fprintf(out, "\t\treturn None\n"); + fprintf(out, "\treturn result\n"); } } fprintf(out, "\n# Helper functions\n"); fprintf(out, "def handle_of_type(value, handle_type):\n"); - fprintf(out, " if isinstance(value, ctypes.POINTER(handle_type)) or isinstance(value, ctypes.c_void_p):\n"); - fprintf(out, " return ctypes.cast(value, ctypes.POINTER(handle_type))\n"); - fprintf(out, " raise ValueError, 'expected pointer to %%s' %% str(handle_type)\n"); + fprintf(out, "\tif isinstance(value, ctypes.POINTER(handle_type)) or isinstance(value, ctypes.c_void_p):\n"); + fprintf(out, "\t\treturn ctypes.cast(value, ctypes.POINTER(handle_type))\n"); + fprintf(out, "\traise ValueError, 'expected pointer to %%s' %% str(handle_type)\n"); fprintf(out, "\n# Set path for core plugins\n"); fprintf(out, "BNSetBundledPluginDirectory(os.path.join(_base_path, \"plugins\"))\n"); fclose(out); + fclose(enums); return 0; } diff --git a/python/highlight.py b/python/highlight.py index 98735166..6af1cf95 100644 --- a/python/highlight.py +++ b/python/highlight.py @@ -21,66 +21,67 @@ # Binary Ninja components import _binaryninjacore as core +from enums import HighlightColorStyle, HighlightStandardColor class HighlightColor(object): def __init__(self, color = None, mix_color = None, mix = None, red = None, green = None, blue = None, alpha = 255): if (red is not None) and (green is not None) and (blue is not None): - self.style = core.BNHighlightColorStyle.CustomHighlightColor + self.style = HighlightColorStyle.CustomHighlightColor self.red = red self.green = green self.blue = blue elif (mix_color is not None) and (mix is not None): - self.style = core.BNHighlightColorStyle.MixedHighlightColor + self.style = HighlightColorStyle.MixedHighlightColor if color is None: - self.color = core.BNHighlightStandardColor.NoHighlightColor + self.color = HighlightStandardColor.NoHighlightColor else: self.color = color self.mix_color = mix_color self.mix = mix else: - self.style = core.BNHighlightColorStyle.StandardHighlightColor + self.style = HighlightColorStyle.StandardHighlightColor if color is None: - self.color = core.BNHighlightStandardColor.NoHighlightColor + self.color = HighlightStandardColor.NoHighlightColor else: self.color = color self.alpha = alpha def _standard_color_to_str(self, color): - if color == core.BNHighlightStandardColor.NoHighlightColor: + if color == HighlightStandardColor.NoHighlightColor: return "none" - if color == core.BNHighlightStandardColor.BlueHighlightColor: + if color == HighlightStandardColor.BlueHighlightColor: return "blue" - if color == core.BNHighlightStandardColor.GreenHighlightColor: + if color == HighlightStandardColor.GreenHighlightColor: return "green" - if color == core.BNHighlightStandardColor.CyanHighlightColor: + if color == HighlightStandardColor.CyanHighlightColor: return "cyan" - if color == core.BNHighlightStandardColor.RedHighlightColor: + if color == HighlightStandardColor.RedHighlightColor: return "red" - if color == core.BNHighlightStandardColor.MagentaHighlightColor: + if color == HighlightStandardColor.MagentaHighlightColor: return "magenta" - if color == core.BNHighlightStandardColor.YellowHighlightColor: + if color == HighlightStandardColor.YellowHighlightColor: return "yellow" - if color == core.BNHighlightStandardColor.OrangeHighlightColor: + if color == HighlightStandardColor.OrangeHighlightColor: return "orange" - if color == core.BNHighlightStandardColor.WhiteHighlightColor: + if color == HighlightStandardColor.WhiteHighlightColor: return "white" - if color == core.BNHighlightStandardColor.BlackHighlightColor: + if color == HighlightStandardColor.BlackHighlightColor: return "black" return "%d" % color def __repr__(self): - if self.style == core.BNHighlightColorStyle.StandardHighlightColor: + if self.style == HighlightColorStyle.StandardHighlightColor: if self.alpha == 255: return "" % self._standard_color_to_str(self.color) return "" % (self._standard_color_to_str(self.color), self.alpha) - if self.style == core.BNHighlightColorStyle.MixedHighlightColor: + if self.style == HighlightColorStyle.MixedHighlightColor: if self.alpha == 255: return "" % (self._standard_color_to_str(self.color), self._standard_color_to_str(self.mix_color), self.mix) return "" % (self._standard_color_to_str(self.color), self._standard_color_to_str(self.mix_color), self.mix, self.alpha) - if self.style == core.BNHighlightColorStyle.CustomHighlightColor: + if self.style == HighlightColorStyle.CustomHighlightColor: if self.alpha == 255: return "" % (self.red, self.green, self.blue) return "" % (self.red, self.green, self.blue, self.alpha) @@ -89,21 +90,21 @@ class HighlightColor(object): def _get_core_struct(self): result = core.BNHighlightColor() result.style = self.style - result.color = core.BNHighlightStandardColor.NoHighlightColor - result.mix_color = core.BNHighlightStandardColor.NoHighlightColor + result.color = HighlightStandardColor.NoHighlightColor + result.mix_color = HighlightStandardColor.NoHighlightColor result.mix = 0 result.r = 0 result.g = 0 result.b = 0 result.alpha = self.alpha - if self.style == core.BNHighlightColorStyle.StandardHighlightColor: + if self.style == HighlightColorStyle.StandardHighlightColor: result.color = self.color - elif self.style == core.BNHighlightColorStyle.MixedHighlightColor: + elif self.style == HighlightColorStyle.MixedHighlightColor: result.color = self.color result.mixColor = self.mix_color result.mix = self.mix - elif self.style == core.BNHighlightColorStyle.CustomHighlightColor: + elif self.style == HighlightColorStyle.CustomHighlightColor: result.r = self.red result.g = self.green result.b = self.blue diff --git a/python/interaction.py b/python/interaction.py index 1899b7aa..6d640d17 100644 --- a/python/interaction.py +++ b/python/interaction.py @@ -23,6 +23,7 @@ import traceback # Binary Ninja components import _binaryninjacore as core +from enums import FormInputFieldType, MessageBoxIcon, MessageBoxButtonResult import binaryview import log @@ -32,7 +33,7 @@ class LabelField(object): self.text = text def _fill_core_struct(self, value): - value.type = core.BNFormInputFieldType.LabelFormField + value.type = FormInputFieldType.LabelFormField value.prompt = self.text def _fill_core_result(self, value): @@ -44,7 +45,7 @@ class LabelField(object): class SeparatorField(object): def _fill_core_struct(self, value): - value.type = core.BNFormInputFieldType.SeparatorFormField + value.type = FormInputFieldType.SeparatorFormField def _fill_core_result(self, value): pass @@ -59,7 +60,7 @@ class TextLineField(object): self.result = None def _fill_core_struct(self, value): - value.type = core.BNFormInputFieldType.TextLineFormField + value.type = FormInputFieldType.TextLineFormField value.prompt = self.prompt def _fill_core_result(self, value): @@ -75,7 +76,7 @@ class MultilineTextField(object): self.result = None def _fill_core_struct(self, value): - value.type = core.BNFormInputFieldType.MultilineTextFormField + value.type = FormInputFieldType.MultilineTextFormField value.prompt = self.prompt def _fill_core_result(self, value): @@ -91,7 +92,7 @@ class IntegerField(object): self.result = None def _fill_core_struct(self, value): - value.type = core.BNFormInputFieldType.IntegerFormField + value.type = FormInputFieldType.IntegerFormField value.prompt = self.prompt def _fill_core_result(self, value): @@ -109,7 +110,7 @@ class AddressField(object): self.result = None def _fill_core_struct(self, value): - value.type = core.BNFormInputFieldType.AddressFormField + value.type = FormInputFieldType.AddressFormField value.prompt = self.prompt value.view = None if self.view is not None: @@ -130,7 +131,7 @@ class ChoiceField(object): self.result = None def _fill_core_struct(self, value): - value.type = core.BNFormInputFieldType.ChoiceFormField + value.type = FormInputFieldType.ChoiceFormField value.prompt = self.prompt choice_buf = (ctypes.c_char_p * len(self.choices))() for i in xrange(0, len(self.choices)): @@ -152,7 +153,7 @@ class OpenFileNameField(object): self.result = None def _fill_core_struct(self, value): - value.type = core.BNFormInputFieldType.OpenFileNameFormField + value.type = FormInputFieldType.OpenFileNameFormField value.prompt = self.prompt value.ext = self.ext @@ -171,7 +172,7 @@ class SaveFileNameField(object): self.result = None def _fill_core_struct(self, value): - value.type = core.BNFormInputFieldType.SaveFileNameFormField + value.type = FormInputFieldType.SaveFileNameFormField value.prompt = self.prompt value.ext = self.ext value.defaultName = self.default_name @@ -190,7 +191,7 @@ class DirectoryNameField(object): self.result = None def _fill_core_struct(self, value): - value.type = core.DirectoryNameField + value.type = DirectoryNameField value.prompt = self.prompt value.defaultName = self.default_name @@ -335,31 +336,31 @@ class InteractionHandler(object): try: field_objs = [] for i in xrange(0, count): - if fields[i].type == core.BNFormInputFieldType.LabelFormField: + if fields[i].type == FormInputFieldType.LabelFormField: field_objs.append(LabelField(fields[i].prompt)) - elif fields[i].type == core.BNFormInputFieldType.SeparatorFormField: + elif fields[i].type == FormInputFieldType.SeparatorFormField: field_objs.append(SeparatorField()) - elif fields[i].type == core.BNFormInputFieldType.TextLineFormField: + elif fields[i].type == FormInputFieldType.TextLineFormField: field_objs.append(TextLineField(fields[i].prompt)) - elif fields[i].type == core.BNFormInputFieldType.MultilineTextFormField: + elif fields[i].type == FormInputFieldType.MultilineTextFormField: field_objs.append(MultilineTextField(fields[i].prompt)) - elif fields[i].type == core.BNFormInputFieldType.IntegerFormField: + elif fields[i].type == FormInputFieldType.IntegerFormField: field_objs.append(IntegerField(fields[i].prompt)) - elif fields[i].type == core.BNFormInputFieldType.AddressFormField: + elif fields[i].type == FormInputFieldType.AddressFormField: view = None if fields[i].view: view = binaryview.BinaryView(handle = core.BNNewViewReference(fields[i].view)) field_objs.append(AddressField(fields[i].prompt, view, fields[i].currentAddress)) - elif fields[i].type == core.BNFormInputFieldType.ChoiceFormField: + elif fields[i].type == FormInputFieldType.ChoiceFormField: choices = [] for i in xrange(0, fields[i].count): choices.append(fields[i].choices[i]) field_objs.append(ChoiceField(fields[i].prompt, choices)) - elif fields[i].type == core.BNFormInputFieldType.OpenFileNameFormField: + elif fields[i].type == FormInputFieldType.OpenFileNameFormField: field_objs.append(OpenFileNameField(fields[i].prompt, fields[i].ext)) - elif fields[i].type == core.BNFormInputFieldType.SaveFileNameFormField: + elif fields[i].type == FormInputFieldType.SaveFileNameFormField: field_objs.append(SaveFileNameField(fields[i].prompt, fields[i].ext, fields[i].defaultName)) - elif fields[i].type == core.DirectoryNameField: + elif fields[i].type == DirectoryNameField: field_objs.append(DirectoryNameField(fields[i].prompt, fields[i].defaultName)) else: field_objs.append(LabelField(fields[i].prompt)) @@ -419,7 +420,7 @@ class InteractionHandler(object): return False def show_message_box(self, title, text, buttons, icon): - return core.BNMessageBoxButtonResult.CancelButton + return MessageBoxButtonResult.CancelButton def markdown_to_html(contents): @@ -516,5 +517,5 @@ def get_form_input(fields, title): return True -def show_message_box(title, text, buttons = core.BNMessageBoxButtonResult.OKButton, icon = core.BNMessageBoxIcon.InformationIcon): +def show_message_box(title, text, buttons = MessageBoxButtonResult.OKButton, icon = MessageBoxIcon.InformationIcon): return core.BNShowMessageBox(title, text, buttons, icon) diff --git a/python/log.py b/python/log.py index 932c739d..45adb4aa 100644 --- a/python/log.py +++ b/python/log.py @@ -57,7 +57,7 @@ def log_debug(text): :rtype: None :Example: - >>> log_to_stdout(core.BNLogLevel.DebugLog) + >>> log_to_stdout(LogLevel.DebugLog) >>> log_debug("Hotdogs!") Hotdogs! """ @@ -87,7 +87,7 @@ def log_warn(text): :rtype: None :Example: - >>> log_to_stdout(core.BNLogLevel.DebugLog) + >>> log_to_stdout(LogLevel.DebugLog) >>> log_info("Chilidogs!") Chilidogs! >>> @@ -103,7 +103,7 @@ def log_error(text): :rtype: None :Example: - >>> log_to_stdout(core.BNLogLevel.DebugLog) + >>> log_to_stdout(LogLevel.DebugLog) >>> log_error("Spanferkel!") Spanferkel! >>> @@ -119,7 +119,7 @@ def log_alert(text): :rtype: None :Example: - >>> log_to_stdout(core.BNLogLevel.DebugLog) + >>> log_to_stdout(LogLevel.DebugLog) >>> log_alert("Kielbasa!") Kielbasa! >>> @@ -136,7 +136,7 @@ def log_to_stdout(min_level): :Example: >>> log_debug("Hotdogs!") - >>> log_to_stdout(core.BNLogLevel.DebugLog) + >>> log_to_stdout(LogLevel.DebugLog) >>> log_debug("Hotdogs!") Hotdogs! >>> diff --git a/python/lowlevelil.py b/python/lowlevelil.py index 7025a7c1..4564bf13 100644 --- a/python/lowlevelil.py +++ b/python/lowlevelil.py @@ -22,6 +22,7 @@ import ctypes # Binary Ninja components import _binaryninjacore as core +from .enums import LowLevelILOperation, LowLevelILFlagCondition, InstructionTextTokenType import function import basicblock @@ -43,73 +44,73 @@ class LowLevelILInstruction(object): """ ILOperations = { - core.BNLowLevelILOperation.LLIL_NOP: [], - core.BNLowLevelILOperation.LLIL_SET_REG: [("dest", "reg"), ("src", "expr")], - core.BNLowLevelILOperation.LLIL_SET_REG_SPLIT: [("hi", "reg"), ("lo", "reg"), ("src", "expr")], - core.BNLowLevelILOperation.LLIL_SET_FLAG: [("dest", "flag"), ("src", "expr")], - core.BNLowLevelILOperation.LLIL_LOAD: [("src", "expr")], - core.BNLowLevelILOperation.LLIL_STORE: [("dest", "expr"), ("src", "expr")], - core.BNLowLevelILOperation.LLIL_PUSH: [("src", "expr")], - core.BNLowLevelILOperation.LLIL_POP: [], - core.BNLowLevelILOperation.LLIL_REG: [("src", "reg")], - core.BNLowLevelILOperation.LLIL_CONST: [("value", "int")], - core.BNLowLevelILOperation.LLIL_FLAG: [("src", "flag")], - core.BNLowLevelILOperation.LLIL_FLAG_BIT: [("src", "flag"), ("bit", "int")], - core.BNLowLevelILOperation.LLIL_ADD: [("left", "expr"), ("right", "expr")], - core.BNLowLevelILOperation.LLIL_ADC: [("left", "expr"), ("right", "expr")], - core.BNLowLevelILOperation.LLIL_SUB: [("left", "expr"), ("right", "expr")], - core.BNLowLevelILOperation.LLIL_SBB: [("left", "expr"), ("right", "expr")], - core.BNLowLevelILOperation.LLIL_AND: [("left", "expr"), ("right", "expr")], - core.BNLowLevelILOperation.LLIL_OR: [("left", "expr"), ("right", "expr")], - core.BNLowLevelILOperation.LLIL_XOR: [("left", "expr"), ("right", "expr")], - core.BNLowLevelILOperation.LLIL_LSL: [("left", "expr"), ("right", "expr")], - core.BNLowLevelILOperation.LLIL_LSR: [("left", "expr"), ("right", "expr")], - core.BNLowLevelILOperation.LLIL_ASR: [("left", "expr"), ("right", "expr")], - core.BNLowLevelILOperation.LLIL_ROL: [("left", "expr"), ("right", "expr")], - core.BNLowLevelILOperation.LLIL_RLC: [("left", "expr"), ("right", "expr")], - core.BNLowLevelILOperation.LLIL_ROR: [("left", "expr"), ("right", "expr")], - core.BNLowLevelILOperation.LLIL_RRC: [("left", "expr"), ("right", "expr")], - core.BNLowLevelILOperation.LLIL_MUL: [("left", "expr"), ("right", "expr")], - core.BNLowLevelILOperation.LLIL_MULU_DP: [("left", "expr"), ("right", "expr")], - core.BNLowLevelILOperation.LLIL_MULS_DP: [("left", "expr"), ("right", "expr")], - core.BNLowLevelILOperation.LLIL_DIVU: [("left", "expr"), ("right", "expr")], - core.BNLowLevelILOperation.LLIL_DIVU_DP: [("hi", "expr"), ("lo", "expr"), ("right", "expr")], - core.BNLowLevelILOperation.LLIL_DIVS: [("left", "expr"), ("right", "expr")], - core.BNLowLevelILOperation.LLIL_DIVS_DP: [("hi", "expr"), ("lo", "expr"), ("right", "expr")], - core.BNLowLevelILOperation.LLIL_MODU: [("left", "expr"), ("right", "expr")], - core.BNLowLevelILOperation.LLIL_MODU_DP: [("hi", "expr"), ("lo", "expr"), ("right", "expr")], - core.BNLowLevelILOperation.LLIL_MODS: [("left", "expr"), ("right", "expr")], - core.BNLowLevelILOperation.LLIL_MODS_DP: [("hi", "expr"), ("lo", "expr"), ("right", "expr")], - core.BNLowLevelILOperation.LLIL_NEG: [("src", "expr")], - core.BNLowLevelILOperation.LLIL_NOT: [("src", "expr")], - core.BNLowLevelILOperation.LLIL_SX: [("src", "expr")], - core.BNLowLevelILOperation.LLIL_ZX: [("src", "expr")], - core.BNLowLevelILOperation.LLIL_JUMP: [("dest", "expr")], - core.BNLowLevelILOperation.LLIL_JUMP_TO: [("dest", "expr"), ("targets", "int_list")], - core.BNLowLevelILOperation.LLIL_CALL: [("dest", "expr")], - core.BNLowLevelILOperation.LLIL_RET: [("dest", "expr")], - core.BNLowLevelILOperation.LLIL_NORET: [], - core.BNLowLevelILOperation.LLIL_IF: [("condition", "expr"), ("true", "int"), ("false", "int")], - core.BNLowLevelILOperation.LLIL_GOTO: [("dest", "int")], - core.BNLowLevelILOperation.LLIL_FLAG_COND: [("condition", "cond")], - core.BNLowLevelILOperation.LLIL_CMP_E: [("left", "expr"), ("right", "expr")], - core.BNLowLevelILOperation.LLIL_CMP_NE: [("left", "expr"), ("right", "expr")], - core.BNLowLevelILOperation.LLIL_CMP_SLT: [("left", "expr"), ("right", "expr")], - core.BNLowLevelILOperation.LLIL_CMP_ULT: [("left", "expr"), ("right", "expr")], - core.BNLowLevelILOperation.LLIL_CMP_SLE: [("left", "expr"), ("right", "expr")], - core.BNLowLevelILOperation.LLIL_CMP_ULE: [("left", "expr"), ("right", "expr")], - core.BNLowLevelILOperation.LLIL_CMP_SGE: [("left", "expr"), ("right", "expr")], - core.BNLowLevelILOperation.LLIL_CMP_UGE: [("left", "expr"), ("right", "expr")], - core.BNLowLevelILOperation.LLIL_CMP_SGT: [("left", "expr"), ("right", "expr")], - core.BNLowLevelILOperation.LLIL_CMP_UGT: [("left", "expr"), ("right", "expr")], - core.BNLowLevelILOperation.LLIL_TEST_BIT: [("left", "expr"), ("right", "expr")], - core.BNLowLevelILOperation.LLIL_BOOL_TO_INT: [("src", "expr")], - core.BNLowLevelILOperation.LLIL_SYSCALL: [], - core.BNLowLevelILOperation.LLIL_BP: [], - core.BNLowLevelILOperation.LLIL_TRAP: [("value", "int")], - core.BNLowLevelILOperation.LLIL_UNDEF: [], - core.BNLowLevelILOperation.LLIL_UNIMPL: [], - core.BNLowLevelILOperation.LLIL_UNIMPL_MEM: [("src", "expr")] + LowLevelILOperation.LLIL_NOP: [], + LowLevelILOperation.LLIL_SET_REG: [("dest", "reg"), ("src", "expr")], + LowLevelILOperation.LLIL_SET_REG_SPLIT: [("hi", "reg"), ("lo", "reg"), ("src", "expr")], + LowLevelILOperation.LLIL_SET_FLAG: [("dest", "flag"), ("src", "expr")], + LowLevelILOperation.LLIL_LOAD: [("src", "expr")], + LowLevelILOperation.LLIL_STORE: [("dest", "expr"), ("src", "expr")], + LowLevelILOperation.LLIL_PUSH: [("src", "expr")], + LowLevelILOperation.LLIL_POP: [], + LowLevelILOperation.LLIL_REG: [("src", "reg")], + LowLevelILOperation.LLIL_CONST: [("value", "int")], + LowLevelILOperation.LLIL_FLAG: [("src", "flag")], + LowLevelILOperation.LLIL_FLAG_BIT: [("src", "flag"), ("bit", "int")], + LowLevelILOperation.LLIL_ADD: [("left", "expr"), ("right", "expr")], + LowLevelILOperation.LLIL_ADC: [("left", "expr"), ("right", "expr")], + LowLevelILOperation.LLIL_SUB: [("left", "expr"), ("right", "expr")], + LowLevelILOperation.LLIL_SBB: [("left", "expr"), ("right", "expr")], + LowLevelILOperation.LLIL_AND: [("left", "expr"), ("right", "expr")], + LowLevelILOperation.LLIL_OR: [("left", "expr"), ("right", "expr")], + LowLevelILOperation.LLIL_XOR: [("left", "expr"), ("right", "expr")], + LowLevelILOperation.LLIL_LSL: [("left", "expr"), ("right", "expr")], + LowLevelILOperation.LLIL_LSR: [("left", "expr"), ("right", "expr")], + LowLevelILOperation.LLIL_ASR: [("left", "expr"), ("right", "expr")], + LowLevelILOperation.LLIL_ROL: [("left", "expr"), ("right", "expr")], + LowLevelILOperation.LLIL_RLC: [("left", "expr"), ("right", "expr")], + LowLevelILOperation.LLIL_ROR: [("left", "expr"), ("right", "expr")], + LowLevelILOperation.LLIL_RRC: [("left", "expr"), ("right", "expr")], + LowLevelILOperation.LLIL_MUL: [("left", "expr"), ("right", "expr")], + LowLevelILOperation.LLIL_MULU_DP: [("left", "expr"), ("right", "expr")], + LowLevelILOperation.LLIL_MULS_DP: [("left", "expr"), ("right", "expr")], + LowLevelILOperation.LLIL_DIVU: [("left", "expr"), ("right", "expr")], + LowLevelILOperation.LLIL_DIVU_DP: [("hi", "expr"), ("lo", "expr"), ("right", "expr")], + LowLevelILOperation.LLIL_DIVS: [("left", "expr"), ("right", "expr")], + LowLevelILOperation.LLIL_DIVS_DP: [("hi", "expr"), ("lo", "expr"), ("right", "expr")], + LowLevelILOperation.LLIL_MODU: [("left", "expr"), ("right", "expr")], + LowLevelILOperation.LLIL_MODU_DP: [("hi", "expr"), ("lo", "expr"), ("right", "expr")], + LowLevelILOperation.LLIL_MODS: [("left", "expr"), ("right", "expr")], + LowLevelILOperation.LLIL_MODS_DP: [("hi", "expr"), ("lo", "expr"), ("right", "expr")], + LowLevelILOperation.LLIL_NEG: [("src", "expr")], + LowLevelILOperation.LLIL_NOT: [("src", "expr")], + LowLevelILOperation.LLIL_SX: [("src", "expr")], + LowLevelILOperation.LLIL_ZX: [("src", "expr")], + LowLevelILOperation.LLIL_JUMP: [("dest", "expr")], + LowLevelILOperation.LLIL_JUMP_TO: [("dest", "expr"), ("targets", "int_list")], + LowLevelILOperation.LLIL_CALL: [("dest", "expr")], + LowLevelILOperation.LLIL_RET: [("dest", "expr")], + LowLevelILOperation.LLIL_NORET: [], + LowLevelILOperation.LLIL_IF: [("condition", "expr"), ("true", "int"), ("false", "int")], + LowLevelILOperation.LLIL_GOTO: [("dest", "int")], + LowLevelILOperation.LLIL_FLAG_COND: [("condition", "cond")], + LowLevelILOperation.LLIL_CMP_E: [("left", "expr"), ("right", "expr")], + LowLevelILOperation.LLIL_CMP_NE: [("left", "expr"), ("right", "expr")], + LowLevelILOperation.LLIL_CMP_SLT: [("left", "expr"), ("right", "expr")], + LowLevelILOperation.LLIL_CMP_ULT: [("left", "expr"), ("right", "expr")], + LowLevelILOperation.LLIL_CMP_SLE: [("left", "expr"), ("right", "expr")], + LowLevelILOperation.LLIL_CMP_ULE: [("left", "expr"), ("right", "expr")], + LowLevelILOperation.LLIL_CMP_SGE: [("left", "expr"), ("right", "expr")], + LowLevelILOperation.LLIL_CMP_UGE: [("left", "expr"), ("right", "expr")], + LowLevelILOperation.LLIL_CMP_SGT: [("left", "expr"), ("right", "expr")], + LowLevelILOperation.LLIL_CMP_UGT: [("left", "expr"), ("right", "expr")], + LowLevelILOperation.LLIL_TEST_BIT: [("left", "expr"), ("right", "expr")], + LowLevelILOperation.LLIL_BOOL_TO_INT: [("src", "expr")], + LowLevelILOperation.LLIL_SYSCALL: [], + LowLevelILOperation.LLIL_BP: [], + LowLevelILOperation.LLIL_TRAP: [("value", "int")], + LowLevelILOperation.LLIL_UNDEF: [], + LowLevelILOperation.LLIL_UNIMPL: [], + LowLevelILOperation.LLIL_UNIMPL_MEM: [("src", "expr")] } def __init__(self, func, expr_index, instr_index=None): @@ -118,7 +119,7 @@ class LowLevelILInstruction(object): self.expr_index = expr_index self.instr_index = instr_index self.operation = instr.operation - self.operation_name = core.BNLowLevelILOperation(instr.operation) + self.operation_name = LowLevelILOperation(instr.operation) self.size = instr.size self.address = instr.address self.source_operand = instr.sourceOperand @@ -144,7 +145,7 @@ class LowLevelILInstruction(object): elif operand_type == "flag": value = func.arch.get_flag_name(instr.operands[i]) elif operand_type == "cond": - value = core.BNLowLevelILFlagCondition(instr.operands[i]) + value = LowLevelILFlagCondition(instr.operands[i]) elif operand_type == "int_list": count = ctypes.c_ulonglong() operands = core.BNLowLevelILGetOperandList(func.handle, self.expr_index, i, count) @@ -182,7 +183,7 @@ class LowLevelILInstruction(object): return None result = [] for i in xrange(0, count.value): - token_type = core.BNInstructionTextTokenType(tokens[i].type) + token_type = InstructionTextTokenType(tokens[i].type) text = tokens[i].text value = tokens[i].value size = tokens[i].size @@ -329,8 +330,8 @@ class LowLevelILFunction(object): def expr(self, operation, a = 0, b = 0, c = 0, d = 0, size = 0, flags = None): if isinstance(operation, str): - operation = core.BNLowLevelILOperation[operation] - elif isinstance(operation, core.BNLowLevelILOperation): + operation = LowLevelILOperation[operation] + elif isinstance(operation, LowLevelILOperation): operation = operation.value if isinstance(flags, str): flags = self.arch.get_flag_write_type_by_name(flags) @@ -355,7 +356,7 @@ class LowLevelILFunction(object): :return: The no operation expression :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_NOP) + return self.expr(LowLevelILOperation.LLIL_NOP) def set_reg(self, size, reg, value, flags = 0): """ @@ -370,7 +371,7 @@ class LowLevelILFunction(object): """ if isinstance(reg, str): reg = self.arch.regs[reg].index - return self.expr(core.BNLowLevelILOperation.LLIL_SET_REG, reg, value.index, size = size, flags = flags) + return self.expr(LowLevelILOperation.LLIL_SET_REG, reg, value.index, size = size, flags = flags) def set_reg_split(self, size, hi, lo, value, flags = 0): """ @@ -389,7 +390,7 @@ class LowLevelILFunction(object): hi = self.arch.regs[hi].index if isinstance(lo, str): lo = self.arch.regs[lo].index - return self.expr(core.BNLowLevelILOperation.LLIL_SET_REG_SPLIT, hi, lo, value.index, size = size, flags = flags) + return self.expr(LowLevelILOperation.LLIL_SET_REG_SPLIT, hi, lo, value.index, size = size, flags = flags) def set_flag(self, flag, value): """ @@ -400,7 +401,7 @@ class LowLevelILFunction(object): :return: The expression FLAG.flag = value :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_SET_FLAG, self.arch.get_flag_by_name(flag), value.index) + return self.expr(LowLevelILOperation.LLIL_SET_FLAG, self.arch.get_flag_by_name(flag), value.index) def load(self, size, addr): """ @@ -411,7 +412,7 @@ class LowLevelILFunction(object): :return: The expression ``[addr].size`` :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_LOAD, addr.index, size=size) + return self.expr(LowLevelILOperation.LLIL_LOAD, addr.index, size=size) def store(self, size, addr, value): """ @@ -423,7 +424,7 @@ class LowLevelILFunction(object): :return: The expression ``[addr].size = value`` :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_STORE, addr.index, value.index, size=size) + return self.expr(LowLevelILOperation.LLIL_STORE, addr.index, value.index, size=size) def push(self, size, value): """ @@ -434,7 +435,7 @@ class LowLevelILFunction(object): :return: The expression push(value) :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_PUSH, value.index, size=size) + return self.expr(LowLevelILOperation.LLIL_PUSH, value.index, size=size) def pop(self, size): """ @@ -444,7 +445,7 @@ class LowLevelILFunction(object): :return: The expression ``pop`` :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_POP, size=size) + return self.expr(LowLevelILOperation.LLIL_POP, size=size) def reg(self, size, reg): """ @@ -457,7 +458,7 @@ class LowLevelILFunction(object): """ if isinstance(reg, str): reg = self.arch.regs[reg].index - return self.expr(core.BNLowLevelILOperation.LLIL_REG, reg, size=size) + return self.expr(LowLevelILOperation.LLIL_REG, reg, size=size) def const(self, size, value): """ @@ -468,7 +469,7 @@ class LowLevelILFunction(object): :return: A constant expression of given value and size :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_CONST, value, size=size) + return self.expr(LowLevelILOperation.LLIL_CONST, value, size=size) def flag(self, reg): """ @@ -478,7 +479,7 @@ class LowLevelILFunction(object): :return: A flag expression of given flag name :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_FLAG, self.arch.get_flag_by_name(reg)) + return self.expr(LowLevelILOperation.LLIL_FLAG, self.arch.get_flag_by_name(reg)) def flag_bit(self, size, reg, bit): """ @@ -490,7 +491,7 @@ class LowLevelILFunction(object): :return: A constant expression of given value and size ``FLAG.reg = bit`` :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_FLAG_BIT, self.arch.get_flag_by_name(reg), bit, size=size) + return self.expr(LowLevelILOperation.LLIL_FLAG_BIT, self.arch.get_flag_by_name(reg), bit, size=size) def add(self, size, a, b, flags=None): """ @@ -504,7 +505,7 @@ class LowLevelILFunction(object): :return: The expression ``add.{}(a, b)`` :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_ADD, a.index, b.index, size=size, flags=flags) + return self.expr(LowLevelILOperation.LLIL_ADD, a.index, b.index, size=size, flags=flags) def add_carry(self, size, a, b, flags=None): """ @@ -518,7 +519,7 @@ class LowLevelILFunction(object): :return: The expression ``adc.{}(a, b)`` :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_ADC, a.index, b.index, size=size, flags=flags) + return self.expr(LowLevelILOperation.LLIL_ADC, a.index, b.index, size=size, flags=flags) def sub(self, size, a, b, flags=None): """ @@ -532,7 +533,7 @@ class LowLevelILFunction(object): :return: The expression ``sub.{}(a, b)`` :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_SUB, a.index, b.index, size=size, flags=flags) + return self.expr(LowLevelILOperation.LLIL_SUB, a.index, b.index, size=size, flags=flags) def sub_borrow(self, size, a, b, flags=None): """ @@ -546,7 +547,7 @@ class LowLevelILFunction(object): :return: The expression ``sbc.{}(a, b)`` :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_SBB, a.index, b.index, size=size, flags=flags) + return self.expr(LowLevelILOperation.LLIL_SBB, a.index, b.index, size=size, flags=flags) def and_expr(self, size, a, b, flags=None): """ @@ -560,7 +561,7 @@ class LowLevelILFunction(object): :return: The expression ``and.{}(a, b)`` :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_AND, a.index, b.index, size=size, flags=flags) + return self.expr(LowLevelILOperation.LLIL_AND, a.index, b.index, size=size, flags=flags) def or_expr(self, size, a, b, flags=None): """ @@ -574,7 +575,7 @@ class LowLevelILFunction(object): :return: The expression ``or.{}(a, b)`` :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_OR, a.index, b.index, size=size, flags=flags) + return self.expr(LowLevelILOperation.LLIL_OR, a.index, b.index, size=size, flags=flags) def xor_expr(self, size, a, b, flags=None): """ @@ -588,7 +589,7 @@ class LowLevelILFunction(object): :return: The expression ``xor.{}(a, b)`` :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_XOR, a.index, b.index, size=size, flags=flags) + return self.expr(LowLevelILOperation.LLIL_XOR, a.index, b.index, size=size, flags=flags) def shift_left(self, size, a, b, flags=None): """ @@ -602,7 +603,7 @@ class LowLevelILFunction(object): :return: The expression ``lsl.{}(a, b)`` :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_LSL, a.index, b.index, size=size, flags=flags) + return self.expr(LowLevelILOperation.LLIL_LSL, a.index, b.index, size=size, flags=flags) def logical_shift_right(self, size, a, b, flags=None): """ @@ -616,7 +617,7 @@ class LowLevelILFunction(object): :return: The expression ``lsr.{}(a, b)`` :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_LSR, a.index, b.index, size=size, flags=flags) + return self.expr(LowLevelILOperation.LLIL_LSR, a.index, b.index, size=size, flags=flags) def arith_shift_right(self, size, a, b, flags=None): """ @@ -630,7 +631,7 @@ class LowLevelILFunction(object): :return: The expression ``asr.{}(a, b)`` :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_ASR, a.index, b.index, size=size, flags=flags) + return self.expr(LowLevelILOperation.LLIL_ASR, a.index, b.index, size=size, flags=flags) def rotate_left(self, size, a, b, flags=None): """ @@ -644,7 +645,7 @@ class LowLevelILFunction(object): :return: The expression ``rol.{}(a, b)`` :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_ROL, a.index, b.index, size=size, flags=flags) + return self.expr(LowLevelILOperation.LLIL_ROL, a.index, b.index, size=size, flags=flags) def rotate_left_carry(self, size, a, b, flags=None): """ @@ -658,7 +659,7 @@ class LowLevelILFunction(object): :return: The expression ``rcl.{}(a, b)`` :rtype: LowLevelILExpr """ - return self.expr(core.LLIL_RLC, a.index, b.index, size=size, flags=flags) + return self.expr(LowLevelILOperation.LLIL_RLC, a.index, b.index, size=size, flags=flags) def rotate_right(self, size, a, b, flags=None): """ @@ -672,7 +673,7 @@ class LowLevelILFunction(object): :return: The expression ``ror.{}(a, b)`` :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_ROR, a.index, b.index, size=size, flags=flags) + return self.expr(LowLevelILOperation.LLIL_ROR, a.index, b.index, size=size, flags=flags) def rotate_right_carry(self, size, a, b, flags=None): """ @@ -686,7 +687,7 @@ class LowLevelILFunction(object): :return: The expression ``rcr.{}(a, b)`` :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_RRC, a.index, b.index, size=size, flags=flags) + return self.expr(LowLevelILOperation.LLIL_RRC, a.index, b.index, size=size, flags=flags) def mult(self, size, a, b, flags=None): """ @@ -700,7 +701,7 @@ class LowLevelILFunction(object): :return: The expression ``sbc.{}(a, b)`` :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_MUL, a.index, b.index, size=size, flags=flags) + return self.expr(LowLevelILOperation.LLIL_MUL, a.index, b.index, size=size, flags=flags) def mult_double_prec_signed(self, size, a, b, flags=None): """ @@ -714,7 +715,7 @@ class LowLevelILFunction(object): :return: The expression ``muls.dp.{}(a, b)`` :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_MULS_DP, a.index, b.index, size=size, flags=flags) + return self.expr(LowLevelILOperation.LLIL_MULS_DP, a.index, b.index, size=size, flags=flags) def mult_double_prec_unsigned(self, size, a, b, flags=None): """ @@ -728,7 +729,7 @@ class LowLevelILFunction(object): :return: The expression ``muls.dp.{}(a, b)`` :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_MULU_DP, a.index, b.index, size=size, flags=flags) + return self.expr(LowLevelILOperation.LLIL_MULU_DP, a.index, b.index, size=size, flags=flags) def div_signed(self, size, a, b, flags=None): """ @@ -742,7 +743,7 @@ class LowLevelILFunction(object): :return: The expression ``divs.{}(a, b)`` :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_DIVS, a.index, b.index, size=size, flags=flags) + return self.expr(LowLevelILOperation.LLIL_DIVS, a.index, b.index, size=size, flags=flags) def div_double_prec_signed(self, size, hi, lo, b, flags=None): """ @@ -758,7 +759,7 @@ class LowLevelILFunction(object): :return: The expression ``divs.dp.{}(hi:lo, b)`` :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_DIVS_DP, hi.index, lo.index, b.index, size=size, flags=flags) + return self.expr(LowLevelILOperation.LLIL_DIVS_DP, hi.index, lo.index, b.index, size=size, flags=flags) def div_unsigned(self, size, a, b, flags=None): """ @@ -772,7 +773,7 @@ class LowLevelILFunction(object): :return: The expression ``divs.{}(a, b)`` :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_DIVS, a.index, b.index, size=size, flags=flags) + return self.expr(LowLevelILOperation.LLIL_DIVS, a.index, b.index, size=size, flags=flags) def div_double_prec_unsigned(self, size, hi, lo, b, flags=None): """ @@ -788,7 +789,7 @@ class LowLevelILFunction(object): :return: The expression ``divs.dp.{}(hi:lo, b)`` :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_DIVS_DP, hi.index, lo.index, b.index, size=size, flags=flags) + return self.expr(LowLevelILOperation.LLIL_DIVS_DP, hi.index, lo.index, b.index, size=size, flags=flags) def mod_signed(self, size, a, b, flags=None): """ @@ -802,7 +803,7 @@ class LowLevelILFunction(object): :return: The expression ``mods.{}(a, b)`` :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_MODS, a.index, b.index, size=size, flags=flags) + return self.expr(LowLevelILOperation.LLIL_MODS, a.index, b.index, size=size, flags=flags) def mod_double_prec_signed(self, size, hi, lo, b, flags=None): """ @@ -818,7 +819,7 @@ class LowLevelILFunction(object): :return: The expression ``mods.dp.{}(hi:lo, b)`` :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_MODS_DP, hi.index, lo.index, b.index, size=size, flags=flags) + return self.expr(LowLevelILOperation.LLIL_MODS_DP, hi.index, lo.index, b.index, size=size, flags=flags) def mod_unsigned(self, size, a, b, flags=None): """ @@ -832,7 +833,7 @@ class LowLevelILFunction(object): :return: The expression ``modu.{}(a, b)`` :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_MODS, a.index, b.index, size=size, flags=flags) + return self.expr(LowLevelILOperation.LLIL_MODS, a.index, b.index, size=size, flags=flags) def mod_double_prec_unsigned(self, size, hi, lo, b, flags=None): """ @@ -848,7 +849,7 @@ class LowLevelILFunction(object): :return: The expression ``modu.dp.{}(hi:lo, b)`` :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_MODS_DP, hi.index, lo.index, b.index, size=size, flags=flags) + return self.expr(LowLevelILOperation.LLIL_MODS_DP, hi.index, lo.index, b.index, size=size, flags=flags) def neg_expr(self, size, value, flags=None): """ @@ -860,7 +861,7 @@ class LowLevelILFunction(object): :return: The expression ``neg.{}(value)`` :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_NEG, value.index, size=size, flags=flags) + return self.expr(LowLevelILOperation.LLIL_NEG, value.index, size=size, flags=flags) def not_expr(self, size, value, flags=None): """ @@ -872,7 +873,7 @@ class LowLevelILFunction(object): :return: The expression ``not.{}(value)`` :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_NOT, value.index, size=size, flags=flags) + return self.expr(LowLevelILOperation.LLIL_NOT, value.index, size=size, flags=flags) def sign_extend(self, size, value, flags=None): """ @@ -884,7 +885,7 @@ class LowLevelILFunction(object): :return: The expression ``sx.(value)`` :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_SX, value.index, size=size, flags=flags) + return self.expr(LowLevelILOperation.LLIL_SX, value.index, size=size, flags=flags) def zero_extend(self, size, value): """ @@ -895,7 +896,7 @@ class LowLevelILFunction(object): :return: The expression ``sx.(value)`` :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_ZX, value.index, size=size) + return self.expr(LowLevelILOperation.LLIL_ZX, value.index, size=size) def jump(self, dest): """ @@ -905,7 +906,7 @@ class LowLevelILFunction(object): :return: The expression ``jump(dest)`` :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_JUMP, dest.index) + return self.expr(LowLevelILOperation.LLIL_JUMP, dest.index) def call(self, dest): """ @@ -916,7 +917,7 @@ class LowLevelILFunction(object): :return: The expression ``call(dest)`` :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_CALL, dest.index) + return self.expr(LowLevelILOperation.LLIL_CALL, dest.index) def ret(self, dest): """ @@ -927,7 +928,7 @@ class LowLevelILFunction(object): :return: The expression ``jump(dest)`` :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_RET, dest.index) + return self.expr(LowLevelILOperation.LLIL_RET, dest.index) def no_ret(self): """ @@ -936,7 +937,7 @@ class LowLevelILFunction(object): :return: The expression ``noreturn`` :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_NORET) + return self.expr(LowLevelILOperation.LLIL_NORET) def flag_condition(self, cond): """ @@ -947,10 +948,10 @@ class LowLevelILFunction(object): :rtype: LowLevelILExpr """ if isinstance(cond, str): - cond = core.BNLowLevelILFlagCondition[cond] - elif isinstance(cond, core.BNLowLevelILFlagCondition): + cond = LowLevelILFlagCondition[cond] + elif isinstance(cond, LowLevelILFlagCondition): cond = cond.value - return self.expr(core.BNLowLevelILOperation.LLIL_FLAG_COND, cond) + return self.expr(LowLevelILOperation.LLIL_FLAG_COND, cond) def compare_equal(self, size, a, b): """ @@ -963,7 +964,7 @@ class LowLevelILFunction(object): :return: a comparison expression. :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_CMP_E, a.index, b.index, size = size) + return self.expr(LowLevelILOperation.LLIL_CMP_E, a.index, b.index, size = size) def compare_not_equal(self, size, a, b): """ @@ -976,7 +977,7 @@ class LowLevelILFunction(object): :return: a comparison expression. :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_CMP_NE, a.index, b.index, size = size) + return self.expr(LowLevelILOperation.LLIL_CMP_NE, a.index, b.index, size = size) def compare_signed_less_than(self, size, a, b): """ @@ -989,7 +990,7 @@ class LowLevelILFunction(object): :return: a comparison expression. :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_CMP_SLT, a.index, b.index, size = size) + return self.expr(LowLevelILOperation.LLIL_CMP_SLT, a.index, b.index, size = size) def compare_unsigned_less_than(self, size, a, b): """ @@ -1002,7 +1003,7 @@ class LowLevelILFunction(object): :return: a comparison expression. :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_CMP_ULT, a.index, b.index, size = size) + return self.expr(LowLevelILOperation.LLIL_CMP_ULT, a.index, b.index, size = size) def compare_signed_less_equal(self, size, a, b): """ @@ -1015,7 +1016,7 @@ class LowLevelILFunction(object): :return: a comparison expression. :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_CMP_SLE, a.index, b.index, size = size) + return self.expr(LowLevelILOperation.LLIL_CMP_SLE, a.index, b.index, size = size) def compare_unsigned_less_equal(self, size, a, b): """ @@ -1028,7 +1029,7 @@ class LowLevelILFunction(object): :return: a comparison expression. :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_CMP_ULE, a.index, b.index, size = size) + return self.expr(LowLevelILOperation.LLIL_CMP_ULE, a.index, b.index, size = size) def compare_signed_greater_equal(self, size, a, b): """ @@ -1041,7 +1042,7 @@ class LowLevelILFunction(object): :return: a comparison expression. :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_CMP_SGE, a.index, b.index, size = size) + return self.expr(LowLevelILOperation.LLIL_CMP_SGE, a.index, b.index, size = size) def compare_unsigned_greater_equal(self, size, a, b): """ @@ -1054,7 +1055,7 @@ class LowLevelILFunction(object): :return: a comparison expression. :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_CMP_UGE, a.index, b.index, size = size) + return self.expr(LowLevelILOperation.LLIL_CMP_UGE, a.index, b.index, size = size) def compare_signed_greater_than(self, size, a, b): """ @@ -1067,7 +1068,7 @@ class LowLevelILFunction(object): :return: a comparison expression. :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_CMP_SGT, a.index, b.index, size = size) + return self.expr(LowLevelILOperation.LLIL_CMP_SGT, a.index, b.index, size = size) def compare_unsigned_greater_than(self, size, a, b): """ @@ -1080,10 +1081,10 @@ class LowLevelILFunction(object): :return: a comparison expression. :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_CMP_UGT, a.index, b.index, size = size) + return self.expr(LowLevelILOperation.LLIL_CMP_UGT, a.index, b.index, size = size) def test_bit(self, size, a, b): - return self.expr(core.BNLowLevelILOperation.LLIL_TEST_BIT, a.index, b.index, size = size) + return self.expr(LowLevelILOperation.LLIL_TEST_BIT, a.index, b.index, size = size) def system_call(self): """ @@ -1092,7 +1093,7 @@ class LowLevelILFunction(object): :return: a system call expression. :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_SYSCALL) + return self.expr(LowLevelILOperation.LLIL_SYSCALL) def breakpoint(self): """ @@ -1101,7 +1102,7 @@ class LowLevelILFunction(object): :return: a breakpoint expression. :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_BP) + return self.expr(LowLevelILOperation.LLIL_BP) def trap(self, value): """ @@ -1111,7 +1112,7 @@ class LowLevelILFunction(object): :return: a trap expression. :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_TRAP, value) + return self.expr(LowLevelILOperation.LLIL_TRAP, value) def undefined(self): """ @@ -1121,7 +1122,7 @@ class LowLevelILFunction(object): :return: the unimplemented expression. :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_UNDEF) + return self.expr(LowLevelILOperation.LLIL_UNDEF) def unimplemented(self): """ @@ -1131,7 +1132,7 @@ class LowLevelILFunction(object): :return: the unimplemented expression. :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_UNIMPL) + return self.expr(LowLevelILOperation.LLIL_UNIMPL) def unimplemented_memory_ref(self, size, addr): """ @@ -1142,7 +1143,7 @@ class LowLevelILFunction(object): :return: the unimplemented memory reference expression. :rtype: LowLevelILExpr """ - return self.expr(core.BNLowLevelILOperation.LLIL_UNIMPL_MEM, addr.index, size = size) + return self.expr(LowLevelILOperation.LLIL_UNIMPL_MEM, addr.index, size = size) def goto(self, label): """ diff --git a/python/platform.py b/python/platform.py index 6c3eefea..04dce587 100644 --- a/python/platform.py +++ b/python/platform.py @@ -20,10 +20,12 @@ import ctypes -#Binary Ninja components +# Binary Ninja components import _binaryninjacore as core import startup import architecture +import callingconvention + class _PlatformMetaClass(type): @property @@ -60,15 +62,15 @@ class _PlatformMetaClass(type): def __setattr__(self, name, value): try: - type.__setattr__(self,name,value) + type.__setattr__(self, name, value) except AttributeError: - raise AttributeError, "attribute '%s' is read only" % name + raise AttributeError("attribute '%s' is read only" % name) def __getitem__(cls, value): startup._init_plugins() platform = core.BNGetPlatformByName(str(value)) if platform is None: - raise KeyError, "'%s' is not a valid platform" % str(value) + raise KeyError("'%s' is not a valid platform" % str(value)) return Platform(None, platform) def get_list(cls, os = None, arch = None): @@ -86,6 +88,7 @@ class _PlatformMetaClass(type): core.BNFreePlatformList(platforms, count.value) return result + class Platform(object): """ ``class Platform`` contains all information releated to the execution environment of the binary, mainly the @@ -118,7 +121,7 @@ class Platform(object): result = core.BNGetPlatformDefaultCallingConvention(self.handle) if result is None: return None - return CallingConvention(None, result) + return callingconvention.CallingConvention(None, result) @default_calling_convention.setter def default_calling_convention(self, value): @@ -136,7 +139,7 @@ class Platform(object): result = core.BNGetPlatformCdeclCallingConvention(self.handle) if result is None: return None - return CallingConvention(None, result) + return callingconvention.CallingConvention(None, result) @cdecl_calling_convention.setter def cdecl_calling_convention(self, value): @@ -154,7 +157,7 @@ class Platform(object): result = core.BNGetPlatformStdcallCallingConvention(self.handle) if result is None: return None - return CallingConvention(None, result) + return callingconvention.CallingConvention(None, result) @stdcall_calling_convention.setter def stdcall_calling_convention(self, value): @@ -172,7 +175,7 @@ class Platform(object): result = core.BNGetPlatformFastcallCallingConvention(self.handle) if result is None: return None - return CallingConvention(None, result) + return callingconvention.CallingConvention(None, result) @fastcall_calling_convention.setter def fastcall_calling_convention(self, value): @@ -190,7 +193,7 @@ class Platform(object): result = core.BNGetPlatformSystemCallConvention(self.handle) if result is None: return None - return CallingConvention(None, result) + return callingconvention.CallingConvention(None, result) @system_call_convention.setter def system_call_convention(self, value): @@ -208,15 +211,15 @@ class Platform(object): cc = core.BNGetPlatformCallingConventions(self.handle, count) result = [] for i in xrange(0, count.value): - result.append(CallingConvention(None, core.BNNewCallingConventionReference(cc[i]))) + result.append(callingconvention.CallingConvention(None, core.BNNewCallingConventionReference(cc[i]))) core.BNFreeCallingConventionList(cc, count.value) return result def __setattr__(self, name, value): try: - object.__setattr__(self,name,value) + object.__setattr__(self, name, value) except AttributeError: - raise AttributeError, "attribute '%s' is read only" % name + raise AttributeError("attribute '%s' is read only" % name) def __repr__(self): return "" % self.name @@ -250,3 +253,9 @@ class Platform(object): def add_related_platform(self, arch, platform): core.BNAddRelatedPlatform(self.handle, arch.handle, platform.handle) + + def get_associated_platform_by_address(self, addr): + new_addr = ctypes.c_ulonglong() + new_addr.value = addr + result = core.BNGetAssociatedPlatformByAddress(self.handle, new_addr) + return Platform(None, handle = result), new_addr.value diff --git a/python/plugin.py b/python/plugin.py index b6faef7f..9a4da487 100644 --- a/python/plugin.py +++ b/python/plugin.py @@ -24,6 +24,7 @@ import threading # Binary Ninja components import _binaryninjacore as core +from enums import LowLevelILOperation import startup import filemetadata import binaryview @@ -77,7 +78,7 @@ class PluginCommand(object): ctypes.memmove(ctypes.byref(self.command), ctypes.byref(cmd), ctypes.sizeof(core.BNPluginCommand)) self.name = str(cmd.name) self.description = str(cmd.description) - self.type = core.BNPluginCommandType(cmd.type) + self.type = LowLevelILOperation(cmd.type) @classmethod def _default_action(cls, view, action): @@ -209,21 +210,21 @@ class PluginCommand(object): def is_valid(self, context): if context.view is None: return False - if self.command.type == core.BNPluginCommandType.DefaultPluginCommand: + if self.command.type == LowLevelILOperation.DefaultPluginCommand: if not self.command.defaultIsValid: return True return self.command.defaultIsValid(self.command.context, context.view.handle) - elif self.command.type == core.BNPluginCommandType.AddressPluginCommand: + elif self.command.type == LowLevelILOperation.AddressPluginCommand: if not self.command.addressIsValid: return True return self.command.addressIsValid(self.command.context, context.view.handle, context.address) - elif self.command.type == core.BNPluginCommandType.RangePluginCommand: + elif self.command.type == LowLevelILOperation.RangePluginCommand: if context.length == 0: return False if not self.command.rangeIsValid: return True return self.command.rangeIsValid(self.command.context, context.view.handle, context.address, context.length) - elif self.command.type == core.BNPluginCommandType.FunctionPluginCommand: + elif self.command.type == LowLevelILOperation.FunctionPluginCommand: if context.function is None: return False if not self.command.functionIsValid: @@ -234,13 +235,13 @@ class PluginCommand(object): def execute(self, context): if not self.is_valid(context): return - if self.command.type == core.BNPluginCommandType.DefaultPluginCommand: + if self.command.type == LowLevelILOperation.DefaultPluginCommand: self.command.defaultCommand(self.command.context, context.view.handle) - elif self.command.type == core.BNPluginCommandType.AddressPluginCommand: + elif self.command.type == LowLevelILOperation.AddressPluginCommand: self.command.addressCommand(self.command.context, context.view.handle, context.address) - elif self.command.type == core.BNPluginCommandType.RangePluginCommand: + elif self.command.type == LowLevelILOperation.RangePluginCommand: self.command.rangeCommand(self.command.context, context.view.handle, context.address, context.length) - elif self.command.type == core.BNPluginCommandType.FunctionPluginCommand: + elif self.command.type == LowLevelILOperation.FunctionPluginCommand: self.command.functionCommand(self.command.context, context.view.handle, context.function.handle) def __repr__(self): diff --git a/python/scriptingprovider.py b/python/scriptingprovider.py index 079b47cd..71402b1b 100644 --- a/python/scriptingprovider.py +++ b/python/scriptingprovider.py @@ -28,6 +28,7 @@ import sys # Binary Ninja Components import _binaryninjacore as core +from enums import ScriptingProviderExecuteResult, ScriptingProviderInputReadyState import binaryview import function import basicblock @@ -131,7 +132,7 @@ class ScriptingInstance(object): return self.perform_execute_script_input(text) except: log.log_error(traceback.format_exc()) - return core.BNScriptingProviderExecuteResult.InvalidScriptInput + return ScriptingProviderExecuteResult.InvalidScriptInput def _set_current_binary_view(self, ctxt, view): try: @@ -186,7 +187,7 @@ class ScriptingInstance(object): @abc.abstractmethod def perform_execute_script_input(self, text): - return core.BNScriptingProviderExecuteResult.InvalidScriptInput + return ScriptingProviderExecuteResult.InvalidScriptInput @abc.abstractmethod def perform_set_current_binary_view(self, view): @@ -506,7 +507,7 @@ class PythonScriptingInstance(ScriptingInstance): result = self.input self.input = "" return result - self.instance.input_ready_state = core.BNScriptingProviderInputReadyState.ReadyForScriptProgramInput + self.instance.input_ready_state = ScriptingProviderInputReadyState.ReadyForScriptProgramInput self.event.wait() self.event.clear() return "" @@ -518,7 +519,7 @@ class PythonScriptingInstance(ScriptingInstance): if self.exit: break if self.code is not None: - self.instance.input_ready_state = core.BNScriptingProviderInputReadyState.NotReadyForInput + self.instance.input_ready_state = ScriptingProviderInputReadyState.NotReadyForInput code = self.code self.code = None @@ -551,7 +552,7 @@ class PythonScriptingInstance(ScriptingInstance): traceback.print_exc() finally: PythonScriptingInstance._interpreter.value = None - self.instance.input_ready_state = core.BNScriptingProviderInputReadyState.ReadyForScriptExecution + self.instance.input_ready_state = ScriptingProviderInputReadyState.ReadyForScriptExecution def get_selected_data(self): if self.active_view is None: @@ -575,7 +576,7 @@ class PythonScriptingInstance(ScriptingInstance): self.interpreter = PythonScriptingInstance.InterpreterThread(self) self.interpreter.start() self.queued_input = "" - self.input_ready_state = core.BNScriptingProviderInputReadyState.ReadyForScriptExecution + self.input_ready_state = ScriptingProviderInputReadyState.ReadyForScriptExecution @abc.abstractmethod def perform_destroy_instance(self): @@ -583,15 +584,15 @@ class PythonScriptingInstance(ScriptingInstance): @abc.abstractmethod def perform_execute_script_input(self, text): - if self.input_ready_state == core.BNScriptingProviderInputReadyState.NotReadyForInput: - return core.BNScriptingProviderExecuteResult.InvalidScriptInput + if self.input_ready_state == ScriptingProviderInputReadyState.NotReadyForInput: + return ScriptingProviderExecuteResult.InvalidScriptInput - if self.input_ready_state == core.BNScriptingProviderInputReadyState.ReadyForScriptProgramInput: + if self.input_ready_state == ScriptingProviderInputReadyState.ReadyForScriptProgramInput: if len(text) == 0: - return core.BNScriptingProviderExecuteResult.SuccessfulScriptExecution - self.input_ready_state = core.BNScriptingProviderInputReadyState.NotReadyForInput + return ScriptingProviderExecuteResult.SuccessfulScriptExecution + self.input_ready_state = ScriptingProviderInputReadyState.NotReadyForInput self.interpreter.add_input(text) - return core.BNScriptingProviderExecuteResult.SuccessfulScriptExecution + return ScriptingProviderExecuteResult.SuccessfulScriptExecution try: result = code.compile_command(text) @@ -600,11 +601,11 @@ class PythonScriptingInstance(ScriptingInstance): if result is None: # Command is not complete, ask for more input - return core.BNScriptingProviderExecuteResult.IncompleteScriptInput + return ScriptingProviderExecuteResult.IncompleteScriptInput - self.input_ready_state = core.BNScriptingProviderInputReadyState.NotReadyForInput + self.input_ready_state = ScriptingProviderInputReadyState.NotReadyForInput self.interpreter.execute(text) - return core.BNScriptingProviderExecuteResult.SuccessfulScriptExecution + return ScriptingProviderExecuteResult.SuccessfulScriptExecution @abc.abstractmethod def perform_set_current_binary_view(self, view): @@ -635,6 +636,10 @@ class PythonScriptingProvider(ScriptingProvider): PythonScriptingProvider().register() # Wrap stdin/stdout/stderr for Python scripting provider implementation +original_stdin = sys.stdin +original_stdout = sys.stdout +original_stderr = sys.stderr + sys.stdin = _PythonScriptingInstanceInput(sys.stdin) sys.stdout = _PythonScriptingInstanceOutput(sys.stdout, False) sys.stderr = _PythonScriptingInstanceOutput(sys.stderr, True) diff --git a/python/startup.py b/python/startup.py index c9d6792e..809f185b 100644 --- a/python/startup.py +++ b/python/startup.py @@ -32,7 +32,3 @@ def _init_plugins(): core.BNInitUserPlugins() if not core.BNIsLicenseValidated(): raise RuntimeError("License is not valid. Please supply a valid license.") - - -def shutdown(): - core.BNShutdown() diff --git a/python/transform.py b/python/transform.py index 0bbffc8f..0c003738 100644 --- a/python/transform.py +++ b/python/transform.py @@ -24,6 +24,7 @@ import abc # Binary Ninja components import _binaryninjacore as core +from enums import TransformType import startup import log import databuffer @@ -109,14 +110,14 @@ class Transform(object): self._pending_param_lists = {} self.type = self.__class__.transform_type if not isinstance(self.type, str): - self.type = core.BNTransformType(self.type) + self.type = TransformType(self.type) self.name = self.__class__.name self.long_name = self.__class__.long_name self.group = self.__class__.group self.parameters = self.__class__.parameters else: self.handle = handle - self.type = core.BNTransformType(core.BNGetTransformType(self.handle)) + self.type = TransformType(core.BNGetTransformType(self.handle)) self.name = core.BNGetTransformName(self.handle) self.long_name = core.BNGetTransformLongName(self.handle) self.group = core.BNGetTransformGroup(self.handle) @@ -191,7 +192,7 @@ class Transform(object): @abc.abstractmethod def perform_decode(self, data, params): - if self.type == core.BNTransformType.InvertingTransform: + if self.type == TransformType.InvertingTransform: return self.perform_encode(data, params) return None diff --git a/python/types.py b/python/types.py new file mode 100644 index 00000000..8582e4e0 --- /dev/null +++ b/python/types.py @@ -0,0 +1,506 @@ +# Copyright (c) 2015-2016 Vector 35 LLC +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to +# deal in the Software without restriction, including without limitation the +# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +# sell copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +# IN THE SOFTWARE. + +import ctypes + +# Binary Ninja components +import _binaryninjacore as core +from enums import SymbolType, TypeClass +import callingconvention +import demangle + + +class Symbol(object): + """ + Symbols are defined as one of the following types: + + =========================== ============================================================== + SymbolType Description + =========================== ============================================================== + FunctionSymbol Symbol for Function that exists in the current binary + ImportAddressSymbol Symbol defined in the Import Address Table + ImportedFunctionSymbol Symbol for Function that is not defined in the current binary + DataSymbol Symbol for Data in the current binary + ImportedDataSymbol Symbol for Data that is not defined in the current binary + =========================== ============================================================== + """ + def __init__(self, sym_type, addr, short_name, full_name = None, raw_name = None, handle = None): + if handle is not None: + self.handle = core.handle_of_type(handle, core.BNSymbol) + else: + if isinstance(sym_type, str): + sym_type = SymbolType[sym_type] + if full_name is None: + full_name = short_name + if raw_name is None: + raw_name = full_name + self.handle = core.BNCreateSymbol(sym_type, short_name, full_name, raw_name, addr) + + def __del__(self): + core.BNFreeSymbol(self.handle) + + @property + def type(self): + """Symbol type (read-only)""" + return SymbolType(core.BNGetSymbolType(self.handle)) + + @property + def name(self): + """Symbol name (read-only)""" + return core.BNGetSymbolRawName(self.handle) + + @property + def short_name(self): + """Symbol short name (read-only)""" + return core.BNGetSymbolShortName(self.handle) + + @property + def full_name(self): + """Symbol full name (read-only)""" + return core.BNGetSymbolFullName(self.handle) + + @property + def raw_name(self): + """Symbol raw name (read-only)""" + return core.BNGetSymbolRawName(self.handle) + + @property + def address(self): + """Symbol address (read-only)""" + return core.BNGetSymbolAddress(self.handle) + + @property + def auto(self): + return core.BNIsSymbolAutoDefined(self.handle) + + @auto.setter + def auto(self, value): + core.BNSetSymbolAutoDefined(self.handle, value) + + def __repr__(self): + return "<%s: \"%s\" @ %#x>" % (self.type, self.full_name, self.address) + + def __setattr__(self, name, value): + try: + object.__setattr__(self, name, value) + except AttributeError: + raise AttributeError("attribute '%s' is read only" % name) + + +class Type(object): + def __init__(self, handle): + self.handle = handle + + def __del__(self): + core.BNFreeType(self.handle) + + @property + def type_class(self): + """Type class (read-only)""" + return TypeClass(core.BNGetTypeClass(self.handle)) + + @property + def width(self): + """Type width (read-only)""" + return core.BNGetTypeWidth(self.handle) + + @property + def alignment(self): + """Type alignment (read-only)""" + return core.BNGetTypeAlignment(self.handle) + + @property + def signed(self): + """Wether type is signed (read-only)""" + return core.BNIsTypeSigned(self.handle) + + @property + def const(self): + """Whether type is const (read-only)""" + return core.BNIsTypeConst(self.handle) + + @property + def modified(self): + """Whether type is modified (read-only)""" + return core.BNIsTypeFloatingPoint(self.handle) + + @property + def target(self): + """Target (read-only)""" + result = core.BNGetChildType(self.handle) + if result is None: + return None + return Type(result) + + @property + def element_type(self): + """Target (read-only)""" + result = core.BNGetChildType(self.handle) + if result is None: + return None + return Type(result) + + @property + def return_value(self): + """Return value (read-only)""" + result = core.BNGetChildType(self.handle) + if result is None: + return None + return Type(result) + + @property + def calling_convention(self): + """Calling convention (read-only)""" + result = core.BNGetTypeCallingConvention(self.handle) + if result is None: + return None + return callingconvention.CallingConvention(None, result) + + @property + def parameters(self): + """Type parameters list (read-only)""" + count = ctypes.c_ulonglong() + params = core.BNGetTypeParameters(self.handle, count) + result = [] + for i in xrange(0, count.value): + result.append((Type(core.BNNewTypeReference(params[i].type)), params[i].name)) + core.BNFreeTypeParameterList(params, count.value) + return result + + @property + def has_variable_arguments(self): + """Whether type has variable arguments (read-only)""" + return core.BNTypeHasVariableArguments(self.handle) + + @property + def can_return(self): + """Whether type can return (read-only)""" + return core.BNFunctionTypeCanReturn(self.handle) + + @property + def structure(self): + """Structure of the type (read-only)""" + result = core.BNGetTypeStructure(self.handle) + if result is None: + return None + return Structure(result) + + @property + def enumeration(self): + """Type enumeration (read-only)""" + result = core.BNGetTypeEnumeration(self.handle) + if result is None: + return None + return Enumeration(result) + + @property + def count(self): + """Type count (read-only)""" + return core.BNGetTypeElementCount(self.handle) + + def __str__(self): + return core.BNGetTypeString(self.handle) + + def __repr__(self): + return "" % str(self) + + def get_string_before_name(self): + return core.BNGetTypeStringBeforeName(self.handle) + + def get_string_after_name(self): + return core.BNGetTypeStringAfterName(self.handle) + + @classmethod + def void(cls): + return Type(core.BNCreateVoidType()) + + @classmethod + def bool(self): + return Type(core.BNCreateBoolType()) + + @classmethod + def int(self, width, sign = True, altname=""): + return Type(core.BNCreateIntegerType(width, sign, altname)) + + @classmethod + def float(self, width): + return Type(core.BNCreateFloatType(width)) + + @classmethod + def structure_type(self, structure_type): + return Type(core.BNCreateStructureType(structure_type.handle)) + + @classmethod + def unknown_type(self, unknown_type): + return Type(core.BNCreateUnknownType(unknown_type.handle)) + + @classmethod + def enumeration_type(self, arch, e, width=None): + if width is None: + width = arch.default_int_size + return Type(core.BNCreateEnumerationType(e.handle, width)) + + @classmethod + def pointer(self, arch, t, const=False): + return Type(core.BNCreatePointerType(arch.handle, t.handle, const)) + + @classmethod + def array(self, t, count): + return Type(core.BNCreateArrayType(t.handle, count)) + + @classmethod + def function(self, ret, params, calling_convention=None, variable_arguments=False): + param_buf = (core.BNNameAndType * len(params))() + for i in xrange(0, len(params)): + if isinstance(params[i], Type): + param_buf[i].name = "" + param_buf[i].type = params[i].handle + else: + param_buf[i].name = params[i][1] + param_buf[i].type = params[i][0] + if calling_convention is not None: + calling_convention = calling_convention.handle + return Type(core.BNCreateFunctionType(ret.handle, calling_convention, param_buf, len(params), + variable_arguments)) + + def __setattr__(self, name, value): + try: + object.__setattr__(self, name, value) + except AttributeError: + raise AttributeError("attribute '%s' is read only" % name) + + +class UnknownType(object): + def __init__(self, handle=None): + if handle is None: + self.handle = core.BNCreateUnknownType() + else: + self.handle = handle + + def __del__(self): + core.BNFreeUnknownType(self.handle) + + @property + def name(self): + count = ctypes.c_ulonglong() + nameList = core.BNGetUnknownTypeName(self.handle, count) + result = [] + for i in xrange(count.value): + result.append(nameList[i]) + return demangle.get_qualified_name(result) + + @name.setter + def name(self, value): + core.BNSetUnknownTypeName(self.handle, value) + + +class StructureMember(object): + def __init__(self, t, name, offset): + self.type = t + self.name = name + self.offset = offset + + def __repr__(self): + if len(self.name) == 0: + return "" % (str(self.type), self.offset) + return "<%s %s%s, offset %#x>" % (self.type.get_string_before_name(), self.name, + self.type.get_string_after_name(), self.offset) + + +class Structure(object): + def __init__(self, handle=None): + if handle is None: + self.handle = core.BNCreateStructure() + else: + self.handle = handle + + def __del__(self): + core.BNFreeStructure(self.handle) + + @property + def name(self): + count = ctypes.c_ulonglong() + nameList = core.BNGetStructureName(self.handle, count) + result = [] + for i in xrange(count.value): + result.append(nameList[i]) + return demangle.get_qualified_name(result) + + @name.setter + def name(self, value): + core.BNSetStructureName(self.handle, value) + + @property + def members(self): + """Structure member list (read-only)""" + count = ctypes.c_ulonglong() + members = core.BNGetStructureMembers(self.handle, count) + result = [] + for i in xrange(0, count.value): + result.append(StructureMember(Type(core.BNNewTypeReference(members[i].type)), + members[i].name, members[i].offset)) + core.BNFreeStructureMemberList(members, count.value) + return result + + @property + def width(self): + """Structure width (read-only)""" + return core.BNGetStructureWidth(self.handle) + + @property + def alignment(self): + """Structure alignment (read-only)""" + return core.BNGetStructureAlignment(self.handle) + + @property + def packed(self): + return core.BNIsStructurePacked(self.handle) + + @packed.setter + def packed(self, value): + core.BNSetStructurePacked(self.handle, value) + + @property + def union(self): + return core.BNIsStructureUnion(self.handle) + + @union.setter + def union(self, value): + core.BNSetStructureUnion(self.handle, value) + + def __setattr__(self, name, value): + try: + object.__setattr__(self, name, value) + except AttributeError: + raise AttributeError("attribute '%s' is read only" % name) + + def __repr__(self): + if len(self.name) > 0: + return "" % self.name + return "" % self.width + + def append(self, t, name = ""): + core.BNAddStructureMember(self.handle, t.handle, name) + + def insert(self, offset, t, name = ""): + core.BNAddStructureMemberAtOffset(self.handle, t.handle, name, offset) + + def remove(self, i): + core.BNRemoveStructureMember(self.handle, i) + + +class EnumerationMember(object): + def __init__(self, name, value, default): + self.name = name + self.value = value + self.default = default + + def __repr__(self): + return "<%s = %#x>" % (self.name, self.value) + + +class Enumeration(object): + def __init__(self, handle=None): + if handle is None: + self.handle = core.BNCreateEnumeration() + else: + self.handle = handle + + def __del__(self): + core.BNFreeEnumeration(self.handle) + + @property + def name(self): + return core.BNGetEnumerationName(self.handle) + + @name.setter + def name(self, value): + core.BNSetEnumerationName(self.handle, value) + + @property + def members(self): + """Enumeration member list (read-only)""" + count = ctypes.c_ulonglong() + members = core.BNGetEnumerationMembers(self.handle, count) + result = [] + for i in xrange(0, count.value): + result.append(EnumerationMember(members[i].name, members[i].value, members[i].isDefault)) + core.BNFreeEnumerationMemberList(members, count.value) + return result + + def __setattr__(self, name, value): + try: + object.__setattr__(self, name, value) + except AttributeError: + raise AttributeError("attribute '%s' is read only" % name) + + def __repr__(self): + if len(self.name) > 0: + return "" % self.name + return "" % repr(self.members) + + def append(self, name, value = None): + if value is None: + core.BNAddEnumerationMember(self.handle, name) + else: + core.BNAddEnumerationMemberWithValue(self.handle, name, value) + + +class TypeParserResult(object): + def __init__(self, types, variables, functions): + self.types = types + self.variables = variables + self.functions = functions + + def __repr__(self): + return "{types: %s, variables: %s, functions: %s}" % (self.types, self.variables, self.functions) + + +def preprocess_source(source, filename=None, include_dirs=[]): + """ + ``preprocess_source`` run the C preprocessor on the given source or source filename. + + :param str source: source to preprocess + :param str filename: optional filename to preprocess + :param list(str) include_dirs: list of string directorires to use as include directories. + :return: returns a tuple of (preprocessed_source, error_string) + :rtype: tuple(str,str) + :Example: + + >>> source = "#define TEN 10\\nint x[TEN];\\n" + >>> preprocess_source(source) + ('#line 1 "input"\\n\\n#line 2 "input"\\n int x [ 10 ] ;\\n', '') + >>> + """ + if filename is None: + filename = "input" + dir_buf = (ctypes.c_char_p * len(include_dirs))() + for i in xrange(0, len(include_dirs)): + dir_buf[i] = str(include_dirs[i]) + output = ctypes.c_char_p() + errors = ctypes.c_char_p() + result = core.BNPreprocessSource(source, filename, output, errors, dir_buf, len(include_dirs)) + output_str = output.value + error_str = errors.value + core.BNFreeString(ctypes.cast(output, ctypes.POINTER(ctypes.c_byte))) + core.BNFreeString(ctypes.cast(errors, ctypes.POINTER(ctypes.c_byte))) + if result: + return (output_str, error_str) + return (None, error_str) diff --git a/python/undoaction.py b/python/undoaction.py index 850d37fd..9f742e00 100644 --- a/python/undoaction.py +++ b/python/undoaction.py @@ -24,6 +24,7 @@ import ctypes # Binary Ninja components import _binaryninjacore as core +from enums import ActionType import startup import log @@ -40,7 +41,7 @@ class UndoAction(object): raise TypeError("undo action type not registered") action_type = self.__class__.action_type if isinstance(action_type, str): - self._cb.type = core.BNActionType[action_type] + self._cb.type = ActionType[action_type] else: self._cb.type = action_type self._cb.context = 0 diff --git a/python/update.py b/python/update.py index 38d68683..7e2bd4ef 100644 --- a/python/update.py +++ b/python/update.py @@ -23,6 +23,7 @@ import ctypes # Binary Ninja components import _binaryninjacore as core +from enums import UpdateResult import startup import log @@ -180,7 +181,7 @@ class UpdateChannel(object): error_str = errors.value core.BNFreeString(ctypes.cast(errors, ctypes.POINTER(ctypes.c_byte))) raise IOError(error_str) - return core.BNUpdateResult(result) + return UpdateResult(result) class UpdateVersion(object): @@ -204,7 +205,7 @@ class UpdateVersion(object): error_str = errors.value core.BNFreeString(ctypes.cast(errors, ctypes.POINTER(ctypes.c_byte))) raise IOError(error_str) - return core.BNUpdateResult(result) + return UpdateResult(result) def are_auto_updates_enabled(): -- cgit v1.3.1