@push.rocks/smartnftables 1.5.0 → 1.7.0

package/rust/src/docker_process_tests.rs

@@ -0,0 +1,29 @@
+use super::*;
+
+#[test]
+fn frontend_subprocess_drains_large_input_and_output_with_a_clean_environment() {
+    let input="bounded-input\n".repeat(12_000);
+    assert_eq!(command("/usr/bin/cat",&[],input.as_bytes(),deadline()).unwrap(),input);
+    let environment=command("/usr/bin/env",&[],&[],deadline()).unwrap();
+    let values:BTreeSet<_>=environment.lines().collect();
+    assert_eq!(values,BTreeSet::from(["PATH=/usr/sbin:/usr/bin:/sbin:/bin","LC_ALL=C"]));
+}
+fn child_failure(kind: &str, source: &str, expected: Error) {
+    let directory=std::env::temp_dir().join(format!("smartnftables-command-{}-{kind}",std::process::id()));
+    std::fs::create_dir(&directory).unwrap();
+    let pidfile=directory.join("pid");
+    let source=format!("import os,pathlib,time;pathlib.Path({:?}).write_text(str(os.getpid()));{source}",pidfile.to_str().unwrap());
+    assert_eq!(command("/usr/bin/python3",&["-c",&source],&[],deadline()),Err(expected));
+    let pid=std::fs::read_to_string(&pidfile).unwrap().parse::<i32>().unwrap();
+    assert_eq!(unsafe{libc::kill(pid,0)},-1);
+    assert_eq!(std::io::Error::last_os_error().raw_os_error(),Some(libc::ESRCH));
+    std::fs::remove_file(pidfile).unwrap();std::fs::remove_dir(directory).unwrap();
+}
+#[test]
+fn frontend_subprocess_output_overflow_stops_and_joins_the_exact_child() {
+    child_failure("output","os.write(1,b'x'*2097153);time.sleep(60)",Error::Protocol);
+}
+#[test]
+fn frontend_subprocess_timeout_stops_and_joins_the_exact_child() {
+    child_failure("timeout","time.sleep(60)",Error::Unavailable);
+}

package/rust/src/docker_tests.rs

