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,
}
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>> {
let token = extract_bearer_token(req.headers())
.ok_or_else(|| ServerError::Jwt("missing or malformed Authorization header".into()))?;
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;
validate_ref(&claims.resource)?;
let resource = state
.bundle
.match_resource(&claims.resource)
.ok_or_else(|| ServerError::UnknownRef(claims.resource.clone()))?;
if claims.resolver != resource.resolver {
return Err(ServerError::Config(format!(
"token resolver '{}' does not match resource resolver '{}'",
claims.resolver, resource.resolver
)));
}
let resolver = state
.resolvers
.get(&claims.resolver)
.ok_or_else(|| {
ServerError::Config(format!("unknown resolver: {}", claims.resolver))
})?;
let params = build_resolve_params(&claims.resource, resource);
let resolve_req = secret_resolvers::Request::resolve(params);
let resolved = resolver
.resolve(&resolve_req)
.await
.map_err(|e| ServerError::Resolution(e.to_string()))?;
let secret_value = resolved.value.expose_secret();
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);
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}")))?;
let target_url = if uri.scheme().is_some() {
uri.to_string()
} else {
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("/"))
};
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}"
)));
}
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);
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());
}
outgoing = outgoing.header(cred_loc.header_name, &cred_value);
if !body_bytes.is_empty() {
outgoing = outgoing.body(body_bytes.to_vec());
}
let upstream_resp = outgoing
.send()
.await
.map_err(|e| ServerError::Http(e))?;
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)
}