kz-server 0.3.0

JWT verification, CEL policies, and HTTP/MCP server for keyzero
Documentation
use std::collections::HashMap;
use std::sync::Arc;

use async_trait::async_trait;
use axum::body::Body;
use axum::http::{Request, StatusCode};
use jsonwebtoken::{encode, Algorithm, EncodingKey, Header};
use kz_server::config::Bundle;
use kz_server::proxy::build_proxy_router;
use kz_server::signing::ProxyClaims;
use serde_json::Value;
use tower::ServiceExt;

mod common;

// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------

fn now_secs_i64() -> i64 {
    chrono::Utc::now().timestamp()
}

fn sign_proxy_token(resource: &str, resolver: &str, exp: i64) -> String {
    let priv_key = common::load_private_key();
    let claims = ProxyClaims {
        iss: "keyzero".into(),
        aud: "keyzero-proxy".into(),
        iat: now_secs_i64(),
        exp,
        resource: resource.into(),
        resolver: resolver.into(),
    };
    let header = Header::new(Algorithm::RS256);
    let encoding_key = EncodingKey::from_rsa_pem(&priv_key).expect("encoding key from PEM");
    encode(&header, &claims, &encoding_key).expect("sign proxy JWT")
}

fn minimal_bundle_yaml() -> String {
    r#"
version: "1"
resources:
  - ref: "secret/**"
    resolver: fixed
    credential_location: "header:Authorization:Bearer"
backends:
  fixed:
    type: env_file
    path: "/dev/null"
"#
    .to_string()
}

struct FixedResolver(String);

#[async_trait]
impl secret_resolvers::SecretResolver for FixedResolver {
    async fn resolve(
        &self,
        _req: &secret_resolvers::Request,
    ) -> secret_resolvers::Result<secret_resolvers::ResolvedSecret> {
        Ok(secret_resolvers::ResolvedSecret::new(self.0.clone()))
    }
}

fn make_resolvers(secret: &str) -> HashMap<String, Arc<dyn secret_resolvers::SecretResolver>> {
    let mut map: HashMap<String, Arc<dyn secret_resolvers::SecretResolver>> = HashMap::new();
    map.insert("fixed".into(), Arc::new(FixedResolver(secret.into())));
    map
}

async fn parse_body(resp: axum::http::Response<Body>) -> Value {
    let bytes = axum::body::to_bytes(resp.into_body(), 1024 * 1024)
        .await
        .unwrap();
    serde_json::from_slice(&bytes).unwrap_or_default()
}

// ---------------------------------------------------------------------------
// Tests
// ---------------------------------------------------------------------------

#[tokio::test]
async fn test_proxy_rejects_missing_auth() {
    let bundle: Bundle = serde_yaml::from_str(&minimal_bundle_yaml()).expect("parse bundle");
    let public_key = common::load_public_key();
    let resolvers = make_resolvers("unused");

    let router = build_proxy_router(bundle, &public_key, resolvers).expect("build proxy router");

    let req = Request::builder()
        .method("GET")
        .uri("https://api.example.com/data")
        .body(Body::empty())
        .unwrap();

    let resp = router.oneshot(req).await.unwrap();
    assert_eq!(resp.status(), StatusCode::UNAUTHORIZED);

    let body = parse_body(resp).await;
    assert!(body["error"].as_str().unwrap_or("").contains("missing"));
}

#[tokio::test]
async fn test_proxy_rejects_expired_jwt() {
    let bundle: Bundle = serde_yaml::from_str(&minimal_bundle_yaml()).expect("parse bundle");
    let public_key = common::load_public_key();
    let resolvers = make_resolvers("unused");

    let router = build_proxy_router(bundle, &public_key, resolvers).expect("build proxy router");

    // Token expired 1 hour ago
    let token = sign_proxy_token("secret/MY_KEY", "fixed", now_secs_i64() - 3600);

    let req = Request::builder()
        .method("GET")
        .uri("https://api.example.com/data")
        .header("authorization", format!("Bearer {token}"))
        .body(Body::empty())
        .unwrap();

    let resp = router.oneshot(req).await.unwrap();
    assert_eq!(resp.status(), StatusCode::UNAUTHORIZED);
}

#[tokio::test]
async fn test_proxy_swaps_credential() {
    let bundle: Bundle = serde_yaml::from_str(&minimal_bundle_yaml()).expect("parse bundle");
    let public_key = common::load_public_key();
    let resolvers = make_resolvers("sk-real-secret");

    let router = build_proxy_router(bundle, &public_key, resolvers).expect("build proxy router");

    // Valid token expiring in 1 hour
    let token = sign_proxy_token("secret/MY_KEY", "fixed", now_secs_i64() + 3600);

    let req = Request::builder()
        .method("GET")
        .uri("https://api.example.com/data")
        .header("authorization", format!("Bearer {token}"))
        .header("host", "api.example.com")
        .body(Body::empty())
        .unwrap();

    let resp = router.oneshot(req).await.unwrap();
    // Should NOT be 401/403 — JWT was accepted and credential was resolved.
    // It will likely be 502 since there's no real upstream, but not an auth error.
    let status = resp.status();
    assert_ne!(status, StatusCode::UNAUTHORIZED);
    assert_ne!(status, StatusCode::FORBIDDEN);
}