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
27pub 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 let token = extract_bearer_token(req.headers())
83 .ok_or_else(|| ServerError::Jwt("missing or malformed Authorization header".into()))?;
84
85 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 validate_ref(&claims.resource)?;
99
100 let resource = state
102 .bundle
103 .match_resource(&claims.resource)
104 .ok_or_else(|| ServerError::UnknownRef(claims.resource.clone()))?;
105
106 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 let resolver = state
116 .resolvers
117 .get(&claims.resolver)
118 .ok_or_else(|| {
119 ServerError::Config(format!("unknown resolver: {}", claims.resolver))
120 })?;
121
122 let params = build_resolve_params(&claims.resource, resource);
124 let resolve_req = secret_resolvers::Request::resolve(params);
125
126 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 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 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 let target_url = if uri.scheme().is_some() {
151 uri.to_string()
153 } else {
154 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 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 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 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 outgoing = outgoing.header(cred_loc.header_name, &cred_value);
195
196 if !body_bytes.is_empty() {
198 outgoing = outgoing.body(body_bytes.to_vec());
199 }
200
201 let upstream_resp = outgoing
203 .send()
204 .await
205 .map_err(|e| ServerError::Http(e))?;
206
207 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}