Add derived strings and string recognizer API

Author: D0ntPanic

binaryninjaapi.h

@@ -4074,6 +4074,7 @@ namespace BinaryNinja {
 	class Segment;
 	class Component;
 	class TypeArchive;
+	struct DerivedString;
 
 	/*!
 
@@ -4107,6 +4108,8 @@ namespace BinaryNinja {
 
 		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);
+		static void DerivedStringFoundCallback(void* ctxt, BNBinaryView* data, BNDerivedString* str);
+		static void DerivedStringRemovedCallback(void* ctxt, BNBinaryView* data, BNDerivedString* str);
 		static void TypeDefinedCallback(void* ctxt, BNBinaryView* data, BNQualifiedName* name, BNType* type);
 		static void TypeUndefinedCallback(void* ctxt, BNBinaryView* data, BNQualifiedName* name, BNType* type);
 		static void TypeReferenceChangedCallback(void* ctx, BNBinaryView* data, BNQualifiedName* name, BNType* type);
@@ -4203,6 +4206,8 @@ namespace BinaryNinja {
 			UndoEntryTaken = 1ULL << 50,
 			RedoEntryTaken = 1ULL << 51,
 			Rebased = 1ULL << 52,
+			DerivedStringFound = 1ULL << 53,
+			DerivedStringRemoved = 1ULL << 54,
 
 			BinaryDataUpdates = DataWritten | DataInserted | DataRemoved,
 			FunctionLifetime = FunctionAdded | FunctionRemoved,
@@ -4213,7 +4218,7 @@ namespace BinaryNinja {
 			TagUpdates = TagLifetime | TagUpdated,
 			SymbolLifetime = SymbolAdded | SymbolRemoved,
 			SymbolUpdates = SymbolLifetime | SymbolUpdated,
-			StringUpdates = StringFound | StringRemoved,
+			StringUpdates = StringFound | StringRemoved | DerivedStringFound | DerivedStringRemoved,
 			TypeLifetime = TypeDefined | TypeUndefined,
 			TypeUpdates = TypeLifetime | TypeReferenceChanged | TypeFieldReferenceChanged,
 			SegmentLifetime = SegmentAdded | SegmentRemoved,
@@ -4350,6 +4355,16 @@ namespace BinaryNinja {
 			(void)offset;
 			(void)len;
 		}
+		virtual void OnDerivedStringFound(BinaryView* data, const DerivedString& str)
+		{
+			(void)data;
+			(void)str;
+		}
+		virtual void OnDerivedStringRemoved(BinaryView* data, const DerivedString& str)
+		{
+			(void)data;
+			(void)str;
+		}
 		virtual void OnTypeDefined(BinaryView* data, const QualifiedName& name, Type* type)
 		{
 			(void)data;
@@ -4823,7 +4838,7 @@ namespace BinaryNinja {
 
 		const char* c_str() const;
 		size_t size() const;
-		BNStringRef* GetObject() { return m_ref; }
+		BNStringRef* GetObject() const { return m_ref; }
 
 		bool operator==(const StringRef& other) const { return this->operator std::string_view() == other.operator std::string_view(); }
 		bool operator!=(const StringRef& other) const { return this->operator std::string_view() != other.operator std::string_view(); }
@@ -5357,6 +5372,47 @@ namespace BinaryNinja {
 		std::vector<TypeReferenceSource> typeRefs;
 	};
 
+	class CustomStringType: public StaticCoreRefCountObject<BNCustomStringType>
+	{
+	public:
+		CustomStringType(BNCustomStringType* type);
+		std::string GetName() const;
+		std::string GetStringPrefix() const;
+		std::string GetStringPostfix() const;
+
+		static Ref<CustomStringType> Register(
+			const std::string& name, const std::string& stringPrefix = "", const std::string& stringPostfix = "");
+	};
+
+	struct DerivedString
+	{
+		StringRef value;
+		std::optional<std::pair<uint64_t, uint64_t>> addrAndLength;
+		Ref<CustomStringType> customType;
+
+		bool operator==(const DerivedString& other) const
+		{
+			if (value != other.value)
+				return false;
+			if (addrAndLength != other.addrAndLength)
+				return false;
+			return customType == other.customType;
+		}
+
+		bool operator<(const DerivedString& other) const
+		{
+			if (value < other.value)
+				return true;
+			if (other.value < value)
+				return false;
+			if (addrAndLength < other.addrAndLength)
+				return true;
+			if (other.addrAndLength < addrAndLength)
+				return false;
+			return customType < other.customType;
+		}
+	};
+
 	struct QualifiedNameAndType;
 	struct PossibleValueSet;
 	class Metadata;
@@ -7132,6 +7188,10 @@ namespace BinaryNinja {
 		*/
 		std::vector<BNStringReference> GetStrings(uint64_t start, uint64_t len);
 
+		std::vector<DerivedString> GetDerivedStrings();
+		std::vector<ReferenceSource> GetDerivedStringCodeReferences(
+			const DerivedString& str, std::optional<size_t> maxItems = std::nullopt);
+
 		/*! Sets up a call back function to be called when analysis has been completed.
 
 			This is helpful when using `UpdateAnalysis` which does not wait for analysis completion before returning.
@@ -15441,6 +15501,10 @@ namespace BinaryNinja {
 		std::set<Variable> GetVariables();
 		std::set<Variable> GetAliasedVariables();
 		std::set<SSAVariable> GetSSAVariables();
+
+		void SetDerivedStringReferenceForExpr(size_t expr, const DerivedString& str);
+		void RemoveDerivedStringReferenceForExpr(size_t expr);
+		std::optional<DerivedString> GetDerivedStringReferenceForExpr(size_t expr);
 	};
 
 	struct LineFormatterSettings
@@ -21320,6 +21384,62 @@ namespace BinaryNinja {
 			HighLevelILTokenEmitter& tokens, DisassemblySettings* settings, BNSymbolDisplayType symbolDisplay,
 			BNOperatorPrecedence precedence) override;
 	};
+
+	class StringRecognizer : public StaticCoreRefCountObject<BNStringRecognizer>
+	{
+		std::string m_nameForRegister;
+
+	public:
+		StringRecognizer(const std::string& name);
+		StringRecognizer(BNStringRecognizer* renderer);
+
+		std::string GetName() const;
+
+		virtual bool IsValidForType(HighLevelILFunction* func, Type* type);
+		virtual std::optional<DerivedString> RecognizeConstant(
+			const HighLevelILInstruction& instr, Type* type, int64_t val);
+		virtual std::optional<DerivedString> RecognizeConstantPointer(
+			const HighLevelILInstruction& instr, Type* type, int64_t val);
+		virtual std::optional<DerivedString> RecognizeExternPointer(
+			const HighLevelILInstruction& instr, Type* type, int64_t val, uint64_t offset);
+		virtual std::optional<DerivedString> RecognizeImport(
+			const HighLevelILInstruction& instr, Type* type, int64_t val);
+
+		/*! Registers the string recognizer.
+
+		    \param recognizer The string recognizer to register.
+		*/
+		static void Register(StringRecognizer* recognizer);
+
+		static Ref<StringRecognizer> GetByName(const std::string& name);
+		static std::vector<Ref<StringRecognizer>> GetRecognizers();
+
+	private:
+		static bool IsValidForTypeCallback(void* ctxt, BNHighLevelILFunction* hlil, BNType* type);
+		static bool RecognizeConstantCallback(
+			void* ctxt, BNHighLevelILFunction* hlil, size_t expr, BNType* type, int64_t val, BNDerivedString* result);
+		static bool RecognizeConstantPointerCallback(
+			void* ctxt, BNHighLevelILFunction* hlil, size_t expr, BNType* type, int64_t val, BNDerivedString* result);
+		static bool RecognizeExternPointerCallback(void* ctxt, BNHighLevelILFunction* hlil, size_t expr, BNType* type,
+			int64_t val, uint64_t offset, BNDerivedString* result);
+		static bool RecognizeImportCallback(
+			void* ctxt, BNHighLevelILFunction* hlil, size_t expr, BNType* type, int64_t val, BNDerivedString* result);
+	};
+
+	class CoreStringRecognizer : public StringRecognizer
+	{
+	public:
+		CoreStringRecognizer(BNStringRecognizer* recognizer);
+		bool IsValidForType(HighLevelILFunction* func, Type* type) override;
+		std::optional<DerivedString> RecognizeConstant(
+			const HighLevelILInstruction& instr, Type* type, int64_t val) override;
+		std::optional<DerivedString> RecognizeConstantPointer(
+			const HighLevelILInstruction& instr, Type* type, int64_t val) override;
+		std::optional<DerivedString> RecognizeExternPointer(
+			const HighLevelILInstruction& instr, Type* type, int64_t val, uint64_t offset) override;
+		std::optional<DerivedString> RecognizeImport(
+			const HighLevelILInstruction& instr, Type* type, int64_t val) override;
+	};
 }  // namespace BinaryNinja
 
 

