use std::collections::HashMap;
use std::sync::Arc;
use serde::{Deserialize, Serialize};
use crate::cel::{PolicyDecision, PolicyEngine, PolicyInput};
use crate::config::{Bundle, ResolverMode};
use crate::error::{AgentError, Result};
use crate::jwt::JwtVerifier;
use crate::resolver;
use crate::resolver::SecretResolver;
use crate::signing::KeyzeroSigner;
use crate::tags::TagMapper;
#[derive(Debug, Deserialize)]
pub struct ResolveRequest {
pub resource: String,
}
#[derive(Debug, Serialize)]
pub struct SecretEntry {
pub mode: String,
#[serde(skip_serializing_if = "String::is_empty")]
pub value: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub ttl: Option<u64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub token: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub proxy: Option<String>,
}
#[derive(Debug, Serialize)]
pub struct ResolveResponse {
pub allowed: bool,
pub resource: String,
pub policy: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub reason: Option<String>,
#[serde(skip_serializing_if = "HashMap::is_empty")]
pub secrets: HashMap<String, SecretEntry>,
}
pub struct Pipeline {
bundle: Bundle,
jwt_verifier: JwtVerifier,
tag_mapper: TagMapper,
policy_engine: PolicyEngine,
resolvers: HashMap<String, Arc<dyn SecretResolver>>,
signer: Option<KeyzeroSigner>,
proxy_url: Option<String>,
}
impl Pipeline {
pub async fn new(bundle: Bundle) -> Result<Self> {
let jwt_verifier = JwtVerifier::new(bundle.issuers.clone());
let tag_mapper = TagMapper::new(bundle.tag_mappings.clone());
let policy_engine = PolicyEngine::new(bundle.policies.clone())?;
let mut resolvers: HashMap<String, Arc<dyn SecretResolver>> = HashMap::new();
for (name, backend_config) in &bundle.backends {
let resolver: Arc<dyn SecretResolver> = match backend_config.backend_type.as_str() {
"env_file" => Arc::new(resolver::env::EnvFileResolver::new(backend_config)?),
"hashicorp_vault" => {
let token = std::env::var("VAULT_TOKEN").ok();
Arc::new(resolver::vault::VaultResolver::new(backend_config, token)?)
}
"aws_secrets_manager" => {
Arc::new(resolver::aws_sm::AwsSmResolver::new(backend_config).await)
}
"aws_sts" => Arc::new(resolver::aws_sts::AwsStsResolver::new(backend_config).await),
"onepassword_cli" => Arc::new(resolver::onepassword::OnePasswordResolver::new(
backend_config,
)),
other => {
tracing::warn!("Unknown backend type '{other}', skipping");
continue;
}
};
resolvers.insert(name.clone(), resolver);
}
let signer = std::env::var("KZAGENT_SIGNING_KEY_PATH")
.ok()
.and_then(|path| std::fs::read(&path).ok())
.and_then(|key| KeyzeroSigner::new(&key, "kzagent").ok());
let proxy_url = std::env::var("KZAGENT_PROXY_URL").ok();
Ok(Self {
bundle,
jwt_verifier,
tag_mapper,
policy_engine,
resolvers,
signer,
proxy_url,
})
}
pub async fn resolve(&self, token: &str, request: &ResolveRequest) -> Result<ResolveResponse> {
let resource = self
.bundle
.resources
.iter()
.find(|r| r.id == request.resource)
.ok_or_else(|| AgentError::UnknownResource(request.resource.clone()))?;
let verified_claims = self.jwt_verifier.verify(token).await?;
let caller_tags = self.tag_mapper.map(&verified_claims);
let decision = self.policy_engine.evaluate(&PolicyInput {
caller_tags,
resource_tags: resource.tags.clone(),
claims: verified_claims.claims,
});
match decision {
PolicyDecision::Deny { policy, reason } => Ok(ResolveResponse {
allowed: false,
resource: request.resource.clone(),
policy,
reason: Some(reason),
secrets: HashMap::new(),
}),
PolicyDecision::Allow { policy } => {
let mut secrets = HashMap::new();
for resolver_config in &resource.resolvers {
match resolver_config.mode {
ResolverMode::Direct => {
let backend =
self.resolvers
.get(&resolver_config.backend)
.ok_or_else(|| {
AgentError::SecretResolution(format!(
"backend '{}' not found for resolver '{}'",
resolver_config.backend, resolver_config.name
))
})?;
let resolved = backend.resolve(resolver_config).await?;
secrets.insert(
resolver_config.name.clone(),
SecretEntry {
mode: "direct".into(),
value: resolved.value,
ttl: resolved.ttl,
token: None,
proxy: None,
},
);
}
ResolverMode::ShortLived => {
if let Some(signer) = &self.signer {
let ttl = resolver_config.ttl.unwrap_or(300);
let token = signer.sign_short_lived(
&request.resource,
&resolver_config.name,
ttl,
)?;
secrets.insert(
resolver_config.name.clone(),
SecretEntry {
mode: "short_lived".into(),
value: String::new(),
ttl: Some(ttl),
token: Some(token),
proxy: self.proxy_url.clone(),
},
);
} else {
return Err(AgentError::Config(
"short_lived mode requires KZAGENT_SIGNING_KEY_PATH".into(),
));
}
}
}
}
Ok(ResolveResponse {
allowed: true,
resource: request.resource.clone(),
policy,
reason: None,
secrets,
})
}
}
}
pub async fn resolve_single(
&self,
token: &str,
resource_id: &str,
resolver_name: &str,
) -> Result<(String, crate::config::ResolverConfig)> {
let resource = self
.bundle
.resources
.iter()
.find(|r| r.id == resource_id)
.ok_or_else(|| AgentError::UnknownResource(resource_id.into()))?;
let verified_claims = self.jwt_verifier.verify(token).await?;
let caller_tags = self.tag_mapper.map(&verified_claims);
let decision = self.policy_engine.evaluate(&crate::cel::PolicyInput {
caller_tags,
resource_tags: resource.tags.clone(),
claims: verified_claims.claims,
});
match decision {
crate::cel::PolicyDecision::Deny { policy, reason } => Err(
AgentError::SecretResolution(format!("denied by policy '{policy}': {reason}")),
),
crate::cel::PolicyDecision::Allow { .. } => {
let resolver_config = resource
.resolvers
.iter()
.find(|r| r.name == resolver_name)
.ok_or_else(|| {
AgentError::Config(format!(
"resolver '{resolver_name}' not found on resource '{resource_id}'"
))
})?;
let backend = self
.resolvers
.get(&resolver_config.backend)
.ok_or_else(|| {
AgentError::SecretResolution(format!(
"backend '{}' not found",
resolver_config.backend
))
})?;
let resolved = backend.resolve(resolver_config).await?;
Ok((resolved.value, resolver_config.clone()))
}
}
}
pub fn into_resolvers(self) -> HashMap<String, Arc<dyn SecretResolver>> {
self.resolvers
}
}