ending upload binary

Author: anisiosts

features/configuration/config.py

@@ -8,6 +8,8 @@ def __init__(self):
         self.host = ""
         self.current_analysis = None
         self.is_configured = None
+        self.binary_id = None
+        self.analysis_id = None
         self._load_config()
 
 
@@ -34,11 +36,23 @@ def _load_config(self):
             "type" : "string",\
             "default" : "False",\
             "description" : "Configuration Status"}')
+        settings.register_setting("revengai.binary_id", 
+            '{"title" : "Binary ID",\
+            "type" : "string",\
+            "default" : "",\
+            "description" : "Current Binary ID"}')
+        settings.register_setting("revengai.analysis_id", 
+            '{"title" : "Analysis ID",\
+            "type" : "string",\
+            "default" : "",\
+            "description" : "Current Analysis ID"}')
 
         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)
+        self.binary_id = settings.get_integer("revengai.binary_id", None)
+        self.analysis_id = settings.get_integer("revengai.analysis_id", None)
 
         re_conf["apikey"] = self.api_key
         re_conf["host"] = self.host
@@ -71,3 +85,17 @@ def clear_config(self):
         self.current_analysis = None
         self.is_configured = False
         self.save_config() 
+
+    def set_binary_id(self, binary_id: str):
+        """Set the binary ID and store it in settings."""
+        self.binary_id = binary_id
+        settings = Settings()
+        settings.set_integer("revengai.binary_id", self.binary_id)
+        return
+
+    def set_analysis_id(self, analysis_id: str):
+        """Set the analysis ID and store it in settings."""
+        self.analysis_id = analysis_id
+        settings = Settings()
+        settings.set_integer("revengai.analysis_id", self.analysis_id)
+        return

features/configuration/config_dialog.py

@@ -1,32 +1,10 @@
 from PySide6.QtWidgets import (QDialog, QVBoxLayout, QHBoxLayout, QLabel, 
                                  QLineEdit, QPushButton, QMessageBox, QProgressDialog, QProgressBar)
-from PySide6.QtCore import Qt, QThread, Signal
+from PySide6.QtCore import Qt
 from PySide6.QtGui import QPixmap
 from binaryninja import log_info, log_error, log_warn
 import os
-
-class ConfigSaveThread(QThread):
-    finished = Signal(bool, str)
-    
-    def __init__(self, config, api_key, host):
-        super().__init__()
-        self.config = config
-        self.api_key = api_key
-        self.host = host
-        
-    def run(self):
-        try:
-            self.config.api_key = self.api_key
-            self.config.host = self.host
-            success = self.config.save_config()
-            
-            if not success:
-                self.finished.emit(False, "API key not valid or host not reachable.")
-            else:
-                self.finished.emit(True, "")
-                
-        except Exception as e:
-            self.finished.emit(False, str(e))
+from .config_save_thread import ConfigSaveThread
 
 class ConfigDialog(QDialog):
     def __init__(self, config):
@@ -152,18 +130,18 @@ def save_config(self):
         self.progress.findChild(QProgressBar).setMinimumWidth(250)
         self.progress.findChild(QProgressBar).setMinimumHeight(20)
         self.progress.setStyleSheet("""
-            QProgressBar {
-                border: 1px solid #cccccc;
-                border-radius: 4px;
-                text-align: center;
-                background-color: #f0f0f0;
-                min-width: 250px;
-                min-height: 20px;
-            }
-            QProgressBar::chunk {
-                background-color: #007bff;
-                border-radius: 3px;
-            }
+                QProgressBar {
+                    border: 1px solid #cccccc;
+                    border-radius: 4px;
+                    text-align: center;
+                    background-color: #f0f0f0;
+                    min-width: 250px;
+                    min-height: 20px;
+                }
+                QProgressBar::chunk {
+                    background-color: #007bff;
+                    border-radius: 3px;
+                }
         """)
 
         self.save_thread = ConfigSaveThread(self.config, api_key, host)

features/configuration/config_save_thread.py

