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

souleyez/core/msf_rpc_client.py

@@ -14,10 +14,12 @@ import time
 
 # Suppress SSL warnings for self-signed certs (msfrpcd uses self-signed)
 from urllib3.exceptions import InsecureRequestWarning
-warnings.filterwarnings('ignore', category=InsecureRequestWarning)
+
+warnings.filterwarnings("ignore", category=InsecureRequestWarning)
 
 try:
     import msgpack
+
     MSGPACK_AVAILABLE = True
 except ImportError:
     MSGPACK_AVAILABLE = False
@@ -34,7 +36,7 @@ class MSFRPCClient:
         port: int = 55553,
         username: str = "msf",
         password: str = "",
-        ssl: bool = False
+        ssl: bool = False,
     ):
         """
         Initialize MSF RPC client
@@ -48,8 +50,7 @@ class MSFRPCClient:
         """
         if not MSGPACK_AVAILABLE:
             raise ImportError(
-                "msgpack is required for MSF RPC. "
-                "Install with: pip install msgpack"
+                "msgpack is required for MSF RPC. " "Install with: pip install msgpack"
             )
 
         self.host = host
@@ -58,9 +59,7 @@ class MSFRPCClient:
         self.password = password
         self.ssl = ssl
         self.token = None
-        self.headers = {
-            'Content-Type': 'binary/message-pack'
-        }
+        self.headers = {"Content-Type": "binary/message-pack"}
 
     @property
     def url(self) -> str:
@@ -75,8 +74,7 @@ class MSFRPCClient:
         """
         if isinstance(obj, dict):
             return {
-                (k.decode() if isinstance(k, bytes) else k):
-                self._normalize_keys(v)
+                (k.decode() if isinstance(k, bytes) else k): self._normalize_keys(v)
                 for k, v in obj.items()
             }
         elif isinstance(obj, list):
@@ -112,7 +110,10 @@ class MSFRPCClient:
                 data=request_data,
                 headers=self.headers,
                 verify=False,  # nosec B501 - Metasploit RPC uses self-signed certs
-                timeout=(5, 30)  # (connect_timeout, read_timeout) - fast fail on SSL mismatch
+                timeout=(
+                    5,
+                    30,
+                ),  # (connect_timeout, read_timeout) - fast fail on SSL mismatch
             )
             response.raise_for_status()
 
@@ -124,9 +125,11 @@ class MSFRPCClient:
 
             # Check for errors
             if isinstance(result, dict):
-                if 'error' in result:
-                    raise Exception(f"RPC error: {result.get('error_message', 'Unknown error')}")
-                if 'error_message' in result:
+                if "error" in result:
+                    raise Exception(
+                        f"RPC error: {result.get('error_message', 'Unknown error')}"
+                    )
+                if "error_message" in result:
                     raise Exception(f"RPC error: {result['error_message']}")
 
             return result
@@ -143,8 +146,8 @@ class MSFRPCClient:
         """
         try:
             result = self._call("auth.login", self.username, self.password)
-            if isinstance(result, dict) and 'token' in result:
-                self.token = result['token']
+            if isinstance(result, dict) and "token" in result:
+                self.token = result["token"]
                 logger.info(f"Authenticated with MSF RPC at {self.host}:{self.port}")
                 return True
             logger.error("Authentication failed: No token received")
@@ -194,9 +197,13 @@ class MSFRPCClient:
             List of module names
         """
         try:
-            result = self._call("module.exploits" if module_type == "exploit" else f"module.{module_type}s")
-            if isinstance(result, dict) and 'modules' in result:
-                return result['modules']
+            result = self._call(
+                "module.exploits"
+                if module_type == "exploit"
+                else f"module.{module_type}s"
+            )
+            if isinstance(result, dict) and "modules" in result:
+                return result["modules"]
             return []
         except Exception as e:
             logger.error(f"Failed to list modules: {e}")
@@ -239,10 +246,7 @@ class MSFRPCClient:
             return {}
 
     def execute_module(
-        self,
-        module_type: str,
-        module_name: str,
-        options: Dict[str, Any]
+        self, module_type: str, module_name: str, options: Dict[str, Any]
     ) -> Dict[str, Any]:
         """
         Execute a module
