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,
}
#[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 {
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)
}
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()
})
}
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
}
}
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(),
}
}
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()
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct NetworkAccess {
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,
};
pub fn isolated(&self) -> bool {
self.enforced && !(self.mesh && self.internet)
}
}
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, };
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() {
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());
let a = network_access(Some(&sa(&["network:mesh"], Some(legacy))));
assert!(a.enforced);
}
#[test]
fn lowercase_and_list_forms_of_the_backfill_are_legacy() {
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:?}");
}
}
}