✨ (web): Añade HttpRequest::client_ip()

This commit is contained in:
Manuel Cillero 2026-10-31 20:42:51 +01:00
parent 1df91ce4c8
commit 3c6dea9728
4 changed files with 192 additions and 22 deletions

View file

@ -101,12 +101,17 @@ prefix = "tracing.log" # Prefijo de los archivos de traza (si ro
format = "Full" # Formato: "Full", "Compact", "Pretty" o "Json". format = "Full" # Formato: "Full", "Compact", "Pretty" o "Json".
[server] [server]
bind_address = "localhost" # Dirección de enlace del servidor web. bind_address = "localhost" # Dirección de enlace del servidor web.
bind_port = 8080 # Puerto de escucha 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 max_body_size = 2_097_152 # Tamaño máximo en bytes del cuerpo de una petición que se
# entero en memoria (2 MiB): formularios, JSON... y la suma de # lee entero en memoria (2 MiB): formularios, JSON... y la
# los campos de texto de un formulario con archivos. Una # suma de los campos de texto de un formulario con archivos.
# petición mayor se rechaza con 413. 0 -> sin límite. # 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] [upload]
dir = "uploads" # Directorio de los archivos subidos, absoluto o relativo al dir = "uploads" # Directorio de los archivos subidos, absoluto o relativo al

View file

@ -228,7 +228,9 @@ impl Application {
} }
let listener = tokio::net::TcpListener::from_std(std_listener)?; 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::<std::net::SocketAddr>();
let result = axum::serve(listener, service)
.with_graceful_shutdown(shutdown_signal()) .with_graceful_shutdown(shutdown_signal())
.await; .await;

View file

@ -1,8 +1,12 @@
//! Ajustes de configuración globales de PageTop. //! Ajustes de configuración globales de PageTop.
use crate::core::extension::all::StartupError; use crate::core::extension::all::StartupError;
use crate::web::http::HeaderName;
use crate::{config, settings}; use crate::{config, settings};
use serde::de::Error;
use serde::{Deserialize, Deserializer};
use std::sync::LazyLock; use std::sync::LazyLock;
mod lang_negotiation; 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 /// 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. /// 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), /// Se aplica a los extractores que leen el cuerpo completo, como [`Form`], [`RawForm`] o
/// [`RawForm`](crate::web::RawForm) o el `Json` de Axum, y también a la suma de los campos de /// [`Json`], y también a la suma de los campos de texto de un formulario con archivos recibido
/// texto de un formulario con archivos recibido con /// con [`Upload::receive()`]. Los envíos `multipart/form-data` completos, con sus archivos, los
/// [`Upload::receive()`](crate::web::Upload::receive). Los envíos `multipart/form-data` /// limita en cambio [`max_request_size`] de `[upload]`, porque los archivos se escriben en
/// completos, con sus archivos, los limita en cambio /// disco a medida que llegan. Una petición mayor se rechaza con `413 Payload Too Large`.
/// [`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 /// [`Form`]: crate::web::Form
/// `413 Payload Too Large`. /// [`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] #[default = 2_097_152]
pub max_body_size: usize, 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<String, D::Error> {
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`]. /// Sección **`[upload]`** de la configuración. Forma parte de [`Settings`].
@ -305,4 +352,18 @@ mod tests {
assert!(error.contains("Daly")); assert!(error.contains("Daly"));
assert!(error.contains("Daily")); 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::<ServerSettings>(&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());
}
} }

View file

@ -2,16 +2,16 @@
//! //!
//! Define rutas y handlers: el [`Router`], las operaciones HTTP ([`get`], [`post`], [`put`], //! Define rutas y handlers: el [`Router`], las operaciones HTTP ([`get`], [`post`], [`put`],
//! [`delete`], [`patch`]), los extractores ([`Path`], [`Query`], [`Form`], [`RawForm`], //! [`delete`], [`patch`]), los extractores ([`Path`], [`Query`], [`Form`], [`RawForm`],
//! [`Multipart`], [`Request`]) e [`IntoResponse`], el módulo [`middleware`] para *middlewares* de //! [`Multipart`], [`Request`], [`ConnectInfo`]) e [`IntoResponse`], el módulo [`middleware`] para
//! función, y re-exporta el módulo `http` para tipos de bajo nivel como `StatusCode`, `HeaderName` //! *middlewares* de función, y re-exporta el módulo `http` para tipos de bajo nivel como
//! o `Method`. También ofrece utilidades para servir archivos estáticos, [`ServeDir`] y //! `StatusCode`, `HeaderName` o `Method`. También ofrece utilidades para servir archivos estáticos,
//! [`ServeEmbedded`], para recibir y guardar los archivos subidos en formularios, [`Upload`], y //! [`ServeDir`] y [`ServeEmbedded`], para recibir y guardar los archivos subidos en formularios,
//! para servirlos después con control de acceso, [`Download`]. //! [`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 //! Los handlers son las funciones asíncronas que el servidor invoca al recibir una petición HTTP en
//! una ruta concreta. //! una ruta concreta.
use crate::StaticFile; use crate::{StaticFile, global};
#[doc(inline)] #[doc(inline)]
pub use axum::http; pub use axum::http;
@ -20,7 +20,7 @@ pub use axum::http;
pub use axum::Router; pub use axum::Router;
// Extractores de petición. // 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`. // Partes y errores del extractor `Multipart`.
pub use axum::extract::multipart; pub use axum::extract::multipart;
@ -47,6 +47,7 @@ use axum::extract::FromRequestParts;
use std::collections::HashMap; use std::collections::HashMap;
use std::convert::Infallible; use std::convert::Infallible;
use std::net::{IpAddr, SocketAddr};
use std::sync::Arc; use std::sync::Arc;
use std::task::{Context, Poll}; use std::task::{Context, Poll};
@ -134,6 +135,43 @@ impl HttpRequest {
pub fn extension<T: Send + Sync + 'static>(&self) -> Option<&T> { pub fn extension<T: Send + Sync + 'static>(&self) -> Option<&T> {
self.0.extensions.get::<T>() self.0.extensions.get::<T>()
} }
/// 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<IpAddr> {
let header = global::SETTINGS.server.client_ip_header.as_str();
let ip = if header.is_empty() {
self.extension::<ConnectInfo<SocketAddr>>()
.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<IpAddr> {
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::<SocketAddr>().ok().map(|addr| addr.ip())
})
} }
impl<S: Send + Sync> FromRequestParts<S> for HttpRequest { impl<S: Send + Sync> FromRequestParts<S> for HttpRequest {
@ -573,3 +611,67 @@ pub mod test {
String::from_utf8(bytes.to_vec()).unwrap() 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<IpAddr> {
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"));
}
}