trident-windows 0.9.0__py3-none-any.whl

trident/__init__.py

@@ -0,0 +1,2 @@
+"""TRIDENT — The immune layer for Windows."""
+__version__ = "0.9.0"

trident/__main__.py

@@ -0,0 +1,289 @@
+"""TRIDENT entry point."""
+from __future__ import annotations
+
+import os
+import sys
+import time
+from datetime import datetime
+from pathlib import Path
+
+from . import toast
+from .action import ActionLayer
+from .audit import AuditLog
+from .cascade import Cascade
+from .config import load
+from .contracts import Action, Evidence
+from .decision import DecisionKernel
+from .mode import ModeStore
+from .runtime import (
+    CLEANUP_DIR,
+    LOGS_DIR,
+    TRUSTED_PATHS_FILE,
+    _DATA_ROOT,
+    ensure_user_dirs,
+)
+from .system_defaults import is_system_safe
+from .telemetry import TelemetrySession
+from .trust_store import TrustStore
+
+
+def _resolve_paths(cfg) -> dict:
+    """Resolve model, tokenizer, and config paths.
+
+    Model files live in %LOCALAPPDATA%\\TRIDENT\\models, populated by
+    `trident models fetch`.
+    """
+    model_dir = _DATA_ROOT / "models"
+    return {
+        "model_path": model_dir / cfg.model.filename,
+        "tokenizer_dir": model_dir / "tokenizer",
+        "config_path": model_dir / "rl_agent_config.json",
+    }
+
+
+def _ts() -> str:
+    return datetime.now().strftime("%H:%M:%S.%f")[:-3]
+
+
+def _is_self_venv(image_path: str | None) -> bool:
+    if not image_path:
+        return False
+    try:
+        venv_prefix = os.path.normcase(os.path.abspath(sys.prefix))
+        path = os.path.normcase(os.path.abspath(image_path))
+        return path.startswith(venv_prefix + os.sep)
+    except Exception:
+        return False
+
+
+def main() -> int:
+    """Load config, wire all layers, run the watch loop."""
+    ensure_user_dirs()
+
+    # Auto-resolves to %LOCALAPPDATA%\TRIDENT\config\trident.toml,
+    # seeding from the shipped default on first run.
+    cfg = load()
+    paths = _resolve_paths(cfg)
+
+    if not paths["model_path"].exists():
+        print(f"[TRIDENT] Model not found at {paths['model_path']}.", file=sys.stderr)
+        print("[TRIDENT] Run `trident models fetch` to download it.", file=sys.stderr)
+        return 1
+
+    print("[TRIDENT] Loading decision kernel...")
+    kernel = DecisionKernel(
+        model_path=paths["model_path"],
+        tokenizer_dir=paths["tokenizer_dir"],
+        config_path=paths["config_path"],
+        temperature=1.0,
+        max_len=cfg.model.max_len,
+        head_max_len=cfg.model.head_max_len,
+    )
+    kernel.load()
+    print("[TRIDENT] Model ready.")
+
+    mode_store = ModeStore()
+    mode = mode_store.mode
+    print(f"[TRIDENT] Mode: {mode}")
+
+    cascade = Cascade(
+        tier1_threshold=cfg.cascade.tier1_threshold,
+        tier2_threshold=cfg.cascade.tier2_threshold,
+        tier2_max_cycles=cfg.cascade.tier2_max_cycles,
+        suppression_after=cfg.cascade.escalation_suppression_after,
+    )
+
+    action_layer = ActionLayer(
+        ps1_output_dir=CLEANUP_DIR,
+        safety_whitelist=cfg.action.safety_whitelist,
+    )
+
+    audit = AuditLog(LOGS_DIR)
+    trust_store = TrustStore(TRUSTED_PATHS_FILE)
+    trusted_count = len(trust_store.all_trusted())
+    if trusted_count:
+        print(f"[TRIDENT] Trust store loaded: {trusted_count} path(s) trusted.")
+
+    telemetry = TelemetrySession(ring_buffer_size=cfg.telemetry.ring_buffer_size)
+    telemetry.start()
+
+    self_pid = os.getpid()
+    print(f"[TRIDENT] Watching for process events (self pid={self_pid}). Ctrl+C to stop.")
+
+    toast.show_startup(trusted_count, mode=mode)
+
+    suppression_announced: set[int] = set()
+    runtime_trusted_pids: set[int] = set()
+
+    try:
+        while True:
+            new_mode = mode_store.poll()
+            if new_mode is not None and new_mode != mode:
+                mode = new_mode
+                print(f"[TRIDENT] {_ts()} mode changed to {mode}")
+
+            newly_trusted = trust_store.poll()
+            if newly_trusted:
+                import psutil
+                for p in newly_trusted:
+                    print(f"[TRIDENT] {_ts()} trusted via toast: {p}")
+                    try:
+                        target = os.path.normcase(os.path.abspath(p))
+                    except Exception:
+                        continue
+                    for proc in psutil.process_iter(["pid", "exe"]):
+                        try:
+                            exe = proc.info.get("exe")
+                            if not exe:
+                                continue
+                            if os.path.normcase(os.path.abspath(exe)) == target:
+                                runtime_trusted_pids.add(proc.info["pid"])
+                                print(
+                                    f"[TRIDENT] {_ts()} silenced running pid "
+                                    f"{proc.info['pid']} (trusted)"
+                                )
+                        except (psutil.NoSuchProcess, psutil.AccessDenied):
+                            continue
+
+            batch = telemetry.next_batch(cfg.telemetry.batch_size_max)
+            if not batch:
+                time.sleep(0.2)
+                continue
+
+            filtered = [ev for ev in batch if ev.ppid != self_pid]
+            skipped_internal = len(batch) - len(filtered)
+            if skipped_internal:
+                print(
+                    f"[TRIDENT] {_ts()} skipped {skipped_internal} "
+                    f"self-spawned process(es)"
+                )
+
+            before = len(filtered)
+            filtered = [ev for ev in filtered if not _is_self_venv(ev.image_path)]
+            skipped_venv = before - len(filtered)
+            if skipped_venv:
+                print(
+                    f"[TRIDENT] {_ts()} skipped {skipped_venv} "
+                    f"self-venv process(es)"
+                )
+
+            to_score = []
+            skipped_system = 0
+            for ev in filtered:
+                name = Path(ev.image_path).name if ev.image_path else ""
+                if is_system_safe(name, bool(ev.is_system_path)):
+                    audit.write({
+                        "pid": ev.pid,
+                        "name": name,
+                        "path": ev.image_path,
+                        "outcome": "system_pretrusted",
+                    })
+                    skipped_system += 1
+                    continue
+                to_score.append(ev)
+
+            if skipped_system:
+                print(
+                    f"[TRIDENT] {_ts()} skipped {skipped_system} "
+                    f"known system binar{'y' if skipped_system == 1 else 'ies'}"
+                )
+
+            if not to_score:
+                continue
+
+            decisions = kernel.score_batch(to_score)
+            for ev, dec in zip(to_score, decisions):
+                name = Path(ev.image_path).name if ev.image_path else "?"
+                tier = cascade.route(dec, ev)
+                is_trusted = bool(ev.image_path) and trust_store.is_trusted(ev.image_path)
+                is_runtime_trusted = ev.pid in runtime_trusted_pids
+
+                suffix = ""
+                if is_trusted:
+                    suffix = " [trusted]"
+                elif is_runtime_trusted:
+                    suffix = " [trusted:runtime]"
+
+                print(
+                    f"[TRIDENT] {_ts()} {ev.pid} {name} -> "
+                    f"action={dec.action} trust={dec.trust_level} "
+                    f"conf={dec.confidence:.3f} tier={tier}{suffix}"
+                )
+
+                if is_trusted or is_runtime_trusted:
+                    outcome = (
+                        "trusted_override" if dec.action == "terminate"
+                        else "trusted_allow"
+                    )
+                elif tier == 1:
+                    if mode == "enforce":
+                        evid = Evidence(process_tree=[ev])
+                        act = Action(
+                            action_type="terminate",
+                            target_pid=ev.pid,
+                            evidence=evid,
+                        )
+                        action_layer.execute(act)
+                        outcome = "killed"
+                        toast.show_kill(
+                            name, ev.pid, dec.threat_score, tier,
+                            path=ev.image_path,
+                        )
+                    else:
+                        outcome = "would_kill"
+                        print(
+                            f"[TRIDENT] {_ts()} [{mode}] would kill "
+                            f"{name} pid={ev.pid} conf={dec.confidence:.3f}"
+                        )
+                elif tier == 2:
+                    cascade.record_cycle(dec, ev)
+                    outcome = "monitored"
+                else:
+                    if cascade.should_escalate(dec, ev):
+                        if mode == "dry-run":
+                            outcome = "would_toast"
+                            print(
+                                f"[TRIDENT] {_ts()} [dry-run] would escalate "
+                                f"{name} pid={ev.pid} score={dec.threat_score:.1f}"
+                            )
+                        else:
+                            toast.show_escalation(
+                                name, ev.pid, dec.threat_score, dec.confidence,
+                                path=ev.image_path,
+                            )
+                            cascade.record_user_response(ev.pid, "ignore")
+                            outcome = "toast"
+                    elif cascade.is_suppressed(ev.pid):
+                        outcome = "suppressed"
+                        if ev.pid not in suppression_announced:
+                            suppression_announced.add(ev.pid)
+                            if mode != "dry-run":
+                                toast.show_suppressed(
+                                    name, ev.pid, cascade.suppression_after
+                                )
+                    else:
+                        outcome = "silent_allow"
+
+                audit.write({
+                    "pid": ev.pid,
+                    "name": name,
+                    "path": ev.image_path,
+                    "action": str(dec.action),
+                    "trust": str(dec.trust_level),
+                    "conf": round(float(dec.confidence), 4),
+                    "threat_score": round(float(dec.threat_score), 3),
+                    "tier": tier,
+                    "outcome": outcome,
+                    "trusted_path": is_trusted or is_runtime_trusted,
+                    "mode": mode,
+                })
+    except KeyboardInterrupt:
+        print("\n[TRIDENT] Shutting down.")
+    finally:
+        telemetry.stop()
+        audit.close()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

