kz-server 0.2.0

JWT verification, CEL policies, and HTTP/MCP server for keyzero
Documentation
use axum::body::Body;
use http::Request;
use kz_server::config::*;
use kz_server::server::build_router;
use std::collections::HashMap;
use tower::ServiceExt; // for oneshot

/// Helper to send a request to the axum router and return status + body.
async fn axum_test_helper(
    app: &axum::Router,
    method: &str,
    path: &str,
    body: Option<String>,
    auth: Option<String>,
) -> (http::StatusCode, String) {
    let mut req = Request::builder().method(method).uri(path);
    if let Some(token) = auth {
        req = req.header("Authorization", format!("Bearer {token}"));
    }
    let body = body.map(Body::from).unwrap_or(Body::empty());
    let req = req
        .header("Content-Type", "application/json")
        .body(body)
        .unwrap();
    let response = app.clone().oneshot(req).await.unwrap();
    let status = response.status();
    let body_bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
        .await
        .unwrap();
    (status, String::from_utf8(body_bytes.to_vec()).unwrap())
}

/// Helper: create a test bundle with an env_file backend
fn test_bundle(env_path: &str) -> Bundle {
    Bundle {
        version: "1".into(),
        issuers: vec![Issuer {
            name: "test-issuer".into(),
            issuer_url: "https://test-issuer.example.com".into(),
            jwks_url: None,
            audience: Some("keyzero".into()),
            static_keys: Some(vec![StaticKey {
                kid: "test-key-01".into(),
                alg: "RS256".into(),
                pem: String::from_utf8(include_bytes!("fixtures/test_rsa_public.pem").to_vec())
                    .unwrap(),
            }]),
        }],
        tag_mappings: vec![TagMapping {
            match_rule: TagMatchRule {
                issuer: "test-issuer".into(),
                claims: HashMap::from([("repository".into(), "myorg/*".into())]),
            },
            tags: vec!["env:ci".into(), "team:platform".into()],
        }],
        policies: vec![
            Policy {
                name: "allow-ci".into(),
                description: Some("Allow CI".into()),
                match_rule: Some(PolicyMatchRule {
                    resource_tags: vec!["env:ci".into()],
                }),
                rule: "'env:ci' in caller_tags".into(),
                effect: Effect::Allow,
            },
            Policy {
                name: "default-deny".into(),
                description: None,
                match_rule: None,
                rule: "true".into(),
                effect: Effect::Deny,
            },
        ],
        resources: vec![Resource {
            id: "ci/api-key".into(),
            tags: vec!["env:ci".into(), "type:api".into()],
            resolvers: vec![ResolverConfig {
                name: "key".into(),
                mode: ResolverMode::Direct,
                backend: "local".into(),
                path: None,
                field: Some("API_KEY".into()),
                role_arn: None,
                duration_seconds: None,
                secret_id: None,
                credential_location: None,
                ttl: None,
            }],
        }],
        backends: HashMap::from([(
            "local".into(),
            BackendConfig {
                backend_type: BackendType::EnvFile,
                address: None,
                auth: None,
                region: None,
                path: Some(env_path.into()),
                vault: None,
            },
        )]),
    }
}

/// Helper: create a signed JWT for testing
fn make_test_jwt() -> String {
    use jsonwebtoken::{encode, Algorithm, EncodingKey, Header};
    let rsa_private = include_bytes!("fixtures/test_rsa_private.pem");
    let mut claims = std::collections::HashMap::new();
    claims.insert("sub", serde_json::json!("test-subject"));
    claims.insert("iss", serde_json::json!("https://test-issuer.example.com"));
    claims.insert("aud", serde_json::json!("keyzero"));
    claims.insert(
        "exp",
        serde_json::json!((chrono::Utc::now() + chrono::Duration::hours(1)).timestamp()),
    );
    claims.insert("repository", serde_json::json!("myorg/myrepo"));
    let mut header = Header::new(Algorithm::RS256);
    header.kid = Some("test-key-01".into());
    encode(
        &header,
        &claims,
        &EncodingKey::from_rsa_pem(rsa_private).unwrap(),
    )
    .unwrap()
}

#[tokio::test]
async fn test_healthz() {
    let dir = tempfile::tempdir().unwrap();
    let env_path = dir.path().join("secrets.env");
    std::fs::write(&env_path, "API_KEY=sk-test-123\n").unwrap();

    let bundle = test_bundle(env_path.to_str().unwrap());
    let app = build_router(bundle).await.unwrap();

    let (status, body) = axum_test_helper(&app, "GET", "/healthz", None, None).await;

    assert_eq!(status, http::StatusCode::OK);
    let json: serde_json::Value = serde_json::from_str(&body).unwrap();
    assert_eq!(json["status"], "ok");
    assert_eq!(json["bundle_loaded"], true);
}

#[tokio::test]
async fn test_resolve_endpoint_success() {
    let dir = tempfile::tempdir().unwrap();
    let env_path = dir.path().join("secrets.env");
    std::fs::write(&env_path, "API_KEY=sk-test-123\n").unwrap();

    let bundle = test_bundle(env_path.to_str().unwrap());
    let app = build_router(bundle).await.unwrap();

    let token = make_test_jwt();
    let body = serde_json::json!({"resource": "ci/api-key"}).to_string();

    let (status, response_body) =
        axum_test_helper(&app, "POST", "/v1/resolve", Some(body), Some(token)).await;

    assert_eq!(status, http::StatusCode::OK);
    let json: serde_json::Value = serde_json::from_str(&response_body).unwrap();
    assert_eq!(json["allowed"], true);
    assert_eq!(json["resource"], "ci/api-key");
    assert_eq!(json["secrets"]["key"]["value"], "sk-test-123");
}

