improving and solving bugs

Author: anisiosts

features/auto_unstrip/auto_unstrip.py

@@ -23,10 +23,10 @@ def _rename_function(self, bv: BinaryView, addr: int, new_name: str, new_name_ma
                 log_info(f"RevEng.AI | Function at {hex(addr)} already has name {func.name}")
                 return False
 
-            new_symbol = Symbol(SymbolType.FunctionSymbol, addr, new_name_mangled)
+            new_symbol = Symbol(SymbolType.FunctionSymbol, addr, new_name)
             bv.define_user_symbol(new_symbol)
 
-            log_info(f"RevEng.AI | Renamed function at {hex(addr)} to {new_name_mangled}")
+            log_info(f"RevEng.AI | Renamed function at {hex(addr)} to {new_name}")
             return True
 
         except Exception as e:

features/choose_source/choose_source.py

@@ -12,22 +12,24 @@ def choose_source(self, bv: BinaryView, chose: str):
         try:
             log_info(f"RevEng.AI | Chose: {chose}")
             binary_id = chose.split("ID: ")[1].split(" -")[0]
-            self.config.binary_id = binary_id
             log_info(f"RevEng.AI | Binary ID: {self.config.binary_id}")
             # TODO: implement array like to store binary id and binaryhash and filesize
+
+            self.config.set_current_info(binary_id)
+
             return True
         except Exception as e:
             log_error(f"RevEng.AI | Failed to choose source: {str(e)}")
             return False
 
     def get_analysis(self, bv: BinaryView):
         try:
-            self.base_addr = bv.image_base
-            self.path = bv.file.filename
-            log_info(f"RevEng.AI | Path: {self.path}")
+            log_info(f"RevEng.AI | Path: {bv.file.filename}")
             log_info(f"RevEng.AI | Binary ID: {self.config.binary_id}")
 
-            results = RE_search(fpath=self.path).json()["query_results"]
+            # TODO: check if the binary is already in the database
+
+            results = RE_search(fpath=bv.file.filename).json()["query_results"]
 
             if not len(results):
                 raise Exception("Binary not found in RevEng.AI, try processing the binary again.")

features/choose_source/choose_source_dialog.py

@@ -63,7 +63,7 @@ def init_ui(self):
                 background-color: #4400ff;
             }
         """)
-        self.ok_button.clicked.connect(self.choose_source)
+        self.ok_button.clicked.connect(self._choose_source)
         self.cancel_button = QPushButton("Cancel")
         self.cancel_button.setStyleSheet("""
             QPushButton {
@@ -110,7 +110,7 @@ def _on_analysis_load_error(self, error_msg):
         )
         self.reject()   
 