@@ -260,7 +264,7 @@ class MSFRPCClient:
             return result
         except Exception as e:
             logger.error(f"Failed to execute module: {e}")
-            return {'error': str(e)}
+            return {"error": str(e)}
 
     def list_sessions(self) -> Dict[str, Dict[str, Any]]:
         """
@@ -309,10 +313,7 @@ class MSFRPCClient:
             return False
 
     def run_session_command(
-        self,
-        session_id: int,
-        command: str,
-        timeout: int = 30
+        self, session_id: int, command: str, timeout: int = 30
     ) -> str:
         """
         Run a command in a session
@@ -334,8 +335,8 @@ class MSFRPCClient:
 
             # Read output
             result = self._call("session.shell_read", str(session_id))
-            if isinstance(result, dict) and 'data' in result:
-                return result['data']
+            if isinstance(result, dict) and "data" in result:
+                return result["data"]
             return ""
         except Exception as e:
             logger.error(f"Failed to run session command: {e}")
@@ -400,8 +401,8 @@ class MSFRPCClient:
         """
         try:
             result = self._call("console.list")
-            if isinstance(result, dict) and 'consoles' in result:
-                return result['consoles']
+            if isinstance(result, dict) and "consoles" in result:
+                return result["consoles"]
             return []
         except Exception as e:
             logger.error(f"Failed to get console list: {e}")
@@ -416,8 +417,8 @@ class MSFRPCClient:
         """
         try:
             result = self._call("console.create")
-            if isinstance(result, dict) and 'id' in result:
-                return result['id']
+            if isinstance(result, dict) and "id" in result:
+                return result["id"]
             return None
         except Exception as e:
             logger.error(f"Failed to create console: {e}")
@@ -453,8 +454,8 @@ class MSFRPCClient:
         """
         try:
             result = self._call("console.write", console_id, command + "\n")
-            if isinstance(result, dict) and 'wrote' in result:
-                return result['wrote']
+            if isinstance(result, dict) and "wrote" in result:
+                return result["wrote"]
             return 0
         except Exception as e:
             logger.error(f"Failed to write to console: {e}")
@@ -473,8 +474,8 @@ class MSFRPCClient:
         try:
             result = self._call("console.read", console_id)
             if isinstance(result, dict):
-                output = result.get('data', '')
-                busy = result.get('busy', False)
+                output = result.get("data", "")
+                busy = result.get("busy", False)
                 return (output, busy)
             return ("", False)
         except Exception as e:
@@ -482,10 +483,7 @@ class MSFRPCClient:
             return ("", False)
 
     def run_console_command(
-        self,
-        console_id: str,
-        command: str,
-        timeout: int = 30
+        self, console_id: str, command: str, timeout: int = 30
     ) -> str:
         """
         Run a command in console and wait for output
@@ -532,7 +530,7 @@ def test_msf_rpc_connection(
     host: str = "127.0.0.1",
     port: int = 55553,
     username: str = "msf",
-    password: str = ""
+    password: str = "",
 ) -> bool:
     """
     Test MSF RPC connection

souleyez/core/msf_rpc_manager.py

@@ -27,6 +27,7 @@ def is_pro_enabled() -> bool:
     """Check if user has an active Pro license."""
     try:
         from souleyez.licensing.validator import get_active_license
+
         license_info = get_active_license()
         if license_info and license_info.is_valid:
             return license_info.tier.upper() == "PRO"
@@ -37,7 +38,7 @@ def is_pro_enabled() -> bool:
 
 # Session file for sharing decrypted msfrpc password with background worker
 # This file is written when vault is unlocked and cleared on logout
-_SESSION_FILE = os.path.join(os.path.expanduser('~'), '.souleyez', '.msfrpc_session')
+_SESSION_FILE = os.path.join(os.path.expanduser("~"), ".souleyez", ".msfrpc_session")
 
 
 def write_msfrpc_session(password: str) -> bool:
@@ -51,11 +52,12 @@ def write_msfrpc_session(password: str) -> bool:
     """
     try:
         import stat
