kz-server 0.3.0

JWT verification, CEL policies, and HTTP/MCP server for keyzero
Documentation
use crate::config::Bundle;
use crate::error::{Result, ServerError};
use crate::pipeline::build_resolve_params;
use crate::security::{
    effective_location, extract_bearer_token, format_credential_value, is_blocked_host,
    parse_credential_location, validate_ref,
};
use crate::signing::{ProxyClaims, PROXY_ALGORITHM, PROXY_AUDIENCE, PROXY_ISSUER};
use axum::body::Body;
use axum::extract::State;
use axum::http::{Request, Response, StatusCode};
use axum::Router;
use jsonwebtoken::{DecodingKey, Validation};
use secret_resolvers::ExposeSecret;
use std::collections::HashMap;
use std::sync::Arc;

const MAX_BODY_SIZE: usize = 10 * 1024 * 1024;

struct ProxyState {
    bundle: Bundle,
    decoding_key: DecodingKey,
    resolvers: HashMap<String, Arc<dyn secret_resolvers::SecretResolver>>,
    http_client: reqwest::Client,
}

/// Build the proxy router that forwards requests with credential swapping.
pub fn build_proxy_router(
    bundle: Bundle,
    public_key_pem: &str,
    resolvers: HashMap<String, Arc<dyn secret_resolvers::SecretResolver>>,
) -> Result<Router> {
    let decoding_key = DecodingKey::from_rsa_pem(public_key_pem.as_bytes())
        .map_err(|e| ServerError::Config(format!("invalid proxy public key: {e}")))?;

    let http_client = reqwest::Client::new();

    let state = Arc::new(ProxyState {
        bundle,
        decoding_key,
        resolvers,
        http_client,
    });

    let router = Router::new()
        .fallback(proxy_handler)
        .with_state(state);

    Ok(router)
}

fn json_error(status: StatusCode, message: &str) -> Response<Body> {
    let body = serde_json::json!({ "error": message });
    Response::builder()
        .status(status)
        .header("content-type", "application/json")
        .body(Body::from(body.to_string()))
        .unwrap()
}

async fn proxy_handler(
    State(state): State<Arc<ProxyState>>,
    req: Request<Body>,
) -> Response<Body> {
    match proxy_inner(state, req).await {
        Ok(resp) => resp,
        Err(e) => match &e {
            ServerError::Jwt(_) => json_error(StatusCode::UNAUTHORIZED, &e.to_string()),
            ServerError::PathTraversal(_) => json_error(StatusCode::BAD_REQUEST, &e.to_string()),
            ServerError::UnknownRef(_) => json_error(StatusCode::NOT_FOUND, &e.to_string()),
            ServerError::Config(_) => json_error(StatusCode::BAD_REQUEST, &e.to_string()),
            _ => json_error(StatusCode::BAD_GATEWAY, &e.to_string()),
        },
    }
}

