From 7853b6eea8c80b537e2fa199a19dde0f68845449 Mon Sep 17 00:00:00 2001 From: Rusty Wagner Date: Sun, 10 Jul 2016 02:41:25 -0400 Subject: Add APIs for accessing linear disassembly --- binaryview.cpp | 110 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 110 insertions(+) (limited to 'binaryview.cpp') diff --git a/binaryview.cpp b/binaryview.cpp index a3abc02a..437c57a6 100644 --- a/binaryview.cpp +++ b/binaryview.cpp @@ -1100,6 +1100,116 @@ BNAnalysisProgress BinaryView::GetAnalysisProgress() } +uint64_t BinaryView::GetNextFunctionStartAfterAddress(uint64_t addr) +{ + return BNGetNextFunctionStartAfterAddress(m_object, addr); +} + + +uint64_t BinaryView::GetNextBasicBlockStartAfterAddress(uint64_t addr) +{ + return BNGetNextBasicBlockStartAfterAddress(m_object, addr); +} + + +uint64_t BinaryView::GetNextDataAfterAddress(uint64_t addr) +{ + return BNGetNextDataAfterAddress(m_object, addr); +} + + +LinearDisassemblyPosition BinaryView::GetLinearDisassemblyPositionForAddress(uint64_t addr) +{ + BNLinearDisassemblyPosition pos = BNGetLinearDisassemblyPositionForAddress(m_object, addr); + + LinearDisassemblyPosition result; + result.function = pos.function ? new Function(pos.function) : nullptr; + result.block = pos.block ? new BasicBlock(pos.block) : nullptr; + result.address = pos.address; + return result; +} + + +vector BinaryView::GetPreviousLinearDisassemblyLines(LinearDisassemblyPosition& pos, + DisassemblySettings* settings) +{ + BNLinearDisassemblyPosition linearPos; + linearPos.function = pos.function ? BNNewFunctionReference(pos.function->GetObject()) : nullptr; + linearPos.block = pos.block ? BNNewBasicBlockReference(pos.block->GetObject()) : nullptr; + linearPos.address = pos.address; + + size_t count; + BNLinearDisassemblyLine* lines = BNGetPreviousLinearDisassemblyLines(m_object, &linearPos, + settings ? settings->GetObject() : nullptr, &count); + + vector result; + for (size_t i = 0; i < count; i++) + { + LinearDisassemblyLine line; + line.function = lines[i].function ? new Function(BNNewFunctionReference(lines[i].function)) : nullptr; + line.block = lines[i].block ? new BasicBlock(BNNewBasicBlockReference(lines[i].block)) : nullptr; + line.lineOffset = lines[i].lineOffset; + line.contents.addr = lines[i].contents.addr; + for (size_t j = 0; j < lines[i].contents.count; j++) + { + InstructionTextToken token; + token.type = lines[i].contents.tokens[j].type; + token.text = lines[i].contents.tokens[j].text; + token.value = lines[i].contents.tokens[j].value; + line.contents.tokens.push_back(token); + } + result.push_back(line); + } + + pos.function = linearPos.function ? new Function(linearPos.function) : nullptr; + pos.block = linearPos.block ? new BasicBlock(linearPos.block) : nullptr; + pos.address = linearPos.address; + + BNFreeLinearDisassemblyLines(lines, count); + return result; +} + + +vector BinaryView::GetNextLinearDisassemblyLines(LinearDisassemblyPosition& pos, + DisassemblySettings* settings) +{ + BNLinearDisassemblyPosition linearPos; + linearPos.function = pos.function ? BNNewFunctionReference(pos.function->GetObject()) : nullptr; + linearPos.block = pos.block ? BNNewBasicBlockReference(pos.block->GetObject()) : nullptr; + linearPos.address = pos.address; + + size_t count; + BNLinearDisassemblyLine* lines = BNGetNextLinearDisassemblyLines(m_object, &linearPos, + settings ? settings->GetObject() : nullptr, &count); + + vector result; + for (size_t i = 0; i < count; i++) + { + LinearDisassemblyLine line; + line.function = lines[i].function ? new Function(BNNewFunctionReference(lines[i].function)) : nullptr; + line.block = lines[i].block ? new BasicBlock(BNNewBasicBlockReference(lines[i].block)) : nullptr; + line.lineOffset = lines[i].lineOffset; + line.contents.addr = lines[i].contents.addr; + for (size_t j = 0; j < lines[i].contents.count; j++) + { + InstructionTextToken token; + token.type = lines[i].contents.tokens[j].type; + token.text = lines[i].contents.tokens[j].text; + token.value = lines[i].contents.tokens[j].value; + line.contents.tokens.push_back(token); + } + result.push_back(line); + } + + pos.function = linearPos.function ? new Function(linearPos.function) : nullptr; + pos.block = linearPos.block ? new BasicBlock(linearPos.block) : nullptr; + pos.address = linearPos.address; + + BNFreeLinearDisassemblyLines(lines, count); + return result; +} + + BinaryData::BinaryData(FileMetadata* file): BinaryView(BNCreateBinaryDataView(file->GetObject())) { } -- cgit v1.3.1 From ae7753487db7e3cbd4d4c5b0f464a6868da42817 Mon Sep 17 00:00:00 2001 From: Rusty Wagner Date: Mon, 11 Jul 2016 04:44:55 -0400 Subject: Add APIs for querying data and code before address, and add settings parameter to linear disassembly position API --- binaryninjaapi.h | 5 ++++- binaryninjacore.h | 5 ++++- binaryview.cpp | 24 ++++++++++++++++++++++-- python/__init__.py | 17 ++++++++++++++--- 4 files changed, 44 insertions(+), 7 deletions(-) (limited to 'binaryview.cpp') diff --git a/binaryninjaapi.h b/binaryninjaapi.h index cc17f56c..a3aba4b5 100644 --- a/binaryninjaapi.h +++ b/binaryninjaapi.h @@ -854,8 +854,11 @@ namespace BinaryNinja uint64_t GetNextFunctionStartAfterAddress(uint64_t addr); uint64_t GetNextBasicBlockStartAfterAddress(uint64_t addr); uint64_t GetNextDataAfterAddress(uint64_t addr); + uint64_t GetPreviousFunctionStartBeforeAddress(uint64_t addr); + uint64_t GetPreviousStartOfDataBeforeAddress(uint64_t addr); + uint64_t GetPreviousDataBeforeAddress(uint64_t addr); - LinearDisassemblyPosition GetLinearDisassemblyPositionForAddress(uint64_t addr); + LinearDisassemblyPosition GetLinearDisassemblyPositionForAddress(uint64_t addr, DisassemblySettings* settings); std::vector GetPreviousLinearDisassemblyLines(LinearDisassemblyPosition& pos, DisassemblySettings* settings); std::vector GetNextLinearDisassemblyLines(LinearDisassemblyPosition& pos, diff --git a/binaryninjacore.h b/binaryninjacore.h index e559ec9a..bed5c0d0 100644 --- a/binaryninjacore.h +++ b/binaryninjacore.h @@ -1394,9 +1394,12 @@ extern "C" BINARYNINJACOREAPI uint64_t BNGetNextFunctionStartAfterAddress(BNBinaryView* view, uint64_t addr); BINARYNINJACOREAPI uint64_t BNGetNextBasicBlockStartAfterAddress(BNBinaryView* view, uint64_t addr); BINARYNINJACOREAPI uint64_t BNGetNextDataAfterAddress(BNBinaryView* view, uint64_t addr); + BINARYNINJACOREAPI uint64_t BNGetPreviousFunctionStartBeforeAddress(BNBinaryView* view, uint64_t addr); + BINARYNINJACOREAPI uint64_t BNGetPreviousStartOfDataBeforeAddress(BNBinaryView* view, uint64_t addr); + BINARYNINJACOREAPI uint64_t BNGetPreviousDataBeforeAddress(BNBinaryView* view, uint64_t addr); BINARYNINJACOREAPI BNLinearDisassemblyPosition BNGetLinearDisassemblyPositionForAddress(BNBinaryView* view, - uint64_t addr); + uint64_t addr, BNDisassemblySettings* settings); BINARYNINJACOREAPI void BNFreeLinearDisassemblyPosition(BNLinearDisassemblyPosition* pos); BINARYNINJACOREAPI BNLinearDisassemblyLine* BNGetPreviousLinearDisassemblyLines(BNBinaryView* view, BNLinearDisassemblyPosition* pos, BNDisassemblySettings* settings, size_t* count); diff --git a/binaryview.cpp b/binaryview.cpp index 437c57a6..03beb3db 100644 --- a/binaryview.cpp +++ b/binaryview.cpp @@ -1118,9 +1118,29 @@ uint64_t BinaryView::GetNextDataAfterAddress(uint64_t addr) } -LinearDisassemblyPosition BinaryView::GetLinearDisassemblyPositionForAddress(uint64_t addr) +uint64_t BinaryView::GetPreviousFunctionStartBeforeAddress(uint64_t addr) { - BNLinearDisassemblyPosition pos = BNGetLinearDisassemblyPositionForAddress(m_object, addr); + return BNGetPreviousFunctionStartBeforeAddress(m_object, addr); +} + + +uint64_t BinaryView::GetPreviousStartOfDataBeforeAddress(uint64_t addr) +{ + return BNGetPreviousStartOfDataBeforeAddress(m_object, addr); +} + + +uint64_t BinaryView::GetPreviousDataBeforeAddress(uint64_t addr) +{ + return BNGetPreviousDataBeforeAddress(m_object, addr); +} + + +LinearDisassemblyPosition BinaryView::GetLinearDisassemblyPositionForAddress(uint64_t addr, + DisassemblySettings* settings) +{ + BNLinearDisassemblyPosition pos = BNGetLinearDisassemblyPositionForAddress(m_object, addr, + settings ? settings->GetObject() : nullptr); LinearDisassemblyPosition result; result.function = pos.function ? new Function(pos.function) : nullptr; diff --git a/python/__init__.py b/python/__init__.py index cdced08c..ab45dfc0 100644 --- a/python/__init__.py +++ b/python/__init__.py @@ -1551,8 +1551,19 @@ class BinaryView(object): def get_next_data_after(self, addr): return core.BNGetNextDataAfterAddress(self.handle, addr) - def get_linear_disassembly_position_at(self, addr): - pos = core.BNGetLinearDisassemblyPositionForAddress(self.handle, addr) + def get_previous_function_start_before(self, addr): + return core.BNGetPreviousFunctionStartBeforeAddress(self.handle, addr) + + def get_previous_start_of_data_before(self, addr): + return core.BNGetPreviousStartOfDataBeforeAddress(self.handle, addr) + + def get_previous_data_before(self, addr): + return core.BNGetPreviousDataBeforeAddress(self.handle, addr) + + def get_linear_disassembly_position_at(self, addr, settings): + if settings is not None: + settings = settings.handle + pos = core.BNGetLinearDisassemblyPositionForAddress(self.handle, addr, settings) func = None block = None if pos.function: @@ -1622,7 +1633,7 @@ class BinaryView(object): self.settings = settings def __iter__(self): - pos = self.view.get_linear_disassembly_position_at(self.view.start) + 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: -- cgit v1.3.1 From c9612b7373f3322b90047cb4612b2cdfbba7a656 Mon Sep 17 00:00:00 2001 From: Rusty Wagner Date: Mon, 11 Jul 2016 20:50:57 -0400 Subject: Rename API to be more accurate --- binaryninjaapi.h | 2 +- binaryninjacore.h | 2 +- binaryview.cpp | 4 ++-- python/__init__.py | 4 ++-- 4 files changed, 6 insertions(+), 6 deletions(-) (limited to 'binaryview.cpp') diff --git a/binaryninjaapi.h b/binaryninjaapi.h index a3aba4b5..fedd2bf0 100644 --- a/binaryninjaapi.h +++ b/binaryninjaapi.h @@ -855,7 +855,7 @@ namespace BinaryNinja uint64_t GetNextBasicBlockStartAfterAddress(uint64_t addr); uint64_t GetNextDataAfterAddress(uint64_t addr); uint64_t GetPreviousFunctionStartBeforeAddress(uint64_t addr); - uint64_t GetPreviousStartOfDataBeforeAddress(uint64_t addr); + uint64_t GetPreviousBasicBlockEndBeforeAddress(uint64_t addr); uint64_t GetPreviousDataBeforeAddress(uint64_t addr); LinearDisassemblyPosition GetLinearDisassemblyPositionForAddress(uint64_t addr, DisassemblySettings* settings); diff --git a/binaryninjacore.h b/binaryninjacore.h index bed5c0d0..0f88972d 100644 --- a/binaryninjacore.h +++ b/binaryninjacore.h @@ -1395,7 +1395,7 @@ extern "C" BINARYNINJACOREAPI uint64_t BNGetNextBasicBlockStartAfterAddress(BNBinaryView* view, uint64_t addr); BINARYNINJACOREAPI uint64_t BNGetNextDataAfterAddress(BNBinaryView* view, uint64_t addr); BINARYNINJACOREAPI uint64_t BNGetPreviousFunctionStartBeforeAddress(BNBinaryView* view, uint64_t addr); - BINARYNINJACOREAPI uint64_t BNGetPreviousStartOfDataBeforeAddress(BNBinaryView* view, uint64_t addr); + BINARYNINJACOREAPI uint64_t BNGetPreviousBasicBlockEndBeforeAddress(BNBinaryView* view, uint64_t addr); BINARYNINJACOREAPI uint64_t BNGetPreviousDataBeforeAddress(BNBinaryView* view, uint64_t addr); BINARYNINJACOREAPI BNLinearDisassemblyPosition BNGetLinearDisassemblyPositionForAddress(BNBinaryView* view, diff --git a/binaryview.cpp b/binaryview.cpp index 03beb3db..ee01d122 100644 --- a/binaryview.cpp +++ b/binaryview.cpp @@ -1124,9 +1124,9 @@ uint64_t BinaryView::GetPreviousFunctionStartBeforeAddress(uint64_t addr) } -uint64_t BinaryView::GetPreviousStartOfDataBeforeAddress(uint64_t addr) +uint64_t BinaryView::GetPreviousBasicBlockEndBeforeAddress(uint64_t addr) { - return BNGetPreviousStartOfDataBeforeAddress(m_object, addr); + return BNGetPreviousBasicBlockEndBeforeAddress(m_object, addr); } diff --git a/python/__init__.py b/python/__init__.py index ab45dfc0..5d6be5ba 100644 --- a/python/__init__.py +++ b/python/__init__.py @@ -1554,8 +1554,8 @@ class BinaryView(object): def get_previous_function_start_before(self, addr): return core.BNGetPreviousFunctionStartBeforeAddress(self.handle, addr) - def get_previous_start_of_data_before(self, addr): - return core.BNGetPreviousStartOfDataBeforeAddress(self.handle, addr) + def get_previous_basic_block_end_before(self, addr): + return core.BNGetPreviousBasicBlockEndBeforeAddress(self.handle, addr) def get_previous_data_before(self, addr): return core.BNGetPreviousDataBeforeAddress(self.handle, addr) -- cgit v1.3.1 From c3e5c23d9f71fbb4020fe4f71a01b10734d93946 Mon Sep 17 00:00:00 2001 From: Rusty Wagner Date: Tue, 12 Jul 2016 17:05:51 -0400 Subject: Add token and line types for function headers in linear view --- binaryninjacore.h | 12 +++++++++++- binaryview.cpp | 2 ++ python/__init__.py | 5 +++-- 3 files changed, 16 insertions(+), 3 deletions(-) (limited to 'binaryview.cpp') diff --git a/binaryninjacore.h b/binaryninjacore.h index 0f88972d..223b9fac 100644 --- a/binaryninjacore.h +++ b/binaryninjacore.h @@ -159,6 +159,11 @@ extern "C" FloatingPointToken = 8, AnnotationToken = 9, CodeRelativeAddressToken = 10, + VariableTypeToken = 11, + FunctionReturnTypeToken = 12, + FunctionAttributeToken = 13, + ArgumentTypeToken = 14, + ArgumentNameToken = 15, // The following are output by the analysis system automatically, these should // not be used directly by the architecture plugins @@ -171,12 +176,17 @@ extern "C" enum BNLinearDisassemblyLineType { + BlankLineType, CodeDisassemblyLineType, DataVariableLineType, HexDumpLineType, FunctionHeaderLineType, + FunctionHeaderStartLineType, + FunctionHeaderEndLineType, FunctionContinuationLineType, - StackVariableLineType + StackVariableLineType, + StackVariableListEndLineType, + FunctionEndLineType }; enum BNSymbolType diff --git a/binaryview.cpp b/binaryview.cpp index ee01d122..864b4687 100644 --- a/binaryview.cpp +++ b/binaryview.cpp @@ -1166,6 +1166,7 @@ vector BinaryView::GetPreviousLinearDisassemblyLines(Line for (size_t i = 0; i < count; i++) { LinearDisassemblyLine line; + line.type = lines[i].type; line.function = lines[i].function ? new Function(BNNewFunctionReference(lines[i].function)) : nullptr; line.block = lines[i].block ? new BasicBlock(BNNewBasicBlockReference(lines[i].block)) : nullptr; line.lineOffset = lines[i].lineOffset; @@ -1206,6 +1207,7 @@ vector BinaryView::GetNextLinearDisassemblyLines(LinearDi for (size_t i = 0; i < count; i++) { LinearDisassemblyLine line; + line.type = lines[i].type; line.function = lines[i].function ? new Function(BNNewFunctionReference(lines[i].function)) : nullptr; line.block = lines[i].block ? new BasicBlock(BNNewBasicBlockReference(lines[i].block)) : nullptr; line.lineOffset = lines[i].lineOffset; diff --git a/python/__init__.py b/python/__init__.py index 5d6be5ba..f2be8758 100644 --- a/python/__init__.py +++ b/python/__init__.py @@ -683,7 +683,8 @@ class LinearDisassemblyPosition(object): self.address = addr class LinearDisassemblyLine(object): - def __init__(self, func, block, line_offset, contents): + 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 @@ -1604,7 +1605,7 @@ class BinaryView(object): value = lines[i].contents.tokens[j].value tokens.append(InstructionTextToken(token_type, text, value)) contents = DisassemblyTextLine(addr, tokens) - result.append(LinearDisassemblyLine(func, block, lines[i].lineOffset, contents)) + result.append(LinearDisassemblyLine(lines[i].type, func, block, lines[i].lineOffset, contents)) func = None block = None -- cgit v1.3.1 From b2faff7bd9112a878b5fca33048fdbab2fb52045 Mon Sep 17 00:00:00 2001 From: Rusty Wagner Date: Tue, 19 Jul 2016 01:28:31 -0400 Subject: Adding APIs for data variables --- binaryninjaapi.h | 18 +++++++++++++++- binaryninjacore.h | 17 +++++++++++++++ binaryview.cpp | 61 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ python/__init__.py | 47 +++++++++++++++++++++++++++++++++++++++++ 4 files changed, 142 insertions(+), 1 deletion(-) (limited to 'binaryview.cpp') diff --git a/binaryninjaapi.h b/binaryninjaapi.h index 18a379c3..d1d8eeb5 100644 --- a/binaryninjaapi.h +++ b/binaryninjaapi.h @@ -665,6 +665,13 @@ namespace BinaryNinja void Cancel(); }; + struct DataVariable + { + uint64_t address; + Ref type; + bool autoDiscovered; + }; + /*! BinaryView is the base class for creating views on binary data (e.g. ELF, PE, Mach-O). BinaryView should be subclassed to create a new BinaryView */ @@ -803,6 +810,14 @@ namespace BinaryNinja void UpdateAnalysis(); void AbortAnalysis(); + void DefineDataVariable(uint64_t addr, Type* type); + void DefineUserDataVariable(uint64_t addr, Type* type); + void UndefineDataVariable(uint64_t addr); + void UndefineUserDataVariable(uint64_t addr); + + std::map GetDataVariables(); + bool GetDataVariableAtAddress(uint64_t addr, DataVariable& var); + std::vector> GetAnalysisFunctionList(); bool HasFunctions() const; Ref GetAnalysisFunction(Platform* platform, uint64_t addr); @@ -832,7 +847,6 @@ namespace BinaryNinja void DefineImportedFunction(Symbol* importAddressSym, Function* func); - bool IsNeverBranchPatchAvailable(Architecture* arch, uint64_t addr); bool IsAlwaysBranchPatchAvailable(Architecture* arch, uint64_t addr); bool IsInvertBranchPatchAvailable(Architecture* arch, uint64_t addr); @@ -854,9 +868,11 @@ namespace BinaryNinja uint64_t GetNextFunctionStartAfterAddress(uint64_t addr); uint64_t GetNextBasicBlockStartAfterAddress(uint64_t addr); uint64_t GetNextDataAfterAddress(uint64_t addr); + uint64_t GetNextDataVariableAfterAddress(uint64_t addr); uint64_t GetPreviousFunctionStartBeforeAddress(uint64_t addr); uint64_t GetPreviousBasicBlockEndBeforeAddress(uint64_t addr); uint64_t GetPreviousDataBeforeAddress(uint64_t addr); + uint64_t GetPreviousDataVariableBeforeAddress(uint64_t addr); LinearDisassemblyPosition GetLinearDisassemblyPositionForAddress(uint64_t addr, DisassemblySettings* settings); std::vector GetPreviousLinearDisassemblyLines(LinearDisassemblyPosition& pos, diff --git a/binaryninjacore.h b/binaryninjacore.h index ac9e9da9..9af53442 100644 --- a/binaryninjacore.h +++ b/binaryninjacore.h @@ -930,6 +930,13 @@ extern "C" size_t count, total; }; + struct BNDataVariable + { + uint64_t address; + BNType* type; + bool autoDiscovered; + }; + BINARYNINJACOREAPI char* BNAllocString(const char* contents); BINARYNINJACOREAPI void BNFreeString(char* str); @@ -1417,9 +1424,11 @@ extern "C" BINARYNINJACOREAPI uint64_t BNGetNextFunctionStartAfterAddress(BNBinaryView* view, uint64_t addr); BINARYNINJACOREAPI uint64_t BNGetNextBasicBlockStartAfterAddress(BNBinaryView* view, uint64_t addr); BINARYNINJACOREAPI uint64_t BNGetNextDataAfterAddress(BNBinaryView* view, uint64_t addr); + BINARYNINJACOREAPI uint64_t BNGetNextDataVariableAfterAddress(BNBinaryView* view, uint64_t addr); BINARYNINJACOREAPI uint64_t BNGetPreviousFunctionStartBeforeAddress(BNBinaryView* view, uint64_t addr); BINARYNINJACOREAPI uint64_t BNGetPreviousBasicBlockEndBeforeAddress(BNBinaryView* view, uint64_t addr); BINARYNINJACOREAPI uint64_t BNGetPreviousDataBeforeAddress(BNBinaryView* view, uint64_t addr); + BINARYNINJACOREAPI uint64_t BNGetPreviousDataVariableBeforeAddress(BNBinaryView* view, uint64_t addr); BINARYNINJACOREAPI BNLinearDisassemblyPosition BNGetLinearDisassemblyPositionForAddress(BNBinaryView* view, uint64_t addr, BNDisassemblySettings* settings); @@ -1430,6 +1439,14 @@ extern "C" BNLinearDisassemblyPosition* pos, BNDisassemblySettings* settings, size_t* count); BINARYNINJACOREAPI void BNFreeLinearDisassemblyLines(BNLinearDisassemblyLine* lines, size_t count); + BINARYNINJACOREAPI void BNDefineDataVariable(BNBinaryView* view, uint64_t addr, BNType* type); + BINARYNINJACOREAPI void BNDefineUserDataVariable(BNBinaryView* view, uint64_t addr, BNType* type); + BINARYNINJACOREAPI void BNUndefineDataVariable(BNBinaryView* view, uint64_t addr); + BINARYNINJACOREAPI void BNUndefineUserDataVariable(BNBinaryView* view, uint64_t addr); + BINARYNINJACOREAPI BNDataVariable* BNGetDataVariables(BNBinaryView* view, size_t* count); + BINARYNINJACOREAPI void BNFreeDataVariables(BNDataVariable* vars, size_t count); + BINARYNINJACOREAPI bool BNGetDataVariableAtAddress(BNBinaryView* view, uint64_t addr, BNDataVariable* var); + // Disassembly settings BINARYNINJACOREAPI BNDisassemblySettings* BNCreateDisassemblySettings(void); BINARYNINJACOREAPI BNDisassemblySettings* BNNewDisassemblySettingsReference(BNDisassemblySettings* settings); diff --git a/binaryview.cpp b/binaryview.cpp index 864b4687..6d96c8ea 100644 --- a/binaryview.cpp +++ b/binaryview.cpp @@ -764,6 +764,67 @@ void BinaryView::AbortAnalysis() } +void BinaryView::DefineDataVariable(uint64_t addr, Type* type) +{ + BNDefineDataVariable(m_object, addr, type->GetObject()); +} + + +void BinaryView::DefineUserDataVariable(uint64_t addr, Type* type) +{ + BNDefineUserDataVariable(m_object, addr, type->GetObject()); +} + + +void BinaryView::UndefineDataVariable(uint64_t addr) +{ + BNUndefineDataVariable(m_object, addr); +} + + +void BinaryView::UndefineUserDataVariable(uint64_t addr) +{ + BNUndefineUserDataVariable(m_object, addr); +} + + +map BinaryView::GetDataVariables() +{ + size_t count; + BNDataVariable* vars = BNGetDataVariables(m_object, &count); + + map result; + for (size_t i = 0; i < count; i++) + { + DataVariable var; + var.address = vars[i].address; + var.type = new Type(BNNewTypeReference(vars[i].type)); + var.autoDiscovered = vars[i].autoDiscovered; + result[var.address] = var; + } + + BNFreeDataVariables(vars, count); + return result; +} + + +bool BinaryView::GetDataVariableAtAddress(uint64_t addr, DataVariable& var) +{ + var.address = 0; + var.type = nullptr; + var.autoDiscovered = false; + + BNDataVariable result; + if (!BNGetDataVariableAtAddress(m_object, addr, &result)) + return false; + + var.address = result.address; + var.type = new Type(result.type); + var.autoDiscovered = result.autoDiscovered; + return true; +} + + vector> BinaryView::GetAnalysisFunctionList() { size_t count; diff --git a/python/__init__.py b/python/__init__.py index 390c4efd..0d9c15a2 100644 --- a/python/__init__.py +++ b/python/__init__.py @@ -696,6 +696,15 @@ class LinearDisassemblyLine(object): 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 BinaryView(object): name = None """Binary View name""" @@ -994,6 +1003,20 @@ class BinaryView(object): """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 + def __len__(self): return int(core.BNGetViewLength(self.handle)) @@ -1367,6 +1390,24 @@ class BinaryView(object): def abort_analysis(self): core.BNAbortAnalysis(self.handle) + def define_data_var(self, addr, var_type): + 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): + core.BNUndefineDataVariable(self.handle, addr) + + def undefine_user_data_var(self, addr): + core.BNUndefineUserDataVariable(self.handle, addr) + + def get_data_var_at(self, addr): + 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): func = core.BNGetAnalysisFunction(self.handle, platform.handle, addr) if func is None: @@ -1552,6 +1593,9 @@ class BinaryView(object): def get_next_data_after(self, addr): return core.BNGetNextDataAfterAddress(self.handle, addr) + def get_next_data_var_after(self, addr): + return core.BNGetNextDataVariableAfterAddress(self.handle, addr) + def get_previous_function_start_before(self, addr): return core.BNGetPreviousFunctionStartBeforeAddress(self.handle, addr) @@ -1561,6 +1605,9 @@ class BinaryView(object): def get_previous_data_before(self, addr): return core.BNGetPreviousDataBeforeAddress(self.handle, addr) + def get_previous_data_var_before(self, addr): + return core.BNGetPreviousDataVariableBeforeAddress(self.handle, addr) + def get_linear_disassembly_position_at(self, addr, settings): if settings is not None: settings = settings.handle -- cgit v1.3.1 From 5fe41897d085a4fe39135fdcc7ec60a24d1799cd Mon Sep 17 00:00:00 2001 From: Rusty Wagner Date: Wed, 20 Jul 2016 01:24:51 -0400 Subject: Add notifications for data variables --- binaryninjaapi.h | 7 +++++++ binaryninjacore.h | 18 +++++++++++------- binaryview.cpp | 39 +++++++++++++++++++++++++++++++++++++++ python/__init__.py | 39 +++++++++++++++++++++++++++++++++++++++ 4 files changed, 96 insertions(+), 7 deletions(-) (limited to 'binaryview.cpp') diff --git a/binaryninjaapi.h b/binaryninjaapi.h index d1d8eeb5..94e888d3 100644 --- a/binaryninjaapi.h +++ b/binaryninjaapi.h @@ -523,6 +523,7 @@ namespace BinaryNinja class BinaryView; class Function; + struct DataVariable; class BinaryDataNotification { @@ -535,6 +536,9 @@ namespace BinaryNinja static void FunctionAddedCallback(void* ctxt, BNBinaryView* data, BNFunction* func); static void FunctionRemovedCallback(void* ctxt, BNBinaryView* data, BNFunction* func); static void FunctionUpdatedCallback(void* ctxt, BNBinaryView* data, BNFunction* func); + static void DataVariableAddedCallback(void* ctxt, BNBinaryView* data, BNDataVariable* var); + static void DataVariableRemovedCallback(void* ctxt, BNBinaryView* data, BNDataVariable* var); + static void DataVariableUpdatedCallback(void* ctxt, BNBinaryView* data, BNDataVariable* var); static void StringFoundCallback(void* ctxt, BNBinaryView* data, BNStringType type, uint64_t offset, size_t len); static void StringRemovedCallback(void* ctxt, BNBinaryView* data, BNStringType type, uint64_t offset, size_t len); @@ -550,6 +554,9 @@ namespace BinaryNinja virtual void OnAnalysisFunctionAdded(BinaryView* view, Function* func) { (void)view; (void)func; } virtual void OnAnalysisFunctionRemoved(BinaryView* view, Function* func) { (void)view; (void)func; } virtual void OnAnalysisFunctionUpdated(BinaryView* view, Function* func) { (void)view; (void)func; } + virtual void OnDataVariableAdded(BinaryView* view, const DataVariable& var) { (void)view; (void)var; } + virtual void OnDataVariableRemoved(BinaryView* view, const DataVariable& var) { (void)view; (void)var; } + virtual void OnDataVariableUpdated(BinaryView* view, const DataVariable& var) { (void)view; (void)var; } virtual void OnStringFound(BinaryView* data, BNStringType type, uint64_t offset, size_t len) { (void)data; (void)type; (void)offset; (void)len; } virtual void OnStringRemoved(BinaryView* data, BNStringType type, uint64_t offset, size_t len) { (void)data; (void)type; (void)offset; (void)len; } }; diff --git a/binaryninjacore.h b/binaryninjacore.h index 9af53442..d667d12a 100644 --- a/binaryninjacore.h +++ b/binaryninjacore.h @@ -171,6 +171,7 @@ extern "C" HexDumpInvalidByteToken = 18, HexDumpTextToken = 19, OpcodeToken = 20, + StringToken = 21, // The following are output by the analysis system automatically, these should // not be used directly by the architecture plugins @@ -556,6 +557,13 @@ extern "C" uint64_t value; }; + struct BNDataVariable + { + uint64_t address; + BNType* type; + bool autoDiscovered; + }; + // Callbacks struct BNLogListener { @@ -582,6 +590,9 @@ extern "C" void (*functionAdded)(void* ctxt, BNBinaryView* view, BNFunction* func); void (*functionRemoved)(void* ctxt, BNBinaryView* view, BNFunction* func); void (*functionUpdated)(void* ctxt, BNBinaryView* view, BNFunction* func); + void (*dataVariableAdded)(void* ctxt, BNBinaryView* view, BNDataVariable* var); + void (*dataVariableRemoved)(void* ctxt, BNBinaryView* view, BNDataVariable* var); + void (*dataVariableUpdated)(void* ctxt, BNBinaryView* view, BNDataVariable* var); void (*stringFound)(void* ctxt, BNBinaryView* view, BNStringType type, uint64_t offset, size_t len); void (*stringRemoved)(void* ctxt, BNBinaryView* view, BNStringType type, uint64_t offset, size_t len); }; @@ -930,13 +941,6 @@ extern "C" size_t count, total; }; - struct BNDataVariable - { - uint64_t address; - BNType* type; - bool autoDiscovered; - }; - BINARYNINJACOREAPI char* BNAllocString(const char* contents); BINARYNINJACOREAPI void BNFreeString(char* str); diff --git a/binaryview.cpp b/binaryview.cpp index 6d96c8ea..6c84a69b 100644 --- a/binaryview.cpp +++ b/binaryview.cpp @@ -75,6 +75,42 @@ void BinaryDataNotification::FunctionUpdatedCallback(void* ctxt, BNBinaryView* o } +void BinaryDataNotification::DataVariableAddedCallback(void* ctxt, BNBinaryView* object, BNDataVariable* var) +{ + BinaryDataNotification* notify = (BinaryDataNotification*)ctxt; + Ref view = new BinaryView(BNNewViewReference(object)); + DataVariable varObj; + varObj.address = var->address; + varObj.type = new Type(BNNewTypeReference(var->type)); + varObj.autoDiscovered = var->autoDiscovered; + notify->OnDataVariableAdded(view, varObj); +} + + +void BinaryDataNotification::DataVariableRemovedCallback(void* ctxt, BNBinaryView* object, BNDataVariable* var) +{ + BinaryDataNotification* notify = (BinaryDataNotification*)ctxt; + Ref view = new BinaryView(BNNewViewReference(object)); + DataVariable varObj; + varObj.address = var->address; + varObj.type = new Type(BNNewTypeReference(var->type)); + varObj.autoDiscovered = var->autoDiscovered; + notify->OnDataVariableRemoved(view, varObj); +} + + +void BinaryDataNotification::DataVariableUpdatedCallback(void* ctxt, BNBinaryView* object, BNDataVariable* var) +{ + BinaryDataNotification* notify = (BinaryDataNotification*)ctxt; + Ref view = new BinaryView(BNNewViewReference(object)); + DataVariable varObj; + varObj.address = var->address; + varObj.type = new Type(BNNewTypeReference(var->type)); + varObj.autoDiscovered = var->autoDiscovered; + notify->OnDataVariableUpdated(view, varObj); +} + + void BinaryDataNotification::StringFoundCallback(void* ctxt, BNBinaryView* object, BNStringType type, uint64_t offset, size_t len) { BinaryDataNotification* notify = (BinaryDataNotification*)ctxt; @@ -100,6 +136,9 @@ BinaryDataNotification::BinaryDataNotification() m_callbacks.functionAdded = FunctionAddedCallback; m_callbacks.functionRemoved = FunctionRemovedCallback; m_callbacks.functionUpdated = FunctionUpdatedCallback; + m_callbacks.dataVariableAdded = DataVariableAddedCallback; + m_callbacks.dataVariableRemoved = DataVariableRemovedCallback; + m_callbacks.dataVariableUpdated = DataVariableUpdatedCallback; m_callbacks.stringFound = StringFoundCallback; m_callbacks.stringRemoved = StringRemovedCallback; } diff --git a/python/__init__.py b/python/__init__.py index 0d9c15a2..7564ee98 100644 --- a/python/__init__.py +++ b/python/__init__.py @@ -387,6 +387,15 @@ class BinaryDataNotification: 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 @@ -483,6 +492,9 @@ class BinaryDataNotificationCallbacks: 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) @@ -528,6 +540,33 @@ class BinaryDataNotificationCallbacks: 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) -- cgit v1.3.1 From 5e15a16c95dd3e0b48ea0b319a813720f14fec5a Mon Sep 17 00:00:00 2001 From: Rusty Wagner Date: Wed, 20 Jul 2016 18:54:57 -0400 Subject: Add API for previous start of basic block --- binaryninjaapi.h | 1 + binaryninjacore.h | 1 + binaryview.cpp | 6 ++++++ python/__init__.py | 3 +++ 4 files changed, 11 insertions(+) (limited to 'binaryview.cpp') diff --git a/binaryninjaapi.h b/binaryninjaapi.h index 94e888d3..b4606596 100644 --- a/binaryninjaapi.h +++ b/binaryninjaapi.h @@ -877,6 +877,7 @@ namespace BinaryNinja uint64_t GetNextDataAfterAddress(uint64_t addr); uint64_t GetNextDataVariableAfterAddress(uint64_t addr); uint64_t GetPreviousFunctionStartBeforeAddress(uint64_t addr); + uint64_t GetPreviousBasicBlockStartBeforeAddress(uint64_t addr); uint64_t GetPreviousBasicBlockEndBeforeAddress(uint64_t addr); uint64_t GetPreviousDataBeforeAddress(uint64_t addr); uint64_t GetPreviousDataVariableBeforeAddress(uint64_t addr); diff --git a/binaryninjacore.h b/binaryninjacore.h index d667d12a..ac4fa0a3 100644 --- a/binaryninjacore.h +++ b/binaryninjacore.h @@ -1430,6 +1430,7 @@ extern "C" BINARYNINJACOREAPI uint64_t BNGetNextDataAfterAddress(BNBinaryView* view, uint64_t addr); BINARYNINJACOREAPI uint64_t BNGetNextDataVariableAfterAddress(BNBinaryView* view, uint64_t addr); BINARYNINJACOREAPI uint64_t BNGetPreviousFunctionStartBeforeAddress(BNBinaryView* view, uint64_t addr); + BINARYNINJACOREAPI uint64_t BNGetPreviousBasicBlockStartBeforeAddress(BNBinaryView* view, uint64_t addr); BINARYNINJACOREAPI uint64_t BNGetPreviousBasicBlockEndBeforeAddress(BNBinaryView* view, uint64_t addr); BINARYNINJACOREAPI uint64_t BNGetPreviousDataBeforeAddress(BNBinaryView* view, uint64_t addr); BINARYNINJACOREAPI uint64_t BNGetPreviousDataVariableBeforeAddress(BNBinaryView* view, uint64_t addr); diff --git a/binaryview.cpp b/binaryview.cpp index 6c84a69b..ab519297 100644 --- a/binaryview.cpp +++ b/binaryview.cpp @@ -1224,6 +1224,12 @@ uint64_t BinaryView::GetPreviousFunctionStartBeforeAddress(uint64_t addr) } +uint64_t BinaryView::GetPreviousBasicBlockStartBeforeAddress(uint64_t addr) +{ + return BNGetPreviousBasicBlockStartBeforeAddress(m_object, addr); +} + + uint64_t BinaryView::GetPreviousBasicBlockEndBeforeAddress(uint64_t addr) { return BNGetPreviousBasicBlockEndBeforeAddress(m_object, addr); diff --git a/python/__init__.py b/python/__init__.py index 7564ee98..fd4af520 100644 --- a/python/__init__.py +++ b/python/__init__.py @@ -1638,6 +1638,9 @@ class BinaryView(object): def get_previous_function_start_before(self, addr): return core.BNGetPreviousFunctionStartBeforeAddress(self.handle, addr) + def get_previous_basic_block_start_before(self, addr): + return core.BNGetPreviousBasicBlockStartBeforeAddress(self.handle, addr) + def get_previous_basic_block_end_before(self, addr): return core.BNGetPreviousBasicBlockEndBeforeAddress(self.handle, addr) -- cgit v1.3.1 From 13491e5eb8d50c242cf6858b111e404ea9f79239 Mon Sep 17 00:00:00 2001 From: Rusty Wagner Date: Fri, 22 Jul 2016 03:00:52 -0400 Subject: Add API to set type of function --- binaryninjaapi.h | 6 ++++++ binaryninjacore.h | 28 +++++++++++++++++----------- binaryview.cpp | 20 ++++++++++++++++++++ function.cpp | 12 ++++++++++++ python/__init__.py | 26 ++++++++++++++++++++++++-- 5 files changed, 79 insertions(+), 13 deletions(-) (limited to 'binaryview.cpp') diff --git a/binaryninjaapi.h b/binaryninjaapi.h index b4606596..85a0fc41 100644 --- a/binaryninjaapi.h +++ b/binaryninjaapi.h @@ -679,6 +679,8 @@ namespace BinaryNinja bool autoDiscovered; }; + struct NameAndType; + /*! BinaryView is the base class for creating views on binary data (e.g. ELF, PE, Mach-O). BinaryView should be subclassed to create a new BinaryView */ @@ -887,6 +889,8 @@ namespace BinaryNinja DisassemblySettings* settings); std::vector GetNextLinearDisassemblyLines(LinearDisassemblyPosition& pos, DisassemblySettings* settings); + + bool ParseTypeString(const std::string& text, NameAndType& result, std::string& errors); }; class BinaryData: public BinaryView @@ -1612,6 +1616,8 @@ namespace BinaryNinja std::set GetFlagsWrittenByLiftedILInstruction(size_t i); Ref GetType() const; + void SetAutoType(Type* type); + void SetUserType(Type* type); void ApplyImportedTypes(Symbol* sym); void ApplyAutoDiscoveredType(Type* type); diff --git a/binaryninjacore.h b/binaryninjacore.h index ac4fa0a3..837a99e1 100644 --- a/binaryninjacore.h +++ b/binaryninjacore.h @@ -161,17 +161,18 @@ extern "C" FloatingPointToken = 8, AnnotationToken = 9, CodeRelativeAddressToken = 10, - VariableTypeToken = 11, - FunctionReturnTypeToken = 12, - FunctionAttributeToken = 13, - ArgumentTypeToken = 14, - ArgumentNameToken = 15, - HexDumpByteValueToken = 16, - HexDumpSkippedByteToken = 17, - HexDumpInvalidByteToken = 18, - HexDumpTextToken = 19, - OpcodeToken = 20, - StringToken = 21, + StackVariableTypeToken = 11, + DataVariableTypeToken = 12, + FunctionReturnTypeToken = 13, + FunctionAttributeToken = 14, + ArgumentTypeToken = 15, + ArgumentNameToken = 16, + HexDumpByteValueToken = 17, + HexDumpSkippedByteToken = 18, + HexDumpInvalidByteToken = 19, + HexDumpTextToken = 20, + OpcodeToken = 21, + StringToken = 22, // The following are output by the analysis system automatically, these should // not be used directly by the architecture plugins @@ -1309,6 +1310,8 @@ extern "C" BINARYNINJACOREAPI BNSymbol* BNGetFunctionSymbol(BNFunction* func); BINARYNINJACOREAPI bool BNWasFunctionAutomaticallyDiscovered(BNFunction* func); BINARYNINJACOREAPI bool BNCanFunctionReturn(BNFunction* func); + BINARYNINJACOREAPI void BNSetFunctionAutoType(BNFunction* func, BNType* type); + BINARYNINJACOREAPI void BNSetFunctionUserType(BNFunction* func, BNType* type); BINARYNINJACOREAPI char* BNGetCommentForAddress(BNFunction* func, uint64_t addr); BINARYNINJACOREAPI uint64_t* BNGetCommentedAddresses(BNFunction* func, size_t* count); @@ -1452,6 +1455,9 @@ extern "C" BINARYNINJACOREAPI void BNFreeDataVariables(BNDataVariable* vars, size_t count); BINARYNINJACOREAPI bool BNGetDataVariableAtAddress(BNBinaryView* view, uint64_t addr, BNDataVariable* var); + BINARYNINJACOREAPI bool BNParseTypeString(BNBinaryView* view, const char* text, BNNameAndType* result, char** errors); + BINARYNINJACOREAPI void BNFreeNameAndType(BNNameAndType* obj); + // Disassembly settings BINARYNINJACOREAPI BNDisassemblySettings* BNCreateDisassemblySettings(void); BINARYNINJACOREAPI BNDisassemblySettings* BNNewDisassemblySettingsReference(BNDisassemblySettings* settings); diff --git a/binaryview.cpp b/binaryview.cpp index ab519297..ee5bda8e 100644 --- a/binaryview.cpp +++ b/binaryview.cpp @@ -1338,6 +1338,26 @@ vector BinaryView::GetNextLinearDisassemblyLines(LinearDi } +bool BinaryView::ParseTypeString(const string& text, NameAndType& result, string& errors) +{ + BNNameAndType nt; + char* errorStr; + + if (!BNParseTypeString(m_object, text.c_str(), &nt, &errorStr)) + { + errors = errorStr; + BNFreeString(errorStr); + return false; + } + + result.name = nt.name; + result.type = new Type(nt.type); + errors = ""; + BNFreeString(nt.name); + return true; +} + + BinaryData::BinaryData(FileMetadata* file): BinaryView(BNCreateBinaryDataView(file->GetObject())) { } diff --git a/function.cpp b/function.cpp index ea0fec86..55f5cffb 100644 --- a/function.cpp +++ b/function.cpp @@ -354,6 +354,18 @@ Ref Function::GetType() const } +void Function::SetAutoType(Type* type) +{ + BNSetFunctionAutoType(m_object, type->GetObject()); +} + + +void Function::SetUserType(Type* type) +{ + BNSetFunctionUserType(m_object, type->GetObject()); +} + + void Function::ApplyImportedTypes(Symbol* sym) { BNApplyImportedTypes(m_object, sym->GetObject()); diff --git a/python/__init__.py b/python/__init__.py index fd4af520..9f090c2f 100644 --- a/python/__init__.py +++ b/python/__init__.py @@ -1733,6 +1733,18 @@ class BinaryView(object): return iter(LinearDisassemblyIterator(self, settings)) + def parse_type_string(self, text): + 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 __setattr__(self, name, value): try: object.__setattr__(self,name,value) @@ -2523,10 +2535,14 @@ class Function(object): core.BNGetFunctionLiftedIL(self.handle)), self) @property - def type(self): - """Function type (read-only)""" + 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)""" @@ -2783,6 +2799,12 @@ class Function(object): 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) + class BasicBlockEdge: def __init__(self, branch_type, target, arch): self.type = core.BNBranchType_names[branch_type] -- cgit v1.3.1