Keep a Windows manager tied to the firewall that runs it

On Windows the console sends Ctrl+C to both processes. The firewall
exited at once with 0xC000013A, handing the prompt back while a .cmd
shim's cmd.exe still asked "Terminate batch job (Y/N)?". It now ignores
Ctrl+C and Ctrl+Break while the manager runs and exits with its code.

A killed firewall also left the manager and its children running. The
firewall now joins a kill-on-close job before spawning, so whatever is
left dies with it.

An argument with a line break, which Rust refuses to pass to a batch
file, now says so instead of "batch file arguments are invalid".

core/Cargo.toml

@@ -118,7 +118,7 @@ schannel = "0.1.29"
 tokio = { version = "1.53.1", features = ["net"] }
 tracing-appender = "0.2.5"
 tray-icon = { version = "0.26.1", default-features = false }
-windows = { version = "0.62", features = ["Win32_Foundation", "Win32_Security", "Win32_Security_Authorization", "Win32_Security_Cryptography", "Win32_System_Com", "Win32_System_Environment", "Win32_System_Threading", "Win32_UI_Shell", "Win32_UI_WindowsAndMessaging"] }
+windows = { version = "0.62", features = ["Win32_Foundation", "Win32_Security", "Win32_Security_Authorization", "Win32_Security_Cryptography", "Win32_System_Com", "Win32_System_Console", "Win32_System_Environment", "Win32_System_JobObjects", "Win32_System_Threading", "Win32_UI_Shell", "Win32_UI_WindowsAndMessaging"] }
 windows-registry = "0.6.1"
 windows-service = "0.8.0"
 

core/src/aliasing/mod.rs

@@ -1,5 +1,7 @@
 pub mod forward;
 pub mod managers;
+#[cfg(windows)]
+mod windows;
 
 pub use forward::spawn;
 pub use managers::*;
@@ -34,7 +36,8 @@ impl Invocation {
 
 pub fn run(port: u16, invocation: &Invocation, dir: Option<&Path>) -> std::io::Result<i32> {
     let proxy = crate::local_url(port, "");
-    let mut command = Command::new(resolve(&invocation.program)?);
+    let program = resolve(&invocation.program)?;
+    let mut command = Command::new(&program);
     command.args(invocation.arguments(&proxy));
     if let Some(dir) = dir {
         command.current_dir(dir);
@@ -42,7 +45,12 @@ pub fn run(port: u16, invocation: &Invocation, dir: Option<&Path>) -> std::io::R
     for (key, value) in managers::variables(&proxy) {
         command.env(key, value);
     }
-    Ok(command.status()?.code().unwrap_or(1))
+    #[cfg(windows)]
+    windows::prepare();
+    let status = command.status();
+    #[cfg(windows)]
+    let status = status.map_err(|error| windows::explain(error, &program));
+    Ok(status?.code().unwrap_or(1))
 }
 
 // Command::new only finds .exe on Windows; npm, pnpm and gem are .cmd shims found via PATHEXT.

core/src/aliasing/windows.rs

@@ -0,0 +1,64 @@
+use std::io::{Error, ErrorKind};
+use std::path::Path;
+use std::sync::Once;
+use tracing::debug;
+use windows::core::{BOOL, PCWSTR};
+use windows::Win32::System::Console::{SetConsoleCtrlHandler, CTRL_BREAK_EVENT, CTRL_C_EVENT};
+use windows::Win32::System::JobObjects::{
+    AssignProcessToJobObject, CreateJobObjectW, JobObjectExtendedLimitInformation,
+    SetInformationJobObject, JOBOBJECT_EXTENDED_LIMIT_INFORMATION,
+    JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE,
+};
+use windows::Win32::System::Threading::GetCurrentProcess;
+
+/// Called before spawning, so the manager behaves as it would run from the shell directly.
+/// Once per process: a caller may run several managers.
+pub fn prepare() {
+    static PREPARED: Once = Once::new();
+    PREPARED.call_once(|| {
+        // The console sends Ctrl+C to the manager too. Exiting first would hand the prompt back
+        // while a .cmd shim still asks "Terminate batch job (Y/N)?", so wait for its exit instead.
+        // A handler, unlike ignoring the signal outright, is not inherited by the manager.
+        let _ = unsafe { SetConsoleCtrlHandler(Some(ignore_interrupt), true) };
+        if let Err(error) = kill_children_on_exit() {
+            debug!(%error, "the manager may outlive the firewall");
+        }
+    });
+}
+
+unsafe extern "system" fn ignore_interrupt(event: u32) -> BOOL {
+    (event == CTRL_C_EVENT || event == CTRL_BREAK_EVENT).into()
+}
+
+/// Joins a job that kills what is left in it once the firewall exits, even if killed itself.
+/// The manager inherits the job when spawned, as do its own children.
+fn kill_children_on_exit() -> windows::core::Result<()> {
+    let mut limits = JOBOBJECT_EXTENDED_LIMIT_INFORMATION::default();
+    limits.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;
+    // Never closed: the handle closing as the firewall exits is what kills the rest.
+    let job = unsafe { CreateJobObjectW(None, PCWSTR::null())? };
+    unsafe {
+        SetInformationJobObject(
+            job,
+            JobObjectExtendedLimitInformation,
+            (&raw const limits).cast(),
+            size_of_val(&limits) as u32,
+        )?
+    };
+    unsafe { AssignProcessToJobObject(job, GetCurrentProcess()) }
+}
+
+/// Rust refuses to pass a line break to a batch file, where it would cut the command short.
+pub fn explain(error: Error, program: &Path) -> Error {
+    let batch = program
+        .extension()
+        .is_some_and(|ext| ext.eq_ignore_ascii_case("cmd") || ext.eq_ignore_ascii_case("bat"));
+    if !batch || error.kind() != ErrorKind::InvalidInput {
+        return error;
+    }
+    let name = program.file_name().unwrap_or(program.as_os_str()).to_string_lossy();
+    Error::new(
+        ErrorKind::InvalidInput,
+        format!("{name} is a batch file, which cannot be passed an argument with a line break"),
+    )
+}

core/src/blocks.rs

@@ -0,0 +1,36 @@
+use crate::policies::Package;
+use serde::Serialize;
+use std::sync::Mutex;
+
+/// Bounded, so blocks pile up harmlessly while nothing collects them.
+const KEPT: usize = 50;
+
+static RECENT: Mutex<Vec<BlockedPackage>> = Mutex::new(Vec::new());
+
+#[derive(Serialize)]
+pub struct BlockedPackage {
+    pub eco: &'static str,
+    pub name: String,
+    pub version: Option<String>,
+    pub filter: &'static str,
+    pub reason: String,
+}
+
+pub fn record(eco: &'static str, pkg: &Package, filter: &'static str, reason: &str) {
+    let mut recent = RECENT.lock().unwrap_or_else(|e| e.into_inner());
+    if recent.len() == KEPT {
+        recent.remove(0);
+    }
+    recent.push(BlockedPackage {
+        eco,
+        name: pkg.name.clone(),
+        version: pkg.version.clone(),
+        filter,
+        reason: reason.to_owned(),
+    });
+}
+
+/// Hands each block over once.
+pub fn take() -> Vec<BlockedPackage> {
+    std::mem::take(&mut *RECENT.lock().unwrap_or_else(|e| e.into_inner()))
+}

core/src/config/mod.rs

@@ -1,4 +1,4 @@
-use crate::policies::registries::BUILT_IN;
+use crate::policies::registries::{Registry, BUILT_IN};
 use directories::ProjectDirs;
 use serde::Deserialize;
 use serde_json::{Map, Value};
@@ -20,8 +20,9 @@ pub struct FirewallConfig {
     /// Packages never screened, by ecosystem: `{"npm": [{"name": "left-pad"}]}`.
     pub allow: HashMap<String, Vec<AllowedPackage>>,
     pub telemetry: bool,
-    /// Mirrors laid out like a built-in registry, by its name: `{"npm": ["https://npm.example.com/"]}`.
-    pub registries: HashMap<String, Vec<String>>,
+    /// Not describable in the file yet, so this is always the built-in table.
+    #[serde(skip)]
+    pub registries: Vec<&'static Registry>,
 }
 
 #[derive(Debug, Deserialize)]
@@ -47,11 +48,11 @@ impl Default for FirewallConfig {
         FirewallConfig {
             port: DEFAULT_PORT,
             fail_open: true,
-            min_age_hours: 0,
+            min_age_hours: 24,
             denylist: DenylistSource::default(),
             allow: HashMap::new(),
             telemetry: true,
-            registries: HashMap::new(),
+            registries: BUILT_IN.to_vec(),
         }
     }
 }
@@ -86,8 +87,7 @@ impl FirewallConfig {
             };
             let invalid = |e| Error::new(ErrorKind::InvalidData, format!("{}: {e}", path.display()));
             let layer: Value = serde_json::from_str(&text).map_err(invalid)?;
-            let config = FirewallConfig::deserialize(&layer).map_err(invalid)?;
-            check(&config).map_err(|e| Error::new(ErrorKind::InvalidData, format!("{}: {e}", path.display())))?;
+            FirewallConfig::deserialize(&layer).map_err(invalid)?;
             let Value::Object(layer) = layer else {
                 unreachable!("a config parses only from an object");
             };
@@ -99,6 +99,18 @@ impl FirewallConfig {
     pub fn local_url(&self, path: &str) -> String {
         crate::local_url(self.port, path)
     }
+
+    /// Without building a `Firewall`, which needs a runtime.
+    pub fn hosts(&self) -> Vec<&'static str> {
+        let mut hosts: Vec<&'static str> = Vec::new();
+        for registry in &self.registries {
+            let host = registry.host();
+            if !hosts.contains(&host) {
+                hosts.push(host);
+            }
+        }
+        hosts
+    }
 }
 
 pub fn path() -> Option<PathBuf> {
@@ -117,13 +129,3 @@ fn merge(base: &mut Map<String, Value>, top: Map<String, Value>) {
         }
     }
 }
-
-/// What serde's types cannot say.
-fn check(config: &FirewallConfig) -> Result<(), String> {
-    for name in config.registries.keys() {
-        if !BUILT_IN.iter().any(|r| r.name() == name) {
-            return Err(format!("no built-in registry is named {name}"));
-        }
-    }
-    Ok(())
-}

core/src/firewall.rs

@@ -9,7 +9,6 @@ use std::collections::HashMap;
 
 pub struct Firewall {
     pub config: FirewallConfig,
-    registries: Vec<&'static Registry>,
     patterns: HashMap<&'static str, Vec<Regex>>,
     filters: Vec<Box<dyn Filter>>,
 }
@@ -22,19 +21,18 @@ impl Default for Firewall {
 
 impl Firewall {
     pub fn new(config: FirewallConfig) -> Self {
-        let registries = with_mirrors(&config.registries);
         let mut patterns = HashMap::new();
-        for registry in &registries {
+        for registry in &config.registries {
             let compiled = registry.patterns.iter().map(|p| Regex::new(p.re).expect(p.re));
             patterns.insert(registry.prefix, compiled.collect());
         }
-        let ecosystems = registries.iter().map(|r| r.osv_name);
+        let ecosystems = config.registries.iter().map(|r| r.osv_name);
         let denylist = Denylist::new(config.denylist.clone(), ecosystems);
         let mut filters: Vec<Box<dyn Filter>> = vec![Box::new(denylist), Box::new(Osv)];
         if config.min_age_hours > 0 {
             filters.push(Box::new(Age::new(config.min_age_hours)));
         }
-        Firewall { config, registries, patterns, filters }
+        Firewall { config, patterns, filters }
     }
 
     pub fn match_on<'a>(
@@ -42,27 +40,20 @@ impl Firewall {
         url: &'a str,
         key: fn(&Registry) -> &'static str,
     ) -> Option<(&'static Registry, &'a str)> {
-        self.registries.iter().find_map(|r| url.strip_prefix(key(r)).map(|rest| (*r, rest)))
+        self.config.registries.iter().find_map(|r| url.strip_prefix(key(r)).map(|rest| (*r, rest)))
     }
 
     pub fn hosts(&self) -> Vec<&'static str> {
-        let mut hosts: Vec<&'static str> = Vec::new();
-        for registry in &self.registries {
-            let host = registry.host();
-            if !hosts.contains(&host) {
-                hosts.push(host);
-            }
-        }
-        hosts
+        self.config.hosts()
     }
 
     pub fn is_https_url(&self, url: &str) -> bool {
         let host = host_of(url);
-        self.registries.iter().any(|r| r.upstream.starts_with("https://") && r.host() == host)
+        self.config.registries.iter().any(|r| r.upstream.starts_with("https://") && r.host() == host)
     }
 
     pub fn is_index_url(&self, url: &str) -> bool {
-        self.registries.iter().any(|r| r.index && r.host() == host_of(url))
+        self.config.registries.iter().any(|r| r.index && r.host() == host_of(url))
     }
 
     pub fn resolve(&self, registry: &'static Registry, rest: &str) -> Resolved {
@@ -73,15 +64,3 @@ impl Firewall {
         &self.filters
     }
 }
-
-/// The built-ins, then a copy of one per mirror. Leaked, as a `Registry` is `'static` everywhere.
-fn with_mirrors(mirrors: &HashMap<String, Vec<String>>) -> Vec<&'static Registry> {
-    let mut registries = BUILT_IN.to_vec();
-    for built_in in BUILT_IN {
-        for upstream in mirrors.get(built_in.name()).into_iter().flatten() {
-            let upstream = upstream.clone().leak();
-            registries.push(Box::leak(Box::new(Registry { upstream, ..(*built_in).clone() })));
-        }
-    }
-    registries
-}

core/src/lib.rs

@@ -1,4 +1,5 @@
 pub mod aliasing;
+pub mod blocks;
 pub mod config;
 pub mod firewall;
 pub mod http;

core/src/os/macos/mod.rs

@@ -5,7 +5,7 @@ mod uninstall;
 pub use uninstall::uninstall;
 
 use crate::config::FirewallConfig;
-use crate::{mitm, telemetry};
+use crate::{blocks, mitm, telemetry};
 use crate::Firewall;
 use rama::bytes::Bytes;
 use rama::error::BoxError;
@@ -58,6 +58,7 @@ impl TransparentProxyHandler for Handler {
         let message = String::from_utf8_lossy(&message).into_owned();
         Some(Bytes::from(match message.as_str() {
             "ca" => self.ca.pem.clone(),
+            "blocks" => serde_json::to_string(&blocks::take()).expect("blocks serialize"),
             other => format!("error: unknown message {other}"),
         }))
     }

core/src/policies/mod.rs

@@ -69,7 +69,8 @@ pub async fn screen(url: &str, firewall: &Firewall) -> Option<String> {
     };
     info!(eco = registry.eco, pkg = %pkg.label(), %url, "screening");
     match consult(firewall, registry, &pkg).await {
-        Some((_, Verdict::Deny(reason))) => {
+        Some((filter, Verdict::Deny(reason))) => {
+            crate::blocks::record(registry.eco, &pkg, filter, &reason);
             Some(format!("{} {reason}", pkg.label()))
         }
         Some((filter, Verdict::Unknown(e))) if !firewall.config.fail_open => {

core/src/policies/registries/mod.rs

@@ -36,7 +36,7 @@ pub struct Pattern {
 }
 
 /// Requests to the local server match on `prefix`; intercepted URLs match on `upstream`.
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct Registry {
     pub prefix: &'static str,
     pub eco: &'static str,
@@ -52,7 +52,7 @@ pub struct Registry {
 }
 
 /// A URL to fetch and a JSON pointer to the timestamp in its reply.
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct Published {
     pub url: &'static str,
     pub pointer: &'static str,
@@ -63,11 +63,6 @@ impl Registry {
     pub fn host(&self) -> &'static str {
         host_of(self.upstream)
     }
-
-    /// What the config file calls it.
-    pub fn name(&self) -> &'static str {
-        self.prefix.trim_matches('/')
-    }
 }
 
 /// The host of an https:// URL, with the path dropped.

core/tests/config.rs

@@ -38,21 +38,6 @@ fn a_later_file_wins_and_allow_lists_add_up() {
     assert_eq!(names, ["a", "b"]);
 }
 
-#[tokio::test]
-async fn a_mirror_is_screened_like_the_registry_it_copies() {
-    let config = r#"{"registries": {"npm": ["https://npm.example.com/"]}}"#;
-    let firewall = Firewall::new(serde_json::from_str(config).expect("parses"));
-    assert!(firewall.hosts().contains(&"npm.example.com"));
-    let url = "https://npm.example.com/left-pad/-/left-pad-1.3.0.tgz";
-    let (registry, rest) = firewall.match_on(url, |r| r.upstream).expect("the mirror");
-    assert_eq!(firewall.resolve(registry, rest).pkg.map(|p| p.label()), Some("[email protected]".into()));
-    let unknown = std::env::temp_dir().join(format!("firewall-mirror-{}.json", std::process::id()));
-    std::fs::write(&unknown, r#"{"registries": {"nmp": ["https://npm.example.com/"]}}"#).expect("write");
-    let loaded = FirewallConfig::load_from(std::slice::from_ref(&unknown));
-    std::fs::remove_file(&unknown).ok();
-    assert!(loaded.is_err());
-}
-
 #[tokio::test]
 async fn an_allowed_version_skips_the_filters() {
     // An unreachable denylist would otherwise leave the package unchecked.

docs/platforms.md

@@ -1,66 +0,0 @@
-# Platforms
-
-## Requirements
-
-| | Command prefix | Machine-wide |
-|---|---|---|
-| macOS | 13+, Apple silicon or Intel | Apple silicon, or an Intel Mac with a T2 chip |
-| Windows | 10 or 11, x86-64 | A TPM 2.0, and an admin to install |
-| Linux | glibc, x86-64 or arm64 | Not supported |
-
-There are no musl, 32-bit or Windows on Arm builds.
-
-`cargo install strix-firewall` installs only `firewall`. Add `--features machine-wide` for the
-machine-wide binaries, which otherwise come with the macOS app and the Windows MSI.
-
-## What is screened
-
-npm, pnpm, bun, pip, pip3, pipenv, pdm, uv, cargo, go and gem, downloading from:
-
-| Ecosystem | Hosts |
-|---|---|
-| npm | registry.npmjs.org |
-| PyPI | pypi.org, files.pythonhosted.org |
-| crates.io | index.crates.io, static.crates.io, crates.io |
-| RubyGems | rubygems.org |
-| Go | proxy.golang.org |
-
-Machine-wide screening also covers mirrors listed in the config file, under the registry they
-copy (`npm`, `pypi`, `pypi-files`, `cargo/index`, `cargo-dl`, `crates-api`, `gem` or `go`):
-`"registries": {"npm": ["https://npm.example.com/"]}`. A mirror must lay out its paths like that
-registry. `firewall <manager>` still sends managers to the public registries.
-
-## How machine-wide screening works
-
-Traffic to the hosts above is decrypted with a local CA that can only sign for those hosts. Its
-private key never leaves the Secure Enclave (macOS) or the TPM (Windows).
-
-- **macOS:** a system extension, which you approve in System Settings.
-- **Windows:** a service, with a hosts-file entry pointing each registry host at it.
-  - Without a TPM, the service can't start, so the install fails.
-  - Any signed-in user can pause screening from the notification-area icon, until they resume
-    it or the service restarts.
-  - Clients that use an HTTP proxy or their own DNS skip the hosts file and aren't screened.
-    Nor is WSL.
-  - Each client has to trust the CA:
-
-    | Client | Trusts it through |
-    |---|---|
-    | npm, pnpm, bun | `NODE_EXTRA_CA_CERTS`, set to `%ProgramData%\Strix Firewall\ca.pem` |
-    | uv | `UV_SYSTEM_CERTS`, which uses the Windows certificate store |
-    | pip, cargo | The Windows certificate store |
-    | gem, go | Untested |
-
-Tested on Windows 11 and Apple silicon only.
-
-## Changing settings
-
-Machine-wide screening reads an admin-only JSON file when it starts. After editing it, restart
-screening. An invalid file stops screening from starting.
-
-| OS | File | Restart from |
-|---|---|---|
-| macOS | `/Library/Application Support/Firewall/config.json` | The menu bar's Restart |
-| Windows | `%ProgramData%\Strix Firewall\config.json` | The notification-area icon's Restart |
-
-The `firewall` command reads `config.json` from the user's config folder instead.

macos/App/BlockAlerts.swift

@@ -0,0 +1,32 @@
+import AppKit
+
+struct BlockedPackage: Codable, Hashable, Identifiable {
+    let eco: String
+    let name: String
+    let version: String?
+    let filter: String
+    let reason: String
+
+    var id: String { "\(eco)/\(name)@\(version ?? "")" }
+    var label: String { version.map { "\(name) \($0)" } ?? name }
+    /// The denylist and OSV only flag packages known to be malicious; the age check only holds back new ones.
+    var malicious: Bool { filter != "age" }
+}
+
+@MainActor
+enum BlockAlert {
+    static func show(_ package: BlockedPackage) {
+        let alert = NSAlert()
+        alert.addButton(withTitle: "OK")
+        if package.malicious {
+            alert.alertStyle = .critical
+            alert.messageText = "Blocked a malicious package"
+            alert.informativeText = "\(package.label) (\(package.eco)) \(package.reason). Do not install it."
+        } else {
+            alert.messageText = "Held back a new package"
+            alert.informativeText = "\(package.label) (\(package.eco)) \(package.reason)."
+        }
+        NSApp.activate(ignoringOtherApps: true)
+        alert.runModal()
+    }
+}

macos/App/FirewallModel.swift

@@ -51,6 +51,7 @@ final class FirewallModel: NSObject, ObservableObject {
     @Published private(set) var completed = false
     @Published private(set) var removed = false
     @Published private(set) var screening = false
+    @Published private(set) var blocked: [BlockedPackage] = []
 
     private let logger = Logger(subsystem: FirewallIDs.appBundleID, category: "installer")
     private var pendingRequest: (request: OSSystemExtensionRequest, continuation: CheckedContinuation<Void, Error>)?
@@ -72,6 +73,7 @@ final class FirewallModel: NSObject, ObservableObject {
             await refresh()
             if CommandLine.arguments.contains("--install") { await install() }
         }
+        Task { await watchBlocks() }
     }
 
     // MARK: - Flows
@@ -199,6 +201,21 @@ final class FirewallModel: NSObject, ObservableObject {
         if let url = URL(string: pane) { NSWorkspace.shared.open(url) }
     }
 
+    /// The extension cannot message the app, so the app asks it for blocks.
+    private func watchBlocks() async {
+        while true {
+            if screening, let reply = try? await providerMessage("blocks"),
+               let packages = try? JSONDecoder().decode([BlockedPackage].self, from: Data(reply.utf8)) {
+                for package in packages where !blocked.contains(package) {
+                    blocked.append(package)
+                    BlockAlert.show(package)
+                }
+                blocked = Array(blocked.suffix(10))
+            }
+            try? await Task.sleep(nanoseconds: 2_000_000_000)
+        }
+    }
+
     private func stage(_ step: ReferenceWritableKeyPath<FirewallModel, StepStatus>,
                        running: String,
                        work: @MainActor () async throws -> String) async -> Bool {

macos/App/MenuBarView.swift

@@ -22,5 +22,20 @@ struct MenuBarView: View {
             Task { await model.restart() }
         }
         .disabled(model.busy)
+
+        if !model.blocked.isEmpty {
+            Divider()
+            ForEach(model.blocked) { package in
+                if !package.malicious {
+                    Menu("Held back \(package.label) (\(package.eco))") {
+                        Text(package.reason)
+                    }
+                } else {
+                    Menu("Blocked \(package.label) (\(package.eco))") {
+                        Text("Malicious: \(package.reason)")
+                    }
+                }
+            }
+        }
     }
 }