binaryninjacore.h

@@ -37,14 +37,14 @@
 // Current ABI version for linking to the core. This is incremented any time
 // there are changes to the API that affect linking, including new functions,
 // new types, or modifications to existing functions or types.
-#define BN_CURRENT_CORE_ABI_VERSION 137
+#define BN_CURRENT_CORE_ABI_VERSION 138
 
 // Minimum ABI version that is supported for loading of plugins. Plugins that
 // are linked to an ABI version less than this will not be able to load and
 // will require rebuilding. The minimum version is increased when there are
 // incompatible changes that break binary compatibility, such as changes to
 // existing types or functions.
-#define BN_MINIMUM_CORE_ABI_VERSION 136
+#define BN_MINIMUM_CORE_ABI_VERSION 138
 
 #ifdef __GNUC__
 	#ifdef BINARYNINJACORE_LIBRARY
@@ -312,6 +312,8 @@ extern "C"
 	typedef struct BNIndirectBranchInfo BNIndirectBranchInfo;
 	typedef struct BNArchitectureAndAddress BNArchitectureAndAddress;
 	typedef struct BNConstantRenderer BNConstantRenderer;
+	typedef struct BNStringRecognizer BNStringRecognizer;
+	typedef struct BNCustomStringType BNCustomStringType;
 
 	typedef bool(*BNProgressFunction)(void*, size_t, size_t);
 
