🔒️ 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:
Manuel Cillero 2026-11-02 14:34:05 +01:00
parent c9fdc7afc7
commit 574010374d
19 changed files with 639 additions and 35 deletions

View file

@ -112,6 +112,10 @@ client_ip_header = "" # Cabecera con la IP del cliente tras un
# vale la última; "Forwarded" no se admite). Vacía -> la IP # vale la última; "Forwarded" no se admite). Vacía -> la IP
# de la conexión. Sólo si todas las peticiones pasan por el # de la conexión. Sólo si todas las peticiones pasan por el
# proxy y éste escribe siempre la cabecera. # proxy y éste escribe siempre la cabecera.
trusted_origins = [] # Otros orígenes desde los que un navegador puede enviar
# peticiones que cambian estado (POST, PUT...), p. ej.
# ["https://app.example.com"]. Sin ellos, se rechazan con 403
# (protección CSRF). Formato: esquema://servidor[:puerto].
[upload] [upload]
dir = "uploads" # Directorio de los archivos subidos, absoluto o relativo al dir = "uploads" # Directorio de los archivos subidos, absoluto o relativo al
@ -320,6 +324,11 @@ max_ip_requests = 20 # Máximo de registros, recuperaciones de
# inverso requiere 'server.client_ip_header'. Cada instancia # inverso requiere 'server.client_ip_header'. Cada instancia
# cuenta las suyas. 0 -> sin límite. # cuenta las suyas. 0 -> sin límite.
ip_request_window_secs = 3600 # Duración del periodo en segundos (1 hora). ip_request_window_secs = 3600 # Duración del periodo en segundos (1 hora).
max_ip_failed_logins = 30 # Máximo de inicios de sesión fallidos desde una misma IP en
# un periodo de 'ip_failed_login_window_secs' segundos; los
# siguientes se rechazan sin comprobar la contraseña. Frena
# probar contraseñas en muchas cuentas. 0 -> sin límite.
ip_failed_login_window_secs = 900 # Duración del periodo en segundos (15 minutos).
login_strict = false # Dificulta que el navegador recuerde o autorrellene las login_strict = false # Dificulta que el navegador recuerde o autorrellene las
# credenciales en el formulario de acceso. # credenciales en el formulario de acceso.

View file

@ -3,6 +3,7 @@ name = "Testing"
[server] [server]
bind_port = 9000 bind_port = 9000
trusted_origins = ["https://Trusted.example/"]
[upload] [upload]
dir = "target/test-uploads" dir = "target/test-uploads"

View file

@ -149,8 +149,12 @@ por intentos fallidos (`max_failed_logins`), como los del inicio de sesión.
Para que nadie pueda usar la aplicación para enviar correos a direcciones ajenas, las recuperaciones Para que nadie pueda usar la aplicación para enviar correos a direcciones ajenas, las recuperaciones
de contraseña y los cambios de dirección se limitan por cuenta (`max_password_resets` y de contraseña y los cambios de dirección se limitan por cuenta (`max_password_resets` y
`max_email_changes`), y ellos y los registros, también por dirección IP (`max_ip_requests`). Detrás `max_email_changes`), y ellos y los registros, también por dirección IP (`max_ip_requests`).
de un *proxy* inverso, el límite por IP requiere configurar `server.client_ip_header`.
Los inicios de sesión fallidos se limitan también por dirección IP (`max_ip_failed_logins`), para
frenar a quien prueba unas pocas contraseñas habituales en muchas cuentas sin llegar a bloquear
ninguna. Detrás de un *proxy* inverso, los límites por IP requieren configurar
`server.client_ip_header`.
## Créditos ## Créditos

View file

@ -19,6 +19,7 @@ base_url = "https://example.com/"
require_email_verification = true require_email_verification = true
max_failed_logins = 3 max_failed_logins = 3
max_ip_requests = 3 max_ip_requests = 3
max_ip_failed_logins = 3
max_email_changes = 2 max_email_changes = 2
# Costes mínimos de Argon2id: las pruebas cifran muchas contraseñas. # Costes mínimos de Argon2id: las pruebas cifran muchas contraseñas.

