Layer a system config over the user's, and have the extension read only the system one

* Offer a restart once setup finishes

* Describe the restart without naming one variable

core/Cargo.toml

@@ -62,7 +62,7 @@ directories = "6.0.0"
 percent-encoding = "2.3.2"
 rama = { version = "0.4.0", features = ["boring", "http-full", "ring", "rustls"] }
 rand = "0.10.2"
-rcgen = { version = "0.14.10", features = ["x509-parser"] }
+rcgen = "0.14.10"
 regex = "1.13.1"
 semver = "1.0.28"
 serde = { version = "1.0.229", features = ["derive"] }
@@ -76,7 +76,7 @@ which = "8"
 [target.'cfg(target_vendor = "apple")'.dependencies]
 core-foundation = "0.10.1"
 rama = { version = "0.4.0", features = ["net-apple-networkextension"] }
-security-framework = { version = "3.7.0", features = ["macos-12"] }
+security-framework = "3.7.0"
 security-framework-sys = "2.17.0"
 
 [dev-dependencies]

core/src/aliasing/forward.rs

@@ -82,7 +82,7 @@ async fn handle(req: Request, firewall: &Firewall) -> Result<Response, Infallibl
     };
 
     let reason = policies::screen(&url, firewall).await;
-    telemetry::screened(firewall, &url, reason.is_some());
+    telemetry::screened(firewall, &url, reason.as_deref());
     if let Some(reason) = reason {
         warn!(method = %req.method(), %url, %reason, "blocked");
         return Ok(blocked(&reason));

core/src/config/mod.rs

@@ -1,6 +1,7 @@
 use crate::policies::registries::{Registry, BUILT_IN};
 use directories::ProjectDirs;
 use serde::Deserialize;
+use serde_json::{Map, Value};
 use std::collections::HashMap;
 use std::io::{Error, ErrorKind};
 use std::path::PathBuf;
@@ -68,18 +69,31 @@ impl Default for DenylistSource {
 }
 
 impl FirewallConfig {
-    /// A missing file means defaults; a bad one is an error, so the policy is never quietly relaxed.
     pub fn load() -> std::io::Result<Self> {
-        let Some(path) = path() else {
-            return Ok(Self::default());
-        };
-        let text = match std::fs::read_to_string(&path) {
-            Ok(text) => text,
-            Err(e) if e.kind() == ErrorKind::NotFound => return Ok(Self::default()),
-            Err(e) => return Err(Error::new(e.kind(), format!("{}: {e}", path.display()))),
-        };
-        serde_json::from_str(&text)
-            .map_err(|e| Error::new(ErrorKind::InvalidData, format!("{}: {e}", path.display())))
+        let mut paths: Vec<PathBuf> = path().into_iter().collect();
+        paths.extend(crate::os::system_config());
+        Self::load_from(&paths)
+    }
+
+    /// Later files win key by key, but allow lists add up.
+    /// A bad file is an error, so the policy is never quietly relaxed.
+    pub fn load_from(paths: &[PathBuf]) -> std::io::Result<Self> {
+        let mut merged = Map::new();
+        for path in paths {
+            let text = match std::fs::read_to_string(path) {
+                Ok(text) => text,
+                Err(e) if e.kind() == ErrorKind::NotFound => continue,
+                Err(e) => return Err(Error::new(e.kind(), format!("{}: {e}", path.display()))),
+            };
+            let invalid = |e| Error::new(ErrorKind::InvalidData, format!("{}: {e}", path.display()));
+            let layer: Value = serde_json::from_str(&text).map_err(invalid)?;
+            FirewallConfig::deserialize(&layer).map_err(invalid)?;
+            let Value::Object(layer) = layer else {
+                unreachable!("a config parses only from an object");
+            };
+            merge(&mut merged, layer);
+        }
+        Ok(serde_json::from_value(Value::Object(merged)).expect("each layer parsed on its own"))
     }
 
     pub fn local_url(&self, path: &str) -> String {
@@ -103,3 +117,15 @@ pub fn path() -> Option<PathBuf> {
     let dirs = ProjectDirs::from("com", "usestrix", "firewall")?;
     Some(dirs.config_dir().join("config.json"))
 }
+
+fn merge(base: &mut Map<String, Value>, top: Map<String, Value>) {
+    for (key, value) in top {
+        match (base.get_mut(&key), value) {
+            (Some(Value::Object(base)), Value::Object(top)) => merge(base, top),
+            (Some(Value::Array(base)), Value::Array(top)) => base.extend(top),
+            (_, value) => {
+                base.insert(key, value);
+            }
+        }
+    }
+}

core/src/main.rs

@@ -56,6 +56,7 @@ fn options() -> Command {
 }
 
 fn serve() -> ! {
+    telemetry::set_mode("proxy");
     let config = load();
     let port = config.port;
     print_setup(&config);
@@ -83,6 +84,7 @@ fn uninstall() -> ! {
 }
 
 fn run(invocation: Invocation) -> ! {
+    telemetry::set_mode("wrapper");
     let command = &invocation.program;
     let port = match aliasing::spawn(0, load()) {
         Ok(port) => port,

core/src/mitm/ca.rs

@@ -39,8 +39,7 @@ impl CertificateAuthority {
         (held == signer.subject_public_key_info()).then_some(ca)
     }
 
-    /// The first certificate is the CA; any after it are its chain, for clients that read no keychain.
-    pub fn new(pem: String) -> Result<Self, BoxError> {
+    fn new(pem: String) -> Result<Self, BoxError> {
         Ok(Self { crt: X509::from_pem(pem.as_bytes())?, pem })
     }
 }
@@ -62,10 +61,9 @@ pub fn crl(hosts: &[&str], signer: &dyn SigningKey) -> Result<Vec<u8>, BoxError>
 }
 
 pub const COMMON_NAME: &str = "Strix Firewall";
-/// Of a CA an MDM enrolls instead, which must not match `COMMON_NAME`: uninstall deletes those.
-pub const MANAGED_COMMON_NAME: &str = "Strix Firewall Managed";
 
-fn params(hosts: &[&str]) -> CertificateParams {
+/// Also used by the issuer, whose issuer name must match the CA's subject.
+pub fn params(hosts: &[&str]) -> CertificateParams {
     let mut name = DistinguishedName::new();
     name.push(DnType::CommonName, COMMON_NAME);
     name.push(DnType::OrganizationName, "Strix");

core/src/mitm/issuer.rs

@@ -1,15 +1,17 @@
-use super::ca::CaSigner;
+use super::ca::{params, CaSigner};
 use rama::error::BoxError;
 use rama::tls::boring::core::pkey::PKey;
 use rama::tls::boring::core::x509::X509;
 use rama::tls::boring::proxy::cert_issuer::{BoringMitmCertIssuer, MitmIssuedCert};
 use rama::utils::collections::non_empty_vec;
 use rcgen::{CertificateParams, CrlDistributionPoint, DistinguishedName, DnType, Issuer, KeyPair};
+use std::sync::Arc;
 
 /// Leaves name only screened hosts; any other name falls outside the CA's constraint.
 #[derive(Clone)]
 pub struct ConstrainedCertIssuer {
     ca_crt: X509,
+    ca_params: Arc<CertificateParams>,
     signer: CaSigner,
     hosts: Vec<&'static str>,
     crl: Option<String>,
@@ -22,7 +24,8 @@ impl ConstrainedCertIssuer {
         hosts: Vec<&'static str>,
         crl: Option<String>,
     ) -> Self {
-        Self { ca_crt, signer, hosts, crl }
+        let ca_params = Arc::new(params(&hosts));
+        Self { ca_crt, ca_params, signer, hosts, crl }
     }
 }
 
@@ -51,8 +54,7 @@ impl BoringMitmCertIssuer for ConstrainedCertIssuer {
 
         // The TLS server needs the leaf key in memory, so it can't be the platform key.
         let leaf_key = KeyPair::generate()?;
-        let ca_der = self.ca_crt.to_der()?;
-        let issuer = Issuer::from_ca_cert_der(&ca_der.into(), &*self.signer)?;
+        let issuer = Issuer::from_params(&self.ca_params, &*self.signer);
         let crt = X509::from_der(leaf.signed_by(&leaf_key, &issuer)?.der())?;
         let key = PKey::private_key_from_pem(leaf_key.serialize_pem().as_bytes())?;
 

core/src/mitm/mod.rs

@@ -3,7 +3,7 @@ mod issuer;
 mod route;
 mod screen;
 
-pub use ca::{crl, CaSigner, CertificateAuthority, COMMON_NAME, MANAGED_COMMON_NAME};
+pub use ca::{crl, CaSigner, CertificateAuthority, COMMON_NAME};
 
 use crate::Firewall;
 use issuer::ConstrainedCertIssuer;

core/src/mitm/screen.rs

@@ -37,7 +37,7 @@ where
     async fn serve(&self, req: Request) -> Result<Response, Self::Error> {
         if let Some(url) = https_url(&req) {
             let reason = policies::screen(&url, &self.firewall).await;
-            telemetry::screened(&self.firewall, &url, reason.is_some());
+            telemetry::screened(&self.firewall, &url, reason.as_deref());
             if let Some(reason) = reason {
                 warn!(%url, "blocked by firewall: {reason}");
                 return Ok(blocked(&reason));

core/src/os/macos/enclave.rs

@@ -33,17 +33,10 @@ impl EnclaveKey {
             Some(blob) => load(&blob)?,
             None => create()?,
         };
-        Self::new(key)
-    }
-
-    pub fn new(key: SecKey) -> Result<Self, BoxError> {
         let public = key
             .public_key()
             .and_then(|public| public.external_representation())
             .ok_or("secure enclave key has no exportable public half")?;
-        if public.len() != 65 {
-            return Err("the CA key must be P-256".into());
-        }
         Ok(EnclaveKey { key, public: public.to_vec() })
     }
 

core/src/os/macos/install.rs

@@ -1,53 +1,11 @@
-use super::enclave::EnclaveKey;
-use super::{CA_FILE, KEYCHAIN_ACCOUNT, KEYCHAIN_SERVICE, SYSTEM_KEYCHAIN};
-use crate::mitm::{CertificateAuthority, MANAGED_COMMON_NAME};
+use super::{CA_FILE, KEYCHAIN_ACCOUNT, KEYCHAIN_SERVICE};
+use crate::mitm::CertificateAuthority;
 use rama::error::BoxError;
 use rama::net::apple::networkextension::system_keychain;
-use rama::tls::boring::core::x509::X509;
 use rcgen::SigningKey;
-use security_framework::item::{ItemClass, ItemSearchOptions, Limit, Reference, SearchResult};
-use security_framework::os::macos::keychain::SecKeychain;
-use security_framework::policy::SecPolicy;
-use security_framework::trust::SecTrust;
-use security_framework_sys::base::errSecItemNotFound;
 use std::path::Path;
 use tracing::{info, warn};
 
-/// A CA an MDM enrolled over ACME. The MDM trusts its issuer, so the user is never asked to.
-pub fn managed_certificate_authority(
-) -> Result<Option<(EnclaveKey, CertificateAuthority)>, BoxError> {
-    let found = ItemSearchOptions::new()
-        .class(ItemClass::identity())
-        .keychains(&[SecKeychain::open(SYSTEM_KEYCHAIN)?])
-        .load_refs(true)
-        .limit(Limit::All)
-        .search();
-    let results = match found {
-        Ok(results) => results,
-        Err(error) if error.code() == errSecItemNotFound => return Ok(None),
-        Err(error) => return Err(error.into()),
-    };
-    for result in results {
-        let SearchResult::Ref(Reference::Identity(identity)) = result else { continue };
-        let crt = identity.certificate()?;
-        if crt.subject_summary() != MANAGED_COMMON_NAME {
-            continue;
-        }
-        let key = EnclaveKey::new(identity.private_key()?)?;
-        let trust = SecTrust::create_with_certificates(&[crt], &[SecPolicy::create_x509()])?;
-        trust.evaluate_with_error().map_err(|e| format!("the managed CA is not trusted: {e}"))?;
-        let mut pem = String::new();
-        for crt in trust.chain() {
-            pem.push_str(std::str::from_utf8(&X509::from_der(&crt.to_der())?.to_pem()?)?);
-        }
-        let ca = CertificateAuthority::new(pem)?;
-        info!("using the CA enrolled by MDM");
-        export_pem(&ca);
-        return Ok(Some((key, ca)));
-    }
-    Ok(None)
-}
-
 /// Kept in the System keychain so trust survives restarts; replaced if the hosts change.
 pub fn certificate_authority(
     hosts: &[&str],

core/src/os/macos/mod.rs

@@ -23,6 +23,7 @@ use rama::rt::Executor;
 use rama::telemetry::tracing::apple::oslog::{OsLogLayer, Privacy};
 use rama::{Layer, Service};
 use std::convert::Infallible;
+use std::path::PathBuf;
 use std::sync::Arc;
 use tracing_subscriber::layer::SubscriberExt;
 use tracing_subscriber::util::SubscriberInitExt;
@@ -32,7 +33,7 @@ const KEYCHAIN_SERVICE: &str = BUNDLE_ID;
 const KEYCHAIN_ACCOUNT: &str = "ca";
 /// Must match `macos/LaunchAgents/com.usestrix.firewall.env.plist`, which points npm at it.
 const CA_FILE: &str = "/Library/Application Support/Firewall/ca.pem";
-const SYSTEM_KEYCHAIN: &str = "/Library/Keychains/System.keychain";
+const CONFIG_FILE: &str = "/Library/Application Support/Firewall/config.json";
 
 #[derive(Clone)]
 struct Handler {
@@ -98,23 +99,20 @@ impl TransparentProxyHandlerFactory for Factory {
     }
 }
 
+pub fn system_config() -> Option<PathBuf> {
+    Some(CONFIG_FILE.into())
+}
+
 fn handler(exec: Executor) -> Result<Handler, BoxError> {
+    telemetry::set_mode("extension");
     telemetry::heartbeat();
-    let config = FirewallConfig::load().inspect_err(|_| telemetry::error("config"))?;
+    let config = FirewallConfig::load_from(&[CONFIG_FILE.into()]).inspect_err(|_| telemetry::error("config"))?;
     let firewall = Arc::new(Firewall::new(config));
     let hosts = firewall.hosts();
-    let managed = install::managed_certificate_authority().inspect_err(|_| telemetry::error("ca"))?;
-    let (key, ca) = match managed {
-        Some(managed) => managed,
-        None => {
-            let key = enclave::EnclaveKey::load_or_create()
-                .inspect_err(|_| telemetry::error("enclave"))?;
-            let ca = install::certificate_authority(&hosts, &key);
-            (key, ca.inspect_err(|_| telemetry::error("ca"))?)
-        }
-    };
+    let key = enclave::EnclaveKey::load_or_create().inspect_err(|_| telemetry::error("enclave"))?;
     let signer: mitm::CaSigner = Arc::new(key);
-    let ca = Arc::new(ca);
+    let ca = install::certificate_authority(&hosts, &*signer);
+    let ca = Arc::new(ca.inspect_err(|_| telemetry::error("ca"))?);
     let service = mitm::mitm_service(firewall, &ca, signer, None, exec);
     Ok(Handler { ca, hosts, service })
 }

core/src/os/macos/uninstall.rs

@@ -1,5 +1,5 @@
 use super::enclave::EnclaveKey;
-use super::{CA_FILE, KEYCHAIN_ACCOUNT, KEYCHAIN_SERVICE, SYSTEM_KEYCHAIN};
+use super::{CA_FILE, KEYCHAIN_ACCOUNT, KEYCHAIN_SERVICE};
 use crate::mitm::COMMON_NAME;
 use rama::error::BoxError;
 use rama::net::apple::networkextension::system_keychain;
@@ -17,7 +17,7 @@ const ENV_AGENT: &str = "/Library/LaunchAgents/com.usestrix.firewall.env.plist";
 pub fn uninstall() -> Result<(), BoxError> {
     let deleted = ItemSearchOptions::new()
         .class(ItemClass::certificate())
-        .keychains(&[SecKeychain::open(SYSTEM_KEYCHAIN)?])
+        .keychains(&[SecKeychain::open("/Library/Keychains/System.keychain")?])
         .label(COMMON_NAME)
         .limit(Limit::All)
         .delete();

core/src/os/mod.rs

@@ -2,10 +2,15 @@
 pub mod macos;
 
 #[cfg(target_os = "macos")]
-pub use macos::uninstall;
+pub use macos::{system_config, uninstall};
 
 /// Elsewhere nothing is installed system-wide.
 #[cfg(not(target_os = "macos"))]
 pub fn uninstall() -> Result<(), rama::error::BoxError> {
     Ok(())
 }
+
+#[cfg(not(target_os = "macos"))]
+pub fn system_config() -> Option<std::path::PathBuf> {
+    None
+}

core/src/policies/mod.rs

@@ -72,6 +72,9 @@ pub async fn screen(url: &str, firewall: &Firewall) -> Option<String> {
         Some((_, Verdict::Deny(reason))) => {
             Some(format!("{} {reason}", pkg.label()))
         }
+        Some((filter, Verdict::Unknown(e))) if !firewall.config.fail_open => {
+            Some(format!("{} could not be checked by {filter} ({e})", pkg.label()))
+        }
         _ => None,
     }
 }

core/src/proxy/mod.rs

@@ -1,6 +1,6 @@
 use crate::http::{blocked, reply, text};
 use crate::policies::{self, Check, Decision};
-use crate::{Firewall, FirewallConfig};
+use crate::{telemetry, Firewall, FirewallConfig};
 use rama::http::body::util::BodyExt;
 use rama::http::client::EasyHttpWebClient;
 use rama::http::header::CONTENT_TYPE;
@@ -19,6 +19,7 @@ pub fn serve(config: FirewallConfig) -> std::io::Result<()> {
     bound.set_nonblocking(true)?;
     crate::runtime()?.block_on(async move {
         let firewall = Arc::new(Firewall::new(config));
+        telemetry::heartbeat();
         let exec = Executor::default();
         let listener = TcpListener::try_from_std_tcp_listener(bound, exec.clone())?;
         let server = HttpServer::auto(exec).service(service_fn(move |req: Request| {
@@ -44,6 +45,7 @@ async fn screen(target: String, firewall: &Firewall) -> Response {
         }
         Decision::Block { eco, pkg, filter, reason } => {
             let reason = format!("{} {reason}", pkg.label());
+            telemetry::screened_package(eco, &pkg, Some(&reason));
             warn!(%eco, %filter, "blocked by firewall: {reason}");
             blocked(&reason)
         }
@@ -51,9 +53,11 @@ async fn screen(target: String, firewall: &Firewall) -> Response {
             match &check {
                 Check::NoPackage => {}
                 Check::Allowed(pkg) => {
+                    telemetry::screened_package(target.eco, pkg, None);
                     info!(eco = %target.eco, pkg = %pkg.label(), "cleared by every filter")
                 }
                 Check::Unverified { pkg, filter, error } => {
+                    telemetry::screened_package(target.eco, pkg, None);
                     info!(pkg = %pkg.label(), %filter, %error, "filter could not check, allowing")
                 }
             }

core/src/telemetry.rs

@@ -1,10 +1,11 @@
+use crate::policies::Package;
 use crate::{Firewall, FirewallConfig};
 use rama::http::client::EasyHttpWebClient;
 use rama::http::header::CONTENT_TYPE;
 use rama::http::service::client::HttpClientExt;
 use rama::rt::blocking::Runtime;
 use serde_json::{json, Value};
-use std::sync::{LazyLock, Mutex};
+use std::sync::{LazyLock, Mutex, OnceLock};
 use std::time::Duration;
 use time::format_description::well_known::Rfc3339;
 use time::OffsetDateTime;
@@ -29,29 +30,40 @@ static TELEMETRY: LazyLock<Option<Telemetry>> = LazyLock::new(|| {
     })
 });
 
+/// How the firewall is running: "extension", "wrapper" or "proxy".
+static MODE: OnceLock<&'static str> = OnceLock::new();
+
 struct Telemetry {
     key: &'static str,
     session: String,
     events: Mutex<Vec<Value>>,
 }
 
-pub fn screened(firewall: &Firewall, url: &str, blocked: bool) {
+pub fn screened(firewall: &Firewall, url: &str, reason: Option<&str>) {
     if TELEMETRY.is_none() {
         return;
     }
     let Some((registry, rest)) = firewall.match_on(url, |r| r.upstream) else {
         return;
     };
-    let Some(pkg) = firewall.resolve(registry, rest).pkg else {
-        return;
-    };
-    let mut properties = json!({ "eco": registry.eco, "blocked": blocked });
-    if blocked {
+    if let Some(pkg) = firewall.resolve(registry, rest).pkg {
+        screened_package(registry.eco, &pkg, reason);
+    }
+}
+
+pub fn screened_package(eco: &str, pkg: &Package, reason: Option<&str>) {
+    let mut properties = json!({ "eco": eco, "blocked": reason.is_some() });
+    if let Some(reason) = reason {
         properties["package"] = pkg.label().into();
+        properties["reason"] = reason.into();
     }
     record("package_screened", properties);
 }
 
+pub fn set_mode(mode: &'static str) {
+    MODE.set(mode).ok();
+}
+
 pub fn error(kind: &'static str) {
     record("error", json!({ "kind": kind }));
 }
@@ -81,6 +93,7 @@ pub fn flush() {
 fn record(event: &str, mut properties: Value) {
     let Some(telemetry) = &*TELEMETRY else { return };
     properties["distinct_id"] = telemetry.session.clone().into();
+    properties["mode"] = MODE.get().copied().into();
     properties["os"] = std::env::consts::OS.into();
     properties["arch"] = std::env::consts::ARCH.into();
     properties["$process_person_profile"] = false.into();

core/tests/config.rs

@@ -1,6 +1,6 @@
 use firewall::config::path;
 use firewall::policies::filters::consult;
-use firewall::policies::Package;
+use firewall::policies::{screen, Package};
 use firewall::{Firewall, FirewallConfig};
 
 #[test]
@@ -21,6 +21,23 @@ fn the_config_lives_under_the_config_directory() {
     assert!(path.ends_with("config.json"), "{}", path.display());
 }
 
+#[test]
+fn a_later_file_wins_and_allow_lists_add_up() {
+    let dir = std::env::temp_dir().join(format!("firewall-layers-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).expect("temp dir");
+    let user = dir.join("user.json");
+    let system = dir.join("system.json");
+    std::fs::write(&user, r#"{"min_age_hours": 1, "fail_open": false, "allow": {"npm": [{"name": "a"}]}}"#).expect("write");
+    std::fs::write(&system, r#"{"min_age_hours": 24, "allow": {"npm": [{"name": "b"}]}}"#).expect("write");
+    let missing = dir.join("missing.json");
+    let config = FirewallConfig::load_from(&[user, system, missing]).expect("loads");
+    std::fs::remove_dir_all(&dir).ok();
+    assert_eq!(config.min_age_hours, 24);
+    assert!(!config.fail_open);
+    let names: Vec<&str> = config.allow["npm"].iter().map(|p| p.name.as_str()).collect();
+    assert_eq!(names, ["a", "b"]);
+}
+
 #[tokio::test]
 async fn an_allowed_version_skips_the_filters() {
     // An unreachable denylist would otherwise leave the package unchecked.
@@ -31,3 +48,12 @@ async fn an_allowed_version_skips_the_filters() {
     assert!(consult(&firewall, registry, &pkg("0.20.0")).await.is_none());
     assert!(consult(&firewall, registry, &pkg("0.21.0")).await.is_some());
 }
+
+#[tokio::test]
+async fn failing_closed_blocks_what_could_not_be_checked() {
+    let config = r#"{"fail_open": false, "denylist": {"base": "http://127.0.0.1:1"}}"#;
+    let firewall = Firewall::new(serde_json::from_str(config).expect("parses"));
+    let url = "https://registry.npmjs.org/left-pad/-/left-pad-1.3.0.tgz";
+    let blocked = screen(url, &firewall).await.unwrap_or_default();
+    assert!(blocked.contains("could not be checked"), "{blocked:?}");
+}

macos/App/AppIcon.icon/icon.json

@@ -0,0 +1,24 @@
+{
+  "fill" : {
+    "solid" : "srgb:0.07000,0.07000,0.07000,1.00000"
+  },
+  "groups" : [
+    {
+      "layers" : [
+        {
+          "image-name" : "logo.png",
+          "name" : "logo",
+          "position" : {
+            "scale" : 1.8,
+            "translation-in-points" : [0, 0]
+          }
+        }
+      ]
+    }
+  ],
+  "supported-platforms" : {
+    "squares" : [
+      "macOS"
+    ]
+  }
+}

macos/App/Assets.xcassets/AppIcon.appiconset/Contents.json

@@ -1,68 +0,0 @@
-{
-  "images": [
-    {
-      "idiom": "mac",
-      "size": "16x16",
-      "scale": "1x",
-      "filename": "icon_16.png"
-    },
-    {
-      "idiom": "mac",
-      "size": "16x16",
-      "scale": "2x",
-      "filename": "icon_32.png"
-    },
-    {
-      "idiom": "mac",
-      "size": "32x32",
-      "scale": "1x",
-      "filename": "icon_32.png"
-    },
-    {
-      "idiom": "mac",
-      "size": "32x32",
-      "scale": "2x",
-      "filename": "icon_64.png"
-    },
-    {
-      "idiom": "mac",
-      "size": "128x128",
-      "scale": "1x",
-      "filename": "icon_128.png"
-    },
-    {
-      "idiom": "mac",
-      "size": "128x128",
-      "scale": "2x",
-      "filename": "icon_256.png"
-    },
-    {
-      "idiom": "mac",
-      "size": "256x256",
-      "scale": "1x",
-      "filename": "icon_256.png"
-    },
-    {
-      "idiom": "mac",
-      "size": "256x256",
-      "scale": "2x",
-      "filename": "icon_512.png"
-    },
-    {
-      "idiom": "mac",
-      "size": "512x512",
-      "scale": "1x",
-      "filename": "icon_512.png"
-    },
-    {
-      "idiom": "mac",
-      "size": "512x512",
-      "scale": "2x",
-      "filename": "icon_1024.png"
-    }
-  ],
-  "info": {
-    "author": "xcode",
-    "version": 1
-  }
-}

macos/App/FirewallIDs.swift

@@ -4,5 +4,4 @@ enum FirewallIDs {
     static let appBundleID = "com.usestrix.firewall"
     static let extensionBundleID = "com.usestrix.firewall.extension"
     static let caCommonName = "Strix Firewall"
-    static let managedCaCommonName = "Strix Firewall Managed"
 }

macos/App/FirewallModel.swift

@@ -114,6 +114,22 @@ final class FirewallModel: NSObject, ObservableObject {
 
         completed = true
         log("Setup complete")
+        offerRestart()
+    }
+
+    /// Apps opened before setup, terminals included, only get the environment the env agent sets once reopened.
+    private func offerRestart() {
+        let alert = NSAlert()
+        alert.messageText = "Restart to finish setting up"
+        alert.informativeText = "Apps that were already open, such as terminals, can't install packages until they're reopened. Restarting reopens them all."
+        alert.addButton(withTitle: "Restart")
+        alert.addButton(withTitle: "Later")
+        NSApp.activate(ignoringOtherApps: true)
+        guard alert.runModal() == .alertFirstButtonReturn else { return }
+        let osascript = Process()
+        osascript.executableURL = URL(fileURLWithPath: "/usr/bin/osascript")
+        osascript.arguments = ["-e", "tell application \"loginwindow\" to «event aevtrest»"]
+        try? osascript.run()
     }
 
     /// After the admin gate, every stage runs even if an earlier one fails, so a partial uninstall never strands the rest.

macos/App/TrustStore.swift

@@ -34,11 +34,7 @@ enum TrustStore {
         return certificate
     }
 
-    /// The extension only uses a managed CA after checking that it chains to a root the MDM trusts.
     static func isTrusted(_ certificate: SecCertificate) -> Bool {
-        var name: CFString?
-        if SecCertificateCopyCommonName(certificate, &name) == errSecSuccess,
-           name as String? == FirewallIDs.managedCaCommonName { return true }
         var settings: CFArray?
         return SecTrustSettingsCopyTrustSettings(certificate, .admin, &settings) == errSecSuccess
     }

macos/MDM.md

@@ -1,24 +0,0 @@
-# Deploying with MDM
-
-On a managed Mac the firewall can use a CA your MDM enrolls instead of minting its own, so users
-need no admin rights and see no trust prompt. Each Mac still has its own key in its Secure Enclave;
-your PKI signs its certificate.
-
-Push one device-channel profile with:
-
-1. **Certificate** (`com.apple.security.root`): your root CA.
-2. **ACME Certificate** (`com.apple.security.acme`), macOS 14 or later:
-   - `KeyType` `ECSECPrimeRandom`, `KeySize` `256`, `HardwareBound` `true`, `Attest` `true`
-   - `Subject` `[[["CN", "Strix Firewall Managed"]]]`; the extension finds the identity by this name
-   - `AllowAllAppsAccess` `true`, so the extension can sign with the key
-3. **System Extensions**: allow `com.usestrix.firewall.extension` for the Strix team ID.
-
-Your ACME server must issue the enrolled certificate as a CA, not a leaf:
-
-- basic constraints `CA:TRUE, pathlen:0` and key usage `keyCertSign`
-- critical name constraints permitting only the screened hosts: `registry.npmjs.org`, `pypi.org`,
-  `files.pythonhosted.org`, `index.crates.io`, `static.crates.io`, `crates.io`,
-  `proxy.golang.org`, `rubygems.org`
-
-The extension checks the certificate chains to a trusted root before using it. Install the profile
-before the firewall: without a managed CA the extension mints its own, which needs an admin to trust.