+
         session_dir = os.path.dirname(_SESSION_FILE)
         os.makedirs(session_dir, exist_ok=True)
 
         # Write with secure permissions
-        with open(_SESSION_FILE, 'w') as f:
+        with open(_SESSION_FILE, "w") as f:
             f.write(password)
         os.chmod(_SESSION_FILE, stat.S_IRUSR | stat.S_IWUSR)  # 600
 
@@ -86,7 +88,7 @@ def _read_msfrpc_session() -> Optional[str]:
     """Read password from session file if it exists."""
     try:
         if os.path.exists(_SESSION_FILE):
-            with open(_SESSION_FILE, 'r') as f:
+            with open(_SESSION_FILE, "r") as f:
                 password = f.read().strip()
             if password:
                 return password
@@ -112,7 +114,8 @@ def get_msfrpc_password() -> Optional[str]:
     # Fall back to decryption (works if vault is unlocked in this process)
     try:
         from souleyez.storage.crypto import get_crypto_manager
-        encrypted = config.get('msfrpc.password')
+
+        encrypted = config.get("msfrpc.password")
         if not encrypted:
             return None
         crypto = get_crypto_manager()
@@ -131,6 +134,7 @@ def set_msfrpc_password(password: str) -> bool:
     """Encrypt and store msfrpc password in config."""
     try:
         from souleyez.storage.crypto import get_crypto_manager
+
         crypto = get_crypto_manager()
         if crypto:
             encrypted = crypto.encrypt(password)
@@ -138,9 +142,9 @@ def set_msfrpc_password(password: str) -> bool:
             encrypted = password  # No crypto manager, store plain
 
         cfg = config.read_config()
-        if 'msfrpc' not in cfg:
-            cfg['msfrpc'] = {}
-        cfg['msfrpc']['password'] = encrypted
+        if "msfrpc" not in cfg:
+            cfg["msfrpc"] = {}
+        cfg["msfrpc"]["password"] = encrypted
         config.write_config(cfg)
         return True
     except Exception as e:
@@ -169,7 +173,7 @@ class MSFRPCManager:
         return cls._instance
 
     @classmethod
-    def get_instance(cls) -> 'MSFRPCManager':
+    def get_instance(cls) -> "MSFRPCManager":
         """Get singleton instance."""
         if cls._instance is None:
             cls._instance = cls()
@@ -202,7 +206,7 @@ class MSFRPCManager:
             return False
 
         # Check if enabled in config
-        if not config.get('msfrpc.enabled', False):
+        if not config.get("msfrpc.enabled", False):
             logger.debug("MSF RPC unavailable: Not enabled in config")
             return False
 
@@ -239,11 +243,11 @@ class MSFRPCManager:
         # Create new client
         try:
             client = MSFRPCClient(
-                host=config.get('msfrpc.host', '127.0.0.1'),
-                port=config.get('msfrpc.port', 55553),
-                username=config.get('msfrpc.username', 'msf'),
-                password=get_msfrpc_password() or '',
-                ssl=config.get('msfrpc.ssl', False)
+                host=config.get("msfrpc.host", "127.0.0.1"),
+                port=config.get("msfrpc.port", 55553),
+                username=config.get("msfrpc.username", "msf"),
+                password=get_msfrpc_password() or "",
+                ssl=config.get("msfrpc.ssl", False),
             )
 
             if client.login():
@@ -263,7 +267,7 @@ class MSFRPCManager:
         """Public method to get RPC client."""
         if not is_pro_enabled():
             return None
