diff --git a/config/reference.toml b/config/reference.toml index 5055aa0a..1b845948 100644 --- a/config/reference.toml +++ b/config/reference.toml @@ -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 # de la conexión. Sólo si todas las peticiones pasan por el # 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] 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 # cuenta las suyas. 0 -> sin límite. 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 # credenciales en el formulario de acceso. diff --git a/config/test.toml b/config/test.toml index e5df5d56..b146d460 100644 --- a/config/test.toml +++ b/config/test.toml @@ -3,6 +3,7 @@ name = "Testing" [server] bind_port = 9000 +trusted_origins = ["https://Trusted.example/"] [upload] dir = "target/test-uploads" diff --git a/extensions/pagetop-user/README.md b/extensions/pagetop-user/README.md index 301aa552..c3651445 100644 --- a/extensions/pagetop-user/README.md +++ b/extensions/pagetop-user/README.md @@ -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 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 -de un *proxy* inverso, el límite por IP requiere configurar `server.client_ip_header`. +`max_email_changes`), y ellos y los registros, también por dirección IP (`max_ip_requests`). + +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 diff --git a/extensions/pagetop-user/config/common.toml b/extensions/pagetop-user/config/common.toml index 1411191c..06fd3bf5 100644 --- a/extensions/pagetop-user/config/common.toml +++ b/extensions/pagetop-user/config/common.toml @@ -19,6 +19,7 @@ base_url = "https://example.com/" require_email_verification = true max_failed_logins = 3 max_ip_requests = 3 +max_ip_failed_logins = 3 max_email_changes = 2 # Costes mínimos de Argon2id: las pruebas cifran muchas contraseñas. diff --git a/extensions/pagetop-user/src/config.rs b/extensions/pagetop-user/src/config.rs index b2fd212a..01062eda 100644 --- a/extensions/pagetop-user/src/config.rs +++ b/extensions/pagetop-user/src/config.rs @@ -126,6 +126,30 @@ pub struct UserSettings { /// dirección IP: cada una deja de contar al cumplirse este tiempo. #[default = 3_600] 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]`. pub session: SessionSettings, diff --git a/extensions/pagetop-user/src/handlers/account.rs b/extensions/pagetop-user/src/handlers/account.rs index 9fd90dc9..67e6154a 100644 --- a/extensions/pagetop-user/src/handlers/account.rs +++ b/extensions/pagetop-user/src/handlers/account.rs @@ -486,7 +486,11 @@ pub(crate) async fn email_confirm_post( match auth::confirm_email_change(uid, &token).await { Ok(()) => { 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) => { let title = Lc::t("title-confirm-email-change", &LOCALES_USER); diff --git a/extensions/pagetop-user/src/handlers/auth.rs b/extensions/pagetop-user/src/handlers/auth.rs index a9831c4c..d46cda0b 100644 --- a/extensions/pagetop-user/src/handlers/auth.rs +++ b/extensions/pagetop-user/src/handlers/auth.rs @@ -87,7 +87,16 @@ pub async fn login_post( ) -> Response { let cx = Context::new(request.clone()); 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 { Ok(sid) => { let cookie = session::build_cookie(&sid, form.remember); @@ -98,6 +107,7 @@ pub async fn login_post( AuthError::AccountBlocked => "error-account-blocked", AuthError::AccountPending => "error-account-pending", AuthError::AccountLocked => "error-account-locked", + AuthError::TooManyRequests => "error-too-many-requests", _ => "error-invalid-credentials", }; Page::new(request) @@ -190,7 +200,11 @@ pub async fn register_post( ) .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) .with_title(Lc::t("title-register", &LOCALES_USER)) .with_child( @@ -326,7 +340,11 @@ pub async fn password_reset_confirm_post( } .await; 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) => { let error = match err { AuthError::InvalidToken => Lc::t("error-token-invalid", &LOCALES_USER), @@ -407,7 +425,11 @@ pub async fn verify_email_post( } .await; 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(), } } diff --git a/extensions/pagetop-user/src/lib.rs b/extensions/pagetop-user/src/lib.rs index 6d3b0364..d692c73b 100644 --- a/extensions/pagetop-user/src/lib.rs +++ b/extensions/pagetop-user/src/lib.rs @@ -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 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 -de un *proxy* inverso, el límite por IP requiere configurar `server.client_ip_header`. +`max_email_changes`), y ellos y los registros, también por dirección IP (`max_ip_requests`). + +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::*; diff --git a/extensions/pagetop-user/src/locale/en-US/common.ftl b/extensions/pagetop-user/src/locale/en-US/common.ftl index f2fe0bd7..9036b351 100644 --- a/extensions/pagetop-user/src/locale/en-US/common.ftl +++ b/extensions/pagetop-user/src/locale/en-US/common.ftl @@ -74,6 +74,11 @@ msg-email-change-pending = 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 >** mail-greeting = Hello { $username }, diff --git a/extensions/pagetop-user/src/locale/es-ES/common.ftl b/extensions/pagetop-user/src/locale/es-ES/common.ftl index fb414378..403e6d72 100644 --- a/extensions/pagetop-user/src/locale/es-ES/common.ftl +++ b/extensions/pagetop-user/src/locale/es-ES/common.ftl @@ -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-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 >** mail-greeting = Hola, { $username }: diff --git a/extensions/pagetop-user/src/throttle.rs b/extensions/pagetop-user/src/throttle.rs index 1c12635d..c14cb589 100644 --- a/extensions/pagetop-user/src/throttle.rs +++ b/extensions/pagetop-user/src/throttle.rs @@ -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::*; @@ -15,12 +16,20 @@ struct Requests { purged_at: Instant, } -static REQUESTS: LazyLock> = LazyLock::new(|| { - Mutex::new(Requests { - by_ip: HashMap::new(), - purged_at: Instant::now(), +// Cada límite lleva su propia cuenta. +type Log = LazyLock>; + +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 /// [`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 { return true; }; - let window = - StdDuration::from_secs(u64::try_from(SETTINGS.ip_request_window_secs).unwrap_or(0)); let allowed = allow_at( - &mut REQUESTS.lock().unwrap_or_else(PoisonError::into_inner), + &mut lock(&REQUESTS), network(ip), Instant::now(), SETTINGS.max_ip_requests, - window, + window(SETTINGS.ip_request_window_secs), ); if !allowed { trace::warn!("Request limit reached for address {ip}"); @@ -46,6 +53,44 @@ pub(crate) fn allow(request: &HttpRequest) -> bool { 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( requests: &mut Requests, ip: IpAddr, @@ -76,6 +121,13 @@ fn allow_at( 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 // entera y podría cambiar de dirección en cada solicitud. 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)); } + #[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] async fn zero_maximum_never_limits() { let start = Instant::now(); diff --git a/extensions/pagetop-user/tests/flows.rs b/extensions/pagetop-user/tests/flows.rs index d5751058..e71c8630 100644 --- a/extensions/pagetop-user/tests/flows.rs +++ b/extensions/pagetop-user/tests/flows.rs @@ -1,7 +1,8 @@ // 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 -// verification on sign-up, `max_failed_logins = 3`, `max_ip_requests = 3` and -// `max_email_changes = 2` (`max_password_resets` keeps its default, 3). +// verification on sign-up, `max_failed_logins = 3`, `max_ip_requests = 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 // 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; password_resets_are_limited_by_account(&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) { @@ -223,6 +225,10 @@ async fn registration_requires_confirming_the_address(client: &Client) { let reply = client.post(path(&verify), "", None).await; assert_eq!(reply.status, Status::SEE_OTHER); 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 @@ -235,6 +241,21 @@ async fn registration_requires_confirming_the_address(client: &Client) { assert_eq!(client.get(&verify, None).await.status, Status::NOT_FOUND); } +// Deferred components leave a mark (``) 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("") + .map_or("", |(_, after)| after); + } + out.push_str(rest); + out +} + async fn password_reset_links_are_single_use(client: &Client) { 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) .await; 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; 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; 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); +} diff --git a/src/app.rs b/src/app.rs index 700f805a..ac356c6a 100644 --- a/src/app.rs +++ b/src/app.rs @@ -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)) diff --git a/src/base/component/form/hidden.rs b/src/base/component/form/hidden.rs index 30aa7fd1..3dd3b43c 100644 --- a/src/base/component/form/hidden.rs +++ b/src/base/component/form/hidden.rs @@ -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)] diff --git a/src/global.rs b/src/global.rs index 607d1e7f..63a79bc5 100644 --- a/src/global.rs +++ b/src/global.rs @@ -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, +} + +// 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, D::Error> { + Vec::::deserialize(deserializer)? + .iter() + .map(|raw| { + let origin = raw.trim().trim_end_matches('/').to_ascii_lowercase(); + let Some(uri) = origin.parse::().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::(&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}"); + } + } } diff --git a/src/web.rs b/src/web.rs index cc50a09f..73b83a8e 100644 --- a/src/web.rs +++ b/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; diff --git a/src/web/csrf.rs b/src/web/csrf.rs new file mode 100644 index 00000000..833de1e8 --- /dev/null +++ b/src/web/csrf.rs @@ -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)); + } +} diff --git a/src/web/upload.rs b/src/web/upload.rs index ef00be9e..68c92250 100644 --- a/src/web/upload.rs +++ b/src/web/upload.rs @@ -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()` diff --git a/tests/web_csrf.rs b/tests/web_csrf.rs new file mode 100644 index 00000000..36559e4a --- /dev/null +++ b/tests/web_csrf.rs @@ -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> = 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("