Skip to main content

kz_server/
proxy.rs

1use crate::config::Bundle;
2use crate::error::{Result, ServerError};
3use crate::pipeline::build_resolve_params;
4use crate::security::{
5    effective_location, extract_bearer_token, format_credential_value, is_blocked_host,
6    parse_credential_location, validate_ref,
7};
8use crate::signing::{ProxyClaims, PROXY_ALGORITHM, PROXY_AUDIENCE, PROXY_ISSUER};
9use axum::body::Body;
10use axum::extract::State;
11use axum::http::{Request, Response, StatusCode};
12use axum::Router;
13use jsonwebtoken::{DecodingKey, Validation};
14use secret_resolvers::ExposeSecret;
15use std::collections::HashMap;
16use std::sync::Arc;
17
18const MAX_BODY_SIZE: usize = 10 * 1024 * 1024;
19
20struct ProxyState {
21    bundle: Bundle,
22    decoding_key: DecodingKey,
23    resolvers: HashMap<String, Arc<dyn secret_resolvers::SecretResolver>>,
24    http_client: reqwest::Client,
25}
26
27/// Build the proxy router that forwards requests with credential swapping.
28pub fn build_proxy_router(
29    bundle: Bundle,
30    public_key_pem: &str,
31    resolvers: HashMap<String, Arc<dyn secret_resolvers::SecretResolver>>,
32) -> Result<Router> {
33    let decoding_key = DecodingKey::from_rsa_pem(public_key_pem.as_bytes())
34        .map_err(|e| ServerError::Config(format!("invalid proxy public key: {e}")))?;
35
36    let http_client = reqwest::Client::new();
37
38    let state = Arc::new(ProxyState {
39        bundle,
40        decoding_key,
41        resolvers,
42        http_client,
43    });
44
45    let router = Router::new()
46        .fallback(proxy_handler)
47        .with_state(state);
48
49    Ok(router)
50}
51
52fn json_error(status: StatusCode, message: &str) -> Response<Body> {
53    let body = serde_json::json!({ "error": message });
54    Response::builder()
55        .status(status)
56        .header("content-type", "application/json")
57        .body(Body::from(body.to_string()))
58        .unwrap()
59}
60
61async fn proxy_handler(
62    State(state): State<Arc<ProxyState>>,
63    req: Request<Body>,
64) -> Response<Body> {
65    match proxy_inner(state, req).await {
66        Ok(resp) => resp,
67        Err(e) => match &e {
68            ServerError::Jwt(_) => json_error(StatusCode::UNAUTHORIZED, &e.to_string()),
69            ServerError::PathTraversal(_) => json_error(StatusCode::BAD_REQUEST, &e.to_string()),
70            ServerError::UnknownRef(_) => json_error(StatusCode::NOT_FOUND, &e.to_string()),
71            ServerError::Config(_) => json_error(StatusCode::BAD_REQUEST, &e.to_string()),
72            _ => json_error(StatusCode::BAD_GATEWAY, &e.to_string()),
73        },
74    }
75}
76
77async fn proxy_inner(
78    state: Arc<ProxyState>,
79    req: Request<Body>,
80) -> Result<Response<Body>> {
81    // 1. Extract bearer token
82    let token = extract_bearer_token(req.headers())
83        .ok_or_else(|| ServerError::Jwt("missing or malformed Authorization header".into()))?;
84
85    // 2. Verify JWT
86    let mut validation = Validation::new(PROXY_ALGORITHM);
87    validation.set_audience(&[PROXY_AUDIENCE]);
88    validation.set_issuer(&[PROXY_ISSUER]);
89
90    let token_data = jsonwebtoken::decode::<ProxyClaims>(
91        &token,
92        &state.decoding_key,
93        &validation,
94    )?;
95    let claims = token_data.claims;
96
97    // 3. Validate ref
98    validate_ref(&claims.resource)?;
99
100    // 4. Match resource in bundle
101    let resource = state
102        .bundle
103        .match_resource(&claims.resource)
104        .ok_or_else(|| ServerError::UnknownRef(claims.resource.clone()))?;
105
106    // 4b. Cross-check: token resolver must match resource resolver
107    if claims.resolver != resource.resolver {
108        return Err(ServerError::Config(format!(
109            "token resolver '{}' does not match resource resolver '{}'",
110            claims.resolver, resource.resolver
111        )));
112    }
113
114    // 5. Get resolver
115    let resolver = state
116        .resolvers
117        .get(&claims.resolver)
118        .ok_or_else(|| {
119            ServerError::Config(format!("unknown resolver: {}", claims.resolver))
120        })?;
121
122    // 6. Build resolve request
123    let params = build_resolve_params(&claims.resource, resource);
124    let resolve_req = secret_resolvers::Request::resolve(params);
125
126    // 7. Resolve secret
127    let resolved = resolver
128        .resolve(&resolve_req)
129        .await
130        .map_err(|e| ServerError::Resolution(e.to_string()))?;
131
132    let secret_value = resolved.value.expose_secret();
133
134    // 8. Determine credential location and format the value
135    let loc_str = effective_location(resource.credential_location.as_deref());
136    let cred_loc = parse_credential_location(loc_str)
137        .map_err(|e| ServerError::Config(e))?;
138    let cred_value = format_credential_value(&cred_loc, secret_value);
139
140    // 9. Extract method, URI, headers, body BEFORE consuming the request
141    let method = req.method().clone();
142    let uri = req.uri().clone();
143    let headers = req.headers().clone();
144
145    let body_bytes = axum::body::to_bytes(req.into_body(), MAX_BODY_SIZE)
146        .await
147        .map_err(|e| ServerError::Resolution(format!("failed to read request body: {e}")))?;
148
149    // 10. Determine target URL
150    let target_url = if uri.scheme().is_some() {
151        // Absolute URI (e.g. from an HTTP proxy request)
152        uri.to_string()
153    } else {
154        // Relative URI — use Host header
155        let host = headers
156            .get("host")
157            .and_then(|v| v.to_str().ok())
158            .ok_or_else(|| {
159                ServerError::Config("no Host header and no absolute URI".into())
160            })?;
161        format!("https://{host}{}", uri.path_and_query().map(|pq| pq.as_str()).unwrap_or("/"))
162    };
163
164    // 11. SSRF check
165    // TODO(security): pin resolved IPs to prevent DNS rebinding — requires reqwest resolve() integration
166    let parsed_url = reqwest::Url::parse(&target_url)
167        .map_err(|e| ServerError::Config(format!("invalid target URL: {e}")))?;
168    let host = parsed_url.host_str().unwrap_or("");
169    if is_blocked_host(host) {
170        return Err(ServerError::Config(format!(
171            "blocked host: {host}"
172        )));
173    }
174
175    // 12. Build outgoing request
176    let reqwest_method = reqwest::Method::from_bytes(method.as_str().as_bytes())
177        .map_err(|e| ServerError::Config(format!("invalid method: {e}")))?;
178
179    let mut outgoing = state.http_client.request(reqwest_method, parsed_url);
180
181    // Copy headers, skipping hop-by-hop and the original Authorization
182    for (name, value) in headers.iter() {
183        let n = name.as_str();
184        if matches!(
185            n,
186            "host" | "authorization" | "connection" | "transfer-encoding" | "te" | "trailer"
187        ) {
188            continue;
189        }
190        outgoing = outgoing.header(name.clone(), value.clone());
191    }
192
193    // Inject the swapped credential
194    outgoing = outgoing.header(cred_loc.header_name, &cred_value);
195
196    // Attach body
197    if !body_bytes.is_empty() {
198        outgoing = outgoing.body(body_bytes.to_vec());
199    }
200
201    // 13. Forward request
202    let upstream_resp = outgoing
203        .send()
204        .await
205        .map_err(|e| ServerError::Http(e))?;
206
207    // Convert upstream response back to axum response
208    let status = StatusCode::from_u16(upstream_resp.status().as_u16()).unwrap_or(StatusCode::BAD_GATEWAY);
209
210    let mut builder = Response::builder().status(status);
211    for (name, value) in upstream_resp.headers().iter() {
212        builder = builder.header(name.clone(), value.clone());
213    }
214
215    let resp_bytes = upstream_resp
216        .bytes()
217        .await
218        .map_err(|e| ServerError::Http(e))?;
219
220    let response = builder
221        .body(Body::from(resp_bytes))
222        .map_err(|e| ServerError::Config(format!("failed to build response: {e}")))?;
223
224    Ok(response)
225}