kz-server 0.3.0

JWT verification, CEL policies, and HTTP/MCP server for keyzero
Documentation
use std::io::Write;

use axum::body::Body;
use axum::http::{Request, StatusCode};
use kz_server::config::Bundle;
use kz_server::server::build_router;
use serde_json::{json, Value};
use tempfile::TempDir;
use tower::ServiceExt;

mod common;

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

fn write_env_file(dir: &TempDir, contents: &str) -> String {
    let path = dir.path().join("secrets.env");
    let mut f = std::fs::File::create(&path).expect("create env file");
    f.write_all(contents.as_bytes()).expect("write env file");
    path.to_string_lossy().to_string()
}

fn bundle_yaml(env_file_path: &str) -> String {
    let public_pem = common::load_public_key();
    let indented_pem: String = public_pem
        .lines()
        .map(|line| format!("          {line}"))
        .collect::<Vec<_>>()
        .join("\n");

    format!(
        r#"version: "1"
issuers:
  - name: ci
    type: github-actions
    issuer_url: "https://token.actions.githubusercontent.com"
    audience: "keyzero"
    static_keys:
      - kid: "test-key"
        alg: RS256
        pem: |
{indented_pem}
policies:
  - name: allow-test
    rule: "org == 'myorg' && ref.matches('secret/**')"
    effect: allow
  - name: default-deny
    rule: "true"
    effect: deny
resources:
  - ref: "secret/**"
    resolver: local
    mode: direct
backends:
  local:
    type: env_file
    path: "{env_file_path}"
"#
    )
}

async fn make_router(env_file_path: &str) -> axum::Router {
    let yaml = bundle_yaml(env_file_path);
    let bundle: Bundle = serde_yaml::from_str(&yaml).expect("parse bundle YAML");
    build_router(bundle).await.expect("build router")
}

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()
}

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

#[tokio::test]
async fn test_healthz() {
    let dir = TempDir::new().unwrap();
    let env_path = write_env_file(&dir, "secret/X=y\n");
    let router = make_router(&env_path).await;

    let req = Request::builder()
        .method("GET")
        .uri("/healthz")
        .body(Body::empty())
        .unwrap();

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

    let body: Value = parse_body(resp).await;
    assert_eq!(body["status"], "ok");
    assert_eq!(body["bundle_loaded"], true);
    assert_eq!(body["bundle_version"], "1");
}

#[tokio::test]
async fn test_resolve_success() {
    let dir = TempDir::new().unwrap();
    let env_path = write_env_file(&dir, "secret/MY_SECRET=supersecret\n");
    let router = make_router(&env_path).await;
    let token = common::make_token("myorg");

    let req = Request::builder()
        .method("POST")
        .uri("/v1/resolve")
        .header("content-type", "application/json")
        .header("authorization", format!("Bearer {token}"))
        .body(Body::from(
            serde_json::to_string(&json!({"ref": "secret/MY_SECRET"})).unwrap(),
        ))
        .unwrap();

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

    let body: Value = parse_body(resp).await;
    let result = &body["results"]["secret/MY_SECRET"];
    assert_eq!(result["allowed"], true);
    assert_eq!(result["value"], "supersecret");
    assert_eq!(result["mode"], "direct");
}

#[tokio::test]
async fn test_resolve_no_auth() {
    let dir = TempDir::new().unwrap();
    let env_path = write_env_file(&dir, "secret/X=y\n");
    let router = make_router(&env_path).await;

    let req = Request::builder()
        .method("POST")
        .uri("/v1/resolve")
        .header("content-type", "application/json")
        .body(Body::from(
            serde_json::to_string(&json!({"ref": "secret/X"})).unwrap(),
        ))
        .unwrap();

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

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

#[tokio::test]
async fn test_resolve_denied() {
    let dir = TempDir::new().unwrap();
    let env_path = write_env_file(&dir, "secret/DENIED=nope\n");
    let router = make_router(&env_path).await;
    // Token from a different org — policy will deny
    let token = common::make_token("other-org");

    let req = Request::builder()
        .method("POST")
        .uri("/v1/resolve")
        .header("content-type", "application/json")
        .header("authorization", format!("Bearer {token}"))
        .body(Body::from(
            serde_json::to_string(&json!({"ref": "secret/DENIED"})).unwrap(),
        ))
        .unwrap();

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

    let body: Value = parse_body(resp).await;
    let result = &body["results"]["secret/DENIED"];
    assert_eq!(result["allowed"], false);
}

#[tokio::test]
async fn test_resolve_path_traversal_returns_400() {
    let dir = TempDir::new().unwrap();
    let env_path = write_env_file(&dir, "secret/X=y\n");
    let router = make_router(&env_path).await;
    let token = common::make_token("myorg");

    let req = Request::builder()
        .method("POST")
        .uri("/v1/resolve")
        .header("content-type", "application/json")
        .header("authorization", format!("Bearer {token}"))
        .body(Body::from(
            serde_json::to_string(&json!({"ref": "secret/../etc/passwd"})).unwrap(),
        ))
        .unwrap();

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

    let body: Value = parse_body(resp).await;
    assert_eq!(body["error"], "invalid_ref");
}