@@ -0,0 +1,24 @@
+from PySide6.QtCore import QThread, Signal
+
+class ConfigSaveThread(QThread):
+    finished = Signal(bool, str)
+    
+    def __init__(self, config, api_key, host):
+        super().__init__()
+        self.config = config
+        self.api_key = api_key
+        self.host = host
+        
+    def run(self):
+        try:
+            self.config.api_key = self.api_key
+            self.config.host = self.host
+            success = self.config.save_config()
+            
+            if not success:
+                self.finished.emit(False, "API key not valid or host not reachable.")
+            else:
+                self.finished.emit(True, "")
+                
+        except Exception as e:
+            self.finished.emit(False, str(e)) 

features/upload/__init__.py

@@ -8,7 +8,7 @@ def __init__(self, config=None):
         super().__init__(config)
         self.uploader = BinaryUploader(config)
         log_info("RevEng.AI | Process Feature initialized")
-        
+
     def register(self):
         PluginCommand.register(
             "RevEng.AI\\Process Binary",
@@ -17,8 +17,8 @@ def register(self):
             self.is_valid
         )
         log_info("RevEng.AI | Process Feature registered")
-        
+
     def show_upload_dialog(self, bv):
+        log_info("RevEng.AI | Opening process dialog")
         dialog = UploadDialog(self.config, self.uploader, bv)
-        if dialog.exec() == UploadDialog.Accepted:
-            self.uploader.upload_binary(bv, dialog.get_upload_options())
+        dialog.exec()

features/upload/model_load_thread.py

@@ -0,0 +1,19 @@
+from PySide6.QtCore import QThread, Signal
+from binaryninja import log_error
+
+class ModelLoadThread(QThread):
+    finished = Signal(list)  # Signal emitting the loaded models
+    error = Signal(str)     # Signal for error handling
+    
+    def __init__(self, uploader, bv):
+        super().__init__()
+        self.uploader = uploader
+        self.bv = bv
+        
+    def run(self):
+        try:
+            models = self.uploader.get_models(self.bv)
+            self.finished.emit(models)
+        except Exception as e:
+            log_error(f"RevEng.AI | Failed to load models: {str(e)}")
+            self.error.emit(str(e)) 

features/upload/upload.py

@@ -1,36 +1,105 @@
-from binaryninja import BinaryView, log_info, log_error
-from reait.api import RE_models
+from binaryninja import BinaryView, log_info, log_error, log_debug, SymbolType, BinaryViewType
+from reait.api import RE_models, RE_upload, RE_analysis_lookup, RE_analyse
+import json
 
 class BinaryUploader:
     def __init__(self, config):
         self.config = config
 
 
-    def get_models(self):
+    def get_models(self, bv: BinaryView):
         try:
+            guess_model_platform = ""
+            if bv.view_type == "PE":
+                guess_model_platform = "windows"
+            elif bv.view_type == "ELF":
+                guess_model_platform = "linux"
+            elif bv.view_type == "MACHO":
+                guess_model_platform = "macos"
+
+            guess_model_arch = ""
+            if bv.arch.name == "x86":
+                guess_model_arch = "x86-32"
+            elif bv.arch.name == "x86_64":
+                guess_model_arch = "x86"
+            else:
+                guess_model_arch = bv.arch.name
+            
+            log_info(f"RevEng.AI | Architecture: {bv.arch.name} | File type: {bv.view_type}")
             models = RE_models().json()
-            return set([model["model_name"] for model in models["models"]])
+            models = list([model["model_name"] for model in models["models"]])
+
+            guess_model =  f"{guess_model_arch}-{guess_model_platform}"
+            log_info(f"RevEng.AI | Guess model: {guess_model}")
+            for i, model in enumerate(models):
+                if guess_model in model:
+                    log_info(f"RevEng.AI | Found model: {model}")
+                    models.insert(0, models.pop(i))
+                    break
+            log_info(f"RevEng.AI | Models: {models}")
+            return models
         except Exception as e:
-            log_error(f"Failed to get models: {str(e)}")
-            return set()
+            log_error(f"RevEng.AI | Failed to get models: {str(e)}")
+            return []
 
 
     def upload_binary(self, bv: BinaryView, options: dict):
         try:
-            log_info(f"Uploading binary {bv.file.filename} with options: {options}")
-            log_info(f"Options: {options}")
-            log_info(f"Binary size: {bv.file}")
-            self.config.save_config()
+            log_info(f"RevEng.AI | Uploading binary {bv.file.filename}.")
+
+            upload = RE_upload(bv.file.filename).json()   
+
+            if not upload.get("success", False):
+                log_error(f"RevEng.AI | Failed to upload binary {bv.file.filename}.")
+                return False
+
+            log_info(f"RevEng.AI | Binary {bv.file.filename} uploaded successfully.")
+
+            sha_256_hash = upload["sha_256_hash"]
+            log_info(f"RevEng.AI | SHA-256 hash: {sha_256_hash}")
 
-            # TODO: Implement actual upload logic here
-            # This will involve:
-            # 1. Getting the binary data from bv
-            # 2. Use the RE_upload_binary function to upload the binary
-            # 3. Handling the response
+            # Convert symbols to a list of dictionaries with hex strings
+            symbols = []
+            log_info(f"RevEng.AI | Image Base: {bv.image_base:x}")
+            for key, value in bv.symbols.items():
+                if value[0].type == SymbolType.FunctionSymbol:
+                    func = bv.get_function_at(value[0].address)
+                    symbols.append({
+                        "name": func.name,
+                        "start": func.start,
+                        "end": func.start + func.total_bytes,
+                    })
+                    log_info(f"RevEng.AI | Name: {key} | Start: {func.start:x} | End: {func.start + func.total_bytes:x} | Size: {func.total_bytes}")
+
+            # Log all analysis parameters
+            log_info("RevEng.AI | Analysis parameters:")
+            log_info(f"RevEng.AI | - File path: {bv.file.filename}")
+            log_info(f"RevEng.AI | - Binary scope: {'PRIVATE' if options['is_private'] else 'PUBLIC'}")
+            log_info(f"RevEng.AI | - Debug info path: {options.get('debug_info', None)}")
+            log_info(f"RevEng.AI | - Model name: {options['model']}")
+            log_info(f"RevEng.AI | - Tags: {options.get('tags', [])}")
+            log_info(f"RevEng.AI | - Number of symbols: {len(symbols)}")
+                
+            analysis = RE_analyse(
+                fpath=bv.file.filename,
+                binary_scope= "PRIVATE" if options["is_private"] else "PUBLIC",
+                model_name=options["model"],
+                tags=options["tags"],
+                symbols=symbols
+            ).json()
+
+            log_info(f"RevEng.AI | Analysis response: {analysis}")
+
+            binary_id = analysis["binary_id"]
+            analysis_info = RE_analysis_lookup(str(binary_id)).json()
+                
+            log_info(f"RevEng.AI | Analysis info: {analysis_info}")
 
-            log_info(f"Binary {bv.file.filename} uploaded successfully with options: {options}")
+            self.config.set_binary_id(binary_id)
+            self.config.set_analysis_id(analysis_info["analysis_id"])
+                
             return True
 
         except Exception as e:
-            log_error(f"Failed to upload binary: {str(e)}")
+            log_error(f"RevEng.AI | Failed to upload binary: {str(e)}")
             return False 

features/upload/upload_binary_thread.py

@@ -0,0 +1,20 @@
+from PySide6.QtCore import QThread, Signal
+
+class UploadBinaryThread(QThread):
+    finished = Signal(bool, str)  # Signal for success/failure and error message
+    
+    def __init__(self, uploader, bv, options):
+        super().__init__()
+        self.uploader = uploader
+        self.bv = bv
+        self.options = options
+        
+    def run(self):
+        try:
+            success = self.uploader.upload_binary(self.bv, self.options)
+            if success:
+                self.finished.emit(True, "")
+            else:
+                self.finished.emit(False, "Duplicate binary or host not reachable.")
+        except Exception as e:
+            self.finished.emit(False, str(e))