1use std::{
13 fmt,
14 net::{IpAddr, SocketAddr},
15 sync::Arc,
16};
17
18use axum::extract::{ConnectInfo, FromRequestParts};
19use http::{Extensions, HeaderMap, StatusCode, request::Parts};
20use ipnet::IpNet;
21use tuwunel_core::config::IpSource;
22
23#[derive(Clone, Copy, Debug)]
27pub struct ClientIp(
28 pub IpAddr,
30);
31
32#[derive(Clone, Copy, Debug)]
38pub struct RateLimitIp(
39 pub IpAddr,
41);
42
43#[derive(Clone, Copy, Debug)]
48pub struct ConfiguredIpSource(pub IpSource);
49
50#[derive(Clone, Debug)]
56pub struct TrustedPeerSubnets(pub Arc<[IpNet]>);
57
58impl<S> FromRequestParts<S> for ClientIp
59where
60 S: Sync,
61{
62 type Rejection = (StatusCode, &'static str);
63
64 async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
65 const ERROR: StatusCode = StatusCode::INTERNAL_SERVER_ERROR;
66
67 if let Some(&ConfiguredIpSource(source)) = parts.extensions.get::<ConfiguredIpSource>()
68 && !peer_is_trusted(&parts.extensions)
69 {
70 return secure_extract(source, &parts.headers, &parts.extensions)
71 .map(Self)
72 .ok_or((ERROR, "Can't extract client IP from configured http.ip_source"));
73 }
74
75 insecure_fallback(&parts.headers, &parts.extensions)
76 .map(Self)
77 .ok_or((ERROR, "Can't extract `ClientIp`, provide `axum::extract::ConnectInfo`"))
78 }
79}
80
81impl fmt::Display for ClientIp {
82 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fmt::Display::fmt(&self.0, f) }
83}
84
85impl<S> FromRequestParts<S> for RateLimitIp
86where
87 S: Sync,
88{
89 type Rejection = (StatusCode, &'static str);
90
91 async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
92 rate_limit_ip(parts).map(Self)
93 }
94}
95
96pub(crate) fn rate_limit_ip(parts: &Parts) -> Result<IpAddr, (StatusCode, &'static str)> {
97 let source = parts
98 .extensions
99 .get()
100 .map(|ConfiguredIpSource(source): &ConfiguredIpSource| *source)
101 .unwrap_or(IpSource::ConnectInfo);
102
103 secure_extract(source, &parts.headers, &parts.extensions)
104 .ok_or((StatusCode::INTERNAL_SERVER_ERROR, "Can't extract authentication rate-limit IP"))
105}
106
107fn peer_is_trusted(extensions: &Extensions) -> bool {
108 let Some(ConnectInfo(addr)) = extensions.get::<ConnectInfo<SocketAddr>>() else {
109 return false;
110 };
111
112 let peer = addr.ip().to_canonical();
113
114 peer.is_loopback()
115 || extensions
116 .get::<TrustedPeerSubnets>()
117 .is_some_and(|TrustedPeerSubnets(nets)| nets.iter().any(|net| net.contains(&peer)))
118}
119
120fn secure_extract(
121 source: IpSource,
122 headers: &HeaderMap,
123 extensions: &Extensions,
124) -> Option<IpAddr> {
125 match source {
126 | IpSource::ConnectInfo => extensions
127 .get::<ConnectInfo<SocketAddr>>()
128 .map(|ConnectInfo(addr)| addr.ip()),
129 | IpSource::RightmostXForwardedFor => rightmost_x_forwarded_for(headers),
130 | IpSource::RightmostForwarded => rightmost_forwarded(headers),
131 | IpSource::XRealIp => single_ip_header(headers, "x-real-ip"),
132 | IpSource::CfConnectingIp => single_ip_header(headers, "cf-connecting-ip"),
133 | IpSource::TrueClientIp => single_ip_header(headers, "true-client-ip"),
134 | IpSource::FlyClientIp => single_ip_header(headers, "fly-client-ip"),
135 | IpSource::CloudFrontViewerAddress => cloudfront_viewer_address(headers),
136 }
137}
138
139fn rightmost_x_forwarded_for(headers: &HeaderMap) -> Option<IpAddr> {
140 headers
141 .get_all("x-forwarded-for")
142 .iter()
143 .filter_map(|v| v.to_str().ok())
144 .flat_map(|s| s.split(','))
145 .filter_map(|s| s.trim().parse::<IpAddr>().ok())
146 .next_back()
147}
148
149fn rightmost_forwarded(headers: &HeaderMap) -> Option<IpAddr> {
150 headers
151 .get_all("forwarded")
152 .iter()
153 .filter_map(|v| v.to_str().ok())
154 .flat_map(|s| s.split(','))
155 .filter_map(parse_forwarded_for)
156 .next_back()
157}
158
159fn insecure_fallback(headers: &HeaderMap, extensions: &Extensions) -> Option<IpAddr> {
161 leftmost_x_forwarded_for(headers)
162 .or_else(|| leftmost_forwarded(headers))
163 .or_else(|| single_ip_header(headers, "x-real-ip"))
164 .or_else(|| single_ip_header(headers, "fly-client-ip"))
165 .or_else(|| single_ip_header(headers, "true-client-ip"))
166 .or_else(|| single_ip_header(headers, "cf-connecting-ip"))
167 .or_else(|| cloudfront_viewer_address(headers))
168 .or_else(|| {
169 extensions
170 .get::<ConnectInfo<SocketAddr>>()
171 .map(|ConnectInfo(addr)| addr.ip())
172 })
173}
174
175fn leftmost_x_forwarded_for(headers: &HeaderMap) -> Option<IpAddr> {
176 headers
177 .get_all("x-forwarded-for")
178 .iter()
179 .filter_map(|v| v.to_str().ok())
180 .flat_map(|s| s.split(','))
181 .find_map(|s| s.trim().parse::<IpAddr>().ok())
182}
183
184fn leftmost_forwarded(headers: &HeaderMap) -> Option<IpAddr> {
187 headers
188 .get_all("forwarded")
189 .iter()
190 .filter_map(|v| v.to_str().ok())
191 .flat_map(|s| s.split(','))
192 .find_map(parse_forwarded_for)
193}
194
195fn parse_forwarded_for(stanza: &str) -> Option<IpAddr> {
196 let for_value = stanza
197 .split(';')
198 .find_map(|part| {
199 let (k, v) = part.split_once('=')?;
200 k.trim()
201 .eq_ignore_ascii_case("for")
202 .then_some(v.trim())
203 })?
204 .trim_matches('"');
205
206 let bracketed = for_value
207 .strip_prefix('[')
208 .and_then(|s| s.split_once(']'))
209 .map(|(ip, _rest)| ip);
210
211 let candidate = bracketed
212 .or_else(|| for_value.rsplit_once(':').map(|(ip, _port)| ip))
213 .unwrap_or(for_value);
214
215 candidate.trim().parse::<IpAddr>().ok()
216}
217
218fn single_ip_header(headers: &HeaderMap, name: &'static str) -> Option<IpAddr> {
219 headers
220 .get(name)
221 .and_then(|v| v.to_str().ok())
222 .and_then(|s| s.trim().parse::<IpAddr>().ok())
223}
224
225fn cloudfront_viewer_address(headers: &HeaderMap) -> Option<IpAddr> {
226 headers
227 .get("cloudfront-viewer-address")
228 .and_then(|v| v.to_str().ok())
229 .and_then(|s| s.rsplit_once(':').map(|(ip, _port)| ip))
230 .and_then(|s| s.trim().parse::<IpAddr>().ok())
231}
232
233#[cfg(test)]
234mod tests {
235 use std::{
236 iter,
237 net::{IpAddr, SocketAddr},
238 sync::Arc,
239 };
240
241 use axum::{
242 extract::{ConnectInfo, FromRequestParts},
243 http::{Request, StatusCode, request::Parts},
244 };
245 use ipnet::IpNet;
246 use tuwunel_core::config::{IpSource, UNIX_SOCKET_PEER};
247
248 use super::{ClientIp, ConfiguredIpSource, TrustedPeerSubnets, rate_limit_ip};
249
250 #[test]
251 fn rate_limit_default_ignores_forwarded_headers() {
252 let peer: SocketAddr = "203.0.113.9:443".parse().unwrap();
253 let (parts, ()) = Request::builder()
254 .extension(ConnectInfo(peer))
255 .header("X-Forwarded-For", "192.0.2.1")
256 .header("Forwarded", "for=192.0.2.2")
257 .header("X-Real-IP", "192.0.2.3")
258 .body(())
259 .unwrap()
260 .into_parts();
261
262 assert_eq!(rate_limit_ip(&parts).unwrap(), peer.ip());
263 }
264
265 #[test]
266 fn rate_limit_configured_source_has_no_trusted_peer_bypass() {
267 let expected = IpAddr::from([203, 0, 113, 9]);
268
269 for peer in ["127.0.0.1:443", "172.18.0.5:443"] {
270 let peer: SocketAddr = peer.parse().unwrap();
271 let (parts, ()) = Request::builder()
272 .extension(ConnectInfo(peer))
273 .extension(trusted(&["172.18.0.0/16"]))
274 .extension(ConfiguredIpSource(IpSource::RightmostXForwardedFor))
275 .header("X-Forwarded-For", "192.0.2.1, 203.0.113.9")
276 .body(())
277 .unwrap()
278 .into_parts();
279
280 assert_eq!(rate_limit_ip(&parts).unwrap(), expected);
281 }
282 }
283
284 #[test]
285 fn rate_limit_connect_info_ignores_headers_on_loopback() {
286 let peer: SocketAddr = "127.0.0.1:443".parse().unwrap();
287 let (parts, ()) = Request::builder()
288 .extension(ConnectInfo(peer))
289 .extension(ConfiguredIpSource(IpSource::ConnectInfo))
290 .header("X-Forwarded-For", "192.0.2.1")
291 .body(())
292 .unwrap()
293 .into_parts();
294
295 assert_eq!(rate_limit_ip(&parts).unwrap(), peer.ip());
296 }
297
298 #[test]
299 fn rate_limit_missing_address_refuses_fallback() {
300 let headers_only = parts([("X-Forwarded-For", "192.0.2.1")]);
301 let peer: SocketAddr = "127.0.0.1:443".parse().unwrap();
302 let (missing_header, ()) = Request::builder()
303 .extension(ConnectInfo(peer))
304 .extension(ConfiguredIpSource(IpSource::RightmostXForwardedFor))
305 .body(())
306 .unwrap()
307 .into_parts();
308
309 assert_eq!(
310 rate_limit_ip(&headers_only).unwrap_err().0,
311 StatusCode::INTERNAL_SERVER_ERROR
312 );
313
314 assert_eq!(
315 rate_limit_ip(&missing_header).unwrap_err().0,
316 StatusCode::INTERNAL_SERVER_ERROR
317 );
318 }
319
320 fn trusted(nets: &[&str]) -> TrustedPeerSubnets {
321 let nets: Arc<[IpNet]> = nets
322 .iter()
323 .map(|s| s.parse().expect("test CIDR"))
324 .collect();
325
326 TrustedPeerSubnets(nets)
327 }
328
329 fn parts(headers: impl IntoIterator<Item = (&'static str, &'static str)>) -> Parts {
330 let mut request = Request::builder().uri("/");
331 for (name, value) in headers {
332 request = request.header(name, value);
333 }
334 let (parts, ()) = request.body(()).unwrap().into_parts();
335 parts
336 }
337
338 async fn extract_client_ip(
339 parts: &mut Parts,
340 ) -> Result<ClientIp, (StatusCode, &'static str)> {
341 ClientIp::from_request_parts(parts, &()).await
342 }
343
344 #[tokio::test]
345 async fn x_forwarded_for_uses_leftmost_ip() {
346 let mut parts = parts([("X-Forwarded-For", "1.1.1.1, 2.2.2.2")]);
347 let ClientIp(ip) = extract_client_ip(&mut parts).await.unwrap();
348 assert_eq!(ip.to_string(), "1.1.1.1");
349 }
350
351 #[tokio::test]
352 async fn x_forwarded_for_takes_priority_over_x_real_ip() {
353 let mut parts =
354 parts([("X-Forwarded-For", "1.1.1.1, 2.2.2.2"), ("X-Real-Ip", "3.3.3.3")]);
355 let ClientIp(ip) = extract_client_ip(&mut parts).await.unwrap();
356 assert_eq!(ip.to_string(), "1.1.1.1");
357 }
358
359 #[tokio::test]
360 async fn x_forwarded_for_accepts_ipv6() {
361 let mut parts = parts([("X-Forwarded-For", "2001:db8::1, 2001:db8::2")]);
362 let ClientIp(ip) = extract_client_ip(&mut parts).await.unwrap();
363 assert_eq!(ip.to_string(), "2001:db8::1");
364 }
365
366 #[tokio::test]
367 async fn x_real_ip_works() {
368 let mut parts = parts([("X-Real-Ip", "1.2.3.4")]);
369 let ClientIp(ip) = extract_client_ip(&mut parts).await.unwrap();
370 assert_eq!(ip.to_string(), "1.2.3.4");
371 }
372
373 #[tokio::test]
374 async fn malformed_headers_fall_through_to_next_valid_source() {
375 let mut parts = parts([
376 ("X-Forwarded-For", "foo"),
377 ("X-Real-Ip", "foo"),
378 ("Forwarded", "foo"),
379 ("Forwarded", "for=1.1.1.1;proto=https;by=2.2.2.2"),
380 ]);
381 let ClientIp(ip) = extract_client_ip(&mut parts).await.unwrap();
382 assert_eq!(ip.to_string(), "1.1.1.1");
383 }
384
385 #[tokio::test]
386 async fn no_headers_or_connect_info_rejects() {
387 let mut parts = parts(iter::empty());
388 let err = extract_client_ip(&mut parts).await.unwrap_err();
389 assert_eq!(err.0, StatusCode::INTERNAL_SERVER_ERROR);
390 assert!(err.1.contains("ConnectInfo"), "{err:?}");
391 }
392
393 #[tokio::test]
394 async fn configured_source_uses_secure_extraction() {
395 let mut parts = parts([("X-Forwarded-For", "1.1.1.1, 2.2.2.2")]);
396 parts
397 .extensions
398 .insert(ConfiguredIpSource(IpSource::RightmostXForwardedFor));
399 let ClientIp(ip) = extract_client_ip(&mut parts).await.unwrap();
400 assert_eq!(ip.to_string(), "2.2.2.2");
401 }
402
403 #[tokio::test]
404 async fn configured_source_without_matching_header_rejects() {
405 let mut parts = parts(iter::empty());
406 parts
407 .extensions
408 .insert(ConfiguredIpSource(IpSource::RightmostXForwardedFor));
409 let err = extract_client_ip(&mut parts).await.unwrap_err();
410 assert_eq!(err.0, StatusCode::INTERNAL_SERVER_ERROR);
411 assert_eq!(err.1, "Can't extract client IP from configured http.ip_source");
412 }
413
414 #[tokio::test]
415 async fn connect_info_fallback_uses_real_socket_addr_without_config() {
416 let socket_addr = SocketAddr::from(([203, 0, 113, 9], 4567));
417 let mut parts = parts(iter::empty());
418 parts.extensions.insert(ConnectInfo(socket_addr));
419
420 let ClientIp(ip) = extract_client_ip(&mut parts).await.unwrap();
421 assert_eq!(ip, socket_addr.ip());
422 }
423
424 #[tokio::test]
425 async fn loopback_peer_bypasses_configured_source_for_locally_connected_bridges() {
426 let socket_addr = SocketAddr::from(([127, 0, 0, 1], 38000));
427 let mut parts = parts(iter::empty());
428 parts.extensions.insert(ConnectInfo(socket_addr));
429 parts
430 .extensions
431 .insert(ConfiguredIpSource(IpSource::RightmostXForwardedFor));
432
433 let ClientIp(ip) = extract_client_ip(&mut parts).await.unwrap();
434 assert_eq!(ip, socket_addr.ip());
435 }
436
437 #[tokio::test]
438 async fn unix_socket_peer_bypasses_configured_source() {
439 let (mut parts, ()) = Request::builder()
440 .extension(ConnectInfo(UNIX_SOCKET_PEER))
441 .extension(ConfiguredIpSource(IpSource::RightmostXForwardedFor))
442 .body(())
443 .unwrap()
444 .into_parts();
445
446 let ClientIp(ip) = extract_client_ip(&mut parts).await.unwrap();
447
448 assert_eq!(ip, UNIX_SOCKET_PEER.ip());
449 }
450
451 #[tokio::test]
452 async fn loopback_peer_with_proxy_header_still_uses_insecure_fallback() {
453 let socket_addr = SocketAddr::from(([127, 0, 0, 1], 38000));
458 let mut parts = parts([("X-Forwarded-For", "9.9.9.9")]);
459 parts.extensions.insert(ConnectInfo(socket_addr));
460 parts
461 .extensions
462 .insert(ConfiguredIpSource(IpSource::RightmostXForwardedFor));
463
464 let ClientIp(ip) = extract_client_ip(&mut parts).await.unwrap();
465 assert_eq!(ip.to_string(), "9.9.9.9");
466 }
467
468 #[tokio::test]
469 async fn ipv6_loopback_peer_also_bypasses_configured_source() {
470 let socket_addr = SocketAddr::from(([0_u16, 0, 0, 0, 0, 0, 0, 1], 38000));
471 let mut parts = parts(iter::empty());
472 parts.extensions.insert(ConnectInfo(socket_addr));
473 parts
474 .extensions
475 .insert(ConfiguredIpSource(IpSource::RightmostXForwardedFor));
476
477 let ClientIp(ip) = extract_client_ip(&mut parts).await.unwrap();
478 assert_eq!(ip, socket_addr.ip());
479 }
480
481 #[tokio::test]
482 async fn non_loopback_peer_with_configured_source_still_rejects() {
483 let socket_addr = SocketAddr::from(([203, 0, 113, 9], 38000));
484 let mut parts = parts(iter::empty());
485 parts.extensions.insert(ConnectInfo(socket_addr));
486 parts
487 .extensions
488 .insert(ConfiguredIpSource(IpSource::RightmostXForwardedFor));
489
490 let err = extract_client_ip(&mut parts).await.unwrap_err();
491 assert_eq!(err.0, StatusCode::INTERNAL_SERVER_ERROR);
492 assert_eq!(err.1, "Can't extract client IP from configured http.ip_source");
493 }
494
495 #[tokio::test]
496 async fn trusted_subnet_peer_bypasses_configured_source() {
497 let socket_addr = SocketAddr::from(([172, 18, 0, 5], 38000));
498 let mut parts = parts(iter::empty());
499 parts.extensions.insert(ConnectInfo(socket_addr));
500 parts
501 .extensions
502 .insert(ConfiguredIpSource(IpSource::RightmostXForwardedFor));
503 parts
504 .extensions
505 .insert(trusted(&["172.18.0.0/16"]));
506
507 let ClientIp(ip) = extract_client_ip(&mut parts).await.unwrap();
508 assert_eq!(ip, socket_addr.ip());
509 }
510
511 #[tokio::test]
512 async fn trusted_subnet_peer_with_proxy_header_uses_insecure_fallback() {
513 let socket_addr = SocketAddr::from(([172, 18, 0, 5], 38000));
514 let mut parts = parts([("X-Forwarded-For", "9.9.9.9")]);
515 parts.extensions.insert(ConnectInfo(socket_addr));
516 parts
517 .extensions
518 .insert(ConfiguredIpSource(IpSource::RightmostXForwardedFor));
519 parts
520 .extensions
521 .insert(trusted(&["172.18.0.0/16"]));
522
523 let ClientIp(ip) = extract_client_ip(&mut parts).await.unwrap();
524 assert_eq!(ip.to_string(), "9.9.9.9");
525 }
526
527 #[tokio::test]
528 async fn non_trusted_peer_with_subnets_configured_still_rejects() {
529 let socket_addr = SocketAddr::from(([203, 0, 113, 9], 38000));
530 let mut parts = parts(iter::empty());
531 parts.extensions.insert(ConnectInfo(socket_addr));
532 parts
533 .extensions
534 .insert(ConfiguredIpSource(IpSource::RightmostXForwardedFor));
535 parts
536 .extensions
537 .insert(trusted(&["172.18.0.0/16"]));
538
539 let err = extract_client_ip(&mut parts).await.unwrap_err();
540 assert_eq!(err.0, StatusCode::INTERNAL_SERVER_ERROR);
541 assert_eq!(err.1, "Can't extract client IP from configured http.ip_source");
542 }
543
544 #[tokio::test]
545 async fn ipv6_trusted_subnet_peer_bypasses_configured_source() {
546 let socket_addr = SocketAddr::from(([0xFD00_u16, 0, 0, 0, 0, 0, 0, 1], 38000));
547 let mut parts = parts(iter::empty());
548 parts.extensions.insert(ConnectInfo(socket_addr));
549 parts
550 .extensions
551 .insert(ConfiguredIpSource(IpSource::RightmostXForwardedFor));
552 parts.extensions.insert(trusted(&["fd00::/8"]));
553
554 let ClientIp(ip) = extract_client_ip(&mut parts).await.unwrap();
555 assert_eq!(ip, socket_addr.ip());
556 }
557
558 #[tokio::test]
559 async fn trusted_single_host_cidr_matches_only_that_address() {
560 let configured = ConfiguredIpSource(IpSource::RightmostXForwardedFor);
561
562 let mut listed = parts(iter::empty());
563 listed
564 .extensions
565 .insert(ConnectInfo(SocketAddr::from(([10, 0, 0, 5], 38000))));
566 listed.extensions.insert(configured);
567 listed
568 .extensions
569 .insert(trusted(&["10.0.0.5/32"]));
570
571 let ClientIp(ip) = extract_client_ip(&mut listed).await.unwrap();
572 assert_eq!(ip.to_string(), "10.0.0.5");
573
574 let mut neighbour = parts(iter::empty());
575 neighbour
576 .extensions
577 .insert(ConnectInfo(SocketAddr::from(([10, 0, 0, 6], 38000))));
578 neighbour.extensions.insert(configured);
579 neighbour
580 .extensions
581 .insert(trusted(&["10.0.0.5/32"]));
582
583 let err = extract_client_ip(&mut neighbour)
584 .await
585 .unwrap_err();
586 assert_eq!(err.0, StatusCode::INTERNAL_SERVER_ERROR);
587 }
588
589 #[tokio::test]
590 async fn loopback_still_bypasses_when_trusted_subnets_extension_absent() {
591 let socket_addr = SocketAddr::from(([127, 0, 0, 1], 38000));
592 let mut parts = parts(iter::empty());
593 parts.extensions.insert(ConnectInfo(socket_addr));
594 parts
595 .extensions
596 .insert(ConfiguredIpSource(IpSource::RightmostXForwardedFor));
597
598 let ClientIp(ip) = extract_client_ip(&mut parts).await.unwrap();
599 assert_eq!(ip, socket_addr.ip());
600 }
601}