@@ -460,7 +462,8 @@ extern "C"
 		StringDisplayTokenContext = 10, // For displaying strings which aren't associated with an address
 		ContentCollapsedContext = 11,
 		ContentExpandedContext = 12,
-		ContentCollapsiblePadding = 13
+		ContentCollapsiblePadding = 13,
+		DerivedStringReferenceTokenContext = 14
 	} BNInstructionTextTokenContext;
 
 	typedef enum BNLinearDisassemblyLineType
@@ -1631,6 +1634,15 @@ extern "C"
 		size_t nameCount;
 	} BNQualifiedName;
 
+	typedef struct BNDerivedString
+	{
+		BNStringRef* value;
+		bool addrValid;
+		uint64_t addr;
+		uint64_t len;
+		BNCustomStringType* customType;
+	} BNDerivedString;
+
 	typedef struct BNBinaryDataNotification
 	{
 		void* context;
@@ -1656,6 +1668,8 @@ extern "C"
 		void (*symbolUpdated)(void* ctxt, BNBinaryView* view, BNSymbol* sym);
 		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);
+		void (*derivedStringFound)(void* ctxt, BNBinaryView* view, BNDerivedString* str);
+		void (*derivedStringRemoved)(void* ctxt, BNBinaryView* view, BNDerivedString* str);
 		void (*typeDefined)(void* ctxt, BNBinaryView* view, BNQualifiedName* name, BNType* type);
 		void (*typeUndefined)(void* ctxt, BNBinaryView* view, BNQualifiedName* name, BNType* type);
 		void (*typeReferenceChanged)(void* ctxt, BNBinaryView* view, BNQualifiedName* name, BNType* type);
@@ -3818,6 +3832,27 @@ extern "C"
 			BNOperatorPrecedence precedence);
 	} BNCustomConstantRenderer;
 