-    def choose_source(self):
+    def _choose_source(self):
         if not self.combo.currentText():
             log_warn("RevEng.AI | Source selection is required")
             QMessageBox.warning(

features/configuration/__init__.py

@@ -2,29 +2,10 @@
 from .config import Config
 from .config_dialog import ConfigDialog
 from PySide6.QtWidgets import QMessageBox
-from PySide6.QtCore import QThread, pyqtSignal
-import threading
-
-class ConfigInitThread(QThread):
-    finished = pyqtSignal(bool, str, object)  # success, message, bv
-    
-    def __init__(self, config, bv):
-        super().__init__()
-        self.config = config
-        self.bv = bv
-        
-    def run(self):
-        try:
-            status, message = self.config.init_config(self.bv)
-            self.finished.emit(status, message, self.bv)
-        except Exception as e:
-            self.finished.emit(False, str(e), self.bv)
 
 class ConfigurationFeature():
     def __init__(self):
         self.config = Config()
-        self._thread_lock = threading.Lock()
-        self._active_threads = {}
         self._register_binary_view_event()
         log_info("RevEng.AI | Configuration Feature initialized")
 
@@ -45,62 +26,16 @@ def get_config(self):
         return self.config  
 
     def _register_binary_view_event(self):
-        BinaryViewType.add_binaryview_initial_analysis_completion_event(self._add_binaryview_finalized_event) # TODO: Use binaryview_finalized_event instead, but without load 3 times
+        BinaryViewType.add_binaryview_finalized_event(self._add_binaryview_finalized_event) # TODO: Use binaryview_finalized_event instead, but without load 3 times
         # TODO: Nao usar binaryview_finalized_event para checkar creds, resulta em comandos nao carregando.q
         log_info("RevEng.AI | Registered binary view event handler")
 
     def _add_binaryview_finalized_event(self, bv):
         try:
-            log_info(f"RevEng.AI | Binary view finalized: {bv.file.original_filename}")
+            if bv.view_type == "Raw":
+                return
 
-            # Use thread-safe approach
-            with self._thread_lock:
-                # Cancel any existing thread for this binary
-                binary_key = bv.file.original_filename
-                if binary_key in self._active_threads:
-                    old_thread = self._active_threads[binary_key]
-                    if old_thread.isRunning():
-                        old_thread.terminate()
-                        old_thread.wait()
-                
-                # Create new thread for this binary
-                thread = ConfigInitThread(self.config, bv)
-                thread.finished.connect(self._on_config_init_finished)
-                self._active_threads[binary_key] = thread
-                thread.start()
-                
-        except Exception as e:
-            log_error(f"RevEng.AI | Error in binary view event handler: {str(e)}")
-    
-    def _on_config_init_finished(self, status, message, bv):
-        try:
-            # Clean up thread reference
-            with self._thread_lock:
-                binary_key = bv.file.original_filename
-                if binary_key in self._active_threads:
-                    del self._active_threads[binary_key]
-            
-            if status:
-                log_info("RevEng.AI | Configuration initialized successfully")
-            elif message == "Binary not found in RevEng.AI, try processing the binary again.":
-                QMessageBox.warning(
-                    None,
-                    "RevEng.AI - Binary Not Found",
-                    "This binary has not been processed in the RevEng.AI platform yet.\n\n"
-                    "Please upload and process the binary first using the 'RevEng.AI > Upload Binary' option "
-                    "before using other RevEng.AI features.",
-                    QMessageBox.Ok
-                )
-            else:
-                log_error(f"RevEng.AI | Configuration initialization failed: {message}")
-                
-        except Exception as e:
-            log_error(f"RevEng.AI | Error in config init finished handler: {str(e)}")
-
-    
-    def _add_binaryview_finalized_event_old(self, bv):
-        try:
-            log_info(f"RevEng.AI | Binary view finalized: {bv.file.original_filename}")
+            log_info(f"RevEng.AI | Binary view finalized: {bv.file.filename}")
             status, message = self.config.init_config(bv)
             if status:
                 log_info("RevEng.AI | Configuration initialized successfully")

features/configuration/config.py

@@ -1,13 +1,14 @@
 from binaryninja import Settings, log_info, log_error, BinaryView
-from reait.api import re_conf, RE_authentication, RE_search
+from reait.api import re_conf, RE_authentication, RE_search, re_binary_id
+import json
 
 class Config:
     def __init__(self):
         self.settings = Settings()
         self.api_key = ""
         self.host = ""
-        self.current_analysis = None
-        self.is_configured = None
+        self.sha256 = ""
+        self.is_configured = False
         self.binary_id = 0
         self.analysis_id = 0
         self._load_config()
@@ -16,107 +17,109 @@ def __init__(self):
     def _load_config(self):
         settings = Settings()
         settings.register_group("revengai", "RevEng.AI")
-        settings.register_setting("revengai.host", 
+        log_info(f"RevEng.AI | Registering settings")
+        log_info(settings.register_setting("revengai.host", 
             '{"title" : "Host URL",\
             "type" : "string",\
             "default" : "https://api.reveng.ai",\
-            "description" : "RevEng.AI Host URL"}')
-        settings.register_setting("revengai.api_key", 
+            "description" : "RevEng.AI Host URL"}'))
+        log_info(settings.register_setting("revengai.api_key", 
             '{"title" : "API Key",\
             "type" : "string",\
             "default" : "",\
-            "description" : "API Key"}')
-        settings.register_setting("revengai.current_analysis", 
-            '{"title" : "Current Analysis ID",\
-            "type" : "string",\
-            "default" : "",\
-            "description" : "Current Analysis ID"}')
-        settings.register_setting("revengai.is_configured", 
-            '{"title" : "Is Configured",\
-            "type" : "string",\
-            "default" : "False",\
-            "description" : "Configuration Status"}')
+            "description" : "API Key"}'))
+        log_info(settings.register_setting("revengai.all_analyses", 
+            '{"title" : "All Analyses",\
+            "type" : "object",\
+            "description" : "All Analyses"}'))
 
         self.host = settings.get_string("revengai.host", None)
         self.api_key = settings.get_string("revengai.api_key", None)
-        self.current_analysis = settings.get_string("revengai.current_analysis", None)
-        self.is_configured = settings.get_string("revengai.is_configured", None)
 
         re_conf["apikey"] = self.api_key
         re_conf["host"] = self.host
+        re_conf["user_agent"] = "RevEng.AI BinaryNinja Plugin"
 
 
     def save_config(self) -> bool:
         try:
             log_info(f"RevEng.AI | Testing configuration: {self.host} {self.api_key[:4]}...")
-            re_conf["apikey"] = self.api_key
-            re_conf["host"] = self.host
-            RE_authentication()
-            log_info("RevEng.AI | Authentication successful!")
-            self.is_configured = "True"
+            
+            if not self.check_auth():
+                raise(f"RevEng.AI | Authentication failed.")
+            
+            self.is_configured = True
 
             settings = Settings()
             settings.set_string("revengai.host", self.host)
             settings.set_string("revengai.api_key", self.api_key)
-            settings.set_string("revengai.is_configured", self.is_configured)
 
             return True
 
         except Exception as e:
             log_info(f"RevEng.AI | Failed to save API key: {str(e)}")
-            self.is_configured = "False"
-            settings = Settings()
-            settings.set_string("revengai.is_configured", self.is_configured)
+            self.is_configured = False
             return False
 
 
     def clear_config(self):
         self.api_key = ""
         self.host = ""
-        self.current_analysis = None
         self.is_configured = False
         self.save_config() 
 
-    def set_binary_id(self, binary_id: int):
-        """Set the binary ID and store it in settings."""
-        self.binary_id = binary_id
+
+    def check_auth(self):
+        try:
+            re_conf["apikey"] = self.api_key
+            re_conf["host"] = self.host
+            RE_authentication()
+            return True
+        except Exception as e: 
+            return False
+        
+    def get_all_analyses(self):
         settings = Settings()
-        settings.set_integer("revengai.binary_id", self.binary_id)
-        return
+        all_analyses = settings.get_json("revengai.all_analyses", None)
+        if all_analyses == "null":
+            return {}
+        return all_analyses
+    
+    def set_current_info(self, binary_id):
+        binary_id = int(binary_id)
+        self.binary_id = binary_id
 
-    def set_analysis_id(self, analysis_id: int):
-        """Set the analysis ID and store it in settings."""
-        self.analysis_id = analysis_id
+        all_analyses = self.get_all_analyses()
+        all_analyses[self.sha256] = {"binary_id": binary_id}
+        log_info(f"RevEng.AI | All analyses: {all_analyses}")
         settings = Settings()
-        settings.set_integer("revengai.analysis_id", self.analysis_id)
-        return
+        
+        settings.set_json("revengai.all_analyses", json.dumps(all_analyses))
+        log_info(f"RevEng.AI | Updated analysis for SHA256: {self.sha256[:8]}... with binary_id: {binary_id}")
+
 
     def init_config(self, bv: BinaryView):
         try:
-            """
-            log_info(f"RevEng.AI | Testing configuration: {self.host} {self.api_key[:4]}...")
-            re_conf["apikey"] = self.api_key
-            re_conf["host"] = self.host
-            RE_authentication()
-            log_info("RevEng.AI | Authentication successful!")
+            if not self.check_auth():
+                self.is_configured = False
+                raise(f"RevEng.AI | Authentication failed.")
+            
+            self.is_configured = True
 
-            self.is_configured = "True"
-            settings = Settings()
-            settings.set_string("revengai.is_configured", self.is_configured)
-            """
-            # TODO: Ignore search if binary appears in settings options
-            search_results = RE_search(fpath=bv.file.filename).json()["query_results"]
-            if not len(search_results):
-                raise Exception("Binary not found in RevEng.AI, try processing the binary again.")
+            self.sha256 = re_binary_id(bv.file.filename)
+            log_info(f"RevEng.AI | SHA256: {self.sha256}")
 
+            all_analyses = self.get_all_analyses()  
+            if self.sha256 in all_analyses:
+                self.binary_id = all_analyses[self.sha256]["binary_id"]
+            else:
+                search_results = RE_search(fpath=bv.file.filename).json()["query_results"]
+                if not len(search_results):
+                    raise Exception("Binary not found in RevEng.AI, try processing the binary again.")
+            
             return True, ""
 
         except Exception as e:
             log_error(f"RevEng.AI | Failed to initialize configuration: {str(e)}")
-            """
-            self.is_configured = "False"
-            settings = Settings()
-            settings.set_string("revengai.is_configured", self.is_configured)
-            """
             return False, str(e)
 

features/upload/upload.py

@@ -95,8 +95,7 @@ def upload_binary(self, bv: BinaryView, options: dict):
             log_info(f"RevEng.AI | Binary ID: {analysis['binary_id']}")
             log_info(f"RevEng.AI | Analysis ID: {analysis_info['analysis_id']}")
 
-            self.config.set_binary_id(analysis["binary_id"])
-            self.config.set_analysis_id(analysis_info["analysis_id"])
+            # TODO: Set binary and analysis id in config in form of id in array in settings
 
             PeriodicChecker().start_checking(bv, analysis["binary_id"])
 

utils/base_auth_feature.py

@@ -10,4 +10,4 @@ def register(self):
         pass
 
     def is_valid(self, bv: BinaryView):
-        return self.config.is_configured == "True" 
+        return self.config.is_configured == True