Skip to main content

tuwunel_api/router/
client_ip.rs

1//! Extracts the client IP address from request metadata.
2//!
3//! Configuring `http.ip_source` installs [`ConfiguredIpSource`] in request
4//! extensions and selects its address source. Loopback peers and peers in
5//! [`TrustedPeerSubnets`] instead use the insecure header scan and `ConnectInfo`
6//! fallback, because locally connected appservices and containerized bridges on
7//! trusted private networks, including Docker networks, cannot spoof their peer
8//! address at the IP layer.
9//! Without a configured source, that same fallback preserves the default
10//! behavior, including the socket-address fallback needed by UNIX sockets.
11
12use 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/// Resolves the client IP address from request metadata.
24///
25/// Source selection and trusted-peer fallbacks follow the module's policy.
26#[derive(Clone, Copy, Debug)]
27pub struct ClientIp(
28	/// Client IP address resolved from the request.
29	pub IpAddr,
30);
31
32/// Resolves an address for authentication rate limits.
33///
34/// Uses the configured source without trusted-peer bypasses, or the socket peer
35/// when no source is configured. Header sources require a protected listener and
36/// a proxy that supplies the selected header reliably.
37#[derive(Clone, Copy, Debug)]
38pub struct RateLimitIp(
39	/// Address used to partition authentication attempts.
40	pub IpAddr,
41);
42
43/// Marks the explicitly configured client IP source.
44///
45/// Request extensions contain this wrapper only when an operator has set
46/// `http.ip_source`.
47#[derive(Clone, Copy, Debug)]
48pub struct ConfiguredIpSource(pub IpSource);
49
50/// Identifies trusted subnets whose TCP peers bypass secure IP extraction.
51///
52/// Their peers bypass `http.ip_source` in the same way loopback peers do.
53/// Request extensions contain this wrapper only when the configured list is
54/// non-empty.
55#[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
159/// Leftmost header scan with `ConnectInfo` fallback.
160fn 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
184/// Parse `for=` from the leftmost RFC 7239 stanza. Tolerates quoted
185/// values, bracketed IPv6, and an optional `:port` suffix.
186fn 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		// When a loopback peer also forwards a proxy header (e.g. a local
454		// reverse proxy in a sidecar), the insecure leftmost-XFF behaviour wins
455		// over the loopback ConnectInfo fallback, matching how the unconfigured
456		// path already behaves.
457		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}