+	typedef struct BNCustomStringRecognizer
+	{
+		void* context;
+		bool (*isValidForType)(void* ctxt, BNHighLevelILFunction* hlil, BNType* type);
+		bool (*recognizeConstant)(
+			void* ctxt, BNHighLevelILFunction* hlil, size_t expr, BNType* type, int64_t val, BNDerivedString* result);
+		bool (*recognizeConstantPointer)(
+			void* ctxt, BNHighLevelILFunction* hlil, size_t expr, BNType* type, int64_t val, BNDerivedString* result);
+		bool (*recognizeExternPointer)(void* ctxt, BNHighLevelILFunction* hlil, size_t expr, BNType* type, int64_t val,
+			uint64_t offset, BNDerivedString* result);
+		bool (*recognizeImport)(
+			void* ctxt, BNHighLevelILFunction* hlil, size_t expr, BNType* type, int64_t val, BNDerivedString* result);
+	} BNCustomStringRecognizer;
+
+	typedef struct BNCustomStringTypeInfo
+	{
+		char* name;
+		char* stringPrefix;
+		char* stringPostfix;
+	} BNCustomStringTypeInfo;
+
 	BINARYNINJACOREAPI char* BNAllocString(const char* contents);
 	BINARYNINJACOREAPI char* BNAllocStringWithLength(const char* contents, size_t len);
 	BINARYNINJACOREAPI void BNFreeString(char* str);
@@ -5261,6 +5296,11 @@ extern "C"
 	    BNBinaryView* view, uint64_t start, uint64_t len, size_t* count);
 	BINARYNINJACOREAPI void BNFreeStringReferenceList(BNStringReference* strings);
 
+	BINARYNINJACOREAPI BNDerivedString* BNGetDerivedStrings(BNBinaryView* view, size_t* count);
+	BINARYNINJACOREAPI BNReferenceSource* BNGetDerivedStringCodeReferences(
+		BNBinaryView* view, BNDerivedString* str, size_t* count, bool limit, size_t maxItems);
+	BINARYNINJACOREAPI void BNFreeDerivedStringList(BNDerivedString* strings, size_t count);
+
 	BINARYNINJACOREAPI BNVariableNameAndType* BNGetStackLayout(BNFunction* func, size_t* count);
 	BINARYNINJACOREAPI void BNFreeVariableNameAndTypeList(BNVariableNameAndType* vars, size_t count);
 	BINARYNINJACOREAPI void BNCreateAutoStackVariable(
@@ -6564,6 +6604,12 @@ extern "C"
 	BINARYNINJACOREAPI bool BNHighLevelILExprEqual(
 	    BNHighLevelILFunction* leftFunc, size_t leftExpr, BNHighLevelILFunction* rightFunc, size_t rightExpr);
 
+	BINARYNINJACOREAPI void BNSetHighLevelILDerivedStringReferenceForExpr(
+		BNHighLevelILFunction* func, size_t expr, BNDerivedString* str);
+	BINARYNINJACOREAPI void BNRemoveHighLevelILDerivedStringReferenceForExpr(BNHighLevelILFunction* func, size_t expr);
+	BINARYNINJACOREAPI bool BNGetHighLevelILDerivedStringReferenceForExpr(
+		BNHighLevelILFunction* func, size_t expr, BNDerivedString* out);
+
 	// Type Libraries
 	BINARYNINJACOREAPI BNTypeLibrary* BNNewTypeLibrary(BNArchitecture* arch, const char* name);
 	BINARYNINJACOREAPI BNTypeLibrary* BNNewTypeLibraryReference(BNTypeLibrary* lib);
@@ -8686,13 +8732,15 @@ extern "C"
 	BINARYNINJACOREAPI BNStringRef* BNDuplicateStringRef(BNStringRef* ref);
 	BINARYNINJACOREAPI const char* BNGetStringRefContents(BNStringRef* ref);
 	BINARYNINJACOREAPI size_t BNGetStringRefSize(BNStringRef* ref);
+	BINARYNINJACOREAPI BNStringRef* BNCreateStringRef(const char* str);
+	BINARYNINJACOREAPI BNStringRef* BNCreateStringRefOfLength(const char* str, size_t len);
 
 	// Constant Renderers
 	BINARYNINJACOREAPI BNConstantRenderer* BNRegisterConstantRenderer(
 		const char* name, BNCustomConstantRenderer* renderer);
 	BINARYNINJACOREAPI BNConstantRenderer* BNGetConstantRendererByName(const char* name);
 	BINARYNINJACOREAPI BNConstantRenderer** BNGetConstantRendererList(size_t* count);
-	BINARYNINJACOREAPI void BNFreeConstantRendererList(BNLanguageRepresentationFunctionType** renderers);
+	BINARYNINJACOREAPI void BNFreeConstantRendererList(BNConstantRenderer** renderers);
 	BINARYNINJACOREAPI char* BNGetConstantRendererName(BNConstantRenderer* renderer);
 	BINARYNINJACOREAPI bool BNIsConstantRendererValidForType(
 		BNConstantRenderer* renderer, BNHighLevelILFunction* il, BNType* type);
@@ -8703,6 +8751,32 @@ extern "C"
 		BNHighLevelILFunction* il, size_t exprIndex, BNType* type, int64_t val, BNHighLevelILTokenEmitter* tokens,
 		BNDisassemblySettings* settings, BNSymbolDisplayType symbolDisplay, BNOperatorPrecedence precedence);
 
