use std::collections::BTreeSet;
use serde::{Deserialize, Serialize};
use serde_json::Value;
use crate::error::{Result, RustyError};
use crate::record::{canonicalize_value, sha256_hex, CapsuleVersion, Effect};
fn invalid(message: impl Into<String>) -> RustyError {
RustyError::InvalidUpdate(message.into())
}
pub const WORLD_V1: &str = "rusty:capsule/world@0.1.0";
pub const SUPPORTED_WORLDS: &[&str] = &[WORLD_V1];
#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
#[serde(transparent)]
pub struct CapsuleId(String);
impl CapsuleId {
pub fn as_str(&self) -> &str {
&self.0
}
}
impl std::fmt::Display for CapsuleId {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(&self.0)
}
}
impl From<String> for CapsuleId {
fn from(digest: String) -> Self {
Self(digest)
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct CapsuleIdentity {
pub name: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CapsuleInterface {
pub world: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub input_schema: Option<Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub output_schema: Option<Value>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum FilesystemMode {
Read,
ReadWrite,
}
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case")]
pub enum CapabilityGrant {
Filesystem {
paths: Vec<String>,
mode: FilesystemMode,
},
Network {
hosts: Vec<String>,
protocols: Vec<String>,
methods: Vec<String>,
},
Secret {
handles: Vec<String>,
},
Tool {
tools: Vec<String>,
},
Model {
models: Vec<String>,
},
Clock,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum CapabilityKind {
Filesystem,
Network,
Secret,
Tool,
Model,
Clock,
}
impl CapabilityGrant {
pub fn capability_kind(&self) -> CapabilityKind {
match self {
CapabilityGrant::Filesystem { .. } => CapabilityKind::Filesystem,
CapabilityGrant::Network { .. } => CapabilityKind::Network,
CapabilityGrant::Secret { .. } => CapabilityKind::Secret,
CapabilityGrant::Tool { .. } => CapabilityKind::Tool,
CapabilityGrant::Model { .. } => CapabilityKind::Model,
CapabilityGrant::Clock => CapabilityKind::Clock,
}
}
pub fn implied_effect(&self) -> Effect {
match self {
CapabilityGrant::Filesystem { mode, .. } => match mode {
FilesystemMode::Read => Effect::ReadOnly,
FilesystemMode::ReadWrite => Effect::NonIdempotent,
},
CapabilityGrant::Network { methods, .. } => {
if methods.iter().all(|m| is_read_only_method(m)) {
Effect::ReadOnly
} else {
Effect::NonIdempotent
}
}
CapabilityGrant::Secret { .. } => Effect::ReadOnly,
CapabilityGrant::Tool { .. } => Effect::NonIdempotent,
CapabilityGrant::Model { .. } => Effect::NonIdempotent,
CapabilityGrant::Clock => Effect::ReadOnly,
}
}
}
pub fn is_read_only_method(method: &str) -> bool {
matches!(method, "GET" | "HEAD" | "OPTIONS")
}
pub fn network_grant_covers<'a>(
grants: impl IntoIterator<Item = &'a CapabilityGrant>,
protocol: &str,
host: &str,
method: &str,
) -> bool {
grants.into_iter().any(|grant| match grant {
CapabilityGrant::Network {
hosts,
protocols,
methods,
} => {
hosts.iter().any(|h| h == host)
&& protocols.iter().any(|p| p == protocol)
&& methods.iter().any(|m| m == method)
}
_ => false,
})
}
pub fn any_grant_of_kind<'a>(
grants: impl IntoIterator<Item = &'a CapabilityGrant>,
kind: CapabilityKind,
) -> bool {
grants
.into_iter()
.any(|grant| grant.capability_kind() == kind)
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CapsuleOverlay {
pub name: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub targets: Option<Vec<String>>,
pub capabilities: BTreeSet<CapabilityGrant>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub note: Option<String>,
}
impl CapsuleOverlay {
pub fn validate(&self) -> Result<()> {
validate_token("overlay name", &self.name)?;
if let Some(targets) = &self.targets {
if targets.is_empty() {
return Err(invalid(
"overlay targets: the list is empty — an overlay applying to no capsule \
carries no meaning (omit the field to target every capsule)",
));
}
for target in targets {
validate_token("overlay target", target)?;
}
}
for grant in &self.capabilities {
validate_grant(grant)?;
}
Ok(())
}
pub fn applies_to(&self, capsule_name: &str) -> bool {
self.targets
.as_ref()
.is_none_or(|targets| targets.iter().any(|target| target == capsule_name))
}
pub fn effective_grants(
&self,
manifest_grants: &BTreeSet<CapabilityGrant>,
) -> BTreeSet<CapabilityGrant> {
intersect_grants(manifest_grants, &self.capabilities)
}
}
pub fn intersect_grants(
manifest_grants: &BTreeSet<CapabilityGrant>,
overlay_grants: &BTreeSet<CapabilityGrant>,
) -> BTreeSet<CapabilityGrant> {
fn common(a: &[String], b: &[String]) -> Vec<String> {
let mut out: Vec<String> = a.iter().filter(|item| b.contains(item)).cloned().collect();
out.sort();
out.dedup();
out
}
let mut out = BTreeSet::new();
for manifest_grant in manifest_grants {
for overlay_grant in overlay_grants {
let shared = match (manifest_grant, overlay_grant) {
(
CapabilityGrant::Filesystem {
paths: manifest_paths,
mode: manifest_mode,
},
CapabilityGrant::Filesystem {
paths: overlay_paths,
mode: overlay_mode,
},
) => {
let paths = common(manifest_paths, overlay_paths);
(!paths.is_empty()).then(|| CapabilityGrant::Filesystem {
paths,
mode: (*manifest_mode).min(*overlay_mode),
})
}
(
CapabilityGrant::Network {
hosts: manifest_hosts,
protocols: manifest_protocols,
methods: manifest_methods,
},
CapabilityGrant::Network {
hosts: overlay_hosts,
protocols: overlay_protocols,
methods: overlay_methods,
},
) => {
let hosts = common(manifest_hosts, overlay_hosts);
let protocols = common(manifest_protocols, overlay_protocols);
let methods = common(manifest_methods, overlay_methods);
(!hosts.is_empty() && !protocols.is_empty() && !methods.is_empty()).then_some(
CapabilityGrant::Network {
hosts,
protocols,
methods,
},
)
}
(
CapabilityGrant::Secret {
handles: manifest_handles,
},
CapabilityGrant::Secret {
handles: overlay_handles,
},
) => {
let handles = common(manifest_handles, overlay_handles);
(!handles.is_empty()).then_some(CapabilityGrant::Secret { handles })
}
(
CapabilityGrant::Tool {
tools: manifest_tools,
},
CapabilityGrant::Tool {
tools: overlay_tools,
},
) => {
let tools = common(manifest_tools, overlay_tools);
(!tools.is_empty()).then_some(CapabilityGrant::Tool { tools })
}
(
CapabilityGrant::Model {
models: manifest_models,
},
CapabilityGrant::Model {
models: overlay_models,
},
) => {
let models = common(manifest_models, overlay_models);
(!models.is_empty()).then_some(CapabilityGrant::Model { models })
}
(CapabilityGrant::Clock, CapabilityGrant::Clock) => Some(CapabilityGrant::Clock),
_ => None,
};
if let Some(grant) = shared {
out.insert(grant);
}
}
}
out
}
pub fn grants_beyond(
overlay_grants: &BTreeSet<CapabilityGrant>,
manifest_grants: &BTreeSet<CapabilityGrant>,
) -> BTreeSet<CapabilityGrant> {
fn covered<'a>(
needed: &[String],
offered: impl Iterator<Item = &'a Vec<String>> + Clone,
) -> bool {
needed
.iter()
.all(|item| offered.clone().any(|list| list.contains(item)))
}
overlay_grants
.iter()
.filter(|overlay_grant| {
let same_kind = manifest_grants
.iter()
.filter(|m| m.capability_kind() == overlay_grant.capability_kind());
let covered = match overlay_grant {
CapabilityGrant::Filesystem { paths, mode } => {
let mode_covered = same_kind.clone().any(|m| match m {
CapabilityGrant::Filesystem {
mode: manifest_mode,
..
} => manifest_mode >= mode,
_ => false,
});
mode_covered
&& covered(
paths,
same_kind.filter_map(|m| match m {
CapabilityGrant::Filesystem { paths, .. } => Some(paths),
_ => None,
}),
)
}
CapabilityGrant::Network {
hosts,
protocols,
methods,
} => {
let networks = same_kind.filter_map(|m| match m {
CapabilityGrant::Network {
hosts,
protocols,
methods,
} => Some((hosts, protocols, methods)),
_ => None,
});
covered(hosts, networks.clone().map(|(h, _, _)| h))
&& covered(protocols, networks.clone().map(|(_, p, _)| p))
&& covered(methods, networks.map(|(_, _, m)| m))
}
CapabilityGrant::Secret { handles } => covered(
handles,
same_kind.filter_map(|m| match m {
CapabilityGrant::Secret { handles } => Some(handles),
_ => None,
}),
),
CapabilityGrant::Tool { tools } => covered(
tools,
same_kind.filter_map(|m| match m {
CapabilityGrant::Tool { tools } => Some(tools),
_ => None,
}),
),
CapabilityGrant::Model { models } => covered(
models,
same_kind.filter_map(|m| match m {
CapabilityGrant::Model { models } => Some(models),
_ => None,
}),
),
CapabilityGrant::Clock => same_kind.count() > 0,
};
!covered
})
.cloned()
.collect()
}
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ResourceBudget {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub fuel: Option<u64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub max_memory_bytes: Option<u64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub wall_time_ms: Option<u64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub max_tokens: Option<u64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub max_cost_usd: Option<f64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub max_output_bytes: Option<u64>,
}
impl ResourceBudget {
pub fn clamp(&self, ceiling: &ResourceBudget) -> ResourceBudget {
fn min_opt<T: Ord + Copy>(a: Option<T>, b: Option<T>) -> Option<T> {
match (a, b) {
(Some(x), Some(y)) => Some(x.min(y)),
(a, b) => a.or(b),
}
}
ResourceBudget {
fuel: min_opt(self.fuel, ceiling.fuel),
max_memory_bytes: min_opt(self.max_memory_bytes, ceiling.max_memory_bytes),
wall_time_ms: min_opt(self.wall_time_ms, ceiling.wall_time_ms),
max_tokens: min_opt(self.max_tokens, ceiling.max_tokens),
max_cost_usd: match (self.max_cost_usd, ceiling.max_cost_usd) {
(Some(a), Some(b)) => Some(a.min(b)),
(a, b) => a.or(b),
},
max_output_bytes: min_opt(self.max_output_bytes, ceiling.max_output_bytes),
}
}
fn validate(&self) -> Result<()> {
if let Some(cost) = self.max_cost_usd {
if !cost.is_finite() || cost < 0.0 {
return Err(invalid(format!(
"resource budget: max_cost_usd must be finite and non-negative, got {cost}"
)));
}
}
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CapsuleManifest {
pub identity: CapsuleIdentity,
pub version: String,
pub build_digest: String,
pub interface: CapsuleInterface,
pub effects: BTreeSet<Effect>,
pub capabilities: BTreeSet<CapabilityGrant>,
#[serde(default, skip_serializing_if = "ResourceBudget::is_empty")]
pub budget: ResourceBudget,
}
impl ResourceBudget {
pub fn is_empty(&self) -> bool {
self.fuel.is_none()
&& self.max_memory_bytes.is_none()
&& self.wall_time_ms.is_none()
&& self.max_tokens.is_none()
&& self.max_cost_usd.is_none()
&& self.max_output_bytes.is_none()
}
}
pub fn derive_capsule_id(manifest: &CapsuleManifest) -> Result<CapsuleId> {
let canonical = manifest.canonicalized();
Ok(CapsuleId(sha256_hex(&serde_json::to_vec(&canonical)?)))
}
impl CapsuleManifest {
pub fn capsule_id(&self) -> Result<CapsuleId> {
derive_capsule_id(self)
}
fn canonicalized(&self) -> CapsuleManifest {
fn sorted(mut list: Vec<String>) -> Vec<String> {
list.sort();
list.dedup();
list
}
let interface = CapsuleInterface {
world: self.interface.world.clone(),
input_schema: self.interface.input_schema.as_ref().map(canonicalize_value),
output_schema: self
.interface
.output_schema
.as_ref()
.map(canonicalize_value),
};
let capabilities = self
.capabilities
.iter()
.map(|grant| match grant {
CapabilityGrant::Filesystem { paths, mode } => CapabilityGrant::Filesystem {
paths: sorted(paths.clone()),
mode: *mode,
},
CapabilityGrant::Network {
hosts,
protocols,
methods,
} => CapabilityGrant::Network {
hosts: sorted(hosts.clone()),
protocols: sorted(protocols.clone()),
methods: sorted(methods.clone()),
},
CapabilityGrant::Secret { handles } => CapabilityGrant::Secret {
handles: sorted(handles.clone()),
},
CapabilityGrant::Tool { tools } => CapabilityGrant::Tool {
tools: sorted(tools.clone()),
},
CapabilityGrant::Model { models } => CapabilityGrant::Model {
models: sorted(models.clone()),
},
CapabilityGrant::Clock => CapabilityGrant::Clock,
})
.collect();
CapsuleManifest {
identity: self.identity.clone(),
version: self.version.clone(),
build_digest: self.build_digest.clone(),
interface,
effects: self.effects.clone(),
capabilities,
budget: self.budget.clone(),
}
}
pub fn validate(&self) -> Result<()> {
validate_token("capsule name", &self.identity.name)?;
validate_token("capsule version", &self.version)?;
if !SUPPORTED_WORLDS.contains(&self.interface.world.as_str()) {
return Err(invalid(format!(
"unsupported WIT world `{}` (this release instantiates: {})",
self.interface.world,
SUPPORTED_WORLDS.join(", ")
)));
}
let digest_ok = self.build_digest.len() == 64
&& self
.build_digest
.chars()
.all(|c| c.is_ascii_hexdigit() && !c.is_ascii_uppercase());
if !digest_ok {
return Err(invalid(format!(
"build digest `{}` is not a lowercase hex SHA-256",
self.build_digest
)));
}
if self.effects.is_empty() {
return Err(invalid(
"declared effects are empty — even a pure-compute capsule declares `pure`",
));
}
for grant in &self.capabilities {
validate_grant(grant)?;
}
let declared_max = self.effects.iter().max().copied().unwrap_or(Effect::Pure);
let implied_max = self
.capabilities
.iter()
.map(CapabilityGrant::implied_effect)
.max()
.unwrap_or(Effect::Pure);
if declared_max < implied_max {
return Err(invalid(format!(
"declared effects top out at {declared_max:?} but the capability grants imply \
{implied_max:?} — the declaration and the grants must agree"
)));
}
self.budget.validate()?;
Ok(())
}
}
fn validate_token(what: &str, value: &str) -> Result<()> {
let valid = !value.is_empty()
&& value.len() <= 128
&& value
.chars()
.all(|c| c.is_ascii_alphanumeric() || matches!(c, '_' | '-' | '.'));
if !valid {
return Err(invalid(format!(
"invalid {what} `{value}` (allowed: [A-Za-z0-9._-], 1..=128 chars)"
)));
}
Ok(())
}
fn validate_grant(grant: &CapabilityGrant) -> Result<()> {
fn non_empty<'a>(what: &str, list: &'a [String]) -> Result<&'a [String]> {
if list.is_empty() {
return Err(invalid(format!("{what}: the scope list is empty")));
}
Ok(list)
}
match grant {
CapabilityGrant::Filesystem { paths, .. } => {
for path in non_empty("filesystem grant", paths)? {
if !path.starts_with('/') || path.split('/').any(|seg| seg == "..") {
return Err(invalid(format!(
"filesystem grant path `{path}` must be absolute and free of `..`"
)));
}
}
}
CapabilityGrant::Network {
hosts,
protocols,
methods,
} => {
for host in non_empty("network grant hosts", hosts)? {
let valid = !host.is_empty()
&& host.len() <= 253
&& host
.chars()
.all(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '-'));
if !valid {
return Err(invalid(format!(
"network grant host `{host}` (allowed: [A-Za-z0-9.-], 1..=253 chars)"
)));
}
}
for protocol in non_empty("network grant protocols", protocols)? {
let valid =
!protocol.is_empty() && protocol.chars().all(|c| c.is_ascii_lowercase());
if !valid {
return Err(invalid(format!(
"network grant protocol `{protocol}` (lowercase ASCII, e.g. `https`)"
)));
}
}
for method in non_empty("network grant methods", methods)? {
let valid = !method.is_empty() && method.chars().all(|c| c.is_ascii_uppercase());
if !valid {
return Err(invalid(format!(
"network grant method `{method}` (uppercase ASCII, e.g. `GET`)"
)));
}
}
}
CapabilityGrant::Secret { handles } => {
for handle in non_empty("secret grant", handles)? {
validate_token("secret handle", handle)?;
}
}
CapabilityGrant::Tool { tools } => {
for tool in non_empty("tool grant", tools)? {
validate_token("tool name", tool)?;
}
}
CapabilityGrant::Model { models } => {
for model in non_empty("model grant", models)? {
validate_token("model name", model)?;
}
}
CapabilityGrant::Clock => {}
}
Ok(())
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CapsuleResolution {
pub name: String,
pub version: CapsuleVersion,
pub capsule_id: CapsuleId,
pub build_digest: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub policy_version: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub overlays: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub effective_grants: Option<BTreeSet<CapabilityGrant>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub clamped_budget: Option<ResourceBudget>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CapsuleUse {
pub capsule_id: CapsuleId,
pub capability: CapabilityKind,
pub operation: String,
pub request: Value,
pub response: Value,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CapsuleDenial {
pub capsule_id: CapsuleId,
pub capability: CapabilityKind,
pub absent_grant: CapabilityGrant,
pub detail: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub policy_version: Option<String>,
}
impl CapsuleDenial {
pub fn unscoped(
capsule_id: CapsuleId,
capability: CapabilityKind,
detail: impl Into<String>,
) -> Self {
let absent_grant = match capability {
CapabilityKind::Filesystem => CapabilityGrant::Filesystem {
paths: Vec::new(),
mode: FilesystemMode::Read,
},
CapabilityKind::Network => CapabilityGrant::Network {
hosts: Vec::new(),
protocols: Vec::new(),
methods: Vec::new(),
},
CapabilityKind::Secret => CapabilityGrant::Secret {
handles: Vec::new(),
},
CapabilityKind::Tool => CapabilityGrant::Tool { tools: Vec::new() },
CapabilityKind::Model => CapabilityGrant::Model { models: Vec::new() },
CapabilityKind::Clock => CapabilityGrant::Clock,
};
Self {
capsule_id,
capability,
absent_grant,
detail: detail.into(),
policy_version: None,
}
}
pub fn scoped(
capsule_id: CapsuleId,
absent_grant: CapabilityGrant,
detail: impl Into<String>,
) -> Self {
Self {
capsule_id,
capability: absent_grant.capability_kind(),
absent_grant,
detail: detail.into(),
policy_version: None,
}
}
pub fn with_policy_version(mut self, version: impl Into<String>) -> Self {
self.policy_version = Some(version.into());
self
}
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
fn manifest() -> CapsuleManifest {
CapsuleManifest {
identity: CapsuleIdentity {
name: "researcher".into(),
description: None,
},
version: "1.4.0".into(),
build_digest: sha256_hex(b"component-bytes"),
interface: CapsuleInterface {
world: WORLD_V1.into(),
input_schema: None,
output_schema: None,
},
effects: BTreeSet::from([Effect::ReadOnly]),
capabilities: BTreeSet::new(),
budget: ResourceBudget::default(),
}
}
#[test]
fn content_address_converges_and_detects_tampering() {
let id_a = derive_capsule_id(&manifest()).unwrap();
let mut reordered = manifest();
reordered.capabilities.insert(CapabilityGrant::Network {
hosts: vec!["b.example".into(), "a.example".into()],
protocols: vec!["https".into()],
methods: vec!["GET".into()],
});
reordered.effects.insert(Effect::NonIdempotent);
let mut same = reordered.clone();
same.capabilities.insert(CapabilityGrant::Network {
hosts: vec!["a.example".into(), "b.example".into(), "a.example".into()],
protocols: vec!["https".into()],
methods: vec!["GET".into()],
});
assert_eq!(
derive_capsule_id(&reordered).unwrap(),
derive_capsule_id(&same).unwrap()
);
let mut tampered = manifest();
tampered.version = "9.9.9".into();
assert_ne!(derive_capsule_id(&tampered).unwrap(), id_a);
}
#[test]
fn validation_rejects_grants_above_declared_effects() {
let mut m = manifest();
m.capabilities.insert(CapabilityGrant::Tool {
tools: vec!["search".into()],
});
let err = m.validate().unwrap_err();
assert!(err.to_string().contains("must agree"), "got: {err}");
m.effects.insert(Effect::NonIdempotent);
m.validate().unwrap();
}
#[test]
fn validation_rejects_empty_effects_and_bad_worlds() {
let mut m = manifest();
m.effects.clear();
assert!(m.validate().is_err());
let mut m = manifest();
m.interface.world = "rusty:capsule/world@9.9.9".into();
assert!(m.validate().is_err());
let mut m = manifest();
m.build_digest = "DEADBEEF".into();
assert!(m.validate().is_err());
}
#[test]
fn network_matching_is_exact_and_scoped() {
let grants = [CapabilityGrant::Network {
hosts: vec!["api.example".into()],
protocols: vec!["https".into()],
methods: vec!["GET".into()],
}];
assert!(network_grant_covers(&grants, "https", "api.example", "GET"));
assert!(!network_grant_covers(
&grants,
"https",
"evil.example",
"GET"
));
assert!(!network_grant_covers(&grants, "http", "api.example", "GET"));
assert!(!network_grant_covers(
&grants,
"https",
"api.example",
"POST"
));
assert!(any_grant_of_kind(&grants, CapabilityKind::Network));
assert!(!any_grant_of_kind(&grants, CapabilityKind::Clock));
}
#[test]
fn budget_clamp_takes_the_field_wise_minimum() {
let declared = ResourceBudget {
fuel: Some(100),
wall_time_ms: Some(5000),
..Default::default()
};
let ceiling = ResourceBudget {
fuel: Some(50),
max_output_bytes: Some(1024),
..Default::default()
};
let clamped = declared.clamp(&ceiling);
assert_eq!(clamped.fuel, Some(50));
assert_eq!(clamped.wall_time_ms, Some(5000));
assert_eq!(clamped.max_output_bytes, Some(1024));
assert!(clamped.max_memory_bytes.is_none());
}
#[test]
fn denial_payloads_name_the_absent_grant() {
let id = CapsuleId::from("ab".repeat(32));
let structural = CapsuleDenial::unscoped(id.clone(), CapabilityKind::Network, "probe");
assert_eq!(structural.capability, CapabilityKind::Network);
match &structural.absent_grant {
CapabilityGrant::Network { hosts, .. } => assert!(hosts.is_empty()),
other => panic!("expected network grant, got {other:?}"),
}
let scoped = CapsuleDenial::scoped(
id,
CapabilityGrant::Network {
hosts: vec!["evil.example".into()],
protocols: vec!["https".into()],
methods: vec!["GET".into()],
},
"granted api.example, attempted evil.example",
);
assert_eq!(scoped.capability, CapabilityKind::Network);
let value = serde_json::to_value(&scoped).unwrap();
assert_eq!(value["absent_grant"]["hosts"], json!(["evil.example"]));
assert!(value.get("policy_version").is_none());
let pinned = scoped.with_policy_version("cedar-0123456789ab");
let value = serde_json::to_value(&pinned).unwrap();
assert_eq!(
value["policy_version"],
json!("cedar-0123456789ab"),
"authorization refusals pin the deciding policy version"
);
}
#[test]
fn intersection_is_pairwise_and_cannot_widen() {
let net = |hosts: &[&str]| CapabilityGrant::Network {
hosts: hosts.iter().map(|h| h.to_string()).collect(),
protocols: vec!["https".into()],
methods: vec!["GET".into()],
};
let manifest = BTreeSet::from([net(&["a.example", "b.example"]), CapabilityGrant::Clock]);
let overlay = BTreeSet::from([net(&["b.example", "evil.example"])]);
let effective = intersect_grants(&manifest, &overlay);
assert_eq!(effective, BTreeSet::from([net(&["b.example"])]));
for grant in &effective {
match grant {
CapabilityGrant::Network {
hosts,
protocols,
methods,
} => {
assert!(hosts.iter().all(|h| ["b.example"].contains(&h.as_str())));
assert_eq!(protocols, &vec!["https".to_string()]);
assert_eq!(methods, &vec!["GET".to_string()]);
}
other => panic!("unexpected grant survived: {other:?}"),
}
}
let disjoint = BTreeSet::from([net(&["c.example"])]);
assert!(intersect_grants(&manifest, &disjoint).is_empty());
assert!(intersect_grants(
&BTreeSet::from([CapabilityGrant::Clock]),
&BTreeSet::from([net(&["a.example"])]),
)
.is_empty());
}
#[test]
fn intersection_combines_scope_fields_and_modes() {
let manifest = BTreeSet::from([CapabilityGrant::Filesystem {
paths: vec!["/data".into(), "/tmp".into()],
mode: FilesystemMode::ReadWrite,
}]);
let overlay = BTreeSet::from([CapabilityGrant::Filesystem {
paths: vec!["/data".into()],
mode: FilesystemMode::Read,
}]);
let effective = intersect_grants(&manifest, &overlay);
assert_eq!(
effective,
BTreeSet::from([CapabilityGrant::Filesystem {
paths: vec!["/data".into()],
mode: FilesystemMode::Read,
}])
);
let manifest = BTreeSet::from([CapabilityGrant::Network {
hosts: vec!["a.example".into()],
protocols: vec!["https".into()],
methods: vec!["POST".into()],
}]);
let overlay = BTreeSet::from([CapabilityGrant::Network {
hosts: vec!["a.example".into()],
protocols: vec!["https".into()],
methods: vec!["GET".into()],
}]);
assert!(intersect_grants(&manifest, &overlay).is_empty());
}
#[test]
fn grants_beyond_flags_only_uncovered_reach() {
let net = |hosts: &[&str], methods: &[&str]| CapabilityGrant::Network {
hosts: hosts.iter().map(|h| h.to_string()).collect(),
protocols: vec!["https".into()],
methods: methods.iter().map(|m| m.to_string()).collect(),
};
let manifest = BTreeSet::from([net(&["a.example"], &["GET"]), CapabilityGrant::Clock]);
let manifest = manifest
.into_iter()
.chain([net(&["b.example"], &["GET"])])
.collect();
let within = BTreeSet::from([net(&["a.example", "b.example"], &["GET"])]);
assert!(grants_beyond(&within, &manifest).is_empty());
let beyond = BTreeSet::from([
net(&["a.example", "evil.example"], &["GET"]),
net(&["a.example"], &["POST"]),
CapabilityGrant::Secret {
handles: vec!["api-key".into()],
},
]);
let flagged = grants_beyond(&beyond, &manifest);
assert_eq!(flagged.len(), 3);
let covered = BTreeSet::from([CapabilityGrant::Clock, net(&["a.example"], &["GET"])]);
assert!(grants_beyond(&covered, &manifest).is_empty());
}
#[test]
fn overlay_validation_and_targeting() {
let overlay = CapsuleOverlay {
name: "narrow-research".into(),
targets: Some(vec!["researcher".into()]),
capabilities: BTreeSet::from([CapabilityGrant::Clock]),
note: None,
};
overlay.validate().unwrap();
assert!(overlay.applies_to("researcher"));
assert!(!overlay.applies_to("planner"));
let tenant_wide = CapsuleOverlay {
name: "tenant-wide".into(),
targets: None,
capabilities: BTreeSet::from([CapabilityGrant::Clock]),
note: None,
};
tenant_wide.validate().unwrap();
assert!(tenant_wide.applies_to("anything"));
let mut bad = tenant_wide.clone();
bad.targets = Some(Vec::new());
assert!(bad.validate().is_err());
let mut bad = tenant_wide.clone();
bad.capabilities = BTreeSet::from([CapabilityGrant::Secret {
handles: Vec::new(),
}]);
assert!(bad.validate().is_err());
let mut bad = tenant_wide;
bad.name = "has/slash".into();
assert!(bad.validate().is_err());
}
}