Skip to main content

tuwunel_router/
layers.rs

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/// Bespoke `axum::middleware::from_fn`: threading the handler's future type
54/// through `F` spares the boxes the generic middleware allocates per request.
55#[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
278/// Denies framing and foreign scripts for a response that is HTML.
279///
280/// The Content-Type is echoed from whoever uploaded the media, so the media
281/// type decides on its own and regardless of case: a parameter that merely
282/// mentions HTML leaves a response that is not HTML alone.
283fn 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}