+	// String recognizers
+	BINARYNINJACOREAPI BNCustomStringType* BNRegisterCustomStringType(BNCustomStringTypeInfo* info);
+	BINARYNINJACOREAPI BNCustomStringType* BNGetCustomStringTypeByName(const char* name);
+	BINARYNINJACOREAPI BNCustomStringType* BNGetCustomStringTypeByID(uint32_t id);
+	BINARYNINJACOREAPI BNCustomStringType** BNGetCustomStringTypeList(size_t* count);
+	BINARYNINJACOREAPI void BNFreeCustomStringTypeList(BNCustomStringType** types);
+	BINARYNINJACOREAPI char* BNGetCustomStringTypeName(BNCustomStringType* type);
+	BINARYNINJACOREAPI char* BNGetCustomStringTypePrefix(BNCustomStringType* type);
+	BINARYNINJACOREAPI char* BNGetCustomStringTypePostfix(BNCustomStringType* type);
+	BINARYNINJACOREAPI BNStringRecognizer* BNRegisterStringRecognizer(
+		const char* name, BNCustomStringRecognizer* recognizer);
+	BINARYNINJACOREAPI BNStringRecognizer* BNGetStringRecognizerByName(const char* name);
+	BINARYNINJACOREAPI BNStringRecognizer** BNGetStringRecognizerList(size_t* count);
+	BINARYNINJACOREAPI void BNFreeStringRecognizerList(BNStringRecognizer** recognizers);
+	BINARYNINJACOREAPI char* BNGetStringRecognizerName(BNStringRecognizer* recognizer);
+	BINARYNINJACOREAPI bool BNIsStringRecognizerValidForType(
+		BNStringRecognizer* recognizer, BNHighLevelILFunction* il, BNType* type);
+	BINARYNINJACOREAPI bool BNStringRecognizerRecognizeConstant(BNStringRecognizer* recognizer,
+		BNHighLevelILFunction* il, size_t exprIndex, BNType* type, int64_t val, BNDerivedString* out);
+	BINARYNINJACOREAPI bool BNStringRecognizerRecognizeConstantPointer(BNStringRecognizer* recognizer,
+		BNHighLevelILFunction* il, size_t exprIndex, BNType* type, int64_t val, BNDerivedString* out);
+	BINARYNINJACOREAPI bool BNStringRecognizerRecognizeExternPointer(BNStringRecognizer* recognizer,
+		BNHighLevelILFunction* il, size_t exprIndex, BNType* type, int64_t val, uint64_t offset, BNDerivedString* out);
+	BINARYNINJACOREAPI bool BNStringRecognizerRecognizeImport(BNStringRecognizer* recognizer, BNHighLevelILFunction* il,
+		size_t exprIndex, BNType* type, int64_t val, BNDerivedString* out);
+
 #ifdef __cplusplus
 }
 #endif