🔒️ Protección CSRF y límite de logins por IP
- CSRF sin tokens en el núcleo: se rechazan con 403 las peticiones que cambian estado si el navegador indica otro origen (`Sec-Fetch-Site`, y `Origin` frente a `Host`), con el criterio de Go. Sin interruptor. - Nuevo `[server] trusted_origins`, validado y normalizado al arrancar. - (user): `max_ip_failed_logins` limita por IP los logins fallidos; el intento se anota antes de Argon2 para que no se salte en paralelo. - (user): avisos para la página siguiente tras registro, verificación, restablecimiento de contraseña y cambio de email. - `flows.rs` ignora las marcas de componentes aplazados al comparar.
This commit is contained in:
parent
c9fdc7afc7
commit
574010374d
19 changed files with 639 additions and 35 deletions
|
|
@ -10,7 +10,7 @@ use crate::datetime::Timezone;
|
|||
use crate::locale::Locale;
|
||||
use crate::response::route_not_found;
|
||||
use crate::response::{keep_flash_messages, render_error_pages, response_for_panic};
|
||||
use crate::web::{Request, Response, Router, http};
|
||||
use crate::web::{Request, Response, Router, http, reject_cross_origin};
|
||||
use crate::{PAGETOP_VERSION, global, trace};
|
||||
|
||||
use axum::extract::DefaultBodyLimit;
|
||||
|
|
@ -259,6 +259,9 @@ impl Application {
|
|||
// Los mensajes *flash* (`keep_flash_messages()`) se registran junto al middleware de las
|
||||
// extensiones, también antes de los archivos estáticos, que no los muestran.
|
||||
//
|
||||
// La protección CSRF (`web::reject_cross_origin()`) va por fuera del middleware de las
|
||||
// extensiones: una petición rechazada no llega a resolver la sesión.
|
||||
//
|
||||
// El límite del cuerpo de las peticiones (`limit_body()`) sustituye al de Axum en todas las
|
||||
// rutas.
|
||||
//
|
||||
|
|
@ -271,6 +274,7 @@ impl Application {
|
|||
.layer(axum::middleware::from_fn(keep_flash_messages));
|
||||
let router = extension::all::configure_static_files(router);
|
||||
router
|
||||
.layer(axum::middleware::from_fn(reject_cross_origin))
|
||||
.layer(axum::middleware::from_fn(limit_body))
|
||||
.layer(axum::middleware::from_fn(render_error_pages))
|
||||
.layer(CatchPanicLayer::custom(response_for_panic))
|
||||
|
|
|
|||
|
|
@ -3,22 +3,24 @@ use crate::prelude::*;
|
|||
/// Componente para crear un **campo oculto** del formulario.
|
||||
///
|
||||
/// Renderiza un campo sin ningún marcado visible. Su valor se envía al servidor junto con el resto
|
||||
/// del formulario, pero el usuario no puede verlo ni modificarlo.
|
||||
/// del formulario, aunque el usuario no lo vea en la página.
|
||||
///
|
||||
/// Es útil para transportar datos de estado, tokens CSRF, identificadores o cualquier valor que
|
||||
/// deba incluirse en el envío sin ser accesible al usuario.
|
||||
/// Es útil para transportar datos de estado, identificadores o cualquier valor que deba incluirse
|
||||
/// en el envío sin mostrarse. **No es un dato protegido**: el usuario puede verlo en el código de
|
||||
/// la página y cambiarlo antes de enviar el formulario, así que el servidor debe validarlo como
|
||||
/// cualquier otro campo.
|
||||
///
|
||||
/// # Ejemplo
|
||||
///
|
||||
/// ```rust,no_run
|
||||
/// use pagetop::prelude::*;
|
||||
///
|
||||
/// let token = form::Hidden::new()
|
||||
/// .with_name("csrf_token")
|
||||
/// .with_value("a1b2c3d4e5");
|
||||
/// let item = form::Hidden::new()
|
||||
/// .with_name("item_id")
|
||||
/// .with_value("42");
|
||||
///
|
||||
/// // Equivalente, cuando `name` y `value` se conocen de antemano:
|
||||
/// let token = form::Hidden::field("csrf_token", "a1b2c3d4e5");
|
||||
/// let item = form::Hidden::field("item_id", "42");
|
||||
/// ```
|
||||
///
|
||||
/// Al enviar el formulario el navegador transmite `name=valor`. En el servidor se deserializa
|
||||
|
|
@ -27,7 +29,7 @@ use crate::prelude::*;
|
|||
/// ```rust,ignore
|
||||
/// #[derive(serde::Deserialize)]
|
||||
/// struct FormData {
|
||||
/// csrf_token: String,
|
||||
/// item_id: String,
|
||||
/// }
|
||||
/// ```
|
||||
#[derive(AutoDefault, Clone, Debug, Getters)]
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
//! Ajustes de configuración globales de PageTop.
|
||||
|
||||
use crate::core::extension::all::StartupError;
|
||||
use crate::web::http::HeaderName;
|
||||
use crate::web::http::{HeaderName, Uri};
|
||||
use crate::{config, settings};
|
||||
|
||||
use serde::de::Error;
|
||||
|
|
@ -264,6 +264,48 @@ pub struct ServerSettings {
|
|||
#[default = ""]
|
||||
#[serde(deserialize_with = "header_name")]
|
||||
pub client_ip_header: String,
|
||||
/// Otros orígenes desde los que un navegador puede enviar peticiones que cambian estado
|
||||
/// (`POST`, `PUT`, `PATCH`, `DELETE`...), p. ej. `["https://app.example.com"]`.
|
||||
///
|
||||
/// PageTop rechaza con `403 Forbidden` esas peticiones cuando el navegador indica que llegan
|
||||
/// desde otro origen, también desde otro subdominio del mismo sitio, para proteger la
|
||||
/// aplicación frente a CSRF (*Cross-Site Request Forgery*). Esta lista sólo hace falta si otra
|
||||
/// aplicación propia, servida desde otro origen, envía formularios o peticiones `fetch` a ésta.
|
||||
/// Las peticiones que no hace un navegador (`curl`, otros servidores...) no se ven afectadas.
|
||||
///
|
||||
/// Cada origen es `esquema://servidor[:puerto]`, sin ruta. Uno no válido impide arrancar.
|
||||
#[serde(deserialize_with = "origins")]
|
||||
pub trusted_origins: Vec<String>,
|
||||
}
|
||||
|
||||
// Orígenes para `trusted_origins`, tal y como los envía un navegador en la cabecera `Origin`: en
|
||||
// minúsculas, sin `/` final y sin el puerto por defecto del esquema. Un origen con ruta, consulta,
|
||||
// fragmento o credenciales nunca coincidiría con esa cabecera, y quedaría sin efecto sin que nada
|
||||
// lo indicase.
|
||||
fn origins<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Vec<String>, D::Error> {
|
||||
Vec::<String>::deserialize(deserializer)?
|
||||
.iter()
|
||||
.map(|raw| {
|
||||
let origin = raw.trim().trim_end_matches('/').to_ascii_lowercase();
|
||||
let Some(uri) = origin.parse::<Uri>().ok().filter(|uri| {
|
||||
matches!(uri.scheme_str(), Some("http" | "https"))
|
||||
&& uri.authority().is_some_and(|a| !a.as_str().contains('@'))
|
||||
&& uri.path_and_query().is_none_or(|pq| pq.as_str() == "/")
|
||||
&& !origin.contains('#')
|
||||
}) else {
|
||||
return Err(D::Error::custom(format!(
|
||||
"invalid origin \"{raw}\", expected scheme://host[:port] (e.g. \
|
||||
\"https://app.example.com\")"
|
||||
)));
|
||||
};
|
||||
match (uri.scheme_str(), uri.port_u16()) {
|
||||
(Some("http"), Some(80)) | (Some("https"), Some(443)) => Ok(origin
|
||||
.rsplit_once(':')
|
||||
.map_or(origin.clone(), |(o, _)| o.to_owned())),
|
||||
_ => Ok(origin),
|
||||
}
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
// Nombre de cabecera para `client_ip_header`: vacío o un nombre de cabecera HTTP válido, sin
|
||||
|
|
@ -366,4 +408,42 @@ mod tests {
|
|||
// Its values are not plain addresses, so it would never give one.
|
||||
assert!(load("Forwarded").is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn trusted_origins_are_normalized_and_validated() {
|
||||
let load = |value: &str| {
|
||||
let toml = format!("[server]\ntrusted_origins = [\"{value}\"]\n");
|
||||
config::load_from_str::<ServerSettings>(&toml)
|
||||
};
|
||||
let origins = |value| load(value).unwrap().trusted_origins;
|
||||
// Browsers send the Origin header in lowercase and without a trailing slash.
|
||||
assert_eq!(
|
||||
origins(" HTTPS://App.Example.com/ "),
|
||||
["https://app.example.com"]
|
||||
);
|
||||
assert_eq!(origins("http://localhost:3000"), ["http://localhost:3000"]);
|
||||
// Nor with the default port of the scheme, which they leave out.
|
||||
assert_eq!(
|
||||
origins("https://app.example.com:443"),
|
||||
["https://app.example.com"]
|
||||
);
|
||||
assert_eq!(origins("http://[::1]:80"), ["http://[::1]"]);
|
||||
assert_eq!(
|
||||
origins("http://app.example.com:443"),
|
||||
["http://app.example.com:443"]
|
||||
);
|
||||
// None of these could ever match an Origin header.
|
||||
for invalid in [
|
||||
"app.example.com",
|
||||
"ftp://app.example.com",
|
||||
"https://app.example.com/path",
|
||||
"https://app.example.com?x=1",
|
||||
"https://user@app.example.com",
|
||||
"https://app.example.com#top",
|
||||
"",
|
||||
] {
|
||||
let error = load(invalid).expect_err(invalid);
|
||||
assert!(error.to_string().contains("invalid origin"), "{error}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
26
src/web.rs
26
src/web.rs
|
|
@ -10,6 +10,28 @@
|
|||
//!
|
||||
//! Los handlers son las funciones asíncronas que el servidor invoca al recibir una petición HTTP en
|
||||
//! una ruta concreta.
|
||||
//!
|
||||
//! # Protección frente a CSRF
|
||||
//!
|
||||
//! Todas las rutas están protegidas frente a CSRF (*Cross-Site Request Forgery*), sin *tokens* en
|
||||
//! los formularios: una petición que puede cambiar estado (cualquier método salvo `GET`, `HEAD` y
|
||||
//! `OPTIONS`) se rechaza con `403 Forbidden` si el navegador indica que llega desde otro origen
|
||||
//! (cabeceras `Sec-Fetch-Site` y `Origin`), incluido otro subdominio del mismo sitio. Funciona
|
||||
//! igual con formularios, HTMX o `fetch`, y no afecta a las peticiones que no hace un navegador
|
||||
//! (`curl`, otros servidores...), que no llevan esas cabeceras.
|
||||
//!
|
||||
//! Dos consecuencias para las aplicaciones:
|
||||
//!
|
||||
//! - **Un handler `GET` nunca debe cambiar estado** (borrar, cerrar sesión, confirmar...): esas
|
||||
//! acciones van siempre con `POST` u otro método no seguro.
|
||||
//! - Si otra aplicación propia, servida desde otro origen, envía peticiones a ésta, su origen debe
|
||||
//! añadirse a [`trusted_origins`](crate::global::ServerSettings::trusted_origins) de `[server]`.
|
||||
//!
|
||||
//! Detrás de un *proxy* inverso, éste debe conservar la cabecera `Host` original (p. ej.
|
||||
//! `proxy_set_header Host $host;` en nginx): los navegadores que no envían `Sec-Fetch-Site` (o las
|
||||
//! conexiones HTTP sin cifrar fuera de `localhost`) se comprueban comparando `Origin` con `Host`.
|
||||
//!
|
||||
//! Ninguna protección frente a CSRF resiste un fallo de XSS en la propia aplicación.
|
||||
|
||||
use crate::{StaticFile, global};
|
||||
|
||||
|
|
@ -43,6 +65,10 @@ pub use upload::{Upload, UploadError, UploadedFile, UploadedForm};
|
|||
mod download;
|
||||
pub use download::Download;
|
||||
|
||||
// Protección frente a CSRF, aplicada a todas las rutas por `Application`.
|
||||
mod csrf;
|
||||
pub(crate) use csrf::reject_cross_origin;
|
||||
|
||||
use axum::body::Body;
|
||||
use axum::extract::FromRequestParts;
|
||||
|
||||
|
|
|
|||
174
src/web/csrf.rs
Normal file
174
src/web/csrf.rs
Normal file
|
|
@ -0,0 +1,174 @@
|
|||
// Protección frente a CSRF (*Cross-Site Request Forgery*) comprobando el origen de las peticiones,
|
||||
// sin *tokens*, con el mismo criterio que `http.CrossOriginProtection` de Go:
|
||||
//
|
||||
// 1. Los métodos seguros (`GET`, `HEAD`, `OPTIONS`) se admiten siempre: no deben cambiar estado.
|
||||
// 2. Con `Sec-Fetch-Site`, que envían todos los navegadores actuales, sólo se admiten `same-origin`
|
||||
// y `none` (dirección escrita a mano o marcador). `same-site` se rechaza también: una página en
|
||||
// otro subdominio no es la aplicación, y la cookie `SameSite=Lax` no la frena.
|
||||
// 3. Sin `Sec-Fetch-Site` (navegadores antiguos, o HTTP sin cifrar fuera de `localhost`) decide
|
||||
// `Origin`, que debe coincidir con el servidor de la petición.
|
||||
// 4. Sin ninguna de las dos no es un navegador (`curl`, otro servidor, las pruebas), o es uno de
|
||||
// hace años, anterior a enviar `Origin` en los `POST`. Un ataque CSRF necesita un navegador: se
|
||||
// admite.
|
||||
//
|
||||
// En los pasos 2 y 3 se admiten además los orígenes de `server.trusted_origins`.
|
||||
|
||||
use crate::global;
|
||||
use crate::response::ErrorPage;
|
||||
use crate::trace;
|
||||
use crate::web::http::uri::Authority;
|
||||
use crate::web::http::{HeaderMap, HeaderName, Method, header};
|
||||
use crate::web::{HttpRequest, Request, Response};
|
||||
|
||||
use axum::extract::FromRequestParts;
|
||||
use axum::middleware::Next;
|
||||
use axum::response::IntoResponse;
|
||||
|
||||
const SEC_FETCH_SITE: HeaderName = HeaderName::from_static("sec-fetch-site");
|
||||
|
||||
// Rechaza con `403` las peticiones de otro origen que puedan cambiar estado. Va por fuera del
|
||||
// *middleware* de las extensiones, así que una petición rechazada no llega a cargar la sesión.
|
||||
pub(crate) async fn reject_cross_origin(request: Request, next: Next) -> Response {
|
||||
if is_allowed(
|
||||
request.method(),
|
||||
request.headers(),
|
||||
request.uri().authority(),
|
||||
) {
|
||||
return next.run(request).await;
|
||||
}
|
||||
trace::warn!(
|
||||
"Cross-origin request rejected: {} {} (Sec-Fetch-Site: {:?}, Origin: {:?})",
|
||||
request.method(),
|
||||
request.uri().path(),
|
||||
request.headers().get(SEC_FETCH_SITE),
|
||||
request.headers().get(header::ORIGIN),
|
||||
);
|
||||
let (mut parts, _) = request.into_parts();
|
||||
let Ok(request) = HttpRequest::from_request_parts(&mut parts, &()).await;
|
||||
ErrorPage::AccessDenied(Some(request)).into_response()
|
||||
}
|
||||
|
||||
// Con HTTP/2 el servidor llega en la URI (`:authority`) y no siempre en `Host`.
|
||||
fn is_allowed(method: &Method, headers: &HeaderMap, authority: Option<&Authority>) -> bool {
|
||||
if matches!(*method, Method::GET | Method::HEAD | Method::OPTIONS) {
|
||||
return true;
|
||||
}
|
||||
// Una cabecera `Origin` ilegible no coincide con nada, pero sigue indicando un navegador.
|
||||
let origin = headers
|
||||
.get(header::ORIGIN)
|
||||
.map(|v| v.to_str().unwrap_or_default());
|
||||
if let Some(site) = headers.get(SEC_FETCH_SITE) {
|
||||
let site = site.as_bytes();
|
||||
return site == b"same-origin" || site == b"none" || origin.is_some_and(is_trusted);
|
||||
}
|
||||
let Some(origin) = origin else {
|
||||
return true;
|
||||
};
|
||||
let host = authority
|
||||
.map(|a| a.as_str())
|
||||
.or_else(|| headers.get(header::HOST).and_then(|v| v.to_str().ok()));
|
||||
let same_host = origin
|
||||
.split_once("://")
|
||||
.zip(host)
|
||||
.is_some_and(|((_, origin_host), host)| origin_host.eq_ignore_ascii_case(host));
|
||||
same_host || is_trusted(origin)
|
||||
}
|
||||
|
||||
// Los orígenes de confianza se normalizan en minúsculas al cargar la configuración.
|
||||
fn is_trusted(origin: &str) -> bool {
|
||||
global::SETTINGS
|
||||
.server
|
||||
.trusted_origins
|
||||
.iter()
|
||||
.any(|trusted| trusted.eq_ignore_ascii_case(origin))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
use crate::web::http::HeaderValue;
|
||||
|
||||
fn allowed(method: Method, headers: &[(&str, &str)], authority: Option<&str>) -> bool {
|
||||
let mut map = HeaderMap::new();
|
||||
for (name, value) in headers {
|
||||
map.insert(
|
||||
HeaderName::from_bytes(name.as_bytes()).unwrap(),
|
||||
value.parse().unwrap(),
|
||||
);
|
||||
}
|
||||
let authority = authority.map(|a| a.parse().unwrap());
|
||||
is_allowed(&method, &map, authority.as_ref())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn safe_methods_are_always_allowed() {
|
||||
let cross = [("sec-fetch-site", "cross-site")];
|
||||
assert!(allowed(Method::GET, &cross, None));
|
||||
assert!(allowed(Method::HEAD, &cross, None));
|
||||
assert!(allowed(Method::OPTIONS, &cross, None));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sec_fetch_site_decides_when_present() {
|
||||
assert!(allowed(
|
||||
Method::POST,
|
||||
&[("sec-fetch-site", "same-origin")],
|
||||
None
|
||||
));
|
||||
assert!(allowed(Method::POST, &[("sec-fetch-site", "none")], None));
|
||||
// A sibling subdomain is "same-site" but not the application.
|
||||
assert!(!allowed(
|
||||
Method::POST,
|
||||
&[("sec-fetch-site", "same-site")],
|
||||
None
|
||||
));
|
||||
assert!(!allowed(
|
||||
Method::PUT,
|
||||
&[("sec-fetch-site", "cross-site")],
|
||||
None
|
||||
));
|
||||
// A matching Origin does not override a cross-site Sec-Fetch-Site.
|
||||
let headers = [
|
||||
("sec-fetch-site", "cross-site"),
|
||||
("origin", "http://example.com"),
|
||||
];
|
||||
assert!(!allowed(Method::DELETE, &headers, Some("example.com")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn origin_must_match_the_host_without_sec_fetch_site() {
|
||||
let origin = [("origin", "https://example.com"), ("host", "example.com")];
|
||||
assert!(allowed(Method::POST, &origin, None));
|
||||
let origin = [("origin", "https://EXAMPLE.com:8443")];
|
||||
assert!(allowed(Method::POST, &origin, Some("example.com:8443")));
|
||||
let origin = [("origin", "https://evil.example"), ("host", "example.com")];
|
||||
assert!(!allowed(Method::POST, &origin, None));
|
||||
// Opaque origins (sandboxed iframes, some redirects).
|
||||
assert!(!allowed(
|
||||
Method::POST,
|
||||
&[("origin", "null"), ("host", "example.com")],
|
||||
None
|
||||
));
|
||||
// An unreadable Origin is still a browser's, and matches nothing.
|
||||
let mut headers = HeaderMap::new();
|
||||
headers.insert(header::HOST, "example.com".parse().unwrap());
|
||||
headers.insert(
|
||||
header::ORIGIN,
|
||||
HeaderValue::from_bytes(b"https://ex\xe1mple.com").unwrap(),
|
||||
);
|
||||
assert!(!is_allowed(&Method::POST, &headers, None));
|
||||
// Without a known host nothing can match.
|
||||
assert!(!allowed(
|
||||
Method::PATCH,
|
||||
&[("origin", "https://example.com")],
|
||||
None
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn requests_without_browser_headers_are_allowed() {
|
||||
assert!(allowed(Method::POST, &[], None));
|
||||
assert!(allowed(Method::POST, &[("host", "example.com")], None));
|
||||
}
|
||||
}
|
||||
|
|
@ -147,7 +147,9 @@ impl UploadError {
|
|||
|
||||
// **< UploadedFile >*******************************************************************************
|
||||
|
||||
/// Archivo subido y guardado en el servidor por [`Upload::save()`] o [`Upload::receive()`].
|
||||
/// Archivo subido y guardado en el servidor.
|
||||
///
|
||||
/// Lo devuelven [`Upload::save()`] y [`Upload::receive()`].
|
||||
#[derive(Clone, Debug, Getters)]
|
||||
pub struct UploadedFile {
|
||||
/// Devuelve el nombre del campo del formulario en el que llegó el archivo.
|
||||
|
|
@ -173,8 +175,9 @@ pub struct UploadedFile {
|
|||
|
||||
// **< UploadedForm >*******************************************************************************
|
||||
|
||||
/// Envío `multipart/form-data` recibido con [`Upload::receive()`]: los campos de texto
|
||||
/// deserializados en `T` y los archivos ya guardados.
|
||||
/// Envío `multipart/form-data` recibido con [`Upload::receive()`].
|
||||
///
|
||||
/// Contiene los campos de texto, deserializados en `T`, y los archivos ya guardados.
|
||||
///
|
||||
/// **Los archivos se borran al descartar el `UploadedForm`** (al terminar el handler, al salir
|
||||
/// antes con `?`...) salvo que se conserven con [`keep()`](Self::keep). Basta con llamar a `keep()`
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue