From 13a793f7ad19f43ff97c058becb76182b0159452 Mon Sep 17 00:00:00 2001 From: Jordan Wiens Date: Wed, 15 May 2019 15:17:57 -0700 Subject: first half of the refactor adding getters and setters for init created properties --- python/architecture.py | 52 ++++- python/basicblock.py | 93 +++++++-- python/binaryview.py | 374 ++++++++++++++++++++++++++++----- python/callingconvention.py | 11 +- python/databuffer.py | 2 + python/filemetadata.py | 17 +- python/flowgraph.py | 14 +- python/function.py | 492 ++++++++++++++++++++++++++++++++++++++------ python/highlight.py | 96 +++++++-- 9 files changed, 991 insertions(+), 160 deletions(-) (limited to 'python') diff --git a/python/architecture.py b/python/architecture.py index c2f28a86..2d81beb0 100644 --- a/python/architecture.py +++ b/python/architecture.py @@ -2648,7 +2648,7 @@ class CoreArchitecture(Architecture): class ArchitectureHook(CoreArchitecture): def __init__(self, base_arch): - self.base_arch = base_arch + self._base_arch = base_arch super(ArchitectureHook, self).__init__(base_arch.handle) # To improve performance of simpler hooks, use null callback for functions that are not being overridden @@ -2677,17 +2677,53 @@ class ArchitectureHook(CoreArchitecture): def register(self): self.__class__._registered_cb = self._cb - self.handle = core.BNRegisterArchitectureHook(self.base_arch.handle, self._cb) + self.handle = core.BNRegisterArchitectureHook(self._base_arch.handle, self._cb) + + @property + def base_arch(self): + """ """ + return self._base_arch + + @base_arch.setter + def base_arch(self, value): + self._base_arch = value class ReferenceSource(object): def __init__(self, func, arch, addr): - self.function = func - self.arch = arch - self.address = addr + self._function = func + self._arch = arch + self._address = addr def __repr__(self): - if self.arch: - return "" % (self.arch.name, self.address) + if self._arch: + return "" % (self._arch.name, self._address) else: - return "" % self.address + return "" % self._address + + @property + def function(self): + """ """ + return self._function + + @function.setter + def function(self, value): + self._function = value + + @property + def arch(self): + """ """ + return self._arch + + @arch.setter + def arch(self, value): + self._arch = value + + @property + def address(self): + """ """ + return self._address + + @address.setter + def address(self, value): + self._address = value diff --git a/python/basicblock.py b/python/basicblock.py index 5730bab5..14784c81 100644 --- a/python/basicblock.py +++ b/python/basicblock.py @@ -33,27 +33,73 @@ from binaryninja import range class BasicBlockEdge(object): def __init__(self, branch_type, source, target, back_edge, fall_through): - self.type = branch_type - self.source = source - self.target = target - self.back_edge = back_edge - self.fall_through = fall_through + self._type = branch_type + self._source = source + self._target = target + self._back_edge = back_edge + self._fall_through = fall_through def __eq__(self, value): if not isinstance(value, BasicBlockEdge): return False - return (self.type, self.source, self.target, self.back_edge, self.fall_through) == (value.type, value.source, value.target, value.back_edge, value.fall_through) + return (self._type, self._source, self._target, self._back_edge, self._fall_through) == (value.type, value.source, value.target, value.back_edge, value.fall_through) def __hash__(self): - return hash((self.type, self.source, self.target, self.back_edge, self.fall_through)) + return hash((self._type, self._source, self._target, self.back_edge, self.fall_through)) def __repr__(self): - if self.type == BranchType.UnresolvedBranch: - return "<%s>" % BranchType(self.type).name - elif self.target.arch: - return "<%s: %s@%#x>" % (BranchType(self.type).name, self.target.arch.name, self.target.start) + if self._type == BranchType.UnresolvedBranch: + return "<%s>" % BranchType(self._type).name + elif self._target.arch: + return "<%s: %s@%#x>" % (BranchType(self._type).name, self._target.arch.name, self._target.start) else: - return "<%s: %#x>" % (BranchType(self.type).name, self.target.start) + return "<%s: %#x>" % (BranchType(self._type).name, self._target.start) + + @property + def type(self): + """ """ + return self._type + + @type.setter + def type(self, value): + self._type = value + + @property + def source(self): + """ """ + return self._source + + @source.setter + def source(self, value): + self._source = value + + @property + def target(self): + """ """ + return self._target + + @target.setter + def target(self, value): + self._target = value + + @property + def back_edge(self): + """ """ + return self._back_edge + + @back_edge.setter + def back_edge(self, value): + self._back_edge = value + + @property + def fall_through(self): + """ """ + return self._fall_through + + @fall_through.setter + def fall_through(self, value): + self._fall_through = value + class BasicBlock(object): @@ -88,7 +134,7 @@ class BasicBlock(object): return int(core.BNGetBasicBlockLength(self.handle)) def __repr__(self): - arch = self.arch + arch = self._arch if arch: return "" % (arch.name, self.start, self.end) else: @@ -99,7 +145,7 @@ class BasicBlock(object): # don't and instruction start cache the object is likely ephemeral idx = self.start while idx < self.end: - data = self.view.read(idx, min(self.arch.max_instr_length, self.end - idx)) + data = self._view.read(idx, min(self._arch.max_instr_length, self.end - idx)) inst_text = self.arch.get_instruction_text(data, idx) if inst_text[1] == 0: break @@ -107,7 +153,7 @@ class BasicBlock(object): idx += inst_text[1] else: for start, length in zip(self._instStarts, self._instLengths): - inst_text = self.arch.get_instruction_text(self.view.read(start, length), start) + inst_text = self.arch.get_instruction_text(self._view.read(start, length), start) if inst_text[1] == 0: break yield inst_text @@ -116,7 +162,7 @@ class BasicBlock(object): self._buildStartCache() start = self._instStarts[i] length = self._instLengths[i] - data = self.view.read(start, length) + data = self._view.read(start, length) return self.arch.get_instruction_text(data, start) def __hash__(self): @@ -156,7 +202,7 @@ class BasicBlock(object): @property def view(self): - """Binary view that contains the basic block (read-ony)""" + """Binary view that contains the basic block (read-only)""" if self._view is not None: return self._view self._view = self.function.view @@ -228,7 +274,7 @@ class BasicBlock(object): for i in range(0, count.value): branch_type = BranchType(edges[i].type) if edges[i].target: - target = self._create_instance(core.BNNewBasicBlockReference(edges[i].target), self.view) + target = self._create_instance(core.BNNewBasicBlockReference(edges[i].target), G) else: target = None result.append(BasicBlockEdge(branch_type, target, self, edges[i].backEdge, edges[i].fallThrough)) @@ -341,7 +387,7 @@ class BasicBlock(object): @property def annotations(self): """List of automatic annotations for the start of this block (read-only)""" - return self.function.get_block_annotations(self.start, self.arch) + return self.function.get_block_annotations(self.start, self._arch) @property def disassembly_text(self): @@ -461,3 +507,12 @@ class BasicBlock(object): if isinstance(color, HighlightStandardColor): color = highlight.HighlightColor(color) core.BNSetUserBasicBlockHighlight(self.handle, color._get_core_struct()) + + @property + def view(self): + """ """ + return self._view + + @view.setter + def view(self, value): + self._view = value diff --git a/python/binaryview.py b/python/binaryview.py index 66c30d06..e98be02c 100644 --- a/python/binaryview.py +++ b/python/binaryview.py @@ -96,10 +96,10 @@ class BinaryDataNotification(object): class StringReference(object): def __init__(self, bv, string_type, start, length): - self.type = string_type - self.start = start - self.length = length - self.view = bv + self._type = string_type + self._start = start + self._length = length + self._view = bv @property def value(self): @@ -108,6 +108,42 @@ class StringReference(object): def __repr__(self): return "<%s: %#x, len %#x>" % (self.type, self.start, self.length) + @property + def type(self): + """ """ + return self._type + + @type.setter + def type(self, value): + self._type = value + + @property + def start(self): + """ """ + return self._start + + @start.setter + def start(self, value): + self._start = value + + @property + def length(self): + """ """ + return self._length + + @length.setter + def length(self, value): + self._length = value + + @property + def view(self): + """ """ + return self._view + + @view.setter + def view(self, value): + self._view = value + _pending_analysis_completion_events = {} class AnalysisCompletionEvent(object): @@ -125,8 +161,8 @@ class AnalysisCompletionEvent(object): >>> """ def __init__(self, view, callback): - self.view = view - self.callback = 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) global _pending_analysis_completion_events @@ -152,42 +188,122 @@ class AnalysisCompletionEvent(object): def cancel(self): """ - .. warning: This method should only be used when the system is being - shut down and no further analysis should be done afterward. + .. warning: This method should only be used when the system is being shut down and no further analysis should be done afterward. """ - self.callback = self._empty_callback + self._callback = self._empty_callback core.BNCancelAnalysisCompletionEvent(self.handle) global _pending_analysis_completion_events if id(self) in _pending_analysis_completion_events: del _pending_analysis_completion_events[id(self)] + @property + def view(self): + """ """ + return self._view + + @view.setter + def view(self, value): + self._view = value + + @property + def callback(self): + """ """ + return self._callback + + @callback.setter + def callback(self, value): + self._callback = value + class ActiveAnalysisInfo(object): def __init__(self, func, analysis_time, update_count, submit_count): - self.func = func - self.analysis_time = analysis_time - self.update_count = update_count - self.submit_count = submit_count + self._func = func + self._analysis_time = analysis_time + self._update_count = update_count + self._submit_count = submit_count def __repr__(self): return "" % (self.func, self.analysis_time, self.update_count, self.submit_count) + @property + def func(self): + """ """ + return self._func + + @func.setter + def func(self, value): + self._func = value + + @property + def analysis_time(self): + """ """ + return self._analysis_time + + @analysis_time.setter + def analysis_time(self, value): + self._analysis_time = value + + @property + def update_count(self): + """ """ + return self._update_count + + @update_count.setter + def update_count(self, value): + self._update_count = value + + @property + def submit_count(self): + """ """ + return self._submit_count + + @submit_count.setter + def submit_count(self, value): + self._submit_count = value + class AnalysisInfo(object): def __init__(self, state, analysis_time, active_info): - self.state = AnalysisState(state) - self.analysis_time = analysis_time - self.active_info = active_info + self._state = AnalysisState(state) + self._analysis_time = analysis_time + self._active_info = active_info def __repr__(self): return "" % (self.state, self.analysis_time, self.active_info) + @property + def state(self): + """ """ + return self._state + + @state.setter + def state(self, value): + self._state = value + + @property + def analysis_time(self): + """ """ + return self._analysis_time + + @analysis_time.setter + def analysis_time(self, value): + self._analysis_time = value + + @property + def analysis_info(self): + """ """ + return self._analysis_info + + @analysis_info.setter + def analysis_info(self, value): + self._analysis_info = value + class AnalysisProgress(object): def __init__(self, state, count, total): - self.state = state - self.count = count - self.total = total + self._state = state + self._count = count + self._total = total def __str__(self): if self.state == AnalysisState.DisassembleState: @@ -201,13 +317,40 @@ class AnalysisProgress(object): def __repr__(self): return "" % str(self) + @property + def state(self): + """ """ + return self._state + + @state.setter + def state(self, value): + self._state = value + + @property + def count(self): + """ """ + return self._count + + @count.setter + def count(self, value): + self._count = value + + @property + def total(self): + """ """ + return self._total + + @total.setter + def total(self, value): + self._total = value + class DataVariable(object): def __init__(self, addr, var_type, auto_discovered, view=None): - self.address = addr - self.type = var_type - self.auto_discovered = auto_discovered - self.view = view + self._address = addr + self._type = var_type + self._auto_discovered = auto_discovered + self._view = view @property def data_refs_from(self): @@ -230,11 +373,47 @@ class DataVariable(object): def __repr__(self): return "" % (self.address, str(self.type)) + @property + def address(self): + """ """ + return self._address + + @address.setter + def address(self, value): + self._address = value + + @property + def type(self): + """ """ + return self._type + + @type.setter + def type(self, value): + self._type = value + + @property + def auto_discovered(self): + """ """ + return self._auto_discovered + + @auto_discovered.setter + def auto_discovered(self, value): + self._auto_discovered = value + + @property + def view(self): + """ """ + return self._view + + @view.setter + def view(self, value): + self._view = value + class BinaryDataNotificationCallbacks(object): def __init__(self, view, notify): - self.view = view - self.notify = 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) @@ -353,6 +532,24 @@ class BinaryDataNotificationCallbacks(object): except: log.log_error(traceback.format_exc()) + @property + def view(self): + """ """ + return self._view + + @view.setter + def view(self, value): + self._view = value + + @property + def notify(self): + """ """ + return self._notify + + @notify.setter + def notify(self, value): + self._notify = value + class _BinaryViewTypeMetaclass(type): @@ -660,8 +857,8 @@ class Section(object): class AddressRange(object): def __init__(self, start, end): - self.start = start - self.end = end + self._start = start + self._end = end @property def length(self): @@ -673,6 +870,24 @@ class AddressRange(object): def __repr__(self): return "<%#x-%#x>" % (self.start, self.end) + @property + def start(self): + """ """ + return self._start + + @start.setter + def start(self, value): + self._start = value + + @property + def end(self): + """ """ + return self._end + + @end.setter + def end(self, value): + self._end = value + class _BinaryViewAssociatedDataStore(associateddatastore._AssociatedDataStore): _defaults = {} @@ -738,15 +953,15 @@ class BinaryView(object): if handle is not None: self.handle = core.handle_of_type(handle, core.BNBinaryView) if file_metadata is None: - self.file = binaryninja.filemetadata.FileMetadata(handle=core.BNGetFileForView(handle)) + self._file = binaryninja.filemetadata.FileMetadata(handle=core.BNGetFileForView(handle)) else: - self.file = file_metadata + self._file = file_metadata elif self.__class__ is BinaryView: binaryninja._init_plugins() if file_metadata is None: file_metadata = binaryninja.filemetadata.FileMetadata() self.handle = core.BNCreateBinaryDataView(file_metadata.handle) - self.file = binaryninja.filemetadata.FileMetadata(handle=core.BNNewFileReference(file_metadata.handle)) + self._file = binaryninja.filemetadata.FileMetadata(handle=core.BNNewFileReference(file_metadata.handle)) else: binaryninja._init_plugins() if not self.__class__._registered: @@ -774,12 +989,12 @@ class BinaryView(object): self._cb.isRelocatable = self._cb.isRelocatable.__class__(self._is_relocatable) self._cb.getAddressSize = self._cb.getAddressSize.__class__(self._get_address_size) self._cb.save = self._cb.save.__class__(self._save) - self.file = file_metadata + 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 + self._notifications = {} + self._next_address = None # Do NOT try to access view before init() is called, use placeholder def __eq__(self, value): if not isinstance(value, BinaryView): @@ -945,37 +1160,64 @@ class BinaryView(object): @property def modified(self): """boolean modification state of the BinaryView (read/write)""" - return self.file.modified + return self._file.modified @modified.setter def modified(self, value): - self.file.modified = 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 + 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 + return self._file.has_database @property def view(self): - return self.file.view + return self._file.view @view.setter def view(self, value): - self.file.view = value + self._file.view = value @property def offset(self): - return self.file.offset + return self._file.offset @offset.setter def offset(self, value): - self.file.offset = value + self._file.offset = value + + @property + def file(self): + """:class:`.FileMetadata` backing the BinaryView """ + return self._file + + @file.setter + def file(self, value): + self._file = value + + @property + def notifications(self): + """:class:`.FileMetadata` backing the BinaryView """ + return self._notifications + + @notifications.setter + def notifications(self, value): + self._notifications = value + + @property + def next_address(self): + """:class:`.FileMetadata` backing the BinaryView """ + return self._next_address + + @next_address.setter + def next_address(self, value): + self._next_address = value @property def start(self): @@ -994,7 +1236,7 @@ class BinaryView(object): @property def arch(self): - """The architecture associated with the current BinaryView (read/write)""" + """The architecture associated with the current :class:`.BinaryView` (read/write)""" arch = core.BNGetDefaultArchitecture(self.handle) if arch is None: return None @@ -1132,11 +1374,11 @@ class BinaryView(object): @property def saved(self): """boolean state of whether or not the file has been saved (read/write)""" - return self.file.saved + return self._file.saved @saved.setter def saved(self, value): - self.file.saved = value + self._file.saved = value @property def analysis_info(self): @@ -1373,7 +1615,7 @@ class BinaryView(object): size = "start %#x, len %#x" % (start, length) else: size = "len %#x" % length - filename = self.file.filename + filename = self._file.filename if len(filename) > 0: return "" % (filename, size) return "" % (size) @@ -1833,7 +2075,7 @@ class BinaryView(object): :return: true on success, false on failure :rtype: bool """ - return self.file.create_database(filename, progress_func) + return self._file.create_database(filename, progress_func) def save_auto_snapshot(self, progress_func=None): """ @@ -1845,7 +2087,7 @@ class BinaryView(object): :return: True if it successfully saved the snapshot, False otherwise :rtype: bool """ - return self.file.save_auto_snapshot(progress_func) + return self._file.save_auto_snapshot(progress_func) def get_view_of_type(self, name): """ @@ -1855,7 +2097,7 @@ class BinaryView(object): :return: BinaryView object associated with the provided name or None on failure :rtype: BinaryView or None """ - return self.file.get_view_of_type(name) + return self._file.get_view_of_type(name) def begin_undo_actions(self): """ @@ -1877,7 +2119,7 @@ class BinaryView(object): 'xor eax, eax' >>> """ - self.file.begin_undo_actions() + self._file.begin_undo_actions() def add_undo_action(self, action): core.BNAddUndoAction(self.handle, action.__class__.name, action._cb) @@ -1902,7 +2144,7 @@ class BinaryView(object): 'xor eax, eax' >>> """ - self.file.commit_undo_actions() + self._file.commit_undo_actions() def undo(self): """ @@ -1927,7 +2169,7 @@ class BinaryView(object): 'nop' >>> """ - self.file.undo() + self._file.undo() def redo(self): """ @@ -1952,10 +2194,10 @@ class BinaryView(object): 'nop' >>> """ - self.file.redo() + self._file.redo() def navigate(self, view, offset): - return self.file.navigate(view, offset) + return self._file.navigate(view, offset) def read(self, addr, length): """ @@ -2880,6 +3122,7 @@ class BinaryView(object): >>> bv.is_invert_branch_patch_available(0x100012ef) True >>> + """ if arch is None: arch = self.arch @@ -3560,8 +3803,8 @@ class BinaryView(object): """ class LinearDisassemblyIterator(object): def __init__(self, view, settings): - self.view = view - self.settings = settings + self._view = view + self._settings = settings def __iter__(self): pos = self.view.get_linear_disassembly_position_at(self.view.start, self.settings) @@ -3572,6 +3815,25 @@ class BinaryView(object): for line in lines: yield line + @property + def view(self): + """ """ + return self._view + + @view.setter + def view(self, value): + self._view = value + + @property + def settings(self): + """ """ + return self._settings + + @settings.setter + def settings(self, value): + self._settings = value + + return iter(LinearDisassemblyIterator(self, settings)) def parse_type_string(self, text): @@ -3942,7 +4204,7 @@ class BinaryView(object): def get_address_input(self, prompt, title, current_address = None): if current_address is None: - current_address = self.file.offset + current_address = self._file.offset value = ctypes.c_ulonglong() if not core.BNGetAddressInput(value, prompt, title, self.handle, current_address): return None diff --git a/python/callingconvention.py b/python/callingconvention.py index ee42caca..92aa30f2 100644 --- a/python/callingconvention.py +++ b/python/callingconvention.py @@ -53,7 +53,7 @@ class CallingConvention(object): if arch is None or name is None: self.handle = None raise ValueError("Must specify either handle or architecture and name") - self.arch = arch + self._arch = arch self._pending_reg_lists = {} self._cb = core.BNCustomCallingConvention() self._cb.context = 0 @@ -443,3 +443,12 @@ class CallingConvention(object): func_obj = func.handle out_var = core.BNGetParameterVariableForIncomingVariable(self.handle, in_buf, func_obj) return binaryninja.function.Variable(func, out_var.type, out_var.index, out_var.storage) + + @property + def arch(self): + """ """ + return self._arch + + @arch.setter + def arch(self, value): + self._arch = value diff --git a/python/databuffer.py b/python/databuffer.py index 8644a75e..3d754090 100644 --- a/python/databuffer.py +++ b/python/databuffer.py @@ -34,6 +34,8 @@ class DataBuffer(object): 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, str): + self.handle = core.BNCreateDataBuffer(contents.encode(), len(contents.encode())) elif isinstance(contents, DataBuffer): self.handle = core.BNDuplicateDataBuffer(contents.handle) else: diff --git a/python/filemetadata.py b/python/filemetadata.py index 74445a02..8c6b2cb7 100644 --- a/python/filemetadata.py +++ b/python/filemetadata.py @@ -86,7 +86,17 @@ class FileMetadata(object): self.handle = core.BNCreateFileMetadata() if filename is not None: core.BNSetFilename(self.handle, str(filename)) - self.nav = None + self._nav = None + + @property + def nav(self): + """ + """ + return self._nav + + @nav.setter + def nav(self, value): + self._nav = value def __del__(self): if self.navigation is not None: @@ -192,12 +202,13 @@ class FileMetadata(object): @property def navigation(self): - return self.nav + """Alias for nav""" + return self._nav @navigation.setter def navigation(self, value): value._register(self.handle) - self.nav = value + self._nav = value @property def session_data(self): diff --git a/python/flowgraph.py b/python/flowgraph.py index 189b075c..a5ac686c 100644 --- a/python/flowgraph.py +++ b/python/flowgraph.py @@ -58,9 +58,10 @@ class FlowGraphNode(object): raise ValueError("flow graph node must be associated with a graph") handle = core.BNCreateFlowGraphNode(graph.handle) self.handle = handle + self._graph = graph self.graph = graph - if self.graph is None: - self.graph = FlowGraph(handle = core.BNGetFlowGraphNodeOwner(self.handle)) + if self._graph is None: + self._graph = FlowGraph(handle = core.BNGetFlowGraphNodeOwner(self.handle)) def __del__(self): if self.handle is not None: @@ -76,6 +77,15 @@ class FlowGraphNode(object): return True return ctypes.addressof(self.handle.contents) != ctypes.addressof(value.handle.contents) + @property + def graph(self): + """ """ + return self._graph + + @graph.setter + def graph(self, value): + self._graph = value + @property def basic_block(self): """Basic block associated with this part of the flow graph""" diff --git a/python/function.py b/python/function.py index c33ac97f..9e018758 100644 --- a/python/function.py +++ b/python/function.py @@ -41,34 +41,54 @@ from binaryninja import range class LookupTableEntry(object): def __init__(self, from_values, to_value): - self.from_values = from_values - self.to_value = 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) + @property + def from_values(self): + """ """ + return self._from_values + + @from_values.setter + def from_values(self, value): + """ """ + self._from_values = value + + @property + def to_values(self): + """ """ + return self._to_values + + @to_values.setter + def to_values(self, value): + """ """ + self._to_values = value + class RegisterValue(object): def __init__(self, arch = None, value = None, confidence = types.max_confidence): - self.is_constant = False + self._is_constant = False if value is None: - self.type = RegisterValueType.UndeterminedValue + self._type = RegisterValueType.UndeterminedValue else: - self.type = RegisterValueType(value.state) + self._type = RegisterValueType(value.state) if value.state == RegisterValueType.EntryValue: - self.arch = arch + self._arch = arch if arch is not None: - self.reg = arch.get_reg_name(value.value) + self._reg = arch.get_reg_name(value.value) else: - self.reg = value.value + self._reg = value.value elif (value.state == RegisterValueType.ConstantValue) or (value.state == RegisterValueType.ConstantPointerValue): - self.value = value.value - self.is_constant = True + self._value = value.value + self._is_constant = True elif value.state == RegisterValueType.StackFrameOffset: - self.offset = value.value + self._offset = value.value elif value.state == RegisterValueType.ImportedAddressValue: - self.value = value.value - self.confidence = confidence + self._value = value.value + self._confidence = confidence def __repr__(self): if self.type == RegisterValueType.EntryValue: @@ -150,33 +170,143 @@ class RegisterValue(object): result.type = RegisterValueType.ReturnAddressValue return result + @property + def is_constant(self): + """ """ + return self._is_constant + + @is_constant.setter + def is_constant(self, value): + """ """ + self._is_constant = value + + @property + def type(self): + """ """ + return self._type + + @type.setter + def type(self, value): + """ """ + self._type = value + + @property + def state(self): + """ """ + return self._state + + @state.setter + def state(self, value): + """ """ + self._state = value + + @property + def arch(self): + """ """ + return self._arch + + @arch.setter + def arch(self, value): + """ """ + self._arch = value + + @property + def reg(self): + """ """ + return self._reg + + @reg.setter + def reg(self, value): + """ """ + self._reg = value + + @property + def value(self): + """ """ + return self._value + + @value.setter + def value(self, value): + """ """ + self._value = value + + @property + def offset(self): + """ """ + return self._offset + + @offset.setter + def offset(self, value): + """ """ + self._offset = value + + @property + def confidence(self): + """ """ + return self._confidence + + @confidence.setter + def confidence(self, value): + """ """ + self._confidence = value + class ValueRange(object): def __init__(self, start, end, step): - self.start = start - self.end = end - self.step = step + self._start = start + self._end = end + self._step = step def __repr__(self): if self.step == 1: return "" % (self.start, self.end) return "" % (self.start, self.end, self.step) + @property + def start(self): + """ """ + return self._start + + @start.setter + def start(self, value): + """ """ + self._start = value + + @property + def end(self): + """ """ + return self._end + + @end.setter + def end(self, value): + """ """ + self._end = value + + @property + def step(self): + """ """ + return self._step + + @step.setter + def step(self, value): + """ """ + self._step = value + class PossibleValueSet(object): def __init__(self, arch, value): - self.type = RegisterValueType(value.state) + self._type = RegisterValueType(value.state) if value.state == RegisterValueType.EntryValue: - self.reg = arch.get_reg_name(value.value) + self._reg = arch.get_reg_name(value.value) elif value.state == RegisterValueType.ConstantValue: - self.value = value.value + self._value = value.value elif value.state == RegisterValueType.ConstantPointerValue: - self.value = value.value + self._value = value.value elif value.state == RegisterValueType.StackFrameOffset: - self.offset = value.value + self._offset = value.value elif value.state == RegisterValueType.SignedRangeValue: - self.offset = value.value - self.ranges = [] + self._offset = value.value + self._ranges = [] for i in range(0, value.count): start = value.ranges[i].start end = value.ranges[i].end @@ -185,28 +315,28 @@ class PossibleValueSet(object): start |= ~((1 << 63) - 1) if end & (1 << 63): end |= ~((1 << 63) - 1) - self.ranges.append(ValueRange(start, end, step)) + self._ranges.append(ValueRange(start, end, step)) elif value.state == RegisterValueType.UnsignedRangeValue: - self.offset = value.value - self.ranges = [] + self._offset = value.value + self._ranges = [] for i in range(0, value.count): start = value.ranges[i].start end = value.ranges[i].end step = value.ranges[i].step - self.ranges.append(ValueRange(start, end, step)) + self._ranges.append(ValueRange(start, end, step)) elif value.state == RegisterValueType.LookupTableValue: - self.table = [] - self.mapping = {} + self._table = [] + self._mapping = {} for i in range(0, value.count): from_list = [] for j in range(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)) + self._mapping[value.table[i].fromValues[j]] = value.table[i].toValue + self._table.append(LookupTableEntry(from_list, value.table[i].toValue)) elif (value.state == RegisterValueType.InSetOfValues) or (value.state == RegisterValueType.NotInSetOfValues): - self.values = set() + self._values = set() for i in range(0, value.count): - self.values.add(value.valueSet[i]) + self._values.add(value.valueSet[i]) def __repr__(self): if self.type == RegisterValueType.EntryValue: @@ -231,40 +361,184 @@ class PossibleValueSet(object): return "" return "" + @property + def type(self): + """ """ + return self._type + + @type.setter + def type(self, value): + """ """ + self._type = value + + @property + def reg(self): + """ """ + return self._reg + + @reg.setter + def reg(self, value): + """ """ + self._reg = value + + @property + def value(self): + """ """ + return self._value + + @value.setter + def value(self, value): + """ """ + self._value = value + + @property + def offset(self): + """ """ + return self._offset + + @offset.setter + def offset(self, value): + """ """ + self._offset = value + + @property + def ranges(self): + """ """ + return self._ranges + + @ranges.setter + def ranges(self, value): + """ """ + self._ranges = value + + @property + def table(self): + """ """ + return self._table + + @table.setter + def table(self, value): + """ """ + self._table = value + + @property + def table(self): + """ """ + return self._table + + @table.setter + def table(self, value): + """ """ + self._table = value + + @property + def mapping(self): + """ """ + return self._mapping + + @mapping.setter + def mapping(self, value): + """ """ + self._mapping = value + + @property + def values(self): + """ """ + return self._values + + @values.setter + def values(self, value): + """ """ + self._values = value + class StackVariableReference(object): def __init__(self, src_operand, t, name, var, ref_ofs, size): - self.source_operand = src_operand - self.type = t - self.name = name - self.var = var - self.referenced_offset = ref_ofs - self.size = size - if self.source_operand == 0xffffffff: - self.source_operand = None + self._source_operand = src_operand + self._type = t + self._name = name + self._var = var + self._referenced_offset = ref_ofs + self._size = size + if self._source_operand == 0xffffffff: + self._source_operand = None def __repr__(self): - if self.source_operand is None: - if self.referenced_offset != self.var.storage: - return "" % (self.name, self.referenced_offset - self.var.storage) - return "" % self.name - if self.referenced_offset != self.var.storage: - return "" % (self.source_operand, self.name, self.var.storage) - return "" % (self.source_operand, self.name) + if self._source_operand is None: + if self._referenced_offset != self._var.storage: + return "" % (self._name, self._referenced_offset - self._var.storage) + return "" % self._name + if self._referenced_offset != self._var.storage: + return "" % (self._source_operand, self._name, self._var.storage) + return "" % (self._source_operand, self._name) + + @property + def source_operand(self): + """ """ + return self._source_operand + + @source_operand.setter + def source_operand(self, value): + self._source_operand = value + + @property + def type(self): + """ """ + return self._type + + @type.setter + def type(self, value): + self._type = value + + @property + def name(self): + """ """ + return self._name + + @name.setter + def name(self, value): + self._name = value + + @property + def var(self): + """ """ + return self._var + + @var.setter + def var(self, value): + self._var = value + + @property + def referenced_offset(self): + """ """ + return self._referenced_offset + + @referenced_offset.setter + def referenced_offset(self, value): + self._referenced_offset = value + + @property + def size(self): + """ """ + return self._size + + @size.setter + def size(self, value): + self._size = value class Variable(object): def __init__(self, func, source_type, index, storage, name = None, var_type = None): - self.function = func - self.source_type = VariableSourceType(source_type) - self.index = index - self.storage = storage + self._function = func + self._source_type = VariableSourceType(source_type) + self._index = index + self._storage = storage var = core.BNVariable() var.type = source_type var.index = index var.storage = storage - self.identifier = core.BNToVariableIdentifier(var) + self._identifier = core.BNToVariableIdentifier(var) if func is not None: if name is None: @@ -276,8 +550,71 @@ class Variable(object): else: var_type = None - self.name = name - self.type = var_type + self._name = name + self._type = var_type + + @property + def function(self): + """ """ + return self._function + + @function.setter + def function(self, value): + self._function = value + + @property + def source_type(self): + """ """ + return self._source_type + + @source_type.setter + def source_type(self, value): + self._source_type = value + + @property + def index(self): + """ """ + return self._index + + @index.setter + def index(self, value): + self._index = value + + @property + def storage(self): + """ """ + return self._storage + + @storage.setter + def storage(self, value): + self._storage = value + + @property + def identifier(self): + """ """ + return self._identifier + + @identifier.setter + def identifier(self, value): + self._identifier = value + + @property + def name(self): + """ """ + return self._name + + @name.setter + def name(self, value): + self._name = value + + @property + def type(self): + """ """ + return self._type + + @type.setter + def type(self, value): + self._type = value @classmethod def from_identifier(self, func, identifier, name = None, var_type = None): @@ -303,10 +640,10 @@ class Variable(object): class ConstantReference(object): def __init__(self, val, size, ptr, intermediate): - self.value = val - self.size = size - self.pointer = ptr - self.intermediate = intermediate + self._value = val + self._size = size + self._pointer = ptr + self._intermediate = intermediate def __repr__(self): if self.pointer: @@ -315,6 +652,43 @@ class ConstantReference(object): return "" % self.value return "" % (self.value, self.size) + @property + def value(self): + """ """ + return self._value + + @value.setter + def value(self, value): + self._value = value + + @property + def size(self): + """ """ + return self._size + + @size.setter + def size(self, value): + self._size = value + + @property + def pointer(self): + """ """ + return self._pointer + + @pointer.setter + def pointer(self, value): + self._pointer = value + + @property + def intermediate(self): + """ """ + return self._intermediate + + @intermediate.setter + def intermediate(self, value): + self._intermediate = value + + class IndirectBranchInfo(object): def __init__(self, source_arch, source_addr, dest_arch, dest_addr, auto_defined): diff --git a/python/highlight.py b/python/highlight.py index 2949e6d9..344468ef 100644 --- a/python/highlight.py +++ b/python/highlight.py @@ -27,25 +27,97 @@ from binaryninja.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 = HighlightColorStyle.CustomHighlightColor - self.red = red - self.green = green - self.blue = blue + 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 = HighlightColorStyle.MixedHighlightColor + self._style = HighlightColorStyle.MixedHighlightColor if color is None: - self.color = HighlightStandardColor.NoHighlightColor + self._color = HighlightStandardColor.NoHighlightColor else: - self.color = color - self.mix_color = mix_color - self.mix = mix + self._color = color + self._mix_color = mix_color + self._mix = mix else: self.style = HighlightColorStyle.StandardHighlightColor if color is None: - self.color = HighlightStandardColor.NoHighlightColor + self._color = HighlightStandardColor.NoHighlightColor else: - self.color = color - self.alpha = alpha + self._color = color + self._alpha = alpha + + @property + def alpha(self): + """ """ + return self._alpha + + @alpha.setter + def alpha(self, value): + self._alpha = value + + @property + def mix(self): + """ """ + return self._mix + + @mix.setter + def mix(self, value): + self._mix = value + + @property + def mix_color(self): + """ """ + return self._mix_color + + @mix_color.setter + def mix_color(self, value): + self._mix_color = value + + @property + def color(self): + """ """ + return self._color + + @color.setter + def color(self, value): + self._color = value + + @property + def style(self): + """ """ + return self._style + + @style.setter + def style(self, value): + self._style = value + + @property + def green(self): + """ """ + return self._green + + @green.setter + def green(self, value): + self._green = value + + @property + def red(self): + """ """ + return self._red + + @red.setter + def red(self, value): + self._red = value + + @property + def blue(self): + """ """ + return self._blue + + @blue.setter + def blue(self, value): + self._blue = value def _standard_color_to_str(self, color): if color == HighlightStandardColor.NoHighlightColor: -- cgit v1.3.1