feat(secure): add secure delete functionality (v3.3.0)

Author: Binity Bot

release_helper.py

@@ -13,18 +13,28 @@
 
 RELEASES = [
     {
-        "tag": "v3.2.1",
-        "prev": "v3.2.0",
-        "name": "Binity v3.2.1",
-        "body": """## 🛠️ UX Improvements (v3.2.1)
-Hotfix release improving the Auto-Updater user experience.
-
-### improvements
-- **User Feedback**: "Check for updates" now displays an immediate "Checking..." notification.
-- **Dialogs**: "No updates found" and errors are now shown in a dialog box instead of a transient notification, ensuring you don't miss the result.
+        "tag": "v3.3.0",
+        "prev": "v3.2.1",
+        "name": "Binity v3.3.0",
+        "body": """## 🛡️ Secure Delete (Best Effort) & UX (v3.3.0)
+Major update introducing privacy-focused deletion features and enhanced settings.
+
+### 🔥 New Features
+- **🛡️ Secure Delete**:
+  - Added "Secure Delete" modes in Settings: **1-pass zeros** and **1-pass random data**.
+  - **Best Effort**: Attempts to overwrite file content before deletion.
+  - **Payload Protection**: Strictly wipes only files within `$Recycle.Bin` matching specific patterns (`$R...`), ensuring safety of other data.
+  - **Feedback**: Detailed notifications about how many files were successfully overwritten and if any were locked.
+- **Improved UX**:
+  - **Confirmation Dialogs**: Now clearly state which mode is active (Normal vs Secure) and warn about disk load.
+  - **Warnings**: One-time warning when enabling secure mode about SSD wear and limitations.
+
+### 🛠️ Improvements
+- **Tests**: Added unit tests for secure deletion logic and settings normalization.
+- **I18n**: Fully localized (RU/EN) for all new dialogs and menus.
 
 ### 📝 Notes
-- Release to ensure users have the best updater experience out-of-the-box.
+- **SSD Users**: Please note that due to hardware wear leveling, absolute secure deletion cannot be guaranteed on modern SSDs/NVMe drives without full disk encryption/sanitization. Binity does its best to overwrite data at the OS level.
 """
     }
 ]

src/core/i18n.py

@@ -23,6 +23,16 @@
         "sound_off": "Без звука",
         "sound_windows": "Системный звук Windows",
         "sound_paper": "Сминание бумаги",
+        "secure_delete": "Безвозвратное удаление",
+        "secure_delete_off": "Обычная очистка (быстро)",
+        "secure_delete_zero": "Secure Delete: 1-pass нулями",
+        "secure_delete_random": "Secure Delete: 1-pass случайными данными",
+        "secure_delete_load_note": "Повышает нагрузку на диск и замедляет очистку",
+        "secure_delete_info_title": "Безвозвратное удаление",
+        "secure_delete_info_message": "Режим повышает нагрузку на диск. Для SSD/NVMe абсолютная гарантия стирания не обеспечивается из-за wear leveling.",
+        "secure_clear_started": "Запущена безопасная очистка. Возможна повышенная нагрузка на диск.",
+        "secure_clear_success_message": "Безопасная очистка завершена: перезаписано {files} файлов ({size}).",
+        "secure_clear_partial_message": "Часть файлов не удалось перезаписать ({failed}). Остальные элементы удалены стандартно.",
         "overflow_notify": "Уведомлять о переполнении",
         "theme_sync": "Синхронизировать тему Windows",
         "auto_check_updates": "Автопроверка обновлений",
@@ -50,6 +60,8 @@
         "exit": "Выход",
         "confirm_dialog_title": "Подтверждение очистки корзины",
         "confirm_dialog_message": "Удалить все элементы из корзины без возможности восстановления?",
+        "confirm_dialog_message_secure_zero": "Выполнить безопасную очистку корзины (1-pass нулями)?\n\nЭто замедлит операцию и увеличит нагрузку на диск.",
+        "confirm_dialog_message_secure_random": "Выполнить безопасную очистку корзины (1-pass случайными данными)?\n\nЭто самая тяжелая нагрузка на диск среди режимов очистки.",
         "confirm": "Очистить",
         "cancel": "Отмена",
         "about_title": "О программе",
@@ -86,6 +98,16 @@
         "sound_off": "No sound",
         "sound_windows": "Windows system sound",
         "sound_paper": "Paper crumple",
+        "secure_delete": "Secure delete",
+        "secure_delete_off": "Normal empty (fast)",
+        "secure_delete_zero": "Secure Delete: 1-pass zeros",
+        "secure_delete_random": "Secure Delete: 1-pass random data",
+        "secure_delete_load_note": "Increases disk load and slows cleanup",
+        "secure_delete_info_title": "Secure Delete",
+        "secure_delete_info_message": "This mode increases disk load. On SSD/NVMe absolute wipe guarantees are not possible due to wear leveling.",
+        "secure_clear_started": "Secure cleanup started. Disk activity may temporarily increase.",
+        "secure_clear_success_message": "Secure cleanup finished: overwritten {files} files ({size}).",
+        "secure_clear_partial_message": "Some files could not be overwritten ({failed}). Remaining items were removed normally.",
         "overflow_notify": "Notify when overloaded",
         "theme_sync": "Sync with Windows theme",
         "auto_check_updates": "Auto-check updates",
@@ -113,6 +135,8 @@
         "exit": "Exit",
         "confirm_dialog_title": "Confirm Empty Recycle Bin",
         "confirm_dialog_message": "Delete all items from Recycle Bin permanently?",
+        "confirm_dialog_message_secure_zero": "Run secure recycle-bin cleanup (1-pass zeros)?\n\nThis is slower and increases disk load.",
+        "confirm_dialog_message_secure_random": "Run secure recycle-bin cleanup (1-pass random data)?\n\nThis is the heaviest disk load mode.",
         "confirm": "Empty",
         "cancel": "Cancel",
         "about_title": "About",

src/core/settings.py

@@ -17,6 +17,8 @@
     "overflow_notify_enabled": True,
     "overflow_notify_threshold_gb": 15,
     "theme_sync": True,
+    "secure_delete_mode": "off",
+    "secure_delete_info_ack": False,
     "auto_check_updates": True,
     "last_update_check": "",
     "skipped_update_version": "",
@@ -86,6 +88,12 @@ def _normalize(self) -> None:
 
         self.values["theme_sync"] = bool(self.values.get("theme_sync", True))
 
+        secure_mode = str(self.values.get("secure_delete_mode", "off")).lower()
+        if secure_mode not in ("off", "zero", "random"):
+            secure_mode = "off"
+        self.values["secure_delete_mode"] = secure_mode
+        self.values["secure_delete_info_ack"] = bool(self.values.get("secure_delete_info_ack", False))
+
         self.values["auto_check_updates"] = bool(self.values.get("auto_check_updates", True))
 
         last_update_check = str(self.values.get("last_update_check", "") or "").strip()
@@ -200,6 +208,15 @@ def theme_sync(self) -> bool:
     def auto_check_updates(self) -> bool:
         return bool(self.get("auto_check_updates", True))
 
+    @property
+    def secure_delete_mode(self) -> str:
+        mode = str(self.get("secure_delete_mode", "off")).lower()
+        return mode if mode in ("off", "zero", "random") else "off"
+
+    @property
+    def secure_delete_info_ack(self) -> bool:
+        return bool(self.get("secure_delete_info_ack", False))
+
     @property
     def last_update_check(self) -> str:
         return str(self.get("last_update_check", "") or "")

src/services/recycle_bin.py

@@ -1,14 +1,23 @@
-from __future__ import annotations
+from __future__ import annotations
 
 import ctypes
+import os
 import subprocess
 from dataclasses import dataclass
+from pathlib import Path
 
 
 SHERB_NOCONFIRMATION = 0x00000001
 SHERB_NOPROGRESSUI = 0x00000002
 SHERB_NOSOUND = 0x00000004
 
+SECURE_DELETE_OFF = "off"
+SECURE_DELETE_ZERO = "zero"
+SECURE_DELETE_RANDOM = "random"
+SECURE_DELETE_MODES = (SECURE_DELETE_OFF, SECURE_DELETE_ZERO, SECURE_DELETE_RANDOM)
+
+_WIPE_CHUNK_SIZE = 1024 * 1024
+
 
 class SHQUERYRBINFO(ctypes.Structure):
     _fields_ = [
@@ -18,18 +27,27 @@ class SHQUERYRBINFO(ctypes.Structure):
     ]
 
 
-@dataclass
+@dataclass(slots=True)
 class RecycleBinInfo:
     size_bytes: int
     items: int
 
 
+@dataclass(slots=True)
+class BinClearResult:
+    success: bool
+    secure_mode: str
+    wiped_files: int = 0
+    wiped_bytes: int = 0
+    wipe_failures: int = 0
+
+
 class RecycleBinService:
     SIZE_THRESHOLDS_BYTES = (
-        256 * 1024 * 1024,        # 256 MB
-        int(1.5 * 1024**3),       # 1.5 GB
-        4 * 1024**3,              # 4 GB
-        8 * 1024**3,              # 8 GB
+        256 * 1024 * 1024,  # 256 MB
+        int(1.5 * 1024**3),  # 1.5 GB
+        4 * 1024**3,  # 4 GB
+        8 * 1024**3,  # 8 GB
     )
     ITEM_THRESHOLDS = (
         25,
@@ -79,14 +97,160 @@ def get_level(cls) -> int:
         return cls.level_from_metrics(info.size_bytes, info.items)
 
     @staticmethod
-    def empty_bin() -> bool:
+    def _normalize_secure_mode(mode: str) -> str:
+        candidate = str(mode or SECURE_DELETE_OFF).lower()
+        return candidate if candidate in SECURE_DELETE_MODES else SECURE_DELETE_OFF
+
+    @staticmethod
+    def _is_safe_recycle_payload_path(path: Path) -> bool:
+        text = str(path).replace("/", "\\").lower()
+        if "\\$recycle.bin\\" not in text:
+            return False
+        suffix = text.split("\\$recycle.bin\\", 1)[1]
+        parts = [part for part in suffix.split("\\") if part]
+        if len(parts) < 2:
+            return False
+        # Expected pattern: <sid>\\$Rxxxxx[\\...]
+        return parts[1].startswith("$r")
+
+    @staticmethod
+    def _iter_drive_letters():
+        if os.name != "nt":
+            return
+
+        try:
+            mask = int(ctypes.windll.kernel32.GetLogicalDrives())
+            if mask <= 0:
+                raise RuntimeError("no drives mask")
+            for index in range(26):
+                if mask & (1 << index):
+                    yield chr(ord("A") + index)
+            return
+        except Exception:
+            pass
+
+        for index in range(26):
+            yield chr(ord("A") + index)
+
+    @classmethod
+    def _iter_wipe_targets(cls):
+        if os.name != "nt":
+            return
+
+        for letter in cls._iter_drive_letters() or []:
+            recycle_root = Path(f"{letter}:\\$Recycle.Bin")
+            if not recycle_root.exists() or not recycle_root.is_dir():
+                continue
+
+            try:
+                sid_dirs = recycle_root.iterdir()
+            except OSError:
+                continue
+
+            for sid_dir in sid_dirs:
+                if not sid_dir.is_dir():
+                    continue
+
+                try:
+                    entries = sid_dir.iterdir()
+                except OSError:
+                    continue
+
+                for entry in entries:
+                    if not entry.name.lower().startswith("$r"):
+                        continue
+                    if entry.is_symlink():
+                        continue
+
+                    if entry.is_file():
+                        if cls._is_safe_recycle_payload_path(entry):
+                            yield entry
+                        continue
+
+                    if not entry.is_dir():
+                        continue
+
+                    try:
+                        nested_items = entry.rglob("*")
+                    except OSError:
+                        continue
+
+                    for nested in nested_items:
+                        if nested.is_symlink() or not nested.is_file():
+                            continue
+                        if cls._is_safe_recycle_payload_path(nested):
+                            yield nested
+
+    @staticmethod
+    def _wipe_file(path: Path, mode: str) -> int:
+        try:
+            size = int(path.stat().st_size)
+        except OSError:
+            return 0
+
+        if size <= 0:
+            return 0
+
+        zero_chunk = b"\x00" * _WIPE_CHUNK_SIZE if mode == SECURE_DELETE_ZERO else b""
+
+        with open(path, "r+b") as fh:
+            remaining = size
+            while remaining > 0:
+                chunk_size = _WIPE_CHUNK_SIZE if remaining >= _WIPE_CHUNK_SIZE else remaining
+                if mode == SECURE_DELETE_ZERO:
+                    fh.write(zero_chunk[:chunk_size])
+                else:
+                    fh.write(os.urandom(chunk_size))
+                remaining -= chunk_size
+            fh.flush()
+            os.fsync(fh.fileno())
+
+        return size
+
+    @classmethod
+    def _best_effort_secure_wipe(cls, mode: str) -> tuple[int, int, int]:
+        wiped_files = 0
+        wiped_bytes = 0
+        wipe_failures = 0
+
+        for target in cls._iter_wipe_targets() or []:
+            try:
+                bytes_written = cls._wipe_file(target, mode)
+                wiped_files += 1
+                wiped_bytes += bytes_written
+            except Exception:
+                wipe_failures += 1
+
+        return wiped_files, wiped_bytes, wipe_failures
+
+    @staticmethod
+    def _empty_bin_shell() -> bool:
         try:
             flags = SHERB_NOCONFIRMATION | SHERB_NOPROGRESSUI | SHERB_NOSOUND
             result = ctypes.windll.shell32.SHEmptyRecycleBinW(None, None, flags)
             return result == 0
         except Exception:
             return False
 
+    @classmethod
+    def empty_bin(cls, secure_mode: str = SECURE_DELETE_OFF) -> BinClearResult:
+        mode = cls._normalize_secure_mode(secure_mode)
+
+        wiped_files = 0
+        wiped_bytes = 0
+        wipe_failures = 0
+        if mode != SECURE_DELETE_OFF:
+            wiped_files, wiped_bytes, wipe_failures = cls._best_effort_secure_wipe(mode)
+
+        success = cls._empty_bin_shell()
+        return BinClearResult(
+            success=success,
+            secure_mode=mode,
+            wiped_files=wiped_files,
+            wiped_bytes=wiped_bytes,
+            wipe_failures=wipe_failures,
+        )
+
     @staticmethod
     def open_bin() -> bool:
         try:

src/ui/dialogs/confirm_dialog.py

@@ -7,9 +7,10 @@
 
 
 class ConfirmDialog(QDialog):
-    def __init__(self, i18n: I18n, parent=None) -> None:
+    def __init__(self, i18n: I18n, message_override: str | None = None, parent=None) -> None:
         super().__init__(parent)
         self.i18n = i18n
+        self._message_override = message_override
 
         self.setWindowFlag(Qt.WindowType.WindowContextHelpButtonHint, False)
         self.setModal(True)
@@ -63,6 +64,6 @@ def refresh_texts(self) -> None:
         title = self.i18n.tr("confirm_dialog_title")
         self.setWindowTitle(title)
         self.title_label.setText(title)
-        self.message_label.setText(self.i18n.tr("confirm_dialog_message"))
+        self.message_label.setText(self._message_override or self.i18n.tr("confirm_dialog_message"))
         self.cancel_btn.setText(self.i18n.tr("cancel"))
         self.confirm_btn.setText(self.i18n.tr("confirm"))