dwipe 2.0.1__py3-none-any.whl → 2.0.2__py3-none-any.whl

dwipe/DrivePreChecker.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+import subprocess
+import os
+import json
+from typing import Dict, List, Optional
+from dataclasses import dataclass, field
+
+@dataclass
+class PreCheckResult:
+    # Key = Short Code (Frozen, Locked), Value = Long Description
+    issues: Dict[str, str] = field(default_factory=dict)
+    modes: Dict[str, str] = field(default_factory=dict)
+
+class DrivePreChecker:
+    def __init__(self, timeout: int = 10):
+        self.timeout = timeout
+
+    def check_nvme_drive(self, device: str) -> PreCheckResult:
+        result = PreCheckResult()
+        try:
+            id_ctrl = subprocess.run(
+                ['nvme', 'id-ctrl', device, '-o', 'json'],
+                check=False, capture_output=True, text=True, timeout=self.timeout
+            )
+
+            if id_ctrl.returncode != 0:
+                result.issues['Unresponsive'] = "NVMe controller did not respond to id-ctrl"
+                return result
+
+            data = json.loads(id_ctrl.stdout)
+
+            # 1. Sanitize Support
+            sanicap = data.get('sanicap', 0)
+            if sanicap > 0:
+                if sanicap & 0x04: result.modes['CryptoNv'] = 'sanitize --action=0x04'
+                if sanicap & 0x02: result.modes['BlockNv'] = 'sanitize --action=0x02'
+                if sanicap & 0x08: result.modes['OvwrNv'] = 'sanitize --action=0x03'
+
+            # 2. Format Support (Legacy)
+            if 'Format NVM' in id_ctrl.stdout:
+                fna = data.get('fna', 0)
+                if (fna >> 2) & 0x1:
+                    result.modes['FmtCryptoNv'] = 'format --ses=2'
+                result.modes['FmtEraseNv'] = 'format --ses=1'
+
+            if not result.modes:
+                result.issues['Unsupported'] = "Drive lacks Sanitize or Format NVM capabilities"
+
+        except Exception as e:
+            result.issues['Error'] = f"NVMe Probe Exception: {str(e)}"
+
+        return result
+
+    def check_ata_drive(self, device: str) -> PreCheckResult:
+        result = PreCheckResult()
+        try:
+            info = subprocess.run(
+                ['hdparm', '-I', device],
+                check=False, capture_output=True, text=True, timeout=self.timeout
+            )
+
+            if info.returncode != 0:
+                result.issues['Unresponsive'] = "Drive did not respond to hdparm"
+                return result
+
+            out = info.stdout.lower()
+
+            # 1. Hardware Support Check
+            if "security erase unit" not in out:
+                result.issues['Unsupported'] = "Drive does not support ATA Security Erase"
+                return result
+
+            # 2. Frozen Check
+            if "frozen" in out and "not frozen" not in out:
+                result.issues['Frozen'] = "Drive is FROZEN (BIOS/OS lock). Cycle power or Suspend/Resume."
+
+            # 3. Security Enabled (Password set)
+            if "enabled" in out and "not enabled" not in out:
+                result.issues['Locked'] = "Security is ENABLED (Drive is currently password locked)"
+
+            # 4. Populate Modes only if no fatal issues
+            if not result.issues:
+                if "enhanced erase" in out:
+                    result.modes['EnhancedHd'] = '--user-master u --security-erase-enhanced NULL'
+                result.modes['EraseHd'] = '--user-master u --security-erase NULL'
+
+        except Exception as e:
+            result.issues['Error'] = f"ATA Probe Exception: {str(e)}"
+
+        return result

dwipe/FirmwareWipeTask.py