async fn proxy_inner(
    state: Arc<ProxyState>,
    req: Request<Body>,
) -> Result<Response<Body>> {
    // 1. Extract bearer token
    let token = extract_bearer_token(req.headers())
        .ok_or_else(|| ServerError::Jwt("missing or malformed Authorization header".into()))?;

    // 2. Verify JWT
    let mut validation = Validation::new(PROXY_ALGORITHM);
    validation.set_audience(&[PROXY_AUDIENCE]);
    validation.set_issuer(&[PROXY_ISSUER]);

    let token_data = jsonwebtoken::decode::<ProxyClaims>(
        &token,
        &state.decoding_key,
        &validation,
    )?;
    let claims = token_data.claims;

    // 3. Validate ref
    validate_ref(&claims.resource)?;

    // 4. Match resource in bundle
    let resource = state
        .bundle
        .match_resource(&claims.resource)
        .ok_or_else(|| ServerError::UnknownRef(claims.resource.clone()))?;

    // 4b. Cross-check: token resolver must match resource resolver
    if claims.resolver != resource.resolver {
        return Err(ServerError::Config(format!(
            "token resolver '{}' does not match resource resolver '{}'",
            claims.resolver, resource.resolver
        )));
    }

    // 5. Get resolver
    let resolver = state
        .resolvers
        .get(&claims.resolver)
        .ok_or_else(|| {
            ServerError::Config(format!("unknown resolver: {}", claims.resolver))
        })?;

    // 6. Build resolve request
    let params = build_resolve_params(&claims.resource, resource);
    let resolve_req = secret_resolvers::Request::resolve(params);

    // 7. Resolve secret
    let resolved = resolver
        .resolve(&resolve_req)
        .await
        .map_err(|e| ServerError::Resolution(e.to_string()))?;

    let secret_value = resolved.value.expose_secret();

    // 8. Determine credential location and format the value
    let loc_str = effective_location(resource.credential_location.as_deref());
    let cred_loc = parse_credential_location(loc_str)
        .map_err(|e| ServerError::Config(e))?;
    let cred_value = format_credential_value(&cred_loc, secret_value);

    // 9. Extract method, URI, headers, body BEFORE consuming the request
    let method = req.method().clone();
    let uri = req.uri().clone();
    let headers = req.headers().clone();

    let body_bytes = axum::body::to_bytes(req.into_body(), MAX_BODY_SIZE)
        .await
        .map_err(|e| ServerError::Resolution(format!("failed to read request body: {e}")))?;

    // 10. Determine target URL
    let target_url = if uri.scheme().is_some() {
        // Absolute URI (e.g. from an HTTP proxy request)
        uri.to_string()
    } else {
        // Relative URI — use Host header
        let host = headers
            .get("host")
            .and_then(|v| v.to_str().ok())
            .ok_or_else(|| {
                ServerError::Config("no Host header and no absolute URI".into())
            })?;
        format!("https://{host}{}", uri.path_and_query().map(|pq| pq.as_str()).unwrap_or("/"))
    };

    // 11. SSRF check
    // TODO(security): pin resolved IPs to prevent DNS rebinding — requires reqwest resolve() integration
    let parsed_url = reqwest::Url::parse(&target_url)
        .map_err(|e| ServerError::Config(format!("invalid target URL: {e}")))?;
    let host = parsed_url.host_str().unwrap_or("");
    if is_blocked_host(host) {
        return Err(ServerError::Config(format!(
            "blocked host: {host}"
        )));
    }

    // 12. Build outgoing request
    let reqwest_method = reqwest::Method::from_bytes(method.as_str().as_bytes())
        .map_err(|e| ServerError::Config(format!("invalid method: {e}")))?;

    let mut outgoing = state.http_client.request(reqwest_method, parsed_url);

    // Copy headers, skipping hop-by-hop and the original Authorization
    for (name, value) in headers.iter() {
        let n = name.as_str();
        if matches!(
            n,
            "host" | "authorization" | "connection" | "transfer-encoding" | "te" | "trailer"
        ) {
            continue;
        }
        outgoing = outgoing.header(name.clone(), value.clone());
    }

    // Inject the swapped credential
    outgoing = outgoing.header(cred_loc.header_name, &cred_value);

    // Attach body
    if !body_bytes.is_empty() {
        outgoing = outgoing.body(body_bytes.to_vec());
    }

    // 13. Forward request
    let upstream_resp = outgoing
        .send()
        .await
        .map_err(|e| ServerError::Http(e))?;

    // Convert upstream response back to axum response
    let status = StatusCode::from_u16(upstream_resp.status().as_u16()).unwrap_or(StatusCode::BAD_GATEWAY);

    let mut builder = Response::builder().status(status);
    for (name, value) in upstream_resp.headers().iter() {
        builder = builder.header(name.clone(), value.clone());
    }

    let resp_bytes = upstream_resp
        .bytes()
        .await
        .map_err(|e| ServerError::Http(e))?;

    let response = builder
        .body(Body::from(resp_bytes))
        .map_err(|e| ServerError::Config(format!("failed to build response: {e}")))?;

    Ok(response)
}