zc2 0.0.40

P2P compute broker with credit-based billing, WAL, and broker mesh support
//! Service-account policy evaluation for a deployment's network access
//! (hub ADR MKT-0013 / MKT-0021, `docs/service-account-policies.md` in
//! zakuro-ai/zak-marketplace).
//!
//! The hub serves a deployment's service account as `{name, grants, policy?}`.
//! `policy` is an S3/IAM-style document; this module evaluates it with the
//! hub's own semantics (default deny, explicit Deny wins, `*`/`?` wildcards,
//! case-insensitive actions, case-sensitive resources). `tests/fixtures/
//! policy_vectors.json` is a verbatim copy of the hub's shared vectors
//! (`api/tests/fixtures/policy_vectors.json`, #430) and is run against this
//! evaluator by `shared_hub_vectors_match`.
//!
//! Network access is the one thing a broker can enforce on a workload:
//!
//! | Action            | Resource                        | Meaning                   |
//! |-------------------|---------------------------------|---------------------------|
//! | `network:Connect` | `arn:zakuro:network:::mesh`     | reach the zakuro mesh     |
//! | `network:Connect` | `arn:zakuro:network:::internet` | reach the public internet |
//!
//! Back-compat (same rule as the hub's `ServiceAccount.may`): a policy that
//! is unset, or exactly `legacy_grants_to_policy(grants)` (the V025
//! backfill), is NOT enforced. An unparseable policy fails closed.

use serde::Deserialize;
use serde_json::Value;

use super::ServiceAccount;

pub const NETWORK_ACTION: &str = "network:Connect";
pub const MESH_RESOURCE: &str = "arn:zakuro:network:::mesh";
pub const INTERNET_RESOURCE: &str = "arn:zakuro:network:::internet";
const POLICY_VERSION: &str = "2026-01-01";

#[derive(Debug, Clone, PartialEq, Deserialize)]
#[serde(untagged)]
enum OneOrMany {
    One(String),
    Many(Vec<String>),
}

impl OneOrMany {
    fn set(&self) -> std::collections::BTreeSet<&str> {
        self.items().iter().map(String::as_str).collect()
    }

    fn items(&self) -> &[String] {
        match self {
            OneOrMany::One(s) => std::slice::from_ref(s),
            OneOrMany::Many(v) => v,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Deserialize)]
struct Statement {
    #[serde(rename = "Sid", alias = "sid", default)]
    sid: Option<String>,
    #[serde(rename = "Effect", alias = "effect")]
    effect: String,
    #[serde(rename = "Action", alias = "action")]
    action: OneOrMany,
    #[serde(rename = "Resource", alias = "resource")]
    resource: OneOrMany,
}

/// A parsed policy document.
#[derive(Debug, Clone, PartialEq, Deserialize)]
pub struct Policy {
    #[serde(rename = "Version", alias = "version", default = "default_version")]
    version: String,
    #[serde(rename = "Statement", alias = "statement")]
    statement: Vec<Statement>,
}

fn default_version() -> String {
    POLICY_VERSION.to_string()
}

impl Policy {
    /// Parse and validate (structure only; the hub already validated ARN
    /// syntax and service names when the policy was written).
    pub fn parse(v: &Value) -> Result<Policy, String> {
        let p: Policy = serde_json::from_value(v.clone()).map_err(|e| e.to_string())?;
        if p.statement.is_empty() {
            return Err("Statement must not be empty".into());
        }
        for s in &p.statement {
            if s.effect != "Allow" && s.effect != "Deny" {
                return Err(format!("Effect must be Allow or Deny, got {:?}", s.effect));
            }
            if s.action.items().is_empty() || s.resource.items().is_empty() {
                return Err("Action and Resource must not be empty".into());
            }
        }
        Ok(p)
    }

    /// Semantic equality for the legacy back-compat check: `Sid` and
    /// `Version` are ignored and `Action`/`Resource` compare as sets, so a
    /// serialization quirk (`"x"` vs `["x"]`, key casing) cannot make the
    /// V025 backfill look like an authored policy.
    fn same_as(&self, other: &Policy) -> bool {
        self.statement.len() == other.statement.len()
            && self.statement.iter().zip(&other.statement).all(|(a, b)| {
                a.effect == b.effect
                    && a.action.set() == b.action.set()
                    && a.resource.set() == b.resource.set()
            })
    }

    /// IAM evaluation: default deny, any matching Deny wins, else any Allow.
    pub fn is_allowed(&self, action: &str, resource: &str) -> bool {
        let mut allowed = false;
        for s in &self.statement {
            let hit = s.action.items().iter().any(|p| iam_match(p, action, false))
                && s.resource
                    .items()
                    .iter()
                    .any(|p| iam_match(p, resource, true));
            if hit {
                if s.effect == "Deny" {
                    return false;
                }
                allowed = true;
            }
        }
        allowed
    }
}

/// The hub's `legacy_grants_to_policy`: one unscoped Allow per grant.
fn legacy_grants_to_policy(grants: &[String]) -> Policy {
    Policy {
        version: default_version(),
        statement: grants
            .iter()
            .enumerate()
            .map(|(i, g)| {
                let (service, action) = match g.split_once(':') {
                    Some((svc, _)) => (svc.to_string(), g.clone()),
                    None => (g.clone(), format!("{g}:*")),
                };
                Statement {
                    sid: Some(format!("LegacyGrant{i}")),
                    effect: "Allow".into(),
                    action: OneOrMany::One(action),
                    resource: OneOrMany::One(format!("arn:zakuro:{service}:::*")),
                }
            })
            .collect(),
    }
}

/// `*` matches any run (incl. empty, incl. `/` and newlines), `?` exactly one
/// char; everything else is literal (no character classes).
fn iam_match(pattern: &str, value: &str, case_sensitive: bool) -> bool {
    let (p, v): (Vec<char>, Vec<char>) = if case_sensitive {
        (pattern.chars().collect(), value.chars().collect())
    } else {
        (
            pattern.to_lowercase().chars().collect(),
            value.to_lowercase().chars().collect(),
        )
    };
    let (mut pi, mut vi) = (0usize, 0usize);
    let (mut star, mut mark) = (None::<usize>, 0usize);
    while vi < v.len() {
        if pi < p.len() && (p[pi] == '?' || (p[pi] != '*' && p[pi] == v[vi])) {
            pi += 1;
            vi += 1;
        } else if pi < p.len() && p[pi] == '*' {
            star = Some(pi);
            mark = vi;
            pi += 1;
        } else if let Some(s) = star {
            pi = s + 1;
            mark += 1;
            vi = mark;
        } else {
            return false;
        }
    }
    while pi < p.len() && p[pi] == '*' {
        pi += 1;
    }
    pi == p.len()
}

/// What a deployment's service account lets its container reach.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct NetworkAccess {
    /// A policy is being enforced (false = unset / legacy backfill).
    pub enforced: bool,
    pub mesh: bool,
    pub internet: bool,
}

impl NetworkAccess {
    pub const OPEN: NetworkAccess = NetworkAccess {
        enforced: false,
        mesh: true,
        internet: true,
    };
    const DENIED: NetworkAccess = NetworkAccess {
        enforced: true,
        mesh: false,
        internet: false,
    };

    /// The container must run isolated (no mesh and no internet route) when
    /// either is denied: one internal docker network blocks both, so a
    /// partial deny fails closed on the other resource.
    pub fn isolated(&self) -> bool {
        self.enforced && !(self.mesh && self.internet)
    }
}

