From 3c6dea9728fb1bdfc98e86de5aa4e98bd74da27c Mon Sep 17 00:00:00 2001 From: Manuel Cillero Date: Sat, 31 Oct 2026 20:42:51 +0100 Subject: [PATCH] =?UTF-8?q?=E2=9C=A8=20(web):=20A=C3=B1ade=20HttpRequest::?= =?UTF-8?q?client=5Fip()?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- config/reference.toml | 17 ++++--- src/app.rs | 4 +- src/global.rs | 77 +++++++++++++++++++++++++--- src/web.rs | 116 +++++++++++++++++++++++++++++++++++++++--- 4 files changed, 192 insertions(+), 22 deletions(-) diff --git a/config/reference.toml b/config/reference.toml index 5208120e..ab2157ac 100644 --- a/config/reference.toml +++ b/config/reference.toml @@ -101,12 +101,17 @@ prefix = "tracing.log" # Prefijo de los archivos de traza (si ro format = "Full" # Formato: "Full", "Compact", "Pretty" o "Json". [server] -bind_address = "localhost" # Dirección de enlace del servidor web. -bind_port = 8080 # Puerto de escucha del servidor web. -max_body_size = 2_097_152 # Tamaño máximo en bytes del cuerpo de una petición que se lee - # entero en memoria (2 MiB): formularios, JSON... y la suma de - # los campos de texto de un formulario con archivos. Una - # petición mayor se rechaza con 413. 0 -> sin límite. +bind_address = "localhost" # Dirección de enlace del servidor web. +bind_port = 8080 # Puerto de escucha del servidor web. +max_body_size = 2_097_152 # Tamaño máximo en bytes del cuerpo de una petición que se + # lee entero en memoria (2 MiB): formularios, JSON... y la + # suma de los campos de texto de un formulario con archivos. + # Una petición mayor se rechaza con 413. 0 -> sin límite. +client_ip_header = "" # Cabecera con la IP del cliente tras un proxy inverso: + # "X-Forwarded-For", "X-Real-IP"... (con varias direcciones + # vale la última; "Forwarded" no se admite). Vacía -> la IP + # de la conexión. Sólo si todas las peticiones pasan por el + # proxy y éste escribe siempre la cabecera. [upload] dir = "uploads" # Directorio de los archivos subidos, absoluto o relativo al diff --git a/src/app.rs b/src/app.rs index 749a2b82..c7b2312d 100644 --- a/src/app.rs +++ b/src/app.rs @@ -228,7 +228,9 @@ impl Application { } let listener = tokio::net::TcpListener::from_std(std_listener)?; - let result = axum::serve(listener, router) + // Con la dirección de cada conexión, para `HttpRequest::client_ip()`. + let service = router.into_make_service_with_connect_info::(); + let result = axum::serve(listener, service) .with_graceful_shutdown(shutdown_signal()) .await; diff --git a/src/global.rs b/src/global.rs index baaf7248..607d1e7f 100644 --- a/src/global.rs +++ b/src/global.rs @@ -1,8 +1,12 @@ //! Ajustes de configuración globales de PageTop. use crate::core::extension::all::StartupError; +use crate::web::http::HeaderName; use crate::{config, settings}; +use serde::de::Error; +use serde::{Deserialize, Deserializer}; + use std::sync::LazyLock; mod lang_negotiation; @@ -227,16 +231,59 @@ pub struct ServerSettings { /// Tamaño máximo en bytes del cuerpo de una petición que se lee entero en memoria (por defecto /// 2 MiB, el mismo que aplica Axum). Con *0* no hay límite. /// - /// Se aplica a los extractores que leen el cuerpo completo, como [`Form`](crate::web::Form), - /// [`RawForm`](crate::web::RawForm) o el `Json` de Axum, y también a la suma de los campos de - /// texto de un formulario con archivos recibido con - /// [`Upload::receive()`](crate::web::Upload::receive). Los envíos `multipart/form-data` - /// completos, con sus archivos, los limita en cambio - /// [`max_request_size`](UploadSettings::max_request_size) de `[upload]`, porque los archivos se - /// escriben en disco a medida que llegan. Una petición mayor se rechaza con - /// `413 Payload Too Large`. + /// Se aplica a los extractores que leen el cuerpo completo, como [`Form`], [`RawForm`] o + /// [`Json`], y también a la suma de los campos de texto de un formulario con archivos recibido + /// con [`Upload::receive()`]. Los envíos `multipart/form-data` completos, con sus archivos, los + /// limita en cambio [`max_request_size`] de `[upload]`, porque los archivos se escriben en + /// disco a medida que llegan. Una petición mayor se rechaza con `413 Payload Too Large`. + /// + /// [`Form`]: crate::web::Form + /// [`RawForm`]: crate::web::RawForm + /// [`Json`]: crate::response::Json + /// [`Upload::receive()`]: crate::web::Upload::receive + /// [`max_request_size`]: UploadSettings::max_request_size #[default = 2_097_152] pub max_body_size: usize, + /// Cabecera con la dirección IP del cliente, cuando la aplicación está detrás de un *proxy* + /// inverso o de un balanceador (p. ej. `"X-Forwarded-For"` o `"X-Real-IP"`). Vacía, la + /// dirección es la de la conexión. Ver [`HttpRequest::client_ip()`]. + /// + /// Si la cabecera tiene varias direcciones, vale la última, la que añade el *proxy* más cercano + /// a la aplicación. Con varios *proxies* encadenados, esa última sería la del anterior: usa + /// entonces una cabecera con una única dirección que escriba el primero, el que recibe la + /// conexión del cliente. + /// + /// Configúrala sólo si todas las peticiones pasan por el *proxy* y éste escribe siempre la + /// cabecera, sustituyendo o completando la que llegue: si no, cualquiera podría enviarla con la + /// dirección que quisiera. + /// + /// Debe ser un nombre de cabecera HTTP válido; si no, la aplicación no arranca. Tampoco admite + /// `Forwarded` (RFC 7239), cuyos valores (`for=...;proto=...`) no son sólo direcciones. + /// + /// [`HttpRequest::client_ip()`]: crate::web::HttpRequest::client_ip + #[default = ""] + #[serde(deserialize_with = "header_name")] + pub client_ip_header: String, +} + +// Nombre de cabecera para `client_ip_header`: vacío o un nombre de cabecera HTTP válido, sin +// espacios en los extremos. Un nombre que no lo fuera nunca encontraría la cabecera, y +// `HttpRequest::client_ip()` devolvería siempre `None` sin que nada lo indicase. +fn header_name<'de, D: Deserializer<'de>>(deserializer: D) -> Result { + let raw = String::deserialize(deserializer)?; + let name = raw.trim(); + if name.eq_ignore_ascii_case("forwarded") { + return Err(D::Error::custom( + "the Forwarded header (RFC 7239) is not supported; use one with only addresses, such \ + as X-Forwarded-For or X-Real-IP", + )); + } + if !name.is_empty() && HeaderName::from_bytes(name.as_bytes()).is_err() { + return Err(D::Error::custom(format!( + "invalid HTTP header name \"{name}\"" + ))); + } + Ok(name.to_owned()) } /// Sección **`[upload]`** de la configuración. Forma parte de [`Settings`]. @@ -305,4 +352,18 @@ mod tests { assert!(error.contains("Daly")); assert!(error.contains("Daily")); } + + #[test] + fn client_ip_header_must_be_a_valid_header_name() { + let load = |value: &str| { + let toml = format!("[server]\nclient_ip_header = \"{value}\"\n"); + config::load_from_str::(&toml) + }; + assert_eq!(load(" X-Real-IP ").unwrap().client_ip_header, "X-Real-IP"); + assert_eq!(load("").unwrap().client_ip_header, ""); + let error = load("X Real IP").expect_err("invalid name accepted"); + assert!(error.to_string().contains("X Real IP"), "{error}"); + // Its values are not plain addresses, so it would never give one. + assert!(load("Forwarded").is_err()); + } } diff --git a/src/web.rs b/src/web.rs index cb8dc06c..4a2e950c 100644 --- a/src/web.rs +++ b/src/web.rs @@ -2,16 +2,16 @@ //! //! Define rutas y handlers: el [`Router`], las operaciones HTTP ([`get`], [`post`], [`put`], //! [`delete`], [`patch`]), los extractores ([`Path`], [`Query`], [`Form`], [`RawForm`], -//! [`Multipart`], [`Request`]) e [`IntoResponse`], el módulo [`middleware`] para *middlewares* de -//! función, y re-exporta el módulo `http` para tipos de bajo nivel como `StatusCode`, `HeaderName` -//! o `Method`. También ofrece utilidades para servir archivos estáticos, [`ServeDir`] y -//! [`ServeEmbedded`], para recibir y guardar los archivos subidos en formularios, [`Upload`], y -//! para servirlos después con control de acceso, [`Download`]. +//! [`Multipart`], [`Request`], [`ConnectInfo`]) e [`IntoResponse`], el módulo [`middleware`] para +//! *middlewares* de función, y re-exporta el módulo `http` para tipos de bajo nivel como +//! `StatusCode`, `HeaderName` o `Method`. También ofrece utilidades para servir archivos estáticos, +//! [`ServeDir`] y [`ServeEmbedded`], para recibir y guardar los archivos subidos en formularios, +//! [`Upload`], y para servirlos después con control de acceso, [`Download`]. //! //! Los handlers son las funciones asíncronas que el servidor invoca al recibir una petición HTTP en //! una ruta concreta. -use crate::StaticFile; +use crate::{StaticFile, global}; #[doc(inline)] pub use axum::http; @@ -20,7 +20,7 @@ pub use axum::http; pub use axum::Router; // Extractores de petición. -pub use axum::extract::{Form, Multipart, Path, Query, RawForm, Request}; +pub use axum::extract::{ConnectInfo, Form, Multipart, Path, Query, RawForm, Request}; // Partes y errores del extractor `Multipart`. pub use axum::extract::multipart; @@ -47,6 +47,7 @@ use axum::extract::FromRequestParts; use std::collections::HashMap; use std::convert::Infallible; +use std::net::{IpAddr, SocketAddr}; use std::sync::Arc; use std::task::{Context, Poll}; @@ -134,6 +135,43 @@ impl HttpRequest { pub fn extension(&self) -> Option<&T> { self.0.extensions.get::() } + + /// Devuelve la dirección IP del cliente que hace la petición, si se conoce. + /// + /// Por defecto es la dirección desde la que llega la conexión. Detrás de un *proxy* inverso o + /// de un balanceador, esa dirección es siempre la del *proxy*: entonces hay que indicar en + /// [`client_ip_header`](crate::global::ServerSettings::client_ip_header) de `[server]` la + /// cabecera en la que el *proxy* escribe la dirección del cliente. + /// + /// Las direcciones IPv4 se devuelven siempre como tales, también las que llegan en forma IPv6 + /// (`::ffff:192.0.2.1`), como ocurre al escuchar en `"::"`: así una misma dirección es siempre + /// el mismo valor. + /// + /// Devuelve `None` si la cabecera configurada falta o no contiene una dirección válida (nunca + /// la de la conexión, que sería la del *proxy*), y en las pruebas, que no abren conexiones + /// (salvo que la petición incluya [`ConnectInfo`]). + pub fn client_ip(&self) -> Option { + let header = global::SETTINGS.server.client_ip_header.as_str(); + let ip = if header.is_empty() { + self.extension::>() + .map(|ConnectInfo(addr)| addr.ip()) + } else { + ip_from_header(&self.0.headers, header) + }; + ip.map(|ip| ip.to_canonical()) + } +} + +// Dirección IP de la cabecera `name`. Si la cabecera se repite o tiene varias direcciones separadas +// por comas (como `X-Forwarded-For`), vale la última: la que añadió el último *proxy*, el de la +// propia aplicación. Las anteriores las envía el cliente y puede inventarlas. +fn ip_from_header(headers: &http::HeaderMap, name: &str) -> Option { + let value = headers.get_all(name).iter().next_back()?.to_str().ok()?; + let last = value.rsplit(',').next()?.trim(); + last.parse().ok().or_else(|| { + // Una dirección IPv4 o IPv6 con puerto (`203.0.113.7:4711`, `[2001:db8::1]:4711`). + last.parse::().ok().map(|addr| addr.ip()) + }) } impl FromRequestParts for HttpRequest { @@ -573,3 +611,67 @@ pub mod test { String::from_utf8(bytes.to_vec()).unwrap() } } + +#[cfg(test)] +mod tests { + use super::*; + + fn headers(values: &[&str]) -> http::HeaderMap { + let mut headers = http::HeaderMap::new(); + for value in values { + headers.append("x-forwarded-for", value.parse().unwrap()); + } + headers + } + + fn ip(value: &str) -> Option { + Some(value.parse().unwrap()) + } + + #[test] + fn the_last_address_of_the_header_wins() { + let from = |values| ip_from_header(&headers(values), "X-Forwarded-For"); + assert_eq!(from(&["203.0.113.7"]), ip("203.0.113.7")); + // Earlier addresses are sent by the client and may be forged. + assert_eq!(from(&["10.0.0.1, 203.0.113.7"]), ip("203.0.113.7")); + assert_eq!(from(&["10.0.0.1", "203.0.113.7"]), ip("203.0.113.7")); + assert_eq!(from(&["2001:db8::1"]), ip("2001:db8::1")); + assert_eq!(from(&["203.0.113.7:4711"]), ip("203.0.113.7")); + assert_eq!(from(&["[2001:db8::1]:4711"]), ip("2001:db8::1")); + } + + #[test] + fn a_missing_or_invalid_header_gives_no_address() { + assert_eq!(ip_from_header(&headers(&[]), "X-Forwarded-For"), None); + assert_eq!( + ip_from_header(&headers(&["203.0.113.7, unknown"]), "X-Forwarded-For"), + None + ); + } + + #[test] + fn without_a_header_the_connection_address_is_used() { + let request = test::TestRequest::get() + .with_extension(ConnectInfo(SocketAddr::from(([198, 51, 100, 2], 4711)))) + .to_http_request(); + assert_eq!(request.client_ip(), ip("198.51.100.2")); + assert_eq!(test::TestRequest::get().to_http_request().client_ip(), None); + } + + #[test] + fn ipv4_addresses_seen_through_ipv6_are_returned_as_ipv4() { + // A dual-stack socket ("::") sees IPv4 clients as IPv4-mapped IPv6 addresses. + let mapped: SocketAddr = "[::ffff:198.51.100.2]:4711".parse().unwrap(); + let request = test::TestRequest::get() + .with_extension(ConnectInfo(mapped)) + .to_http_request(); + assert_eq!(request.client_ip(), ip("198.51.100.2")); + let request = test::TestRequest::get() + .with_extension(ConnectInfo(SocketAddr::from(( + [0x2001, 0xdb8, 0, 0, 0, 0, 0, 1], + 80, + )))) + .to_http_request(); + assert_eq!(request.client_ip(), ip("2001:db8::1")); + } +}