trident/_daemon.py

@@ -0,0 +1,89 @@
+"""Background daemon entry point."""
+from __future__ import annotations
+
+import logging
+import os
+import sys
+import time
+from pathlib import Path
+
+from .runtime import (
+    DAEMON_LOG,
+    clear_pid,
+    clear_stop_signal,
+    ensure_runtime_dir,
+    stop_requested,
+    write_pid,
+)
+
+
+def _setup_file_logging() -> None:
+    ensure_runtime_dir()
+    try:
+        if DAEMON_LOG.exists() and DAEMON_LOG.stat().st_size > 5_000_000:
+            backup = DAEMON_LOG.with_suffix(".log.1")
+            if backup.exists():
+                backup.unlink()
+            DAEMON_LOG.rename(backup)
+    except OSError:
+        pass
+
+    log_file = open(DAEMON_LOG, "a", encoding="utf-8", buffering=1)
+    sys.stdout = log_file
+    sys.stderr = log_file
+
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s [%(levelname)s] %(message)s",
+        stream=log_file,
+    )
+
+
+def main() -> int:
+    _setup_file_logging()
+    clear_stop_signal()
+    write_pid(os.getpid())
+
+    print(f"[TRIDENT daemon] starting pid={os.getpid()}")
+
+    try:
+        from . import models as models_mod
+        if not models_mod.is_present():
+            print(f"[TRIDENT daemon] model not found in {models_mod.model_dir()}")
+            print("[TRIDENT daemon] run `trident models fetch` and try again")
+            clear_pid()
+            return 1
+        print(f"[TRIDENT daemon] model present in {models_mod.model_dir()}")
+    except Exception as e:
+        print(f"[TRIDENT daemon] model check failed: {e}")
+        clear_pid()
+        return 1
+
+    from . import __main__ as trident_main
+
+    import time as _time
+    _original_sleep = _time.sleep
+
+    def _interruptible_sleep(seconds: float) -> None:
+        end = _time.monotonic() + seconds
+        while _time.monotonic() < end:
+            if stop_requested():
+                print("[TRIDENT daemon] stop signal received")
+                raise KeyboardInterrupt
+            _original_sleep(0.1)
+
+    trident_main.time.sleep = _interruptible_sleep
+
+    try:
+        return trident_main.main()
+    except KeyboardInterrupt:
+        print("[TRIDENT daemon] interrupted, shutting down")
+        return 0
+    finally:
+        clear_pid()
+        clear_stop_signal()
+        print("[TRIDENT daemon] exited")
+
+
+if __name__ == "__main__":
+    sys.exit(main())

