1#[cfg(test)]
2mod tests;
3
4use std::{
5 any::Any,
6 convert::Infallible,
7 mem::replace,
8 sync::{Arc, atomic::Ordering},
9 task::{Context, Poll},
10 time::Duration,
11};
12
13use axum::{
14 Extension, Router,
15 extract::{DefaultBodyLimit, MatchedPath, Request},
16 response::{IntoResponse, Response},
17};
18use futures::{FutureExt, future::Map};
19use http::{
20 HeaderValue, Method, StatusCode,
21 header::{
22 self, CONTENT_SECURITY_POLICY, CONTENT_TYPE, ETAG, HeaderName, IF_MATCH, IF_NONE_MATCH,
23 X_FRAME_OPTIONS,
24 },
25};
26use ipnet::IpNet;
27#[cfg(feature = "sentry_telemetry")]
28use sentry_tower::NewSentryLayer;
29use tower::{
30 Layer, Service, ServiceBuilder,
31 layer::util::Identity,
32 util::{Either, MapResponseLayer, option_layer},
33};
34use tower_http::{
35 catch_panic::CatchPanicLayer,
36 cors::{AllowOrigin, CorsLayer},
37 sensitive_headers::SetSensitiveHeadersLayer,
38 set_header::SetResponseHeaderLayer,
39 timeout::{RequestBodyTimeoutLayer, ResponseBodyTimeoutLayer, TimeoutLayer},
40 trace::{DefaultOnFailure, DefaultOnRequest, DefaultOnResponse, TraceLayer},
41};
42use tracing::Level;
43use tuwunel_api::router::{ConfiguredIpSource, TrustedPeerSubnets, state::Guard};
44use tuwunel_core::{
45 Result, Server, config::IpSource, debug, error, utils::content_disposition::content_type_is,
46};
47use tuwunel_service::Services;
48
49use crate::{request, router};
50
51type Convert = fn(Result<Response, StatusCode>) -> Result<Response, Infallible>;
52
53#[derive(Clone)]
56pub(crate) struct HandleLayer<F> {
57 pub(crate) services: Arc<Services>,
58 pub(crate) handler: F,
59}
60
61#[derive(Clone)]
62pub(crate) struct Handle<S, F> {
63 services: Arc<Services>,
64 handler: F,
65 inner: S,
66}
67
68const TUWUNEL_CSP: &[&str] = &[
69 "default-src 'none'",
70 "script-src 'self'",
71 "style-src 'self'",
72 "frame-ancestors 'none'",
73 "form-action 'self'",
74 "base-uri 'none'",
75];
76
77pub(crate) fn build(services: &Arc<Services>) -> Result<(Router, Guard)> {
78 let server = &services.server;
79 let layers = ServiceBuilder::new();
80
81 #[cfg(feature = "sentry_telemetry")]
82 let sentry = server
83 .config
84 .telemetry
85 .sentry
86 .enable
87 .then(NewSentryLayer::<Request>::new_from_top);
88
89 #[cfg(feature = "sentry_telemetry")]
90 let layers = layers.option_layer(sentry);
91
92 #[cfg(any(
93 feature = "zstd_compression",
94 feature = "gzip_compression",
95 feature = "brotli_compression"
96 ))]
97 let layers = layers.layer(compression_layer(server));
98
99 let services_ = services.clone();
100 let layers = layers
101 .layer(SetSensitiveHeadersLayer::new([header::AUTHORIZATION]))
102 .layer(
103 TraceLayer::new_for_http()
104 .make_span_with(tracing_span::<_>)
105 .on_failure(DefaultOnFailure::new().level(Level::ERROR))
106 .on_request(DefaultOnRequest::new().level(Level::TRACE))
107 .on_response(DefaultOnResponse::new().level(Level::DEBUG)),
108 )
109 .layer(HandleLayer {
110 services: Arc::clone(services),
111 handler: request::handle,
112 })
113 .layer(trusted_peer_subnets_layer(&server.config.http.ip_source_trusted_subnets))
114 .layer(ip_source_layer(server.config.http.ip_source))
115 .layer(ResponseBodyTimeoutLayer::new(Duration::from_secs(
116 server.config.http.response_timeout,
117 )))
118 .layer(RequestBodyTimeoutLayer::new(Duration::from_secs(
119 server.config.http.receive_timeout,
120 )))
121 .layer(TimeoutLayer::with_status_code(
122 StatusCode::REQUEST_TIMEOUT,
123 Duration::from_secs(server.config.http.request_timeout),
124 ))
125 .layer(SetResponseHeaderLayer::if_not_present(
126 header::X_CONTENT_TYPE_OPTIONS,
127 HeaderValue::from_static("nosniff"),
128 ))
129 .layer(html_layer())
130 .layer(cors_layer(server))
131 .layer(body_limit_layer(server))
132 .layer(CatchPanicLayer::custom(move |panic| catch_panic(panic, services_.clone())));
133
134 let (router, guard) = router::build(services);
135 Ok((router.layer(layers), guard))
136}
137
138impl<S, F: Clone> Layer<S> for HandleLayer<F> {
139 type Service = Handle<S, F>;
140
141 fn layer(&self, inner: S) -> Self::Service {
142 Handle {
143 services: self.services.clone(),
144 handler: self.handler.clone(),
145 inner,
146 }
147 }
148}
149
150impl<S, F, Fut> Service<Request> for Handle<S, F>
151where
152 S: Service<Request, Error = Infallible> + Clone,
153 F: FnMut(Arc<Services>, Request, S) -> Fut,
154 Fut: Future<Output = Result<Response, StatusCode>>,
155{
156 type Error = Infallible;
157 type Future = Map<Fut, Convert>;
158 type Response = Response;
159
160 fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
161 self.inner.poll_ready(cx)
162 }
163
164 fn call(&mut self, req: Request) -> Self::Future {
165 let convert: Convert = |result| Ok(result.into_response());
166 let unready = self.inner.clone();
167 let inner = replace(&mut self.inner, unready);
168
169 (self.handler)(self.services.clone(), req, inner).map(convert)
170 }
171}
172
173#[cfg(any(
174 feature = "zstd_compression",
175 feature = "gzip_compression",
176 feature = "brotli_compression"
177))]
178fn compression_layer(server: &Server) -> tower_http::compression::CompressionLayer {
179 let mut compression_layer = tower_http::compression::CompressionLayer::new();
180
181 #[cfg(feature = "zstd_compression")]
182 {
183 compression_layer = if server.config.http.compression.zstd {
184 compression_layer.zstd(true)
185 } else {
186 compression_layer.no_zstd()
187 };
188 };
189
190 #[cfg(feature = "gzip_compression")]
191 {
192 compression_layer = if server.config.http.compression.gzip {
193 compression_layer.gzip(true)
194 } else {
195 compression_layer.no_gzip()
196 };
197 };
198
199 #[cfg(feature = "brotli_compression")]
200 {
201 compression_layer = if server.config.http.compression.brotli {
202 compression_layer.br(true)
203 } else {
204 compression_layer.no_br()
205 };
206 };
207
208 compression_layer
209}
210
211fn cors_layer(server: &Server) -> CorsLayer {
212 const METHODS: [Method; 7] = [
213 Method::DELETE,
214 Method::GET,
215 Method::HEAD,
216 Method::OPTIONS,
217 Method::PATCH,
218 Method::POST,
219 Method::PUT,
220 ];
221
222 let headers: [HeaderName; 7] = [
223 header::ACCEPT,
224 header::AUTHORIZATION,
225 CONTENT_TYPE,
226 IF_MATCH,
227 IF_NONE_MATCH,
228 header::ORIGIN,
229 HeaderName::from_static("x-requested-with"),
230 ];
231
232 let allow_origin_list = server
233 .config
234 .http
235 .access_control_allow_origin
236 .iter()
237 .map(AsRef::as_ref)
238 .map(HeaderValue::from_str)
239 .filter_map(Result::ok);
240
241 let allow_origin = if !server
242 .config
243 .http
244 .access_control_allow_origin
245 .is_empty()
246 {
247 AllowOrigin::list(allow_origin_list)
248 } else {
249 AllowOrigin::any()
250 };
251
252 CorsLayer::new()
253 .max_age(Duration::from_hours(24))
254 .allow_methods(METHODS)
255 .allow_headers(headers)
256 .expose_headers([ETAG])
257 .allow_origin(allow_origin)
258}
259
260fn body_limit_layer(server: &Server) -> DefaultBodyLimit {
261 DefaultBodyLimit::max(server.config.http.max_request_size)
262}
263
264fn trusted_peer_subnets_layer(
265 subnets: &[IpNet],
266) -> Either<Extension<TrustedPeerSubnets>, Identity> {
267 option_layer((!subnets.is_empty()).then(|| Extension(TrustedPeerSubnets(Arc::from(subnets)))))
268}
269
270fn ip_source_layer(source: Option<IpSource>) -> Either<Extension<ConfiguredIpSource>, Identity> {
271 option_layer(source.map(|source| Extension(ConfiguredIpSource(source))))
272}
273
274fn html_layer<T>() -> MapResponseLayer<impl Fn(http::Response<T>) -> http::Response<T> + Clone> {
275 MapResponseLayer::new(set_html_headers)
276}
277
278fn set_html_headers<T>(mut response: http::Response<T>) -> http::Response<T> {
284 let headers = response.headers_mut();
285
286 let content_type = headers
287 .get(CONTENT_TYPE)
288 .map(HeaderValue::to_str)
289 .and_then(Result::ok);
290
291 if content_type_is(content_type, "text/html") {
292 headers
293 .entry(CONTENT_SECURITY_POLICY)
294 .or_insert(HeaderValue::from_static(const_str::join!(TUWUNEL_CSP, ";")));
295
296 headers
297 .entry(X_FRAME_OPTIONS)
298 .or_insert(HeaderValue::from_static("DENY"));
299 }
300
301 response
302}
303
304#[tracing::instrument(name = "panic", level = "error", skip_all)]
305#[expect(clippy::needless_pass_by_value)]
306fn catch_panic(
307 err: Box<dyn Any + Send + 'static>,
308 services: Arc<Services>,
309) -> http::Response<http_body_util::Full<bytes::Bytes>> {
310 services
311 .server
312 .metrics
313 .requests_panic
314 .fetch_add(1, Ordering::Release);
315
316 let details = err
317 .downcast_ref::<String>()
318 .map(String::as_str)
319 .or_else(|| err.downcast_ref::<&str>().copied())
320 .unwrap_or("Unknown internal server error occurred.");
321
322 error!("{details:#}");
323 let body = serde_json::json!({
324 "errcode": "M_UNKNOWN",
325 "error": "M_UNKNOWN: Internal server error occurred",
326 });
327
328 http::Response::builder()
329 .status(StatusCode::INTERNAL_SERVER_ERROR)
330 .header(CONTENT_TYPE, "application/json")
331 .body(http_body_util::Full::from(body.to_string()))
332 .expect("Failed to create response for our panic catcher?")
333}
334
335fn tracing_span<T>(request: &http::Request<T>) -> tracing::Span {
336 let path = request
337 .extensions()
338 .get::<MatchedPath>()
339 .map_or_else(|| request_path_str(request), truncated_matched_path);
340
341 tracing::span! {
342 parent: None,
343 debug::INFO_SPAN_LEVEL,
344 "router",
345 method = %request.method(),
346 %path,
347 }
348}
349
350fn request_path_str<T>(request: &http::Request<T>) -> &str { request.uri().path() }
351
352fn truncated_matched_path(path: &MatchedPath) -> &str {
353 path.as_str()
354 .rsplit_once('{')
355 .map_or(path.as_str(), |path| path.0.strip_suffix('/').unwrap_or(path.0))
356}