@@ -0,0 +1,148 @@
+use super::*;
+use serde_json::json;
+
+fn options() -> Options {Options {owner_id:"dockerfixture".into(),instance_id:"qualification_20260913".into()}}
+fn policy() -> policy::Policy {
+    let prepared:crate::managed::Prepared=serde_json::from_value::<crate::egress::Policy>(crate::egress::tests::host()).unwrap().prepare().unwrap().into();
+    policy::Policy {schema_version:1,revision:1,barrier:owner::Applied {
+        receipt:owner::Receipt {identity:owner::Identity {owner_id:"barrier".into(),instance_id:"qualification_20260913".into(),table_name:"snft_fixture".into(),boot_id:"00000000-0000-4000-8000-000000000000".into(),namespace_device:"4".into(),namespace_inode:"1".into()},table_handle:"1".into(),revision:1,digest:prepared.digest.clone()},prepared}}
+}
+fn text(rules: &[policy::Rule]) -> String {
+    let mut text="*filter\n:INPUT ACCEPT [0:0]\n:FORWARD DROP [0:0]\n:OUTPUT ACCEPT [0:0]\n:DOCKER-USER - [0:0]\n:DOCKER-FORWARD - [0:0]\n-A FORWARD -j DOCKER-USER\n-A FORWARD -j DOCKER-FORWARD\n".to_owned();
+    for rule in rules {text.push_str(&format!("-A DOCKER-USER {}\n",rule.args.join(" ")));}
+    text.push_str("-A DOCKER-USER -m comment --comment \"foreign unrelated rule\" -j RETURN\nCOMMIT\n");text
+}
+fn snapshot(text: &str) -> frontend::Snapshot {frontend::Snapshot::parse("v1.8.11 (nf_tables)".into(),text).unwrap()}
+
+#[test]
+fn docker_compiler_derives_only_scoped_directed_ranges_from_host_barrier() {
+    let prepared=policy().prepare("v1.8.11 (nf_tables)".into()).unwrap();let rules=prepared.rules(&options()).unwrap();
+    assert_eq!(rules.len(),6);
+    assert!(rules.iter().all(|r|r.args.contains(&"--ctorigsrcport".into()) && r.args.contains(&"--ctdir".into()) && !r.args.iter().any(|s|s.contains("RELATED"))));
+    let new_tcp=&rules[0].args;
+    assert!(new_tcp.windows(3).any(|w|w==["--tcp-flags","FIN,SYN,RST,ACK","SYN"]));
+    assert!(rules.iter().all(|r|r.comment.len()<256));
+    assert!(rules.iter().all(|r|r.args.windows(2).any(|w|w[0]=="--ctorigsrc" && !w[1].contains('/'))));
+    assert!(snapshot(&text(&rules)).matches(&options(),&rules).unwrap());
+}
+#[test]
+fn docker_prepare_rejects_router_receipts_bad_hashes_and_unbounded_restore() {
+    let mut value=policy();value.schema_version=2;assert!(value.prepare("v1.8.11 (nf_tables)".into()).is_err());
+    let mut value=policy();value.barrier.receipt.digest="sha256:wrong".into();assert!(value.prepare("v1.8.11 (nf_tables)".into()).is_err());
+    let mut value=policy();value.barrier.prepared.policy=crate::managed::Policy::Egress(serde_json::from_value(crate::egress::tests::router()).unwrap());assert!(value.prepare("v1.8.11 (nf_tables)".into()).is_err());
+    let value=serde_json::to_value(policy()).unwrap();
+    let mut extra=value.clone();extra["rules"]=json!([]);assert!(serde_json::from_value::<policy::Policy>(extra).is_err());
+    let mut extra=value;extra["barrier"]["receipt"]["tableHandle"]=json!("01");assert!(serde_json::from_value::<policy::Policy>(extra).unwrap().prepare("v1.8.11 (nf_tables)".into()).is_err());
+}
+#[test]
+fn docker_policy_digest_binds_barrier_handle_and_revision() {
+    let expected=policy().prepare("v1.8.11 (nf_tables)".into()).unwrap();
+    assert_ne!(policy().prepare("v1.8.10 (nf_tables)".into()).unwrap().digest,expected.digest);
+    for backend in ["v1.8. (nf_tables)","v1.8.9 (nf_tables)","v1.8.11 (legacy)","v1.8.011 (nf_tables)"] {
+        assert!(policy().prepare(backend.into()).is_err());
+    }
+    let mut value=policy();value.barrier.receipt.table_handle="2".into();assert_ne!(value.prepare("v1.8.11 (nf_tables)".into()).unwrap().digest,expected.digest);
+    let mut value=policy();value.revision=2;assert_ne!(value.prepare("v1.8.11 (nf_tables)".into()).unwrap().digest,expected.digest);
+    let mut forged=expected;forged.policy.revision=2;assert!(forged.validate().is_err());
+}
+#[test]
+fn docker_snapshot_accepts_only_equivalent_frontend_rendering() {
+    let rules=policy().prepare("v1.8.11 (nf_tables)".into()).unwrap().rules(&options()).unwrap();
+    let original=text(&rules);
+    let rendered=original.replace("--ctorigsrc 10.240.0.2/32","--ctorigsrc 10.240.0.2");
+    assert!(snapshot(&rendered).matches(&options(),&rules).unwrap());
+    for (before,after) in [("--ctdir ORIGINAL","--ctdir REPLY"),("--ctstate NEW","--ctstate RELATED"),("--sport 10000:10999","--sport 1:65535"),("-o ens18","-o foreign"),("-j ACCEPT","-j RETURN"),("FIN,SYN,RST,ACK SYN","FIN,SYN,RST,ACK ACK")] {
+        assert!(!snapshot(&original.replacen(before,after,1)).matches(&options(),&rules).unwrap());
+    }
+    assert!(snapshot(&original.replacen("-j ACCEPT","-m mark --mark 1 -j ACCEPT",1)).matches(&options(),&rules).is_err());
+}
+#[test]
+fn docker_snapshot_rejects_duplicates_moved_owner_and_foreign_instance() {
+    let rules=policy().prepare("v1.8.11 (nf_tables)".into()).unwrap().rules(&options()).unwrap();
+    let original=text(&rules);
+    let duplicate=original.replace("COMMIT",&format!("-A DOCKER-USER {}\nCOMMIT",rules[0].args.join(" ")));
+    assert!(!snapshot(&duplicate).matches(&options(),&rules).unwrap());
+    let moved=original.replacen("-A DOCKER-USER", "-A INPUT",1);
+    assert!(!snapshot(&moved).matches(&options(),&rules).unwrap());
+    assert!(!snapshot(&original.replace("qualification_20260913","foreign_instance_2026")).matches(&options(),&rules).unwrap());
+    assert_eq!(snapshot(&original.replace("snftd1:dockerfixture:","snftd1:anotherowner:")).matches(&options(),&[]),Err(Error::ForeignOwner));
+    let prepended=original.replacen("-A DOCKER-USER","-A DOCKER-USER -j RETURN\n-A DOCKER-USER",1);
+    assert!(!snapshot(&prepended).matches(&options(),&rules).unwrap());
+    assert!(!snapshot(&original).matches(&options(),&[]).unwrap());
+}
+#[test]
+fn docker_snapshot_rejects_wrong_backend_path_policy_chain_order_and_table_framing() {
+    let original=text(&[]);
+    for changed in [original.replace(":FORWARD DROP",":FORWARD ACCEPT"),original.replace("-A FORWARD -j DOCKER-USER","-A FORWARD -j ACCEPT"),original.replace("*filter","*nat"),original.replace("COMMIT","COMMIT\n*filter"),original.replace(":DOCKER-USER - [0:0]\n","")] {
+        assert!(frontend::Snapshot::parse("v1.8.11 (nf_tables)".into(),&changed).is_err());
+    }
+}
+
+#[test]
+fn docker_raw_graph_rejects_early_verdicts_reordered_matches_and_hidden_bytes() {
+    let rule=policy().prepare("v1.8.11 (nf_tables)".into()).unwrap().rules(&options()).unwrap().remove(0);
+    let expressions=graph::expected(&rule).unwrap();
+    let row=|expressions|vec![crate::wire::Attr::string(1,"filter"),crate::wire::Attr::string(2,"DOCKER-USER"),
+        crate::wire::Attr::u64(3,42),crate::wire::Attr::nested(4,expressions)];
+    assert!(graph::matches_rule(&row(expressions.clone()),&rule).unwrap());
+    let mut early=expressions.clone();let verdict=early.pop().unwrap();early.insert(0,verdict);
+    assert!(!graph::matches_rule(&row(early),&rule).unwrap());
+    let mut reordered=expressions.clone();reordered.swap(0,1);
+    assert!(!graph::matches_rule(&row(reordered),&rule).unwrap());
+    let mut moved_counter=expressions.clone();let length=moved_counter.len();moved_counter.swap(length-1,length-2);
+    assert!(!graph::matches_rule(&row(moved_counter),&rule).unwrap());
+    let mut hidden=expressions.clone();
+    for expression in &mut hidden {
+        let mut fields=crate::wire::attrs(&expression.value).unwrap();
+        if crate::wire::text(&fields,1).unwrap()!="match" {continue;}
+        let mut data=crate::wire::attrs(&crate::wire::one(&fields,2).unwrap().value).unwrap();
+        if crate::wire::text(&data,1).unwrap()!="conntrack" {continue;}
+        data.iter_mut().find(|a|a.id()==3).unwrap().value[20..32].fill(0);
+        *fields.iter_mut().find(|a|a.id()==2).unwrap()=crate::wire::Attr::nested(2,data);
+        expression.value=crate::wire::encode_attrs(&fields);
+    }
+    assert!(!graph::matches_rule(&row(hidden),&rule).unwrap());
+}
+
+#[test]
+fn docker_raw_graph_accepts_kernel_field_order_flags_and_changing_counters_only() {
+    let rule=policy().prepare("v1.8.11 (nf_tables)".into()).unwrap().rules(&options()).unwrap().remove(0);
+    let mut expressions=graph::expected(&rule).unwrap();
+    for expression in &mut expressions {
+        let mut fields=crate::wire::attrs(&expression.value).unwrap();
+        if crate::wire::text(&fields,1).unwrap()=="counter" {
+            *fields.iter_mut().find(|a|a.id()==2).unwrap()=crate::wire::Attr::nested(2,
+                vec![crate::wire::Attr::u64(2,123),crate::wire::Attr::u64(1,456)]);
+        }
+        fields.reverse();expression.value=crate::wire::encode_attrs(&fields);
+    }
+    fn kernel(attributes: &mut [crate::wire::Attr]) {
+        for attribute in attributes {
+            if attribute.kind&0x8000!=0 {
+                let mut children=crate::wire::attrs(&attribute.value).unwrap();kernel(&mut children);
+                attribute.value=crate::wire::encode_attrs(&children);
+            }
+            attribute.kind &= 0x3fff;
+        }
+    }
+    kernel(&mut expressions);
+    let row=vec![crate::wire::Attr::string(1,"filter"),crate::wire::Attr::string(2,"DOCKER-USER"),
+        crate::wire::Attr::u64(3,42),crate::wire::Attr::nested(4,expressions)];
+    assert!(graph::matches_rule(&row,&rule).unwrap());
+}
+
+#[test]
+fn docker_forward_jumps_require_exact_unconditional_order() {
+    use crate::{policy::{expr,verdict},wire::Attr};
+    let row=|expressions|vec![Attr::string(1,"filter"),Attr::string(2,"FORWARD"),
+        Attr::u64(3,42),Attr::nested(4,expressions)];
+    for target in ["DOCKER-USER","DOCKER-FORWARD"] {
+        let expected=vec![expr("counter",vec![Attr::u64(1,7),Attr::u64(2,11)]),verdict(-3,Some(target))];
+        assert!(graph::matches_forward(&row(expected.clone()),target).unwrap());
+        let mut early=expected.clone();early.insert(0,verdict(1,None));
+        assert!(!graph::matches_forward(&row(early),target).unwrap());
+        let mut reordered=expected.clone();reordered.reverse();
+        assert!(!graph::matches_forward(&row(reordered),target).unwrap());
+        assert!(!graph::matches_forward(&row(expected),if target=="DOCKER-USER" {"DOCKER-FORWARD"} else {"DOCKER-USER"}).unwrap());
+    }
+}