/// Evaluate `sa`'s policy for network access (see the module doc).
pub fn network_access(sa: Option<&ServiceAccount>) -> NetworkAccess {
    let Some(sa) = sa else {
        return NetworkAccess::OPEN;
    };
    let Some(raw) = sa.policy.as_ref().filter(|v| !v.is_null()) else {
        return NetworkAccess::OPEN;
    };
    let policy = match Policy::parse(raw) {
        Ok(p) => p,
        Err(_) => return NetworkAccess::DENIED, // fail closed
    };
    if policy.same_as(&legacy_grants_to_policy(&sa.grants)) {
        return NetworkAccess::OPEN;
    }
    NetworkAccess {
        enforced: true,
        mesh: policy.is_allowed(NETWORK_ACTION, MESH_RESOURCE),
        internet: policy.is_allowed(NETWORK_ACTION, INTERNET_RESOURCE),
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use serde_json::json;

    fn sa(grants: &[&str], policy: Option<Value>) -> ServiceAccount {
        ServiceAccount {
            name: "svc".into(),
            grants: grants.iter().map(|s| s.to_string()).collect(),
            policy,
        }
    }

    #[test]
    fn shared_hub_vectors_match() {
        // Copied verbatim from zak-marketplace api/tests/fixtures/policy_vectors.json.
        let file: Value =
            serde_json::from_str(include_str!("../../../tests/fixtures/policy_vectors.json"))
                .unwrap();
        let vectors = file["vectors"].as_array().unwrap();
        assert!(vectors.len() > 40);
        for v in vectors {
            let p = Policy::parse(&v["policy"]).unwrap();
            let got = if p.is_allowed(
                v["action"].as_str().unwrap(),
                v["resource"].as_str().unwrap(),
            ) {
                "Allow"
            } else {
                "Deny"
            };
            assert_eq!(got, v["expected"], "vector {}", v["name"]);
        }
    }

    #[test]
    fn no_policy_is_open() {
        assert_eq!(network_access(None), NetworkAccess::OPEN);
        assert_eq!(
            network_access(Some(&sa(&["network:mesh"], None))),
            NetworkAccess::OPEN
        );
        assert_eq!(
            network_access(Some(&sa(&[], Some(Value::Null)))),
            NetworkAccess::OPEN
        );
    }

    #[test]
    fn legacy_backfill_is_not_enforced() {
        let legacy = json!({"Version":"2026-01-01","Statement":[
            {"Sid":"LegacyGrant0","Effect":"Allow","Action":"network:mesh","Resource":"arn:zakuro:network:::*"},
            {"Sid":"LegacyGrant1","Effect":"Allow","Action":"kv:read","Resource":"arn:zakuro:kv:::*"}]});
        let a = network_access(Some(&sa(
            &["network:mesh", "kv:read"],
            Some(legacy.clone()),
        )));
        assert_eq!(a, NetworkAccess::OPEN);
        assert!(!a.isolated());
        // Same document but grants differ => it is an authored policy.
        let a = network_access(Some(&sa(&["network:mesh"], Some(legacy))));
        assert!(a.enforced);
    }

    #[test]
    fn lowercase_and_list_forms_of_the_backfill_are_legacy() {
        // pydantic `model_dump(mode="json")` without by_alias (hub grants.py).
        let lower = json!({"version":"2026-01-01","statement":[
            {"sid":"LegacyGrant0","effect":"Allow","action":"network:mesh","resource":"arn:zakuro:network:::*"}]});
        assert_eq!(
            network_access(Some(&sa(&["network:mesh"], Some(lower)))),
            NetworkAccess::OPEN
        );
        let list = json!({"Statement":[
            {"Effect":"Allow","Action":["network:mesh"],"Resource":["arn:zakuro:network:::*"]}]});
        assert_eq!(
            network_access(Some(&sa(&["network:mesh"], Some(list)))),
            NetworkAccess::OPEN
        );
    }

    #[test]
    fn lowercase_authored_deny_is_still_enforced() {
        let p = json!({"version":"2026-01-01","statement":[
            {"effect":"Allow","action":"*:*","resource":"arn:zakuro:*:::*"},
            {"effect":"Deny","action":"network:Connect","resource":"arn:zakuro:network:::internet"}]});
        let a = network_access(Some(&sa(&["network:mesh"], Some(p))));
        assert!(a.enforced && a.mesh && !a.internet && a.isolated());
    }

    #[test]
    fn authored_policy_without_network_allow_denies_everything() {
        let p = json!({"Statement":[{"Effect":"Allow","Action":"datasets:Get*","Resource":"arn:zakuro:datasets:::*"}]});
        let a = network_access(Some(&sa(&["network:mesh"], Some(p))));
        assert!(a.enforced && !a.mesh && !a.internet && a.isolated());
    }

    #[test]
    fn admin_policy_allows_network() {
        let p =
            json!({"Statement":[{"Effect":"Allow","Action":"*:*","Resource":"arn:zakuro:*:::*"}]});
        let a = network_access(Some(&sa(&[], Some(p))));
        assert!(a.enforced && a.mesh && a.internet && !a.isolated());
    }

    #[test]
    fn explicit_deny_on_internet_isolates() {
        let p = json!({"Statement":[
            {"Effect":"Allow","Action":"network:*","Resource":"arn:zakuro:network:::*"},
            {"Effect":"Deny","Action":"network:Connect","Resource":"arn:zakuro:network:::internet"}]});
        let a = network_access(Some(&sa(&[], Some(p))));
        assert!(a.mesh && !a.internet && a.isolated());
    }

    #[test]
    fn unparseable_policy_fails_closed() {
        for bad in [
            json!("nope"),
            json!({"Statement": []}),
            json!({"Statement":[{"Effect":"Maybe","Action":"a:b","Resource":"arn:zakuro:a:::x"}]}),
            json!({"Statement":[{"Effect":"Allow","Action":[],"Resource":"x"}]}),
        ] {
            let a = network_access(Some(&sa(&["network:mesh"], Some(bad))));
            assert!(a.enforced && a.isolated(), "{a:?}");
        }
    }
}