kz-server 0.1.0

JWT verification, CEL policies, and HTTP/MCP server for keyzero
Documentation
use super::{ResolvedSecret, SecretResolver};
use crate::config::{BackendConfig, ResolverConfig};
use crate::error::{AgentError, Result};
use async_trait::async_trait;

pub struct AwsStsResolver {
    client: aws_sdk_sts::Client,
}

impl AwsStsResolver {
    pub async fn new(config: &BackendConfig) -> Self {
        let mut builder = aws_config::from_env();
        if let Some(region) = &config.region {
            builder = builder.region(aws_config::Region::new(region.clone()));
        }
        let aws_config = builder.load().await;
        Self {
            client: aws_sdk_sts::Client::new(&aws_config),
        }
    }
}

#[async_trait]
impl SecretResolver for AwsStsResolver {
    async fn resolve(&self, config: &ResolverConfig) -> Result<ResolvedSecret> {
        let role_arn = config
            .role_arn
            .as_ref()
            .ok_or_else(|| AgentError::SecretResolution("aws_sts requires 'role_arn'".into()))?;
        let duration = config.duration_seconds.unwrap_or(900) as i32;

        let response = self
            .client
            .assume_role()
            .role_arn(role_arn)
            .role_session_name("kzagent")
            .duration_seconds(duration)
            .send()
            .await
            .map_err(|e| AgentError::SecretResolution(format!("STS error: {e}")))?;

        let creds = response
            .credentials()
            .ok_or_else(|| AgentError::SecretResolution("STS returned no credentials".into()))?;

        let value = serde_json::json!({
            "access_key_id": creds.access_key_id(),
            "secret_access_key": creds.secret_access_key(),
            "session_token": creds.session_token(),
        })
        .to_string();

        Ok(ResolvedSecret {
            value,
            ttl: Some(duration as u64),
        })
    }
}