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;
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()
}
#[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");
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");
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();
let status = resp.status();
assert_ne!(status, StatusCode::UNAUTHORIZED);
assert_ne!(status, StatusCode::FORBIDDEN);
}