View file

@ -126,6 +126,30 @@ pub struct UserSettings {
/// dirección IP: cada una deja de contar al cumplirse este tiempo. /// dirección IP: cada una deja de contar al cumplirse este tiempo.
#[default = 3_600] #[default = 3_600]
pub ip_request_window_secs: i64, pub ip_request_window_secs: i64,
/// Inicios de sesión fallidos que se admiten desde una misma dirección IP en
/// [`ip_failed_login_window_secs`].
///
/// Complementa a [`max_failed_logins`], que bloquea una cuenta tras varios fallos: sin este
/// límite, cualquiera podría probar unas pocas contraseñas habituales en muchas cuentas
/// distintas sin llegar a bloquear ninguna. Alcanzado el límite, el formulario rechaza los
/// intentos de esa dirección, sin comprobar la contraseña, hasta que el fallo más antiguo de
/// los contados deja de contar. Los accesos correctos no cuentan ni ponen el recuento a cero.
/// Las direcciones IPv6 cuentan por su red `/64`.
///
/// Como en [`max_ip_requests`], la dirección es la de
/// [`pagetop::web::HttpRequest::client_ip()`], las peticiones de dirección desconocida no se
/// limitan, y con varias instancias el límite es por instancia. Con `0` no hay límite.
///
/// [`ip_failed_login_window_secs`]: Self::ip_failed_login_window_secs
/// [`max_failed_logins`]: Self::max_failed_logins
/// [`max_ip_requests`]: Self::max_ip_requests
/// [`pagetop::web::HttpRequest::client_ip()`]: pagetop::web::HttpRequest::client_ip
#[default = 30]
pub max_ip_failed_logins: u32,
/// Periodo en segundos, hacia atrás desde cada intento, en el que se cuentan los inicios de
/// sesión fallidos de una misma dirección IP.
#[default = 900]
pub ip_failed_login_window_secs: i64,
/// Sesiones, en la subsección `[user.session]`. /// Sesiones, en la subsección `[user.session]`.
pub session: SessionSettings, pub session: SessionSettings,

View file

@ -486,7 +486,11 @@ pub(crate) async fn email_confirm_post(
match auth::confirm_email_change(uid, &token).await { match auth::confirm_email_change(uid, &token).await {
Ok(()) => { Ok(()) => {
let cx = Context::new(request); let cx = Context::new(request);
Redirect::see_other(cx.route(PROFILE_PATH)).into_response() Redirect::see_other(cx.route(PROFILE_PATH)).with_message(
&cx,
MessageLevel::Info,
Lc::t("msg-email-changed", &LOCALES_USER),
)
} }
Err(AuthError::EmailTaken) => { Err(AuthError::EmailTaken) => {
let title = Lc::t("title-confirm-email-change", &LOCALES_USER); let title = Lc::t("title-confirm-email-change", &LOCALES_USER);

View file

@ -87,7 +87,16 @@ pub async fn login_post(
) -> Response { ) -> Response {
let cx = Context::new(request.clone()); let cx = Context::new(request.clone());
let next = waypoint.or(cx.route("/")); let next = waypoint.or(cx.route("/"));
let result = auth::login(&form.username, &form.password, form.remember).await; // Una dirección que ya ha fallado demasiadas veces no llega a comprobar la contraseña (Argon2).
let result = if throttle::allow_login(&request) {
let result = auth::login(&form.username, &form.password, form.remember).await;
if !matches!(result, Err(AuthError::InvalidCredentials)) {
throttle::forget_login(&request);
}
result
} else {
Err(AuthError::TooManyRequests)
};
match result { match result {
Ok(sid) => { Ok(sid) => {
let cookie = session::build_cookie(&sid, form.remember); let cookie = session::build_cookie(&sid, form.remember);
@ -98,6 +107,7 @@ pub async fn login_post(
AuthError::AccountBlocked => "error-account-blocked", AuthError::AccountBlocked => "error-account-blocked",
AuthError::AccountPending => "error-account-pending", AuthError::AccountPending => "error-account-pending",
AuthError::AccountLocked => "error-account-locked", AuthError::AccountLocked => "error-account-locked",
AuthError::TooManyRequests => "error-too-many-requests",
_ => "error-invalid-credentials", _ => "error-invalid-credentials",
}; };
Page::new(request) Page::new(request)
@ -190,7 +200,11 @@ pub async fn register_post(
) )
.await .await
} }
Ok(_) => Redirect::see_other(cx.route(LOGIN_PATH)), Ok(_) => Redirect::see_other(cx.route(LOGIN_PATH)).with_message(
&cx,
MessageLevel::Info,
Lc::t("msg-account-created", &LOCALES_USER),
),
Err(err) => Page::new(request) Err(err) => Page::new(request)
.with_title(Lc::t("title-register", &LOCALES_USER)) .with_title(Lc::t("title-register", &LOCALES_USER))
.with_child( .with_child(
@ -326,7 +340,11 @@ pub async fn password_reset_confirm_post(
} }
.await; .await;
match result { match result {
Ok(()) => Redirect::see_other(cx.route(LOGIN_PATH)), Ok(()) => Redirect::see_other(cx.route(LOGIN_PATH)).with_message(
&cx,
MessageLevel::Info,
Lc::t("msg-password-reset-done", &LOCALES_USER),
),
Err(err) => { Err(err) => {
let error = match err { let error = match err {
AuthError::InvalidToken => Lc::t("error-token-invalid", &LOCALES_USER), AuthError::InvalidToken => Lc::t("error-token-invalid", &LOCALES_USER),
@ -407,7 +425,11 @@ pub async fn verify_email_post(
} }
.await; .await;
match result { match result {
Ok(()) => Redirect::see_other(cx.route(LOGIN_PATH)), Ok(()) => Redirect::see_other(cx.route(LOGIN_PATH)).with_message(
&cx,
MessageLevel::Info,
Lc::t("msg-email-verified", &LOCALES_USER),
),
Err(_) => ErrorPage::NotFound(Some(request)).into_response(), Err(_) => ErrorPage::NotFound(Some(request)).into_response(),
} }
} }

View file

@ -150,8 +150,12 @@ por intentos fallidos (`max_failed_logins`), como los del inicio de sesión.
Para que nadie pueda usar la aplicación para enviar correos a direcciones ajenas, las recuperaciones Para que nadie pueda usar la aplicación para enviar correos a direcciones ajenas, las recuperaciones
de contraseña y los cambios de dirección se limitan por cuenta (`max_password_resets` y de contraseña y los cambios de dirección se limitan por cuenta (`max_password_resets` y
`max_email_changes`), y ellos y los registros, también por dirección IP (`max_ip_requests`). Detrás `max_email_changes`), y ellos y los registros, también por dirección IP (`max_ip_requests`).
de un *proxy* inverso, el límite por IP requiere configurar `server.client_ip_header`.
Los inicios de sesión fallidos se limitan también por dirección IP (`max_ip_failed_logins`), para
frenar a quien prueba unas pocas contraseñas habituales en muchas cuentas sin llegar a bloquear
ninguna. Detrás de un *proxy* inverso, los límites por IP requieren configurar
`server.client_ip_header`.
*/ */
use pagetop::prelude::*; use pagetop::prelude::*;

View file

@ -74,6 +74,11 @@ msg-email-change-pending =
msg-confirm-email-change = Press the button to use this email address in your account. msg-confirm-email-change = Press the button to use this email address in your account.
msg-account-created = Your account has been created. You can now sign in.
msg-email-verified = Your email address has been confirmed.
msg-password-reset-done = Your password has been changed. Sign in with the new one.
msg-email-changed = Your email address has been changed.
# **< Emails >** # **< Emails >**
mail-greeting = Hello { $username }, mail-greeting = Hello { $username },

View file

@ -74,6 +74,11 @@ msg-email-change-pending =
msg-confirm-email-change = Pulsa el botón para usar esta dirección de correo en tu cuenta. msg-confirm-email-change = Pulsa el botón para usar esta dirección de correo en tu cuenta.
msg-account-created = Tu cuenta se ha creado. Ya puedes iniciar sesión.
msg-email-verified = Tu dirección de correo se ha confirmado.
msg-password-reset-done = Tu contraseña se ha cambiado. Inicia sesión con la nueva.
msg-email-changed = Tu dirección de correo se ha cambiado.
# **< Correos >** # **< Correos >**
mail-greeting = Hola, { $username }: mail-greeting = Hola, { $username }:

View file

@ -1,4 +1,5 @@
//! Límite de solicitudes por dirección IP (`user.max_ip_requests`). //! Límites de solicitudes por dirección IP: las que envían un correo o crean una cuenta
//! (`user.max_ip_requests`) y los inicios de sesión fallidos (`user.max_ip_failed_logins`).
use pagetop::prelude::*; use pagetop::prelude::*;
@ -15,12 +16,20 @@ struct Requests {
purged_at: Instant, purged_at: Instant,
} }
static REQUESTS: LazyLock<Mutex<Requests>> = LazyLock::new(|| { // Cada límite lleva su propia cuenta.
Mutex::new(Requests { type Log = LazyLock<Mutex<Requests>>;
by_ip: HashMap::new(),
purged_at: Instant::now(), const fn new_log() -> Log {
LazyLock::new(|| {
Mutex::new(Requests {
by_ip: HashMap::new(),
purged_at: Instant::now(),
})
}) })
}); }
static REQUESTS: Log = new_log();
static FAILED_LOGINS: Log = new_log();
/// Anota una solicitud de la dirección del cliente y devuelve si se admite, según /// Anota una solicitud de la dirección del cliente y devuelve si se admite, según
/// [`max_ip_requests`](crate::config::UserSettings::max_ip_requests). /// [`max_ip_requests`](crate::config::UserSettings::max_ip_requests).
@ -31,14 +40,12 @@ pub(crate) fn allow(request: &HttpRequest) -> bool {
let Some(ip) = request.client_ip() else { let Some(ip) = request.client_ip() else {
return true; return true;
}; };
let window =
StdDuration::from_secs(u64::try_from(SETTINGS.ip_request_window_secs).unwrap_or(0));
let allowed = allow_at( let allowed = allow_at(
&mut REQUESTS.lock().unwrap_or_else(PoisonError::into_inner), &mut lock(&REQUESTS),
network(ip), network(ip),
Instant::now(), Instant::now(),
SETTINGS.max_ip_requests, SETTINGS.max_ip_requests,
window, window(SETTINGS.ip_request_window_secs),
); );
if !allowed { if !allowed {
trace::warn!("Request limit reached for address {ip}"); trace::warn!("Request limit reached for address {ip}");
@ -46,6 +53,44 @@ pub(crate) fn allow(request: &HttpRequest) -> bool {
allowed allowed
} }
/// Anota un intento de inicio de sesión de la dirección del cliente y devuelve si se admite, según
/// [`max_ip_failed_logins`](crate::config::UserSettings::max_ip_failed_logins).
///
/// El intento se anota antes de comprobar la contraseña, para que varios intentos simultáneos no
/// puedan superar el límite; si no resulta fallido, se retira con [`forget_login()`].
pub(crate) fn allow_login(request: &HttpRequest) -> bool {
let Some(ip) = request.client_ip() else {
return true;
};
let allowed = allow_at(
&mut lock(&FAILED_LOGINS),
network(ip),
Instant::now(),
SETTINGS.max_ip_failed_logins,
window(SETTINGS.ip_failed_login_window_secs),
);
if !allowed {
trace::warn!("Failed login limit reached for address {ip}");
}
allowed
}
/// Retira un intento anotado por [`allow_login()`] que no ha resultado fallido.
pub(crate) fn forget_login(request: &HttpRequest) {
if let Some(ip) = request.client_ip() {
forget_at(&mut lock(&FAILED_LOGINS), network(ip));
}
}
fn lock(log: &Log) -> std::sync::MutexGuard<'_, Requests> {
log.lock().unwrap_or_else(PoisonError::into_inner)
}
fn window(secs: i64) -> StdDuration {
StdDuration::from_secs(u64::try_from(secs).unwrap_or(0))
}
// Anota la solicitud si se admite.
fn allow_at( fn allow_at(
requests: &mut Requests, requests: &mut Requests,
ip: IpAddr, ip: IpAddr,
@ -76,6 +121,13 @@ fn allow_at(
true true
} }
// Retira la solicitud más reciente de la dirección. Todas cuentan igual, así que da lo mismo cuál.
fn forget_at(requests: &mut Requests, ip: IpAddr) {
if let Some(times) = requests.by_ip.get_mut(&ip) {
times.pop_back();
}
}
// Una dirección IPv6 cuenta por su red `/64`: un mismo equipo o red local suele disponer de una red // Una dirección IPv6 cuenta por su red `/64`: un mismo equipo o red local suele disponer de una red
// entera y podría cambiar de dirección en cada solicitud. // entera y podría cambiar de dirección en cada solicitud.
fn network(ip: IpAddr) -> IpAddr { fn network(ip: IpAddr) -> IpAddr {
@ -121,6 +173,18 @@ mod tests {
assert!(!allow_at(&mut log, ip("192.0.2.1"), at(61), 2, WINDOW)); assert!(!allow_at(&mut log, ip("192.0.2.1"), at(61), 2, WINDOW));
} }
#[pagetop::test]
async fn forgotten_requests_free_their_place() {
let start = Instant::now();
let mut log = requests(start);
assert!(allow_at(&mut log, ip("192.0.2.1"), start, 1, WINDOW));
forget_at(&mut log, ip("192.0.2.1"));
assert!(allow_at(&mut log, ip("192.0.2.1"), start, 1, WINDOW));
assert!(!allow_at(&mut log, ip("192.0.2.1"), start, 1, WINDOW));
// Unknown addresses are ignored.
forget_at(&mut log, ip("192.0.2.2"));
}
#[pagetop::test] #[pagetop::test]
async fn zero_maximum_never_limits() { async fn zero_maximum_never_limits() {
let start = Instant::now(); let start = Instant::now();

View file

@ -1,7 +1,8 @@
// End-to-end account flows against a real database. `config/common.toml` gives these tests an // End-to-end account flows against a real database. `config/common.toml` gives these tests an
// in-memory SQLite database with a single connection, the memory mail transport, email // in-memory SQLite database with a single connection, the memory mail transport, email
// verification on sign-up, `max_failed_logins = 3`, `max_ip_requests = 3` and // verification on sign-up, `max_failed_logins = 3`, `max_ip_requests = 3`,
// `max_email_changes = 2` (`max_password_resets` keeps its default, 3). // `max_ip_failed_logins = 3` and `max_email_changes = 2` (`max_password_resets` keeps its
// default, 3).
// //
// Every scenario shares the same database, so they run one after another in a single test (and a // Every scenario shares the same database, so they run one after another in a single test (and a
// single runtime, which also keeps the database connection alive). Each one uses its own accounts // single runtime, which also keeps the database connection alive). Each one uses its own accounts
@ -195,6 +196,7 @@ async fn account_flows() {
email_changes_are_limited_by_account(&client).await; email_changes_are_limited_by_account(&client).await;
password_resets_are_limited_by_account(&client).await; password_resets_are_limited_by_account(&client).await;
requests_are_limited_by_address(&client).await; requests_are_limited_by_address(&client).await;
failed_logins_are_limited_by_address(&client).await;
} }
async fn registration_requires_confirming_the_address(client: &Client) { async fn registration_requires_confirming_the_address(client: &Client) {
@ -223,6 +225,10 @@ async fn registration_requires_confirming_the_address(client: &Client) {
let reply = client.post(path(&verify), "", None).await; let reply = client.post(path(&verify), "", None).await;
assert_eq!(reply.status, Status::SEE_OTHER); assert_eq!(reply.status, Status::SEE_OTHER);
assert_eq!(path(reply.location()), "/user/login"); assert_eq!(path(reply.location()), "/user/login");
// The login page tells so.
let flash = reply.header("set-cookie").split(';').next().unwrap();
let page = client.get("/user/login", Some(flash)).await;
assert!(page.body.contains("Your email address has been confirmed"));
assert!(client.login("ana", "ana-password").await.is_some()); assert!(client.login("ana", "ana-password").await.is_some());
assert!( assert!(
client client
@ -235,6 +241,21 @@ async fn registration_requires_confirming_the_address(client: &Client) {
assert_eq!(client.get(&verify, None).await.status, Status::NOT_FOUND); assert_eq!(client.get(&verify, None).await.status, Status::NOT_FOUND);
} }
// Deferred components leave a mark (`<!-- placeholder ... -->`) with a value of its own on every
// page, so two answers are never identical byte for byte.
fn without_marks(body: &str) -> String {
let mut rest = body;
let mut out = String::with_capacity(body.len());
while let Some(start) = rest.find("<!-- placeholder ") {
out.push_str(&rest[..start]);
rest = rest[start..]
.split_once(" -->")
.map_or("", |(_, after)| after);
}
out.push_str(rest);
out
}
async fn password_reset_links_are_single_use(client: &Client) { async fn password_reset_links_are_single_use(client: &Client) {
verified_account(client, "bea", "bea@example.com", "bea-password").await; verified_account(client, "bea", "bea@example.com", "bea-password").await;
@ -246,7 +267,7 @@ async fn password_reset_links_are_single_use(client: &Client) {
.post("/user/password/reset", "email=bea%40example.com", None) .post("/user/password/reset", "email=bea%40example.com", None)
.await; .await;
assert_eq!(unknown.status, Status::OK); assert_eq!(unknown.status, Status::OK);
assert_eq!(unknown.body, reply.body); assert_eq!(without_marks(&unknown.body), without_marks(&reply.body));
no_mail_to("nobody@example.com").await; no_mail_to("nobody@example.com").await;
let reset = link(&mail_to("bea@example.com").await, "/user/password/reset/"); let reset = link(&mail_to("bea@example.com").await, "/user/password/reset/");
@ -745,3 +766,34 @@ async fn requests_are_limited_by_address(client: &Client) {
let reply = client.send(register([192, 0, 2, 10])).await; let reply = client.send(register([192, 0, 2, 10])).await;
assert!(!reply.body.contains("Too many requests")); assert!(!reply.body.contains("Too many requests"));
} }
async fn failed_logins_are_limited_by_address(client: &Client) {
verified_account(client, "iris", "iris@example.com", "iris-password").await;
let login = |ip: [u8; 4], username: &str, password: &str| {
web::test::TestRequest::post()
.with_extension(web::ConnectInfo(SocketAddr::from((ip, 4711))))
.uri("/user/login")
.form(form(&[("username", username), ("password", password)]))
};
// One guess on each of several accounts: none of them gets locked.
for username in ["iris", "nobody", "carla"] {
let reply = client
.send(login([192, 0, 2, 20], username, "123456"))
.await;
assert_eq!(reply.status, Status::OK);
assert!(!reply.body.contains("Too many requests"));
}
// The address is refused, even with the right password.
let reply = client
.send(login([192, 0, 2, 20], "iris", "iris-password"))
.await;
assert_eq!(reply.status, Status::OK);
assert!(reply.body.contains("Too many requests"));
// Other addresses keep their own count, and the account was never locked.
let reply = client
.send(login([192, 0, 2, 21], "iris", "iris-password"))
.await;
assert_eq!(reply.status, Status::SEE_OTHER);
}

View file

@ -10,7 +10,7 @@ use crate::datetime::Timezone;
use crate::locale::Locale; use crate::locale::Locale;
use crate::response::route_not_found; use crate::response::route_not_found;
use crate::response::{keep_flash_messages, render_error_pages, response_for_panic}; 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 crate::{PAGETOP_VERSION, global, trace};
use axum::extract::DefaultBodyLimit; use axum::extract::DefaultBodyLimit;
@ -259,6 +259,9 @@ impl Application {
// Los mensajes *flash* (`keep_flash_messages()`) se registran junto al middleware de las // 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. // 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 // El límite del cuerpo de las peticiones (`limit_body()`) sustituye al de Axum en todas las
// rutas. // rutas.
// //
@ -271,6 +274,7 @@ impl Application {
.layer(axum::middleware::from_fn(keep_flash_messages)); .layer(axum::middleware::from_fn(keep_flash_messages));
let router = extension::all::configure_static_files(router); let router = extension::all::configure_static_files(router);
router router
.layer(axum::middleware::from_fn(reject_cross_origin))
.layer(axum::middleware::from_fn(limit_body)) .layer(axum::middleware::from_fn(limit_body))
.layer(axum::middleware::from_fn(render_error_pages)) .layer(axum::middleware::from_fn(render_error_pages))
.layer(CatchPanicLayer::custom(response_for_panic)) .layer(CatchPanicLayer::custom(response_for_panic))

View file

@ -3,22 +3,24 @@ use crate::prelude::*;
/// Componente para crear un **campo oculto** del formulario. /// 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 /// 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 /// Es útil para transportar datos de estado, identificadores o cualquier valor que deba incluirse
/// deba incluirse en el envío sin ser accesible al usuario. /// 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 /// # Ejemplo
/// ///
/// ```rust,no_run /// ```rust,no_run
/// use pagetop::prelude::*; /// use pagetop::prelude::*;
/// ///
/// let token = form::Hidden::new() /// let item = form::Hidden::new()
/// .with_name("csrf_token") /// .with_name("item_id")
/// .with_value("a1b2c3d4e5"); /// .with_value("42");
/// ///
/// // Equivalente, cuando `name` y `value` se conocen de antemano: /// // 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 /// Al enviar el formulario el navegador transmite `name=valor`. En el servidor se deserializa
@ -27,7 +29,7 @@ use crate::prelude::*;
/// ```rust,ignore /// ```rust,ignore
/// #[derive(serde::Deserialize)] /// #[derive(serde::Deserialize)]
/// struct FormData { /// struct FormData {
/// csrf_token: String, /// item_id: String,
/// } /// }
/// ``` /// ```
#[derive(AutoDefault, Clone, Debug, Getters)] #[derive(AutoDefault, Clone, Debug, Getters)]

View file

@ -1,7 +1,7 @@
//! 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::web::http::{HeaderName, Uri};
use crate::{config, settings}; use crate::{config, settings};
use serde::de::Error; use serde::de::Error;
@ -264,6 +264,48 @@ pub struct ServerSettings {
#[default = ""] #[default = ""]
#[serde(deserialize_with = "header_name")] #[serde(deserialize_with = "header_name")]
pub client_ip_header: String, 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 // 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. // Its values are not plain addresses, so it would never give one.
assert!(load("Forwarded").is_err()); 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}");
}
}
} }

View file

@ -10,6 +10,28 @@
//! //!
//! 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.
//!
//! # 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}; use crate::{StaticFile, global};
@ -43,6 +65,10 @@ pub use upload::{Upload, UploadError, UploadedFile, UploadedForm};
mod download; mod download;
pub use download::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::body::Body;
use axum::extract::FromRequestParts; use axum::extract::FromRequestParts;

174
src/web/csrf.rs Normal file
View 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));
}
}

View file

@ -147,7 +147,9 @@ impl UploadError {
// **< UploadedFile >******************************************************************************* // **< 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)] #[derive(Clone, Debug, Getters)]
pub struct UploadedFile { pub struct UploadedFile {
/// Devuelve el nombre del campo del formulario en el que llegó el archivo. /// Devuelve el nombre del campo del formulario en el que llegó el archivo.
@ -173,8 +175,9 @@ pub struct UploadedFile {
// **< UploadedForm >******************************************************************************* // **< UploadedForm >*******************************************************************************
/// Envío `multipart/form-data` recibido con [`Upload::receive()`]: los campos de texto /// Envío `multipart/form-data` recibido con [`Upload::receive()`].
/// deserializados en `T` y los archivos ya guardados. ///
/// 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 /// **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()` /// antes con `?`...) salvo que se conserven con [`keep()`](Self::keep). Basta con llamar a `keep()`

120
tests/web_csrf.rs Normal file
View file

@ -0,0 +1,120 @@
use pagetop::prelude::*;
use web::http::StatusCode;
// Paths seen by the extension middleware: a rejected request must not reach it (it would load
// the session).
static SEEN_PATHS: std::sync::Mutex<Vec<String>> = std::sync::Mutex::new(Vec::new());
fn middleware_saw(path: &str) -> bool {
SEEN_PATHS
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.iter()
.any(|seen| seen == path)
}
struct ActionExtension;
#[async_trait]
impl Extension for ActionExtension {
fn configure_router(&self, router: Router) -> Router {
router.route(
"/action/{name}",
web::get(|| async { "read" }).post(|| async { "done" }),
)
}
fn configure_middleware(&self, router: Router) -> Router {
router.layer(web::middleware::from_fn(record_path))
}
}
async fn record_path(request: web::Request, next: web::middleware::Next) -> Response {
SEEN_PATHS
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.push(request.uri().path().to_owned());
next.run(request).await
}
async fn send(request: web::test::TestRequest) -> Response {
let app = web::test::init_router(Application::prepare(&ActionExtension).await.test());
web::test::send_request(&app, request.to_request()).await
}
fn post(path: &str, headers: &[(&str, &str)]) -> web::test::TestRequest {
headers.iter().fold(
web::test::TestRequest::post().uri(path),
|req, (name, value)| req.header(name, value),
)
}
#[pagetop::test]
async fn same_origin_requests_are_allowed() {
let resp = send(post("/action/same", &[("sec-fetch-site", "same-origin")])).await;
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(web::test::read_body_text(resp).await, "done");
let origin = [("origin", "http://example.com"), ("host", "example.com")];
assert_eq!(
send(post("/action/old", &origin)).await.status(),
StatusCode::OK
);
}
#[pagetop::test]
async fn cross_origin_requests_are_rejected_before_the_middleware() {
let resp = send(post("/action/cross", &[("sec-fetch-site", "cross-site")])).await;
assert_eq!(resp.status(), StatusCode::FORBIDDEN);
// The theme renders the 403 page.
assert!(web::test::read_body_text(resp).await.contains("<html"));
assert!(!middleware_saw("/action/cross"));
let resp = send(post(
"/action/subdomain",
&[("sec-fetch-site", "same-site")],
))
.await;
assert_eq!(resp.status(), StatusCode::FORBIDDEN);
let origin = [("origin", "https://evil.example"), ("host", "example.com")];
assert_eq!(
send(post("/action/old-cross", &origin)).await.status(),
StatusCode::FORBIDDEN
);
}
#[pagetop::test]
async fn safe_methods_and_non_browser_clients_are_not_checked() {
let req = web::test::TestRequest::get()
.uri("/action/read")
.header("sec-fetch-site", "cross-site");
assert_eq!(send(req).await.status(), StatusCode::OK);
// No Sec-Fetch-Site nor Origin: not a browser (curl, another server, a webhook).
assert_eq!(
send(post("/action/curl", &[])).await.status(),
StatusCode::OK
);
}
#[pagetop::test]
async fn trusted_origins_are_allowed() {
// `config/test.toml` trusts "https://Trusted.example/", normalized when loaded.
let headers = [
("sec-fetch-site", "cross-site"),
("origin", "https://trusted.example"),
];
assert_eq!(
send(post("/action/trusted", &headers)).await.status(),
StatusCode::OK
);
let headers = [
("origin", "https://trusted.example"),
("host", "example.com"),
];
assert_eq!(
send(post("/action/trusted-old", &headers)).await.status(),
StatusCode::OK
);
}