use super::PolicyError;
use serde::{Deserialize, Serialize};
use stateknot_core::{
BoundedJson, BudgetLimits, CapabilityIdentity, Digest, PrincipalIdentity, RunId,
SchemaReference, ScopeSet, TenantId, Timestamp,
};
#[derive(Clone, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub struct SubmissionRule {
pub tenant: TenantId,
pub principal: PrincipalIdentity,
pub agent: CapabilityIdentity,
pub input_schema: SchemaReference,
pub granted_scopes: ScopeSet,
pub budget_limits: BudgetLimits,
}
#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum RunPermission {
Read,
Cancel,
}
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(
tag = "kind",
content = "value",
rename_all = "snake_case",
deny_unknown_fields
)]
pub enum RunAccessTarget {
Run(RunId),
Submission(Digest),
TenantRuns,
}
#[derive(Clone, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub struct RunRule {
pub tenant: TenantId,
pub principal: PrincipalIdentity,
pub operation: RunPermission,
pub target: RunAccessTarget,
}
#[derive(Clone, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub struct PolicyDocument {
pub format_version: u16,
pub policy: CapabilityIdentity,
pub valid_until: Timestamp,
pub submissions: Vec<SubmissionRule>,
pub runs: Vec<RunRule>,
}
#[derive(Clone)]
pub struct PolicyArtifact {
pub(super) document: PolicyDocument,
canonical: Vec<u8>,
digest: Digest,
pub(super) submissions: Vec<Digest>,
pub(super) runs: Vec<Digest>,
}
impl PolicyArtifact {
pub const MAX_RULES: usize = 1024;
pub fn new(document: PolicyDocument) -> Result<Self, PolicyError> {
if document.format_version != 1
|| document
.submissions
.len()
.saturating_add(document.runs.len())
> Self::MAX_RULES
{
return Err(PolicyError);
}
let value = serde_json::to_value(&document).map_err(|_| PolicyError)?;
BoundedJson::try_from_value(value).map_err(|_| PolicyError)?;
for (i, rule) in document.submissions.iter().enumerate() {
if rule.budget_limits.is_empty()
|| document.submissions[..i].iter().any(|old| {
old.tenant == rule.tenant
&& old.principal == rule.principal
&& old.agent == rule.agent
&& old.input_schema == rule.input_schema
})
{
return Err(PolicyError);
}
}
for (i, rule) in document.runs.iter().enumerate() {
if document.runs[..i].iter().any(|old| {
old.tenant == rule.tenant
&& old.principal == rule.principal
&& old.operation == rule.operation
&& (old.target == rule.target
|| old.target == RunAccessTarget::TenantRuns
|| rule.target == RunAccessTarget::TenantRuns)
}) {
return Err(PolicyError);
}
if rule.operation == RunPermission::Cancel
&& matches!(rule.target, RunAccessTarget::Submission(_))
{
return Err(PolicyError);
}
}
let canonical = serde_json_canonicalizer::to_vec(&document).map_err(|_| PolicyError)?;
let digest = Digest::sha256(&canonical);
let submissions = document
.submissions
.iter()
.map(|rule| {
checksum(
b"stateknot.agent-policy-submission-rule.v1\0",
&(&document.policy, rule),
)
})
.collect::<Result<_, _>>()?;
let runs = document
.runs
.iter()
.map(|rule| {
checksum(
b"stateknot.agent-policy-run-rule.v1\0",
&(&document.policy, rule),
)
})
.collect::<Result<_, _>>()?;
Ok(Self {
document,
canonical,
digest,
submissions,
runs,
})
}
pub fn from_json(bytes: &[u8], expected: Digest) -> Result<Self, PolicyError> {
let bounded = BoundedJson::from_slice(bytes).map_err(|_| PolicyError)?;
let document = serde_json::from_value(bounded.into_value()).map_err(|_| PolicyError)?;
let artifact = Self::new(document)?;
if artifact.digest != expected {
return Err(PolicyError);
}
Ok(artifact)
}
#[must_use]
pub const fn digest(&self) -> Digest {
self.digest
}
#[must_use]
pub fn canonical_bytes(&self) -> &[u8] {
&self.canonical
}
}
pub(super) fn checksum(domain: &[u8], value: &impl Serialize) -> Result<Digest, PolicyError> {
let mut bytes = domain.to_vec();
bytes.extend(serde_json_canonicalizer::to_vec(value).map_err(|_| PolicyError)?);
Ok(Digest::sha256(bytes))
}