✨ (web): Añade HttpRequest::client_ip()
This commit is contained in:
parent
1df91ce4c8
commit
3c6dea9728
4 changed files with 192 additions and 22 deletions
|
|
@ -103,10 +103,15 @@ format = "Full" # Formato: "Full", "Compact", "Pretty" o
|
|||
[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.
|
||||
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
|
||||
|
|
|
|||
|
|
@ -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::<std::net::SocketAddr>();
|
||||
let result = axum::serve(listener, service)
|
||||
.with_graceful_shutdown(shutdown_signal())
|
||||
.await;
|
||||
|
||||
|
|
|
|||
|
|
@ -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<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`].
|
||||
|
|
@ -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::<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());
|
||||
}
|
||||
}
|
||||
|
|
|
|||
116
src/web.rs
116
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<T: Send + Sync + 'static>(&self) -> Option<&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 {
|
||||
|
|
@ -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<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"));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue