kz-server 0.1.0

JWT verification, CEL policies, and HTTP/MCP server for keyzero
Documentation
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;

/// A request to resolve secrets for a given resource.
#[derive(Debug, Deserialize)]
pub struct ResolveRequest {
    pub resource: String,
}

/// A single secret entry in the resolve response.
#[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>,
}

/// The response from a resolve request.
#[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>,
}

/// The Pipeline wires together JWT verification, tag mapping, CEL policy
/// evaluation, and secret resolution into a single resolve flow.
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 {
    /// Create a new Pipeline from a Bundle.
    ///
    /// 1. Creates a JwtVerifier from bundle.issuers
    /// 2. Creates a TagMapper from bundle.tag_mappings
    /// 3. Creates a PolicyEngine from bundle.policies (can fail if CEL compilation fails)
    /// 4. Creates resolver instances for each backend in bundle.backends
    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,
        })
    }

    /// Resolve secrets for a given resource, performing the full pipeline:
    ///
    /// 1. Find resource by id (or error UnknownResource)
    /// 2. Verify JWT
    /// 3. Map claims to tags
    /// 4. Evaluate policy
    /// 5. If denied: return ResolveResponse with allowed=false
    /// 6. If allowed: resolve all Direct mode resolvers, return with allowed=true
    pub async fn resolve(&self, token: &str, request: &ResolveRequest) -> Result<ResolveResponse> {
        // Step 1: Find the resource
        let resource = self
            .bundle
            .resources
            .iter()
            .find(|r| r.id == request.resource)
            .ok_or_else(|| AgentError::UnknownResource(request.resource.clone()))?;

        // Step 2: Verify JWT
        let verified_claims = self.jwt_verifier.verify(token).await?;

        // Step 3: Map claims to caller tags
        let caller_tags = self.tag_mapper.map(&verified_claims);

        // Step 4: Evaluate policy
        let decision = self.policy_engine.evaluate(&PolicyInput {
            caller_tags,
            resource_tags: resource.tags.clone(),
            claims: verified_claims.claims,
        });

        // Step 5/6: Build response based on decision
        match decision {
            PolicyDecision::Deny { policy, reason } => Ok(ResolveResponse {
                allowed: false,
                resource: request.resource.clone(),
                policy,
                reason: Some(reason),
                secrets: HashMap::new(),
            }),
            PolicyDecision::Allow { policy } => {
                // Resolve all resolvers based on their mode
                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,
                })
            }
        }
    }

    /// Resolve a single secret for a specific resolver on a resource,
    /// after verifying JWT and evaluating policy. Used by the MCP fetch tool.
    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()))
            }
        }
    }

    /// Consume the pipeline and return its resolver map.
    /// Used by the proxy mode to reuse the same resolver instances.
    pub fn into_resolvers(self) -> HashMap<String, Arc<dyn SecretResolver>> {
        self.resolvers
    }
}