@@ -0,0 +1,370 @@
+"""
+FirmwareWipeTask - Firmware-based secure erase operations
+
+Includes:
+- FirmwareWipeTask: Abstract base class for firmware wipes
+- NvmeWipeTask: NVMe secure erase using nvme-cli
+- SataWipeTask: SATA/ATA secure erase using hdparm
+"""
+# pylint: disable=broad-exception-raised,broad-exception-caught
+import os
+import json
+import time
+import subprocess
+import traceback
+# from types import SimpleNamespace
+
+from .WipeTask import WipeTask
+from .Utils import Utils
+
+
+class FirmwareWipeTask(WipeTask):
+    """Abstract base class for firmware-based wipe operations
+
+    Firmware wipes execute in the drive's controller, not via CPU writes.
+    The host just sends a command and monitors for completion.
+
+    Progress reporting is estimated since most firmware doesn't report
+    real-time progress. NVMe sanitize can optionally poll for actual progress.
+
+    Subclasses must implement:
+    - _build_command(): Return list of command args
+    - _check_completion(): Check if wipe is complete
+    - _estimate_duration(): Estimate total time in seconds
+    """
+
+    def __init__(self, device_path, total_size, opts, command_args, wipe_name):
+        """Initialize firmware wipe task
+
+        Args:
+            device_path: Path to device (e.g., '/dev/sda', '/dev/nvme0n1')
+            total_size: Total size in bytes
+            opts: Options namespace
+            command_args: Command args from hw_caps (e.g., 'sanitize --action=0x04')
+            wipe_name: Human-readable name (e.g., 'Sanitize-Crypto')
+        """
+        super().__init__(device_path, total_size, opts)
+
+        self.command_args = command_args
+        self.wipe_name = wipe_name
+        self.process = None
+        self.finish_mono = None
+
+        # Estimated duration for progress reporting
+        self.estimated_duration = self._estimate_duration()
+
+    def _estimate_duration(self):
+        """Estimate total duration in seconds (override in subclasses)
+
+        Returns:
+            int: Estimated seconds for completion
+        """
+        return 60  # Default 1 minute
+
+    def get_display_name(self):
+        """Get display name for firmware wipe"""
+        return self.wipe_name
+
+    def _build_command(self):
+        """Build command list for subprocess (must be implemented by subclasses)
+
+        Returns:
+            list: Command args like ['nvme', 'sanitize', ...]
+        """
+        raise NotImplementedError("Subclasses must implement _build_command()")
+
+    def _check_completion(self):
+        """Check if wipe completed successfully (can be overridden)
+
+        Returns:
+            bool or None: True if done, False if failed, None if still running
+        """
+        if self.process and self.process.poll() is not None:
+            return self.process.returncode == 0
+        return None
+
+    def _write_marker(self):
+        """Write completion marker after firmware wipe
+
+        Firmware wipes erase the entire disk including any existing markers.
+        We need to write a new marker indicating the wipe is complete.
+        """
+        try:
+            # Force OS to re-read partition table (now empty)
+            subprocess.run(['blockdev', '--rereadpt', self.device_path],
+                          capture_output=True, timeout=5, check=False)
+            time.sleep(1)  # Let kernel settle
+
+            # Prepare marker data
+            data = {
+                "unixtime": int(time.time()),
+                "scrubbed_bytes": self.total_size,
+                "size_bytes": self.total_size,
+                "passes": 1,
+                "mode": self.wipe_name,  # e.g., 'Sanitize-Crypto'
+                "firmware_wipe": True
+            }
+            json_data = json.dumps(data).encode('utf-8')
+
+            # Build marker buffer (16KB)
+            buffer = bytearray(WipeTask.MARKER_SIZE)
+            buffer[:WipeTask.STATE_OFFSET] = b'\x00' * WipeTask.STATE_OFFSET
+            buffer[WipeTask.STATE_OFFSET:WipeTask.STATE_OFFSET + len(json_data)] = json_data
+            remaining = WipeTask.MARKER_SIZE - (WipeTask.STATE_OFFSET + len(json_data))
+            buffer[WipeTask.STATE_OFFSET + len(json_data):] = b'\x00' * remaining
+
+            # Write marker to beginning of device
+            with open(self.device_path, 'wb') as f:
+                f.write(buffer)
+                f.flush()
+                os.fsync(f.fileno())
+
+        except Exception as e:
+            # Don't fail the whole job if marker write fails
+            self.exception = f"Marker write warning: {e}"
+
+    def run_task(self):
+        """Execute firmware wipe operation (blocking, runs in thread)"""
+        try:
+            # Build command
+            cmd = self._build_command()
+
+            # Start subprocess (non-blocking)
+            self.process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True
+            )
+
+            # Monitor progress with polling loop
+            check_interval = 2  # Check every 2 seconds
+
+            while not self.do_abort:
+                # Check if process completed
+                completion_status = self._check_completion()
+
+                if completion_status is True:
+                    # Success!
+                    self.total_written = self.total_size
+                    self.finish_mono = time.monotonic()
+
+                    # Write marker after successful firmware wipe
+                    self._write_marker()
+                    break
+
+                elif completion_status is False:
+                    # Failed
+                    stderr = self.process.stderr.read() if self.process.stderr else ""
+                    self.exception = f"Firmware wipe failed: {stderr}"
+                    break
+
+                # Still running - update estimated progress
+                elapsed = time.monotonic() - self.start_mono
+                progress_pct = min(1.0, elapsed / self.estimated_duration)
+                self.total_written = int(self.total_size * progress_pct)
+
+                time.sleep(check_interval)
+
+            # Handle abort
+            if self.do_abort and self.process:
+                self.process.terminate()
+                time.sleep(0.5)
+                if self.process.poll() is None:
+                    self.process.kill()
+
+        except Exception:
+            self.exception = traceback.format_exc()
+        finally:
+            self.done = True
+
+    def get_status(self):
+        """Get current progress status (thread-safe)
+
+        Returns:
+            tuple: (elapsed_str, pct_str, rate_str, eta_str)
+        """
+        mono = time.monotonic()
+        elapsed_time = mono - self.start_mono
+
+        # Calculate percentage based on estimated progress
+        pct = (self.total_written / self.total_size) * 100 if self.total_size > 0 else 0
+        pct = min(pct, 100)
+        pct_str = f'{int(round(pct))}%'
+
+        if self.do_abort:
+            pct_str = 'STOP'
+
+        # Show "FW" to indicate firmware operation
+        rate_str = 'FW'
+
+        # Calculate ETA based on estimated duration
+        if pct < 100:
+            remaining = self.estimated_duration - elapsed_time
+            eta_str = Utils.ago_str(max(0, int(remaining)))
+        else:
+            eta_str = '0'
+
+        elapsed_str = Utils.ago_str(int(round(elapsed_time)))
+
+        return elapsed_str, pct_str, rate_str, eta_str
+
+    def get_summary_dict(self):
+        """Generate summary dictionary for structured logging
+
+        Returns:
+            dict: Summary with step details
+        """
+        mono = time.monotonic()
+        elapsed = mono - self.start_mono
+
+        return {
+            "step": f"firmware {self.wipe_name} {self.device_path}",
+            "elapsed": Utils.ago_str(int(elapsed)),
+            "rate": "Firmware",
+            "command": ' '.join(self._build_command()),
+            "bytes_written": self.total_written,
+            "bytes_total": self.total_size,
+            "result": "completed" if self.total_written == self.total_size else "partial"
+        }
+
+
+class NvmeWipeTask(FirmwareWipeTask):
+    """NVMe firmware wipe using nvme-cli
+
+    Supports various sanitize and format operations:
+    - Sanitize: Crypto Erase, Block Erase, Overwrite
+    - Format: Crypto Erase, User Data Erase
+
+    Example command_args:
+    - 'sanitize --action=0x04' (Crypto Erase)
+    - 'format --ses=2' (Format with Crypto Erase)
+    """
+
+    def _estimate_duration(self):
+        """Estimate NVMe wipe duration
+
+        Most NVMe sanitize/format operations complete in seconds.
+        Crypto erase: 2-10 seconds
+        Block erase: 10-30 seconds
+        Overwrite: 30-120 seconds
+        """
+        if 'sanitize' in self.command_args:
+            if 'crypto' in self.command_args or '0x04' in self.command_args:
+                return 10  # Crypto erase is very fast
+            elif 'block' in self.command_args or '0x02' in self.command_args:
+                return 30
+            else:  # Overwrite
+                return 120
+        else:  # Format
+            return 30
+
+    def _build_command(self):
+        """Build nvme command
+
+        Returns:
+            list: ['nvme', 'sanitize', '--action=0x04', '/dev/nvme0n1']
+        """
+        # Parse command_args: 'sanitize --action=0x04'
+        parts = self.command_args.split()
+        cmd = ['nvme'] + parts + [self.device_path]
+        return cmd
+
+    def _check_completion(self):
+        """Check NVMe wipe completion
+
+        Can optionally poll 'nvme sanitize-log' for actual progress.
+        For now, just check if process exited.
+        """
+        if self.process and self.process.poll() is not None:
+            return self.process.returncode == 0
+        return None
+
+    # TODO: Implement real-time progress polling via 'nvme sanitize-log'
+    # def _get_sanitize_progress(self):
+    #     """Query actual sanitize progress from device"""
+    #     try:
+    #         result = subprocess.run(
+    #             ['nvme', 'sanitize-log', self.device_path, '-o', 'json'],
+    #             capture_output=True, text=True, timeout=5
+    #         )
+    #         if result.returncode == 0:
+    #             data = json.loads(result.stdout)
+    #             # Parse progress from data
+    #             return progress_pct
+    #     except:
+    #         pass
+    #     return None
+
+
+class SataWipeTask(FirmwareWipeTask):
+    """SATA/ATA firmware wipe using hdparm
+
+    Uses ATA Security Erase command:
+    - Normal Erase: Writes zeros to all sectors (slow)
+    - Enhanced Erase: Cryptographic erase or vendor-specific (fast)
+
+    Example command_args:
+    - '--user-master u --security-erase NULL'
+    - '--user-master u --security-erase-enhanced NULL'
+
+    Note: Requires setting a temporary password before erase.
+    """
+
+    def _estimate_duration(self):
+        """Estimate SATA wipe duration
+
+        Enhanced erase: 2-10 minutes (varies by vendor)
+        Normal erase: ~1 hour per TB
+        """
+        if 'enhanced' in self.command_args:
+            return 600  # 10 minutes for enhanced
+        else:
+            # Estimate based on size: 1 hour per TB
+            size_tb = self.total_size / (1024**4)
+            hours = max(0.5, size_tb)
+            return int(hours * 3600)
+
+    def _build_command(self):
+        """Build hdparm command
+
+        For security erase, we need to:
+        1. Set password: hdparm --user-master u --security-set-pass NULL /dev/sda
+        2. Erase: hdparm --user-master u --security-erase NULL /dev/sda
+
+        We'll just build the erase command - password setting happens in run_task
+        """
+        # Parse: '--user-master u --security-erase-enhanced NULL'
+        parts = self.command_args.split()
+        cmd = ['hdparm'] + parts + [self.device_path]
+        return cmd
+
+    def _set_ata_password(self):
+        """Set temporary ATA password before erase
+
+        Returns:
+            bool: True if successful
+        """
+        try:
+            cmd = ['hdparm', '--user-master', 'u', '--security-set-pass', 'NULL', self.device_path]
+            result = subprocess.run(cmd, capture_output=True, text=True, timeout=10)
+            return result.returncode == 0
+        except Exception as e:
+            self.exception = f"Failed to set ATA password: {e}"
+            return False
+
+    def run_task(self):
+        """Execute SATA firmware wipe (overrides base to add password step)"""
+        try:
+            # Step 1: Set temporary password
+            if not self._set_ata_password():
+                self.exception = "Failed to set ATA security password"
+                self.done = True
+                return
+
+            # Step 2: Execute erase command (base class handles this)
+            super().run_task()
+
+        except Exception:
+            self.exception = traceback.format_exc()
+            self.done = True

