kz-server 0.2.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 secrecy::ExposeSecret;

use crate::cel::{PolicyDecision, PolicyEngine, PolicyInput};
use crate::config::{BackendConfig, Bundle, ResolverMode};
use crate::error::{AgentError, Result};
use crate::auth::JwtVerifier;
use crate::signing::KeyzeroSigner;
use crate::tags::TagMapper;

const VAULT_TOKEN_ENV: &str = "VAULT_TOKEN";
const SIGNING_KEY_PATH_ENV: &str = "KEYZERO_SIGNING_KEY_PATH";
const PROXY_URL_ENV: &str = "KEYZERO_PROXY_URL";

/// Convert a server-side `ResolverConfig` into a resolvers-crate `Request`.
pub fn to_resolve_request(config: &crate::config::ResolverConfig) -> secret_resolvers::Request {
    let mut params = std::collections::HashMap::new();

    if let Some(ref path) = config.path {
        params.insert(secret_resolvers::params::REF.to_string(), toml::Value::String(path.clone()));
    }
    if let Some(ref field) = config.field {
        // For env_file: field is the lookup key (maps to "ref")
        // For other resolvers: field is an additional selector within the secret
        if config.path.is_none() && config.secret_id.is_none() && config.role_arn.is_none() {
            params.insert(secret_resolvers::params::REF.to_string(), toml::Value::String(field.clone()));
        } else {
            params.insert(secret_resolvers::params::FIELD.to_string(), toml::Value::String(field.clone()));
        }
    }
    if let Some(ref secret_id) = config.secret_id {
        params.insert(secret_resolvers::params::REF.to_string(), toml::Value::String(format!("sm://{}", secret_id)));
    }
    if let Some(ref role_arn) = config.role_arn {
        params.insert(secret_resolvers::params::REF.to_string(), toml::Value::String(role_arn.clone()));
    }
    if let Some(duration) = config.duration_seconds {
        params.insert(secret_resolvers::params::DURATION_SECONDS.to_string(), toml::Value::String(duration.to_string()));
    }

    secret_resolvers::Request::resolve(params)
}

/// Convert a `BackendConfig` into a generic `HashMap<String, toml::Value>` map.
///
/// This is useful for bridging between the server's typed config structs and
/// the standalone `kz-resolvers` crate which accepts `HashMap<String, toml::Value>`.
pub fn backend_to_config(backend: &BackendConfig) -> HashMap<String, toml::Value> {
    let mut config = HashMap::new();
    if let Some(ref addr) = backend.address {
        config.insert("address".to_string(), toml::Value::String(addr.clone()));
    }
    if let Some(ref region) = backend.region {
        config.insert("region".to_string(), toml::Value::String(region.clone()));
    }
    if let Some(ref path) = backend.path {
        config.insert("path".to_string(), toml::Value::String(path.clone()));
    }
    if let Some(ref vault) = backend.vault {
        config.insert("vault".to_string(), toml::Value::String(vault.clone()));
    }
    // Include VAULT_TOKEN from env if available
    if let Ok(token) = std::env::var(VAULT_TOKEN_ENV) {
        config.insert("token".to_string(), toml::Value::String(token));
    }
    config
}

/// 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 secret_resolvers::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 secret_resolvers::SecretResolver>> = HashMap::new();
        for (name, backend_config) in &bundle.backends {
            let config = backend_to_config(backend_config);
            let resolver = secret_resolvers::registry::create_resolver(
                backend_config.backend_type.as_resolver_name(), config,
            ).await.map_err(|e| AgentError::Config(format!("{} resolver: {e}", name)))?;
            resolvers.insert(name.clone(), resolver);
        }

        let signer = match std::env::var(SIGNING_KEY_PATH_ENV) {
            Ok(path) => match std::fs::read(&path) {
                Ok(key) => match KeyzeroSigner::new(&key, crate::signing::PROXY_JWT_ISSUER) {
                    Ok(s) => Some(s),
                    Err(e) => {
                        tracing::warn!(path = %path, error = %e, "KEYZERO_SIGNING_KEY_PATH is set but signer initialization failed");
                        None
                    }
                },
                Err(e) => {
                    tracing::warn!(path = %path, error = %e, "KEYZERO_SIGNING_KEY_PATH is set but key file could not be read");
                    None
                }
            },
            Err(_) => None,
        };

        let proxy_url = std::env::var(PROXY_URL_ENV).ok();

        Ok(Self {
            bundle,
            jwt_verifier,
            tag_mapper,
            policy_engine,
            resolvers,
            signer,
            proxy_url,
        })
    }

    /// Verify JWT, map claims to tags, and evaluate policy for a resource.
    /// Returns the policy decision or an error.
    async fn auth_and_authorize(
        &self,
        token: &str,
        resource: &crate::config::Resource,
    ) -> Result<PolicyDecision> {
        let verified_claims = self.jwt_verifier.verify(token).await?;
        let caller_tags = self.tag_mapper.map(&verified_claims);
        Ok(self.policy_engine.evaluate(&PolicyInput {
            caller_tags,
            resource_tags: resource.tags.clone(),
            claims: verified_claims.claims,
        }))
    }

    /// 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()))?;

        // Steps 2-4: Authenticate and authorize
        let decision = self.auth_and_authorize(token, resource).await?;

        // 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 request = to_resolve_request(resolver_config);
                            let resolved = backend.resolve(&request).await
                                .map_err(|e| AgentError::SecretResolution(e.to_string()))?;

                            secrets.insert(
                                resolver_config.name.clone(),
                                SecretEntry {
                                    mode: "direct".into(),
                                    value: resolved.value.expose_secret().to_string(),
                                    ttl: resolver_config.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(
                                    format!("short_lived mode requires {SIGNING_KEY_PATH_ENV}").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 decision = self.auth_and_authorize(token, resource).await?;

        match decision {
            PolicyDecision::Deny { policy, reason } => Err(
                AgentError::SecretResolution(format!("denied by policy '{policy}': {reason}")),
            ),
            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 request = to_resolve_request(resolver_config);
                let resolved = backend.resolve(&request).await
                    .map_err(|e| AgentError::SecretResolution(e.to_string()))?;
                Ok((resolved.value.expose_secret().to_string(), 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 secret_resolvers::SecretResolver>> {
        self.resolvers
    }
}