reverse-engineering-assistant 2.9.2__tar.gz → 2.9.4__tar.gz

{reverse_engineering_assistant-2.9.2 → reverse_engineering_assistant-2.9.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: reverse-engineering-assistant
-Version: 2.9.2
+Version: 2.9.4
 Summary: An AI assistant for reverse engineering tasks
 Author: サイバーカイダ (cyberkaida)
 Classifier: License :: OSI Approved :: Apache Software License
@@ -12,6 +12,8 @@ Requires-Dist: langchain
 Requires-Dist: langchain-core
 Requires-Dist: langchain-openai
 Requires-Dist: langchain-community
+Requires-Dist: langchain-experimental
+Requires-Dist: langgraph
 Requires-Dist: prompt_toolkit
 Requires-Dist: sentence_transformers
 Requires-Dist: PyYAML

{reverse_engineering_assistant-2.9.2 → reverse_engineering_assistant-2.9.4}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "reverse-engineering-assistant"
 readme = "README.md"
-version = "2.9.2"
+version = "2.9.4"
 authors = [
     {name="サイバーカイダ (cyberkaida)"},
 ]
@@ -21,6 +21,8 @@ dependencies = [
     "langchain-core",
     "langchain-openai",
     "langchain-community",
+    "langchain-experimental",
+    "langgraph",
     "prompt_toolkit",
     "sentence_transformers",
     "PyYAML",

reverse_engineering_assistant-2.9.4/reverse_engineering_assistant/api_server_tools/__init__.py

@@ -0,0 +1,91 @@
+
+
+from typing import List
+from reverse_engineering_assistant.reva_exceptions import RevaToolException
+from reverse_engineering_assistant.tool import AssistantProject
+from reverse_engineering_assistant.assistant import RevaTool
+from reverse_engineering_assistant.model import RevaModel
+from reverse_engineering_assistant.api_server_tools.connection import get_channel
+from typing import Optional, Tuple
+import logging
+
+
+class RevaMessageHandler(object):
+    handles_type = None
+
+_global_message_handlers: List[RevaMessageHandler] = []
+
+__all__ = ['register_message_handler']
+
+def register_message_handler(cls: RevaMessageHandler):
+    _global_message_handlers.append(cls)
+    return cls
+
+
+class RevaRemoteTool(RevaTool):
+    logger: logging.Logger
+
+    def __init__(self, project: AssistantProject, llm: RevaModel) -> None:
+        self.logger = logging.getLogger(f"reverse_engineering_assistant.RevaRemoteTool.{self.__class__.__name__}")
+        self.logger.addHandler(logging.FileHandler(project.project_path / "reva.log"))
+        super().__init__(project, llm)
+
+    @property
+    def channel(self):
+        return get_channel()
+
+    def resolve_to_address_and_symbol(self, thing: str) -> Tuple[str, Optional[str]]:
+        """
+        Resolve a string to an address and symbol.
+        If it is an address it can be a namespaced address or a plain hex address.
+
+        This helps reduce hallucinations and catch issues with symbols and namespaces early.
+
+        Returns a tuple of (address, symbol).
+        """
+        self.logger.debug(f"Resolving {thing} to address and symbol")
+        assert thing is not None
+        address: Optional[str] = None
+        symbol: Optional[str] = None
+        try:
+            # This is a plain address in the main namespace
+            address = hex(int(thing, 16))
+            self.logger.debug(f"Resolved {thing} to address: {address}")
+        except ValueError:
+            # This could also be a Ghidra namespaced address, so let's check that too!
+            if "::" in thing:
+                last_part = thing.split("::")[-1]
+                try:
+                    hex(int(last_part, 16))
+                    # If the last part of the address is a hex number, then we can assume it is an address
+                    address = thing
+                except ValueError:
+                    # Otherwise, it is a symbol
+                    symbol = thing
+            else:
+                # This is a symbol
+                symbol = thing
+
+        # We can check if it is a symbol
+        from ..protocol import RevaGetSymbols_pb2_grpc, RevaGetSymbols_pb2
+        stub = RevaGetSymbols_pb2_grpc.RevaToolSymbolServiceStub(self.channel)
+        request = RevaGetSymbols_pb2.RevaSymbolRequest()
+        if address:
+            request.address = address
+        if symbol:
+            request.name = symbol
+
+        self.logger.debug(f"Getting symbol for {thing} request: {request}")
+        response = stub.GetSymbol(request)
+        self.logger.debug(f"Got symbol for {thing} response: {response}")
+
+        if response.name:
+            symbol = response.name
+        if response.address:
+            address = response.address
+
+        if address is None and symbol is None:
+            raise RevaToolException(message=f"Could not resolve {thing} to an address or symbol. Double check your symbol or address is correct.")
+        self.logger.debug(f"Resolved {thing} to address: {address}, symbol: {symbol}")
+        assert address is not None
+        return address, symbol

{reverse_engineering_assistant-2.9.2 → reverse_engineering_assistant-2.9.4}/reverse_engineering_assistant/api_server_tools/connection.py

@@ -11,6 +11,9 @@ from functools import cache
 _channel: Optional[Channel] = None
 @cache
 def get_channel() -> Channel:
+    """
+    Get the global gRPC channel to the extension.
+    """
     global _channel
     if not _channel:
         raise ValueError("Channel not set")

{reverse_engineering_assistant-2.9.2 → reverse_engineering_assistant-2.9.4}/reverse_engineering_assistant/api_server_tools/llm_tools.py

@@ -4,6 +4,7 @@ from ast import Call
 import queue
 import threading
 from typing import Callable, Dict, Optional
+from uuid import uuid4
 from venv import logger
 
 from ..protocol.RevaChat_pb2_grpc import RevaChatServiceServicer
@@ -18,58 +19,27 @@ module_logger = logging.getLogger("reva-server")
 from langchain_core.callbacks.base import BaseCallbackHandler
 from langchain_core.agents import AgentAction, AgentFinish
 
-from langchain_core.language_models.base import BaseLanguageModel
-from langchain_core.language_models.chat_models import BaseChatModel
-
-class RevaActionCollector(BaseCallbackHandler):
-    """
-    A callback handler for logging agent actions in the reverse engineering assistant.
-
-    This class logs agent actions and calls a callback. This is what prints the green
-    thoughts from the model to the console. This is very useful for the analyst to understand
-    what the model is doing (and is arguably the most important part of the assistant output!)
-
-    Attributes:
-        callback (Callable[[str], None]): The callback function to call when an agent action is performed.
-        logger (logging.Logger): The logger instance for the reverse_engineering_assistant.RevaActionLogger class.
-    """
-
-    callback: Callable[[str], None]
-    def __init__(self, callback: Callable[[str], None]) -> None:
-        super().__init__()
-        self.callback = callback
-
-    logger = logging.getLogger("reverse_engineering_assistant.RevaActionLogger")
-
-    def on_agent_action(self, action: AgentAction, **kwargs) -> None:
-        """
-        Callback method called when an agent action is performed.
-
-        Args:
-            action (AgentAction): The agent action that was performed.
-            **kwargs: Additional keyword arguments.
-
-        Returns:
-            None
-        """
-        logger.debug(f"Agent action: {action} {kwargs}")
-        # TODO: Should this be AgentAction?
-        # TODO: Is `.action` still a thing?
-        self.callback(str(action.log))
-
+from reverse_engineering_assistant.model import RevaModel
+from reverse_engineering_assistant.model import get_llm_ollama, get_llm_openai
 
 class RevaChat(RevaChatServiceServicer):
     logger = logging.getLogger("reva-server.RevaChat")
-    llm: BaseLanguageModel | BaseChatModel
 
-    def __init__(self, llm: BaseLanguageModel | BaseChatModel) -> None:
-        self.llm = llm
+    def _model_from_request(self, request) -> RevaModel:
+        """
+        Given a request, return the model associated with the request.
+        """
+        if request.ollama.model:
+            return get_llm_ollama(base_url=request.ollama.url, model=request.ollama.model)
+        if request.openai.model:
+            return get_llm_openai(model=request.openai.model, api_key=request.openai.token)
+        raise ValueError("No model specified in request. Please file a bug.")
 
     def chat(self, request, context):
         self.logger.info(f"Received request: {request}")
         assistant = ReverseEngineeringAssistant(
             request.project,
-            model=self.llm
+            model=self._model_from_request(request)
         )
         self.logger.info(f"Assistant: {assistant}")
         llm_response = assistant.query(request.message)
@@ -95,8 +65,8 @@ class RevaChat(RevaChatServiceServicer):
 
         assistant = ReverseEngineeringAssistant(
             request.project,
-            model=self.llm,
-            langchain_callbacks=[RevaActionCollector(callback)]
+            model=self._model_from_request(request),
+            logging_callbacks=[callback],
         )
         self.logger.info(f"Assistant: {assistant}")
 
@@ -133,8 +103,8 @@ class RevaChat(RevaChatServiceServicer):
             if not assistant:
                 assistant = ReverseEngineeringAssistant(
                     request.project,
-                    model=self.llm,
-                    langchain_callbacks=[RevaActionCollector(callback)]
+                    model=self._model_from_request(request),
+                    logging_callbacks=[callback],
                 )
             self.logger.info(f"Received request: {request}")
             def run_query(query: str):
@@ -157,3 +127,8 @@ class RevaChat(RevaChatServiceServicer):
                     done = True
                 yield response
             t.join()
+
+    def shutdown(self, request, context):
+        self.logger.warning("Shutting down")
+        import sys
+        sys.exit(0)

reverse_engineering_assistant-2.9.4/reverse_engineering_assistant/api_server_tools/re_tool_box/__init__.py

@@ -0,0 +1,6 @@
+"""
+To make sure your tool is loaded, you should import it here.
+`assistant_api_server.py` imports everything from `re_tools.py`,
+and `re_tools.py` imports everything from here.
+"""
+

reverse_engineering_assistant-2.9.4/reverse_engineering_assistant/api_server_tools/re_tool_box/bookmarks.py

@@ -0,0 +1,65 @@
+from typing import Dict, List
+import logging
+
+import grpc
+
+from reverse_engineering_assistant.tool import AssistantProject
+from reverse_engineering_assistant.assistant import AssistantProject, register_tool
+from reverse_engineering_assistant.reva_exceptions import RevaToolException
+from reverse_engineering_assistant.api_server_tools import RevaRemoteTool
+from langchain_core.language_models.base import BaseLanguageModel
+from reverse_engineering_assistant.protocol import RevaBookmark_pb2, RevaBookmark_pb2_grpc
+
+from reverse_engineering_assistant.model import RevaModel
+
+
+@register_tool
+class RevaBookmarks(RevaRemoteTool):
+
+    def __init__(self, project: AssistantProject, llm: RevaModel) -> None:
+        super().__init__(project, llm)
+        self.description = "Used for managing bookmarks in the program"
+
+        self.tool_functions = [
+            self.get_bookmarks,
+            self.add_bookmark,
+        ]
+
+    def get_bookmarks(self) -> List[Dict[str, str]]:
+        """
+        Return a list of Ghidra bookmarks in the program.
+        Use this to keep track of important locations in the program the user
+        has marked.
+        """
+        stub = RevaBookmark_pb2_grpc.RevaBookmarkStub(self.channel)
+
+        request = RevaBookmark_pb2.RevaGetBookmarksRequest()
+
+        bookmarks: List[Dict[str, str]] = []
+        for bookmark in stub.get_bookmarks(request):
+            bookmarks.append({
+                "address": bookmark.address,
+                "category": bookmark.category,
+                "description": bookmark.description,
+            })
+        return bookmarks
+
+    def add_bookmark(self, address_or_symbol: str, category: str, description: str) -> str:
+        """
+        Add a Ghidra bookmark at the given address or symbol with the given category and description.
+        If the category does not exist, it will be created. Use a category to group bookmarks together.
+        Make sure your category is descriptive and useful to the user.
+
+        Use this tool to keep note of anything important enough you want to look at it
+        again.
+        """
+        stub = RevaBookmark_pb2_grpc.RevaBookmarkStub(self.channel)
+
+        request = RevaBookmark_pb2.RevaAddBookmarkRequest()
+        request.category = f"ReVa.{category}"
+        request.description = description
+        request.address, _ = self.resolve_to_address_and_symbol(address_or_symbol)
+
+        response = stub.add_bookmark(request)
+
+        return "Added bookmark successfully"

reverse_engineering_assistant-2.9.4/reverse_engineering_assistant/api_server_tools/re_tool_box/comment.py

@@ -0,0 +1,65 @@
+from typing import Dict, List
+import logging
+
+import grpc
+
+from reverse_engineering_assistant.tool import AssistantProject
+from reverse_engineering_assistant.assistant import AssistantProject, register_tool
+from reverse_engineering_assistant.reva_exceptions import RevaToolException
+from reverse_engineering_assistant.api_server_tools import RevaRemoteTool
+
+from reverse_engineering_assistant.protocol import RevaGetDecompilation_pb2_grpc, RevaGetDecompilation_pb2
+from reverse_engineering_assistant.protocol import RevaComment_pb2_grpc, RevaComment_pb2
+
+from reverse_engineering_assistant.model import RevaModel
+
+@register_tool
+class RevaSetComment(RevaRemoteTool):
+    """
+    A tool for setting comments on addresses, functions and symbols.
+    """
+
+    def __init__(self, project: AssistantProject, llm: RevaModel) -> None:
+        super().__init__(project, llm)
+        self.description = "Used for setting comments on addresses, functions and symbols"
+
+        self.tool_functions = [
+            self.set_comment,
+            self.set_multiple_comments,
+        ]
+
+    def set_multiple_comments(self, comments: Dict[str, str]) -> List[str]:
+        """
+        Set multiple comments at the same time.
+        Keys are addresses or symbols, values are the comments to set at that location.
+        This is more efficient than calling set_comment multiple times.
+        """
+        outputs: List[str] = []
+
+        for address_or_symbol, comment in comments.items():
+            outputs.append(self.set_comment(address_or_symbol=address_or_symbol, comment=comment))
+
+        return outputs
+
+    def set_comment(self, address_or_symbol: str, comment: str) -> str:
+        """
+        Set the comment at the given address, function or symbol to `comment`.
+        Use this when you want to add an explanation or note to a specific part
+        of the code.
+        """
+        stub = RevaComment_pb2_grpc.RevaCommentServiceStub(self.channel)
+
+        request = RevaComment_pb2.RevaSetCommentRequest()
+        request.comment = comment
+        address, symbol = self.resolve_to_address_and_symbol(address_or_symbol)
+
+        if address:
+            request.address = address
+        if symbol:
+            request.symbol = symbol
+
+        try:
+            response: RevaComment_pb2.RevaSetCommentResponse = stub.SetComment(request)
+        except grpc.RpcError as e:
+            raise RevaToolException(f"Failed to set comment: {e}")
+        return "Set comment successfully"

reverse_engineering_assistant-2.9.4/reverse_engineering_assistant/api_server_tools/re_tool_box/cross_reference.py

@@ -0,0 +1,69 @@
+from typing import Dict, List, Union
+import logging
+
+import grpc
+
+from reverse_engineering_assistant.tool import AssistantProject
+from reverse_engineering_assistant.assistant import AssistantProject, register_tool
+from reverse_engineering_assistant.reva_exceptions import RevaToolException
+from reverse_engineering_assistant.api_server_tools import RevaRemoteTool
+from reverse_engineering_assistant.model import RevaModel
+
+@register_tool
+class RevaCrossReferenceTool(RevaRemoteTool):
+    """
+    An tool to retrieve cross references, to and from, addresses.
+    """
+    def __init__(self, project: AssistantProject, llm: RevaModel) -> None:
+        super().__init__(project, llm)
+        self.description = "Used for retrieving cross references to and from addresses"
+
+        self.tool_functions = [
+            self.get_references,
+            self.get_references_to,
+            self.get_references_from,
+        ]
+
+    def get_references(self, address_or_symbol: str) -> Dict[str, Union[str, List[str]]]:
+        """
+        Return a list of references to and from the given address or symbol.
+        These might be calls from/to other functions, or data references from/to this address.
+        """
+        from reverse_engineering_assistant.protocol import RevaReferences_pb2_grpc, RevaReferences_pb2
+
+        stub = RevaReferences_pb2_grpc.RevaReferenceServiceStub(self.channel)
+
+        request = RevaReferences_pb2.RevaGetReferencesRequest()
+
+        address, symbol = self.resolve_to_address_and_symbol(address_or_symbol)
+        request.address = address
+
+        try:
+            response: RevaReferences_pb2.RevaGetReferencesResponse = stub.get_references(request)
+        except grpc.RpcError as e:
+            raise RevaToolException(f"Failed to get references: {e}")
+
+        result: Dict[str, Union[str, List[str]]] = {
+            "address": address,
+            "incoming_references": list(response.incoming_references),
+            "outgoing_references": list(response.outgoing_references),
+        }
+
+        if symbol:
+            result["symbol"] = symbol
+
+        return result
+
+    def get_references_to(self, address_or_symbol: str) -> List[str]:
+        """
+        Return a list of references to the given address or symbol.
+        """
+        references = self.get_references(address_or_symbol)
+        return references.get("incoming_references", []) # type: ignore
+
+    def get_references_from(self, address_or_symbol: str) -> List[str]:
+        """
+        Return a list of references from the given address or symbol.
+        """
+        references = self.get_references(address_or_symbol)
+        return references.get("outgoing_references", []) # type: ignore

reverse_engineering_assistant-2.9.4/reverse_engineering_assistant/api_server_tools/re_tool_box/cursor.py

@@ -0,0 +1,45 @@
+from typing import Dict, List, Union
+import logging
+
+import grpc
+
+from reverse_engineering_assistant.tool import AssistantProject
+from reverse_engineering_assistant.assistant import AssistantProject, register_tool
+from reverse_engineering_assistant.reva_exceptions import RevaToolException
+from reverse_engineering_assistant.api_server_tools import RevaRemoteTool
+from reverse_engineering_assistant.model import RevaModel
+from reverse_engineering_assistant.protocol import RevaGetCursor_pb2, RevaGetCursor_pb2_grpc
+
+
+@register_tool
+class RevaGetCursor(RevaRemoteTool):
+
+    def __init__(self, project: AssistantProject, llm: RevaModel) -> None:
+        super().__init__(project, llm)
+        self.description = "Used for getting and setting the cursor or when the user mentions 'this'"
+
+        self.tool_functions = [
+            self.get_cursor,
+        ]
+
+    def get_cursor(self) -> Dict[str, Union[str, int]]:
+        """
+        Return the current location the user is looking at in the program.
+        Use this to find the current function, symbol or address. When the user mentions "this",
+        you should find the current location using this function.
+
+        This method returns a dictionary with the keys "address", "symbol", and "function".
+        Use other tools to gather context around this location. For example, decompile
+        the function to find the exact code at this location in the listing or decompilation.
+        """
+        stub = RevaGetCursor_pb2_grpc.RevaGetCursorStub(self.channel)
+
+        request = RevaGetCursor_pb2.RevaGetCursorRequest()
+
+        response = stub.getCursor(request)
+
+        return {
+            "address": response.address,
+            "symbol": response.symbol,
+            "function": response.function,
+        }

reverse_engineering_assistant-2.9.4/reverse_engineering_assistant/api_server_tools/re_tool_box/data.py

@@ -0,0 +1,154 @@
+from typing import Dict, List, Optional, Union
+from binascii import a2b_hex, b2a_hex, a2b_base64
+import logging
+
+import grpc
+
+from reverse_engineering_assistant.tool import AssistantProject
+from reverse_engineering_assistant.assistant import AssistantProject, register_tool
+from reverse_engineering_assistant.reva_exceptions import RevaToolException
+from reverse_engineering_assistant.api_server_tools import RevaRemoteTool
+from reverse_engineering_assistant.model import RevaModel
+from reverse_engineering_assistant.protocol import RevaGetDecompilation_pb2_grpc, RevaGetDecompilation_pb2
+from reverse_engineering_assistant.protocol import RevaData_pb2_grpc, RevaData_pb2, RevaGetSymbols_pb2, RevaGetSymbols_pb2_grpc
+
+
+@register_tool
+class RevaData(RevaRemoteTool):
+    """
+    A tool for getting and setting data
+    """
+
+    def __init__(self, project: AssistantProject, llm: RevaModel) -> None:
+        super().__init__(project, llm)
+        self.description = "Used for getting and setting data"
+
+        self.tool_functions = [
+            self.list_strings,
+            self.list_data,
+            self.get_data,
+            self.set_global_data_type,
+            self.xor_data,
+            self.base64_decode_string,
+        ]
+
+    def list_strings(self) -> List[Dict[str, Union[str, List[str]]]]:
+        """
+        Return a list of defined strings in the program.
+        """
+        stub = RevaData_pb2_grpc.RevaDataServiceStub(self.channel)
+
+        request = RevaData_pb2.RevaStringListRequest()
+
+        defined_strings: List[Dict[str, Union[str, List[str]]]] = []
+        for string in stub.getStringList(request):
+            defined_strings.append({
+                "address": string.address,
+                "symbol": string.symbol,
+                "value": string.value,
+                "incoming_references": list(string.incoming_references),
+                "outgoing_references": list(string.outgoing_references),
+            })
+
+        return defined_strings
+
+    def list_data(self) -> List[Dict[str, Union[str, List[str]]]]:
+        """
+        Return a list of defined data in the program.
+        This is not all data, only the data that has been defined in the Ghidra database.
+
+        This function returns a list of dictionaries with the keys "address", "symbol", "type", "size", "incoming_references", and "outgoing_references".
+        """
+
+        stub = RevaData_pb2_grpc.RevaDataServiceStub(self.channel)
+
+        request = RevaData_pb2.RevaDataListRequest()
+
+        defined_data: List[Dict[str, Union[str, List[str]]]] = []
+        for data in stub.getListData(request):
+            defined_data.append({
+                "address": data.address,
+                "symbol": data.symbol,
+                "type": data.type,
+                "size": data.size,
+                "incoming_references": list(data.incoming_references),
+                "outgoing_references": list(data.outgoing_references),
+            })
+
+        return defined_data
+
+    def get_data(self, address_or_symbol: str, size: Optional[int] = None) -> Dict[str, Optional[Union[str, List[str], int]]]:
+        """
+        Return information about the data at the given address or with the given symbol.
+        Don't set the size if you don't know it, Ghidra will try to figure it out.
+
+        This function returns a dictionary with the keys "address", "symbol", "type", "size", "data", "incoming_references", and "outgoing_references".
+        """
+        stub = RevaData_pb2_grpc.RevaDataServiceStub(self.channel)
+        request = RevaData_pb2.RevaGetDataAtAddressRequest()
+
+        request.address, symbol = self.resolve_to_address_and_symbol(address_or_symbol)
+
+        if size:
+            request.size = size
+
+        response = stub.getDataAtAddress(request)
+
+        return {
+            "address": response.address,
+            "symbol": symbol,
+            "type": response.type,
+            "size": len(response.data),
+            "data": b2a_hex(response.data).decode("utf-8"),
+            "incoming_references": list(response.incoming_references),
+            "outgoing_references": list(response.outgoing_references),
+        }
+
+    def set_global_data_type(self, address_or_symbol: str, data_type: Optional[str], new_name: Optional[str]) -> str:
+        """
+        Set the data type or name of the data at the given address or symbol to the given data type.
+
+        `new_type` must be a string that can be passed to the "Set Data Type" dialog in Ghidra.
+        Something like `int`, `char`, `string`, `long`, `unsigned int`, `char[0x10]` or `char[16]`, or `int*` should work,
+        but you can use custom types from the program too.
+
+        You can't define a _new_ data type here, only use existing ones.
+        """
+        if not data_type and not new_name:
+            raise RevaToolException("You must provide either a data type or a new name")
+        address, symbol = self.resolve_to_address_and_symbol(address_or_symbol)
+
+        if data_type:
+            stub = RevaData_pb2_grpc.RevaDataServiceStub(self.channel)
+            request = RevaData_pb2.RevaSetGlobalDataTypeRequest()
+            request.address = address
+            request.data_type = data_type
+            response = stub.setGlobalDataType(request)
+
+        if new_name:
+            symbol_stub = RevaGetSymbols_pb2_grpc.RevaToolSymbolServiceStub(self.channel)
+            symbol_request = RevaGetSymbols_pb2.RevaSetSymbolNameRequest()
+            if symbol:
+                symbol_request.old_name = symbol
+            symbol_request.new_name = new_name
+            symbol_request.old_address = address
+            symbol_response = symbol_stub.SetSymbolName(symbol_request)
+
+        # TODO: Should we return truth to reduce hallucinations?
+        return f"{address_or_symbol} has been updated successfully"
+
+    def xor_data(self, hex_string: str, key_byte: str) -> str:
+        """
+        Given a data buffer and a key buffer, return the result of XORing the data with the key.
+        Returns a hex string.
+        """
+        # TODO: Should we expose cyberchef recipes?
+        data = bytes.fromhex(hex_string)
+        key = int(key_byte, 16)
+        return b2a_hex(bytes([byte ^ key for byte in data])).decode("utf-8")
+
+    def base64_decode_string(self, base64_string: str) -> str:
+        """
+        Given a base64 encoded string, return the decoded string.
+        """
+        return a2b_base64(base64_string).decode("utf-8")