diff options
Diffstat (limited to 'python')
| -rw-r--r-- | python/__init__.py | 93 |
1 files changed, 88 insertions, 5 deletions
diff --git a/python/__init__.py b/python/__init__.py index 16738292..0cc3cc37 100644 --- a/python/__init__.py +++ b/python/__init__.py @@ -1362,10 +1362,10 @@ class BinaryView(object): have segments or the virtual address is different from the physical address. This method **must not** be called directly. - addr (int): a virtual address - data (str): the data to be written - - returns (int): length of data written, should return 0 on error + :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 @@ -1656,7 +1656,11 @@ class BinaryView(object): platform (binaryninja.Platform): platform for the function to be added addr (int): virtual address of the function to be added - returns + returns (None): :: + + >>> bv.add_function(bv.platform, bv.entry_point + 1) + >>> bv.functions + [<func: x86_64@0x1>] """ core.BNAddFunctionForAnalysis(self.handle, platform.handle, addr) @@ -1664,6 +1668,19 @@ class BinaryView(object): core.BNAddEntryPointForAnalysis(self.handle, platform.handle, addr) def remove_function(self, func): + """ + ``remove_function`` removes the function ``func`` from the list of functions + + func (binaryninja.Function): a binaryninja.Function object. + + returns (None): :: + + >>> bv.functions + [<func: x86_64@0x1>] + >>> bv.remove_function(bv.functions[0]) + >>> bv.functions + [] + """ core.BNRemoveAnalysisFunction(self.handle, func.handle) def create_user_function(self, platform, addr): @@ -1715,33 +1732,96 @@ class BinaryView(object): wait.wait() def abort_analysis(self): + """ + ``abort_analysis`` will abort the currently running analysis. + + returns (None): + """ core.BNAbortAnalysis(self.handle) def define_data_var(self, addr, var_type): + """ + ``define_data_var`` defines a data variable ``var_type`` at the virtual address ``addr``. + + addr (int): virtual address to define the given data variable + var_type (binaryninja.Type): type to be defined at the given virtual address + + returns (None): :: + + >>> bv.define_data_var(bv.entry_point, bv.parse_type_string("int foo")[0]) + >>> t = bv.parse_type_string("int foo") + >>> t + (<type: int32_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): core.BNDefineUserDataVariable(self.handle, addr, var_type.handle) def undefine_data_var(self, addr): + """ + ``undefine_data_var`` removes the data variable at the virtual address ``addr``. + + addr (int): virtual address to define the data variable to be removed + + returns (None): :: + + >>> bv.undefine_data_var(bv.entry_point) + >>> + """ core.BNUndefineDataVariable(self.handle, addr) def undefine_user_data_var(self, addr): 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. + + addr (int): virtual address to get the data type from + + returns (binaryninja.DataVariable): returns the DataVariable at the given virtual address, None on error.:: + + >>> 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 0x100001174: int32_t> + """ 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``: + + platform (binaryninja.Platform): platform of the desired function + addr (int): virtual address of the desired function + + returns (binaryninja.Function): returns a Function object or None for the function at the virtual address provided :: + + >>> bv.get_function_at(bv.platform, bv.entry_point) + <func: x86_64@0x100001174> + >>> + """ 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. + + addr (int): virtual address of the desired Function object list. + + returns ([binaryninja.Function]): a list of binaryninja.Function objects defined at the provided virtual address + """ count = ctypes.c_ulonglong(0) funcs = core.BNGetAnalysisFunctionsForAddress(self.handle, addr, count) result = [] @@ -1757,6 +1837,9 @@ class BinaryView(object): return Function(self, func) def get_basic_blocks_at(self, addr): + """ + ``get_basic_blocks_at`` returns the binaryninja.BasicBlock + """ count = ctypes.c_ulonglong(0) blocks = core.BNGetBasicBlocksForAddress(self.handle, addr, count) result = [] |