souleyez 2.43.29__py3-none-any.whl → 2.43.34__py3-none-any.whl

souleyez/core/msf_sync_manager.py

@@ -22,7 +22,11 @@ from souleyez.storage.hosts import HostManager
 from souleyez.storage.findings import FindingsManager
 from souleyez.storage.credentials import CredentialsManager
 from souleyez.storage.exploit_attempts import record_attempt
-from souleyez.storage.msf_sessions import add_msf_session, get_msf_sessions, close_msf_session
+from souleyez.storage.msf_sessions import (
+    add_msf_session,
+    get_msf_sessions,
+    close_msf_session,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -38,7 +42,7 @@ def get_msf_database_config() -> Optional[Dict[str, Any]]:
     """
     # Check user config first, then system-wide config (Kali uses system-wide)
     user_db_path = Path.home() / ".msf4" / "database.yml"
-    system_db_path = Path('/usr/share/metasploit-framework/config/database.yml')
+    system_db_path = Path("/usr/share/metasploit-framework/config/database.yml")
 
     db_yml_path = None
     if user_db_path.exists():
@@ -53,13 +57,13 @@ def get_msf_database_config() -> Optional[Dict[str, Any]]:
     try:
         import yaml
 
-        with open(db_yml_path, 'r') as f:
+        with open(db_yml_path, "r") as f:
             config = yaml.safe_load(f)
 
         # MSF database.yml has environment sections (development, production, etc.)
         # Look for 'production' first, then 'development', then any section
         env_config = None
-        for env in ['production', 'development']:
+        for env in ["production", "development"]:
             if env in config:
                 env_config = config[env]
                 break
@@ -67,7 +71,7 @@ def get_msf_database_config() -> Optional[Dict[str, Any]]:
         if not env_config:
             # Take the first available section
             for key, val in config.items():
-                if isinstance(val, dict) and 'database' in val:
+                if isinstance(val, dict) and "database" in val:
                     env_config = val
                     break
 
@@ -76,12 +80,12 @@ def get_msf_database_config() -> Optional[Dict[str, Any]]:
             return None
 
         return {
-            'host': env_config.get('host', 'localhost'),
-            'port': env_config.get('port', 5432),
-            'database': env_config.get('database', 'msf'),
-            'username': env_config.get('username', 'msf'),
-            'password': env_config.get('password', ''),
-            'workspace': 'default'
+            "host": env_config.get("host", "localhost"),
+            "port": env_config.get("port", 5432),
+            "database": env_config.get("database", "msf"),
+            "username": env_config.get("username", "msf"),
+            "password": env_config.get("password", ""),
+            "workspace": "default",
         }
     except ImportError:
         logger.debug("PyYAML not available, cannot parse database.yml")
@@ -106,6 +110,7 @@ def get_msf_active_sessions_count() -> Optional[int]:
     # Method 1: Try MSF RPC first (most reliable when msfrpcd is running)
     try:
         from souleyez.core.msf_rpc_client import MSFRPCClient, MSGPACK_AVAILABLE
+
         if MSGPACK_AVAILABLE:
             # Try connecting without password first (some setups don't require it)
             client = MSFRPCClient()
@@ -156,22 +161,22 @@ def _map_msf_state_to_status(msf_state: Optional[str]) -> str:
         SoulEyez status value ('up' or 'down')
     """
     if not msf_state:
-        return 'up'  # Default for null/empty
+        return "up"  # Default for null/empty
 
     state_lower = msf_state.lower()
 
     # Map MSF state to SoulEyez status
-    if state_lower == 'alive':
-        return 'up'
-    elif state_lower == 'dead':
-        return 'down'
-    elif state_lower in ('up', 'down'):
+    if state_lower == "alive":
+        return "up"
+    elif state_lower == "dead":
+        return "down"
+    elif state_lower in ("up", "down"):
         # Already in correct format
         return state_lower
     else:
         # Unknown state - log warning and default to up
         logger.warning(f"Unknown MSF host state '{msf_state}', defaulting to 'up'")
-        return 'up'
+        return "up"
 
 
 class MSFSyncManager:
@@ -182,7 +187,7 @@ class MSFSyncManager:
         db_path: str,
         engagement_id: int,
         msf_db_config: Optional[Dict[str, Any]] = None,
-        msf_rpc_config: Optional[Dict[str, Any]] = None
+        msf_rpc_config: Optional[Dict[str, Any]] = None,
     ):
         """
         Initialize MSF sync manager
@@ -196,19 +201,19 @@ class MSFSyncManager:
         self.db_path = db_path
         self.engagement_id = engagement_id
         self.msf_db_config = msf_db_config or {
-            'host': 'localhost',
-            'port': 5432,
-            'database': 'msf',
-            'username': 'msf',
-            'password': '',
-            'workspace': 'default'
+            "host": "localhost",
+            "port": 5432,
+            "database": "msf",
+            "username": "msf",
+            "password": "",
+            "workspace": "default",
         }
         self.msf_rpc_config = msf_rpc_config or {
-            'host': '127.0.0.1',
-            'port': 55553,
-            'username': 'msf',
-            'password': '',
-            'ssl': False
+            "host": "127.0.0.1",
+            "port": 55553,
+            "username": "msf",
+            "password": "",
+            "ssl": False,
         }
 
     def import_msf_data(
@@ -217,7 +222,7 @@ class MSFSyncManager:
         import_services: bool = True,
         import_vulns: bool = True,
         import_creds: bool = True,
-        import_sessions: bool = True
+        import_sessions: bool = True,
     ) -> Dict[str, int]:
         """
         Import data from MSF database into SoulEyez
