From 15a96a83106cf73a0b666360c9a92c68b4e498f2 Mon Sep 17 00:00:00 2001 From: Manuel Cillero Date: Sat, 31 Oct 2026 22:16:45 +0100 Subject: [PATCH] =?UTF-8?q?=F0=9F=94=92=EF=B8=8F=20(user):=20Refuerza=20la?= =?UTF-8?q?=20seguridad=20de=20las=20cuentas?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Límite de solicitudes por dirección IP para registros, recuperaciones de contraseña y cambios de email (`max_ip_requests`). - Avisa del cambio de contraseña, propio o de un administrador. - El email propio se cambia en /user/email con la contraseña actual y no se aplica hasta confirmarlo desde un enlace ligado a esa dirección. - Cambiar el email o la contraseña anula los enlaces antiguos, y los fallos de la contraseña actual cuentan para el bloqueo de la cuenta. - `Referrer-Policy: no-referrer` en las páginas con token en la URL. --- config/reference.toml | 11 +- extensions/pagetop-user/Cargo.toml | 3 + extensions/pagetop-user/config/common.toml | 31 + extensions/pagetop-user/src/auth.rs | 168 ++++- extensions/pagetop-user/src/component.rs | 2 + .../src/component/admin/user_form.rs | 9 + .../src/component/change_email_form.rs | 86 +++ extensions/pagetop-user/src/config.rs | 28 +- extensions/pagetop-user/src/entity/user.rs | 3 + extensions/pagetop-user/src/error.rs | 6 + extensions/pagetop-user/src/handlers.rs | 46 ++ .../pagetop-user/src/handlers/account.rs | 160 +++- extensions/pagetop-user/src/handlers/admin.rs | 3 + .../pagetop-user/src/handlers/admin/users.rs | 9 +- extensions/pagetop-user/src/handlers/auth.rs | 106 +-- extensions/pagetop-user/src/lib.rs | 45 +- .../pagetop-user/src/locale/en-US/common.ftl | 72 +- .../pagetop-user/src/locale/es-ES/common.ftl | 72 +- extensions/pagetop-user/src/mail.rs | 230 ++++-- .../m20260629_000001_create_users.rs | 3 + .../m20260629_000006_create_user_tokens.rs | 2 +- .../pagetop-user/src/service/user_admin.rs | 36 +- extensions/pagetop-user/src/throttle.rs | 149 ++++ extensions/pagetop-user/src/token.rs | 77 +- extensions/pagetop-user/tests/flows.rs | 689 ++++++++++++++++++ 25 files changed, 1850 insertions(+), 196 deletions(-) create mode 100644 extensions/pagetop-user/config/common.toml create mode 100644 extensions/pagetop-user/src/component/change_email_form.rs create mode 100644 extensions/pagetop-user/src/throttle.rs create mode 100644 extensions/pagetop-user/tests/flows.rs diff --git a/config/reference.toml b/config/reference.toml index ab2157ac..c8d32cda 100644 --- a/config/reference.toml +++ b/config/reference.toml @@ -296,8 +296,9 @@ identity_policy = "strict" # Nombres de usuario que se aceptan: # Con cualquiera: nunca "@", sin distinguir mayúsculas y sin # nombres que se confundan con otro existente. -max_failed_logins = 5 # Intentos fallidos seguidos que bloquean la - # cuenta. 0 -> nunca. +max_failed_logins = 5 # Intentos fallidos seguidos que bloquean la cuenta, también + # los de la contraseña actual al cambiar la contraseña o el + # email. 0 -> nunca. failed_login_window_secs = 900 # Segundos desde el último fallo en los que el siguiente se # suma al recuento (15 minutos); si no, empieza de nuevo. locked_for_secs = 600 # Duración del bloqueo de la cuenta en segundos (10 minutos). @@ -307,6 +308,12 @@ max_password_resets = 3 # Solicitudes de recuperación de contras # ventana; las siguientes no envían correo. 0 -> sin límite. password_reset_window_secs = 3600 # Segundos en los que se cuentan las solicitudes (1 hora). +max_ip_requests = 20 # Registros, recuperaciones de contraseña y cambios de email + # desde una misma IP (IPv6 por su red /64) en la ventana. + # Tras un proxy inverso requiere 'server.client_ip_header'. + # Cada instancia cuenta las suyas. 0 -> sin límite. +ip_request_window_secs = 3600 # Segundos en los que se cuentan las solicitudes (1 hora). + login_strict = false # Dificulta que el navegador recuerde o autorrellene las # credenciales en el formulario de acceso. diff --git a/extensions/pagetop-user/Cargo.toml b/extensions/pagetop-user/Cargo.toml index 1a77842e..637b2db7 100644 --- a/extensions/pagetop-user/Cargo.toml +++ b/extensions/pagetop-user/Cargo.toml @@ -40,3 +40,6 @@ argon2.workspace = true base64ct.workspace = true sha2.workspace = true rand_core.workspace = true + +[dev-dependencies] +pagetop-seaorm = { workspace = true, features = ["sqlite"] } diff --git a/extensions/pagetop-user/config/common.toml b/extensions/pagetop-user/config/common.toml new file mode 100644 index 00000000..7430bf97 --- /dev/null +++ b/extensions/pagetop-user/config/common.toml @@ -0,0 +1,31 @@ +# Configuración para las pruebas de este crate: base de datos SQLite en memoria y correos guardados +# en memoria en lugar de enviarlos. + +[app] +language = "en-US" + +# Nueva en cada ejecución, con una sola conexión para que todas las consultas la compartan. +[database] +db_type = "sqlite" +db_name = "user-tests?mode=memory" +max_pool_size = 1 + +[mail] +transport = "memory" +from = "PageTop Tests " +base_url = "https://example.com/" + +[user] +require_email_verification = true +max_failed_logins = 3 +max_ip_requests = 3 + +# Costes mínimos de Argon2id: las pruebas cifran muchas contraseñas. +[user.password] +argon2_m_cost = 64 +argon2_t_cost = 1 + +[user.seed] +admin_username = "admin" +admin_email = "admin@example.com" +admin_password = "admin-password" diff --git a/extensions/pagetop-user/src/auth.rs b/extensions/pagetop-user/src/auth.rs index f5550dc8..bc173380 100644 --- a/extensions/pagetop-user/src/auth.rs +++ b/extensions/pagetop-user/src/auth.rs @@ -1,4 +1,5 @@ -//! Lógica de autenticación: login, logout, registro, cambio de contraseña, semilla inicial. +//! Lógica de autenticación: login, logout, registro, cambio de contraseña y de email, semilla +//! inicial. use pagetop::prelude::*; use pagetop_seaorm::db::{ @@ -15,6 +16,7 @@ use crate::password; use crate::permission::UserPermission; use crate::service::user_admin::{ensure_email_available, ensure_username_available}; use crate::session; +use crate::token::{self, TokenKind}; // **< login >************************************************************************************** @@ -154,22 +156,20 @@ pub async fn register( // **< change_own_password >************************************************************************ /// Cambia la contraseña del propio usuario tras comprobar la actual, y cierra el resto de sus -/// sesiones abiertas conservando la indicada en `current_sid` (la de quien hace el cambio). +/// sesiones abiertas conservando la indicada en `current_sid` (la de quien hace el cambio). Anula +/// los enlaces de recuperación que tuviera sin usar. Devuelve la cuenta, para avisar del cambio a +/// su dirección. /// -/// Devuelve [`AuthError::InvalidCredentials`] si la contraseña actual no es correcta. +/// Devuelve [`AuthError::InvalidCredentials`] si la contraseña actual no es correcta, y +/// [`AuthError::AccountLocked`] si la cuenta está bloqueada por intentos fallidos (ver +/// `checked_user()`). pub(crate) async fn change_own_password( user_id: i32, current_password: &str, new_password: &str, current_sid: Option<&str>, -) -> Result<(), AuthError> { - let user_model = user::Entity::find_by_id(user_id) - .one(dbconn()) - .await? - .ok_or(AuthError::UserNotFound)?; - if !password::verify_password_async(current_password, &user_model.password_hash).await { - return Err(AuthError::InvalidCredentials); - } +) -> Result { + let user_model = checked_user(user_id, current_password).await?; password::validate_strength(new_password)?; let hash = password::hash_password_async(new_password).await?; @@ -186,7 +186,151 @@ pub(crate) async fn change_own_password( Some(sid) => session::destroy_other_sessions(user_id, sid).await?, None => session::destroy_user_sessions(user_id).await?, } - Ok(()) + // Un enlace de recuperación pedido antes no debe deshacer el cambio. + token::revoke_tokens(user_id, TokenKind::PasswordReset).await?; + Ok(user_model) +} + +// Cuenta del usuario, si `plain_password` es su contraseña actual; si no, +// `AuthError::InvalidCredentials`. +// +// Los fallos cuentan para el bloqueo por intentos fallidos, como en `login()`, y con la cuenta +// bloqueada se rechaza también la contraseña correcta (`AuthError::AccountLocked`): si no, quien +// tuviera una sesión robada podría adivinar la contraseña desde estos formularios sin límite, y +// pedirla no protegería el cambio de la contraseña ni el del email. +async fn checked_user(user_id: i32, plain_password: &str) -> Result { + let user_model = user::Entity::find_by_id(user_id) + .one(dbconn()) + .await? + .ok_or(AuthError::UserNotFound)?; + let now = Utc::now(); + if let Some(locked_until) = user_model.locked_until + && locked_until > now + { + return Err(AuthError::AccountLocked); + } + if !password::verify_password_async(plain_password, &user_model.password_hash).await { + register_failed_login(&user_model, now).await?; + return Err(AuthError::InvalidCredentials); + } + Ok(user_model) +} + +// **< request_email_change / confirm_email_change >************************************************ + +/// Pide cambiar la dirección de email del propio usuario tras comprobar su contraseña actual. +/// +/// La nueva dirección no se aplica todavía: queda pendiente (`pending_email`) hasta que se confirme +/// con el enlace de un solo uso que se envía a ella ([`confirm_email_change()`]), y así nadie puede +/// asignar a su cuenta una dirección que no es suya. El enlace sólo vale para esa dirección: si se +/// pide otro cambio, el anterior ya no puede aplicar la nueva. Pedir la contraseña impide que quien +/// sólo ha conseguido una sesión abierta se quede la cuenta cambiando la dirección y recuperando +/// después la contraseña. Devuelve la cuenta antes del cambio, la nueva dirección y el token en +/// claro. +/// +/// Falla con [`AuthError::InvalidCredentials`] si la contraseña no es correcta, +/// [`AuthError::AccountLocked`] si la cuenta está bloqueada por intentos fallidos, +/// [`AuthError::SameEmail`] si la dirección es la actual (sin distinguir mayúsculas) y +/// [`AuthError::EmailTaken`] si la usa otra cuenta. +pub(crate) async fn request_email_change( + user_id: i32, + current_password: &str, + new_email: &str, +) -> Result<(user::Model, String, String), AuthError> { + let user_model = checked_user(user_id, current_password).await?; + let email = identity::email(new_email)?; + if *email.key() == user_model.email_key { + return Err(AuthError::SameEmail); + } + ensure_email_available(&email, Some(user_id)).await?; + + let new_email = email.value().to_owned(); + user::ActiveModel { + id: Set(user_id), + pending_email: Set(Some(new_email.clone())), + updated_at: Set(Utc::now()), + ..Default::default() + } + .update(dbconn()) + .await?; + let token = token::create_bound_token(user_id, TokenKind::EmailChange, email.key()).await?; + Ok((user_model, new_email, token)) +} + +/// Aplica la dirección pendiente del usuario si el token es válido para ella, y la da por +/// verificada: quien abre el enlace ha demostrado recibir los correos de esa dirección. Anula los +/// enlaces enviados a la dirección anterior (ver [`revoke_address_tokens()`]). +/// +/// Falla con [`AuthError::InvalidToken`] si el token no es válido, ya no hay ningún cambio +/// pendiente o el pendiente es otro, y con [`AuthError::EmailTaken`] si otra cuenta ha empezado a +/// usar la dirección mientras tanto. +pub(crate) async fn confirm_email_change(user_id: i32, plain_token: &str) -> Result<(), AuthError> { + let email = pending_email(user_id).await?; + token::consume_bound_token(user_id, plain_token, TokenKind::EmailChange, email.key()).await?; + ensure_email_available(&email, Some(user_id)).await?; + + let now = Utc::now(); + let mut model = user::ActiveModel { + id: Set(user_id), + email_verified_at: Set(Some(now)), + pending_email: Set(None), + updated_at: Set(now), + ..Default::default() + }; + email.set_on(&mut model); + model.update(dbconn()).await?; + revoke_address_tokens(user_id).await +} + +/// Indica, sin consumirlo, si el token sirve para confirmar el cambio de dirección pendiente del +/// usuario (ver [`confirm_email_change()`]). +pub(crate) async fn is_valid_email_change_token( + user_id: i32, + plain_token: &str, +) -> Result { + let email = match pending_email(user_id).await { + Ok(email) => email, + Err(AuthError::InvalidToken) => return Ok(false), + Err(err) => return Err(err), + }; + token::is_valid_bound_token(user_id, plain_token, TokenKind::EmailChange, email.key()).await +} + +// Dirección pendiente de confirmar del usuario, o `AuthError::InvalidToken` si no tiene ninguna. +async fn pending_email(user_id: i32) -> Result { + let user_model = user::Entity::find_by_id(user_id) + .one(dbconn()) + .await? + .ok_or(AuthError::InvalidToken)?; + let pending = user_model.pending_email.ok_or(AuthError::InvalidToken)?; + identity::email(&pending) +} + +/// Anula los enlaces de recuperación de contraseña y de verificación que el usuario tenga sin +/// usar. Se llama cuando cambia su dirección: se enviaron a la anterior, y quien siga recibiendo +/// sus correos (p. ej. la empresa que la gestionaba) no debe poder usarlos para quedarse la cuenta. +pub(crate) async fn revoke_address_tokens(user_id: i32) -> Result<(), AuthError> { + token::revoke_tokens(user_id, TokenKind::PasswordReset).await?; + token::revoke_tokens(user_id, TokenKind::EmailVerification).await +} + +/// Descarta el cambio de dirección pendiente del usuario, si lo hay, y anula su enlace. +/// +/// Se llama al restablecer la contraseña, porque el aviso de cambio de dirección pide hacerlo a +/// quien no lo ha pedido, para que la cuenta conserve su dirección; y cuando un administrador fija +/// otra dirección. +pub(crate) async fn cancel_email_change(user_id: i32) -> Result<(), AuthError> { + use pagetop_seaorm::db::query::Expr; + user::Entity::update_many() + .col_expr( + user::Column::PendingEmail, + Expr::value(Option::::None), + ) + .filter(user::Column::Id.eq(user_id)) + .filter(user::Column::PendingEmail.is_not_null()) + .exec(dbconn()) + .await?; + token::revoke_tokens(user_id, TokenKind::EmailChange).await } // **< register_failed_login >********************************************************************** diff --git a/extensions/pagetop-user/src/component.rs b/extensions/pagetop-user/src/component.rs index 56f35362..e4971ae1 100644 --- a/extensions/pagetop-user/src/component.rs +++ b/extensions/pagetop-user/src/component.rs @@ -3,6 +3,7 @@ pub(crate) mod admin; mod account_menu; +mod change_email_form; mod change_password_form; mod login_form; mod password_confirm; @@ -12,6 +13,7 @@ mod register_form; mod user_name; pub use account_menu::{AccountMenu, account_menu}; +pub(crate) use change_email_form::ChangeEmailForm; pub(crate) use change_password_form::ChangePasswordForm; pub use login_form::LoginForm; pub(crate) use password_confirm::PasswordConfirm; diff --git a/extensions/pagetop-user/src/component/admin/user_form.rs b/extensions/pagetop-user/src/component/admin/user_form.rs index 315ecc4a..98b297f9 100644 --- a/extensions/pagetop-user/src/component/admin/user_form.rs +++ b/extensions/pagetop-user/src/component/admin/user_form.rs @@ -60,6 +60,9 @@ impl Component for UserForm { }; let username_readonly = *self.mode() == UserFormMode::Profile && !*self.allow_username_field(); + // El propio usuario cambia su email en otra pantalla, que pide su contraseña y confirma la + // nueva dirección antes de aplicarla. + let email_readonly = *self.mode() == UserFormMode::Profile; let action = self.waypoint().append_to(cx.route(action)); let mut form = Form::new() @@ -87,7 +90,13 @@ impl Component for UserForm { .with_name("email") .with_value(self.email()) .with_label(Lc::t("field-email", &LOCALES_USER)) + .with_help_text(if email_readonly { + Lc::t("help-email-readonly", &LOCALES_USER) + } else { + Lc::none() + }) .with_required(true) + .with_readonly(email_readonly) .with_maxlength(EMAIL_MAX_CHARS), ) .with_child( diff --git a/extensions/pagetop-user/src/component/change_email_form.rs b/extensions/pagetop-user/src/component/change_email_form.rs new file mode 100644 index 00000000..2512350e --- /dev/null +++ b/extensions/pagetop-user/src/component/change_email_form.rs @@ -0,0 +1,86 @@ +//! Formulario para que el usuario autenticado cambie su propia dirección de email. + +use pagetop::prelude::*; + +use crate::{EMAIL_PATH, LOCALES_USER}; + +use crate::component::error_banner; +use crate::identity::EMAIL_MAX_CHARS; + +/// Pide la nueva dirección y la contraseña actual. Si ya hay un cambio pendiente de confirmar, lo +/// indica: pedir otro lo sustituye. +#[derive(AutoDefault, Clone, Debug, Getters)] +pub(crate) struct ChangeEmailForm { + error: Option, + email: String, + pending_email: Option, +} + +#[async_trait] +impl Component for ChangeEmailForm { + fn new() -> Self { + Self::default() + } + + async fn prepare(&self, cx: &mut Context) -> Result { + let mut form = Form::new() + .with_id("user-change-email-form") + .with_action(cx.route(EMAIL_PATH)) + .with_method(form::Method::Post) + .with_child(error_banner(self.error().cloned())); + if let Some(pending) = self.pending_email().cloned() { + form = form.with_child(Html::with(move |cx| { + html! { + p { + (Lc::t("msg-email-change-pending", &LOCALES_USER) + .with_arg("email", pending.clone()) + .using(cx)) + } + } + })); + } + form = form + .with_child( + form::input::Field::email() + .with_name("email") + .with_value(self.email()) + .with_label(Lc::t("field-new-email", &LOCALES_USER)) + .with_autocomplete(Some(form::Autocomplete::email())) + .with_required(true) + .with_maxlength(EMAIL_MAX_CHARS), + ) + .with_child( + form::input::Field::password() + .with_name("current_password") + .with_label(Lc::t("field-current-password", &LOCALES_USER)) + .with_autocomplete(Some(form::Autocomplete::current_password())) + .with_required(true), + ) + .with_child( + Button::submit(Lc::t("btn-change-email", &LOCALES_USER)) + .with_style(button::Style::Solid(Intent::Primary)), + ); + + Ok(form.render(cx).await) + } +} + +#[builder_impl] +impl ChangeEmailForm { + // **< ChangeEmailForm BUILDER >**************************************************************** + + pub(crate) fn with_error(mut self, error: impl Into>) -> Self { + self.error = error.into(); + self + } + + pub(crate) fn with_email(mut self, email: impl Into) -> Self { + self.email = email.into(); + self + } + + pub(crate) fn with_pending_email(mut self, pending_email: impl Into>) -> Self { + self.pending_email = pending_email.into(); + self + } +} diff --git a/extensions/pagetop-user/src/config.rs b/extensions/pagetop-user/src/config.rs index cb0d01a3..4267baf1 100644 --- a/extensions/pagetop-user/src/config.rs +++ b/extensions/pagetop-user/src/config.rs @@ -50,7 +50,9 @@ pub struct UserSettings { /// Qué nombres de usuario se aceptan. Ver [`IdentityPolicy`]. pub identity_policy: IdentityPolicy, - /// Intentos fallidos de acceso seguidos que bloquean temporalmente la cuenta. + /// Intentos fallidos de acceso seguidos que bloquean temporalmente la cuenta. Cuentan también + /// los fallos de la contraseña actual al cambiar la contraseña o el email: así nadie con una + /// sesión robada puede adivinarla desde esos formularios. /// /// Un fallo se suma a los anteriores si llega antes de /// [`failed_login_window_secs`](Self::failed_login_window_secs) desde el último; si no, el @@ -81,6 +83,30 @@ pub struct UserSettings { #[default = 3_600] pub password_reset_window_secs: i64, + /// Solicitudes que envían un correo o crean una cuenta (registros, recuperaciones de + /// contraseña y cambios de email) que se admiten desde una misma dirección IP en + /// [`ip_request_window_secs`](Self::ip_request_window_secs). + /// + /// Complementa a [`max_password_resets`](Self::max_password_resets), que limita las de cada + /// cuenta: sin este límite, cualquiera podría usar la aplicación para enviar correos a muchas + /// direcciones ajenas, registrándolas o pidiendo su recuperación. Alcanzado el límite, el + /// registro y el cambio de email muestran un error, y la recuperación no envía nada, con la + /// misma respuesta de siempre. Las direcciones IPv6 cuentan por su red `/64`, que suele ser la + /// de un mismo equipo o red local. + /// + /// La dirección es la que da [`pagetop::web::HttpRequest::client_ip()`]: detrás de un *proxy* + /// inverso hay que configurar `server.client_ip_header`, o todas las peticiones contarían como + /// de la misma dirección. Las peticiones de dirección desconocida no se limitan. Cada proceso + /// lleva su propia cuenta, en memoria: con varias instancias, el límite es por instancia. Con + /// `0` no hay límite. + /// + /// [`pagetop::web::HttpRequest::client_ip()`]: pagetop::web::HttpRequest::client_ip + #[default = 20] + pub max_ip_requests: u32, + /// Segundos en los que se cuentan las solicitudes de una misma dirección IP. + #[default = 3_600] + pub ip_request_window_secs: i64, + /// Sesiones, en la subsección `[user.session]`. pub session: SessionSettings, diff --git a/extensions/pagetop-user/src/entity/user.rs b/extensions/pagetop-user/src/entity/user.rs index 3d0d29d4..590b3f49 100644 --- a/extensions/pagetop-user/src/entity/user.rs +++ b/extensions/pagetop-user/src/entity/user.rs @@ -20,6 +20,9 @@ pub struct Model { #[sea_orm(unique)] pub email_key: String, pub email_verified_at: Option, + /// Nueva dirección pedida por el propio usuario, que no se aplica hasta que la confirma desde + /// el enlace que se le envía. + pub pending_email: Option, pub password_hash: String, pub status: i16, pub language: Option, diff --git a/extensions/pagetop-user/src/error.rs b/extensions/pagetop-user/src/error.rs index f8b80264..c1509388 100644 --- a/extensions/pagetop-user/src/error.rs +++ b/extensions/pagetop-user/src/error.rs @@ -44,6 +44,12 @@ pub enum AuthError { #[error("email is already registered")] EmailTaken, + #[error("new email is the same as the current one")] + SameEmail, + + #[error("too many requests from the same address")] + TooManyRequests, + #[error("passwords do not match")] PasswordMismatch, diff --git a/extensions/pagetop-user/src/handlers.rs b/extensions/pagetop-user/src/handlers.rs index 52fb3546..db85983e 100644 --- a/extensions/pagetop-user/src/handlers.rs +++ b/extensions/pagetop-user/src/handlers.rs @@ -3,3 +3,49 @@ pub(crate) mod account; pub(crate) mod admin; pub(crate) mod auth; + +use pagetop::prelude::*; + +// Página con un único mensaje. +pub(crate) async fn message_page(request: HttpRequest, title: Lc, message: Lc) -> Response { + Page::new(request) + .with_title(title) + .with_child(Html::with(move |cx| html! { p { (message.using(cx)) } })) + .render() + .await + .into_response() +} + +// Página con un mensaje y un botón que envía un formulario a la propia URL, que incluye el +// `{uid}/{token}`: los servidores de correo abren por su cuenta los enlaces de los correos para +// analizarlos, así que el token sólo se consume al pulsar el botón. +pub(crate) async fn confirm_page( + request: HttpRequest, + title: Lc, + message: Lc, + action: Lc, +) -> Response { + // Sin `with_action()`: se envía a la propia URL. + let form = Form::new() + .with_id("user-confirm-form") + .with_method(form::Method::Post) + .with_child(Html::with(move |cx| html! { p { (message.using(cx)) } })) + .with_child(Button::submit(action).with_style(button::Style::Solid(Intent::Primary))); + Page::new(request) + .with_title(title) + .with_child(form) + .render() + .await + .into_response() +} + +// Añade `Referrer-Policy: no-referrer` a la respuesta de una página con un token en la URL: si el +// tema carga recursos de otro sitio, o el usuario sigue un enlace externo, el navegador no le +// enviará la URL con el token en la cabecera `Referer`. +pub(crate) fn no_referrer(mut response: Response) -> Response { + response.headers_mut().insert( + web::http::header::REFERRER_POLICY, + web::http::HeaderValue::from_static("no-referrer"), + ); + response +} diff --git a/extensions/pagetop-user/src/handlers/account.rs b/extensions/pagetop-user/src/handlers/account.rs index aa9628a5..9fd90dc9 100644 --- a/extensions/pagetop-user/src/handlers/account.rs +++ b/extensions/pagetop-user/src/handlers/account.rs @@ -1,5 +1,5 @@ -//! Handlers HTTP para el perfil del propio usuario autenticado (consulta, edición de sus datos y -//! cambio de contraseña) y para el perfil público de cualquier usuario. +//! Handlers HTTP para el perfil del propio usuario autenticado (consulta, edición de sus datos, +//! cambio de contraseña y de email) y para el perfil público de cualquier usuario. use serde::Deserialize; @@ -8,15 +8,20 @@ use pagetop::prelude::*; use crate::account::{Account, UserStatus}; use crate::auth; use crate::component::admin::{UserForm, UserFormMode}; -use crate::component::{ChangePasswordForm, multiline_text, user_details}; +use crate::component::{ChangeEmailForm, ChangePasswordForm, multiline_text, user_details}; use crate::entity::{role, user}; use crate::error::AuthError; use crate::handlers::admin::map_auth_error; +use crate::handlers::{confirm_page, message_page, no_referrer}; +use crate::mail::{Notice, send_email_change_mail, send_notice}; use crate::password; use crate::permission::UserPermission; use crate::service::user_admin; use crate::session; -use crate::{LOCALES_USER, LOGIN_PATH, PROFILE_EDIT_PATH, PROFILE_PASSWORD_PATH, PROFILE_PATH}; +use crate::throttle; +use crate::{ + EMAIL_PATH, LOCALES_USER, LOGIN_PATH, PROFILE_EDIT_PATH, PROFILE_PASSWORD_PATH, PROFILE_PATH, +}; // **< current_user_id / login_redirect >*********************************************************** @@ -68,8 +73,9 @@ pub(crate) async fn profile_get(request: HttpRequest) -> Response { .into_response() } -// Botones para editar el perfil y cambiar la contraseña, cada uno sólo si se tiene el permiso. -// Sin ninguno de los dos, el contenedor queda vacío y no se renderiza. +// Botones para editar el perfil, cambiar el email y cambiar la contraseña, cada uno sólo si se +// tiene el permiso (el email, con el de editar el perfil). Sin ninguno, el contenedor queda vacío y +// no se renderiza. fn profile_actions(can_edit: bool, can_change_password: bool, cx: &Context) -> Flex { let mut actions = Flex::new() .with_wrap(flex::Behavior::Wrap) @@ -82,6 +88,13 @@ fn profile_actions(can_edit: bool, can_change_password: bool, cx: &Context) -> F ) .with_style(button::Style::Solid(Intent::Primary)), ); + actions = actions.with_child( + Button::anchor( + Lc::t("btn-change-email", &LOCALES_USER), + cx.route(EMAIL_PATH), + ) + .with_style(button::Style::Solid(Intent::Neutral)), + ); } if can_change_password { actions = actions.with_child( @@ -235,7 +248,6 @@ pub(crate) async fn profile_edit_get(request: HttpRequest) -> Result, @@ -273,13 +286,12 @@ pub(crate) async fn profile_edit_post( id, user_admin::UserUpdateData { username: &username, - email: &form.email, + email: &user.email, display_name: util::non_blank(&form.display_name), about: util::non_blank(&form.about), language: util::non_blank(&form.language), timezone: util::non_blank(&form.timezone), theme: util::non_blank(&form.theme), - email_verified: false, }, ) .await; @@ -292,7 +304,7 @@ pub(crate) async fn profile_edit_post( Err(err) => { let form = UserForm::new() .with_username(username) - .with_email(form.email) + .with_email(user.email) .with_display_name(form.display_name) .with_about(form.about) .with_language(form.language) @@ -332,8 +344,8 @@ pub(crate) struct ChangePasswordFormData { confirm_password: String, } -/// POST /user/password - Cambia la contraseña propia tras comprobar la actual y cierra el resto de -/// sesiones abiertas del usuario, conservando la actual. +/// POST /user/password - Cambia la contraseña propia tras comprobar la actual, cierra el resto de +/// sesiones abiertas del usuario, conservando la actual, y avisa del cambio a su dirección. pub(crate) async fn password_post( request: HttpRequest, web::Form(form): web::Form, @@ -350,7 +362,8 @@ pub(crate) async fn password_post( }; match result { - Ok(()) => { + Ok(user) => { + send_notice(&request, Notice::PasswordChanged, &user); let cx = Context::new(request); Ok(Redirect::see_other(cx.route(PROFILE_PATH)).into_response()) } @@ -366,6 +379,125 @@ pub(crate) async fn password_post( } } +// **< email_get / email_post >********************************************************************* + +/// GET /user/email - Formulario de cambio del email propio. +pub(crate) async fn email_get(request: HttpRequest) -> Result { + let Some(id) = current_user_id(&request) else { + return Ok(login_redirect(request, EMAIL_PATH)); + }; + require_permission(&request, &UserPermission::EditOwnProfile)?; + let Ok(user) = user_admin::find_user(id).await else { + return Err(ErrorPage::NotFound(Some(request))); + }; + let title = Lc::t("title-profile-email", &LOCALES_USER); + let form = ChangeEmailForm::new().with_pending_email(user.pending_email); + Ok(render_profile_page(request, title, form).await) +} + +#[derive(Deserialize)] +pub(crate) struct ChangeEmailFormData { + email: String, + current_password: String, +} + +/// POST /user/email - Pide cambiar el email propio tras comprobar la contraseña actual: envía a la +/// nueva dirección el enlace para confirmarla y avisa a la actual (ver +/// `auth::request_email_change()`). +pub(crate) async fn email_post( + request: HttpRequest, + web::Form(form): web::Form, +) -> Result { + let Some(id) = current_user_id(&request) else { + return Ok(login_redirect(request, EMAIL_PATH)); + }; + require_permission(&request, &UserPermission::EditOwnProfile)?; + + let result = if throttle::allow(&request) { + auth::request_email_change(id, &form.current_password, &form.email).await + } else { + Err(AuthError::TooManyRequests) + }; + match result { + Ok((user, new_email, token)) => { + send_email_change_mail(&request, &user, &new_email, &token); + send_notice(&request, Notice::EmailChangeRequested, &user); + let title = Lc::t("title-profile-email", &LOCALES_USER); + Ok(message_page( + request, + title, + Lc::t("msg-email-change-sent", &LOCALES_USER), + ) + .await) + } + Err(err) => { + let error = match err { + AuthError::InvalidCredentials => Lc::t("error-current-password", &LOCALES_USER), + err => map_auth_error(&err), + }; + let pending = user_admin::find_user(id) + .await + .ok() + .and_then(|user| user.pending_email); + let title = Lc::t("title-profile-email", &LOCALES_USER); + let form = ChangeEmailForm::new() + .with_email(form.email) + .with_pending_email(pending) + .with_error(error); + Ok(render_profile_page(request, title, form).await) + } + } +} + +// **< email_confirm_get / email_confirm_post >***************************************************** + +/// GET /user/email/{uid}/{token} - Pide confirmar la nueva dirección con un botón. +/// +/// Como en la verificación del email al registrarse, abrir el enlace no confirma nada: los +/// servidores de correo abren los enlaces para analizarlos. Sólo el envío del formulario +/// ([`email_confirm_post()`]) consume el token. No exige sesión: el enlace basta para demostrar que +/// se reciben los correos de la nueva dirección. +pub(crate) async fn email_confirm_get( + request: HttpRequest, + web::Path((uid, token)): web::Path<(i32, String)>, +) -> Result { + if !auth::is_valid_email_change_token(uid, &token) + .await + .unwrap_or(false) + { + return Err(ErrorPage::NotFound(Some(request))); + } + Ok(no_referrer( + confirm_page( + request, + Lc::t("title-confirm-email-change", &LOCALES_USER), + Lc::t("msg-confirm-email-change", &LOCALES_USER), + Lc::t("btn-confirm-email-change", &LOCALES_USER), + ) + .await, + )) +} + +/// POST /user/email/{uid}/{token} - Aplica la nueva dirección y la da por verificada. +pub(crate) async fn email_confirm_post( + request: HttpRequest, + web::Path((uid, token)): web::Path<(i32, String)>, +) -> Response { + match auth::confirm_email_change(uid, &token).await { + Ok(()) => { + let cx = Context::new(request); + Redirect::see_other(cx.route(PROFILE_PATH)).into_response() + } + Err(AuthError::EmailTaken) => { + let title = Lc::t("title-confirm-email-change", &LOCALES_USER); + no_referrer( + message_page(request, title, Lc::t("error-email-taken", &LOCALES_USER)).await, + ) + } + Err(_) => ErrorPage::NotFound(Some(request)).into_response(), + } +} + // **< render_profile_page >************************************************************************ // Página del perfil propio con un formulario y un botón para volver al perfil sin guardar. diff --git a/extensions/pagetop-user/src/handlers/admin.rs b/extensions/pagetop-user/src/handlers/admin.rs index 23bf652b..7b6f40da 100644 --- a/extensions/pagetop-user/src/handlers/admin.rs +++ b/extensions/pagetop-user/src/handlers/admin.rs @@ -42,6 +42,9 @@ pub(crate) fn map_auth_error(err: &AuthError) -> Lc { AuthError::InvalidUsername => Lc::t("error-invalid-username", &LOCALES_USER), AuthError::InvalidEmail => Lc::t("error-invalid-email", &LOCALES_USER), AuthError::EmailTaken => Lc::t("error-email-taken", &LOCALES_USER), + AuthError::SameEmail => Lc::t("error-same-email", &LOCALES_USER), + AuthError::TooManyRequests => Lc::t("error-too-many-requests", &LOCALES_USER), + AuthError::AccountLocked => Lc::t("error-account-locked", &LOCALES_USER), AuthError::UserNotFound => Lc::t("error-user-not-found", &LOCALES_USER), AuthError::RoleNotFound => Lc::t("error-role-not-found", &LOCALES_USER), AuthError::RoleMachineNameTaken => Lc::t("error-role-machine-name-taken", &LOCALES_USER), diff --git a/extensions/pagetop-user/src/handlers/admin/users.rs b/extensions/pagetop-user/src/handlers/admin/users.rs index 7150ef4f..8f3d7dca 100644 --- a/extensions/pagetop-user/src/handlers/admin/users.rs +++ b/extensions/pagetop-user/src/handlers/admin/users.rs @@ -16,6 +16,7 @@ use crate::config::SETTINGS; use crate::entity::{role, user}; use crate::error::AuthError; use crate::handlers::admin::{back_link, frame, map_auth_error}; +use crate::mail::{Notice, send_notice}; use crate::password; use crate::permission::UserPermission; use crate::role_path; @@ -499,7 +500,6 @@ pub(crate) async fn edit_post( language: util::non_blank(&form.language), timezone: util::non_blank(&form.timezone), theme: util::non_blank(&form.theme), - email_verified: true, }, ) .await; @@ -759,8 +759,8 @@ pub(crate) struct AdminPasswordFormData { confirm_password: String, } -/// POST /admin/user/users/{id}/password - Aplica la nueva contraseña e invalida las sesiones -/// activas del usuario. +/// POST /admin/user/users/{id}/password - Aplica la nueva contraseña, invalida las sesiones +/// activas del usuario y le avisa del cambio por correo. pub(crate) async fn password_post( request: HttpRequest, web::Path(id): web::Path, @@ -776,7 +776,8 @@ pub(crate) async fn password_post( }; match result { - Ok(()) => { + Ok(user) => { + send_notice(&request, Notice::PasswordChangedByAdmin, &user); let cx = Context::admin(request); let edit_href = waypoint.append_to(cx.route(user_path(id, "edit"))); Ok(Redirect::see_other(edit_href).into_response()) diff --git a/extensions/pagetop-user/src/handlers/auth.rs b/extensions/pagetop-user/src/handlers/auth.rs index 920a43b0..14e3247e 100644 --- a/extensions/pagetop-user/src/handlers/auth.rs +++ b/extensions/pagetop-user/src/handlers/auth.rs @@ -10,9 +10,11 @@ use crate::component::{LoginForm, PasswordResetConfirmForm, PasswordResetForm, R use crate::config::SETTINGS; use crate::error::AuthError; use crate::handlers::admin::map_auth_error; +use crate::handlers::{confirm_page, message_page, no_referrer}; use crate::mail::send_token_mail; use crate::password; use crate::session; +use crate::throttle; use crate::token::{TokenKind, consume_token, count_tokens_since, create_token, is_valid_token}; use crate::{LOCALES_USER, LOGIN_PATH, PROFILE_PATH}; @@ -166,24 +168,27 @@ pub async fn register_post( return ErrorPage::NotFound(Some(request)).into_response(); } let cx = Context::new(request.clone()); - let result = auth::register( - &form.username, - &form.email, - &form.password, - &form.confirm_password, - ) - .await; + let result = if throttle::allow(&request) { + auth::register( + &form.username, + &form.email, + &form.password, + &form.confirm_password, + ) + .await + } else { + Err(AuthError::TooManyRequests) + }; match result { Ok(user_id) if SETTINGS.require_email_verification => { send_verification_mail(&request, user_id).await; - Page::new(request) - .with_title(Lc::t("title-register", &LOCALES_USER)) - .with_child(Html::with(|cx| { - html! { p { (Lc::t("msg-verification-sent", &LOCALES_USER).using(cx)) } } - })) - .render() - .await - .into_response() + let title = Lc::t("title-register", &LOCALES_USER); + message_page( + request, + title, + Lc::t("msg-verification-sent", &LOCALES_USER), + ) + .await } Ok(_) => Redirect::see_other(cx.route(LOGIN_PATH)), Err(err) => Page::new(request) @@ -217,11 +222,16 @@ pub async fn password_reset_get(request: HttpRequest) -> Result, -) -> Result { +) -> Response { // Respondemos igual exista o no el email para no revelar qué emails están registrados, también // en el tiempo de respuesta: la búsqueda, el token y el correo se resuelven en segundo plano. // Sólo a cuentas activas: una pendiente o bloqueada no podría iniciar sesión con la nueva - // contraseña. + // contraseña. Superado el límite de solicitudes de la dirección IP, tampoco se envía nada. + let title = Lc::t("title-password-reset", &LOCALES_USER); + let sent = Lc::t("msg-password-reset-sent", &LOCALES_USER); + if !throttle::allow(&request) { + return message_page(request, title, sent).await; + } let mail_request = request.clone(); tokio::spawn(async move { use crate::account::UserStatus; @@ -263,13 +273,7 @@ pub async fn password_reset_post( Err(err) => trace::error!("Cannot create password reset token: {err}"), } }); - Page::new(request) - .with_title(Lc::t("title-password-reset", &LOCALES_USER)) - .with_child(Html::with(|cx| { - html! { p { (Lc::t("msg-password-reset-sent", &LOCALES_USER).using(cx)) } } - })) - .render() - .await + message_page(request, title, sent).await } // **< password_reset_confirm_get >***************************************************************** @@ -278,18 +282,19 @@ pub async fn password_reset_post( pub async fn password_reset_confirm_get( request: HttpRequest, web::Path((uid, token)): web::Path<(i32, String)>, -) -> Result { +) -> Result { if !is_valid_token(uid, &token, TokenKind::PasswordReset) .await .unwrap_or(false) { return Err(ErrorPage::NotFound(Some(request))); } - Page::new(request) + let page = Page::new(request) .with_title(Lc::t("title-new-password", &LOCALES_USER)) .with_child(PasswordResetConfirmForm::new()) .render() - .await + .await?; + Ok(no_referrer(page.into_response())) } // **< password_reset_confirm_post >**************************************************************** @@ -297,9 +302,10 @@ pub async fn password_reset_confirm_get( /// POST /user/password/reset/{uid}/{token} - Aplica la nueva contraseña. /// /// La contraseña se valida antes de consumir el token: si no es válida, el mismo enlace sirve para -/// intentarlo de nuevo. Al aplicarla se cierran todas las sesiones del usuario y se levanta el +/// intentarlo de nuevo. Al aplicarla se cierran todas las sesiones del usuario, se levanta el /// bloqueo temporal por intentos fallidos, porque quien abre el enlace ha demostrado ser el titular -/// de la dirección. +/// de la dirección, y se descarta el cambio de dirección pendiente, si lo hay: el aviso de ese +/// cambio pide restablecer la contraseña a quien no lo ha pedido. pub async fn password_reset_confirm_post( request: HttpRequest, web::Path((uid, token)): web::Path<(i32, String)>, @@ -327,6 +333,7 @@ pub async fn password_reset_confirm_post( session::destroy_user_sessions(uid) .await .map_err(AuthError::Database)?; + auth::cancel_email_change(uid).await?; Ok::<(), AuthError>(()) } .await; @@ -337,12 +344,14 @@ pub async fn password_reset_confirm_post( AuthError::InvalidToken => Lc::t("error-token-invalid", &LOCALES_USER), err => map_auth_error(&err), }; - Page::new(request) - .with_title(Lc::t("title-new-password", &LOCALES_USER)) - .with_child(PasswordResetConfirmForm::new().with_error(error)) - .render() - .await - .into_response() + no_referrer( + Page::new(request) + .with_title(Lc::t("title-new-password", &LOCALES_USER)) + .with_child(PasswordResetConfirmForm::new().with_error(error)) + .render() + .await + .into_response(), + ) } } } @@ -358,29 +367,22 @@ pub async fn password_reset_confirm_post( pub async fn verify_email_get( request: HttpRequest, web::Path((uid, token)): web::Path<(i32, String)>, -) -> Result { +) -> Result { if !is_valid_token(uid, &token, TokenKind::EmailVerification) .await .unwrap_or(false) { return Err(ErrorPage::NotFound(Some(request))); } - // Sin `with_action()`: se envía a la propia URL, que incluye el `{uid}/{token}`. - let form = Form::new() - .with_id("user-verify-email-form") - .with_method(form::Method::Post) - .with_child(Html::with(|cx| { - html! { p { (Lc::t("msg-verify-email", &LOCALES_USER).using(cx)) } } - })) - .with_child( - Button::submit(Lc::t("btn-verify-email", &LOCALES_USER)) - .with_style(button::Style::Solid(Intent::Primary)), - ); - Page::new(request) - .with_title(Lc::t("title-verify-email", &LOCALES_USER)) - .with_child(form) - .render() - .await + Ok(no_referrer( + confirm_page( + request, + Lc::t("title-verify-email", &LOCALES_USER), + Lc::t("msg-verify-email", &LOCALES_USER), + Lc::t("btn-verify-email", &LOCALES_USER), + ) + .await, + )) } /// POST /user/verify/{uid}/{token} - Confirma la dirección de email. diff --git a/extensions/pagetop-user/src/lib.rs b/extensions/pagetop-user/src/lib.rs index 8614d48f..02e5c650 100644 --- a/extensions/pagetop-user/src/lib.rs +++ b/extensions/pagetop-user/src/lib.rs @@ -78,18 +78,36 @@ cada política, y las del email, están en [`IdentityPolicy`](config::IdentityPo ## Correos -La recuperación de contraseña y, con `require_email_verification`, la verificación de las cuentas -nuevas envían un correo con un enlace de un solo uso mediante [`pagetop_mail`]. Configura el envío -en la sección `[mail]`, incluidos el remitente (`mail.from`), que estos correos no indican, y la -URL pública de los enlaces (`mail.base_url`): sin configurar, los correos se escriben en las trazas -en lugar de enviarse. +La recuperación de contraseña, la confirmación de una nueva dirección y, con +`require_email_verification`, la verificación de las cuentas nuevas envían un correo con un enlace +de un solo uso mediante [`pagetop_mail`]. Además, se avisa a la dirección de la cuenta cuando +cambia su contraseña (la cambie el usuario o un administrador) y cuando se pide cambiar su +dirección. Configura el envío en la sección `[mail]`, incluidos el remitente (`mail.from`), que +estos correos no indican, y la URL pública de los enlaces (`mail.base_url`): sin configurar, los +correos se escriben en las trazas en lugar de enviarse. La recuperación de contraseña sólo se envía a cuentas activas. Mientras una dirección no está verificada podría ser de otra persona, así que sus correos no incluyen nada que elija quien creó la cuenta, ni el nombre de usuario ni el nombre visible. Una dirección queda verificada al confirmarla desde el enlace del correo de verificación (abrirlo no basta: hay que pulsar un botón, porque los servidores de correo abren los enlaces para analizarlos) o cuando la fija un -administrador, y deja de estarlo si el usuario la cambia en su perfil. +administrador. + +Para cambiar su dirección, el usuario indica la nueva y su contraseña actual. La nueva no se aplica +hasta que se confirma desde el enlace que se le envía, y entonces queda verificada; mientras tanto, +la cuenta conserva la anterior, que recibe un aviso. Restablecer la contraseña descarta el cambio +pendiente: es lo que el aviso pide hacer a quien no lo ha pedido. También lo descarta un +administrador que fije otra dirección. Cada enlace sirve sólo para la dirección a la que se envió, +y los enlaces sin usar de recuperación y de verificación dejan de valer cuando cambia la dirección +de la cuenta; los de recuperación, también cuando cambia su contraseña. + +Cambiar la contraseña o el email exige la contraseña actual, y sus fallos cuentan para el bloqueo +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 se limitan por cuenta (`max_password_resets`), y ellas, los registros +y los cambios de dirección, 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`. */ use pagetop::prelude::*; @@ -113,6 +131,7 @@ pub(crate) mod middleware; pub(crate) mod migration; pub(crate) mod service; pub(crate) mod session; +pub(crate) mod throttle; pub(crate) mod token; pub mod component; @@ -155,6 +174,11 @@ const PROFILE_EDIT_PATH: &str = "/user/edit"; // `user:change_own_password`). // POST - aplica la nueva contraseña tras comprobar la actual. const PROFILE_PASSWORD_PATH: &str = "/user/password"; +// GET - muestra el formulario de cambio del email propio (requiere `user:edit_own_profile`). +// POST - comprueba la contraseña y envía el enlace de confirmación a la nueva dirección. +// Con el sufijo `/{uid}/{token}`: GET - pide confirmar la nueva dirección. +// POST - la aplica. +const EMAIL_PATH: &str = "/user/email"; // GET - muestra el formulario de solicitud de restablecimiento. // POST - inicia el flujo (envío del token). // Con el sufijo `/{uid}/{token}`: GET - muestra el formulario de nueva contraseña. @@ -326,6 +350,15 @@ impl Extension for User { PROFILE_PASSWORD_PATH, web::get(handlers::account::password_get).post(handlers::account::password_post), ) + .route( + EMAIL_PATH, + web::get(handlers::account::email_get).post(handlers::account::email_post), + ) + .route( + &format!("{}/{{uid}}/{{token}}", EMAIL_PATH), + web::get(handlers::account::email_confirm_get) + .post(handlers::account::email_confirm_post), + ) .route( PASSWORD_RESET_PATH, web::get(handlers::auth::password_reset_get) diff --git a/extensions/pagetop-user/src/locale/en-US/common.ftl b/extensions/pagetop-user/src/locale/en-US/common.ftl index 4a4b531e..207e1867 100644 --- a/extensions/pagetop-user/src/locale/en-US/common.ftl +++ b/extensions/pagetop-user/src/locale/en-US/common.ftl @@ -7,20 +7,23 @@ extension_description = User identity, authentication, roles and permissions for # **< Page titles >** -title-login = Sign in -title-register = Create account -title-password-reset = Reset password -title-new-password = Set new password -title-verify-email = Confirm your email -title-profile = My profile -title-profile-edit = Edit my profile -title-profile-password = Change my password +title-login = Sign in +title-register = Create account +title-password-reset = Reset password +title-new-password = Set new password +title-verify-email = Confirm your email +title-confirm-email-change = Confirm your new email +title-profile = My profile +title-profile-edit = Edit my profile +title-profile-password = Change my password +title-profile-email = Change my email # **< Field labels >** field-username = Username or email field-password = Password field-email = Email address +field-new-email = New email address field-confirm-password = Confirm password field-new-password = New password field-current-password = Current password @@ -28,13 +31,15 @@ field-remember-me = Remember me # **< Buttons and links >** -btn-login = Sign in -btn-logout = Sign out -btn-register = Create account -btn-send-reset-link = Send reset link -btn-set-password = Change password -btn-verify-email = Confirm my email -btn-edit-profile = Edit profile +btn-login = Sign in +btn-logout = Sign out +btn-register = Create account +btn-send-reset-link = Send reset link +btn-set-password = Change password +btn-verify-email = Confirm my email +btn-edit-profile = Edit profile +btn-change-email = Change email +btn-confirm-email-change = Confirm the new address link-register = Create an account link-forgot-password = Forgot your password? @@ -59,6 +64,16 @@ msg-verification-sent = We have sent you an email to confirm your address. Open the link it contains and confirm your address to activate your account. +msg-email-change-sent = + We have sent a link to the new address. Open it and confirm the address to apply the change; + until then, your account keeps its current address. + +msg-email-change-pending = + The change to { $email } is pending confirmation. If you request another one, the previous link + will no longer work. + +msg-confirm-email-change = Press the button to use this email address in your account. + # **< Emails >** mail-greeting = Hello { $username }, @@ -79,8 +94,27 @@ mail-verify-intro = Thank you for signing up. To activate your account, confir mail-verify-action = Confirm my email mail-verify-ignore = If you did not create an account, ignore this email. -mail-preview-reset = Password reset -mail-preview-verify = Email verification on sign-up +mail-email-change-subject = Confirm your new email for { $app } +mail-email-change-intro = Someone asked to use this email address in an account. To confirm it, open this link: +mail-email-change-action = Confirm the new address +mail-email-change-ignore = If you did not request it, ignore this email: the account will keep its current address. + +mail-password-changed-subject = Your { $app } password has changed +mail-password-changed-intro = The password of your account has just been changed. If it was not you, reset it as soon as possible from this link: +mail-password-changed-admin-intro = An administrator has just changed the password of your account. If you did not expect it, reset it from this link: + +mail-email-change-requested-subject = A change of your { $app } email was requested +mail-email-change-requested-intro = Someone asked to change the email address of your account to another one. The change will apply once it is confirmed from the new address. If it was not you, reset your password as soon as possible: this cancels the change and signs out every session of your account. + +mail-notice-action = Reset my password +mail-notice-ignore = If you already knew, you do not need to do anything. + +mail-preview-reset = Password reset +mail-preview-verify = Email verification on sign-up +mail-preview-email-change = Confirmation of a new address +mail-preview-email-change-requested = Notice of a requested address change +mail-preview-password-changed = Notice of a password change +mail-preview-password-changed-admin = Notice of a password change by an administrator # **< Error messages >** @@ -99,6 +133,8 @@ error-username-taken = This username is already taken or can be mistaken error-invalid-username = The username is not valid: check the rules shown below the field. error-invalid-email = The email address is not valid. error-email-taken = This email address is already registered. +error-same-email = The new address is the same as the current one. +error-too-many-requests = Too many requests from your connection. Please try again later. error-token-invalid = This link is invalid or has expired. error-current-password = The current password is incorrect. error-internal = An unexpected error occurred. Please try again. @@ -177,6 +213,8 @@ help-username-permissive = help-password-min-length = At least { $n } characters. +help-email-readonly = To change it, use "Change email" in your profile. + help-machine-name-immutable = Lowercase letters, digits and underscores only. Cannot be changed after creation. diff --git a/extensions/pagetop-user/src/locale/es-ES/common.ftl b/extensions/pagetop-user/src/locale/es-ES/common.ftl index a966538c..0d30832c 100644 --- a/extensions/pagetop-user/src/locale/es-ES/common.ftl +++ b/extensions/pagetop-user/src/locale/es-ES/common.ftl @@ -7,20 +7,23 @@ extension_description = Identidad de usuario, autenticación, roles y permisos p # **< Títulos de página >** -title-login = Iniciar sesión -title-register = Crear cuenta -title-password-reset = Recuperar contraseña -title-new-password = Establecer nueva contraseña -title-verify-email = Confirmar tu correo -title-profile = Mi perfil -title-profile-edit = Editar mi perfil -title-profile-password = Cambiar mi contraseña +title-login = Iniciar sesión +title-register = Crear cuenta +title-password-reset = Recuperar contraseña +title-new-password = Establecer nueva contraseña +title-verify-email = Confirmar tu correo +title-confirm-email-change = Confirmar tu nuevo correo +title-profile = Mi perfil +title-profile-edit = Editar mi perfil +title-profile-password = Cambiar mi contraseña +title-profile-email = Cambiar mi email # **< Etiquetas de campos >** field-username = Usuario o email field-password = Contraseña field-email = Dirección de email +field-new-email = Nueva dirección de email field-confirm-password = Confirmar contraseña field-new-password = Nueva contraseña field-current-password = Contraseña actual @@ -28,13 +31,15 @@ field-remember-me = Recuérdame # **< Botones y enlaces >** -btn-login = Entrar -btn-logout = Cerrar sesión -btn-register = Crear cuenta -btn-send-reset-link = Enviar enlace -btn-set-password = Cambiar contraseña -btn-verify-email = Confirmar mi correo -btn-edit-profile = Editar perfil +btn-login = Entrar +btn-logout = Cerrar sesión +btn-register = Crear cuenta +btn-send-reset-link = Enviar enlace +btn-set-password = Cambiar contraseña +btn-verify-email = Confirmar mi correo +btn-edit-profile = Editar perfil +btn-change-email = Cambiar email +btn-confirm-email-change = Confirmar la nueva dirección link-register = Crear una cuenta link-forgot-password = ¿Olvidaste tu contraseña? @@ -59,6 +64,16 @@ msg-verification-sent = Te hemos enviado un correo para confirmar tu dirección. Abre el enlace que contiene y confirma tu dirección para activar tu cuenta. +msg-email-change-sent = + Te hemos enviado un enlace a la nueva dirección. Ábrelo y confírmala para aplicar el cambio; + hasta entonces, tu cuenta conserva la dirección actual. + +msg-email-change-pending = + Tienes pendiente de confirmar el cambio a { $email }. Si pides otro, el enlace anterior dejará + de valer. + +msg-confirm-email-change = Pulsa el botón para usar esta dirección de correo en tu cuenta. + # **< Correos >** mail-greeting = Hola, { $username }: @@ -79,8 +94,27 @@ mail-verify-intro = Gracias por registrarte. Para activar tu cuenta, confirma mail-verify-action = Confirmar mi correo mail-verify-ignore = Si no has creado ninguna cuenta, ignora este correo. -mail-preview-reset = Recuperación de contraseña -mail-preview-verify = Verificación del correo al registrarse +mail-email-change-subject = Confirma tu nuevo correo en { $app } +mail-email-change-intro = Se ha pedido usar esta dirección de correo en una cuenta. Para confirmarla, abre este enlace: +mail-email-change-action = Confirmar la nueva dirección +mail-email-change-ignore = Si no lo has pedido tú, ignora este correo: la cuenta conservará su dirección actual. + +mail-password-changed-subject = Se ha cambiado tu contraseña de { $app } +mail-password-changed-intro = Se acaba de cambiar la contraseña de tu cuenta. Si no has sido tú, restablécela cuanto antes desde este enlace: +mail-password-changed-admin-intro = Un administrador acaba de cambiar la contraseña de tu cuenta. Si no lo esperabas, restablécela desde este enlace: + +mail-email-change-requested-subject = Se ha pedido cambiar tu correo de { $app } +mail-email-change-requested-intro = Se ha pedido cambiar la dirección de correo de tu cuenta por otra. El cambio se aplicará cuando se confirme desde la nueva dirección. Si no has sido tú, restablece tu contraseña cuanto antes: así se cancela el cambio y se cierran todas las sesiones de tu cuenta. + +mail-notice-action = Restablecer mi contraseña +mail-notice-ignore = Si ya lo sabías, no tienes que hacer nada. + +mail-preview-reset = Recuperación de contraseña +mail-preview-verify = Verificación del correo al registrarse +mail-preview-email-change = Confirmación de una nueva dirección +mail-preview-email-change-requested = Aviso de cambio de dirección pedido +mail-preview-password-changed = Aviso de cambio de contraseña +mail-preview-password-changed-admin = Aviso de cambio de contraseña por un administrador # **< Mensajes de error >** @@ -99,6 +133,8 @@ error-username-taken = Este nombre de usuario ya está en uso o se confun error-invalid-username = El nombre de usuario no es válido: revisa las reglas indicadas bajo el campo. error-invalid-email = La dirección de correo no es válida. error-email-taken = Esta dirección de email ya está registrada. +error-same-email = La nueva dirección es la misma que la actual. +error-too-many-requests = Demasiadas solicitudes desde tu conexión. Inténtalo de nuevo más tarde. error-token-invalid = Este enlace no es válido o ha caducado. error-current-password = La contraseña actual no es correcta. error-internal = Se ha producido un error inesperado. Inténtalo de nuevo. @@ -178,6 +214,8 @@ help-username-permissive = help-password-min-length = Al menos { $n } caracteres. +help-email-readonly = Para cambiarla, usa «Cambiar email» en tu perfil. + help-machine-name-immutable = Sólo minúsculas, dígitos y guiones bajos. No se puede cambiar tras crearlo. diff --git a/extensions/pagetop-user/src/mail.rs b/extensions/pagetop-user/src/mail.rs index a1370c6f..041037f6 100644 --- a/extensions/pagetop-user/src/mail.rs +++ b/extensions/pagetop-user/src/mail.rs @@ -1,11 +1,14 @@ -//! Correos con enlaces de un solo uso: recuperación de contraseña y verificación de email. +//! Correos de `pagetop-user`: los que llevan un enlace de un solo uso (recuperación de contraseña, +//! verificación del email y confirmación de una nueva dirección) y los avisos de seguridad (cambio +//! de contraseña y petición de cambio de dirección). use pagetop::prelude::*; use pagetop_mail::prelude::*; use crate::config; +use crate::entity::user; use crate::token::TokenKind; -use crate::{LOCALES_USER, PASSWORD_RESET_PATH, VERIFY_PATH}; +use crate::{EMAIL_PATH, LOCALES_USER, PASSWORD_RESET_PATH, VERIFY_PATH}; // Estilo del enlace principal, con aspecto de botón. const BUTTON_STYLE: &str = concat!( @@ -13,19 +16,37 @@ const BUTTON_STYLE: &str = concat!( "background-color: #2563eb; color: #ffffff; text-decoration: none; font-weight: 600;" ); -// Correo con el enlace que consume un token del usuario. -struct TokenMail { - kind: TokenKind, +// **< Notice >************************************************************************************* + +/// Avisos de seguridad que se envían a la dirección actual de la cuenta. +#[derive(Clone, Copy, Debug)] +pub(crate) enum Notice { + /// El propio usuario ha cambiado su contraseña. + PasswordChanged, + /// Un administrador ha cambiado la contraseña del usuario. + PasswordChangedByAdmin, + /// Se ha pedido cambiar la dirección de la cuenta por otra, pendiente de confirmar. + EmailChangeRequested, +} + +// **< UserMail >*********************************************************************************** + +// Correo con un enlace principal: el que consume un token o, en los avisos, el de la recuperación +// de contraseña. +struct UserMail { + // Claves del asunto, la introducción, el texto del enlace y la nota final. + keys: [&'static str; 4], // Nombre de usuario para el saludo, sólo si la dirección está verificada (ver `recipient()`). username: Option, link: String, + // Horas que vale el enlace, si caduca. + expires_hours: Option, } -impl TokenMail { - // Claves de los textos propios de cada tipo de token: asunto, introducción, texto del enlace y - // aviso para quien no lo haya solicitado. - fn keys(&self) -> [&'static str; 4] { - match self.kind { +impl UserMail { + // Correo con el enlace que consume un token del tipo indicado. + fn token(kind: TokenKind, username: Option, link: String) -> Self { + let keys = match kind { TokenKind::PasswordReset => [ "mail-reset-subject", "mail-reset-intro", @@ -38,25 +59,56 @@ impl TokenMail { "mail-verify-action", "mail-verify-ignore", ], + TokenKind::EmailChange => [ + "mail-email-change-subject", + "mail-email-change-intro", + "mail-email-change-action", + "mail-email-change-ignore", + ], + }; + UserMail { + keys, + username, + link, + expires_hours: Some(u32::try_from(kind.ttl_secs() / 3600).unwrap_or(u32::MAX)), } } - fn expires(&self) -> Lc { - let hours = u32::try_from(self.kind.ttl_secs() / 3600).unwrap_or(u32::MAX); - Lc::t("mail-link-expires", &LOCALES_USER).with_number("hours", hours) + // Aviso de seguridad, con el enlace a la recuperación de contraseña. + fn notice(notice: Notice, username: Option, link: String) -> Self { + let [subject, intro] = match notice { + Notice::PasswordChanged => [ + "mail-password-changed-subject", + "mail-password-changed-intro", + ], + Notice::PasswordChangedByAdmin => [ + "mail-password-changed-subject", + "mail-password-changed-admin-intro", + ], + Notice::EmailChangeRequested => [ + "mail-email-change-requested-subject", + "mail-email-change-requested-intro", + ], + }; + UserMail { + keys: [subject, intro, "mail-notice-action", "mail-notice-ignore"], + username, + link, + expires_hours: None, + } } } -impl MailTemplate for TokenMail { +impl MailTemplate for UserMail { fn subject(&self, cx: &Context) -> String { - Lc::t(self.keys()[0], &LOCALES_USER) + Lc::t(self.keys[0], &LOCALES_USER) .with_arg("app", &global::SETTINGS.app.name) .lookup(cx) .unwrap_or_default() } fn html(&self, cx: &Context) -> Option { - let [_, intro, action, ignore] = self.keys(); + let [_, intro, action, note] = self.keys; let greeting = match &self.username { // El nombre de usuario lo elige quien creó la cuenta: va con `with_arg()`, que lo // escapa, nunca con `with_markup()`. @@ -65,38 +117,73 @@ impl MailTemplate for TokenMail { } None => Lc::t("mail-greeting-plain", &LOCALES_USER), }; + let expires = self + .expires_hours + .map(|hours| Lc::t("mail-link-expires", &LOCALES_USER).with_number("hours", hours)); Some(html! { p { (greeting.using(cx)) } p { (Lc::t(intro, &LOCALES_USER).using(cx)) } p style="margin: 24px 0;" { a href=(self.link) style=(BUTTON_STYLE) { (Lc::t(action, &LOCALES_USER).using(cx)) } } - p { (self.expires().using(cx)) } - p style="color: #6b7280;" { (Lc::t(ignore, &LOCALES_USER).using(cx)) } + @if let Some(expires) = expires { + p { (expires.using(cx)) } + } + p style="color: #6b7280;" { (Lc::t(note, &LOCALES_USER).using(cx)) } }) } } -// Envía en segundo plano el correo con el enlace que consume `token`. -// -// El correo sale en el idioma propio del usuario si lo tiene (y se aplica), o en el de la petición -// en curso. Se envía en segundo plano para que el tiempo de respuesta no revele si existe la -// cuenta, y porque un fallo del servidor de correo no debe impedir completar la petición: se -// registra en las trazas. +// **< Envío >************************************************************************************** + +// Todos se envían en segundo plano: el tiempo de respuesta no debe revelar si existe la cuenta, y +// un fallo del servidor de correo no debe impedir completar la petición (se registra en las +// trazas). Salen en el idioma propio del usuario si lo tiene (y se aplica), o en el de la petición. + +// Envía el correo con el enlace que consume `token` a la dirección actual del usuario. pub(crate) fn send_token_mail( request: &HttpRequest, kind: TokenKind, - user: &crate::entity::user::Model, + user: &user::Model, token: &str, ) { + let cx = user_context(request, user); + let (username, to) = recipient(user); + token_email(&cx, kind, user.id, username, to, token).send_later(); +} + +// Envía a `new_email` el enlace para confirmarla como nueva dirección del usuario. +// +// La dirección la ha escrito quien está en la cuenta y puede ser de otra persona: como con una +// dirección sin verificar (ver `recipient()`), el correo no incluye nada que haya elegido, ni +// siquiera el nombre de usuario. +pub(crate) fn send_email_change_mail( + request: &HttpRequest, + user: &user::Model, + new_email: &str, + token: &str, +) { + let cx = user_context(request, user); + let to = Mailbox::new(new_email); + token_email(&cx, TokenKind::EmailChange, user.id, None, to, token).send_later(); +} + +// Envía un aviso de seguridad a la dirección actual del usuario. +pub(crate) fn send_notice(request: &HttpRequest, notice: Notice, user: &user::Model) { + let cx = user_context(request, user); + let (username, to) = recipient(user); + notice_email(&cx, notice, username, to).send_later(); +} + +// Contexto de la petición con el idioma propio del usuario, si lo tiene y se aplica. +fn user_context(request: &HttpRequest, user: &user::Model) -> Context { let mut cx = Context::new(request.clone()); if config::user_language_applies() && let Some(locale @ Locale::Resolved(_)) = user.language.as_deref().map(Locale::resolve) { cx.alter_langid(&locale); } - let (username, to) = recipient(user); - token_email(&cx, kind, user.id, username, to, token).send_later(); + cx } // Destinatario del correo y nombre de usuario para el saludo. @@ -108,7 +195,7 @@ pub(crate) fn send_token_mail( // quien creó la cuenta, ni el nombre de usuario ni el nombre visible (tampoco en la cabecera `To`), // porque bastaría para colar un texto o un enlace engañoso (*phishing*). Se puede iniciar sesión // con el email, así que el nombre de usuario no hace falta para recuperar el acceso. -fn recipient(user: &crate::entity::user::Model) -> (Option, Mailbox) { +fn recipient(user: &user::Model) -> (Option, Mailbox) { if user.email_verified_at.is_none() { return (None, Mailbox::new(user.email.as_str())); } @@ -132,16 +219,19 @@ fn token_email( let base = match kind { TokenKind::PasswordReset => PASSWORD_RESET_PATH, TokenKind::EmailVerification => VERIFY_PATH, + TokenKind::EmailChange => EMAIL_PATH, }; let path = util::join!(base, "/", user_id.to_string(), "/", token); - let template = TokenMail { - kind, - username, - link: absolute_url(cx.route(path)), - }; + let template = UserMail::token(kind, username, absolute_url(cx.route(path))); Email::from_template(&template, cx).with_to(to) } +// Compone un aviso de seguridad, con el enlace a la recuperación de contraseña. +fn notice_email(cx: &Context, notice: Notice, username: Option, to: Mailbox) -> Email { + let link = absolute_url(cx.route(PASSWORD_RESET_PATH)); + Email::from_template(&UserMail::notice(notice, username, link), cx).with_to(to) +} + // **< Vistas previas >***************************************************************************** // Declara las vistas previas de los correos de `pagetop-user`, con datos de ejemplo. @@ -149,28 +239,59 @@ pub(crate) fn declare_previews(previews: &mut MailPreviews) { previews.add( "user.email_verification", Lc::t("mail-preview-verify", &LOCALES_USER), - |cx| sample(cx, TokenKind::EmailVerification), + |cx| sample_token(cx, TokenKind::EmailVerification), ); previews.add( "user.password_reset", Lc::t("mail-preview-reset", &LOCALES_USER), - |cx| sample(cx, TokenKind::PasswordReset), + |cx| sample_token(cx, TokenKind::PasswordReset), + ); + previews.add( + "user.email_change", + Lc::t("mail-preview-email-change", &LOCALES_USER), + |cx| sample_token(cx, TokenKind::EmailChange), + ); + previews.add( + "user.email_change_requested", + Lc::t("mail-preview-email-change-requested", &LOCALES_USER), + |cx| sample_notice(cx, Notice::EmailChangeRequested), + ); + previews.add( + "user.password_changed", + Lc::t("mail-preview-password-changed", &LOCALES_USER), + |cx| sample_notice(cx, Notice::PasswordChanged), + ); + previews.add( + "user.password_changed_by_admin", + Lc::t("mail-preview-password-changed-admin", &LOCALES_USER), + |cx| sample_notice(cx, Notice::PasswordChangedByAdmin), ); } -// La verificación se envía a una dirección sin verificar (sin nombre); la recuperación, a la de una -// cuenta verificada (ver `recipient()`). -fn sample(cx: &Context, kind: TokenKind) -> Email { +// La verificación y la confirmación de una nueva dirección se envían a una dirección sin verificar +// (sin nombre); el resto, a la de una cuenta verificada (ver `recipient()`). +fn sample_token(cx: &Context, kind: TokenKind) -> Email { let (username, to) = match kind { - TokenKind::EmailVerification => (None, Mailbox::new("ana@example.com")), - TokenKind::PasswordReset => ( - Some("ana".to_owned()), - Mailbox::from(("Ana Pérez", "ana@example.com")), - ), + TokenKind::EmailVerification | TokenKind::EmailChange => { + (None, Mailbox::new("ana@example.com")) + } + TokenKind::PasswordReset => sample_verified(), }; token_email(cx, kind, 42, username, to, "EXAMPLE-TOKEN") } +fn sample_notice(cx: &Context, notice: Notice) -> Email { + let (username, to) = sample_verified(); + notice_email(cx, notice, username, to) +} + +fn sample_verified() -> (Option, Mailbox) { + ( + Some("ana".to_owned()), + Mailbox::from(("Ana Pérez", "ana@example.com")), + ) +} + #[cfg(test)] mod tests { use super::*; @@ -178,11 +299,11 @@ mod tests { const USERNAME: &str = r#"ana"#; fn html(username: Option<&str>) -> String { - let mail = TokenMail { - kind: TokenKind::PasswordReset, - username: username.map(str::to_owned), - link: "https://example.com/user/token".to_owned(), - }; + let mail = UserMail::token( + TokenKind::PasswordReset, + username.map(str::to_owned), + "https://example.com/user/token".to_owned(), + ); mail.html(&Context::default()).unwrap().into_string() } @@ -207,4 +328,17 @@ mod tests { "username must not appear: {html}" ); } + + // Notices link to the password reset page and have no expiry line. + #[pagetop::test] + async fn notices_link_to_password_reset_without_expiry() { + let mail = UserMail::notice( + Notice::PasswordChanged, + None, + "https://example.com/user/password/reset".to_owned(), + ); + assert!(mail.expires_hours.is_none()); + let html = mail.html(&Context::default()).unwrap().into_string(); + assert!(html.contains("href=\"https://example.com/user/password/reset\"")); + } } diff --git a/extensions/pagetop-user/src/migration/m20260629_000001_create_users.rs b/extensions/pagetop-user/src/migration/m20260629_000001_create_users.rs index f941c250..20853816 100644 --- a/extensions/pagetop-user/src/migration/m20260629_000001_create_users.rs +++ b/extensions/pagetop-user/src/migration/m20260629_000001_create_users.rs @@ -19,6 +19,8 @@ impl MigrationTrait for Migration { .col(char_len_uniq(Users::UsernameSkeleton, 64)) .col(string_len_uniq(Users::EmailKey, 255)) .col(timestamp_null(Users::EmailVerifiedAt)) + // Nueva dirección pedida en el perfil, hasta que se confirma desde ella. + .col(string_len_null(Users::PendingEmail, 254)) .col(string(Users::PasswordHash)) // 0=Blocked, 1=Active, 2=Pending .col(small_integer(Users::Status).default(1)) @@ -57,6 +59,7 @@ pub enum Users { UsernameSkeleton, EmailKey, EmailVerifiedAt, + PendingEmail, PasswordHash, Status, Language, diff --git a/extensions/pagetop-user/src/migration/m20260629_000006_create_user_tokens.rs b/extensions/pagetop-user/src/migration/m20260629_000006_create_user_tokens.rs index a9390c0d..8120abfe 100644 --- a/extensions/pagetop-user/src/migration/m20260629_000006_create_user_tokens.rs +++ b/extensions/pagetop-user/src/migration/m20260629_000006_create_user_tokens.rs @@ -10,7 +10,7 @@ impl MigrationTrait for Migration { table_auto(UserTokens::Table) .col(pk_auto(UserTokens::Id)) .col(integer(UserTokens::UserId)) - // "email_verification" | "password_reset" + // "email_verification" | "password_reset" | "email_change" .col(string_len(UserTokens::Kind, 32)) // SHA-256 del token plano (nunca se almacena el token en claro) .col(char_len_uniq(UserTokens::TokenHash, 64)) diff --git a/extensions/pagetop-user/src/service/user_admin.rs b/extensions/pagetop-user/src/service/user_admin.rs index 07d1b5de..b72f75b7 100644 --- a/extensions/pagetop-user/src/service/user_admin.rs +++ b/extensions/pagetop-user/src/service/user_admin.rs @@ -294,12 +294,17 @@ pub(crate) struct UserUpdateData<'a> { pub language: Option<&'a str>, pub timezone: Option<&'a str>, pub theme: Option<&'a str>, - /// Si un email nuevo se da por verificado: `true` cuando lo cambia un administrador, que da fe - /// de él igual que al dar de alta (ver [`create_user`]). Si lo cambia el propio usuario, queda - /// sin verificar hasta que se compruebe que la dirección es suya. - pub email_verified: bool, } +/// Guarda los datos de la cuenta. Un email distinto del actual se da por verificado: sólo lo +/// cambia así un administrador, que da fe de él igual que al dar de alta (ver [`create_user`]). El +/// propio usuario conserva aquí el suyo y lo cambia con `auth::request_email_change()`, que no lo +/// aplica hasta que se confirma desde la nueva dirección. +/// +/// La dirección que fija el administrador descarta la que el usuario tuviera pendiente de +/// confirmar (ver `auth::cancel_email_change()`): si la corrige porque otra persona pidió +/// cambiarla, el enlace de esa petición no debe deshacer la corrección. También anula los enlaces +/// enviados a la dirección anterior (ver `auth::revoke_address_tokens()`). pub(crate) async fn update_user(user_id: i32, data: UserUpdateData<'_>) -> Result<(), AuthError> { // Un nombre que no cambia no se valida de nuevo con la política (ver `identity::username()`). let current = find_user(user_id).await?; @@ -354,12 +359,17 @@ pub(crate) async fn update_user(user_id: i32, data: UserUpdateData<'_>) -> Resul updated_at: Set(now), ..Default::default() }; - if *email.key() != current.email_key { - model.email_verified_at = Set(data.email_verified.then_some(now)); + let email_changed = *email.key() != current.email_key; + if email_changed { + model.email_verified_at = Set(Some(now)); } username.set_on(&mut model); email.set_on(&mut model); model.update(dbconn()).await?; + if email_changed { + crate::auth::cancel_email_change(user_id).await?; + crate::auth::revoke_address_tokens(user_id).await?; + } Ok(()) } @@ -494,12 +504,15 @@ pub(crate) async fn set_user_admin( // **< admin_reset_password >*********************************************************************** /// Restablece la contraseña de un usuario como acción administrativa, invalida sus sesiones -/// activas y levanta el bloqueo temporal por intentos fallidos. +/// activas, levanta el bloqueo temporal por intentos fallidos, descarta el cambio de email que +/// tuviera pendiente (ver `auth::cancel_email_change()`) y anula los enlaces de recuperación que +/// tuviera sin usar. Devuelve la cuenta, para avisar del +/// cambio a su dirección. pub(crate) async fn admin_reset_password( user_id: i32, new_password: &str, -) -> Result<(), AuthError> { - find_user(user_id).await?; +) -> Result { + let user_model = find_user(user_id).await?; password::validate_strength(new_password)?; let hash = password::hash_password_async(new_password).await?; @@ -519,7 +532,10 @@ pub(crate) async fn admin_reset_password( session::destroy_user_sessions(user_id) .await .map_err(AuthError::Database)?; - Ok(()) + crate::auth::cancel_email_change(user_id).await?; + // Un enlace de recuperación pedido antes no debe deshacer el cambio. + crate::token::revoke_tokens(user_id, crate::token::TokenKind::PasswordReset).await?; + Ok(user_model) } // **< HELPERS >************************************************************************************ diff --git a/extensions/pagetop-user/src/throttle.rs b/extensions/pagetop-user/src/throttle.rs new file mode 100644 index 00000000..1c12635d --- /dev/null +++ b/extensions/pagetop-user/src/throttle.rs @@ -0,0 +1,149 @@ +//! Límite de solicitudes por dirección IP (`user.max_ip_requests`). + +use pagetop::prelude::*; + +use crate::config::SETTINGS; + +use std::collections::{HashMap, VecDeque}; +use std::net::{IpAddr, Ipv6Addr}; +use std::sync::{LazyLock, Mutex, PoisonError}; +use std::time::{Duration as StdDuration, Instant}; + +// Momentos de las solicitudes de cada dirección dentro de la ventana, y última limpieza. +struct Requests { + by_ip: HashMap>, + purged_at: Instant, +} + +static REQUESTS: LazyLock> = LazyLock::new(|| { + Mutex::new(Requests { + by_ip: HashMap::new(), + purged_at: Instant::now(), + }) +}); + +/// 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). +/// +/// Una solicitud rechazada no se anota: la dirección vuelve a disponer de solicitudes en cuanto la +/// más antigua sale de la ventana. Las de dirección desconocida se admiten siempre. +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), + network(ip), + Instant::now(), + SETTINGS.max_ip_requests, + window, + ); + if !allowed { + trace::warn!("Request limit reached for address {ip}"); + } + allowed +} + +fn allow_at( + requests: &mut Requests, + ip: IpAddr, + now: Instant, + max: u32, + window: StdDuration, +) -> bool { + if max == 0 { + return true; + } + let expired = |at: &Instant| now.duration_since(*at) >= window; + // Sin limpiar, la tabla guardaría todas las direcciones vistas desde el arranque. Basta con + // hacerlo una vez por ventana: sólo quedan las direcciones con solicitudes recientes. + if now.duration_since(requests.purged_at) >= window { + requests + .by_ip + .retain(|_, times| times.back().is_some_and(|at| !expired(at))); + requests.purged_at = now; + } + let times = requests.by_ip.entry(ip).or_default(); + while times.front().is_some_and(expired) { + times.pop_front(); + } + if times.len() >= usize::try_from(max).unwrap_or(usize::MAX) { + return false; + } + times.push_back(now); + true +} + +// 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 { + match ip { + IpAddr::V4(_) => ip, + IpAddr::V6(v6) => { + let mut segments = v6.segments(); + segments[4..].fill(0); + IpAddr::V6(Ipv6Addr::from(segments)) + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + const WINDOW: StdDuration = StdDuration::from_secs(60); + + fn requests(start: Instant) -> Requests { + Requests { + by_ip: HashMap::new(), + purged_at: start, + } + } + + fn ip(value: &str) -> IpAddr { + value.parse().unwrap() + } + + #[pagetop::test] + async fn requests_over_the_limit_are_rejected_until_the_oldest_expires() { + let start = Instant::now(); + let mut log = requests(start); + let at = |secs| start + StdDuration::from_secs(secs); + assert!(allow_at(&mut log, ip("192.0.2.1"), at(0), 2, WINDOW)); + assert!(allow_at(&mut log, ip("192.0.2.1"), at(10), 2, WINDOW)); + assert!(!allow_at(&mut log, ip("192.0.2.1"), at(20), 2, WINDOW)); + // Other addresses keep their own count. + assert!(allow_at(&mut log, ip("192.0.2.2"), at(20), 2, WINDOW)); + // A rejected request is not counted: the first one expires at 60 s. + assert!(allow_at(&mut log, ip("192.0.2.1"), at(60), 2, WINDOW)); + assert!(!allow_at(&mut log, ip("192.0.2.1"), at(61), 2, WINDOW)); + } + + #[pagetop::test] + async fn zero_maximum_never_limits() { + let start = Instant::now(); + let mut log = requests(start); + for _ in 0..10 { + assert!(allow_at(&mut log, ip("192.0.2.1"), start, 0, WINDOW)); + } + assert!(log.by_ip.is_empty()); + } + + #[pagetop::test] + async fn addresses_without_recent_requests_are_purged() { + let start = Instant::now(); + let mut log = requests(start); + allow_at(&mut log, ip("192.0.2.1"), start, 5, WINDOW); + allow_at(&mut log, ip("192.0.2.2"), start + WINDOW, 5, WINDOW); + assert_eq!(log.by_ip.len(), 1); + assert!(log.by_ip.contains_key(&ip("192.0.2.2"))); + } + + #[pagetop::test] + async fn ipv6_addresses_count_by_their_64_network() { + assert_eq!(network(ip("2001:db8:1:2:aaaa::1")), ip("2001:db8:1:2::")); + assert_eq!(network(ip("192.0.2.1")), ip("192.0.2.1")); + } +} diff --git a/extensions/pagetop-user/src/token.rs b/extensions/pagetop-user/src/token.rs index bb4902b5..66eec852 100644 --- a/extensions/pagetop-user/src/token.rs +++ b/extensions/pagetop-user/src/token.rs @@ -41,6 +41,16 @@ pub fn hash_token(token: &str) -> String { s } +// Hash que se guarda de un token ligado a `binding` (ver `create_bound_token()`). Sin `binding`, el +// de `hash_token()`. El token es base64url, sin saltos de línea: el separador no es ambiguo. +fn bound_hash(token: &str, binding: &str) -> String { + if binding.is_empty() { + hash_token(token) + } else { + hash_token(&util::join!(token, "\n", binding)) + } +} + // **< TokenKind >********************************************************************************** /// Tipos de token que emite `pagetop-user`. @@ -48,6 +58,8 @@ pub fn hash_token(token: &str) -> String { pub enum TokenKind { PasswordReset, EmailVerification, + /// Confirma la nueva dirección pedida en el perfil (`pending_email`). + EmailChange, } impl TokenKind { @@ -55,6 +67,7 @@ impl TokenKind { match self { TokenKind::PasswordReset => "password_reset", TokenKind::EmailVerification => "email_verification", + TokenKind::EmailChange => "email_change", } } @@ -63,6 +76,7 @@ impl TokenKind { match self { TokenKind::PasswordReset => 3600, // 1 hora TokenKind::EmailVerification => 86400 * 3, // 3 días + TokenKind::EmailChange => 86400, // 1 día } } @@ -71,7 +85,7 @@ impl TokenKind { fn keep_secs(self) -> i64 { match self { TokenKind::PasswordReset => self.ttl_secs().max(SETTINGS.password_reset_window_secs), - TokenKind::EmailVerification => self.ttl_secs(), + TokenKind::EmailVerification | TokenKind::EmailChange => self.ttl_secs(), } } } @@ -83,18 +97,22 @@ impl TokenKind { /// Anula los tokens del mismo tipo que el usuario tenga sin consumir, de modo que sólo vale el /// último enlace enviado. pub async fn create_token(user_id: i32, kind: TokenKind) -> Result { + create_bound_token(user_id, kind, "").await +} + +/// Como [`create_token()`], pero el token sólo vale junto con `binding` (p. ej. la dirección a la +/// que se envía): [`is_valid_bound_token()`] y [`consume_bound_token()`] lo rechazan con otro +/// valor. Así un enlace no sirve para lo que haya cambiado después de enviarlo. +pub async fn create_bound_token( + user_id: i32, + kind: TokenKind, + binding: &str, +) -> Result { let now = Utc::now(); // Los anteriores se anulan en lugar de borrarse para que sigan contando en // `count_tokens_since()`; sólo se borran los que ya no pueden usarse ni cuentan. - user_token::Entity::update_many() - .col_expr(user_token::Column::ConsumedAt, Expr::value(now)) - .col_expr(user_token::Column::UpdatedAt, Expr::value(now)) - .filter(user_token::Column::UserId.eq(user_id)) - .filter(user_token::Column::Kind.eq(kind.as_str())) - .filter(user_token::Column::ConsumedAt.is_null()) - .exec(dbconn()) - .await?; + revoke_tokens(user_id, kind).await?; user_token::Entity::delete_many() .filter(user_token::Column::UserId.eq(user_id)) .filter(user_token::Column::Kind.eq(kind.as_str())) @@ -109,7 +127,7 @@ pub async fn create_token(user_id: i32, kind: TokenKind) -> Result Result Result<(), AuthError> { + let now = Utc::now(); + user_token::Entity::update_many() + .col_expr(user_token::Column::ConsumedAt, Expr::value(now)) + .col_expr(user_token::Column::UpdatedAt, Expr::value(now)) + .filter(user_token::Column::UserId.eq(user_id)) + .filter(user_token::Column::Kind.eq(kind.as_str())) + .filter(user_token::Column::ConsumedAt.is_null()) + .exec(dbconn()) + .await?; + Ok(()) +} + /// Cuenta los tokens del tipo indicado creados para el usuario desde `since`, consumidos o no. /// /// Los tokens se conservan al menos durante su tiempo de vida o, en los de recuperación de @@ -143,8 +176,18 @@ pub async fn count_tokens_since( /// Comprueba, sin consumirlo, que el token en claro sea válido para el usuario: existe, es del tipo /// indicado, no ha caducado y no se ha consumido. pub async fn is_valid_token(user_id: i32, token: &str, kind: TokenKind) -> Result { + is_valid_bound_token(user_id, token, kind, "").await +} + +/// Como [`is_valid_token()`], para un token creado con [`create_bound_token()`] y `binding`. +pub async fn is_valid_bound_token( + user_id: i32, + token: &str, + kind: TokenKind, + binding: &str, +) -> Result { let row = user_token::Entity::find() - .filter(user_token::Column::TokenHash.eq(hash_token(token))) + .filter(user_token::Column::TokenHash.eq(bound_hash(token, binding))) .filter(user_token::Column::UserId.eq(user_id)) .filter(user_token::Column::Kind.eq(kind.as_str())) .filter(user_token::Column::ConsumedAt.is_null()) @@ -160,11 +203,21 @@ pub async fn is_valid_token(user_id: i32, token: &str, kind: TokenKind) -> Resul /// sentencia condicionada a que siga sin consumir: dos peticiones simultáneas con el mismo enlace /// no pueden usarlo las dos. pub async fn consume_token(user_id: i32, token: &str, kind: TokenKind) -> Result<(), AuthError> { + consume_bound_token(user_id, token, kind, "").await +} + +/// Como [`consume_token()`], para un token creado con [`create_bound_token()`] y `binding`. +pub async fn consume_bound_token( + user_id: i32, + token: &str, + kind: TokenKind, + binding: &str, +) -> Result<(), AuthError> { let now = Utc::now(); let result = user_token::Entity::update_many() .col_expr(user_token::Column::ConsumedAt, Expr::value(now)) .col_expr(user_token::Column::UpdatedAt, Expr::value(now)) - .filter(user_token::Column::TokenHash.eq(hash_token(token))) + .filter(user_token::Column::TokenHash.eq(bound_hash(token, binding))) .filter(user_token::Column::UserId.eq(user_id)) .filter(user_token::Column::Kind.eq(kind.as_str())) .filter(user_token::Column::ConsumedAt.is_null()) diff --git a/extensions/pagetop-user/tests/flows.rs b/extensions/pagetop-user/tests/flows.rs new file mode 100644 index 00000000..a24ab84e --- /dev/null +++ b/extensions/pagetop-user/tests/flows.rs @@ -0,0 +1,689 @@ +// 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` and `max_ip_requests = 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 +// and addresses, and emails are sent in the background, so `mail_to()` waits for them. + +use pagetop::prelude::*; +use pagetop_mail::outbox::{self, SentEmail}; + +use std::net::SocketAddr; + +struct TestApp; + +#[async_trait] +impl Extension for TestApp { + fn dependencies(&self) -> Vec { + vec![&pagetop_user::User] + } +} + +type Status = web::http::StatusCode; + +// Response status, headers and body text. +struct Reply { + status: Status, + headers: web::http::HeaderMap, + body: String, +} + +impl Reply { + fn location(&self) -> &str { + self.header("location") + } + + fn header(&self, name: &str) -> &str { + self.headers + .get(name) + .and_then(|value| value.to_str().ok()) + .unwrap_or_default() + } + + // `name=value` of the session cookie, to send it back. + fn session_cookie(&self) -> Option { + let cookie = self.header("set-cookie"); + let pair = cookie.split(';').next()?; + (!pair.ends_with('=')).then(|| pair.to_owned()) + } +} + +struct Client { + app: Router, +} + +impl Client { + async fn send(&self, request: web::test::TestRequest) -> Reply { + let response = web::test::send_request(&self.app, request.to_request()).await; + let status = response.status(); + let headers = response.headers().clone(); + let body = web::test::read_body_text(response).await; + Reply { + status, + headers, + body, + } + } + + async fn get(&self, uri: &str, session: Option<&str>) -> Reply { + self.send(with_session( + web::test::TestRequest::get().uri(uri), + session, + )) + .await + } + + async fn post(&self, uri: &str, fields: &str, session: Option<&str>) -> Reply { + let request = web::test::TestRequest::post().uri(uri).form(fields); + self.send(with_session(request, session)).await + } + + // Signs in and returns the session cookie, or `None` if the credentials are rejected. + async fn login(&self, username: &str, password: &str) -> Option { + let fields = form(&[("username", username), ("password", password)]); + let reply = self.post("/user/login", &fields, None).await; + match reply.status { + Status::SEE_OTHER => Some(reply.session_cookie().expect("login sets the cookie")), + Status::OK => None, + status => panic!("unexpected login status {status}"), + } + } +} + +fn with_session(request: web::test::TestRequest, session: Option<&str>) -> web::test::TestRequest { + match session { + Some(cookie) => request.header("cookie", cookie), + None => request, + } +} + +// Form body with every value encoded. +fn form(fields: &[(&str, &str)]) -> String { + let mut body = String::new(); + for (name, value) in fields { + if !body.is_empty() { + body.push('&'); + } + body.push_str(name); + body.push('='); + for byte in value.bytes() { + if byte.is_ascii_alphanumeric() || b"-._~".contains(&byte) { + body.push(char::from(byte)); + } else { + body.push_str(&format!("%{byte:02X}")); + } + } + } + body +} + +// Waits for the only email sent to `address` in the background. +async fn mail_to(address: &str) -> SentEmail { + for _ in 0..200 { + let mut sent = outbox::take_to(address); + if !sent.is_empty() { + assert_eq!(sent.len(), 1, "expected exactly one email for {address}"); + return sent.remove(0); + } + tokio::time::sleep(std::time::Duration::from_millis(25)).await; + } + panic!("no email sent to {address}"); +} + +// Waits a while to check that nothing has been sent to `address`. +async fn no_mail_to(address: &str) { + tokio::time::sleep(std::time::Duration::from_millis(300)).await; + assert!( + outbox::take_to(address).is_empty(), + "no email expected for {address}" + ); +} + +// Path of the first link in the email that starts with `prefix`, without the base URL. +fn link(sent: &SentEmail, prefix: &str) -> String { + sent.links() + .into_iter() + .filter_map(|link| link.strip_prefix("https://example.com").map(str::to_owned)) + .find(|path| path.starts_with(prefix)) + .unwrap_or_else(|| panic!("no {prefix} link in {:?}", sent.links())) +} + +// User id in a `/{base}/{uid}/{token}` link. +fn uid(path: &str) -> &str { + path.rsplit('/').nth(1).unwrap() +} + +// Path without its query string. +fn path(link: &str) -> &str { + link.split('?').next().unwrap() +} + +// Registers and verifies an account, and returns its id. +async fn verified_account(client: &Client, username: &str, email: &str, password: &str) -> String { + let fields = form(&[ + ("username", username), + ("email", email), + ("password", password), + ("confirm_password", password), + ]); + let reply = client.post("/user/register", &fields, None).await; + assert_eq!(reply.status, Status::OK, "sign-up of {username} failed"); + let verify = link(&mail_to(email).await, "/user/verify/"); + let reply = client.post(path(&verify), "", None).await; + assert_eq!(reply.status, Status::SEE_OTHER); + uid(path(&verify)).to_owned() +} + +#[pagetop::test] +async fn account_flows() { + let client = Client { + app: Application::prepare(&TestApp).await.test(), + }; + registration_requires_confirming_the_address(&client).await; + password_reset_links_are_single_use(&client).await; + failed_logins_lock_the_account(&client).await; + password_changes_are_notified(&client).await; + email_changes_are_confirmed_from_the_new_address(&client).await; + password_reset_cancels_a_pending_email_change(&client).await; + administrators_activate_accounts_and_reset_passwords(&client).await; + password_changes_revoke_older_reset_links(&client).await; + email_changes_revoke_links_sent_to_the_old_address(&client).await; + email_change_links_are_bound_to_their_address(&client).await; + wrong_current_passwords_lock_the_account(&client).await; + requests_are_limited_by_address(&client).await; +} + +async fn registration_requires_confirming_the_address(client: &Client) { + let fields = form(&[ + ("username", "ana"), + ("email", "ana@example.com"), + ("password", "ana-password"), + ("confirm_password", "ana-password"), + ]); + let reply = client.post("/user/register", &fields, None).await; + assert_eq!(reply.status, Status::OK); + let sent = mail_to("ana@example.com").await; + // The address may belong to someone else: the email does not include the chosen username. + assert!(!sent.email().html().unwrap().as_str().contains("ana,")); + let verify = link(&sent, "/user/verify/"); + + // A pending account cannot sign in. + assert_eq!(client.login("ana", "ana-password").await, None); + + // Opening the link only asks for confirmation, without leaking the token to other sites. + let reply = client.get(&verify, None).await; + assert_eq!(reply.status, Status::OK); + assert_eq!(reply.header("referrer-policy"), "no-referrer"); + assert_eq!(client.login("ana", "ana-password").await, None); + + let reply = client.post(path(&verify), "", None).await; + assert_eq!(reply.status, Status::SEE_OTHER); + assert_eq!(path(reply.location()), "/user/login"); + assert!(client.login("ana", "ana-password").await.is_some()); + assert!( + client + .login("ANA@example.com", "ana-password") + .await + .is_some() + ); + + // The link is single use. + assert_eq!(client.get(&verify, None).await.status, Status::NOT_FOUND); +} + +async fn password_reset_links_are_single_use(client: &Client) { + verified_account(client, "bea", "bea@example.com", "bea-password").await; + + // Unknown addresses get the same answer, and no email. + let unknown = client + .post("/user/password/reset", "email=nobody%40example.com", None) + .await; + let reply = client + .post("/user/password/reset", "email=bea%40example.com", None) + .await; + assert_eq!(unknown.status, Status::OK); + assert_eq!(unknown.body, reply.body); + no_mail_to("nobody@example.com").await; + let reset = link(&mail_to("bea@example.com").await, "/user/password/reset/"); + + let reply = client.get(&reset, None).await; + assert_eq!(reply.status, Status::OK); + assert_eq!(reply.header("referrer-policy"), "no-referrer"); + + // An invalid password does not spend the link. + let mismatch = form(&[ + ("password", "bea-new-password"), + ("confirm_password", "something-else"), + ]); + let reply = client.post(path(&reset), &mismatch, None).await; + assert_eq!(reply.status, Status::OK); + assert_eq!(reply.header("referrer-policy"), "no-referrer"); + assert_eq!(client.get(&reset, None).await.status, Status::OK); + + let fields = form(&[ + ("password", "bea-new-password"), + ("confirm_password", "bea-new-password"), + ]); + let reply = client.post(path(&reset), &fields, None).await; + assert_eq!(reply.status, Status::SEE_OTHER); + assert_eq!(client.get(&reset, None).await.status, Status::NOT_FOUND); + assert_eq!(client.login("bea", "bea-password").await, None); + assert!(client.login("bea", "bea-new-password").await.is_some()); +} + +async fn failed_logins_lock_the_account(client: &Client) { + verified_account(client, "carla", "carla@example.com", "carla-password").await; + for _ in 0..3 { + assert_eq!(client.login("carla", "wrong-password").await, None); + } + // Locked: even the right password is rejected until the lock expires. + assert_eq!(client.login("carla", "carla-password").await, None); + + // Resetting the password lifts the lock. + client + .post("/user/password/reset", "email=carla%40example.com", None) + .await; + let reset = link(&mail_to("carla@example.com").await, "/user/password/reset/"); + let fields = form(&[ + ("password", "carla-new-password"), + ("confirm_password", "carla-new-password"), + ]); + client.post(path(&reset), &fields, None).await; + assert!(client.login("carla", "carla-new-password").await.is_some()); +} + +async fn password_changes_are_notified(client: &Client) { + verified_account(client, "dani", "dani@example.com", "dani-password").await; + let session = client.login("dani", "dani-password").await.unwrap(); + + let wrong = form(&[ + ("current_password", "wrong-password"), + ("password", "dani-new-password"), + ("confirm_password", "dani-new-password"), + ]); + let reply = client.post("/user/password", &wrong, Some(&session)).await; + assert_eq!(reply.status, Status::OK); + no_mail_to("dani@example.com").await; + + let fields = form(&[ + ("current_password", "dani-password"), + ("password", "dani-new-password"), + ("confirm_password", "dani-new-password"), + ]); + let reply = client.post("/user/password", &fields, Some(&session)).await; + assert_eq!(reply.status, Status::SEE_OTHER); + let notice = mail_to("dani@example.com").await; + // A verified address is greeted by name and offered the way to recover the account. + assert!(notice.email().html().unwrap().as_str().contains("dani")); + link(¬ice, "/user/password/reset"); +} + +async fn email_changes_are_confirmed_from_the_new_address(client: &Client) { + verified_account(client, "eva", "eva@example.com", "eva-password").await; + let session = client.login("eva", "eva-password").await.unwrap(); + assert_eq!( + client.get("/user/email", Some(&session)).await.status, + Status::OK + ); + + // The current password is required. + let wrong = form(&[ + ("email", "eva.new@example.com"), + ("current_password", "wrong-password"), + ]); + let reply = client.post("/user/email", &wrong, Some(&session)).await; + assert_eq!(reply.status, Status::OK); + no_mail_to("eva.new@example.com").await; + + // The profile form cannot change the address. + let profile = form(&[("email", "eva.other@example.com"), ("display_name", "Eva")]); + let reply = client.post("/user/edit", &profile, Some(&session)).await; + assert_eq!(reply.status, Status::SEE_OTHER); + assert_eq!( + client.login("eva.other@example.com", "eva-password").await, + None + ); + + let fields = form(&[ + ("email", "eva.new@example.com"), + ("current_password", "eva-password"), + ]); + let reply = client.post("/user/email", &fields, Some(&session)).await; + assert_eq!(reply.status, Status::OK); + let confirm = mail_to("eva.new@example.com").await; + // The new address may belong to someone else: no name in the greeting. + assert!(!confirm.email().html().unwrap().as_str().contains("Eva")); + let confirm = link(&confirm, "/user/email/"); + link(&mail_to("eva@example.com").await, "/user/password/reset"); + + // Nothing changes until the new address is confirmed. + assert_eq!( + client.login("eva.new@example.com", "eva-password").await, + None + ); + assert!( + client + .login("eva@example.com", "eva-password") + .await + .is_some() + ); + let reply = client.get(&confirm, None).await; + assert_eq!(reply.status, Status::OK); + assert_eq!(reply.header("referrer-policy"), "no-referrer"); + + let reply = client.post(path(&confirm), "", None).await; + assert_eq!(reply.status, Status::SEE_OTHER); + assert_eq!(path(reply.location()), "/user"); + assert!( + client + .login("eva.new@example.com", "eva-password") + .await + .is_some() + ); + assert_eq!(client.login("eva@example.com", "eva-password").await, None); + assert_eq!(client.get(&confirm, None).await.status, Status::NOT_FOUND); + + // The address of another account cannot be requested. + let taken = form(&[ + ("email", "ana@example.com"), + ("current_password", "eva-password"), + ]); + let reply = client.post("/user/email", &taken, Some(&session)).await; + assert_eq!(reply.status, Status::OK); + no_mail_to("ana@example.com").await; +} + +async fn password_reset_cancels_a_pending_email_change(client: &Client) { + verified_account(client, "fede", "fede@example.com", "fede-password").await; + let session = client.login("fede", "fede-password").await.unwrap(); + let fields = form(&[ + ("email", "intruder@example.com"), + ("current_password", "fede-password"), + ]); + client.post("/user/email", &fields, Some(&session)).await; + let confirm = link(&mail_to("intruder@example.com").await, "/user/email/"); + mail_to("fede@example.com").await; + + // The owner follows the notice and resets the password. + client + .post("/user/password/reset", "email=fede%40example.com", None) + .await; + let reset = link(&mail_to("fede@example.com").await, "/user/password/reset/"); + let new_password = form(&[ + ("password", "fede-new-password"), + ("confirm_password", "fede-new-password"), + ]); + client.post(path(&reset), &new_password, None).await; + + assert_eq!(client.get(&confirm, None).await.status, Status::NOT_FOUND); + assert_eq!( + client.post(path(&confirm), "", None).await.status, + Status::NOT_FOUND + ); + assert!( + client + .login("fede@example.com", "fede-new-password") + .await + .is_some() + ); + // The reset also closed the session that requested the change. + let reply = client.get("/user/email", Some(&session)).await; + assert_eq!(reply.status, Status::SEE_OTHER); +} + +async fn administrators_activate_accounts_and_reset_passwords(client: &Client) { + let fields = form(&[ + ("username", "gil"), + ("email", "gil@example.com"), + ("password", "gil-password"), + ("confirm_password", "gil-password"), + ]); + client.post("/user/register", &fields, None).await; + let id = uid(path(&link( + &mail_to("gil@example.com").await, + "/user/verify/", + ))) + .to_owned(); + assert_eq!(client.login("gil", "gil-password").await, None); + + // Only users with the permission reach the administration. + let ana = client.login("ana", "ana-password").await.unwrap(); + let status = format!("/admin/user/users/{id}/status"); + let reply = client.post(&status, "status=active", Some(&ana)).await; + assert_eq!(reply.status, Status::FORBIDDEN); + assert_eq!(client.login("gil", "gil-password").await, None); + + let admin = client.login("admin", "admin-password").await.unwrap(); + let edit = client + .get(&format!("/admin/user/users/{id}/edit"), Some(&admin)) + .await; + assert_eq!(edit.status, Status::OK); + assert!(edit.body.contains(&format!("action=\"{status}\""))); + let reply = client.post(&status, "status=active", Some(&admin)).await; + assert_eq!(reply.status, Status::SEE_OTHER); + let gil = client.login("gil", "gil-password").await.unwrap(); + + // An address set by an administrator replaces the one pending confirmation. + let request = form(&[ + ("email", "gil.pending@example.com"), + ("current_password", "gil-password"), + ]); + client.post("/user/email", &request, Some(&gil)).await; + let confirm = link(&mail_to("gil.pending@example.com").await, "/user/email/"); + mail_to("gil@example.com").await; + let edit = form(&[("username", "gil"), ("email", "gil.admin@example.com")]); + let reply = client + .post(&format!("/admin/user/users/{id}/edit"), &edit, Some(&admin)) + .await; + assert_eq!(reply.status, Status::SEE_OTHER); + assert_eq!( + client.post(path(&confirm), "", None).await.status, + Status::NOT_FOUND + ); + assert!( + client + .login("gil.admin@example.com", "gil-password") + .await + .is_some() + ); + + let fields = form(&[ + ("password", "gil-new-password"), + ("confirm_password", "gil-new-password"), + ]); + let password = format!("/admin/user/users/{id}/password"); + let reply = client.post(&password, &fields, Some(&admin)).await; + assert_eq!(reply.status, Status::SEE_OTHER); + link( + &mail_to("gil.admin@example.com").await, + "/user/password/reset", + ); + assert!(client.login("gil", "gil-new-password").await.is_some()); + // Every session of the user is closed. + assert_eq!( + client.get("/user/email", Some(&gil)).await.status, + Status::SEE_OTHER + ); +} + +async fn password_changes_revoke_older_reset_links(client: &Client) { + verified_account(client, "irene", "irene@example.com", "irene-password").await; + client + .post("/user/password/reset", "email=irene%40example.com", None) + .await; + let reset = link(&mail_to("irene@example.com").await, "/user/password/reset/"); + + let session = client.login("irene", "irene-password").await.unwrap(); + let fields = form(&[ + ("current_password", "irene-password"), + ("password", "irene-new-password"), + ("confirm_password", "irene-new-password"), + ]); + let reply = client.post("/user/password", &fields, Some(&session)).await; + assert_eq!(reply.status, Status::SEE_OTHER); + mail_to("irene@example.com").await; + // A link requested before must not undo the change. + assert_eq!(client.get(&reset, None).await.status, Status::NOT_FOUND); +} + +async fn email_changes_revoke_links_sent_to_the_old_address(client: &Client) { + verified_account(client, "juan", "juan@example.com", "juan-password").await; + // Whoever still reads the old address (e.g. a former employer) may hold this link. + client + .post("/user/password/reset", "email=juan%40example.com", None) + .await; + let reset = link(&mail_to("juan@example.com").await, "/user/password/reset/"); + + let session = client.login("juan", "juan-password").await.unwrap(); + let request = |email| form(&[("email", email), ("current_password", "juan-password")]); + client + .post( + "/user/email", + &request("juan.first@example.com"), + Some(&session), + ) + .await; + let first = link(&mail_to("juan.first@example.com").await, "/user/email/"); + mail_to("juan@example.com").await; + client + .post( + "/user/email", + &request("juan.second@example.com"), + Some(&session), + ) + .await; + let second = link(&mail_to("juan.second@example.com").await, "/user/email/"); + mail_to("juan@example.com").await; + + // Only the last requested change can be confirmed. + assert_eq!(client.get(&first, None).await.status, Status::NOT_FOUND); + assert_eq!( + client.post(path(&first), "", None).await.status, + Status::NOT_FOUND + ); + assert_eq!( + client.post(path(&second), "", None).await.status, + Status::SEE_OTHER + ); + assert!( + client + .login("juan.second@example.com", "juan-password") + .await + .is_some() + ); + assert_eq!(client.get(&reset, None).await.status, Status::NOT_FOUND); +} + +async fn email_change_links_are_bound_to_their_address(client: &Client) { + use pagetop_seaorm::db::execute; + + verified_account(client, "lia", "lia@example.com", "lia-password").await; + let session = client.login("lia", "lia-password").await.unwrap(); + let fields = form(&[ + ("email", "lia.own@example.com"), + ("current_password", "lia-password"), + ]); + client.post("/user/email", &fields, Some(&session)).await; + let confirm = link(&mail_to("lia.own@example.com").await, "/user/email/"); + mail_to("lia@example.com").await; + + // A newer request may replace the pending address before the older link is revoked: that link + // must not apply an address nobody has confirmed. + let pending = + |email: &str| format!("UPDATE users SET pending_email = '{email}' WHERE username = 'lia'"); + execute(pending("someone.else@example.com")).await.unwrap(); + assert_eq!(client.get(&confirm, None).await.status, Status::NOT_FOUND); + assert_eq!( + client.post(path(&confirm), "", None).await.status, + Status::NOT_FOUND + ); + assert_eq!( + client + .login("someone.else@example.com", "lia-password") + .await, + None + ); + + // The link itself is still valid for its own address. + execute(pending("lia.own@example.com")).await.unwrap(); + assert_eq!( + client.post(path(&confirm), "", None).await.status, + Status::SEE_OTHER + ); + assert!( + client + .login("lia.own@example.com", "lia-password") + .await + .is_some() + ); +} + +async fn wrong_current_passwords_lock_the_account(client: &Client) { + verified_account(client, "kim", "kim@example.com", "kim-password").await; + let session = client.login("kim", "kim-password").await.unwrap(); + let change = |current| { + form(&[ + ("current_password", current), + ("password", "kim-new-password"), + ("confirm_password", "kim-new-password"), + ]) + }; + for _ in 0..3 { + let reply = client + .post("/user/password", &change("wrong-password"), Some(&session)) + .await; + assert_eq!(reply.status, Status::OK); + } + // With a stolen session, guessing the password here is as limited as signing in. + let reply = client + .post("/user/password", &change("kim-password"), Some(&session)) + .await; + assert_eq!(reply.status, Status::OK); + let email = form(&[ + ("email", "kim.new@example.com"), + ("current_password", "kim-password"), + ]); + let reply = client.post("/user/email", &email, Some(&session)).await; + assert_eq!(reply.status, Status::OK); + no_mail_to("kim.new@example.com").await; + no_mail_to("kim@example.com").await; + assert_eq!(client.login("kim", "kim-password").await, None); +} + +async fn requests_are_limited_by_address(client: &Client) { + let from = |ip: [u8; 4]| { + web::test::TestRequest::post() + .with_extension(web::ConnectInfo(SocketAddr::from((ip, 4711)))) + }; + let reset = |ip, email: &str| { + from(ip) + .uri("/user/password/reset") + .form(form(&[("email", email)])) + }; + for _ in 0..2 { + client.send(reset([192, 0, 2, 9], "bea@example.com")).await; + mail_to("bea@example.com").await; + } + let register = |ip| { + from(ip).uri("/user/register").form(form(&[ + ("username", "hugo"), + ("email", "hugo@example.com"), + ("password", "short"), + ("confirm_password", "short"), + ])) + }; + let reply = client.send(register([192, 0, 2, 9])).await; + assert!(!reply.body.contains("Too many requests")); + + // The fourth request from the same address is refused, with the same answer for resets. + let reply = client.send(reset([192, 0, 2, 9], "ana@example.com")).await; + assert_eq!(reply.status, Status::OK); + no_mail_to("ana@example.com").await; + let reply = client.send(register([192, 0, 2, 9])).await; + assert!(reply.body.contains("Too many requests")); + + // Other addresses keep their own count. + let reply = client.send(register([192, 0, 2, 10])).await; + assert!(!reply.body.contains("Too many requests")); +}