kz-server 0.1.0

JWT verification, CEL policies, and HTTP/MCP server for keyzero
Documentation
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::path::Path;

use crate::error::Result;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Bundle {
    pub version: String,
    pub issuers: Vec<Issuer>,
    pub tag_mappings: Vec<TagMapping>,
    pub policies: Vec<Policy>,
    pub resources: Vec<Resource>,
    pub backends: HashMap<String, BackendConfig>,
}

impl Bundle {
    pub fn load(path: &Path) -> Result<Self> {
        let contents = std::fs::read_to_string(path)?;
        let bundle: Bundle = serde_yaml::from_str(&contents)?;
        Ok(bundle)
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Issuer {
    pub name: String,
    pub issuer_url: String,
    #[serde(default)]
    pub jwks_url: Option<String>,
    #[serde(default)]
    pub audience: Option<String>,
    #[serde(default)]
    pub static_keys: Option<Vec<StaticKey>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StaticKey {
    pub kid: String,
    pub alg: String,
    pub pem: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TagMapping {
    #[serde(rename = "match")]
    pub match_rule: TagMatchRule,
    pub tags: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TagMatchRule {
    pub issuer: String,
    #[serde(default)]
    pub claims: HashMap<String, String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Policy {
    pub name: String,
    #[serde(default)]
    pub description: Option<String>,
    #[serde(default, rename = "match")]
    pub match_rule: Option<PolicyMatchRule>,
    pub rule: String,
    pub effect: Effect,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PolicyMatchRule {
    #[serde(default)]
    pub resource_tags: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum Effect {
    Allow,
    Deny,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Resource {
    pub id: String,
    pub tags: Vec<String>,
    pub resolvers: Vec<ResolverConfig>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ResolverConfig {
    pub name: String,
    pub mode: ResolverMode,
    pub backend: String,
    #[serde(default)]
    pub path: Option<String>,
    #[serde(default)]
    pub field: Option<String>,
    #[serde(default)]
    pub role_arn: Option<String>,
    #[serde(default)]
    pub duration_seconds: Option<u64>,
    #[serde(default)]
    pub secret_id: Option<String>,
    #[serde(default)]
    pub credential_location: Option<String>,
    #[serde(default)]
    pub ttl: Option<u64>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum ResolverMode {
    Direct,
    ShortLived,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BackendConfig {
    #[serde(rename = "type")]
    pub backend_type: String,
    #[serde(default)]
    pub address: Option<String>,
    #[serde(default)]
    pub auth: Option<BackendAuth>,
    #[serde(default)]
    pub region: Option<String>,
    #[serde(default)]
    pub path: Option<String>,
    #[serde(default)]
    pub vault: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BackendAuth {
    pub method: String,
    #[serde(default)]
    pub role: Option<String>,
}