@@ -233,12 +238,12 @@ class MSFSyncManager:
             Dictionary with counts of imported items
         """
         stats = {
-            'hosts': 0,
-            'services': 0,
-            'vulns': 0,
-            'creds': 0,
-            'sessions': 0,
-            'errors': 0
+            "hosts": 0,
+            "services": 0,
+            "vulns": 0,
+            "creds": 0,
+            "sessions": 0,
+            "errors": 0,
         }
 
         try:
@@ -247,58 +252,62 @@ class MSFSyncManager:
                 if import_hosts:
                     try:
                         hosts_imported = self._import_hosts(msf_db)
-                        stats['hosts'] = hosts_imported
+                        stats["hosts"] = hosts_imported
                     except (KeyError, AttributeError) as e:
                         logger.error(f"Schema error importing hosts: {e}")
-                        logger.error("MSF database schema may have changed. Consider using XML export.")
-                        stats['errors'] += 1
+                        logger.error(
+                            "MSF database schema may have changed. Consider using XML export."
+                        )
+                        stats["errors"] += 1
 
                 # Import services
                 if import_services:
                     try:
                         services_imported = self._import_services(msf_db)
-                        stats['services'] = services_imported
+                        stats["services"] = services_imported
                     except (KeyError, AttributeError) as e:
                         logger.error(f"Schema error importing services: {e}")
-                        stats['errors'] += 1
+                        stats["errors"] += 1
 
                 # Import vulnerabilities
                 if import_vulns:
                     try:
                         vulns_imported = self._import_vulns(msf_db)
-                        stats['vulns'] = vulns_imported
+                        stats["vulns"] = vulns_imported
                     except (KeyError, AttributeError) as e:
                         logger.error(f"Schema error importing vulnerabilities: {e}")
-                        stats['errors'] += 1
+                        stats["errors"] += 1
 
                 # Import credentials
                 if import_creds:
                     try:
                         creds_imported = self._import_creds(msf_db)
-                        stats['creds'] = creds_imported
+                        stats["creds"] = creds_imported
                     except (KeyError, AttributeError) as e:
                         logger.error(f"Schema error importing credentials: {e}")
-                        stats['errors'] += 1
+                        stats["errors"] += 1
 
                 # Import sessions
                 if import_sessions:
                     try:
                         sessions_imported = self._import_sessions(msf_db)
-                        stats['sessions'] = sessions_imported
+                        stats["sessions"] = sessions_imported
                     except (KeyError, AttributeError) as e:
                         logger.error(f"Schema error importing sessions: {e}")
-                        stats['errors'] += 1
+                        stats["errors"] += 1
 
         except MSFDatabaseSchemaError as e:
             logger.error(f"MSF database schema is incompatible: {e}")
             logger.error("RECOMMENDATION: Use MSF XML export instead:")
             logger.error("  In msfconsole: db_export -f xml /tmp/msf_export.xml")
             logger.error("  Then import the XML file into SoulEyez")
-            stats['errors'] += 1
+            stats["errors"] += 1
         except Exception as e:
             logger.error(f"Failed to import MSF data: {e}")
-            logger.error("If this error persists, try using MSF XML export as an alternative")
-            stats['errors'] += 1
+            logger.error(
+                "If this error persists, try using MSF XML export as an alternative"
+            )
+            stats["errors"] += 1
 
         return stats
 
@@ -312,24 +321,28 @@ class MSFSyncManager:
         for msf_host in msf_hosts:
             try:
                 # Check if host already exists
-                existing = host_mgr.get_host_by_ip(self.engagement_id, msf_host['address'])
+                existing = host_mgr.get_host_by_ip(
+                    self.engagement_id, msf_host["address"]
+                )
 
                 if not existing:
                     # Add new host
                     # Map MSF state ('alive'/'dead') to SoulEyez status ('up'/'down')
-                    msf_state = msf_host.get('state')
+                    msf_state = msf_host.get("state")
                     souleyez_status = _map_msf_state_to_status(msf_state)
 
                     host_data = {
-                        'ip': msf_host['address'],
-                        'hostname': msf_host.get('name') or None,
-                        'mac_address': msf_host.get('mac') or None,
-                        'os': msf_host.get('os_name') or None,
-                        'status': souleyez_status
+                        "ip": msf_host["address"],
+                        "hostname": msf_host.get("name") or None,
+                        "mac_address": msf_host.get("mac") or None,
+                        "os": msf_host.get("os_name") or None,
+                        "status": souleyez_status,
                     }
                     host_mgr.add_or_update_host(self.engagement_id, host_data)
                     count += 1
-                    logger.debug(f"Imported host {msf_host['address']} with status '{souleyez_status}' (MSF state: '{msf_state}')")
+                    logger.debug(
+                        f"Imported host {msf_host['address']} with status '{souleyez_status}' (MSF state: '{msf_state}')"
+                    )
             except Exception as e:
                 logger.error(f"Failed to import host {msf_host['address']}: {e}")
 
@@ -346,27 +359,33 @@ class MSFSyncManager:
         for msf_svc in msf_services:
             try:
                 # Get or create host
-                host = host_mgr.get_host_by_ip(self.engagement_id, msf_svc['host_address'])
+                host = host_mgr.get_host_by_ip(
+                    self.engagement_id, msf_svc["host_address"]
+                )
                 if not host:
                     # Create host if it doesn't exist
-                    logger.debug(f"Creating host for service: {msf_svc['host_address']}")
-                    host_data = {'ip': msf_svc['host_address']}
+                    logger.debug(
+                        f"Creating host for service: {msf_svc['host_address']}"
+                    )
+                    host_data = {"ip": msf_svc["host_address"]}
                     host_id = host_mgr.add_or_update_host(self.engagement_id, host_data)
                 else:
-                    host_id = host['id']
+                    host_id = host["id"]
 
                 # Add or update service (add_service handles duplicates)
                 service_data = {
-                    'port': msf_svc['port'],
-                    'protocol': msf_svc.get('proto', 'tcp'),
-                    'state': msf_svc.get('state', 'open'),
-                    'service': msf_svc.get('name') or 'unknown',
-                    'product': msf_svc.get('info') or None
+                    "port": msf_svc["port"],
+                    "protocol": msf_svc.get("proto", "tcp"),
+                    "state": msf_svc.get("state", "open"),
+                    "service": msf_svc.get("name") or "unknown",
+                    "product": msf_svc.get("info") or None,
                 }
                 host_mgr.add_service(host_id, service_data)
                 count += 1
             except Exception as e:
-                logger.error(f"Failed to import service on {msf_svc.get('host_address')}:{msf_svc.get('port')}: {e}")
+                logger.error(
+                    f"Failed to import service on {msf_svc.get('host_address')}:{msf_svc.get('port')}: {e}"
+                )
                 skipped += 1
 
         if skipped > 0:
@@ -386,46 +405,56 @@ class MSFSyncManager:
         for msf_vuln in msf_vulns:
             try:
                 # Get host
-                host = host_mgr.get_host_by_ip(self.engagement_id, msf_vuln['host_address'])
+                host = host_mgr.get_host_by_ip(
+                    self.engagement_id, msf_vuln["host_address"]
+                )
                 if not host:
-                    logger.debug(f"Skipping vuln - host not found: {msf_vuln['host_address']}")
+                    logger.debug(
+                        f"Skipping vuln - host not found: {msf_vuln['host_address']}"
+                    )
                     skipped += 1
                     continue
 
                 # Get service if available
-                port = msf_vuln.get('service_port')
+                port = msf_vuln.get("service_port")
                 if port:
-                    services = host_mgr.get_host_services(host['id'])
+                    services = host_mgr.get_host_services(host["id"])
                     matching_services = [
-                        s for s in services
-                        if s['port'] == port and s['protocol'] == msf_vuln.get('service_proto', 'tcp')
+                        s
+                        for s in services
+                        if s["port"] == port
+                        and s["protocol"] == msf_vuln.get("service_proto", "tcp")
                     ]
                 else:
                     matching_services = []
 
                 # Determine severity from vuln name/info
-                severity = self._determine_severity(msf_vuln.get('name', ''))
+                severity = self._determine_severity(msf_vuln.get("name", ""))
 
                 # Add finding
                 findings_mgr.add_finding(
                     engagement_id=self.engagement_id,
-                    title=msf_vuln.get('name', 'Unknown Vulnerability'),
-                    finding_type='vulnerability',
+                    title=msf_vuln.get("name", "Unknown Vulnerability"),
+                    finding_type="vulnerability",
                     severity=severity,
-                    description=msf_vuln.get('info') or '',
-                    host_id=host['id'],
-                    tool='metasploit',
-                    refs=msf_vuln.get('refs') or '',
+                    description=msf_vuln.get("info") or "",
+                    host_id=host["id"],
+                    tool="metasploit",
+                    refs=msf_vuln.get("refs") or "",
                     port=port,
-                    evidence=f"MSF Vuln ID: {msf_vuln['id']}"
+                    evidence=f"MSF Vuln ID: {msf_vuln['id']}",
                 )
                 count += 1
             except Exception as e:
-                logger.error(f"Failed to import vulnerability '{msf_vuln.get('name')}': {e}")
+                logger.error(
+                    f"Failed to import vulnerability '{msf_vuln.get('name')}': {e}"
+                )
                 skipped += 1
 
         if skipped > 0:
-            logger.warning(f"Skipped {skipped} vulnerabilities (host not found or errors)")
+            logger.warning(
+                f"Skipped {skipped} vulnerabilities (host not found or errors)"
+            )
 
         return count
 
@@ -441,41 +470,55 @@ class MSFSyncManager:
         for msf_cred in msf_creds:
             try:
                 # Skip if no host address
-                if not msf_cred.get('host_address'):
-                    logger.debug(f"Skipping credential - no host address (service-less credential)")
+                if not msf_cred.get("host_address"):
+                    logger.debug(
+                        f"Skipping credential - no host address (service-less credential)"
+                    )
                     skipped += 1
                     continue
 
                 # Get host
-                host = host_mgr.get_host_by_ip(self.engagement_id, msf_cred['host_address'])
+                host = host_mgr.get_host_by_ip(
+                    self.engagement_id, msf_cred["host_address"]
+                )
                 if not host:
-                    logger.debug(f"Skipping credential - host not found: {msf_cred['host_address']}")
+                    logger.debug(
+                        f"Skipping credential - host not found: {msf_cred['host_address']}"
+                    )
                     skipped += 1
                     continue
 
                 # Create credential finding
-                username = msf_cred.get('username', 'N/A')
-                private_data = msf_cred.get('private_data', 'N/A')
-                private_type = msf_cred.get('private_type', 'password')
+                username = msf_cred.get("username", "N/A")
+                private_data = msf_cred.get("private_data", "N/A")
+                private_type = msf_cred.get("private_type", "password")
 
                 findings_mgr.add_finding(
                     engagement_id=self.engagement_id,
                     title=f"Credential Found: {username}",
-                    finding_type='credential',
-                    severity='high',
+                    finding_type="credential",
+                    severity="high",
                     description=f"Username: {username}\nType: {private_type}\nStatus: {msf_cred.get('status', 'unknown')}",
-                    host_id=host['id'],
-                    tool='metasploit',
-                    port=msf_cred.get('service_port'),
-                    evidence=f"Private: {private_data[:20]}..." if len(private_data) > 20 else private_data
+                    host_id=host["id"],
+                    tool="metasploit",
+                    port=msf_cred.get("service_port"),
+                    evidence=(
+                        f"Private: {private_data[:20]}..."
+                        if len(private_data) > 20
+                        else private_data
+                    ),
                 )
                 count += 1
             except Exception as e:
-                logger.error(f"Failed to import credential for {msf_cred.get('username')}: {e}")
+                logger.error(
+                    f"Failed to import credential for {msf_cred.get('username')}: {e}"
+                )
                 skipped += 1
 
         if skipped > 0:
-            logger.warning(f"Skipped {skipped} credentials (no host address or host not found)")
+            logger.warning(
+                f"Skipped {skipped} credentials (no host address or host not found)"
+            )
 
         return count
 
@@ -489,37 +532,42 @@ class MSFSyncManager:
 
         # Get database connection for msf_sessions functions
         from souleyez.storage.database import get_db
+
         db = get_db()
         conn = db.get_connection()
 
         for msf_session in msf_sessions:
             try:
                 # Get host
-                host = host_mgr.get_host_by_ip(self.engagement_id, msf_session['host_address'])
+                host = host_mgr.get_host_by_ip(
+                    self.engagement_id, msf_session["host_address"]
+                )
                 if not host:
-                    session_num = msf_session.get('local_id') or msf_session['id']
-                    logger.debug(f"Skipping session {session_num} - host not found: {msf_session['host_address']}")
+                    session_num = msf_session.get("local_id") or msf_session["id"]
+                    logger.debug(
+                        f"Skipping session {session_num} - host not found: {msf_session['host_address']}"
+                    )
                     skipped += 1
                     continue
 
                 # Add session to msf_sessions table
-                is_active = msf_session.get('closed_at') is None
+                is_active = msf_session.get("closed_at") is None
 
                 session_id = add_msf_session(
                     conn,
                     engagement_id=self.engagement_id,
-                    host_id=host['id'],
-                    msf_session_id=msf_session.get('local_id') or msf_session['id'],
-                    session_type=msf_session.get('stype'),
-                    via_exploit=msf_session.get('via_exploit'),
-                    via_payload=msf_session.get('via_payload'),
-                    platform=msf_session.get('platform'),
+                    host_id=host["id"],
+                    msf_session_id=msf_session.get("local_id") or msf_session["id"],
+                    session_type=msf_session.get("stype"),
+                    via_exploit=msf_session.get("via_exploit"),
+                    via_payload=msf_session.get("via_payload"),
+                    platform=msf_session.get("platform"),
                     arch=None,  # Not available in DB schema
                     username=None,  # Not available in DB schema
-                    port=msf_session.get('port'),
+                    port=msf_session.get("port"),
                     tunnel_peer=None,  # Not available in DB schema
-                    opened_at=msf_session.get('opened_at'),
-                    notes=msf_session.get('desc')
+                    opened_at=msf_session.get("opened_at"),
+                    notes=msf_session.get("desc"),
                 )
 
                 # Mark as closed if applicable
@@ -527,24 +575,24 @@ class MSFSyncManager:
                     close_msf_session(
                         conn,
                         self.engagement_id,
-                        msf_session.get('local_id') or msf_session['id'],
-                        msf_session.get('close_reason')
+                        msf_session.get("local_id") or msf_session["id"],
+                        msf_session.get("close_reason"),
                     )
 
                 count += 1
 
                 # If session was created via exploit, mark that exploit as successful
-                via_exploit = msf_session.get('via_exploit')
-                if via_exploit and via_exploit not in ['unknown', '']:
-                    session_num = msf_session.get('local_id') or msf_session['id']
+                via_exploit = msf_session.get("via_exploit")
+                if via_exploit and via_exploit not in ["unknown", ""]:
+                    session_num = msf_session.get("local_id") or msf_session["id"]
                     self._mark_exploit_success(
-                        host['id'],
-                        via_exploit,
-                        f"Session {session_num} created"
+                        host["id"], via_exploit, f"Session {session_num} created"
                     )
 
             except Exception as e:
-                session_num = msf_session.get('local_id') or msf_session.get('id', 'unknown')
+                session_num = msf_session.get("local_id") or msf_session.get(
+                    "id", "unknown"
+                )
                 logger.error(f"Failed to import session {session_num}: {e}")
                 skipped += 1
 
@@ -568,11 +616,7 @@ class MSFSyncManager:
         Returns:
             Dictionary with counts of updated exploits
         """