package/rust/src/egress.compile.rs

@@ -4,6 +4,8 @@ use crate::wire::{self, Attr};
 
 #[path = "egress.host.rs"]
 mod host;
+#[path = "egress.poolguard.rs"]
+mod poolguard;
 #[path = "egress.router.rs"]
 mod router;
 
@@ -283,6 +285,7 @@ pub(super) fn compile(prepared: &Prepared, table: &str) -> Result<Vec<(u16, Vec<
             router::compile(&mut program, scope, prepared.policy.revision)?
         }
         Scope::HostTransit(scope) => host::compile(&mut program, scope)?,
+        Scope::AllocationPoolGuard(scope) => poolguard::compile(&mut program, scope)?,
     }
     Ok(program.operations)
 }

package/rust/src/egress.poolguard.rs

@@ -0,0 +1,30 @@
+use super::*;
+
+pub(super) fn compile(program: &mut Program<'_>, scope: &AllocationPoolGuardScope) -> Result<()> {
+    for (name, hook) in [("input", 1), ("forward", 2), ("output", 3)] {
+        program.chain(name, Some((hook, 0, "filter")))?;
+    }
+    for name in ["pool_guard", "pool_reply"] {
+        program.chain(name, None)?;
+    }
+    for name in ["input", "forward", "output"] {
+        program.jump(name, ipv4(), "pool_guard")?;
+    }
+    // An earlier owner's DNAT must not conceal the original protected target.
+    for prefix in &scope.prefixes {
+        program.end("pool_guard", original_address(prefix, false)?, 0)?;
+    }
+    // GOTO, not JUMP: RETURN from pool_reply must return to the base chain,
+    // skipping current-destination denial for legitimate reverse-SNAT replies.
+    let mut reply = ct(1, None, vec![1]);
+    reply.push(verdict(-4, Some("pool_reply")));
+    program.rule("pool_guard", reply)?;
+    // A missing conntrack tuple/direction breaks only its rule. Untracked or
+    // invalid packets still reach this unconditional current-destination guard.
+    for prefix in &scope.prefixes {
+        program.end("pool_guard", current_address(prefix, false)?, 0)?;
+        program.end("pool_reply", current_address(prefix, true)?, 0)?;
+    }
+    program.end("pool_guard", vec![], -5)?;
+    program.end("pool_reply", vec![], -5)
+}