#[tokio::test]
async fn test_resolve_endpoint_no_auth() {
    let dir = tempfile::tempdir().unwrap();
    let env_path = dir.path().join("secrets.env");
    std::fs::write(&env_path, "API_KEY=sk-test-123\n").unwrap();

    let bundle = test_bundle(env_path.to_str().unwrap());
    let app = build_router(bundle).await.unwrap();

    let body = serde_json::json!({"resource": "ci/api-key"}).to_string();

    let (status, response_body) = axum_test_helper(
        &app,
        "POST",
        "/v1/resolve",
        Some(body),
        None, // no auth header
    )
    .await;

    assert_eq!(status, http::StatusCode::UNAUTHORIZED);
    let json: serde_json::Value = serde_json::from_str(&response_body).unwrap();
    assert_eq!(json["error"], "invalid_token");
}

#[tokio::test]
async fn test_resolve_expired_jwt_returns_401() {
    let dir = tempfile::tempdir().unwrap();
    let env_path = dir.path().join("secrets.env");
    std::fs::write(&env_path, "API_KEY=sk-test-123\n").unwrap();

    let bundle = test_bundle(env_path.to_str().unwrap());
    let app = build_router(bundle).await.unwrap();

    // Create an expired JWT
    let rsa_private = include_bytes!("fixtures/test_rsa_private.pem");
    let mut claims = std::collections::HashMap::new();
    claims.insert("sub", serde_json::json!("test-subject"));
    claims.insert("iss", serde_json::json!("https://test-issuer.example.com"));
    claims.insert("aud", serde_json::json!("keyzero"));
    claims.insert(
        "exp",
        serde_json::json!((chrono::Utc::now() - chrono::Duration::hours(1)).timestamp()),
    );
    claims.insert("repository", serde_json::json!("myorg/myrepo"));
    let mut header = jsonwebtoken::Header::new(jsonwebtoken::Algorithm::RS256);
    header.kid = Some("test-key-01".into());
    let token = jsonwebtoken::encode(
        &header,
        &claims,
        &jsonwebtoken::EncodingKey::from_rsa_pem(rsa_private).unwrap(),
    )
    .unwrap();

    let body = serde_json::json!({"resource": "ci/api-key"}).to_string();
    let (status, _) =
        axum_test_helper(&app, "POST", "/v1/resolve", Some(body), Some(token)).await;

    assert_eq!(status, http::StatusCode::UNAUTHORIZED);
}

#[tokio::test]
async fn test_resolve_wrong_kid_returns_401() {
    let dir = tempfile::tempdir().unwrap();
    let env_path = dir.path().join("secrets.env");
    std::fs::write(&env_path, "API_KEY=sk-test-123\n").unwrap();

    let bundle = test_bundle(env_path.to_str().unwrap());
    let app = build_router(bundle).await.unwrap();

    // Create JWT with a KID that doesn't exist in the bundle
    let rsa_private = include_bytes!("fixtures/test_rsa_private.pem");
    let mut claims = std::collections::HashMap::new();
    claims.insert("sub", serde_json::json!("test-subject"));
    claims.insert("iss", serde_json::json!("https://test-issuer.example.com"));
    claims.insert("aud", serde_json::json!("keyzero"));
    claims.insert(
        "exp",
        serde_json::json!((chrono::Utc::now() + chrono::Duration::hours(1)).timestamp()),
    );
    claims.insert("repository", serde_json::json!("myorg/myrepo"));
    let mut header = jsonwebtoken::Header::new(jsonwebtoken::Algorithm::RS256);
    header.kid = Some("nonexistent-key-id".into());
    let token = jsonwebtoken::encode(
        &header,
        &claims,
        &jsonwebtoken::EncodingKey::from_rsa_pem(rsa_private).unwrap(),
    )
    .unwrap();

    let body = serde_json::json!({"resource": "ci/api-key"}).to_string();
    let (status, _) =
        axum_test_helper(&app, "POST", "/v1/resolve", Some(body), Some(token)).await;

    assert_eq!(status, http::StatusCode::UNAUTHORIZED);
}

#[tokio::test]
async fn test_resolve_unknown_issuer_returns_401() {
    let dir = tempfile::tempdir().unwrap();
    let env_path = dir.path().join("secrets.env");
    std::fs::write(&env_path, "API_KEY=sk-test-123\n").unwrap();

    let bundle = test_bundle(env_path.to_str().unwrap());
    let app = build_router(bundle).await.unwrap();

    // Create JWT with an issuer not registered in the bundle
    let rsa_private = include_bytes!("fixtures/test_rsa_private.pem");
    let mut claims = std::collections::HashMap::new();
    claims.insert("sub", serde_json::json!("test-subject"));
    claims.insert("iss", serde_json::json!("https://unknown-issuer.example.com"));
    claims.insert("aud", serde_json::json!("keyzero"));
    claims.insert(
        "exp",
        serde_json::json!((chrono::Utc::now() + chrono::Duration::hours(1)).timestamp()),
    );
    claims.insert("repository", serde_json::json!("myorg/myrepo"));
    let mut header = jsonwebtoken::Header::new(jsonwebtoken::Algorithm::RS256);
    header.kid = Some("test-key-01".into());
    let token = jsonwebtoken::encode(
        &header,
        &claims,
        &jsonwebtoken::EncodingKey::from_rsa_pem(rsa_private).unwrap(),
    )
    .unwrap();

    let body = serde_json::json!({"resource": "ci/api-key"}).to_string();
    let (status, _) =
        axum_test_helper(&app, "POST", "/v1/resolve", Some(body), Some(token)).await;

    assert_eq!(status, http::StatusCode::UNAUTHORIZED);
}