kz-server 0.1.0

JWT verification, CEL policies, and HTTP/MCP server for keyzero
Documentation
use async_trait::async_trait;
use axum::body::Body;
use http::Request;
use kz_server::config::*;
use kz_server::proxy::build_proxy_router;
use kz_server::resolver::{ResolvedSecret, SecretResolver};
use kz_server::signing::KeyzeroSigner;
use std::collections::HashMap;
use std::sync::Arc;
use tower::ServiceExt; // for oneshot
use wiremock::matchers::{header, method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};

/// A simple test resolver that always returns a fixed secret value.
struct FixedResolver {
    value: String,
}

#[async_trait]
impl SecretResolver for FixedResolver {
    async fn resolve(&self, _config: &ResolverConfig) -> kz_server::error::Result<ResolvedSecret> {
        Ok(ResolvedSecret {
            value: self.value.clone(),
            ttl: None,
        })
    }
}

/// Create a test bundle that points to the given mock server URL.
fn test_bundle_for_proxy(mock_url: &str) -> Bundle {
    Bundle {
        version: "1".into(),
        issuers: vec![],
        tag_mappings: vec![],
        policies: vec![],
        resources: vec![Resource {
            id: "ai/openai".into(),
            tags: vec!["env:prod".into()],
            resolvers: vec![ResolverConfig {
                name: "api_key".into(),
                mode: ResolverMode::ShortLived,
                backend: "test_backend".into(),
                path: None,
                field: None,
                role_arn: None,
                duration_seconds: None,
                secret_id: None,
                credential_location: Some("header:Authorization:Bearer".into()),
                ttl: Some(300),
            }],
        }],
        backends: HashMap::from([(
            "test_backend".into(),
            BackendConfig {
                backend_type: "env_file".into(),
                address: Some(mock_url.into()),
                auth: None,
                region: None,
                path: None,
                vault: None,
            },
        )]),
    }
}

/// Helper: sign a keyzero JWT for the proxy
fn sign_proxy_jwt(resource: &str, resolver: &str) -> String {
    let private_pem = include_bytes!("fixtures/test_rsa_private.pem");
    let signer = KeyzeroSigner::new(private_pem, "kzagent").unwrap();
    signer.sign_short_lived(resource, resolver, 300).unwrap()
}

#[tokio::test]
async fn test_proxy_swaps_credentials_and_forwards() {
    // 1. Start a wiremock mock server as the "target API"
    let mock_server = MockServer::start().await;

    // Set up mock to expect the real credential (not the keyzero JWT)
    Mock::given(method("GET"))
        .and(path("/v1/chat/completions"))
        .and(header("authorization", "Bearer sk-real-secret-key-123"))
        .respond_with(
            ResponseTemplate::new(200)
                .set_body_json(serde_json::json!({"response": "hello from upstream"})),
        )
        .mount(&mock_server)
        .await;

    // 2. Create proxy router with test keys and a mock resolver
    let public_pem = include_bytes!("fixtures/test_rsa_public.pem");
    let bundle = test_bundle_for_proxy(&mock_server.uri());

    let resolvers: HashMap<String, Arc<dyn SecretResolver>> = HashMap::from([(
        "test_backend".into(),
        Arc::new(FixedResolver {
            value: "sk-real-secret-key-123".into(),
        }) as Arc<dyn SecretResolver>,
    )]);

    let app = build_proxy_router(bundle, public_pem, resolvers)
        .await
        .unwrap();

    // 3. Create a keyzero JWT
    let kz_token = sign_proxy_jwt("ai/openai", "api_key");

    // 4. Send a request through the proxy with the keyzero JWT
    // The proxy needs to know the target URL. We pass it as the full URI.
    let target_url = format!("{}/v1/chat/completions", mock_server.uri());
    let req = Request::builder()
        .method("GET")
        .uri(&target_url)
        .header("Authorization", format!("Bearer {kz_token}"))
        .header("Host", "api.openai.com")
        .body(Body::empty())
        .unwrap();

    let response = app.oneshot(req).await.unwrap();

    // 5. Assert the proxy returns the mock server's response
    assert_eq!(response.status(), http::StatusCode::OK);

    let body_bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
        .await
        .unwrap();
    let body: serde_json::Value = serde_json::from_slice(&body_bytes).unwrap();
    assert_eq!(body["response"], "hello from upstream");
}

#[tokio::test]
async fn test_proxy_rejects_missing_auth() {
    let public_pem = include_bytes!("fixtures/test_rsa_public.pem");
    let bundle = test_bundle_for_proxy("http://localhost:9999");

    let resolvers: HashMap<String, Arc<dyn SecretResolver>> = HashMap::new();
    let app = build_proxy_router(bundle, public_pem, resolvers)
        .await
        .unwrap();

    let req = Request::builder()
        .method("GET")
        .uri("http://localhost:9999/v1/test")
        .body(Body::empty())
        .unwrap();

    let response = app.oneshot(req).await.unwrap();
    assert_eq!(response.status(), http::StatusCode::UNAUTHORIZED);
}

#[tokio::test]
async fn test_proxy_rejects_invalid_jwt() {
    let public_pem = include_bytes!("fixtures/test_rsa_public.pem");
    let bundle = test_bundle_for_proxy("http://localhost:9999");

    let resolvers: HashMap<String, Arc<dyn SecretResolver>> = HashMap::new();
    let app = build_proxy_router(bundle, public_pem, resolvers)
        .await
        .unwrap();

    let req = Request::builder()
        .method("GET")
        .uri("http://localhost:9999/v1/test")
        .header("Authorization", "Bearer invalid.jwt.token")
        .body(Body::empty())
        .unwrap();

    let response = app.oneshot(req).await.unwrap();
    assert_eq!(response.status(), http::StatusCode::UNAUTHORIZED);
}

#[tokio::test]
async fn test_proxy_custom_credential_location() {
    // Test with a custom credential_location: header:X-API-Key:
    let mock_server = MockServer::start().await;

    Mock::given(method("POST"))
        .and(path("/api/generate"))
        .and(header("x-api-key", "real-api-key-456"))
        .respond_with(
            ResponseTemplate::new(200).set_body_json(serde_json::json!({"result": "generated"})),
        )
        .mount(&mock_server)
        .await;

    let public_pem = include_bytes!("fixtures/test_rsa_public.pem");

    // Bundle with custom credential_location
    let mut bundle = test_bundle_for_proxy(&mock_server.uri());
    bundle.resources[0].resolvers[0].credential_location = Some("header:X-API-Key:".into());

    let resolvers: HashMap<String, Arc<dyn SecretResolver>> = HashMap::from([(
        "test_backend".into(),
        Arc::new(FixedResolver {
            value: "real-api-key-456".into(),
        }) as Arc<dyn SecretResolver>,
    )]);

    let app = build_proxy_router(bundle, public_pem, resolvers)
        .await
        .unwrap();

    let kz_token = sign_proxy_jwt("ai/openai", "api_key");
    let target_url = format!("{}/api/generate", mock_server.uri());

    let req = Request::builder()
        .method("POST")
        .uri(&target_url)
        .header("Authorization", format!("Bearer {kz_token}"))
        .header("Content-Type", "application/json")
        .body(Body::from(r#"{"prompt": "hello"}"#))
        .unwrap();

    let response = app.oneshot(req).await.unwrap();
    assert_eq!(response.status(), http::StatusCode::OK);

    let body_bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
        .await
        .unwrap();
    let body: serde_json::Value = serde_json::from_slice(&body_bytes).unwrap();
    assert_eq!(body["result"], "generated");
}