dwipe/LsblkMonitor.py

@@ -0,0 +1,124 @@
+"""
+LsblkMonitor - Background thread for monitoring block device changes
+"""
+import os
+import threading
+import subprocess
+
+
+class LsblkMonitor:
+    """Background monitor that checks for block device changes and runs lsblk"""
+
+    def __init__(self, check_interval=0.2):
+        """
+        Initialize the lsblk monitor.
+
+        Args:
+            check_interval: How often to check for changes (seconds)
+        """
+        self.check_interval = check_interval
+        self.lsblk_str = ""
+        self._lock = threading.Lock()
+        self._thread = None
+        self._stop_event = threading.Event()
+        self.last_fingerprint = None
+
+    def start(self):
+        """Start the background monitoring thread"""
+        if self._thread is not None and self._thread.is_alive():
+            return  # Already running
+
+        self._stop_event.clear()
+        self._thread = threading.Thread(target=self._monitor_loop, daemon=True)
+        self._thread.start()
+
+    def stop(self):
+        """Stop the background monitoring thread"""
+        self._stop_event.set()
+        if self._thread is not None:
+            self._thread.join(timeout=1.0)
+
+    def check_for_changes(self):
+        """
+        Check if block devices or partitions have changed.
+
+        Returns:
+            True if changes detected, False otherwise
+        """
+        try:
+            # 1. Quickest check: Does the list of block devices match?
+            # This catches "Forget" (DEL) and "Scan" (!) events immediately.
+            current_devs = os.listdir('/sys/class/block')
+
+            # 2. Secondary check: Do the partition sizes/counts match?
+            with open('/proc/partitions', 'r', encoding='utf-8') as f:
+                current_parts = f.read()
+
+            # Create a combined "Fingerprint"
+            fingerprint = f"{len(current_devs)}|{current_parts}"
+
+            if fingerprint != self.last_fingerprint:
+                self.last_fingerprint = fingerprint
+                return True
+
+        except Exception:  # pylint: disable=broad-exception-caught
+            # If we can't read /sys or /proc, default to True
+            # so we don't get stuck with a blank screen.
+            return True
+        return False
+
+    def _run_lsblk(self):
+        """
+        Run lsblk and capture output in JSON format matching DeviceInfo.parse_lsblk requirements.
+
+        Returns:
+            JSON output string from lsblk command
+        """
+        try:
+            result = subprocess.run(
+                ['lsblk', '-J', '--bytes', '-o',
+                 'NAME,MAJ:MIN,FSTYPE,TYPE,LABEL,PARTLABEL,FSUSE%,SIZE,MOUNTPOINTS,UUID,PARTUUID,SERIAL'],
+                capture_output=True,
+                text=True,
+                timeout=5.0,
+                check=False
+            )
+            return result.stdout
+        except Exception:  # pylint: disable=broad-exception-caught
+            return ""  # Return empty string on error
+
+    def _monitor_loop(self):
+        """Background thread loop that monitors for changes"""
+        while not self._stop_event.is_set():
+            if self.check_for_changes():
+                # Changes detected, run lsblk
+                lsblk_output = self._run_lsblk()
+
+                # Store the result in a thread-safe manner
+                with self._lock:
+                    self.lsblk_str = lsblk_output
+
+            # Sleep for the check interval
+            self._stop_event.wait(self.check_interval)
+
+    def get_and_clear(self):
+        """
+        Get the latest lsblk output and clear it.
+
+        Returns:
+            String containing lsblk output, or empty string if no new data
+        """
+        with self._lock:
+            result = self.lsblk_str
+            self.lsblk_str = ""
+            return result
+
+    def peek(self):
+        """
+        Get the latest lsblk output without clearing it.
+
+        Returns:
+            String containing lsblk output, or empty string if no new data
+        """
+        with self._lock:
+            return self.lsblk_str