trident/action.py

@@ -0,0 +1,213 @@
+"""Layer 4 - Kill sequence and forensic uninstaller.
+
+Kill tree uses psutil + TerminateProcess directly -- no subprocess
+calls, so nothing flashes on screen when the daemon runs under
+pythonw.exe. PowerShell is only invoked for the rarely-run forensic
+lookups (find_matching_services, find_autostart_entries), and those
+go through _run_hidden.
+"""
+from __future__ import annotations
+
+import subprocess
+import sys
+import time
+from datetime import datetime
+from pathlib import Path
+
+from .contracts import Action, Evidence, ProcessEvent
+
+
+_IS_WINDOWS = sys.platform == "win32"
+_NO_WINDOW_FLAGS = 0x08000000 if _IS_WINDOWS else 0
+
+
+def _startup_info() -> subprocess.STARTUPINFO | None:
+    if not _IS_WINDOWS:
+        return None
+    si = subprocess.STARTUPINFO()
+    si.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+    si.wShowWindow = subprocess.SW_HIDE
+    return si
+
+
+def _run_hidden(cmd, **kwargs) -> subprocess.CompletedProcess:
+    if _IS_WINDOWS:
+        kwargs.setdefault("startupinfo", _startup_info())
+        kwargs.setdefault("creationflags", _NO_WINDOW_FLAGS)
+    return subprocess.run(cmd, **kwargs)
+
+
+def _run_ps(cmd: str, timeout: int = 15) -> tuple[int, str]:
+    """Run a PowerShell command with no console window.
+
+    Only used for forensic lookups that are not on the kill path.
+    """
+    try:
+        r = _run_hidden(
+            ["powershell", "-NoProfile", "-NonInteractive", "-Command", cmd],
+            capture_output=True, text=True, timeout=timeout,
+        )
+        return r.returncode, (r.stdout or "") + (r.stderr or "")
+    except subprocess.TimeoutExpired:
+        return -1, "timeout"
+    except Exception as e:
+        return -1, str(e)
+
+
+class ActionLayer:
+    """Kills process trees and generates forensic cleanup scripts."""
+
+    def __init__(self, ps1_output_dir: Path, safety_whitelist: list[str]) -> None:
+        self.ps1_output_dir = Path(ps1_output_dir)
+        self.ps1_output_dir.mkdir(parents=True, exist_ok=True)
+        self.safety_whitelist = [p.lower() for p in safety_whitelist]
+
+    def _is_whitelisted(self, path: str | None) -> bool:
+        if not path:
+            return True
+        low = path.lower()
+        return any(low.startswith(w) for w in self.safety_whitelist)
+
+    def kill_tree(self, root_pid: int) -> bool:
+        """Terminate a PID and all its descendants. Pure-Python.
+
+        No subprocess calls, so nothing can flash on screen. Uses
+        psutil to walk the tree and psutil.Process.kill() (which on
+        Windows maps to TerminateProcess) per node.
+
+        Falls back to `taskkill /T /F` via _run_hidden only if psutil
+        raises AccessDenied on a protected child.
+        """
+        import psutil
+
+        # Collect the tree first. If the root is already gone, we're done.
+        try:
+            root = psutil.Process(root_pid)
+        except psutil.NoSuchProcess:
+            return True
+
+        try:
+            descendants = root.children(recursive=True)
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            descendants = []
+
+        # Kill children before parents so nothing gets re-parented.
+        denied_any = False
+        for child in descendants:
+            try:
+                child.kill()
+            except psutil.NoSuchProcess:
+                continue
+            except psutil.AccessDenied:
+                denied_any = True
+            except Exception:
+                denied_any = True
+
+        try:
+            root.kill()
+        except psutil.NoSuchProcess:
+            pass
+        except psutil.AccessDenied:
+            denied_any = True
+        except Exception:
+            denied_any = True
+
+        # If any node refused psutil.kill (protected or elevated), fall
+        # back to taskkill /T /F for the whole tree. Wrapped with the
+        # hidden-window flags so it doesn't flash.
+        if denied_any:
+            _run_hidden(
+                ["taskkill", "/PID", str(root_pid), "/T", "/F"],
+                capture_output=True, text=True,
+            )
+
+        # Give Windows a moment to reap the processes, then verify.
+        time.sleep(0.2)
+        return not psutil.pid_exists(root_pid)
+
+    def find_matching_services(self, image_path: str) -> list[str]:
+        """List Windows services whose binary path matches image_path."""
+        if not image_path:
+            return []
+        name = Path(image_path).name
+        _rc, out = _run_ps(
+            f"Get-CimInstance Win32_Service | Where-Object "
+            f"{{$_.PathName -like '*{name}*'}} | "
+            f"Select-Object -ExpandProperty Name"
+        )
+        return [s.strip() for s in out.splitlines() if s.strip()]
+
+    def find_autostart_entries(self, image_path: str) -> dict:
+        """Return scheduled tasks and autostart entries for this binary."""
+        if not image_path:
+            return {"run_keys": [], "tasks": [], "startup": []}
+        name = Path(image_path).name
+        _rc, out = _run_ps(
+            f"schtasks /Query /FO CSV /NH | Select-String '{name}' | "
+            f"ForEach-Object {{ ($_ -split ',')[0].Trim('\"') }}"
+        )
+        tasks = [t.strip() for t in out.splitlines() if t.strip()]
+        return {"run_keys": [], "tasks": tasks, "startup": []}
+
+    def generate_cleanup_script(
+        self, evidence: Evidence, ps1_name: str | None = None
+    ) -> Path:
+        """Write a reviewable .ps1 that removes the artefact."""
+        if ps1_name is None:
+            ts = datetime.now().strftime("%Y%m%d-%H%M%S")
+            ps1_name = f"trident-cleanup-{ts}.ps1"
+        out = self.ps1_output_dir / ps1_name
+
+        root = evidence.process_tree[0] if evidence.process_tree else None
+        pid = root.pid if root else 0
+        name = Path(root.image_path).name if root and root.image_path else "unknown"
+        path = root.image_path if root else ""
+
+        lines = [
+            "# TRIDENT Cleanup Script - review before running",
+            f"# Generated: {datetime.now().isoformat()}",
+            f"# Target: {name} (PID {pid})",
+            "",
+            "$ErrorActionPreference = 'Stop'",
+            "",
+            f'Write-Host "[TRIDENT] Stopping PID {pid}..."',
+            f"Stop-Process -Id {pid} -Force -ErrorAction SilentlyContinue",
+            "Start-Sleep -Milliseconds 500",
+            "",
+        ]
+
+        if path and not self._is_whitelisted(path):
+            lines += [
+                f'Write-Host "[TRIDENT] Removing {path}"',
+                f'if (Test-Path "{path}") {{ '
+                f'Remove-Item -Path "{path}" -Force -ErrorAction SilentlyContinue }}',
+                "",
+            ]
+
+        lines += ['Write-Host "[TRIDENT] Cleanup complete."', ""]
+
+        out.write_text("\n".join(lines), encoding="utf-8")
+        return out
+
+    def execute(self, action: Action) -> Action:
+        """Execute a terminate Action. Returns the same Action, mutated."""
+        try:
+            root_pid = action.target_pid
+            root = (
+                action.evidence.process_tree[0]
+                if action.evidence.process_tree
+                else None
+            )
+            path = root.image_path if root else None
+
+            if path and not self._is_whitelisted(path):
+                ps1 = self.generate_cleanup_script(action.evidence)
+                action.generated_ps1_path = ps1
+
+            ok = self.kill_tree(root_pid)
+            action.executed = ok
+            if not ok:
+                action.error = "kill_tree returned False"
+        except Exception as e:
+            action.error = str(e)
+        return action

