iotsploit-core 0.0.7__tar.gz → 0.0.8__tar.gz

{iotsploit_core-0.0.7 → iotsploit_core-0.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iotsploit-core
-Version: 0.0.7
+Version: 0.0.8
 Summary: IoTSploit core library (domain + ports + core) - IoT security testing framework
 License: GPL-3.0-or-later
 Keywords: iot,security,testing,pentest,vulnerability
@@ -75,8 +75,8 @@ print(mgr.list_plugins())
 ```
 
 Default exploit plugin dir:
-- `IOTSPLOIT_EXPLOIT_PLUGINS_DIR` (or legacy `SAT_EXPLOIT_PLUGINS_DIR`)
-- fallback: `./plugins/exploits`
+- `IOTSPLOIT_EXPLOIT_PLUGINS_DIR`
+- fallback: `None` (entry-point discovery only)
 
 ### Device drivers (manager)
 

{iotsploit_core-0.0.7 → iotsploit_core-0.0.8}/README.md

@@ -47,8 +47,8 @@ print(mgr.list_plugins())
 ```
 
 Default exploit plugin dir:
-- `IOTSPLOIT_EXPLOIT_PLUGINS_DIR` (or legacy `SAT_EXPLOIT_PLUGINS_DIR`)
-- fallback: `./plugins/exploits`
+- `IOTSPLOIT_EXPLOIT_PLUGINS_DIR`
+- fallback: `None` (entry-point discovery only)
 
 ### Device drivers (manager)
 

{iotsploit_core-0.0.7 → iotsploit_core-0.0.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "iotsploit-core"
-version = "0.0.7"
+version = "0.0.8"
 description = "IoTSploit core library (domain + ports + core) - IoT security testing framework"
 authors = ["IoTSploit Team <support@iotsploit.org>"]
 readme = "README.md"

{iotsploit_core-0.0.7 → iotsploit_core-0.0.8}/src/iotsploit_core/core/device_manager.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import datetime
 from importlib import metadata as importlib_metadata
 import importlib.util
 import json
@@ -8,10 +7,10 @@ import logging
 import os
 import threading
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Dict, List, Optional
 
 from iotsploit_core.core.base_plugin import BaseDeviceDriver
-from iotsploit_core.core.device_spec import DevicePluginSpec, DeviceState
+from iotsploit_core.core.device_spec import DeviceState
 from iotsploit_core.domain.device import Device
 from iotsploit_core.ports.driver_state_repo import DriverStateRepository
 

{iotsploit_core-0.0.7 → iotsploit_core-0.0.8}/src/iotsploit_core/core/device_registry.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from typing import Dict, List, Optional
+from typing import Dict, List
 
 from iotsploit_core.core.device_config import DeviceConfigManager
 from iotsploit_core.core.device_scanner import CompositeDeviceScanner, PluginDeviceScanner

{iotsploit_core-0.0.7 → iotsploit_core-0.0.8}/src/iotsploit_core/core/device_scanner.py

@@ -1,4 +1,4 @@
-from typing import List, Dict, Type
+from typing import List
 import logging
 from iotsploit_core.domain.device import Device
 from iotsploit_core.core.device_store import DeviceStore

{iotsploit_core-0.0.7 → iotsploit_core-0.0.8}/src/iotsploit_core/core/execution_backend.py

@@ -13,14 +13,13 @@ This allows plugins to choose the best execution method for their needs.
 """
 
 import os
-import sys
 import time
 import logging
 import subprocess
+import importlib.util
 from abc import ABC, abstractmethod
-from typing import Dict, List, Optional, Any, Union
+from typing import Dict, List, Optional, Any
 from dataclasses import dataclass
-from enum import Enum
 
 logger = logging.getLogger(__name__)
 
@@ -144,11 +143,7 @@ class InvokeBackend(ExecutionBackend):
     
     def _check_invoke(self) -> bool:
         """Check if invoke is available"""
-        try:
-            import invoke
-            return True
-        except ImportError:
-            return False
+        return importlib.util.find_spec("invoke") is not None
     
     def execute(self, tool_path: str, args: List[str], 
                 working_dir: Optional[str] = None,
@@ -160,7 +155,7 @@ class InvokeBackend(ExecutionBackend):
             raise RuntimeError("Invoke backend not available")
         
         import invoke
-        from invoke.exceptions import CommandTimedOut, UnexpectedExit
+        from invoke.exceptions import CommandTimedOut
         
         command_str = f"{tool_path} {' '.join(args)}"
         exec_env = self._prepare_environment(env)
@@ -235,11 +230,7 @@ class ShBackend(ExecutionBackend):
     
     def _check_sh(self) -> bool:
         """Check if sh is available"""
-        try:
-            import sh
-            return True
-        except ImportError:
-            return False
+        return importlib.util.find_spec("sh") is not None
     
     def execute(self, tool_path: str, args: List[str], 
                 working_dir: Optional[str] = None,
@@ -251,7 +242,7 @@ class ShBackend(ExecutionBackend):
             raise RuntimeError("sh backend not available")
         
         import sh
-        from sh import CommandNotFound, TimeoutException
+        from sh import TimeoutException
         
         command_str = f"{tool_path} {' '.join(args)}"
         exec_env = self._prepare_environment(env)
@@ -290,7 +281,7 @@ class ShBackend(ExecutionBackend):
                 metadata={'sh_result': result}
             )
             
-        except TimeoutException as e:
+        except TimeoutException:
             execution_time = time.time() - start_time
             return ExecutionResult(
                 success=False,
@@ -328,11 +319,7 @@ class SargeBackend(ExecutionBackend):
     
     def _check_sarge(self) -> bool:
         """Check if sarge is available"""
-        try:
-            import sarge
-            return True
-        except ImportError:
-            return False
+        return importlib.util.find_spec("sarge") is not None
     
     def execute(self, tool_path: str, args: List[str], 
                 working_dir: Optional[str] = None,
@@ -469,4 +456,4 @@ def get_execution_backend_manager() -> ExecutionBackendManager:
     global _backend_manager
     if _backend_manager is None:
         _backend_manager = ExecutionBackendManager()
-    return _backend_manager 
+    return _backend_manager

{iotsploit_core-0.0.7 → iotsploit_core-0.0.8}/src/iotsploit_core/core/execution_queue.py

@@ -5,8 +5,7 @@ import time
 import threading
 import queue
 import logging
-from abc import ABC, abstractmethod
-from typing import Dict, List, Optional, Any, Callable, Union
+from typing import Dict, List, Optional, Any, Callable
 from dataclasses import dataclass, field
 from enum import Enum, IntEnum
 from concurrent.futures import ThreadPoolExecutor, Future

{iotsploit_core-0.0.7 → iotsploit_core-0.0.8}/src/iotsploit_core/core/exploit_manager.py

@@ -1,9 +1,6 @@
 from __future__ import annotations
 
 import os
-# Disable pwntools terminal mode before any plugin imports to prevent
-# "argument must be an int, or have a fileno() method" errors in non-TTY environments
-os.environ.setdefault("PWNLIB_NOTERM", "1")
 
 import glob
 import importlib
@@ -50,7 +47,7 @@ class ExploitPluginManager:
 
     @staticmethod
     def _default_plugins_dir() -> Path | None:
-        env = os.getenv("IOTSPLOIT_EXPLOIT_PLUGINS_DIR") or os.getenv("SAT_EXPLOIT_PLUGINS_DIR")
+        env = os.getenv("IOTSPLOIT_EXPLOIT_PLUGINS_DIR")
         if env:
             return Path(env)
         return None

{iotsploit_core-0.0.7 → iotsploit_core-0.0.8}/src/iotsploit_core/core/tool_config.py

@@ -12,7 +12,6 @@ import logging
 from pathlib import Path
 from typing import Dict, List, Optional, Any, Union
 from dataclasses import dataclass, field, asdict
-from enum import Enum
 
 logger = logging.getLogger(__name__)
 
@@ -369,7 +368,7 @@ class ToolConfigManager:
             
             # Check required fields
             if not config.name:
-                issues['missing_required_fields'].append(f"Tool missing name")
+                issues['missing_required_fields'].append("Tool missing name")
             
             # Check for duplicates
             if config.name in seen_names:

{iotsploit_core-0.0.7 → iotsploit_core-0.0.8}/src/iotsploit_core/core/tool_manager.py

@@ -2,25 +2,22 @@
 """Tool management: discovery, validation, and cross-platform execution."""
 
 import os
-import sys
 import shutil
 import subprocess
 import platform
 import json
 import logging
-from abc import ABC, abstractmethod
 from pathlib import Path
-from typing import Dict, List, Optional, Union, Any, Tuple
+from typing import Dict, List, Optional, Any
 from dataclasses import dataclass, field, asdict
 from enum import Enum
 import threading
 import time
-from contextlib import contextmanager
 
 # Import ExecutionResult from execution_backend to avoid duplication
 from .execution_backend import ExecutionResult, get_execution_backend_manager
 from .tool_config import get_tool_config_manager, ToolConfig
-from .execution_queue import get_execution_queue, TaskPriority
+from .execution_queue import get_execution_queue
 
 logger = logging.getLogger(__name__)
 
@@ -771,88 +768,6 @@ class ToolManager:
         """Get statistics about tool configurations"""
         return self.config_manager.get_stats()
     
-    # Convenience methods for common operations
-    def flash_esp32(self, port: str, firmware_path: str, **kwargs) -> Dict[str, Any]:
-        """Convenience method for ESP32 flashing"""
-        if not self.is_available('esptool'):
-            return {"status": "error", "message": "esptool not available"}
-        
-        args = [
-            '--chip', kwargs.get('chip', 'esp32s3'),
-            '--port', port,
-            '--baud', kwargs.get('baud', '460800'),
-            'write_flash', kwargs.get('address', '0x10000'), firmware_path
-        ]
-        
-        result = self.execute('esptool', args, timeout=300)
-        return {
-            "status": "success" if result.success else "error",
-            "message": "Flash completed" if result.success else result.stderr,
-            "execution_time": result.execution_time
-        }
-    
-    def port_scan(self, target: str, ports: str = "1-1000", 
-                 scan_type: str = "syn") -> Dict[str, Any]:
-        """Convenience method for port scanning"""
-        if not self.is_available('nmap'):
-            return {"status": "error", "message": "nmap not available"}
-        
-        scan_args = {
-            'syn': ['-sS'],
-            'tcp': ['-sT'],
-            'udp': ['-sU'],
-            'ping': ['-sn']
-        }
-        
-        args = scan_args.get(scan_type, ['-sS'])
-        args.extend(['-p', ports, target])
-        
-        result = self.execute('nmap', args, timeout=300)
-        return {
-            "status": "success" if result.success else "error",
-            "message": "Scan completed" if result.success else result.stderr,
-            "output": result.stdout,
-            "execution_time": result.execution_time
-        }
-    
-    def extract_strings(self, file_path: str, min_length: int = 4) -> Dict[str, Any]:
-        """Convenience method for string extraction"""
-        if not self.is_available('strings'):
-            return {"status": "error", "message": "strings tool not available"}
-        
-        args = [f'-n{min_length}', file_path]
-        result = self.execute('strings', args)
-        
-        return {
-            "status": "success" if result.success else "error",
-            "message": "Strings extracted" if result.success else result.stderr,
-            "strings": result.stdout.split('\n') if result.success else [],
-            "execution_time": result.execution_time
-        }
-    
-    def adb_devices(self) -> Dict[str, Any]:
-        """Convenience method for listing ADB devices"""
-        if not self.is_available('adb'):
-            return {"status": "error", "message": "adb not available"}
-        
-        result = self.execute('adb', ['devices'])
-        
-        devices = []
-        if result.success:
-            lines = result.stdout.split('\n')[1:]  # Skip header
-            for line in lines:
-                line = line.strip()
-                if line and '\t' in line:
-                    device_id, status = line.split('\t')
-                    devices.append({'id': device_id, 'status': status})
-        
-        return {
-            "status": "success" if result.success else "error",
-            "message": "Devices listed" if result.success else result.stderr,
-            "devices": devices,
-            "execution_time": result.execution_time
-        }
-    
     # ========== Methods from CentralizedToolManager ==========
     
     def get_system_status(self) -> SystemStatus:
@@ -912,44 +827,6 @@ class ToolManager:
         
         return report
     
-    def get_installation_guide(self) -> Dict[str, Any]:
-        """Get installation recommendations with hints"""
-        missing_tools = self.get_missing_tools()
-        install_hints = self.get_install_hints()
-        required_tools = self.get_required_tools()
-        optional_tools = self.get_optional_tools()
-        
-        # Separate required and optional missing tools
-        required_missing = [t for t in missing_tools if t in required_tools]
-        optional_missing = [t for t in missing_tools if t in optional_tools]
-        
-        guide = {
-            'required_tools': {},
-            'optional_tools': {},
-            'priority_order': required_missing + optional_missing[:5]  # Top 5 optional
-        }
-        
-        for tool in required_missing:
-            guide['required_tools'][tool] = {
-                'description': self._get_tool_description(tool),
-                'install_hint': install_hints.get(tool, "No installation hint available"),
-                'priority': 'HIGH'
-            }
-        
-        for tool in optional_missing:
-            guide['optional_tools'][tool] = {
-                'description': self._get_tool_description(tool),
-                'install_hint': install_hints.get(tool, "No installation hint available"),
-                'priority': 'MEDIUM'
-            }
-        
-        return guide
-    
-    def _get_tool_description(self, tool_name: str) -> str:
-        """Get tool description from config"""
-        tool_config = self.get_tool_config(tool_name)
-        return tool_config.description if tool_config else "No description available"
-    
     def _get_timestamp(self) -> str:
         """Get current timestamp"""
         from datetime import datetime
@@ -995,81 +872,7 @@ class ToolManager:
             }
         }
     
-    # Queue delegation methods
-    def submit_task(self, tool_name: str, args: List[str], 
-                   priority: Union[str, TaskPriority] = "normal", **kwargs) -> str:
-        """Submit a tool execution task to the queue"""
-        # Handle both string and enum priority inputs
-        if isinstance(priority, TaskPriority):
-            task_priority = priority
-        else:
-            # Convert priority string to enum
-            priority_map = {
-                'critical': TaskPriority.CRITICAL,
-                'high': TaskPriority.HIGH,
-                'normal': TaskPriority.NORMAL,
-                'low': TaskPriority.LOW,
-                'background': TaskPriority.BACKGROUND
-            }
-            task_priority = priority_map.get(priority.lower(), TaskPriority.NORMAL)
-        
-        # Get tool path
-        tool_info = self.registry.get_tool(tool_name)
-        if not tool_info:
-            raise ValueError(f"Tool '{tool_name}' not found")
-        
-        return self.queue_manager.submit_task(
-            tool_name=tool_name,
-            tool_path=tool_info.path,
-            args=args,
-            priority=task_priority,
-            **kwargs
-        )
-    
-    def get_task(self, task_id: str):
-        """Get task by ID"""
-        return self.queue_manager.get_task(task_id)
-    
-    def wait_for_task(self, task_id: str, timeout: Optional[float] = None):
-        """Wait for task completion"""
-        return self.queue_manager.wait_for_task(task_id, timeout)
-    
-    def get_queue_stats(self):
-        """Get queue statistics"""
-        return self.queue_manager.get_stats()
-    
-    # Backend delegation methods
-    def list_execution_backends(self) -> List[str]:
-        """List available execution backends"""
-        return self.backend_manager.list_available_backends()
-    
-    def set_default_backend(self, backend_name: str):
-        """Set default execution backend"""
-        self.backend_manager.set_default_backend(backend_name)
-    
-    # System management
-    def initialize(self) -> bool:
-        """Initialize the system"""
-        try:
-            logger.info("Initializing tool manager...")
-            
-            # Discover tools
-            discovery_results = self.discover_tools()
-            logger.info(f"Discovered {len(discovery_results)} tools")
-            
-            # Check system health
-            status = self.get_system_status()
-            logger.info(f"System health: {status.health.value}")
-            
-            if status.health == SystemHealth.CRITICAL:
-                logger.warning(f"System is in CRITICAL state - {status.required_missing} required tools missing")
-            
-            return True
-            
-        except Exception as e:
-            logger.error(f"Failed to initialize system: {e}")
-            return False
-    
+    # Lifecycle management
     def cleanup(self):
         """Cleanup resources"""
         try:
@@ -1081,15 +884,6 @@ class ToolManager:
     def shutdown(self, wait: bool = True):
         """Shutdown the system"""
         self.cleanup()
-    
-    def __enter__(self):
-        """Context manager entry"""
-        self.initialize()
-        return self
-    
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        """Context manager exit"""
-        self.cleanup()
 
 # Convenience
 def get_tool_manager() -> ToolManager:
@@ -1104,87 +898,4 @@ def execute_tool(tool_name: str, args: List[str], **kwargs) -> ExecutionResult:
 
 def is_tool_available(tool_name: str) -> bool:
     """Check if a tool is available"""
-    return get_tool_manager().is_available(tool_name)
-
-def print_system_report():
-    """Print a comprehensive system report"""
-    manager = get_tool_manager()
-    
-    print("\n" + "="*60)
-    print("🔧 IOTSPLOIT TOOL MANAGEMENT SYSTEM REPORT")
-    print("="*60)
-    
-    # Get system status
-    status = manager.get_system_status()
-    health_icon = {
-        "healthy": "✅",
-        "degraded": "⚠️",
-        "critical": "❌"
-    }.get(status.health.value, "❓")
-    
-    print(f"\n📊 System Health: {health_icon} {status.health.value.upper()}")
-    print(f"🔧 Total Tools: {status.total_tools}")
-    print(f"✅ Available: {status.available_tools}")
-    print(f"❌ Missing: {status.missing_tools}")
-    print(f"🔴 Required Missing: {status.required_missing}")
-    print(f"🚀 Can Operate: {'Yes' if status.can_operate else 'No'}")
-    
-    # Show recommendations
-    if status.recommendations:
-        print(f"\n💡 Recommendations:")
-        for rec in status.recommendations:
-            print(f"   • {rec}")
-    
-    # Show queue stats
-    try:
-        queue_stats = manager.get_queue_stats()
-        print(f"\n📋 Queue Status:")
-        print(f"   • Total Tasks: {queue_stats.total_tasks}")
-        print(f"   • Running: {queue_stats.running_tasks}")
-        print(f"   • Pending: {queue_stats.pending_tasks}")
-        print(f"   • Completed: {queue_stats.completed_tasks}")
-        print(f"   • Failed: {queue_stats.failed_tasks}")
-        if queue_stats.average_execution_time > 0:
-            print(f"   • Avg Execution Time: {queue_stats.average_execution_time:.2f}s")
-    except Exception as e:
-        print(f"\n📋 Queue Status: Error - {e}")
-    
-    # Show category info
-    try:
-        category_info = manager.get_category_info()
-        print(f"\n📂 Tool Category: {category_info.name}")
-        print(f"   Description: {category_info.description}")
-        print(f"   Tools: {len(category_info.tools)}")
-        
-        # Show available vs missing
-        available = manager.get_available_tools()
-        missing = manager.get_missing_tools()
-        required = manager.get_required_tools()
-        
-        print(f"\n🔧 Tool Breakdown:")
-        print(f"   ✅ Available: {len(available)}")
-        if available[:5]:  # Show first 5
-            for tool in available[:5]:
-                print(f"      • {tool}")
-            if len(available) > 5:
-                print(f"      ... and {len(available) - 5} more")
-        
-        if missing:
-            print(f"   ❌ Missing: {len(missing)}")
-            required_missing = [t for t in missing if t in required]
-            optional_missing = [t for t in missing if t not in required]
-            
-            if required_missing:
-                print(f"      🔴 Required: {', '.join(required_missing[:3])}")
-                if len(required_missing) > 3:
-                    print(f"         ... and {len(required_missing) - 3} more")
-            
-            if optional_missing:
-                print(f"      🟡 Optional: {', '.join(optional_missing[:3])}")
-                if len(optional_missing) > 3:
-                    print(f"         ... and {len(optional_missing) - 3} more")
-    
-    except Exception as e:
-        print(f"\n📂 Category Status: Error - {e}")
-    
-    print("\n" + "="*60) 
+    return get_tool_manager().is_available(tool_name)

{iotsploit_core-0.0.7 → iotsploit_core-0.0.8}/src/iotsploit_core/core/tool_service.py

@@ -3,12 +3,9 @@
 
 import json
 import logging
-import time
-from typing import Dict, List, Optional, Any, Union
-from dataclasses import dataclass, field
-from enum import Enum
+from typing import Dict, List, Optional, Any
 
-from .tool_manager import get_tool_manager, ExecutionResult, ToolStatus
+from .tool_manager import get_tool_manager, ExecutionResult
 
 logger = logging.getLogger(__name__)
 
@@ -387,7 +384,7 @@ exit
             result = self.execute_tool('openocd', args, timeout=300)
             os.unlink(script_path)
             return result
-        except Exception as e:
+        except Exception:
             if os.path.exists(script_path):
                 os.unlink(script_path)
             raise
@@ -741,7 +738,6 @@ class FirmwareToolService(ToolService):
         manifest.
         """
         from contextlib import contextmanager, ExitStack
-        from pathlib import Path
 
         info = self.manifests.get(name)
         if info is None:
@@ -1019,68 +1015,8 @@ class NetworkToolService(ToolService):
         return self.execute_tool('nmap', args, timeout=300)
     
 
-
-class BinaryToolService(ToolService):
-    """Tool service specialized for binary analysis"""
-    
-    def __init__(self):
-        super().__init__()
-        # Pre-register common binary analysis tools
-        self.register_tool('strings', required=False)
-        self.register_tool('binwalk', required=False)
-        self.register_tool('objdump', required=False)
-        self.register_tool('readelf', required=False)
-        self.register_tool('file', required=False)
-    
-    def extract_strings(self, file_path: str, min_length: int = 4) -> ExecutionResult:
-        """
-        Extract strings from binary file.
-        
-        Args:
-            file_path: Path to binary file
-            min_length: Minimum string length
-            
-        Returns:
-            ExecutionResult: Result containing extracted strings
-        """
-        if not self.is_tool_available('strings'):
-            raise RuntimeError("strings tool is not available")
-        
-        args = [f'-n{min_length}', file_path]
-        return self.execute_tool('strings', args)
-    
-    def analyze_firmware(self, file_path: str, extract: bool = False) -> ExecutionResult:
-        """
-        Analyze firmware file with binwalk.
-        
-        Args:
-            file_path: Path to firmware file
-            extract: Whether to extract found files
-            
-        Returns:
-            ExecutionResult: Result of the analysis
-        """
-        if not self.is_tool_available('binwalk'):
-            raise RuntimeError("binwalk is not available")
-        
-        args = []
-        if extract:
-            args.append('-e')
-        args.append(file_path)
-        
-        return self.execute_tool('binwalk', args)
-
-_tool_service_instance = None
 _firmware_service_instance = None
 _network_service_instance = None
-_binary_service_instance = None
-
-def get_tool_service() -> ToolService:
-    """Get singleton ToolService instance"""
-    global _tool_service_instance
-    if _tool_service_instance is None:
-        _tool_service_instance = ToolService()
-    return _tool_service_instance
 
 def get_firmware_service() -> FirmwareToolService:
     """Get singleton FirmwareToolService instance"""
@@ -1094,11 +1030,4 @@ def get_network_service() -> NetworkToolService:
     global _network_service_instance
     if _network_service_instance is None:
         _network_service_instance = NetworkToolService()
-    return _network_service_instance
-
-def get_binary_service() -> BinaryToolService:
-    """Get singleton BinaryToolService instance"""
-    global _binary_service_instance
-    if _binary_service_instance is None:
-        _binary_service_instance = BinaryToolService()
-    return _binary_service_instance 
+    return _network_service_instance

{iotsploit_core-0.0.7 → iotsploit_core-0.0.8}/src/iotsploit_core/domain/target.py

@@ -21,6 +21,21 @@ class Target(BaseModel, ABC):
     def get_info(self) -> Dict[str, Any]:
         raise NotImplementedError
 
+    def get_ecu_ip(self, ecu: str) -> Optional[str]:
+        """Return the configured IP of the ECU component whose name matches `ecu`.
+
+        ECUs are modeled as components selected by name ("TCAM"/"DHU"/"VGM").
+        The IP is read from the component's free-form ``properties.ip_address``,
+        falling back to a typed ``ip_address`` field (e.g. NetworkComponent).
+        Returns None when the ECU has no configured IP.
+        """
+        name = (ecu or "").upper()
+        for comp in self.components:
+            if comp.name.upper() == name:
+                ip = comp.properties.get("ip_address") if isinstance(comp.properties, dict) else None
+                return ip or getattr(comp, "ip_address", None)
+        return None
+
 
 class Component(BaseModel):
     component_id: str

{iotsploit_core-0.0.7 → iotsploit_core-0.0.8}/src/iotsploit_core/ports/wifi_backend.py

@@ -8,7 +8,6 @@ Platform-specific implementations should be provided in adapter modules.
 from abc import ABC, abstractmethod
 from typing import List, Optional, Dict, Any, Tuple
 
-from iotsploit_core.utils.exceptions import NotSupportedError
 
 
 class WifiBackend(ABC):

{iotsploit_core-0.0.7 → iotsploit_core-0.0.8}/src/iotsploit_core/utils/iots_logger.py

@@ -25,9 +25,17 @@ class IotsLogger:
     _instance: Optional["IotsLogger"] = None
     _lock = threading.Lock()
 
-    LOG_FORMAT = "%(asctime)s | %(levelname)s | %(name)s | %(message)s"
     LOG_DATE_FORMAT = "%Y-%m-%d %H:%M:%S"
-    COLOR_FORMAT = "%(log_color)s%(asctime)s | %(levelname)s | %(name)s | %(message)s"
+    LOG_FORMATS = {
+        "standard": "%(asctime)s | %(levelname)s | %(name)s | %(message)s",
+        "compact": "%(levelname)s | %(message)s",
+        "plain": "%(message)s",
+    }
+    COLOR_LOG_FORMATS = {
+        "standard": "%(log_color)s%(asctime)s | %(levelname)s | %(name)s | %(message)s",
+        "compact": "%(log_color)s%(levelname)s | %(message)s",
+        "plain": "%(log_color)s%(message)s",
+    }
 
     LOG_COLORS = {
         "DEBUG": "cyan",
@@ -50,6 +58,7 @@ class IotsLogger:
         self._extra_handlers: List[logging.Handler] = []
         self._use_color = _HAS_COLORLOG and self._is_tty()
         self._default_level = self._get_env_level()
+        self._default_format = self._get_env_format()
 
     @staticmethod
     def _is_tty() -> bool:
@@ -63,6 +72,13 @@ class IotsLogger:
         level_str = os.getenv("IOTSPLOIT_LOG_LEVEL", "INFO").upper()
         return getattr(logging, level_str, logging.INFO)
 
+    @classmethod
+    def _get_env_format(cls) -> str:
+        fmt = os.getenv("IOTSPLOIT_LOG_FORMAT", "standard").strip().lower()
+        if fmt not in cls.LOG_FORMATS:
+            return "standard"
+        return fmt
+
     def get_logger(self, name: str = "iotsploit", level: Optional[int] = None) -> logging.Logger:
         """
         获取（或创建）一个已配置好的 logger。
@@ -93,18 +109,27 @@ class IotsLogger:
     def _create_console_handler(self) -> logging.Handler:
         if self._use_color and _HAS_COLORLOG:
             handler = colorlog.StreamHandler(sys.stderr)  # type: ignore[name-defined]
+            self._set_console_formatter(handler)
+            return handler
+
+        handler = logging.StreamHandler(sys.stderr)
+        self._set_console_formatter(handler)
+        return handler
+
+    def _set_console_formatter(self, handler: logging.Handler) -> None:
+        if self._use_color and _HAS_COLORLOG:
             handler.setFormatter(
                 colorlog.ColoredFormatter(  # type: ignore[name-defined]
-                    self.COLOR_FORMAT,
+                    self.COLOR_LOG_FORMATS[self._default_format],
                     datefmt=self.LOG_DATE_FORMAT,
                     log_colors=self.LOG_COLORS,
                 )
             )
-            return handler
+            return
 
-        handler = logging.StreamHandler(sys.stderr)
-        handler.setFormatter(logging.Formatter(self.LOG_FORMAT, datefmt=self.LOG_DATE_FORMAT))
-        return handler
+        handler.setFormatter(
+            logging.Formatter(self.LOG_FORMATS[self._default_format], datefmt=self.LOG_DATE_FORMAT)
+        )
 
     def add_handler(self, handler: logging.Handler) -> None:
         """为所有已创建的 logger 注入额外 handler。"""
@@ -140,6 +165,21 @@ class IotsLogger:
                 for logger in self._loggers.values():
                     logger.setLevel(level_value)
 
+    def set_format(self, fmt: str) -> None:
+        """设置控制台日志格式：standard、compact 或 plain。额外 handler 不受影响。"""
+        fmt = fmt.strip().lower()
+        if fmt not in self.LOG_FORMATS:
+            return
+
+        with self._lock:
+            self._default_format = fmt
+            for logger in self._loggers.values():
+                for handler in logger.handlers:
+                    if handler in self._extra_handlers:
+                        continue
+                    if isinstance(handler, logging.StreamHandler):
+                        self._set_console_formatter(handler)
+
     def debug(self, msg: str, name: str = "iotsploit", **kwargs: Any) -> None:
         self.get_logger(name).debug(msg, **kwargs)
 
@@ -161,4 +201,4 @@ iots_logger = IotsLogger()
 
 def get_logger(name: str = "iotsploit") -> logging.Logger:
     """便捷函数：`get_logger("plugin_foo")` 等价于 `iots_logger.get_logger("plugin_foo")`。"""
-    return iots_logger.get_logger(name)
+    return iots_logger.get_logger(name)