dwipe/PersistentState.py

@@ -9,7 +9,7 @@ from .Utils import Utils
 
 
 class PersistentState:
-    """Manages persistent state for dwipe preferences and device locks"""
+    """Manages persistent state for dwipe preferences and device blocks"""
 
     def __init__(self, config_path=None):
         """Initialize persistent state
@@ -24,7 +24,7 @@ class PersistentState:
         self.config_path = Path(config_path)
         self.state = {
             'theme': 'default',
-            'wipe_mode': 'Zero',  # 'Rand' or 'Zero' or +V
+            'wipe_mode': '+V',  # '+V' (verify) or '-V' (no verify)
             'passes': 1,  # 1, 2, or 4 wipe pass
             'confirmation': 'YES',  # 'Y', 'y', 'YES', 'yes', 'device'
             'verify_pct': 2,  # 0, 2, 5, 10, 25, 50, 100
@@ -32,7 +32,7 @@ class PersistentState:
             'slowdown_stop': 16,
             'stall_timeout': 60,
             'port_serial': False,
-            'devices': {}  # device_id -> {locked, last_seen, last_name, size_bytes}
+            'devices': {}  # device_id -> {blocked, last_seen, last_name, size_bytes}
         }
         self.dirty = False
         self.max_devices = 400
@@ -63,6 +63,18 @@ class PersistentState:
                 with open(self.config_path, 'r', encoding='utf-8') as f:
                     loaded = json.load(f)
                     self.state.update(loaded)
+
+                    # Migrate old wipe_mode values to new format
+                    old_wipe_mode = self.state.get('wipe_mode', '+V')
+                    if old_wipe_mode not in ['+V', '-V']:
+                        # Old format: 'Zero', 'Zero+V', 'Rand', 'Rand+V'
+                        # Convert to new format: '+V' or '-V'
+                        if '+V' in str(old_wipe_mode):
+                            self.state['wipe_mode'] = '+V'
+                        else:
+                            self.state['wipe_mode'] = '-V'
+                        self.dirty = True  # Save the migration
+
             except (json.JSONDecodeError, IOError) as e:
                 print(f'Warning: Could not load state from {self.config_path}: {e}')
 
@@ -134,24 +146,28 @@ class PersistentState:
         return f'fallback:{fallback_id}'
 
     def get_device_locked(self, partition):
-        """Check if a device is locked
+        """Check if a device is blocked (backward compatible with 'locked')
 
         Args:
             partition: SimpleNamespace with device info
 
         Returns:
-            bool: True if device is locked
+            bool: True if device is blocked
         """
         device_id = self.make_device_id(partition)
         device_state = self.state['devices'].get(device_id, {})
+
+        # Check new 'blocked' field first, fall back to old 'locked' field for backward compatibility
+        if 'blocked' in device_state:
+            return device_state['blocked']
         return device_state.get('locked', False)
 
     def set_device_locked(self, partition, locked):
-        """Set device lock state
+        """Set device block state
 
         Args:
             partition: SimpleNamespace with device info
-            locked: bool, True to lock device
+            locked: bool, True to block device (parameter name kept for API compatibility)
         """
         device_id = self.make_device_id(partition)
         now = int(time.time())
@@ -160,7 +176,9 @@ class PersistentState:
             self.state['devices'][device_id] = {}
 
         device_state = self.state['devices'][device_id]
-        device_state['locked'] = locked
+        device_state['blocked'] = locked  # Only save 'blocked', not 'locked'
+        # Remove old 'locked' field if it exists (gradual migration)
+        device_state.pop('locked', None)
         device_state['last_seen'] = now
         device_state['last_name'] = partition.name
         device_state['size_bytes'] = partition.size_bytes