trident/audit.py

@@ -0,0 +1,48 @@
+"""Append-only JSONL decision log. One file per UTC day under ./logs/.
+
+Usage from __main__.py:
+    from trident.audit import AuditLog
+    audit = AuditLog("logs")
+    ...
+    audit.write({"pid": pid, "name": name, "action": action,
+                 "trust": trust, "conf": conf, "tier": tier})
+"""
+from __future__ import annotations
+
+import json
+import os
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+class AuditLog:
+    def __init__(self, log_dir: str | os.PathLike = "logs") -> None:
+        self._dir = Path(log_dir)
+        self._dir.mkdir(parents=True, exist_ok=True)
+        self._fh = None
+        self._current_date: str | None = None
+
+    def _roll(self) -> None:
+        today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+        if today == self._current_date and self._fh is not None:
+            return
+        if self._fh is not None:
+            self._fh.close()
+        path = self._dir / f"decisions-{today}.jsonl"
+        self._fh = open(path, "a", encoding="utf-8", newline="\n")
+        self._current_date = today
+
+    def write(self, record: dict[str, Any]) -> None:
+        self._roll()
+        record.setdefault(
+            "ts", datetime.now(timezone.utc).isoformat(timespec="milliseconds")
+        )
+        self._fh.write(json.dumps(record, ensure_ascii=False, default=str))
+        self._fh.write("\n")
+        self._fh.flush()
+
+    def close(self) -> None:
+        if self._fh is not None:
+            self._fh.close()
+            self._fh = None