-        stats = {
-            'success': 0,
-            'failed': 0,
-            'errors': 0
-        }
+        stats = {"success": 0, "failed": 0, "errors": 0}
 
         try:
             with MSFDatabase(**self.msf_db_config) as msf_db:
@@ -584,42 +628,45 @@ class MSFSyncManager:
                 for attempt in exploit_attempts:
                     try:
                         # Get host
-                        host = host_mgr.get_host_by_ip(self.engagement_id, attempt['host_address'])
+                        host = host_mgr.get_host_by_ip(
+                            self.engagement_id, attempt["host_address"]
+                        )
                         if not host:
                             continue
 
                         # Get service if available
                         service_id = None
-                        if attempt.get('service_port'):
-                            services = host_mgr.get_host_services(host['id'])
+                        if attempt.get("service_port"):
+                            services = host_mgr.get_host_services(host["id"])
                             matching_services = [
-                                s for s in services
-                                if s['port'] == attempt['service_port'] and
-                                   s['protocol'] == attempt.get('service_proto', 'tcp')
+                                s
+                                for s in services
+                                if s["port"] == attempt["service_port"]
+                                and s["protocol"] == attempt.get("service_proto", "tcp")
                             ]
                             if matching_services:
-                                service_id = matching_services[0]['id']
+                                service_id = matching_services[0]["id"]
 
                         # Record exploit attempt with success status