-        if not config.get('msfrpc.enabled', False):
+        if not config.get("msfrpc.enabled", False):
             return None
         return self._get_client()
 
@@ -279,28 +283,25 @@ class MSFRPCManager:
         # Check Pro license first
         if not is_pro_enabled():
             return {
-                'status': 'no_license',
-                'reason': 'Pro license required for msfrpcd integration'
+                "status": "no_license",
+                "reason": "Pro license required for msfrpcd integration",
             }
 
         if not MSGPACK_AVAILABLE:
             return {
-                'status': 'unavailable',
-                'reason': 'msgpack not installed (pip install msgpack)'
+                "status": "unavailable",
+                "reason": "msgpack not installed (pip install msgpack)",
             }
 
-        if not config.get('msfrpc.enabled', False):
-            return {
-                'status': 'disabled',
-                'reason': 'msfrpc.enabled is False in config'
-            }
+        if not config.get("msfrpc.enabled", False):
+            return {"status": "disabled", "reason": "msfrpc.enabled is False in config"}
 
         # Check if password can be retrieved (vault must be unlocked)
         password = get_msfrpc_password()
-        if not password and config.get('msfrpc.password'):
+        if not password and config.get("msfrpc.password"):
             return {
-                'status': 'vault_locked',
-                'reason': 'Credential vault is locked - unlock to connect'
+                "status": "vault_locked",
+                "reason": "Credential vault is locked - unlock to connect",
             }
 
         try:
@@ -309,26 +310,23 @@ class MSFRPCManager:
                 version = client.get_version()
                 sessions = client.list_sessions()
                 return {
-                    'status': 'connected',
-                    'version': version.get('version', 'unknown'),
-                    'ruby': version.get('ruby', 'unknown'),
-                    'active_sessions': len(sessions)
+                    "status": "connected",
+                    "version": version.get("version", "unknown"),
+                    "ruby": version.get("ruby", "unknown"),
+                    "active_sessions": len(sessions),
                 }
         except Exception as e:
-            return {'status': 'error', 'reason': str(e)}
+            return {"status": "error", "reason": str(e)}
 
-        return {
-            'status': 'unavailable',
-            'reason': 'Could not connect to msfrpcd'
-        }
+        return {"status": "unavailable", "reason": "Could not connect to msfrpcd"}
 
     def get_start_command(self) -> str:
         """Get the command to start msfrpcd with current config."""
-        host = config.get('msfrpc.host', '127.0.0.1')
-        port = config.get('msfrpc.port', 55553)
-        username = config.get('msfrpc.username', 'msf')
-        password = get_msfrpc_password() or 'YOUR_PASSWORD'
-        ssl = config.get('msfrpc.ssl', False)
+        host = config.get("msfrpc.host", "127.0.0.1")
+        port = config.get("msfrpc.port", 55553)
+        username = config.get("msfrpc.username", "msf")
+        password = get_msfrpc_password() or "YOUR_PASSWORD"
+        ssl = config.get("msfrpc.ssl", False)
 
         cmd = f"msfrpcd -U {username} -P {password} -a {host} -p {port}"
         if not ssl:
@@ -345,19 +343,16 @@ class MSFRPCManager:
         """
         # Check if msfrpcd is already running
         if self.is_available():
-            return {
-                'success': True,
-                'message': 'msfrpcd is already running'
-            }
+            return {"success": True, "message": "msfrpcd is already running"}
 
         # Check if msfrpcd binary exists
-        msfrpcd_path = shutil.which('msfrpcd')
+        msfrpcd_path = shutil.which("msfrpcd")
         if not msfrpcd_path:
             # Check common MSF install locations
             common_paths = [
-                '/opt/metasploit-framework/bin/msfrpcd',
-                '/usr/share/metasploit-framework/msfrpcd',
-                '/usr/bin/msfrpcd'
+                "/opt/metasploit-framework/bin/msfrpcd",
+                "/usr/share/metasploit-framework/msfrpcd",
+                "/usr/bin/msfrpcd",
             ]
             for path in common_paths:
                 if shutil.which(path):
@@ -366,43 +361,47 @@ class MSFRPCManager:
 
         if not msfrpcd_path:
             return {
-                'success': False,
-                'message': 'msfrpcd not found. Is Metasploit Framework installed?',
-                'command': self.get_start_command()
+                "success": False,
+                "message": "msfrpcd not found. Is Metasploit Framework installed?",
+                "command": self.get_start_command(),
             }
 
         # Check if password is configured
         password = get_msfrpc_password()
         if not password:
             return {
-                'success': False,
-                'message': 'msfrpc password not configured. Set it in Settings first.',
-                'command': self.get_start_command()
+                "success": False,
+                "message": "msfrpc password not configured. Set it in Settings first.",
+                "command": self.get_start_command(),
             }
 
         # Try to start msfrpcd
         try:
-            host = config.get('msfrpc.host', '127.0.0.1')
-            port = config.get('msfrpc.port', 55553)
-            username = config.get('msfrpc.username', 'msf')
-            ssl = config.get('msfrpc.ssl', False)
+            host = config.get("msfrpc.host", "127.0.0.1")
+            port = config.get("msfrpc.port", 55553)
+            username = config.get("msfrpc.username", "msf")
+            ssl = config.get("msfrpc.ssl", False)
 
             cmd = [
                 msfrpcd_path,
-                '-U', username,
-                '-P', password,
-                '-a', host,
-                '-p', str(port)
+                "-U",
+                username,
+                "-P",
+                password,
+                "-a",
+                host,
+                "-p",
+                str(port),
             ]
             if not ssl:
-                cmd.append('-S')  # -S flag DISABLES SSL
+                cmd.append("-S")  # -S flag DISABLES SSL
 
             # Start in background
             proc = subprocess.Popen(
                 cmd,
                 stdout=subprocess.DEVNULL,
                 stderr=subprocess.DEVNULL,
-                start_new_session=True
+                start_new_session=True,
             )
 
             # Wait a moment for it to start
@@ -411,30 +410,27 @@ class MSFRPCManager:
             # Check if it's running
             if proc.poll() is not None:
                 return {
-                    'success': False,
-                    'message': 'msfrpcd failed to start. Check if port is in use.',
-                    'command': self.get_start_command()
+                    "success": False,
+                    "message": "msfrpcd failed to start. Check if port is in use.",
+                    "command": self.get_start_command(),
                 }
 
             # Try to connect
             time.sleep(1)
             if self.is_available():
-                return {
-                    'success': True,
-                    'message': f'msfrpcd started on {host}:{port}'
-                }
+                return {"success": True, "message": f"msfrpcd started on {host}:{port}"}
             else:
                 return {
-                    'success': False,
-                    'message': 'msfrpcd started but connection failed. Check credentials.',
-                    'command': self.get_start_command()
+                    "success": False,
+                    "message": "msfrpcd started but connection failed. Check credentials.",
+                    "command": self.get_start_command(),
                 }
 
         except Exception as e:
             return {
-                'success': False,
-                'message': f'Failed to start msfrpcd: {e}',
-                'command': self.get_start_command()
+                "success": False,
+                "message": f"Failed to start msfrpcd: {e}",
+                "command": self.get_start_command(),
             }
 
     def list_sessions(self) -> Dict[str, Dict[str, Any]]:
@@ -470,7 +466,9 @@ class MSFRPCManager:
             logger.error(f"Failed to kill session: {e}")
             return False
 
-    def run_session_command(self, session_id: int, command: str, timeout: int = 30) -> str:
+    def run_session_command(
+        self, session_id: int, command: str, timeout: int = 30
+    ) -> str:
         """Run a command in a session."""
         client = self.get_client()
         if not client: