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;
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()
}
#[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;
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");
}