-                        exploit_name = attempt.get('vuln_name', 'unknown')
+                        exploit_name = attempt.get("vuln_name", "unknown")
                         record_attempt(
                             engagement_id=self.engagement_id,
-                            host_id=host['id'],
+                            host_id=host["id"],
                             exploit_identifier=f"msf:{exploit_name}",
                             exploit_title=exploit_name,
-                            status='success',
+                            status="success",
                             service_id=service_id,
-                            notes=f"Exploited at: {attempt['exploited_at']}"
+                            notes=f"Exploited at: {attempt['exploited_at']}",
                         )
-                        stats['success'] += 1
+                        stats["success"] += 1
 
                     except Exception as e:
                         logger.error(f"Failed to sync exploit result: {e}")
-                        stats['errors'] += 1
+                        stats["errors"] += 1
 
         except Exception as e:
             logger.error(f"Failed to sync exploit results: {e}")
-            stats['errors'] += 1
+            stats["errors"] += 1
 
         return stats
 
@@ -638,50 +685,55 @@ class MSFSyncManager:
                 with MSFRPCClient(**self.msf_rpc_config) as rpc:
                     rpc_sessions = rpc.list_sessions()
                     for session_id, session_info in rpc_sessions.items():
-                        sessions.append({
-                            'id': session_id,
-                            'type': session_info.get('type', 'unknown'),
-                            'tunnel': session_info.get('tunnel_peer', 'unknown'),
-                            'via_exploit': session_info.get('via_exploit', 'unknown'),
-                            'via_payload': session_info.get('via_payload', 'unknown'),
-                            'info': session_info.get('info', ''),
-                            'username': session_info.get('username', ''),
-                            'platform': session_info.get('platform', ''),
-                            'arch': session_info.get('arch', ''),
-                            'source': 'rpc'
-                        })
+                        sessions.append(
+                            {
+                                "id": session_id,
+                                "type": session_info.get("type", "unknown"),
+                                "tunnel": session_info.get("tunnel_peer", "unknown"),
+                                "via_exploit": session_info.get(
+                                    "via_exploit", "unknown"
+                                ),
+                                "via_payload": session_info.get(
+                                    "via_payload", "unknown"
+                                ),
+                                "info": session_info.get("info", ""),
+                                "username": session_info.get("username", ""),
+                                "platform": session_info.get("platform", ""),
+                                "arch": session_info.get("arch", ""),
+                                "source": "rpc",
+                            }
+                        )
                     return sessions
             except Exception as rpc_error:
-                logger.debug(f"RPC not available, falling back to database: {rpc_error}")
+                logger.debug(
+                    f"RPC not available, falling back to database: {rpc_error}"
+                )
 
             # Fallback to database
             with MSFDatabase(**self.msf_db_config) as msf_db:
                 msf_sessions = msf_db.get_sessions(active_only=True)
                 for session in msf_sessions:
-                    sessions.append({
-                        'id': session['id'],
-                        'type': session.get('stype', 'unknown'),
-                        'host': session.get('host_address', 'unknown'),
-                        'port': session.get('port', 0),
-                        'via_exploit': session.get('via_exploit', 'unknown'),
-                        'via_payload': session.get('via_payload', 'unknown'),
-                        'platform': session.get('platform', ''),
-                        'opened_at': session.get('opened_at'),
-                        'last_seen': session.get('last_seen'),
-                        'source': 'database'
-                    })
+                    sessions.append(
+                        {
+                            "id": session["id"],
+                            "type": session.get("stype", "unknown"),
+                            "host": session.get("host_address", "unknown"),
+                            "port": session.get("port", 0),
+                            "via_exploit": session.get("via_exploit", "unknown"),
+                            "via_payload": session.get("via_payload", "unknown"),
+                            "platform": session.get("platform", ""),
+                            "opened_at": session.get("opened_at"),
+                            "last_seen": session.get("last_seen"),
+                            "source": "database",
+                        }
+                    )
 
         except Exception as e:
             logger.error(f"Failed to get active sessions: {e}")
 
         return sessions
 
-    def _mark_exploit_success(
-        self,
-        host_id: int,
-        exploit_name: str,
-        notes: str = ""
-    ):
+    def _mark_exploit_success(self, host_id: int, exploit_name: str, notes: str = ""):
         """Mark an exploit as successful"""
         try:
             # Record successful exploit attempt
@@ -690,9 +742,9 @@ class MSFSyncManager:
                 host_id=host_id,
                 exploit_identifier=f"msf:{exploit_name}",
                 exploit_title=exploit_name,
-                status='success',
+                status="success",
                 service_id=None,
-                notes=notes
+                notes=notes,
             )
         except Exception as e:
             logger.debug(f"Failed to mark exploit success: {e}")
@@ -701,14 +753,22 @@ class MSFSyncManager:
         """Determine severity from vulnerability name"""
         vuln_lower = vuln_name.lower()
 
-        if any(x in vuln_lower for x in ['rce', 'remote code', 'command execution', 'backdoor']):
-            return 'critical'
-        elif any(x in vuln_lower for x in ['exploit', 'overflow', 'injection', 'authentication bypass']):
-            return 'high'
-        elif any(x in vuln_lower for x in ['disclosure', 'exposure', 'misconfiguration']):
-            return 'medium'
+        if any(
+            x in vuln_lower
+            for x in ["rce", "remote code", "command execution", "backdoor"]
+        ):
+            return "critical"
+        elif any(
+            x in vuln_lower
+            for x in ["exploit", "overflow", "injection", "authentication bypass"]
+        ):
+            return "high"
+        elif any(
+            x in vuln_lower for x in ["disclosure", "exposure", "misconfiguration"]
+        ):
+            return "medium"
         else:
-            return 'low'
+            return "low"
 
     def get_msf_stats(self) -> Dict[str, Any]:
         """