iotsploit-exploits 0.0.6__py3-none-any.whl

iotsploit_exploits/serial/picocom_serial_reader.py

@@ -0,0 +1,704 @@
+#!/usr/bin/python3
+
+import logging
+import pluggy
+import asyncio
+import serial
+import serial.tools.list_ports
+import re
+import time
+from typing import Optional, Any, List, Dict
+from threading import Thread, Event
+from queue import Queue, Empty
+from dataclasses import dataclass
+from iotsploit_core.core.exploit_spec import AsyncExploitResult
+from iotsploit_core.core.base_plugin import BasePlugin
+from iotsploit_core.utils import iots_logger
+
+logger = iots_logger.get_logger("picocom_serial_reader")
+hookimpl = pluggy.HookimplMarker("exploit_mgr")
+
+# Add file logging for debugging
+import logging
+import os
+file_logger = logging.getLogger('picocom_serial_reader_file')
+file_logger.setLevel(logging.DEBUG)
+
+# Create logs directory if it doesn't exist
+log_dir = "/tmp/sat_logs"
+os.makedirs(log_dir, exist_ok=True)
+
+# Add file handler
+file_handler = logging.FileHandler(f"{log_dir}/picocom_serial_reader.log")
+file_handler.setLevel(logging.DEBUG)
+formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+file_handler.setFormatter(formatter)
+file_logger.addHandler(file_handler)
+
+def log_both(level, message):
+    """Log to both regular logger and file logger"""
+    getattr(logger, level)(message)
+    getattr(file_logger, level)(message)
+
+@dataclass
+class SerialAnalysis:
+    """Data structure for serial port analysis results"""
+    device_type: str = "unknown"
+    confidence: float = 0.0
+    detected_patterns: List[str] = None
+    login_detected: bool = False
+    shell_type: str = "unknown"
+    firmware_info: Dict[str, str] = None
+    raw_output: List[str] = None
+    
+    def __post_init__(self):
+        if self.detected_patterns is None:
+            self.detected_patterns = []
+        if self.firmware_info is None:
+            self.firmware_info = {}
+        if self.raw_output is None:
+            self.raw_output = []
+
+class PicocomSerialReaderPlugin(BasePlugin):
+    def __init__(self):
+        super().__init__({
+            'Name': 'Picocom Serial Reader',
+            'Description': 'AI-powered serial port reader and analyzer similar to picocom',
+            'License': 'GPL',
+            'Author': ['iotsploit'],
+            'Parameters': {
+                'port': {
+                    'type': 'str',
+                    'required': True,
+                    'description': 'Serial port path (e.g., /dev/ttyUSB0, COM1)',
+                    'default': '/dev/ttyUSB0'
+                },
+                'baudrate': {
+                    'type': 'int',
+                    'required': False,
+                    'description': 'Baud rate for serial communication',
+                    'default': 115200,
+                    'validation': {
+                        'min': 300,
+                        'max': 921600
+                    }
+                },
+                'timeout': {
+                    'type': 'int',
+                    'required': False,
+                    'description': 'Maximum time to wait for output (seconds)',
+                    'default': 60,
+                    'validation': {
+                        'min': 5,
+                        'max': 300
+                    }
+                },
+                'auto_interact': {
+                    'type': 'bool',
+                    'required': False,
+                    'description': 'Automatically send Enter and common inputs to trigger responses',
+                    'default': True
+                },
+                'analyze_output': {
+                    'type': 'bool',
+                    'required': False,
+                    'description': 'Enable AI analysis of serial output',
+                    'default': True
+                }
+            }
+        })
+        
+        # Plugin state
+        self._stop_reading = False
+        self._serial_conn = None
+        self._reader_thread = None
+        self._output_queue = Queue()
+        self._analysis = SerialAnalysis()
+        
+        # Detection patterns
+        self._login_patterns = [
+            r'login\s*:',
+            r'username\s*:',
+            r'user\s*:',
+            r'password\s*:',
+            r'passwd\s*:',
+            r'>\s*$',
+            r'#\s*$',
+            r'\$\s*$',
+            r'.*@.*:.*\$',
+            r'.*@.*:.*#'
+        ]
+        
+        self._shell_patterns = {
+            'bash': [r'bash-\d+\.\d+', r'GNU bash'],
+            'sh': [r'\/bin\/sh', r'\$\s*$'],
+            'busybox': [r'BusyBox', r'built-in shell'],
+            'uboot': [r'U-Boot', r'=>\s*$', r'Hit any key to stop autoboot'],
+            'bootloader': [r'Bootloader', r'Boot>', r'bootloader>'],
+            'linux': [r'Linux version', r'GNU\/Linux', r'kernel'],
+            'embedded': [r'Embedded', r'firmware', r'version']
+        }
+        
+        self._interaction_sequences = [
+            "\r\n",  # Enter
+            "\r",    # Carriage return
+            "\n",    # Line feed
+            " \r\n", # Space + Enter
+            "help\r\n",
+            "?\r\n",
+            "ls\r\n",
+            "id\r\n",
+            "whoami\r\n"
+        ]
+
+    @hookimpl
+    def initialize(self, device_plugin: Optional[Any] = None):
+        logger.info("Initializing PicocomSerialReaderPlugin")
+        self._stop_reading = False
+        self._analysis = SerialAnalysis()
+
+    @hookimpl
+    async def execute_async(self, target: Optional[Any] = None, parameters: Optional[dict] = None) -> AsyncExploitResult:
+        """Asynchronous execution method for serial port reading and analysis"""
+        log_both('info', "🎯 Starting Picocom Serial Reader execution")
+        async_result = AsyncExploitResult()
+        
+        try:
+            # Extract parameters
+            params = parameters or {}
+            port = params.get('port', '/dev/ttyUSB0')
+            baudrate = params.get('baudrate', 115200)
+            timeout = params.get('timeout', 30)
+            auto_interact = params.get('auto_interact', True)
+            analyze_output = params.get('analyze_output', True)
+            
+            log_both('info', f"🎯 Serial parameters: port={port}, baudrate={baudrate}, timeout={timeout}")
+            
+            # Check if port exists
+            available_ports = self._list_serial_ports()
+            if port not in available_ports:
+                async_result.update(
+                    status=False,
+                    message=f"Port {port} not found. Available ports: {', '.join(available_ports)}",
+                    progress=100
+                )
+                return async_result
+            
+            # Initialize serial connection
+            async_result.update(
+                status=True,
+                progress=10,
+                message=f"Connecting to serial port {port}...",
+                data={"available_ports": available_ports}
+            )
+            
+            success = await self._connect_serial(port, baudrate)
+            if not success:
+                async_result.update(
+                    status=False,
+                    message=f"Failed to connect to {port}",
+                    progress=100
+                )
+                return async_result
+            
+            # Start reading thread
+            async_result.update(
+                status=True,
+                progress=20,
+                message="Starting serial communication...",
+                data={"port": port, "baudrate": baudrate}
+            )
+            
+            self._start_reader_thread()
+            
+            # Main reading and interaction loop
+            start_time = time.time()
+            interaction_step = 0
+            last_interaction_time = start_time
+            last_log_time = start_time
+            log_interval = 10.0  # Log every 10 seconds
+            
+            # Simple early exit: exit when all interactions done + have some data
+            min_data_threshold = 5  # Need at least 5 lines of output for early exit
+            
+            log_both('info', f"🚀 Starting main reading loop - timeout: {timeout}s")
+            log_both('info', f"🚀 Auto-interact: {auto_interact}, Available interactions: {len(self._interaction_sequences)}")
+            log_both('info', f"🚀 Serial connection status: {self._serial_conn.is_open if self._serial_conn else 'No connection'}")
+            log_both('info', f"🚀 Simple early exit: will exit when all {len(self._interaction_sequences)} interactions done + {min_data_threshold}+ lines captured")
+            
+            while time.time() - start_time < timeout and not self._stop_reading:
+                # Check for stop condition
+                if self._stop_reading:
+                    logger.info("🛑 Stop reading flag set, breaking loop")
+                    break
+                
+                # Update progress
+                elapsed = time.time() - start_time
+                progress = 20 + (elapsed / timeout) * 70  # 20-90% for reading phase
+                
+                # Periodic detailed logging
+                current_time = time.time()
+                if current_time - last_log_time >= log_interval:
+                    log_both('info', f"📊 PROGRESS UPDATE: {elapsed:.1f}s/{timeout}s ({progress:.1f}%)")
+                    log_both('info', f"📊 Serial port status: connected={self._serial_conn.is_open if self._serial_conn else False}")
+                    log_both('info', f"📊 Lines captured so far: {len(self._analysis.raw_output)}")
+                    log_both('info', f"📊 Interactions sent: {interaction_step}/{len(self._interaction_sequences)}")
+                    log_both('info', f"📊 Device type detected: {self._analysis.device_type}")
+                    log_both('info', f"📊 Login detected: {self._analysis.login_detected}")
+                    
+                    # Check serial connection health
+                    if self._serial_conn:
+                        try:
+                            waiting_bytes = self._serial_conn.in_waiting
+                            log_both('info', f"📊 Bytes waiting in buffer: {waiting_bytes}")
+                        except Exception as e:
+                            log_both('warning', f"📊 Error checking in_waiting: {e}")
+                    
+                    last_log_time = current_time
+                
+                # Collect any new output
+                new_output = self._collect_output()
+                if new_output:
+                    self._analysis.raw_output.extend(new_output)
+                    log_both('info', f"📥 Received {len(new_output)} lines of output:")
+                    for i, line in enumerate(new_output[:5]):  # Show first 5 lines
+                        log_both('info', f"📥   Line {i+1}: {repr(line)}")
+                    if len(new_output) > 5:
+                        log_both('info', f"📥   ... and {len(new_output) - 5} more lines")
+                    
+                    # Analyze output in real-time
+                    if analyze_output:
+                        self._analyze_output_patterns(new_output)
+                        log_both('info', f"🔍 Analysis updated: device_type={self._analysis.device_type}, confidence={self._analysis.confidence:.2f}")
+                else:
+                    log_both('debug', f"📭 No new output available (elapsed: {elapsed:.1f}s)")
+                
+                # Simple early exit: all interactions done + have data = exit immediately
+                interactions_complete = interaction_step >= len(self._interaction_sequences)
+                sufficient_data = len(self._analysis.raw_output) >= min_data_threshold
+                
+                if interactions_complete and sufficient_data:
+                    log_both('info', f"🎯 SIMPLE EARLY EXIT: All done!")
+                    log_both('info', f"🎯   - All interactions sent: {interaction_step}/{len(self._interaction_sequences)} ✅")
+                    log_both('info', f"🎯   - Sufficient data captured: {len(self._analysis.raw_output)} lines ✅")
+                    # Stop reader thread early to speed up cleanup
+                    self._stop_reading = True
+                    log_both('info', f"🎯 Exiting after {elapsed:.1f}s instead of waiting full {timeout}s")
+                    break
+                
+                # Auto-interact if enabled and no recent output
+                if (auto_interact and 
+                    current_time - last_interaction_time > 3 and  # Wait 3 seconds between interactions
+                    interaction_step < len(self._interaction_sequences)):
+                    
+                    interaction = self._interaction_sequences[interaction_step]
+                    log_both('info', f"💬 Sending interaction #{interaction_step}: {repr(interaction)}")
+                    
+                    if self._send_data(interaction):
+                        last_interaction_time = current_time
+                        interaction_step += 1
+                        log_both('info', f"✅ Successfully sent interaction #{interaction_step-1}")
+                        
+                        async_result.update(
+                            status=True,
+                            progress=progress,
+                            message=f"Sent interaction: {repr(interaction)} | Lines captured: {len(self._analysis.raw_output)}",
+                            data={
+                                "interactions_sent": interaction_step,
+                                "output_lines": len(self._analysis.raw_output),
+                                "login_detected": self._analysis.login_detected,
+                                "device_type": self._analysis.device_type
+                            }
+                        )
+                    else:
+                        log_both('error', f"❌ Failed to send interaction #{interaction_step}: {repr(interaction)}")
+                else:
+                    log_both('debug', f"⏳ Waiting... (elapsed: {elapsed:.1f}s, next_interaction: {interaction_step < len(self._interaction_sequences)})")
+                    async_result.update(
+                        status=True,
+                        progress=progress,
+                        message=f"Reading serial output... | Lines captured: {len(self._analysis.raw_output)}",
+                        data={
+                            "output_lines": len(self._analysis.raw_output),
+                            "login_detected": self._analysis.login_detected,
+                            "device_type": self._analysis.device_type
+                        }
+                    )
+                
+                # Short sleep to prevent busy waiting
+                await asyncio.sleep(0.5)
+            
+            logger.info(f"🏁 Main loop completed: elapsed={time.time() - start_time:.1f}s, lines_captured={len(self._analysis.raw_output)}")
+            
+            # Final analysis
+            async_result.update(
+                status=True,
+                progress=90,
+                message="Performing final analysis...",
+                data=self._get_analysis_data()
+            )
+            
+            if analyze_output:
+                final_analysis = self._perform_comprehensive_analysis()
+                self._analysis = final_analysis
+            
+            # Generate final report
+            report = self._generate_analysis_report()
+            
+            async_result.update(
+                status=True,
+                progress=100,
+                message="Serial reading and analysis completed",
+                data={
+                    "analysis": self._get_analysis_data(),
+                    "report": report,
+                    "total_output_lines": len(self._analysis.raw_output),
+                    "execution_time": time.time() - start_time
+                }
+            )
+            
+            logger.info(f"Returning AsyncExploitResult with status={async_result.status}, message='{async_result.message}'")
+            return async_result
+            
+        except Exception as e:
+            logger.error(f"Error during serial reading: {str(e)}")
+            async_result.update(
+                status=False,
+                message=f"Serial reading failed: {str(e)}",
+                progress=100,
+                data={"error": str(e)}
+            )
+            return async_result
+        finally:
+            # Cleanup
+            await self._cleanup()
+
+    @hookimpl
+    def stop(self):
+        """Stop the running serial reading"""
+        logger.info("Stopping serial reading")
+        self._stop_reading = True
+
+    @hookimpl
+    def cleanup(self):
+        """Cleanup after serial reading"""
+        logger.info("Cleaning up PicocomSerialReaderPlugin")
+        # Perform synchronous cleanup instead of creating async task
+        self._cleanup_sync()
+
+    def _cleanup_sync(self):
+        """Synchronous cleanup for serial connection and threads"""
+        logger.info("Cleaning up serial connection (sync)...")
+        self._stop_reading = True
+        
+        # Wait for reader thread to finish (non-blocking)
+        if self._reader_thread and self._reader_thread.is_alive():
+            self._reader_thread.join(timeout=2)
+            if self._reader_thread.is_alive():
+                logger.warning("Reader thread did not stop within 2s – skipping join to avoid hang")
+                # Do NOT attempt to close the serial port while the reader thread is still active
+                # to avoid potential deadlocks. We will detach and let it die with the process.
+                self._reader_thread = None
+                return  # Skip the rest of cleanup
+        
+        # Close serial connection (safe to do only if reader thread has stopped)
+        if self._serial_conn and self._serial_conn.is_open:
+            try:
+                self._serial_conn.close()
+                logger.info("Serial connection closed")
+            except Exception as e:
+                logger.error(f"Error closing serial connection: {e}")
+        
+        self._serial_conn = None
+        self._reader_thread = None
+
+    async def _cleanup(self):
+        """Async cleanup for use during normal execution"""
+        logger.info("Cleaning up serial connection...")
+        self._stop_reading = True
+        
+        # Wait for reader thread to finish (non-blocking)
+        if self._reader_thread and self._reader_thread.is_alive():
+            self._reader_thread.join(timeout=2)
+            if self._reader_thread.is_alive():
+                logger.warning("Reader thread did not stop within 2s – skipping join to avoid hang")
+                # Do NOT attempt to close the serial port while the reader thread is still active
+                # to avoid potential deadlocks. We will detach and let it die with the process.
+                self._reader_thread = None
+                return  # Skip the rest of cleanup
+        
+        # Close serial connection (safe to do only if reader thread has stopped)
+        if self._serial_conn and self._serial_conn.is_open:
+            try:
+                self._serial_conn.close()
+                logger.info("Serial connection closed")
+            except Exception as e:
+                logger.error(f"Error closing serial connection: {e}")
+        
+        self._serial_conn = None
+        self._reader_thread = None
+
+    def _list_serial_ports(self) -> List[str]:
+        """List available serial ports"""
+        try:
+            ports = serial.tools.list_ports.comports()
+            return [port.device for port in ports]
+        except Exception as e:
+            logger.error(f"Error listing serial ports: {e}")
+            return []
+
+    async def _connect_serial(self, port: str, baudrate: int) -> bool:
+        """Connect to serial port"""
+        try:
+            log_both('info', f"🔌 Attempting to connect to serial port {port} at {baudrate} baud...")
+            log_both('info', f"🔌 Connection parameters: 8N1, timeout=1s, no flow control")
+            
+            self._serial_conn = serial.Serial(
+                port=port,
+                baudrate=baudrate,
+                bytesize=serial.EIGHTBITS,
+                parity=serial.PARITY_NONE,
+                stopbits=serial.STOPBITS_ONE,
+                timeout=1,
+                xonxoff=False,
+                rtscts=False,
+                dsrdtr=False
+            )
+            
+            if self._serial_conn.is_open:
+                log_both('info', f"✅ Successfully connected to {port} at {baudrate} baud")
+                log_both('info', f"✅ Serial port details: name={self._serial_conn.name}, is_open={self._serial_conn.is_open}")
+                log_both('info', f"✅ Port settings: baudrate={self._serial_conn.baudrate}, bytesize={self._serial_conn.bytesize}")
+                
+                # Try to read any initial data
+                initial_waiting = self._serial_conn.in_waiting
+                log_both('info', f"✅ Initial bytes waiting: {initial_waiting}")
+                
+                return True
+            else:
+                log_both('error', f"❌ Failed to open serial port {port}")
+                return False
+                
+        except Exception as e:
+            log_both('error', f"❌ Error connecting to serial port {port}: {e}")
+            log_both('error', f"❌ Exception type: {type(e).__name__}")
+            return False
+
+    def _start_reader_thread(self):
+        """Start the serial reading thread"""
+        if self._reader_thread and self._reader_thread.is_alive():
+            return
+            
+        self._reader_thread = Thread(target=self._reader_loop, daemon=True)
+        self._reader_thread.start()
+
+    def _reader_loop(self):
+        """Main reading loop running in separate thread"""
+        logger.info("🧵 Serial reader thread started")
+        buffer = b""
+        total_bytes_read = 0
+        total_lines_queued = 0
+        last_activity_log = time.time()
+        activity_log_interval = 30.0  # Log activity every 30 seconds
+        
+        while not self._stop_reading and self._serial_conn and self._serial_conn.is_open:
+            try:
+                current_time = time.time()
+                
+                # Periodic activity logging
+                if current_time - last_activity_log >= activity_log_interval:
+                    logger.info(f"🧵 Reader thread status: bytes_read={total_bytes_read}, lines_queued={total_lines_queued}")
+                    logger.info(f"🧵 Buffer size: {len(buffer)} bytes")
+                    logger.info(f"🧵 Serial port connected: {self._serial_conn.is_open}")
+                    last_activity_log = current_time
+                
+                waiting = self._serial_conn.in_waiting
+                if waiting > 0:
+                    logger.debug(f"🧵 Reading {waiting} bytes from serial port")
+                    data = self._serial_conn.read(waiting)
+                    buffer += data
+                    total_bytes_read += len(data)
+                    
+                    logger.debug(f"🧵 Read {len(data)} bytes, buffer now {len(buffer)} bytes")
+                    
+                    # Process complete lines
+                    lines_in_this_batch = 0
+                    while b'\n' in buffer or b'\r' in buffer:
+                        if b'\r\n' in buffer:
+                            line, buffer = buffer.split(b'\r\n', 1)
+                        elif b'\n' in buffer:
+                            line, buffer = buffer.split(b'\n', 1)
+                        elif b'\r' in buffer:
+                            line, buffer = buffer.split(b'\r', 1)
+                        
+                        try:
+                            decoded_line = line.decode('utf-8', errors='replace').strip()
+                            if decoded_line:  # Only queue non-empty lines
+                                self._output_queue.put(decoded_line)
+                                lines_in_this_batch += 1
+                                total_lines_queued += 1
+                                logger.debug(f"🧵 Queued line #{total_lines_queued}: {repr(decoded_line)}")
+                        except Exception as e:
+                            logger.warning(f"🧵 Error decoding line: {e}")
+                    
+                    if lines_in_this_batch > 0:
+                        logger.info(f"🧵 Processed {lines_in_this_batch} lines from {len(data)} bytes")
+                else:
+                    logger.debug(f"🧵 No data waiting (checked at {current_time:.1f})")
+                
+                time.sleep(0.01)  # Small delay to prevent excessive CPU usage
+                
+            except Exception as e:
+                logger.error(f"🧵 Error in reader loop: {e}")
+                logger.error(f"🧵 Exception type: {type(e).__name__}")
+                import traceback
+                logger.error(f"🧵 Traceback: {traceback.format_exc()}")
+                break
+        
+        logger.info(f"🧵 Serial reader thread ended - Total: {total_bytes_read} bytes, {total_lines_queued} lines")
+
+    def _collect_output(self) -> List[str]:
+        """Collect available output from the queue"""
+        output = []
+        try:
+            while True:
+                line = self._output_queue.get_nowait()
+                output.append(line)
+        except Empty:
+            pass
+        return output
+
+    def _send_data(self, data: str) -> bool:
+        """Send data to serial port"""
+        try:
+            if self._serial_conn and self._serial_conn.is_open:
+                encoded_data = data.encode('utf-8')
+                log_both('info', f"📤 Sending {len(encoded_data)} bytes: {repr(data)}")
+                self._serial_conn.write(encoded_data)
+                self._serial_conn.flush()
+                log_both('info', f"📤 Data sent and flushed successfully")
+                return True
+            else:
+                log_both('error', f"📤 Cannot send data - serial connection not available")
+                return False
+        except Exception as e:
+            log_both('error', f"📤 Error sending data: {e}")
+            log_both('error', f"📤 Exception type: {type(e).__name__}")
+            return False
+
+    def _analyze_output_patterns(self, output_lines: List[str]):
+        """Analyze output for patterns in real-time"""
+        for line in output_lines:
+            line_lower = line.lower()
+            
+            # Check for login patterns
+            for pattern in self._login_patterns:
+                if re.search(pattern, line_lower):
+                    self._analysis.login_detected = True
+                    self._analysis.detected_patterns.append(f"login_pattern: {pattern}")
+                    logger.info(f"Login pattern detected: {pattern}")
+            
+            # Check for shell types
+            for shell_type, patterns in self._shell_patterns.items():
+                for pattern in patterns:
+                    if re.search(pattern, line, re.IGNORECASE):
+                        if self._analysis.shell_type == "unknown" or self._analysis.confidence < 0.8:
+                            self._analysis.shell_type = shell_type
+                            self._analysis.device_type = shell_type
+                            self._analysis.confidence = 0.8
+                            self._analysis.detected_patterns.append(f"shell_pattern: {shell_type}")
+                            logger.info(f"Shell type detected: {shell_type}")
+
+    def _perform_comprehensive_analysis(self) -> SerialAnalysis:
+        """Perform comprehensive analysis of all collected output"""
+        analysis = SerialAnalysis()
+        analysis.raw_output = self._analysis.raw_output.copy()
+        analysis.detected_patterns = self._analysis.detected_patterns.copy()
+        analysis.login_detected = self._analysis.login_detected
+        
+        all_output = "\n".join(analysis.raw_output)
+        all_output_lower = all_output.lower()
+        
+        # Advanced pattern matching
+        confidence_scores = {}
+        
+        # Boot sequence analysis
+        boot_patterns = {
+            'uboot': [r'u-boot', r'hit any key to stop autoboot', r'=>'],
+            'linux': [r'linux version', r'kernel', r'init:', r'systemd'],
+            'busybox': [r'busybox', r'built-in shell'],
+            'embedded': [r'firmware', r'bootloader', r'flash'],
+            'network': [r'ip address', r'dhcp', r'network', r'ethernet'],
+            'iot': [r'wifi', r'sensor', r'temperature', r'gpio']
+        }
+        
+        for device_type, patterns in boot_patterns.items():
+            score = 0
+            for pattern in patterns:
+                matches = len(re.findall(pattern, all_output_lower))
+                score += matches * 0.2
+            
+            if score > 0:
+                confidence_scores[device_type] = min(score, 1.0)
+        
+        # Determine most likely device type
+        if confidence_scores:
+            best_match = max(confidence_scores.items(), key=lambda x: x[1])
+            analysis.device_type = best_match[0]
+            analysis.confidence = best_match[1]
+        
+        # Extract firmware information
+        version_patterns = [
+            r'version\s+([0-9.]+)',
+            r'firmware\s+([0-9.]+)',
+            r'build\s+([0-9.]+)',
+            r'rev\s+([0-9.]+)'
+        ]
+        
+        for pattern in version_patterns:
+            matches = re.findall(pattern, all_output_lower)
+            if matches:
+                analysis.firmware_info['version'] = matches[0]
+                break
+        
+        return analysis
+
+    def _generate_analysis_report(self) -> str:
+        """Generate a human-readable analysis report"""
+        report = []
+        report.append("=== Serial Port Analysis Report ===")
+        report.append(f"Device Type: {self._analysis.device_type}")
+        report.append(f"Confidence: {self._analysis.confidence:.2f}")
+        report.append(f"Login Shell Detected: {'Yes' if self._analysis.login_detected else 'No'}")
+        report.append(f"Shell Type: {self._analysis.shell_type}")
+        report.append(f"Total Output Lines: {len(self._analysis.raw_output)}")
+        
+        if self._analysis.firmware_info:
+            report.append("\nFirmware Information:")
+            for key, value in self._analysis.firmware_info.items():
+                report.append(f"  {key}: {value}")
+        
+        if self._analysis.detected_patterns:
+            report.append("\nDetected Patterns:")
+            for pattern in set(self._analysis.detected_patterns):  # Remove duplicates
+                report.append(f"  - {pattern}")
+        
+        if self._analysis.raw_output:
+            report.append("\nSample Output (last 10 lines):")
+            for line in self._analysis.raw_output[-10:]:
+                report.append(f"  > {line}")
+        
+        return "\n".join(report)
+
+    def _get_analysis_data(self) -> Dict:
+        """Get analysis data as dictionary"""
+        return {
+            "device_type": self._analysis.device_type,
+            "confidence": self._analysis.confidence,
+            "login_detected": self._analysis.login_detected,
+            "shell_type": self._analysis.shell_type,
+            "firmware_info": self._analysis.firmware_info,
+            "detected_patterns": self._analysis.detected_patterns,
+            "output_lines_count": len(self._analysis.raw_output),
+            "raw_output_sample": self._analysis.raw_output[-5:] if self._analysis.raw_output else []
+        }