package/rust/src/egress.rs

@@ -119,10 +119,17 @@ pub struct HostScope {
     pub snat_address: String,
 }
 #[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub struct AllocationPoolGuardScope {
+    pub authority_digest: String,
+    pub prefixes: Vec<String>,
+}
+#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
 #[serde(tag = "kind", rename_all = "camelCase", deny_unknown_fields)]
 pub enum Scope {
     RouterEgress(RouterScope),
     HostTransit(HostScope),
+    AllocationPoolGuard(AllocationPoolGuardScope),
 }
 #[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
 #[serde(rename_all = "camelCase", deny_unknown_fields)]
@@ -532,6 +539,23 @@ fn normalize_router(value: &mut RouterScope, revision: u64) -> Result<()> {
         )
     }))
 }
+fn normalize_pool_guard(value: &mut AllocationPoolGuardScope) -> Result<()> {
+    require(
+        digest(&value.authority_digest) && !value.prefixes.is_empty() && value.prefixes.len() <= 64,
+    )?;
+    value.prefixes.sort();
+    for (index, item) in value.prefixes.iter().enumerate() {
+        require(
+            covers("10.0.0.0/8", item)?
+                || covers("172.16.0.0/12", item)?
+                || covers("192.168.0.0/16", item)?,
+        )?;
+        for previous in &value.prefixes[..index] {
+            require(!overlaps(item, previous)?)?;
+        }
+    }
+    Ok(())
+}
 fn normalize_host(value: &mut HostScope) -> Result<()> {
     normalize_protection(&mut value.protection)?;
     normalize_link(&mut value.uplink)?;
@@ -642,6 +666,7 @@ impl Policy {
         match &mut self.scope {
             Scope::RouterEgress(scope) => normalize_router(scope, self.revision)?,
             Scope::HostTransit(scope) => normalize_host(scope)?,
+            Scope::AllocationPoolGuard(scope) => normalize_pool_guard(scope)?,
         }
         Ok(self)
     }
@@ -667,6 +692,8 @@ impl Prepared {
                 .map(|item| &item.link)
                 .chain(std::iter::once(&scope.uplink))
                 .collect(),
+            // No link/route dependency: this policy must apply before allocation.
+            Scope::AllocationPoolGuard(_) => return Ok(()),
         };
         crate::wire::verify_bound_interfaces(links.into_iter().map(|link| {
             crate::wire::BoundInterface {

package/rust/src/egress_tests.rs

@@ -45,6 +45,11 @@ pub(crate) fn host() -> Value {
         "handoffs":[{"link":link(4,"handoff","veth","10.240.0.1"),"allocations":[allocation()]}],
         "uplink":link(2,"ens18","ethernet","192.0.2.2"),"snatAddress":"192.0.2.2"}})
 }
+pub(crate) fn pool_guard() -> Value {
+    json!({"schemaVersion":2,"revision":1,"scope":{"kind":"allocationPoolGuard",
+        "authorityDigest":format!("sha256:{}", "b".repeat(64)),
+        "prefixes":["10.241.0.0/16", "10.240.0.0/16"]}})
+}
 fn normalized(value: Value) -> super::Result<Policy> {
     serde_json::from_value::<Policy>(value)
         .map_err(|_| crate::Error::Invalid)?
@@ -330,3 +335,83 @@ fn managed_union_keeps_strict_duplicate_and_unknown_field_rejection() {
     )
     .is_err());
 }
+
+#[test]
+fn allocation_pool_guard_is_canonical_authority_bound_and_private_only() {
+    let prepared = normalized(pool_guard()).unwrap().prepare().unwrap();
+    let mut reordered = pool_guard();
+    reordered["scope"]["prefixes"]
+        .as_array_mut()
+        .unwrap()
+        .reverse();
+    assert_eq!(normalized(reordered).unwrap().prepare().unwrap(), prepared);
+    let mut changed_authority = pool_guard();
+    changed_authority["scope"]["authorityDigest"] = json!(format!("sha256:{}", "c".repeat(64)));
+    assert_ne!(
+        normalized(changed_authority)
+            .unwrap()
+            .prepare()
+            .unwrap()
+            .digest,
+        prepared.digest
+    );
+    for prefixes in [
+        json!([]),
+        json!(["10.0.0.1/8"]),
+        json!(["10.0.0.0/8", "10.1.0.0/16"]),
+        json!(["10.0.0.0/8", "10.0.0.0/8"]),
+        json!(["0.0.0.0/0"]),
+        json!(["192.0.2.0/24"]),
+        json!(["127.0.0.0/8"]),
+        json!(["172.0.0.0/8"]),
+        json!(["192.168.0.0/15"]),
+        json!(["10.0.0.0/08"]),
+        json!(["::/0"]),
+    ] {
+        assert!(normalized(changed(pool_guard(), "/scope/prefixes", prefixes)).is_err());
+    }
+    let mut extra = pool_guard();
+    extra["scope"]["handoffs"] = json!([]);
+    assert!(normalized(extra).is_err());
+    assert!(normalized(changed(
+        pool_guard(),
+        "/scope/authorityDigest",
+        json!("sha256:bad")
+    ))
+    .is_err());
+    assert!(normalized(changed(
+        pool_guard(),
+        "/scope/prefixes",
+        json!(["10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16"])
+    ))
+    .is_ok());
+    let duplicate = serde_json::to_string(&pool_guard())
+        .unwrap()
+        .replace("\"prefixes\":", "\"prefixes\":[],\"prefixes\":");
+    assert!(serde_json::from_str::<crate::managed::Policy>(&duplicate).is_err());
+}
+
+#[test]
+fn allocation_pool_guard_maximum_fits_the_atomic_graph_without_link_bindings() {
+    let prefixes: Vec<_> = (0..64).map(|part| format!("10.{part}.0.0/16")).collect();
+    let prepared = normalized(changed(pool_guard(), "/scope/prefixes", json!(prefixes)))
+        .unwrap()
+        .prepare()
+        .unwrap();
+    prepared.validate().unwrap();
+    prepared.validate_interfaces().unwrap();
+    let program = prepared
+        .program(&format!("snft_{}", "x".repeat(59)))
+        .unwrap();
+    let bytes: usize = program
+        .iter()
+        .map(|(_, attrs)| crate::wire::encode_attrs(attrs).len() + 20)
+        .sum();
+    assert!(program.len() <= 768 && bytes <= 100_000);
+    println!(
+        "POOL_GUARD_MAX prefixes=64 operations={} bytes={bytes}",
+        program.len()
+    );
+    let excessive: Vec<_> = (0..65).map(|part| format!("10.{part}.0.0/16")).collect();
+    assert!(normalized(changed(pool_guard(), "/scope/prefixes", json!(excessive))).is_err());
+}

package/rust/src/main.rs

@@ -1,4 +1,5 @@
 mod egress;
+mod docker;
 mod managed;
 mod namespace;
 mod owner;
@@ -14,6 +15,7 @@ use std::io::{BufRead, Read, Write};
 pub enum Error {
     Invalid,
     Unsupported,
+    UnsupportedBackend,
     Permission,
     ForeignOwner,
     Conflict,
@@ -27,6 +29,7 @@ impl Error {
         match self {
             Self::Invalid => "INVALID",
             Self::Unsupported => "UNSUPPORTED_KERNEL",
+            Self::UnsupportedBackend => "UNSUPPORTED_BACKEND",
             Self::Permission => "PERMISSION",
             Self::ForeignOwner => "FOREIGN_OWNER",
             Self::Conflict => "CONFLICT",
@@ -101,13 +104,14 @@ fn dispatch(owner: &mut Option<owner::Owner>, request: Request) -> Result<serde_
 
 fn main() {
     let arguments = std::env::args().skip(1).collect::<Vec<_>>();
-    let descriptor = match arguments.as_slice() {
-        [management] if management == "--management" => None,
+    let (docker_mode, descriptor) = match arguments.as_slice() {
+        [management] if management == "--management" => (false, None),
+        [management] if management == "--docker-forwarding" => (true, None),
         [management, option, fd]
-            if management == "--management" && option == "--network-namespace-fd" =>
+            if (management == "--management" || management == "--docker-forwarding") && option == "--network-namespace-fd" =>
         {
             match fd.parse::<i32>() {
-                Ok(value) => Some(value),
+                Ok(value) => (management == "--docker-forwarding", Some(value)),
                 Err(_) => std::process::exit(2),
             }
         }
@@ -125,6 +129,7 @@ fn main() {
     output.flush().unwrap();
     let mut input = std::io::stdin().lock();
     let mut owner = None;
+    let mut docker = None;
     loop {
         let mut bytes = Vec::new();
         let read = std::io::Read::by_ref(&mut input)
@@ -144,7 +149,7 @@ fn main() {
             std::process::exit(2);
         }
         let id = request.id.clone();
-        let response = match dispatch(&mut owner, request) {
+        let response = match if docker_mode { docker::dispatch(&mut docker, request) } else { dispatch(&mut owner, request) } {
             Ok(result) => serde_json::json!({"id":id,"success":true,"result":result}),
             Err(error) => {
                 serde_json::json!({"id":id,"success":false,"error":"Managed policy operation failed.","errorCode":error.code()})

package/rust/src/managed.rs

@@ -34,6 +34,10 @@ impl Policy {
                 scope: egress::Scope::HostTransit(_),
                 ..
             }) => "hostTransitV2",
+            Self::Egress(egress::Policy {
+                scope: egress::Scope::AllocationPoolGuard(_),
+                ..
+            }) => "allocationPoolGuardV2",
         }
     }
     pub fn prepare(self) -> Result<Prepared> {

package/rust/src/owner.rs

@@ -70,7 +70,7 @@ pub struct Owner {
     released: bool,
 }
 
-fn context() -> Result<(String, String, String)> {
+pub(crate) fn context() -> Result<(String, String, String)> {
     let boot = std::fs::read_to_string("/proc/sys/kernel/random/boot_id")
         .map_err(|_| Error::Unavailable)?
         .trim()
@@ -112,6 +112,24 @@ fn kernel_floor() -> Result<()> {
 }
 
 impl Owner {
+    /// Read another dedicated owner's exact receipt without claiming its table.
+    /// PERSIST may retain enforcement after that owner's socket closes.
+    pub(crate) fn verify_external(expected: &Applied) -> Result<()> {
+        let identity = &expected.receipt.identity;
+        let mut reader = Self::new(Options {
+            owner_id: identity.owner_id.clone(),
+            instance_id: identity.instance_id.clone(),
+            table_name: identity.table_name.clone(),
+        })?;
+        reader.validate_receipt(expected)?;
+        let graph = reader.graph()?.ok_or(Error::Conflict)?;
+        reader.binding(&graph, Some(expected))?;
+        if !reader.matches(&graph, &expected.prepared)? {
+            return Err(Error::Conflict);
+        }
+        expected.prepared.validate_interfaces()
+    }
+
     pub fn new(options: Options) -> Result<Self> {
         if !identifier(&options.owner_id)
             || !identifier(&options.instance_id)

package/rust/src/owner_egress_tests.rs

@@ -62,7 +62,7 @@ fn host() -> egress::Policy {
     value["scope"]["uplink"] = binding("uplink", "192.0.2.2", "veth");
     serde_json::from_value(value).unwrap()
 }
-fn recover(name: &str, policy: egress::Policy) {
+pub(super) fn recover(name: &str, policy: egress::Policy) {
     let prepared: Prepared = policy.clone().prepare().unwrap().into();
     prepared.validate_interfaces().expect("fixture bindings");
     let mut owner = Owner::new(options(name)).unwrap();

package/rust/src/owner_egress_traffic_tests.rs

@@ -205,6 +205,18 @@ fn v2_four_namespace_private_tun_local_dns_egress_and_revocation() {
     ns_ip(ROUTER, &["address", "add", "10.242.0.1/24", "dev", "vpn"]);
     ns_ip(ROUTER, &["link", "set", "vpn", "up"]);
     let mut device = in_namespace(ROUTER, tun);
+    let (pool_owner, pool_applied) = in_namespace(HOST, || {
+        let mut owner = Owner::new(options("pool_coexistence")).unwrap();
+        let policy: egress::Policy = serde_json::from_value(egress::tests::pool_guard()).unwrap();
+        let applied = owner
+            .reconcile(Transition {
+                previous: None,
+                target: policy.prepare().unwrap().into(),
+            })
+            .unwrap();
+        assert!(owner.inspect().enforced);
+        (owner, applied)
+    });
     let (host_owner, host_applied) = in_namespace(HOST, || {
         let mut owner = Owner::new(options("host_packets")).unwrap();
         let applied = owner
@@ -260,11 +272,8 @@ fn v2_four_namespace_private_tun_local_dns_egress_and_revocation() {
     });
     let listener = in_namespace(PEER, || TcpListener::bind("192.0.2.3:3000").unwrap());
     let mut client = in_namespace(WORK, || {
-        TcpStream::connect_timeout(
-            &"192.0.2.3:3000".parse().unwrap(),
-            Duration::from_secs(1),
-        )
-        .unwrap()
+        TcpStream::connect_timeout(&"192.0.2.3:3000".parse().unwrap(), Duration::from_secs(1))
+            .unwrap()
     });
     let (mut server, peer) = listener.accept().unwrap();
     assert_eq!(peer.ip().to_string(), "192.0.2.2");
@@ -290,11 +299,8 @@ fn v2_four_namespace_private_tun_local_dns_egress_and_revocation() {
     assert_eq!(syn[33] & 0xc0, 0xc0);
     assert!((10016..=10031).contains(&u16::from_be_bytes(syn[20..22].try_into().unwrap())));
     let mut local_tcp = in_namespace(ROUTER, || {
-        TcpStream::connect_timeout(
-            &"192.0.2.3:3000".parse().unwrap(),
-            Duration::from_secs(1),
-        )
-        .unwrap()
+        TcpStream::connect_timeout(&"192.0.2.3:3000".parse().unwrap(), Duration::from_secs(1))
+            .unwrap()
     });
     let (mut local_peer, local_outer) = listener.accept().unwrap();
     assert!((10016..=10031).contains(&local_outer.port()));
@@ -466,5 +472,10 @@ fn v2_four_namespace_private_tun_local_dns_egress_and_revocation() {
         let mut owner = host_owner;
         owner.release(host_applied).unwrap();
     });
+    in_namespace(HOST, move || {
+        let mut owner = pool_owner;
+        assert!(owner.inspect().enforced);
+        owner.release(pool_applied).unwrap();
+    });
     println!("V2_PACKET_PROOF private_dns=true tun_private=true tun_public_denied=true workload_public=true local_dns_and_tcp=true handoff_udp_tcp_ranges=true ecn_syn=true opening_ack_rst_denied=true fragments_checked=true range_exhaustion_denied=true protected_grant_denied=true ungranted_local_denied=true retired_replies_denied=true revoked_egress_denied=true disjoint_generation_restored=true flows_drained=false reusable=false");
 }

package/rust/src/owner_host_traffic_tests.rs

@@ -7,7 +7,7 @@ const SOURCE: &str = "hs_source";
 const HOST: &str = "hs_host";
 const PEER: &str = "hs_peer";
 
-fn payload(offset: u32, bytes: Vec<u8>, transport: bool) -> Vec<Attr> {
+pub(super) fn payload(offset: u32, bytes: Vec<u8>, transport: bool) -> Vec<Attr> {
     vec![
         expr(
             "payload",
@@ -21,7 +21,7 @@ fn payload(offset: u32, bytes: Vec<u8>, transport: bool) -> Vec<Attr> {
         compare(bytes),
     ]
 }
-fn immediate(value: Vec<u8>) -> Attr {
+pub(super) fn immediate(value: Vec<u8>) -> Attr {
     expr(
         "immediate",
         vec![
@@ -196,10 +196,7 @@ fn v2_host_rejects_foreign_dnat_zone_local_diversion_and_ipv6() {
         HOST,
         &["route", "add", "203.0.113.2/32", "via", "192.0.2.3"],
     );
-    ns_ip(
-        HOST,
-        &["route", "add", "10.250.0.2/32", "via", "192.0.2.3"],
-    );
+    ns_ip(HOST, &["route", "add", "10.250.0.2/32", "via", "192.0.2.3"]);
     for address in ["203.0.113.2/32", "10.250.0.2/32"] {
         ns_ip(PEER, &["address", "add", address, "dev", "lo"]);
     }
@@ -285,10 +282,7 @@ fn v2_host_rejects_foreign_dnat_zone_local_diversion_and_ipv6() {
         control(source, destination, target, false);
     }
     let allowed = socket(SOURCE, "10.240.0.2:10000");
-    assert_eq!(
-        roundtrip(&allowed, &public).ip().to_string(),
-        "192.0.2.2"
-    );
+    assert_eq!(roundtrip(&allowed, &public).ip().to_string(), "192.0.2.2");
     let platform = socket(PEER, "192.0.2.3:5300");
     roundtrip(&allowed, &platform);
     let unleased = socket(SOURCE, "10.240.0.2:9999");