diff --git a/Cargo.lock b/Cargo.lock index d69da3a1..fddb5dcc 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -127,6 +127,150 @@ dependencies = [ "password-hash", ] +[[package]] +name = "async-channel" +version = "1.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "81953c529336010edd6d8e358f886d9581267795c61b19475b71314bffa46d35" +dependencies = [ + "concurrent-queue", + "event-listener 2.5.3", + "futures-core", +] + +[[package]] +name = "async-channel" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "924ed96dd52d1b75e9c1a3e6275715fd320f5f9439fb5a4a11fa51f4221158d2" +dependencies = [ + "concurrent-queue", + "event-listener-strategy", + "futures-core", + "pin-project-lite", +] + +[[package]] +name = "async-executor" +version = "1.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c96bf972d85afc50bf5ab8fe2d54d1586b4e0b46c97c50a0c9e71e2f7bcd812a" +dependencies = [ + "async-task", + "concurrent-queue", + "fastrand", + "futures-lite", + "pin-project-lite", + "slab", +] + +[[package]] +name = "async-global-executor" +version = "2.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05b1b633a2115cd122d73b955eadd9916c18c8f510ec9cd1686404c60ad1c29c" +dependencies = [ + "async-channel 2.5.0", + "async-executor", + "async-io", + "async-lock", + "blocking", + "futures-lite", + "once_cell", +] + +[[package]] +name = "async-io" +version = "2.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "456b8a8feb6f42d237746d4b3e9a178494627745c3c56c6ea55d92ba50d026fc" +dependencies = [ + "autocfg", + "cfg-if", + "concurrent-queue", + "futures-io", + "futures-lite", + "parking", + "polling", + "rustix", + "slab", + "windows-sys 0.61.2", +] + +[[package]] +name = "async-lock" +version = "3.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "290f7f2596bd5b78a9fec8088ccd89180d7f9f55b94b0576823bbbdc72ee8311" +dependencies = [ + "event-listener 5.4.1", + "event-listener-strategy", + "pin-project-lite", +] + +[[package]] +name = "async-process" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc50921ec0055cdd8a16de48773bfeec5c972598674347252c0399676be7da75" +dependencies = [ + "async-channel 2.5.0", + "async-io", + "async-lock", + "async-signal", + "async-task", + "blocking", + "cfg-if", + "event-listener 5.4.1", + "futures-lite", + "rustix", +] + +[[package]] +name = "async-signal" +version = "0.2.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52b5aaafa020cf5053a01f2a60e8ff5dccf550f0f77ec54a4e47285ac2bab485" +dependencies = [ + "async-io", + "async-lock", + "atomic-waker", + "cfg-if", + "futures-core", + "futures-io", + "rustix", + "signal-hook-registry", + "slab", + "windows-sys 0.61.2", +] + +[[package]] +name = "async-std" +version = "1.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2c8e079a4ab67ae52b7403632e4618815d6db36d2a010cfe41b02c1b1578f93b" +dependencies = [ + "async-channel 1.9.0", + "async-global-executor", + "async-io", + "async-lock", + "async-process", + "crossbeam-utils", + "futures-channel", + "futures-core", + "futures-io", + "futures-lite", + "gloo-timers", + "kv-log-macro", + "log", + "memchr", + "once_cell", + "pin-project-lite", + "pin-utils", + "slab", + "wasm-bindgen-futures", +] + [[package]] name = "async-stream" version = "0.3.6" @@ -149,6 +293,12 @@ dependencies = [ "syn", ] +[[package]] +name = "async-task" +version = "4.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de" + [[package]] name = "async-trait" version = "0.1.89" @@ -239,6 +389,12 @@ version = "0.22.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6" +[[package]] +name = "base64" +version = "0.23.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5" + [[package]] name = "base64ct" version = "1.8.3" @@ -281,6 +437,19 @@ dependencies = [ "hybrid-array", ] +[[package]] +name = "blocking" +version = "1.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a70e4329df6cb94385eed412ec92375c3cdd8a6e502493d1229b6414e4036dfa" +dependencies = [ + "async-channel 2.5.0", + "async-task", + "futures-io", + "futures-lite", + "piper", +] + [[package]] name = "bstr" version = "1.12.1" @@ -684,6 +853,22 @@ dependencies = [ "serde", ] +[[package]] +name = "email-encoding" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "420b9da095f052ea597503e39073b5b3c522f7db933fbac202d91d24492693fd" +dependencies = [ + "base64 0.23.1", + "memchr", +] + +[[package]] +name = "email_address" +version = "0.2.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e079f19b08ca6239f47f8ba8509c11cf3ea30095831f7fed61441475edd8c449" + [[package]] name = "equivalent" version = "1.0.2" @@ -711,6 +896,12 @@ dependencies = [ "windows-sys 0.48.0", ] +[[package]] +name = "event-listener" +version = "2.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0206175f82b8d6bf6652ff7d71a1e27fd2e4efde587fd368662814d6ec1d9ce0" + [[package]] name = "event-listener" version = "5.4.1" @@ -722,6 +913,16 @@ dependencies = [ "pin-project-lite", ] +[[package]] +name = "event-listener-strategy" +version = "0.5.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93" +dependencies = [ + "event-listener 5.4.1", + "pin-project-lite", +] + [[package]] name = "fastrand" version = "2.4.1" @@ -925,6 +1126,19 @@ version = "0.3.32" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718" +[[package]] +name = "futures-lite" +version = "2.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f78e10609fe0e0b3f4157ffab1876319b5b0db102a2c60dc4626306dc46b44ad" +dependencies = [ + "fastrand", + "futures-core", + "futures-io", + "parking", + "pin-project-lite", +] + [[package]] name = "futures-sink" version = "0.3.32" @@ -1018,6 +1232,18 @@ dependencies = [ "regex-syntax", ] +[[package]] +name = "gloo-timers" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbb143cf96099802033e0d4f4963b19fd2e0b728bcf076cd9cf7f6634f092994" +dependencies = [ + "futures-channel", + "futures-core", + "js-sys", + "wasm-bindgen", +] + [[package]] name = "grass" version = "0.13.4" @@ -1101,6 +1327,12 @@ version = "0.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" +[[package]] +name = "hermit-abi" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e17592d60ebacc7d5e169f4663c5f84f9161cc90328abcfe8456f41e4dfcb284" + [[package]] name = "hex" version = "0.4.3" @@ -1134,6 +1366,17 @@ dependencies = [ "windows-sys 0.61.2", ] +[[package]] +name = "hostname" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "617aaa3557aef3810a6369d0a99fac8a080891b68bd9f9812a1eeda0c0730cbd" +dependencies = [ + "cfg-if", + "libc", + "windows-link", +] + [[package]] name = "http" version = "1.4.1" @@ -1459,6 +1702,15 @@ dependencies = [ "wasm-bindgen", ] +[[package]] +name = "kv-log-macro" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0de8b303297635ad57c9f5059fd9cee7a47f8e8daa09df0fcd07dd39fb22977f" +dependencies = [ + "log", +] + [[package]] name = "lasso" version = "0.7.3" @@ -1483,6 +1735,35 @@ version = "0.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2" +[[package]] +name = "lettre" +version = "0.11.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2c646bd5cc763b1087b15493e29a64be6147ba8f19342004fa52048ee596eae" +dependencies = [ + "async-std", + "async-trait", + "base64 0.23.1", + "email-encoding", + "email_address", + "fastrand", + "futures-io", + "futures-util", + "hostname", + "httpdate", + "idna", + "mime", + "native-tls", + "nom", + "percent-encoding", + "quoted_printable", + "socket2", + "tokio", + "tokio-native-tls", + "url", + "uuid", +] + [[package]] name = "libc" version = "0.2.186" @@ -1544,6 +1825,9 @@ name = "log" version = "0.4.29" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897" +dependencies = [ + "value-bag", +] [[package]] name = "matchers" @@ -1641,6 +1925,15 @@ dependencies = [ "tempfile", ] +[[package]] +name = "nom" +version = "8.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df9761775871bdef83bee530e60050f7e54b1105350d6884eb0fb4f46c2f9405" +dependencies = [ + "memchr", +] + [[package]] name = "nu-ansi-term" version = "0.50.3" @@ -1882,6 +2175,18 @@ dependencies = [ "syn", ] +[[package]] +name = "pagetop-mail" +version = "0.1.0" +dependencies = [ + "lettre", + "mime_guess", + "pagetop", + "serde", + "thiserror", + "tokio", +] + [[package]] name = "pagetop-minimal" version = "0.1.0" @@ -1921,6 +2226,7 @@ dependencies = [ "pagetop", "pagetop-admin", "pagetop-htmx", + "pagetop-mail", "pagetop-seaorm", "rand_core", "serde", @@ -1928,6 +2234,10 @@ dependencies = [ "serde_qs", "sha2 0.11.0", "thiserror", + "tokio", + "unicode-ident", + "unicode-normalization", + "unicode-security", ] [[package]] @@ -2097,6 +2407,23 @@ version = "0.2.17" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd" +[[package]] +name = "pin-utils" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13bee6c73da26345c729282832b60b0363cf3dd9f4bfd81d8551b7a1c889a113" + +[[package]] +name = "piper" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c835479a4443ded371d6c535cbfd8d31ad92c5d23ae9770a61bc155e4992a3c1" +dependencies = [ + "atomic-waker", + "fastrand", + "futures-io", +] + [[package]] name = "pkcs1" version = "0.7.5" @@ -2130,6 +2457,20 @@ version = "0.2.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6" +[[package]] +name = "polling" +version = "3.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d0e4f59085d47d8241c88ead0f274e8a0cb551f3625263c05eb8dd897c34218" +dependencies = [ + "cfg-if", + "concurrent-queue", + "hermit-abi", + "pin-project-lite", + "rustix", + "windows-sys 0.61.2", +] + [[package]] name = "potential_utf" version = "0.1.5" @@ -2223,6 +2564,12 @@ dependencies = [ "proc-macro2", ] +[[package]] +name = "quoted_printable" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "478e0585659a122aa407eb7e3c0e1fa51b1d8a870038bd29f0cf4a8551eea972" + [[package]] name = "r-efi" version = "6.0.0" @@ -2754,13 +3101,13 @@ version = "0.8.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ee6798b1838b6a0f69c007c133b8df5866302197e404e8b6ee8ed3e3a5e68dc6" dependencies = [ - "base64", + "base64 0.22.1", "bytes", "chrono", "crc", "crossbeam-queue", "either", - "event-listener", + "event-listener 5.4.1", "futures-core", "futures-intrusive", "futures-io", @@ -2829,7 +3176,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "aa003f0038df784eb8fecbbac13affe3da23b45194bd57dba231c8f48199c526" dependencies = [ "atoi", - "base64", + "base64 0.22.1", "bitflags", "byteorder", "bytes", @@ -2872,7 +3219,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "db58fcd5a53cf07c184b154801ff91347e4c30d17a3562a635ff028ad5deda46" dependencies = [ "atoi", - "base64", + "base64 0.22.1", "bitflags", "byteorder", "chrono", @@ -3140,6 +3487,16 @@ dependencies = [ "syn", ] +[[package]] +name = "tokio-native-tls" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbae76ab933c85776efabc971569dd6119c580d8f5d448769dec1764bf796ef2" +dependencies = [ + "native-tls", + "tokio", +] + [[package]] name = "tokio-stream" version = "0.1.18" @@ -3428,6 +3785,22 @@ version = "0.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7df058c713841ad818f1dc5d3fd88063241cc61f49f5fbea4b951e8cf5a8d71d" +[[package]] +name = "unicode-script" +version = "0.5.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "383ad40bb927465ec0ce7720e033cb4ca06912855fc35db31b5755d0de75b1ee" + +[[package]] +name = "unicode-security" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2e4ddba1535dd35ed8b61c52166b7155d7f4e4b8847cec6f48e71dc66d8b5e50" +dependencies = [ + "unicode-normalization", + "unicode-script", +] + [[package]] name = "unicode-xid" version = "0.2.6" @@ -3458,12 +3831,29 @@ version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821" +[[package]] +name = "uuid" +version = "1.28.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7cc1186384beb7dd8eedea376413fd654937285ea6c9cfbb928dc3043ea4b606" +dependencies = [ + "getrandom 0.4.2", + "js-sys", + "wasm-bindgen", +] + [[package]] name = "valuable" version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65" +[[package]] +name = "value-bag" +version = "1.14.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2799ffb329a792ecfd902b71306c8a815a6ef1c0470fa9953a6aa4d4cecbe511" + [[package]] name = "vcpkg" version = "0.2.15" @@ -3529,6 +3919,16 @@ dependencies = [ "wasm-bindgen-shared", ] +[[package]] +name = "wasm-bindgen-futures" +version = "0.4.71" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96492d0d3ffba25305a7dc88720d250b1401d7edca02cc3bcd50633b424673b8" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + [[package]] name = "wasm-bindgen-macro" version = "0.2.121" diff --git a/Cargo.toml b/Cargo.toml index 809579fa..60af40a1 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -66,6 +66,9 @@ tracing = "0.1" tracing-appender = "0.2" tracing-subscriber = { version = "0.3", features = ["json", "env-filter"] } unic-langid = { version = "0.9", features = ["macros"] } +unicode-ident = "1.0" +unicode-normalization = "0.1" +unicode-security = "0.1" url = "2.5" # Helpers pagetop-build = { version = "0.3", path = "helpers/pagetop-build" } diff --git a/config/reference.toml b/config/reference.toml index 677aac28..41e082ce 100644 --- a/config/reference.toml +++ b/config/reference.toml @@ -124,7 +124,8 @@ transport = "log" # Entrega de los correos: # "memory" -> se guardan en memoria (sólo pruebas). #from = "Mi Aplicación " # Remitente por defecto, con o sin nombre. Sin valor, cada - # correo debe indicar el suyo. + # correo debe indicar el suyo para enviarse (salvo con "log"). + # Los de pagetop-user no lo indican: configúralo siempre. #reply_to = "soporte@example.com" # Dirección de respuesta por defecto. #redirect_to = "pruebas@example.com" # Entrega todos los correos sólo a esta dirección, sin # cambiar sus cabeceras (entornos de pruebas o preproducción). @@ -161,12 +162,23 @@ dir = "mail" # Directorio de los archivos .eml. Se crea s [user] allow_registration = true # Permite que los visitantes creen su propia cuenta. require_email_verification = false # Las cuentas nuevas quedan pendientes ("Pending") en lugar - # de activas hasta verificar el correo. + # de activas hasta confirmar la dirección desde el enlace del + # correo de verificación que se envía al registrarse. +identity_policy = "strict" # Nombres de usuario que se aceptan: + # "strict" -> letras ASCII sin tildes, dígitos, ".", "_" + # y "-", de 3 a 32 caracteres. + # "unicode" -> letras y dígitos de cualquier alfabeto, sin + # mezclarlos, ".", "_" y "-", de 3 a 32. + # "permissive" -> como "unicode", más espacios simples, "'" + # y "+", de 3 a 60. + # Con cualquiera: nunca "@", sin distinguir mayúsculas y sin + # nombres que se confundan con otro existente. -max_failed_logins = 5 # Intentos fallidos de acceso antes de bloquear la cuenta. -failed_login_window_secs = 900 # Ventana de recuento de intentos fallidos (15 minutos). - # Reservada: todavía no tiene efecto. +max_failed_logins = 5 # Intentos fallidos seguidos que bloquean la cuenta. 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). + # Después se dispone otra vez de todos los intentos. login_strict = false # Dificulta que el navegador recuerde o autorrellene las # credenciales en el formulario de acceso. @@ -187,15 +199,16 @@ write_interval_secs = 60 # Segundos mínimos entre dos escrituras de # bajarlo (o 0, escribir siempre) da más precisión si las # sesiones caducan tras pocos minutos sin uso. -[user.password] # Contraseñas, cifradas con Argon2id. -argon2_m_cost = 19456 # Coste de memoria en KiB. Si cambia, las contraseñas se - # vuelven a cifrar en el siguiente acceso de cada usuario. +[user.password] # Contraseñas, cifradas con Argon2id. Si cambia cualquiera de + # los tres costes, cada contraseña se vuelve a cifrar en el + # siguiente acceso de su usuario. +argon2_m_cost = 19456 # Coste de memoria en KiB. argon2_t_cost = 2 # Coste de tiempo (número de iteraciones). argon2_p_cost = 1 # Grado de paralelismo (número de hilos). -min_length = 8 # Longitud mínima de las contraseñas. +min_length = 8 # Longitud mínima de las contraseñas, en caracteres. [user.seed] # Primer administrador, creado si no existe ningún usuario. -admin_username = "admin" # Nombre de usuario. +admin_username = "admin" # Nombre de usuario, válido según "identity_policy". admin_email = "admin@example.com" # Correo electrónico. #admin_password = "cambiar" # Contraseña. Sin valor -> se genera una aleatoria y se # muestra una sola vez por la salida estándar al crearlo. diff --git a/extensions/pagetop-mail/src/config.rs b/extensions/pagetop-mail/src/config.rs index edcc252f..62cd91fe 100644 --- a/extensions/pagetop-mail/src/config.rs +++ b/extensions/pagetop-mail/src/config.rs @@ -44,7 +44,9 @@ pub struct MailSettings { pub transport: MailTransport, /// Remitente por defecto, para los correos que no indican uno propio. Admite la dirección sola /// (`"no-reply@example.com"`) o con nombre (`"Mi Aplicación "`). Sin - /// valor, cada correo debe indicar su remitente. + /// valor, cada correo debe indicar su remitente para enviarse, salvo con + /// [`MailTransport::Log`], que sólo lo escribe en las trazas. Los correos de otras extensiones, + /// como los de `pagetop-user`, no lo indican: conviene configurarlo siempre. pub from: Option, /// Dirección de respuesta por defecto, para los correos que no indican una propia. pub reply_to: Option, diff --git a/extensions/pagetop-user/Cargo.toml b/extensions/pagetop-user/Cargo.toml index 8acf19c1..1a77842e 100644 --- a/extensions/pagetop-user/Cargo.toml +++ b/extensions/pagetop-user/Cargo.toml @@ -23,10 +23,17 @@ pagetop.workspace = true pagetop-admin.workspace = true pagetop-seaorm.workspace = true pagetop-htmx.workspace = true +pagetop-mail.workspace = true serde.workspace = true serde_json.workspace = true serde_qs.workspace = true thiserror.workspace = true +tokio.workspace = true + +# Nombres de usuario +unicode-ident.workspace = true +unicode-normalization.workspace = true +unicode-security.workspace = true # Criptografía argon2.workspace = true diff --git a/extensions/pagetop-user/src/auth.rs b/extensions/pagetop-user/src/auth.rs index 7ba951d2..f5550dc8 100644 --- a/extensions/pagetop-user/src/auth.rs +++ b/extensions/pagetop-user/src/auth.rs @@ -2,16 +2,18 @@ use pagetop::prelude::*; use pagetop_seaorm::db::{ - ActiveModelTrait, ActiveValue, ColumnTrait, Condition, EntityTrait, IntoActiveModel, - PaginatorTrait, QueryFilter, Set, dbconn, + ActiveModelTrait, ActiveValue, ColumnTrait, EntityTrait, IntoActiveModel, PaginatorTrait, + QueryFilter, Set, dbconn, }; use crate::account::UserStatus; use crate::config::SETTINGS; use crate::entity::{role_permission, user}; use crate::error::AuthError; +use crate::identity::{self, Email, Username}; use crate::password; use crate::permission::UserPermission; +use crate::service::user_admin::{ensure_email_available, ensure_username_available}; use crate::session; // **< login >************************************************************************************** @@ -20,6 +22,11 @@ use crate::session; /// /// Acepta nombre de usuario o email como primer parámetro. Aplica la política de bloqueo /// por intentos fallidos y rehashea la contraseña si los parámetros de coste han cambiado. +/// +/// Sólo con la contraseña correcta se informa de que la cuenta está bloqueada +/// ([`AuthError::AccountBlocked`]) o pendiente de verificar ([`AuthError::AccountPending`]): sin +/// ella, cualquiera sabría así qué cuentas existen y en qué estado están. Por lo mismo, sin cuenta +/// se tarda lo mismo que con una contraseña errónea. pub async fn login( username_or_email: &str, plain_password: &str, @@ -27,16 +34,17 @@ pub async fn login( ) -> Result { let now = Utc::now(); - // Buscar usuario por username o email. - let user_model = user::Entity::find() - .filter( - Condition::any() - .add(user::Column::Username.eq(username_or_email)) - .add(user::Column::Email.eq(username_or_email)), - ) - .one(dbconn()) - .await? - .ok_or(AuthError::InvalidCredentials)?; + // Buscar usuario por email o por username, sin distinguir mayúsculas. Un nombre de usuario + // nunca contiene `@`, así que la entrada sólo puede ser uno de los dos. + let filter = if username_or_email.contains('@') { + user::Column::EmailKey.eq(identity::email_key(username_or_email)) + } else { + user::Column::UsernameKey.eq(identity::username_key(username_or_email)) + }; + let Some(user_model) = user::Entity::find().filter(filter).one(dbconn()).await? else { + password::verify_password_without_account(plain_password).await; + return Err(AuthError::InvalidCredentials); + }; // Comprobar bloqueo temporal por intentos fallidos. if let Some(locked_until) = user_model.locked_until @@ -45,6 +53,12 @@ pub async fn login( return Err(AuthError::AccountLocked); } + // Verificar contraseña. + if !password::verify_password_async(plain_password, &user_model.password_hash).await { + register_failed_login(&user_model, now).await?; + return Err(AuthError::InvalidCredentials); + } + // Comprobar estado de la cuenta. match UserStatus::from_i16(user_model.status) { UserStatus::Blocked => return Err(AuthError::AccountBlocked), @@ -52,12 +66,6 @@ pub async fn login( UserStatus::Active => {} } - // Verificar contraseña. - if !password::verify_password(plain_password, &user_model.password_hash) { - register_failed_login(&user_model, now).await?; - return Err(AuthError::InvalidCredentials); - } - // Actualizar last_login_at y resetear contador de fallos. let user_id = user_model.id; let needs_rehash = password::needs_rehash(&user_model.password_hash); @@ -65,9 +73,10 @@ pub async fn login( active.last_login_at = Set(Some(now)); active.last_access_at = Set(Some(now)); active.failed_login_count = Set(0); + active.failed_login_at = Set(None); active.locked_until = Set(None); if needs_rehash { - let new_hash = password::hash_password(plain_password)?; + let new_hash = password::hash_password_async(plain_password).await?; active.password_hash = Set(new_hash); } active.update(dbconn()).await?; @@ -91,35 +100,23 @@ pub async fn logout(sid: &str) -> Result<(), AuthError> { /// Registra un nuevo usuario. Devuelve el `user_id` asignado. /// -/// Valida: longitud de contraseña, coincidencia de confirmación, y unicidad de username y email. +/// Valida: username según la política de identidad y email (ver +/// [`IdentityPolicy`](crate::config::IdentityPolicy)), longitud de contraseña, coincidencia de +/// confirmación, y que ni el username (o uno que se confunda con él) ni el email estén en uso. pub async fn register( username: &str, email: &str, plain_password: &str, confirm_password: &str, ) -> Result { + let username = identity::username(username, SETTINGS.identity_policy, None)?; + let email = identity::email(email)?; password::validate_strength(plain_password)?; password::passwords_match(plain_password, confirm_password)?; + ensure_username_available(&username, None).await?; + ensure_email_available(&email, None).await?; - // Comprobar unicidad de username y email. - if user::Entity::find() - .filter(user::Column::Username.eq(username)) - .one(dbconn()) - .await? - .is_some() - { - return Err(AuthError::UsernameTaken); - } - if user::Entity::find() - .filter(user::Column::Email.eq(email)) - .one(dbconn()) - .await? - .is_some() - { - return Err(AuthError::EmailTaken); - } - - let hash = password::hash_password(plain_password)?; + let hash = password::hash_password_async(plain_password).await?; let now = Utc::now(); let status = if SETTINGS.require_email_verification { UserStatus::Pending @@ -127,10 +124,8 @@ pub async fn register( UserStatus::Active }; - let new_user = user::ActiveModel { + let mut new_user = user::ActiveModel { id: ActiveValue::NotSet, - username: Set(username.to_owned()), - email: Set(email.to_owned()), email_verified_at: Set(None), password_hash: Set(hash), status: Set(status.as_i16()), @@ -146,7 +141,10 @@ pub async fn register( is_admin: Set(false), created_at: Set(now), updated_at: Set(now), + ..Default::default() }; + username.set_on(&mut new_user); + email.set_on(&mut new_user); let result = user::Entity::insert(new_user).exec(dbconn()).await?; let user_id = result.last_insert_id; @@ -169,11 +167,11 @@ pub(crate) async fn change_own_password( .one(dbconn()) .await? .ok_or(AuthError::UserNotFound)?; - if !password::verify_password(current_password, &user_model.password_hash) { + if !password::verify_password_async(current_password, &user_model.password_hash).await { return Err(AuthError::InvalidCredentials); } password::validate_strength(new_password)?; - let hash = password::hash_password(new_password)?; + let hash = password::hash_password_async(new_password).await?; user::ActiveModel { id: Set(user_id), @@ -197,16 +195,21 @@ async fn register_failed_login( user_model: &user::Model, now: DateTime, ) -> Result<(), AuthError> { - let new_count = user_model.failed_login_count + 1; - let lock_at = if new_count >= SETTINGS.max_failed_logins { - Some(now + Duration::seconds(SETTINGS.locked_for_secs)) - } else { - None - }; + let (count, locked_until) = failed_login_outcome( + user_model.failed_login_count, + user_model.failed_login_at, + now, + FailedLoginPolicy { + max: SETTINGS.max_failed_logins, + window: Duration::seconds(SETTINGS.failed_login_window_secs), + locked_for: Duration::seconds(SETTINGS.locked_for_secs), + }, + ); user::ActiveModel { id: Set(user_model.id), - failed_login_count: Set(new_count), - locked_until: Set(lock_at), + failed_login_count: Set(count), + failed_login_at: Set(Some(now)), + locked_until: Set(locked_until), updated_at: Set(now), ..Default::default() } @@ -215,6 +218,34 @@ async fn register_failed_login( Ok(()) } +struct FailedLoginPolicy { + max: i32, + window: Duration, + locked_for: Duration, +} + +// Nuevo recuento tras un intento fallido en `now` y, si alcanza el máximo, hasta cuándo queda +// bloqueada la cuenta. Un fallo cuenta junto a los anteriores sólo si el último fue hace menos de +// la ventana; si no, el recuento empieza de nuevo. Al bloquear, el recuento vuelve a cero para +// que, pasado el bloqueo, se disponga otra vez de todos los intentos. Con un máximo de `0` nunca +// se bloquea. +fn failed_login_outcome( + count: i32, + last_failed: Option>, + now: DateTime, + policy: FailedLoginPolicy, +) -> (i32, Option>) { + let count = match last_failed { + Some(t) if now - t < policy.window => count.saturating_add(1), + _ => 1, + }; + if policy.max > 0 && count >= policy.max { + (0, Some(now + policy.locked_for)) + } else { + (count, None) + } +} + // **< seed_initial_data >************************************************************************** /// Prepara una instalación nueva si no existe ningún usuario en la base de datos. @@ -226,11 +257,27 @@ async fn register_failed_login( /// Concede además al rol "authenticated" los permisos que todo usuario espera tener sobre su /// propia cuenta: editar su perfil y cambiar su contraseña. Sólo en la instalación nueva; después /// los gestiona el administrador desde la interfaz. -pub(crate) async fn seed_initial_data() { - do_seed().await; +/// +/// Falla con [`AuthError::InvalidSetting`] si el nombre de usuario o el email configurados no son +/// válidos, aunque ya existan usuarios, como cualquier otro ajuste no válido. +pub(crate) async fn seed_initial_data() -> Result<(), AuthError> { + let cfg = &SETTINGS.seed; + let username = identity::username(&cfg.admin_username, SETTINGS.identity_policy, None) + .map_err(|err| invalid_setting("user.seed.admin_username", err))?; + let email = identity::email(&cfg.admin_email) + .map_err(|err| invalid_setting("user.seed.admin_email", err))?; + do_seed(username, email).await; + Ok(()) } -async fn do_seed() { +fn invalid_setting(key: &'static str, source: AuthError) -> AuthError { + AuthError::InvalidSetting { + key, + source: Box::new(source), + } +} + +async fn do_seed(username: Username, email: Email) { let count = user::Entity::find().count(dbconn()).await.unwrap_or(1); if count > 0 { return; @@ -261,10 +308,9 @@ async fn do_seed() { }; let now = Utc::now(); - let new_admin = user::ActiveModel { + let admin_username = username.value().to_owned(); + let mut new_admin = user::ActiveModel { id: ActiveValue::NotSet, - username: Set(cfg.admin_username.clone()), - email: Set(cfg.admin_email.clone()), email_verified_at: Set(Some(now)), password_hash: Set(hash), status: Set(UserStatus::Active.as_i16()), @@ -280,14 +326,17 @@ async fn do_seed() { is_admin: Set(true), created_at: Set(now), updated_at: Set(now), + ..Default::default() }; + username.set_on(&mut new_admin); + email.set_on(&mut new_admin); match user::Entity::insert(new_admin).exec(dbconn()).await { Ok(_) => { if generated { println!( "\npagetop-user: admin account created.\n username: {}\n password: {}\n", - cfg.admin_username, admin_password + admin_username, admin_password ); } } @@ -316,3 +365,50 @@ async fn do_seed() { ); } } + +#[cfg(test)] +mod tests { + use super::*; + + fn at(secs: i64) -> DateTime { + DateTime::from_timestamp(1_800_000_000 + secs, 0).unwrap() + } + + fn outcome(count: i32, last: Option, now: i64) -> (i32, Option>) { + let policy = FailedLoginPolicy { + max: 3, + window: Duration::seconds(900), + locked_for: Duration::seconds(600), + }; + failed_login_outcome(count, last.map(at), at(now), policy) + } + + #[pagetop::test] + async fn failures_within_the_window_accumulate() { + assert_eq!(outcome(0, None, 0), (1, None)); + assert_eq!(outcome(1, Some(0), 100), (2, None)); + } + + #[pagetop::test] + async fn reaching_the_maximum_locks_and_resets_the_count() { + assert_eq!(outcome(2, Some(0), 100), (0, Some(at(700)))); + } + + #[pagetop::test] + async fn zero_maximum_never_locks() { + let policy = FailedLoginPolicy { + max: 0, + window: Duration::seconds(900), + locked_for: Duration::seconds(600), + }; + assert_eq!( + failed_login_outcome(9, Some(at(0)), at(1), policy), + (10, None) + ); + } + + #[pagetop::test] + async fn a_failure_after_the_window_starts_a_new_count() { + assert_eq!(outcome(2, Some(0), 900), (1, None)); + } +} diff --git a/extensions/pagetop-user/src/component/admin/role_form.rs b/extensions/pagetop-user/src/component/admin/role_form.rs index f132f233..6393a7be 100644 --- a/extensions/pagetop-user/src/component/admin/role_form.rs +++ b/extensions/pagetop-user/src/component/admin/role_form.rs @@ -7,6 +7,7 @@ use crate::LOCALES_USER; use crate::role_path; use crate::component::error_banner; +use crate::service::role_admin::{ROLE_LABEL_MAX_CHARS, ROLE_MACHINE_NAME_MAX_CHARS}; #[derive(AutoDefault, Clone, Copy, Debug, PartialEq)] pub(crate) enum RoleFormMode { @@ -48,7 +49,7 @@ impl Component for RoleForm { .with_label(Lc::t("field-machine-name", &LOCALES_USER)) .with_help_text(Lc::t("help-machine-name-immutable", &LOCALES_USER)) .with_required(true) - .with_maxlength(Some(64)), + .with_maxlength(ROLE_MACHINE_NAME_MAX_CHARS), RoleFormMode::Edit => form::input::Field::text() .with_name("machine_name") .with_value(self.machine_name()) @@ -68,7 +69,7 @@ impl Component for RoleForm { .with_value(self.label()) .with_label(Lc::t("field-label", &LOCALES_USER)) .with_required(true) - .with_maxlength(Some(128)), + .with_maxlength(ROLE_LABEL_MAX_CHARS), ) .with_child( form::Textarea::new() diff --git a/extensions/pagetop-user/src/component/admin/role_table.rs b/extensions/pagetop-user/src/component/admin/role_table.rs index 79ae47f4..2041e036 100644 --- a/extensions/pagetop-user/src/component/admin/role_table.rs +++ b/extensions/pagetop-user/src/component/admin/role_table.rs @@ -6,6 +6,7 @@ use pagetop_htmx::hx_table::sort_link; use crate::ADMIN_ROLES_PATH; use crate::LOCALES_USER; +use crate::permission::UserPermission; use crate::role_path; use crate::service::role_admin::{RoleListItem, RoleSortField}; @@ -227,8 +228,8 @@ fn label_cell(role: &RoleListItem, waypoint: &Waypoint) -> Html { }) } -// Construye la celda de acciones: gestionar permisos siempre, y editar/borrar sólo si el rol no -// está bloqueado por el sistema. Devuelve un componente `Html` para que el marcado se genere cuando +// Construye la celda de acciones: gestionar permisos si se tiene `user:admin_permissions`, y +// editar/borrar sólo si el rol no está bloqueado por el sistema. Devuelve un componente `Html` para que el marcado se genere cuando // `Table` renderice la celda, no al construir la fila. async fn actions_cell( role: &RoleListItem, @@ -242,20 +243,29 @@ async fn actions_cell( let locked = role.locked; let waypoint = waypoint.clone(); - let permissions_href = waypoint.append_to(cx.route(role_path(id, "permissions"))); + let can_manage_permissions = cx + .request() + .is_some_and(|request| has_permission(request, &UserPermission::AdminPermissions)); // Los botones se renderizan aquí, no dentro del `Html::with()` de abajo: necesitan pasar por su // propio ciclo de renderizado (`.render().await`) para que el tema activo los estilice igual // (ver `pagetop-bootsier::theme::bs::button`), incluida la traducción de `data-dialog-*` que // usa el botón de borrado. - let permissions_button = Button::anchor( - Lc::t("btn-manage-permissions", &LOCALES_USER), - permissions_href, - ) - .with_style(button::Style::Solid(Intent::Neutral)) - .with_size(button::Size::Small) - .render(cx) - .await; + let permissions_button = if can_manage_permissions { + let permissions_href = waypoint.append_to(cx.route(role_path(id, "permissions"))); + Some( + Button::anchor( + Lc::t("btn-manage-permissions", &LOCALES_USER), + permissions_href, + ) + .with_style(button::Style::Solid(Intent::Neutral)) + .with_size(button::Size::Small) + .render(cx) + .await, + ) + } else { + None + }; let (edit_button, delete_button) = if locked { (None, None) @@ -290,15 +300,11 @@ async fn actions_cell( }; Html::with(move |_cx| { + let buttons = [&permissions_button, &edit_button, &delete_button]; html! { - (permissions_button) - @if let Some(edit_button) = &edit_button { - " " - (edit_button) - } - @if let Some(delete_button) = &delete_button { - " " - (delete_button) + @for (i, button) in buttons.into_iter().flatten().enumerate() { + @if i > 0 { " " } + (button) } } }) diff --git a/extensions/pagetop-user/src/component/admin/user_form.rs b/extensions/pagetop-user/src/component/admin/user_form.rs index 9795bb08..315ecc4a 100644 --- a/extensions/pagetop-user/src/component/admin/user_form.rs +++ b/extensions/pagetop-user/src/component/admin/user_form.rs @@ -3,12 +3,13 @@ use pagetop::prelude::*; use crate::LOCALES_USER; -use crate::config::{user_language_applies, user_timezone_applies}; +use crate::config::{SETTINGS, user_language_applies, user_timezone_applies}; use crate::user_path; use crate::{ADMIN_USERS_PATH, PROFILE_EDIT_PATH}; use crate::component::{PasswordConfirm, error_banner}; -use crate::service::user_admin::ABOUT_MAX_CHARS; +use crate::identity::{EMAIL_MAX_CHARS, USERNAME_MIN_CHARS, username_help, username_max_chars}; +use crate::service::user_admin::{ABOUT_MAX_CHARS, DISPLAY_NAME_MAX_CHARS}; use super::{USER_ADMIN_FORM_ID, roles_fieldset}; @@ -71,22 +72,30 @@ impl Component for UserForm { .with_name("username") .with_value(self.username()) .with_label(Lc::t("field-username-admin", &LOCALES_USER)) + .with_help_text(if username_readonly { + Lc::none() + } else { + username_help(SETTINGS.identity_policy) + }) .with_required(true) .with_readonly(username_readonly) - .with_maxlength(Some(64)), + .with_minlength(USERNAME_MIN_CHARS) + .with_maxlength(username_max_chars(SETTINGS.identity_policy)), ) .with_child( form::input::Field::email() .with_name("email") .with_value(self.email()) .with_label(Lc::t("field-email", &LOCALES_USER)) - .with_required(true), + .with_required(true) + .with_maxlength(EMAIL_MAX_CHARS), ) .with_child( form::input::Field::text() .with_name("display_name") .with_value(self.display_name()) - .with_label(Lc::t("field-display-name", &LOCALES_USER)), + .with_label(Lc::t("field-display-name", &LOCALES_USER)) + .with_maxlength(DISPLAY_NAME_MAX_CHARS), ); // Sólo se ofrecen si se aplican (ver `config::user_language_applies()` y diff --git a/extensions/pagetop-user/src/component/login_form.rs b/extensions/pagetop-user/src/component/login_form.rs index ab5c8381..20424b3c 100644 --- a/extensions/pagetop-user/src/component/login_form.rs +++ b/extensions/pagetop-user/src/component/login_form.rs @@ -9,6 +9,8 @@ use crate::{LOCALES_USER, LOGIN_PATH, PASSWORD_RESET_PATH, REGISTER_PATH}; #[derive(AutoDefault, Clone, Debug, Getters)] pub struct LoginForm { error: Option, + /// Usuario o email con el que se rellena el campo. + username: String, /// Página a la que volver tras iniciar sesión. waypoint: Waypoint, } @@ -32,6 +34,7 @@ impl Component for LoginForm { form::input::Field::text().with_autocomplete(Some(form::Autocomplete::username())) } .with_name(if strict { "ident" } else { "username" }) + .with_value(self.username()) .with_label(Lc::t("field-username", &LOCALES_USER)) .with_autofocus(true) .with_required(true); @@ -104,6 +107,12 @@ impl LoginForm { self } + /// Rellena el usuario o email, p. ej. con el enviado si el inicio de sesión falla. + pub fn with_username(mut self, username: impl Into) -> Self { + self.username = username.into(); + self + } + pub fn with_waypoint(mut self, waypoint: impl Into) -> Self { self.waypoint = waypoint.into(); self diff --git a/extensions/pagetop-user/src/component/password_confirm.rs b/extensions/pagetop-user/src/component/password_confirm.rs index 4009c624..b62fec04 100644 --- a/extensions/pagetop-user/src/component/password_confirm.rs +++ b/extensions/pagetop-user/src/component/password_confirm.rs @@ -4,11 +4,13 @@ use pagetop::prelude::*; use crate::LOCALES_USER; +use crate::config::SETTINGS; /// Campos de contraseña y confirmación, compuestos a partir de /// [`form::input::Field::password()`] del core. No valida en ningún momento que ambos valores /// coincidan (eso ocurre en el servidor, tras el envío del formulario), sólo renderiza los dos -/// campos, uno junto al otro, sin ningún contenedor propio. +/// campos, uno junto al otro, sin ningún contenedor propio. El de la contraseña indica la longitud +/// mínima configurada (`user.password.min_length`), como ayuda y con `minlength`. #[derive(AutoDefault, Clone, Debug, Getters)] pub(crate) struct PasswordConfirm { /// Devuelve la etiqueta del campo de contraseña. @@ -21,7 +23,7 @@ pub(crate) struct PasswordConfirm { impl Component for PasswordConfirm { // Las etiquetas por defecto cubren los dos casos más habituales (alta de cuenta, alta de // usuario desde administración); `with_password_label()` cubre los casos distintos - // (restablecimiento por un administrador y cambio de la contraseña propia). + // (restablecimientos y cambio de la contraseña propia). fn new() -> Self { Self { password_label: Lc::t("field-password", &LOCALES_USER), @@ -30,10 +32,19 @@ impl Component for PasswordConfirm { } async fn prepare(&self, cx: &mut Context) -> Result { + // `minlength` cuenta unidades UTF-16 y el servidor caracteres: con caracteres fuera del + // plano básico (emojis) el navegador puede aceptar una contraseña que el servidor rechaza, + // pero nunca al revés. + let min_length = SETTINGS.password.min_length; let mut password = form::input::Field::password() .with_name("password") .with_label(self.password_label().clone()) + .with_help_text( + Lc::t("help-password-min-length", &LOCALES_USER) + .with_number("n", u32::try_from(min_length).unwrap_or(u32::MAX)), + ) .with_autocomplete(Some(form::Autocomplete::new_password())) + .with_minlength(u16::try_from(min_length).unwrap_or(u16::MAX)) .with_required(true); let mut confirm = form::input::Field::password() .with_name("confirm_password") diff --git a/extensions/pagetop-user/src/component/password_reset_confirm_form.rs b/extensions/pagetop-user/src/component/password_reset_confirm_form.rs index 172af055..a0922c4e 100644 --- a/extensions/pagetop-user/src/component/password_reset_confirm_form.rs +++ b/extensions/pagetop-user/src/component/password_reset_confirm_form.rs @@ -3,7 +3,7 @@ use pagetop::prelude::*; use crate::LOCALES_USER; -use crate::component::error_banner; +use crate::component::{PasswordConfirm, error_banner}; #[derive(AutoDefault, Clone, Debug)] pub struct PasswordResetConfirmForm { @@ -24,19 +24,8 @@ impl Component for PasswordResetConfirmForm { .with_method(form::Method::Post) .with_child(error_banner(self.error.clone())) .with_child( - form::input::Field::password() - .with_name("password") - .with_label(Lc::t("field-new-password", &LOCALES_USER)) - .with_autocomplete(Some(form::Autocomplete::new_password())) - .with_autofocus(true) - .with_required(true), - ) - .with_child( - form::input::Field::password() - .with_name("confirm_password") - .with_label(Lc::t("field-confirm-password", &LOCALES_USER)) - .with_autocomplete(Some(form::Autocomplete::new_password())) - .with_required(true), + PasswordConfirm::new() + .with_password_label(Lc::t("field-new-password", &LOCALES_USER)), ) .with_child(Button::submit(Lc::t("btn-set-password", &LOCALES_USER))); diff --git a/extensions/pagetop-user/src/component/register_form.rs b/extensions/pagetop-user/src/component/register_form.rs index 5eec2871..3dd4ecde 100644 --- a/extensions/pagetop-user/src/component/register_form.rs +++ b/extensions/pagetop-user/src/component/register_form.rs @@ -5,10 +5,14 @@ use pagetop::prelude::*; use crate::LOCALES_USER; use crate::REGISTER_PATH; use crate::component::{PasswordConfirm, error_banner}; +use crate::config::SETTINGS; +use crate::identity::{EMAIL_MAX_CHARS, USERNAME_MIN_CHARS, username_help, username_max_chars}; #[derive(AutoDefault, Clone, Debug)] pub struct RegisterForm { error: Option, + username: String, + email: String, } #[async_trait] @@ -26,7 +30,11 @@ impl Component for RegisterForm { .with_child( form::input::Field::text() .with_name("username") - .with_label(Lc::t("field-username", &LOCALES_USER)) + .with_value(&self.username) + .with_label(Lc::t("field-username-admin", &LOCALES_USER)) + .with_help_text(username_help(SETTINGS.identity_policy)) + .with_minlength(USERNAME_MIN_CHARS) + .with_maxlength(username_max_chars(SETTINGS.identity_policy)) .with_autocomplete(Some(form::Autocomplete::username())) .with_autofocus(true) .with_required(true), @@ -34,7 +42,9 @@ impl Component for RegisterForm { .with_child( form::input::Field::email() .with_name("email") + .with_value(&self.email) .with_label(Lc::t("field-email", &LOCALES_USER)) + .with_maxlength(EMAIL_MAX_CHARS) .with_autocomplete(Some(form::Autocomplete::email())) .with_required(true), ) @@ -51,4 +61,16 @@ impl RegisterForm { self.error = error.into(); self } + + /// Rellena el nombre de usuario, p. ej. con el enviado si el registro falla. + pub fn with_username(mut self, username: impl Into) -> Self { + self.username = username.into(); + self + } + + /// Rellena el email, p. ej. con el enviado si el registro falla. + pub fn with_email(mut self, email: impl Into) -> Self { + self.email = email.into(); + self + } } diff --git a/extensions/pagetop-user/src/config.rs b/extensions/pagetop-user/src/config.rs index 62b9928f..e6233f3c 100644 --- a/extensions/pagetop-user/src/config.rs +++ b/extensions/pagetop-user/src/config.rs @@ -5,6 +5,7 @@ //! ```toml //! [user] //! allow_registration = false +//! identity_policy = "unicode" //! //! [user.session] //! secure_cookie = true @@ -23,12 +24,15 @@ //! //! Todas las opciones, con su valor por defecto, se documentan en [`UserSettings`] y sus //! subsecciones ([`SessionSettings`], [`PasswordSettings`], [`SeedSettings`] y [`AdminSettings`]). +//! Las reglas de los nombres de usuario y del email se explican en [`IdentityPolicy`]. //! //! Consulta [`pagetop::config`] para ver cómo PageTop lee los archivos de configuración y aplica //! los valores a los ajustes. use pagetop::prelude::*; +use serde::Deserialize; + /// Ajustes de la sección `[user]`, cargados al arrancar la aplicación. pub static SETTINGS: LazySettings = LazySettings::new(); @@ -38,18 +42,28 @@ pub struct UserSettings { /// Permite que los visitantes creen su propia cuenta. #[default = true] pub allow_registration: bool, - /// Las cuentas nuevas quedan pendientes (*"Pending"*) en lugar de activas hasta verificar el - /// correo. + /// Las cuentas nuevas quedan pendientes (*"Pending"*) en lugar de activas hasta que su titular + /// confirma su dirección desde el enlace del correo de verificación que se le envía al + /// registrarse. #[default = false] pub require_email_verification: bool, + /// Qué nombres de usuario se aceptan. Ver [`IdentityPolicy`]. + pub identity_policy: IdentityPolicy, - /// Intentos fallidos de acceso antes de bloquear la cuenta. + /// Intentos fallidos de acceso seguidos que bloquean temporalmente la cuenta. + /// + /// 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 + /// recuento empieza de nuevo. Un acceso correcto o una recuperación de contraseña lo ponen a + /// cero, y al bloquear también vuelve a cero, así que pasado el bloqueo se dispone otra vez de + /// todos los intentos. Con `0` no se bloquea nunca. #[default = 5] pub max_failed_logins: i32, - /// Ventana de recuento de intentos fallidos, en segundos. Reservada: todavía no tiene efecto. + /// Segundos desde el último intento fallido en los que el siguiente se suma al recuento. #[default = 900] pub failed_login_window_secs: i64, - /// Duración del bloqueo de la cuenta, en segundos. + /// Duración del bloqueo de la cuenta, en segundos. Durante el bloqueo se rechaza el acceso + /// aunque la contraseña sea correcta. #[default = 600] pub locked_for_secs: i64, @@ -71,6 +85,105 @@ pub struct UserSettings { pub login_strict: bool, } +/// Política de identidad: qué nombres de usuario se aceptan al crear una cuenta o al cambiar su +/// nombre. Usado en [`UserSettings::identity_policy`]. +/// +/// Cada nivel admite todo lo del anterior y algo más: +/// +/// | Valor | Caracteres | Longitud | Como en | +/// |---|---|---|---| +/// | `"strict"` (defecto) | Letras ASCII sin tildes, dígitos, `.`, `_`, `-` | 3 a 32 | Kanidm | +/// | `"unicode"` | Letras y dígitos de cualquier alfabeto, `.`, `_`, `-` | 3 a 32 | RFC 8265 | +/// | `"permissive"` | Los de `"unicode"`, espacios simples, `'` y `+` | 3 a 60 | Drupal | +/// +/// # Reglas comunes +/// +/// Con cualquier política: +/// +/// - Se ignoran los espacios al principio y al final, y el texto se normaliza (Unicode NFKC): las +/// formas equivalentes de un mismo carácter, como `é` compuesta o con la tilde aparte, o las +/// letras de ancho completo (`Ana`), cuentan como la misma, y el nombre se guarda ya +/// normalizado (`Ana`). +/// - El nombre empieza por una letra o un dígito. +/// - **Nunca se admite `@`.** El email es un dato aparte y obligatorio, y también sirve para +/// iniciar sesión: sin `@`, un nombre de usuario nunca se confunde con el email de otra cuenta. +/// - El nombre se guarda con sus mayúsculas, pero **no se distinguen**: `Ana` y `ana` son el mismo +/// usuario al iniciar sesión, y no pueden existir los dos. +/// - **No se admiten nombres que se confunden a simple vista con otro existente**, según la tabla +/// de caracteres confusables de Unicode (UTS #39): si existe `maria`, no se puede crear +/// `rnaria`; si existe `admin`, tampoco `аdmin` con una `а` cirílica. +/// +/// Con `"unicode"` y `"permissive"`, además, un nombre no puede mezclar alfabetos (`pаypal`, con +/// una `а` cirílica entre letras latinas), salvo las combinaciones habituales de una misma +/// escritura (como kanji y kana en japonés), ni usar caracteres que Unicode desaconseja en +/// identificadores (invisibles, obsoletos o de control). En `"permissive"` tampoco se admiten +/// dos espacios seguidos. +/// +/// El email se valida igual con cualquier política: el formato que exige `pagetop-mail` para poder +/// enviarle correos, hasta 254 caracteres, y sin distinguir mayúsculas. +/// +/// # Elegir una política +/// +/// El riesgo no depende tanto de dónde se publica la aplicación como de **quién elige los +/// nombres**. Con el registro abierto (`allow_registration`), cualquiera escoge un nombre que verán +/// otros usuarios y que aparece en el saludo de sus correos en cuanto verifica su dirección. Si las +/// cuentas sólo las crean administradores, ese riesgo casi desaparece. +/// +/// | Situación | Política | +/// |---|---| +/// | Aplicación en Internet con registro abierto | `"strict"` | +/// | Comunidad en Internet cuyos usuarios escriben su nombre en su alfabeto | `"unicode"` | +/// | Aplicación interna con cuentas creadas por administradores | `"strict"` o `"unicode"` | +/// | Importar cuentas de un sistema con espacios en los nombres (Drupal...) | `"permissive"` | +/// +/// `"strict"` es la más segura y basta en la mayoría de las aplicaciones: los nombres con tildes o +/// en otros alfabetos tienen su sitio en el nombre visible del usuario (`display_name`). +/// `"unicode"` permite que el nombre de usuario se escriba en el idioma de cada persona, con la +/// misma protección contra nombres que se confunden. `"permissive"` no es aconsejable con el +/// registro abierto: los espacios permiten escribir frases («Soporte técnico», «Llama al 900...») +/// que luego aparecen donde se muestra el nombre, también en el saludo de los correos. +/// +/// # Cambiar de política +/// +/// La política sólo decide qué nombres **nuevos** se aceptan: buscar y comparar usuarios funciona +/// igual con cualquiera, así que nadie pierde el acceso al cambiarla. +/// +/// - **A una más abierta** (de `"strict"` a `"unicode"`, por ejemplo), las cuentas existentes no +/// cambian. Los nombres nuevos pueden usar más caracteres, y siguen sin poder confundirse con +/// ninguno de los existentes. +/// - **A una más estricta**, los nombres que ya no la cumplen (o que superan la nueva longitud +/// máxima) se conservan: sus titulares pueden iniciar sesión y guardar su perfil, incluso +/// cambiando sólo las mayúsculas de su nombre. Pero si alguien lo cambia, el propio usuario o un +/// administrador, el nuevo nombre debe cumplir la política. No hay renombrado automático: para +/// ajustar los nombres existentes, un administrador los cambia a mano. +/// - **El administrador inicial** ([`SeedSettings::admin_username`]) se comprueba en cada +/// arranque, aunque ya exista. Si deja de cumplir la política, la aplicación no arranca hasta +/// que se configure un nombre válido. Cambiar ese ajuste no renombra al administrador existente: +/// sólo se usa para crearlo cuando la base de datos está vacía. Con el valor por defecto, +/// `"admin"`, no ocurre con ninguna política. +/// +/// # Referencias +/// +/// - [UAX #15](https://www.unicode.org/reports/tr15/): formas de normalización (NFKC). +/// - [UAX #31](https://www.unicode.org/reports/tr31/): qué caracteres forman un identificador. +/// - [UTS #39](https://www.unicode.org/reports/tr39/): caracteres confusables, mezcla de alfabetos +/// y caracteres desaconsejados en identificadores. +/// - [RFC 8265](https://www.rfc-editor.org/rfc/rfc8265): nombres de usuario internacionales +/// (PRECIS), el modelo de `"unicode"`. +#[derive(AutoDefault, Clone, Copy, Debug, Deserialize, Eq, PartialEq)] +#[serde(rename_all = "lowercase")] +pub enum IdentityPolicy { + /// Letras ASCII sin tildes, dígitos, `.`, `_` y `-`, de 3 a 32 caracteres. + #[default] + Strict, + /// Letras y dígitos de cualquier alfabeto, `.`, `_` y `-`, de 3 a 32 caracteres, sin mezclar + /// alfabetos. + Unicode, + /// Lo mismo que [`Unicode`](Self::Unicode), más espacios simples, `'` y `+`, de 3 a 60 + /// caracteres. + Permissive, +} + /// Subsección **`[user.session]`** de la configuración. #[settings] pub struct SessionSettings { @@ -112,11 +225,11 @@ pub struct SessionSettings { /// Subsección **`[user.password]`** de la configuración. /// -/// Las contraseñas se cifran con Argon2id. +/// Las contraseñas se cifran con Argon2id. Si cambia cualquiera de sus tres costes, cada contraseña +/// se vuelve a cifrar con los nuevos en el siguiente acceso de su usuario. #[settings] pub struct PasswordSettings { - /// Coste de memoria de Argon2id, en KiB. Si cambia, las contraseñas se vuelven a cifrar en el - /// siguiente acceso de cada usuario. + /// Coste de memoria de Argon2id, en KiB. #[default = 19_456] pub argon2_m_cost: u32, /// Coste de tiempo de Argon2id (número de iteraciones). @@ -125,7 +238,7 @@ pub struct PasswordSettings { /// Grado de paralelismo de Argon2id (número de hilos). #[default = 1] pub argon2_p_cost: u32, - /// Longitud mínima de las contraseñas. + /// Longitud mínima de las contraseñas, en caracteres. #[default = 8] pub min_length: usize, } @@ -135,10 +248,12 @@ pub struct PasswordSettings { /// El primer administrador, que se crea si no existe ningún usuario. #[settings] pub struct SeedSettings { - /// Nombre de usuario del primer administrador. + /// Nombre de usuario del primer administrador. Debe cumplir la política de identidad + /// configurada ([`IdentityPolicy`]); si no, la aplicación no arranca. #[default = "admin"] pub admin_username: String, - /// Correo electrónico del primer administrador. + /// Correo electrónico del primer administrador. Si no es una dirección válida, la aplicación no + /// arranca. #[default = "admin@example.com"] pub admin_email: String, /// Contraseña del primer administrador. Sin valor, se genera una aleatoria y se muestra una diff --git a/extensions/pagetop-user/src/demo.rs b/extensions/pagetop-user/src/demo.rs index acd8f33b..a57f1285 100644 --- a/extensions/pagetop-user/src/demo.rs +++ b/extensions/pagetop-user/src/demo.rs @@ -8,8 +8,10 @@ use pagetop::prelude::*; use pagetop_seaorm::db::{ActiveValue, ColumnTrait, EntityTrait, QueryFilter, Set, dbconn}; use crate::account::UserStatus; +use crate::config::SETTINGS; use crate::entity::{role, user, user_role}; use crate::error::AuthError; +use crate::identity; use crate::password; const ROLE_COUNT: usize = 25; @@ -80,10 +82,11 @@ async fn create_demo_users(role_ids: &[i32]) -> Result<(), AuthError> { let now = Utc::now(); for n in 1..=USER_COUNT { - let new_user = user::ActiveModel { + let username = + identity::username(&format!("demo_user_{n:02}"), SETTINGS.identity_policy, None)?; + let email = identity::email(&format!("demo_user_{n:02}@example.com"))?; + let mut new_user = user::ActiveModel { id: ActiveValue::NotSet, - username: Set(format!("demo_user_{n:02}")), - email: Set(format!("demo_user_{n:02}@example.com")), email_verified_at: Set(Some(now)), password_hash: Set(hash.clone()), status: Set(UserStatus::Active.as_i16()), @@ -99,7 +102,10 @@ async fn create_demo_users(role_ids: &[i32]) -> Result<(), AuthError> { is_admin: Set(false), created_at: Set(now), updated_at: Set(now), + ..Default::default() }; + username.set_on(&mut new_user); + email.set_on(&mut new_user); let result = user::Entity::insert(new_user).exec(dbconn()).await?; let user_id = result.last_insert_id; diff --git a/extensions/pagetop-user/src/entity/user.rs b/extensions/pagetop-user/src/entity/user.rs index 6b124a52..3d0d29d4 100644 --- a/extensions/pagetop-user/src/entity/user.rs +++ b/extensions/pagetop-user/src/entity/user.rs @@ -5,10 +5,20 @@ use pagetop_seaorm::db::*; pub struct Model { #[sea_orm(primary_key)] pub id: i32, - #[sea_orm(unique)] + /// Nombre de usuario con sus mayúsculas, normalizado (NFKC) y sin espacios en los extremos. pub username: String, - #[sea_orm(unique)] + /// Email con sus mayúsculas, sin espacios en los extremos. pub email: String, + /// Nombre de usuario para buscar sin distinguir mayúsculas (ver `identity.rs`). + #[sea_orm(unique)] + pub username_key: String, + /// *Hash* SHA-256 del esqueleto de confusión del nombre de usuario, único para que no haya dos + /// que se confundan. + #[sea_orm(unique)] + pub username_skeleton: String, + /// Email para buscar sin distinguir mayúsculas. + #[sea_orm(unique)] + pub email_key: String, pub email_verified_at: Option, pub password_hash: String, pub status: i16, @@ -20,8 +30,13 @@ pub struct Model { /// Texto libre "Sobre mí" que el propio usuario escribe en su perfil. pub about: Option, pub last_login_at: Option, + /// Último acceso: al iniciar sesión y al prorrogar la sesión, con la precisión de + /// `user.session.write_interval_secs`. pub last_access_at: Option, + /// Intentos fallidos seguidos dentro de la ventana de recuento (`failed_login_window_secs`). pub failed_login_count: i32, + /// Último intento fallido, para saber si el siguiente cae dentro de la misma ventana. + pub failed_login_at: Option, pub locked_until: Option, /// Acceso irrestricto al sistema, sin pasar por roles ni permisos. pub is_admin: bool, diff --git a/extensions/pagetop-user/src/error.rs b/extensions/pagetop-user/src/error.rs index 3d898124..f8b80264 100644 --- a/extensions/pagetop-user/src/error.rs +++ b/extensions/pagetop-user/src/error.rs @@ -28,6 +28,19 @@ pub enum AuthError { #[error("username is already taken")] UsernameTaken, + #[error("username does not meet the identity policy (user.identity_policy)")] + InvalidUsername, + + #[error("invalid email address")] + InvalidEmail, + + #[error("invalid setting \"{key}\"")] + InvalidSetting { + key: &'static str, + #[source] + source: Box, + }, + #[error("email is already registered")] EmailTaken, @@ -49,6 +62,9 @@ pub enum AuthError { #[error("about text must be at most {0} characters")] AboutTooLong(usize), + #[error("display name must be at most {0} characters")] + DisplayNameTooLong(usize), + #[error("user not found")] UserNotFound, @@ -58,9 +74,14 @@ pub enum AuthError { #[error("role machine name is already taken")] RoleMachineNameTaken, - #[error("role machine name must contain only lowercase letters, digits and underscores")] + #[error( + "role machine name must contain only lowercase letters, digits and underscores, up to 64" + )] InvalidMachineName, + #[error("role label must not be blank and must be at most {0} characters")] + InvalidRoleLabel(usize), + #[error("role is locked and cannot be modified or deleted")] RoleLocked, diff --git a/extensions/pagetop-user/src/handlers/account.rs b/extensions/pagetop-user/src/handlers/account.rs index 90a18848..aa9628a5 100644 --- a/extensions/pagetop-user/src/handlers/account.rs +++ b/extensions/pagetop-user/src/handlers/account.rs @@ -26,10 +26,12 @@ fn current_user_id(request: &HttpRequest) -> Option { request.extension::().map(|a| a.id()) } -// Redirección al formulario de inicio de sesión conservando `next` como URL de retorno. +// Redirección al formulario de inicio de sesión con `next` como `waypoint`: la ruta a la que +// volver tras iniciar sesión. fn login_redirect(request: HttpRequest, next: &'static str) -> Response { let cx = Context::new(request); - Redirect::see_other(cx.route(LOGIN_PATH).with_param("next", next)).into_response() + let waypoint = Waypoint::new(cx.route(next).to_string()); + Redirect::see_other(waypoint.append_to(cx.route(LOGIN_PATH))).into_response() } // **< profile_get >******************************************************************************** @@ -277,6 +279,7 @@ pub(crate) async fn profile_edit_post( language: util::non_blank(&form.language), timezone: util::non_blank(&form.timezone), theme: util::non_blank(&form.theme), + email_verified: false, }, ) .await; diff --git a/extensions/pagetop-user/src/handlers/admin.rs b/extensions/pagetop-user/src/handlers/admin.rs index cbcf9849..23bf652b 100644 --- a/extensions/pagetop-user/src/handlers/admin.rs +++ b/extensions/pagetop-user/src/handlers/admin.rs @@ -1,8 +1,8 @@ //! Handlers HTTP para el mantenimiento de usuarios, roles y permisos. //! -//! Accesibles sólo por URL directa (sin entradas de menú). Cada handler comprueba el permiso -//! correspondiente con [`require_permission()`](pagetop::auth::require_permission) antes de -//! construir la página. +//! Las páginas de usuarios, roles y permisos se registran en el portal de `pagetop-admin` (ver +//! `declare_admin_pages()`). Cada handler comprueba el permiso correspondiente con +//! [`require_permission()`](pagetop::auth::require_permission) antes de construir la página. pub(crate) mod permissions; pub(crate) mod roles; @@ -13,6 +13,7 @@ use pagetop_admin::component::AdminFrame; use crate::LOCALES_USER; use crate::error::AuthError; +use crate::service::role_admin::ROLE_MACHINE_NAME_MAX_CHARS; // Envuelve el contenido de una página de administración en el frame de `pagetop-admin`: // breadcrumb, tareas y acciones locales registradas para la ruta actual en su `AdminRegistry`. @@ -34,12 +35,21 @@ pub(crate) fn map_auth_error(err: &AuthError) -> Lc { AuthError::AboutTooLong(n) => { Lc::t("error-about-too-long", &LOCALES_USER).with_arg("n", n.to_string()) } + AuthError::DisplayNameTooLong(n) => { + Lc::t("error-display-name-too-long", &LOCALES_USER).with_arg("n", n.to_string()) + } AuthError::UsernameTaken => Lc::t("error-username-taken", &LOCALES_USER), + 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::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), - AuthError::InvalidMachineName => Lc::t("error-invalid-machine-name", &LOCALES_USER), + AuthError::InvalidMachineName => Lc::t("error-invalid-machine-name", &LOCALES_USER) + .with_number("n", u32::from(ROLE_MACHINE_NAME_MAX_CHARS)), + AuthError::InvalidRoleLabel(n) => { + Lc::t("error-invalid-role-label", &LOCALES_USER).with_arg("n", n.to_string()) + } AuthError::RoleLocked => Lc::t("error-role-locked", &LOCALES_USER), AuthError::RoleInUse => Lc::t("error-role-in-use", &LOCALES_USER), AuthError::LastAdministrator => Lc::t("error-last-administrator", &LOCALES_USER), diff --git a/extensions/pagetop-user/src/handlers/admin/roles.rs b/extensions/pagetop-user/src/handlers/admin/roles.rs index ecc6a648..e8dcc2cc 100644 --- a/extensions/pagetop-user/src/handlers/admin/roles.rs +++ b/extensions/pagetop-user/src/handlers/admin/roles.rs @@ -412,7 +412,7 @@ pub(crate) async fn delete_post( .with_per_page(page_result.per_page) .with_total(page_result.total) .with_message(message); - let mut cx = Context::new(request); + let mut cx = Context::admin(request); Ok(HtmxResponse::new(table.render(&mut cx).await).into_response()) } else { let cx = Context::new(request); diff --git a/extensions/pagetop-user/src/handlers/admin/users.rs b/extensions/pagetop-user/src/handlers/admin/users.rs index eb7a3805..7150ef4f 100644 --- a/extensions/pagetop-user/src/handlers/admin/users.rs +++ b/extensions/pagetop-user/src/handlers/admin/users.rs @@ -327,6 +327,8 @@ async fn render_edit_page( let can_toggle_admin = request .extension::() .is_some_and(|a| a.is_admin() && a.id() != id); + // Bloquear y activar exige además `user:block_accounts` (ver `status_post`). + let can_change_status = has_permission(&request, &UserPermission::BlockAccounts); let mut page = Page::admin(request); let back_href = waypoint.or(page.context().route(ADMIN_USERS_PATH)); let title = Lc::t("title-admin-user-edit", &LOCALES_USER); @@ -335,6 +337,7 @@ async fn render_edit_page( status, is_admin, can_toggle_admin, + can_change_status, &waypoint, page.context(), ); @@ -355,8 +358,9 @@ async fn render_edit_page( .into_response() } -// Enlace a la pantalla de restablecer contraseña y botones de bloqueo/activación y de -// concesión/revocación de acceso irrestricto (este último sólo si `can_toggle_admin`). El listado +// Enlace a la pantalla de restablecer contraseña y botones de bloqueo/activación (sólo si +// `can_change_status`) y de concesión/revocación de acceso irrestricto (sólo si +// `can_toggle_admin`). El listado // de origen (`waypoint`) se arrastra a todas ellas para que, al volver aquí, esta misma pantalla // siga sabiendo devolver al listado en el estado en que se dejó. // @@ -372,12 +376,15 @@ fn edit_actions( status: UserStatus, target_is_admin: bool, can_toggle_admin: bool, + can_change_status: bool, waypoint: &Waypoint, cx: &mut Context, ) -> Flex { + // Una cuenta pendiente de verificar su email también se puede activar directamente, p. ej. si + // el correo de verificación no llegó. let (next_status, label_key) = match status { - UserStatus::Blocked => ("active", "btn-activate"), - _ => ("blocked", "btn-block"), + UserStatus::Active => ("blocked", "btn-block"), + UserStatus::Blocked | UserStatus::Pending => ("active", "btn-activate"), }; let (next_is_admin, admin_label_key, admin_confirm_key) = if target_is_admin { ("false", "btn-revoke-admin", "confirm-revoke-admin") @@ -414,8 +421,10 @@ fn edit_actions( .with_child( Button::anchor(Lc::t("btn-reset-password", &LOCALES_USER), password_href) .with_style(button::Style::Solid(Intent::Neutral)), - ) - .with_child(status_form); + ); + if can_change_status { + container = container.with_child(status_form); + } if can_toggle_admin { let admin_button = Button::submit(Lc::t(admin_label_key, &LOCALES_USER)) @@ -490,6 +499,7 @@ 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; diff --git a/extensions/pagetop-user/src/handlers/auth.rs b/extensions/pagetop-user/src/handlers/auth.rs index 1cfac9cf..1e3b42bd 100644 --- a/extensions/pagetop-user/src/handlers/auth.rs +++ b/extensions/pagetop-user/src/handlers/auth.rs @@ -10,9 +10,10 @@ use crate::component::{LoginForm, PasswordResetConfirmForm, PasswordResetForm, R use crate::config::SETTINGS; use crate::error::AuthError; use crate::handlers::admin::map_auth_error; +use crate::mail::send_token_mail; use crate::password; use crate::session; -use crate::token::{TokenKind, consume_token, create_token}; +use crate::token::{TokenKind, consume_token, create_token, is_valid_token}; use crate::{LOCALES_USER, LOGIN_PATH, PROFILE_PATH}; // **< Tipos de formularios >*********************************************************************** @@ -101,6 +102,7 @@ pub async fn login_post( .with_title(Lc::t("title-login", &LOCALES_USER)) .with_child( LoginForm::new() + .with_username(form.username) .with_error(Lc::t(error_key, &LOCALES_USER)) .with_waypoint(waypoint), ) @@ -172,24 +174,29 @@ pub async fn register_post( ) .await; match result { - Ok(_user_id) => Redirect::see_other(cx.route(LOGIN_PATH)), - Err(err) => { - let error_lc = match &err { - AuthError::PasswordTooShort(n) => { - Lc::t("error-password-too-short", &LOCALES_USER).with_arg("n", n.to_string()) - } - AuthError::PasswordMismatch => Lc::t("error-password-mismatch", &LOCALES_USER), - AuthError::UsernameTaken => Lc::t("error-username-taken", &LOCALES_USER), - AuthError::EmailTaken => Lc::t("error-email-taken", &LOCALES_USER), - _ => Lc::t("error-internal", &LOCALES_USER), - }; + 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(RegisterForm::new().with_error(error_lc)) + .with_child(Html::with(|cx| { + html! { p { (Lc::t("msg-verification-sent", &LOCALES_USER).using(cx)) } } + })) .render() .await .into_response() } + Ok(_) => Redirect::see_other(cx.route(LOGIN_PATH)), + Err(err) => Page::new(request) + .with_title(Lc::t("title-register", &LOCALES_USER)) + .with_child( + RegisterForm::new() + .with_username(form.username) + .with_email(form.email) + .with_error(map_auth_error(&err)), + ) + .render() + .await + .into_response(), } } @@ -211,21 +218,36 @@ pub async fn password_reset_post( request: HttpRequest, web::Form(form): web::Form, ) -> Result { - // Respondemos igual exista o no el email para no revelar qué emails están registrados. - { + // 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. + let mail_request = request.clone(); + tokio::spawn(async move { + use crate::account::UserStatus; use crate::entity::user; + use crate::identity::email_key; use pagetop_seaorm::db::{ColumnTrait, EntityTrait, QueryFilter, dbconn}; - if let Ok(Some(user_model)) = user::Entity::find() - .filter(user::Column::Email.eq(&form.email)) + let found = user::Entity::find() + .filter(user::Column::EmailKey.eq(email_key(&form.email))) + .filter(user::Column::Status.eq(UserStatus::Active.as_i16())) .one(dbconn()) - .await - { - create_token(user_model.id, TokenKind::PasswordReset) - .await - .ok(); - // TODO: enviar email con el token al usuario. + .await; + let user_model = match found { + Ok(Some(user_model)) => user_model, + Ok(None) => return, + Err(err) => { + trace::error!("Cannot look up account for password reset: {err}"); + return; + } + }; + match create_token(user_model.id, TokenKind::PasswordReset).await { + Ok(token) => { + send_token_mail(&mail_request, TokenKind::PasswordReset, &user_model, &token); + } + 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| { @@ -242,23 +264,10 @@ pub async fn password_reset_confirm_get( request: HttpRequest, web::Path((uid, token)): web::Path<(i32, String)>, ) -> Result { - let valid = { - use crate::entity::user_token; - use crate::token::hash_token; - use pagetop_seaorm::db::{ColumnTrait, EntityTrait, QueryFilter, dbconn}; - let hash = hash_token(&token); - let now = Utc::now(); - user_token::Entity::find() - .filter(user_token::Column::TokenHash.eq(&hash)) - .filter(user_token::Column::UserId.eq(uid)) - .filter(user_token::Column::ConsumedAt.is_null()) - .one(dbconn()) - .await - .ok() - .flatten() - .is_some_and(|r| r.expires_at > now) - }; - if !valid { + if !is_valid_token(uid, &token, TokenKind::PasswordReset) + .await + .unwrap_or(false) + { return Err(ErrorPage::NotFound(Some(request))); } Page::new(request) @@ -271,36 +280,36 @@ pub async fn password_reset_confirm_get( // **< password_reset_confirm_post >**************************************************************** /// 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 +/// bloqueo temporal por intentos fallidos, porque quien abre el enlace ha demostrado ser el titular +/// de la dirección. pub async fn password_reset_confirm_post( request: HttpRequest, - web::Path((_uid, token)): web::Path<(i32, String)>, + web::Path((uid, token)): web::Path<(i32, String)>, web::Form(form): web::Form, ) -> Response { let cx = Context::new(request.clone()); - if let Err(err) = password::passwords_match(&form.password, &form.confirm_password) { - return Page::new(request) - .with_title(Lc::t("title-new-password", &LOCALES_USER)) - .with_child(PasswordResetConfirmForm::new().with_error(map_auth_error(&err))) - .render() - .await - .into_response(); - } let result = async { use crate::entity::user; use pagetop_seaorm::db::{ActiveModelTrait, Set, dbconn}; - let user_id = consume_token(&token, TokenKind::PasswordReset).await?; + password::passwords_match(&form.password, &form.confirm_password)?; password::validate_strength(&form.password)?; - let hash = password::hash_password(&form.password)?; - let now = Utc::now(); + let hash = password::hash_password_async(&form.password).await?; + consume_token(uid, &token, TokenKind::PasswordReset).await?; user::ActiveModel { - id: Set(user_id), + id: Set(uid), password_hash: Set(hash), - updated_at: Set(now), + failed_login_count: Set(0), + failed_login_at: Set(None), + locked_until: Set(None), + updated_at: Set(Utc::now()), ..Default::default() } .update(dbconn()) .await?; - session::destroy_user_sessions(user_id) + session::destroy_user_sessions(uid) .await .map_err(AuthError::Database)?; Ok::<(), AuthError>(()) @@ -308,41 +317,87 @@ pub async fn password_reset_confirm_post( .await; match result { Ok(()) => Redirect::see_other(cx.route(LOGIN_PATH)), - Err(_) => Page::new(request) - .with_title(Lc::t("title-new-password", &LOCALES_USER)) - .with_child( - PasswordResetConfirmForm::new() - .with_error(Lc::t("error-token-invalid", &LOCALES_USER)), - ) - .render() - .await - .into_response(), + Err(err) => { + let error = match err { + 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() + } } } -// **< verify_email_get >*************************************************************************** +// **< verify_email_get / verify_email_post >******************************************************* -/// GET /user/verify/{uid}/{token} - Confirma la dirección de email. +/// GET /user/verify/{uid}/{token} - Pide confirmar la dirección de email con un botón. +/// +/// Abrir el enlace no verifica nada: los servidores de correo y los antivirus abren por su cuenta +/// los enlaces de los correos para analizarlos, y así quedaría verificada una cuenta creada con la +/// dirección de otra persona sin que ésta haya hecho nada. Sólo el envío del formulario +/// ([`verify_email_post()`]) consume el token. pub async fn verify_email_get( request: HttpRequest, - web::Path((_uid, token)): web::Path<(i32, String)>, + web::Path((uid, token)): web::Path<(i32, String)>, +) -> 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 +} + +/// POST /user/verify/{uid}/{token} - Confirma la dirección de email. +/// +/// Activa la cuenta si estaba pendiente de esta verificación; una cuenta bloqueada sigue bloqueada. +pub async fn verify_email_post( + request: HttpRequest, + web::Path((uid, token)): web::Path<(i32, String)>, ) -> Response { let cx = Context::new(request.clone()); let result = async { use crate::account::UserStatus; use crate::entity::user; - use pagetop_seaorm::db::{ActiveModelTrait, Set, dbconn}; - let user_id = consume_token(&token, TokenKind::EmailVerification).await?; + use pagetop_seaorm::db::query::Expr; + use pagetop_seaorm::db::{ColumnTrait, EntityTrait, QueryFilter, dbconn}; + consume_token(uid, &token, TokenKind::EmailVerification).await?; let now = Utc::now(); - user::ActiveModel { - id: Set(user_id), - email_verified_at: Set(Some(now)), - status: Set(UserStatus::Active.as_i16()), - updated_at: Set(now), - ..Default::default() - } - .update(dbconn()) - .await?; + user::Entity::update_many() + .col_expr(user::Column::EmailVerifiedAt, Expr::value(now)) + .col_expr(user::Column::UpdatedAt, Expr::value(now)) + .filter(user::Column::Id.eq(uid)) + .exec(dbconn()) + .await?; + user::Entity::update_many() + .col_expr( + user::Column::Status, + Expr::value(UserStatus::Active.as_i16()), + ) + .filter(user::Column::Id.eq(uid)) + .filter(user::Column::Status.eq(UserStatus::Pending.as_i16())) + .exec(dbconn()) + .await?; Ok::<(), AuthError>(()) } .await; @@ -354,6 +409,30 @@ pub async fn verify_email_get( // **< HELPERS >************************************************************************************ +// Envía el correo para verificar la dirección de la cuenta recién creada. Un fallo no impide el +// registro: la cuenta queda pendiente y un administrador puede activarla. +// +// La dirección todavía no está verificada: cualquiera puede registrarse con la de otra persona y +// hacer que le llegue este correo, que sale del dominio de la aplicación y con su diseño, así que +// pasa los filtros y resulta creíble. Por eso no incluye nada que elija quien se registra, ni +// siquiera el nombre de usuario: bastaría para colar un texto o un enlace engañoso (*phishing*). +async fn send_verification_mail(request: &HttpRequest, user_id: i32) { + use crate::entity::user; + use pagetop_seaorm::db::{EntityTrait, dbconn}; + let user = match user::Entity::find_by_id(user_id).one(dbconn()).await { + Ok(Some(user)) => user, + Ok(None) => return, + Err(err) => { + trace::error!("Cannot load new user {user_id} to send verification email: {err}"); + return; + } + }; + match create_token(user_id, TokenKind::EmailVerification).await { + Ok(token) => send_token_mail(request, TokenKind::EmailVerification, &user, &token), + Err(err) => trace::error!("Cannot create email verification token: {err}"), + } +} + fn redirect_with_cookie(to: impl Into, cookie: &str) -> Response { ( web::http::StatusCode::SEE_OTHER, diff --git a/extensions/pagetop-user/src/identity.rs b/extensions/pagetop-user/src/identity.rs new file mode 100644 index 00000000..33fe37b4 --- /dev/null +++ b/extensions/pagetop-user/src/identity.rs @@ -0,0 +1,353 @@ +//! Nombre de usuario y email que identifican una cuenta: normalización y validación. +//! +//! Las reglas públicas se documentan en `IdentityPolicy`. Aquí se separan dos cosas: +//! +//! - **Buscar y comparar**, igual con cualquier política: `*_key` (sin espacios en los extremos, +//! NFKC en el nombre de usuario y en minúsculas) y el esqueleto de confusión del nombre +//! (UTS #39), guardados en columnas propias con índice único. Así se puede cambiar de política +//! sin que dejen de encontrarse las cuentas existentes. +//! +//! Del esqueleto se guarda su *hash* SHA-256: sólo se compara por igualdad, y puede ser mucho +//! más largo que el nombre (cada sílaba coreana se descompone en hasta siete caracteres), así +//! que no cabría en una columna de longitud fija con índice único. +//! - **Aceptar un nombre nuevo**, lo único que depende de la política. + +use pagetop::prelude::*; +use pagetop_mail::Mailbox; +use pagetop_seaorm::db::Set; + +use unicode_ident::{is_xid_continue, is_xid_start}; +use unicode_normalization::UnicodeNormalization; +use unicode_security::{GeneralSecurityProfile, MixedScript, skeleton}; + +use sha2::{Digest, Sha256}; + +use crate::LOCALES_USER; +use crate::config::IdentityPolicy; +use crate::entity::user; +use crate::error::AuthError; + +// Longitud mínima del nombre de usuario, con cualquier política. `u16` porque también limita el +// campo del formulario (`minlength`), igual que las máximas de `username_max_chars()`. +pub(crate) const USERNAME_MIN_CHARS: u16 = 3; + +// Longitud máxima de una dirección de correo, la que admite SMTP. +pub(crate) const EMAIL_MAX_CHARS: u16 = 254; + +// Longitud máxima del nombre de usuario según la política. La de `Permissive` es la de Drupal. +pub(crate) fn username_max_chars(policy: IdentityPolicy) -> u16 { + match policy { + IdentityPolicy::Strict | IdentityPolicy::Unicode => 32, + IdentityPolicy::Permissive => 60, + } +} + +// **< Username >*********************************************************************************** + +// Nombre de usuario listo para guardar: el valor tal como se escribió (normalizado), su clave de +// búsqueda y el *hash* de su esqueleto de confusión. +#[derive(Debug, Getters)] +pub(crate) struct Username { + value: String, + key: String, + skeleton: String, +} + +impl Username { + // Guarda el nombre de usuario en el modelo. + pub(crate) fn set_on(self, model: &mut user::ActiveModel) { + model.username = Set(self.value); + model.username_key = Set(self.key); + model.username_skeleton = Set(self.skeleton); + } +} + +// Normaliza y valida un nombre de usuario con la política dada. +// +// `current_key` es la clave del nombre actual de la cuenta, si se está editando: un nombre que no +// cambia (salvo en mayúsculas) no se valida de nuevo, para que una cuenta creada con una política +// más abierta pueda seguir guardando su perfil. +pub(crate) fn username( + raw: &str, + policy: IdentityPolicy, + current_key: Option<&str>, +) -> Result { + let value = raw.trim().nfkc().collect::(); + let key = value.to_lowercase(); + if current_key != Some(key.as_str()) && !accepts(&value, policy) { + return Err(AuthError::InvalidUsername); + } + let skeleton = skeleton_hash(&key); + Ok(Username { + value, + key, + skeleton, + }) +} + +// Clave para buscar una cuenta por nombre de usuario con lo que escribe el usuario, que no se +// valida: una entrada no válida simplemente no encuentra ninguna cuenta. +pub(crate) fn username_key(raw: &str) -> String { + raw.trim().nfkc().collect::().to_lowercase() +} + +// *Hash* SHA-256, en hexadecimal, del esqueleto de confusión (UTS #39) de la clave del nombre. +fn skeleton_hash(key: &str) -> String { + let digest = Sha256::digest(skeleton(key).collect::().as_bytes()); + let mut hex = String::with_capacity(64); + for byte in digest { + hex.push(char::from(b"0123456789abcdef"[usize::from(byte >> 4)])); + hex.push(char::from(b"0123456789abcdef"[usize::from(byte & 0x0f)])); + } + hex +} + +// Si la política acepta el nombre, ya normalizado. +// +// Nunca se admite `@`: un nombre de usuario no puede coincidir con el email de otra cuenta, que +// también sirve para iniciar sesión. Con `Unicode` y `Permissive`, las letras y dígitos son las +// clases que definen los identificadores de Rust (XID, UAX #31), que incluyen las marcas +// combinables de escrituras como el devanagari; `identifier_allowed()` descarta los caracteres +// que UTS #39 desaconseja (invisibles, obsoletos...) y `is_single_script()` la mezcla de alfabetos. +fn accepts(name: &str, policy: IdentityPolicy) -> bool { + let symbols: &[char] = match policy { + IdentityPolicy::Strict | IdentityPolicy::Unicode => &['.', '_', '-'], + IdentityPolicy::Permissive => &['.', '_', '-', ' ', '\'', '+'], + }; + let length = usize::from(USERNAME_MIN_CHARS)..=usize::from(username_max_chars(policy)); + if !length.contains(&name.chars().count()) { + return false; + } + let Some(first) = name.chars().next() else { + return false; + }; + match policy { + IdentityPolicy::Strict => { + first.is_ascii_alphanumeric() + && name + .chars() + .all(|c| c.is_ascii_alphanumeric() || symbols.contains(&c)) + } + IdentityPolicy::Unicode | IdentityPolicy::Permissive => { + let letter_or_digit = |c: char| { + c.identifier_allowed() + && (is_xid_start(c) || (is_xid_continue(c) && c.is_numeric())) + }; + letter_or_digit(first) + && name + .chars() + .all(|c| symbols.contains(&c) || (c.identifier_allowed() && is_xid_continue(c))) + && name.is_single_script() + && !name.contains(" ") + } + } +} + +// **< Email >************************************************************************************** + +// Email listo para guardar: el valor tal como se escribió y su clave de búsqueda. +#[derive(Debug, Getters)] +pub(crate) struct Email { + value: String, + key: String, +} + +impl Email { + // Guarda el email en el modelo. + pub(crate) fn set_on(self, model: &mut user::ActiveModel) { + model.email = Set(self.value); + model.email_key = Set(self.key); + } +} + +// Normaliza y valida un email, igual con cualquier política: el formato que exige `pagetop-mail` +// para poder enviarle correos. Se guarda tal como se escribe; la clave en minúsculas evita cuentas +// duplicadas por mayúsculas (la parte local las distingue según el estándar, pero ningún +// proveedor real lo aplica). +pub(crate) fn email(raw: &str) -> Result { + let value = raw.trim().to_owned(); + let key = email_key(&value); + // También la clave: en minúsculas, algunas letras ocupan dos caracteres (`İ` -> `i̇`). + let max = usize::from(EMAIL_MAX_CHARS); + if value.chars().count() > max + || key.chars().count() > max + || Mailbox::new(value.as_str()).validate().is_err() + { + return Err(AuthError::InvalidEmail); + } + Ok(Email { key, value }) +} + +// Clave para buscar una cuenta por email con lo que escribe el usuario, sin validarlo. +pub(crate) fn email_key(raw: &str) -> String { + raw.trim().to_lowercase() +} + +// **< Textos >************************************************************************************* + +// Reglas del nombre de usuario de la política, como texto de ayuda de los formularios. +pub(crate) fn username_help(policy: IdentityPolicy) -> Lc { + let key = match policy { + IdentityPolicy::Strict => "help-username-strict", + IdentityPolicy::Unicode => "help-username-unicode", + IdentityPolicy::Permissive => "help-username-permissive", + }; + Lc::t(key, &LOCALES_USER) + .with_number("min", u32::from(USERNAME_MIN_CHARS)) + .with_number("max", u32::from(username_max_chars(policy))) +} + +#[cfg(test)] +mod tests { + use super::*; + + fn accepted(raw: &str, policy: IdentityPolicy) -> bool { + username(raw, policy, None).is_ok() + } + + fn skeleton_of(raw: &str) -> String { + username(raw, IdentityPolicy::Permissive, Some(&username_key(raw))) + .unwrap() + .skeleton + } + + const ALWAYS_REJECTED: &[&str] = &[ + "ab", + "_ana", + ".ana", + "ana@example.com", + "ana@casa", + "", + "a\u{200B}na", // Zero-width space. + "ana\u{202E}", // Right-to-left override. + ]; + + #[pagetop::test] + async fn strict_accepts_only_ascii_identifiers() { + let name = username(" Ana.Perez_01 ", IdentityPolicy::Strict, None).unwrap(); + assert_eq!(name.value, "Ana.Perez_01", "the value keeps its case"); + assert_eq!(name.key, "ana.perez_01"); + assert!(accepted("a-b", IdentityPolicy::Strict)); + // Full-width letters are normalized to ASCII (NFKC). + assert_eq!( + username("Ana", IdentityPolicy::Strict, None) + .unwrap() + .value, + "Ana" + ); + let too_long = "a".repeat(33); + for name in + ALWAYS_REJECTED + .iter() + .copied() + .chain(["peña", "аna", "ana perez", too_long.as_str()]) + { + assert!( + !accepted(name, IdentityPolicy::Strict), + "{name:?} must be rejected" + ); + } + } + + #[pagetop::test] + async fn unicode_accepts_any_single_script() { + for name in [ + "josé", + "peña", + "Müller", + "σοφία", + "Иван", + "山田太郎", + "山田やまだ", + "नमस्ते", // Devanagari, with combining vowel signs. + "محمد", + "ana_01", + ] { + assert!( + accepted(name, IdentityPolicy::Unicode), + "{name:?} must be accepted" + ); + } + // A combining accent is composed (NFKC): both spellings are the same user. + assert_eq!(username_key("jose\u{301}"), username_key("josé")); + let too_long = "a".repeat(33); + for name in ALWAYS_REJECTED.iter().copied().chain([ + "pаypal", + "ana perez", + "O'Brien", + too_long.as_str(), + ]) { + assert!( + !accepted(name, IdentityPolicy::Unicode), + "{name:?} must be rejected" + ); + } + } + + #[pagetop::test] + async fn permissive_adds_spaces_apostrophes_and_plus() { + for name in ["Ana Pérez", "O'Brien", "ana+test", "José María"] { + assert!( + accepted(name, IdentityPolicy::Permissive), + "{name:?} must be accepted" + ); + } + let too_long = "a".repeat(61); + for name in + ALWAYS_REJECTED + .iter() + .copied() + .chain(["ana perez", "pаypal", too_long.as_str()]) + { + assert!( + !accepted(name, IdentityPolicy::Permissive), + "{name:?} must be rejected" + ); + } + } + + #[pagetop::test] + async fn confusable_names_share_their_skeleton() { + assert_eq!(skeleton_of("admin"), skeleton_of("аdmin")); // Cyrillic "а". + assert_eq!(skeleton_of("maria"), skeleton_of("rnaria")); + assert_eq!(skeleton_of("Ana"), skeleton_of("ana")); + assert_ne!(skeleton_of("ana"), skeleton_of("eva")); + } + + // Each Hangul syllable expands to up to seven characters in the skeleton: only its hash fits + // the column, whatever the name. + #[pagetop::test] + async fn longest_names_fit_their_columns() { + let name = username(&"꽦".repeat(60), IdentityPolicy::Permissive, None).unwrap(); + assert_eq!(name.skeleton.len(), 64); + assert!(name.key.chars().count() <= 255); + } + + #[pagetop::test] + async fn unchanged_names_skip_the_policy() { + let current = username_key("Ana Pérez"); + assert!(username("ana pérez", IdentityPolicy::Strict, Some(¤t)).is_ok()); + assert!(username("Eva Pérez", IdentityPolicy::Strict, Some(¤t)).is_err()); + } + + #[pagetop::test] + async fn emails_keep_their_case_and_compare_without_it() { + let email = email(" Ana@Example.COM ").unwrap(); + assert_eq!(email.value, "Ana@Example.COM"); + assert_eq!(email.key, "ana@example.com"); + assert_eq!(email_key("ANA@example.com "), email.key); + let too_long = format!("{}@example.com", "a".repeat(250)); + for invalid in [ + "", + "ana", + "ana@", + "Ana ", + too_long.as_str(), + ] { + assert!( + matches!(super::email(invalid), Err(AuthError::InvalidEmail)), + "{invalid:?} must be rejected" + ); + } + } +} diff --git a/extensions/pagetop-user/src/lib.rs b/extensions/pagetop-user/src/lib.rs index 911aba0d..8614d48f 100644 --- a/extensions/pagetop-user/src/lib.rs +++ b/extensions/pagetop-user/src/lib.rs @@ -32,7 +32,7 @@ enum MyPermission { impl Permission for MyPermission { fn key(&self) -> CowStr { match self { - Self::SeeDashboard => "myapp.see_dashboard".into(), + Self::SeeDashboard => "myapp:see_dashboard".into(), } } } @@ -59,6 +59,37 @@ async fn dashboard(request: HttpRequest) -> Result { .render().await } ``` + +## Nombres de usuario y email + +Cada cuenta tiene un nombre de usuario y un email, obligatorios y únicos; se puede iniciar sesión +con cualquiera de los dos. Qué nombres de usuario se aceptan lo decide `identity_policy` en la +sección `[user]`: + +```toml +[user] +identity_policy = "unicode" # "strict" (por defecto), "unicode" o "permissive". +``` + +Con cualquier política, un nombre de usuario nunca contiene `@`, no se distinguen mayúsculas (`Ana` +y `ana` son el mismo usuario) y no se admiten nombres que se confunden a simple vista con otro +existente (`rnaria` si existe `maria`, o `аdmin` con una `а` cirílica). Las reglas completas de +cada política, y las del email, están en [`IdentityPolicy`](config::IdentityPolicy). + +## 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 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. */ use pagetop::prelude::*; @@ -76,6 +107,8 @@ pub(crate) mod auth; pub(crate) mod demo; pub(crate) mod entity; pub(crate) mod handlers; +pub(crate) mod identity; +pub(crate) mod mail; pub(crate) mod middleware; pub(crate) mod migration; pub(crate) mod service; @@ -127,7 +160,8 @@ const PROFILE_PASSWORD_PATH: &str = "/user/password"; // Con el sufijo `/{uid}/{token}`: GET - muestra el formulario de nueva contraseña. // POST - la aplica. const PASSWORD_RESET_PATH: &str = "/user/password/reset"; -// Con el sufijo `/{uid}/{token}`: confirma la dirección de email del usuario. +// Con el sufijo `/{uid}/{token}`: GET - pide confirmar la dirección de email del usuario. +// POST - la confirma. const VERIFY_PATH: &str = "/user/verify"; // **< Rutas de administración (fijas) >************************************************************ @@ -231,6 +265,7 @@ impl Extension for User { &pagetop_admin::Admin, &pagetop_seaorm::SeaORM, &pagetop_htmx::Htmx, + &pagetop_mail::Mail, ] } @@ -242,6 +277,8 @@ impl Extension for User { DeclarePermissions::new(permission::declare_builtin_permissions), // Registra las páginas de usuarios, roles y permisos en el portal de pagetop-admin. DeclareAdminPages::new(declare_admin_pages), + // Declara las vistas previas de los correos de recuperación y verificación. + pagetop_mail::DeclareMailPreviews::new(mail::declare_previews), ] } @@ -258,7 +295,7 @@ impl Extension for User { // Los permisos de "anonymous" en memoria sobreviven a una nueva preparación en el mismo // proceso (las pruebas lo hacen), que puede usar otra base de datos. session::invalidate_anonymous_permissions(); - auth::seed_initial_data().await; + auth::seed_initial_data().await?; #[cfg(feature = "demo-data")] demo::seed_demo_data().await; Ok(()) @@ -301,7 +338,7 @@ impl Extension for User { ) .route( &format!("{}/{{uid}}/{{token}}", VERIFY_PATH), - web::get(handlers::auth::verify_email_get), + web::get(handlers::auth::verify_email_get).post(handlers::auth::verify_email_post), ) .route(ADMIN_USERS_PATH, web::get(handlers::admin::users::list_get)) .route( diff --git a/extensions/pagetop-user/src/locale/en-US/common.ftl b/extensions/pagetop-user/src/locale/en-US/common.ftl index bb3b97e0..4a4b531e 100644 --- a/extensions/pagetop-user/src/locale/en-US/common.ftl +++ b/extensions/pagetop-user/src/locale/en-US/common.ftl @@ -11,6 +11,7 @@ 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 @@ -32,6 +33,7 @@ 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 link-register = Create an account @@ -51,23 +53,55 @@ msg-password-reset-sent = If an account with that email exists, we have sent a reset link. Please check your inbox. +msg-verify-email = Press the button to confirm your email address and activate your account. + +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. + +# **< Emails >** + +mail-greeting = Hello { $username }, +mail-greeting-plain = Hello, +mail-link-expires = + { $hours -> + [one] The link expires in one hour. + *[other] The link expires in { $hours } hours. + } + +mail-reset-subject = Reset your { $app } password +mail-reset-intro = We received a request to reset the password of your account. To choose a new one, open this link: +mail-reset-action = Choose a new password +mail-reset-ignore = If you did not request it, ignore this email: your password will not change. + +mail-verify-subject = Confirm your email for { $app } +mail-verify-intro = Thank you for signing up. To activate your account, confirm your email address by opening this link: +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 + # **< Error messages >** -error-invalid-credentials = Invalid username or password. -error-account-blocked = Your account is blocked. Please contact the administrator. -error-account-pending = Please verify your email address before signing in. -error-account-locked = Too many failed attempts. Please try again later. -error-password-mismatch = Passwords do not match. -error-password-too-short = Password must be at least { $n } characters. -error-invalid-timezone = Invalid timezone. -error-invalid-language = Invalid language. -error-invalid-theme = Invalid theme. -error-about-too-long = The "About me" text must be at most { $n } characters. -error-username-taken = This username is already taken. -error-email-taken = This email address is already registered. -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. +error-invalid-credentials = Invalid username or password. +error-account-blocked = Your account is blocked. Please contact the administrator. +error-account-pending = Please verify your email address before signing in. +error-account-locked = Too many failed attempts. Please try again later. +error-password-mismatch = Passwords do not match. +error-password-too-short = Password must be at least { $n } characters. +error-invalid-timezone = Invalid timezone. +error-invalid-language = Invalid language. +error-invalid-theme = Invalid theme. +error-about-too-long = The "About me" text must be at most { $n } characters. +error-display-name-too-long = The display name must be at most { $n } characters. +error-username-taken = This username is already taken or can be mistaken for an existing one. +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-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. # **< Account statuses >** @@ -128,11 +162,27 @@ field-roles = Roles field-is-admin = Administrator (unrestricted access) field-search-users = Search by username, email or name... +help-username-strict = + { $min } to { $max } characters: unaccented letters, digits, period, hyphen or underscore, + starting with a letter or digit. Case is ignored when signing in. + +help-username-unicode = + { $min } to { $max } characters: letters of any alphabet (without mixing them), digits, period, + hyphen or underscore, starting with a letter or digit. Case is ignored when signing in. + +help-username-permissive = + { $min } to { $max } characters: letters of any alphabet (without mixing them), digits, single + spaces, period, hyphen, underscore, apostrophe or "+", starting with a letter or digit. Case is + ignored when signing in. + +help-password-min-length = At least { $n } characters. + help-machine-name-immutable = Lowercase letters, digits and underscores only. Cannot be changed after creation. help-admin-roles = - As an administrator they have every permission. These roles will apply if they stop being one. + This is an administrator account with every permission. These roles will apply if it stops + being one. # **< Admin: buttons and links >** @@ -167,7 +217,8 @@ empty-role-permissions = This role has no permissions. error-role-not-found = Role not found. error-role-machine-name-taken = This machine name is already taken. -error-invalid-machine-name = Machine name may only contain lowercase letters, digits and underscores. +error-invalid-machine-name = Machine name may only contain lowercase letters, digits and underscores, up to { $n } characters. +error-invalid-role-label = The label must not be blank or longer than { $n } characters. error-role-locked = This role is a system role and cannot be modified. error-role-in-use = This role has users assigned and cannot be deleted. error-last-administrator = Cannot remove the last administrator. diff --git a/extensions/pagetop-user/src/locale/es-ES/common.ftl b/extensions/pagetop-user/src/locale/es-ES/common.ftl index b844837b..a966538c 100644 --- a/extensions/pagetop-user/src/locale/es-ES/common.ftl +++ b/extensions/pagetop-user/src/locale/es-ES/common.ftl @@ -11,6 +11,7 @@ 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 @@ -32,6 +33,7 @@ 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 link-register = Crear una cuenta @@ -51,23 +53,55 @@ msg-password-reset-sent = Si existe una cuenta con ese email, hemos enviado un enlace de recuperación. Revisa tu bandeja de entrada. +msg-verify-email = Pulsa el botón para confirmar tu dirección de correo y activar tu cuenta. + +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. + +# **< Correos >** + +mail-greeting = Hola, { $username }: +mail-greeting-plain = Hola: +mail-link-expires = + { $hours -> + [one] El enlace caduca en una hora. + *[other] El enlace caduca en { $hours } horas. + } + +mail-reset-subject = Recupera tu contraseña de { $app } +mail-reset-intro = Hemos recibido una solicitud para restablecer la contraseña de tu cuenta. Para elegir una nueva, abre este enlace: +mail-reset-action = Elegir una nueva contraseña +mail-reset-ignore = Si no lo has solicitado tú, ignora este correo: tu contraseña no cambiará. + +mail-verify-subject = Confirma tu correo en { $app } +mail-verify-intro = Gracias por registrarte. Para activar tu cuenta, confirma tu dirección de correo abriendo este enlace: +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 + # **< Mensajes de error >** -error-invalid-credentials = Usuario o contraseña incorrectos. -error-account-blocked = Tu cuenta está bloqueada. Contacta con el administrador. -error-account-pending = Verifica tu dirección de email antes de iniciar sesión. -error-account-locked = Demasiados intentos fallidos. Inténtalo de nuevo más tarde. -error-password-mismatch = Las contraseñas no coinciden. -error-password-too-short = La contraseña debe tener al menos { $n } caracteres. -error-invalid-timezone = Zona horaria no válida. -error-invalid-language = Idioma no válido. -error-invalid-theme = Tema no válido. -error-about-too-long = El texto «Sobre mí» no puede superar { $n } caracteres. -error-username-taken = Este nombre de usuario ya está en uso. -error-email-taken = Esta dirección de email ya está registrada. -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. +error-invalid-credentials = Usuario o contraseña incorrectos. +error-account-blocked = Tu cuenta está bloqueada. Contacta con el administrador. +error-account-pending = Verifica tu dirección de email antes de iniciar sesión. +error-account-locked = Demasiados intentos fallidos. Inténtalo de nuevo más tarde. +error-password-mismatch = Las contraseñas no coinciden. +error-password-too-short = La contraseña debe tener al menos { $n } caracteres. +error-invalid-timezone = Zona horaria no válida. +error-invalid-language = Idioma no válido. +error-invalid-theme = Tema no válido. +error-about-too-long = El texto «Sobre mí» no puede superar { $n } caracteres. +error-display-name-too-long = El nombre visible no puede superar { $n } caracteres. +error-username-taken = Este nombre de usuario ya está en uso o se confunde con otro existente. +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-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. # **< Estados de cuenta >** @@ -128,11 +162,28 @@ field-roles = Roles field-is-admin = Administrador (acceso irrestricto) field-search-users = Buscar por usuario, email o nombre... +help-username-strict = + Entre { $min } y { $max } caracteres: letras sin tildes ni eñes, números, punto, guion o guion + bajo, empezando por una letra o un número. No se distinguen mayúsculas al iniciar sesión. + +help-username-unicode = + Entre { $min } y { $max } caracteres: letras de cualquier alfabeto (sin mezclarlos), números, + punto, guion o guion bajo, empezando por una letra o un número. No se distinguen mayúsculas + al iniciar sesión. + +help-username-permissive = + Entre { $min } y { $max } caracteres: letras de cualquier alfabeto (sin mezclarlos), números, + espacios simples, punto, guion, guion bajo, apóstrofo o «+», empezando por una letra o un + número. No se distinguen mayúsculas al iniciar sesión. + +help-password-min-length = Al menos { $n } caracteres. + help-machine-name-immutable = Sólo minúsculas, dígitos y guiones bajos. No se puede cambiar tras crearlo. help-admin-roles = - Como administrador tiene todos los permisos. Estos roles se aplicarán si deja de serlo. + Esta cuenta es de administrador y tiene todos los permisos. Estos roles se aplicarán si deja de + serlo. # **< Administración: botones y enlaces >** @@ -167,7 +218,8 @@ empty-role-permissions = Este rol no tiene permisos. error-role-not-found = Rol no encontrado. error-role-machine-name-taken = Este nombre técnico ya está en uso. -error-invalid-machine-name = El nombre técnico sólo admite minúsculas, dígitos y guiones bajos. +error-invalid-machine-name = El nombre técnico sólo admite minúsculas, dígitos y guiones bajos, hasta { $n } caracteres. +error-invalid-role-label = La etiqueta no puede quedar vacía ni superar { $n } caracteres. error-role-locked = Este rol es de sistema y no se puede modificar. error-role-in-use = Este rol tiene usuarios asignados y no se puede eliminar. error-last-administrator = No se puede quitar al último administrador. diff --git a/extensions/pagetop-user/src/mail.rs b/extensions/pagetop-user/src/mail.rs new file mode 100644 index 00000000..a1370c6f --- /dev/null +++ b/extensions/pagetop-user/src/mail.rs @@ -0,0 +1,210 @@ +//! Correos con enlaces de un solo uso: recuperación de contraseña y verificación de email. + +use pagetop::prelude::*; +use pagetop_mail::prelude::*; + +use crate::config; +use crate::token::TokenKind; +use crate::{LOCALES_USER, PASSWORD_RESET_PATH, VERIFY_PATH}; + +// Estilo del enlace principal, con aspecto de botón. +const BUTTON_STYLE: &str = concat!( + "display: inline-block; padding: 10px 20px; border-radius: 4px; ", + "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, + // Nombre de usuario para el saludo, sólo si la dirección está verificada (ver `recipient()`). + username: Option, + link: String, +} + +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 { + TokenKind::PasswordReset => [ + "mail-reset-subject", + "mail-reset-intro", + "mail-reset-action", + "mail-reset-ignore", + ], + TokenKind::EmailVerification => [ + "mail-verify-subject", + "mail-verify-intro", + "mail-verify-action", + "mail-verify-ignore", + ], + } + } + + 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) + } +} + +impl MailTemplate for TokenMail { + fn subject(&self, cx: &Context) -> String { + 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 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()`. + Some(username) => { + Lc::t("mail-greeting", &LOCALES_USER).with_arg("username", username.clone()) + } + None => Lc::t("mail-greeting-plain", &LOCALES_USER), + }; + 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)) } + }) + } +} + +// 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. +pub(crate) fn send_token_mail( + request: &HttpRequest, + kind: TokenKind, + user: &crate::entity::user::Model, + token: &str, +) { + 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(); +} + +// Destinatario del correo y nombre de usuario para el saludo. +// +// Mientras la dirección no esté verificada, el correo puede llegar a otra persona: cualquiera puede +// crear una cuenta con una dirección ajena, y con `require_email_verification = false` la cuenta +// queda activa y puede pedir la recuperación de contraseña. El correo sale del dominio de la +// aplicación y con su diseño, así que pasa los filtros y resulta creíble: no incluye nada que elija +// 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) { + if user.email_verified_at.is_none() { + return (None, Mailbox::new(user.email.as_str())); + } + let name = + util::non_blank(user.display_name.as_deref().unwrap_or_default()).unwrap_or(&user.username); + ( + Some(user.username.clone()), + Mailbox::from((name, user.email.as_str())), + ) +} + +// Compone el correo con el enlace que consume `token` del usuario `user_id`. +fn token_email( + cx: &Context, + kind: TokenKind, + user_id: i32, + username: Option, + to: Mailbox, + token: &str, +) -> Email { + let base = match kind { + TokenKind::PasswordReset => PASSWORD_RESET_PATH, + TokenKind::EmailVerification => VERIFY_PATH, + }; + let path = util::join!(base, "/", user_id.to_string(), "/", token); + let template = TokenMail { + kind, + username, + link: absolute_url(cx.route(path)), + }; + Email::from_template(&template, cx).with_to(to) +} + +// **< Vistas previas >***************************************************************************** + +// Declara las vistas previas de los correos de `pagetop-user`, con datos de ejemplo. +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), + ); + previews.add( + "user.password_reset", + Lc::t("mail-preview-reset", &LOCALES_USER), + |cx| sample(cx, TokenKind::PasswordReset), + ); +} + +// 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 { + 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")), + ), + }; + token_email(cx, kind, 42, username, to, "EXAMPLE-TOKEN") +} + +#[cfg(test)] +mod tests { + use super::*; + + 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(), + }; + mail.html(&Context::default()).unwrap().into_string() + } + + // The username is chosen by whoever creates the account. + #[pagetop::test] + async fn username_cannot_inject_markup() { + let html = html(Some(USERNAME)); + assert!( + !html.contains("evil.example\">"), + "username must be escaped: {html}" + ); + assert!(html.contains("<a href=")); + } + + // An unverified address may belong to someone else: nothing chosen by whoever created the + // account may appear in the email. + #[pagetop::test] + async fn unverified_address_gets_a_plain_greeting() { + let html = html(None); + assert!( + !html.contains("evil.example"), + "username must not appear: {html}" + ); + } +} 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 144db0e7..f941c250 100644 --- a/extensions/pagetop-user/src/migration/m20260629_000001_create_users.rs +++ b/extensions/pagetop-user/src/migration/m20260629_000001_create_users.rs @@ -9,8 +9,15 @@ impl MigrationTrait for Migration { .create_table( table_auto(Users::Table) .col(pk_auto(Users::Id)) - .col(string_len_uniq(Users::Username, 64)) - .col(string_len_uniq(Users::Email, 254)) + // El nombre de usuario y el email con sus mayúsculas (ver `identity.rs`). + .col(string_len(Users::Username, 64)) + .col(string_len(Users::Email, 254)) + // Formas para buscar y comparar sin distinguir mayúsculas, que pueden ser más + // largas que el original (en minúsculas, un carácter puede ocupar dos), y + // *hash* del esqueleto de confusión del nombre (ver `identity.rs`). + .col(string_len_uniq(Users::UsernameKey, 255)) + .col(char_len_uniq(Users::UsernameSkeleton, 64)) + .col(string_len_uniq(Users::EmailKey, 255)) .col(timestamp_null(Users::EmailVerifiedAt)) .col(string(Users::PasswordHash)) // 0=Blocked, 1=Active, 2=Pending @@ -24,6 +31,7 @@ impl MigrationTrait for Migration { .col(timestamp_null(Users::LastLoginAt)) .col(timestamp_null(Users::LastAccessAt)) .col(integer(Users::FailedLoginCount).default(0)) + .col(timestamp_null(Users::FailedLoginAt)) .col(timestamp_null(Users::LockedUntil)) // Acceso irrestricto al sistema, sin pasar por roles ni permisos. .col(boolean(Users::IsAdmin).default(false)) @@ -45,6 +53,9 @@ pub enum Users { Id, Username, Email, + UsernameKey, + UsernameSkeleton, + EmailKey, EmailVerifiedAt, PasswordHash, Status, @@ -56,6 +67,7 @@ pub enum Users { LastLoginAt, LastAccessAt, FailedLoginCount, + FailedLoginAt, LockedUntil, IsAdmin, } diff --git a/extensions/pagetop-user/src/password.rs b/extensions/pagetop-user/src/password.rs index 25661a7a..d31c1465 100644 --- a/extensions/pagetop-user/src/password.rs +++ b/extensions/pagetop-user/src/password.rs @@ -6,6 +6,8 @@ use argon2::{ }; use rand_core::OsRng; +use std::sync::LazyLock; + use crate::config::SETTINGS; use crate::error::AuthError; @@ -38,25 +40,51 @@ pub fn verify_password(plain: &str, phc: &str) -> bool { .is_ok() } -/// Indica si el hash necesita actualizarse (parámetros de coste han cambiado). +// Versiones de `hash_password()` y `verify_password()` para las peticiones: el cálculo se hace en +// el *pool* de hilos bloqueantes de Tokio. Con los costes por defecto tarda decenas de milisegundos, +// que retendrían un hilo del *runtime* asíncrono y retrasarían las demás peticiones (p. ej. durante +// un intento de fuerza bruta contra el inicio de sesión). +pub(crate) async fn hash_password_async(plain: &str) -> Result { + let plain = plain.to_owned(); + tokio::task::spawn_blocking(move || hash_password(&plain)) + .await + .map_err(|err| AuthError::PasswordHash(err.to_string()))? +} + +pub(crate) async fn verify_password_async(plain: &str, phc: &str) -> bool { + let (plain, phc) = (plain.to_owned(), phc.to_owned()); + tokio::task::spawn_blocking(move || verify_password(&plain, &phc)) + .await + .unwrap_or(false) +} + +// Verifica la contraseña contra un *hash* que no corresponde a ninguna cuenta. Cuando no existe la +// cuenta, iguala el tiempo de respuesta al de una contraseña errónea: si no, la diferencia +// revelaría qué cuentas existen. +pub(crate) async fn verify_password_without_account(plain: &str) { + static DUMMY_HASH: LazyLock = + LazyLock::new(|| hash_password("pagetop-user-dummy-password").unwrap_or_default()); + verify_password_async(plain, DUMMY_HASH.as_str()).await; +} + +/// Indica si el hash necesita actualizarse: no es de Argon2id o se cifró con otros parámetros de +/// coste que los configurados. pub fn needs_rehash(phc: &str) -> bool { let Ok(parsed) = PasswordHash::new(phc) else { return true; }; - // Compara el coste de memoria con el configurado. - if let Some(m_cost) = parsed.params.get_str("m") { - let current: u32 = m_cost.parse().unwrap_or(0); - if current != SETTINGS.password.argon2_m_cost { - return true; - } - } - false + let cost = |name: &str| parsed.params.get_decimal(name); + let password = &SETTINGS.password; + parsed.algorithm != argon2::Algorithm::Argon2id.ident() + || cost("m") != Some(password.argon2_m_cost) + || cost("t") != Some(password.argon2_t_cost) + || cost("p") != Some(password.argon2_p_cost) } -/// Valida la longitud mínima y devuelve error si no se cumple. +/// Valida la longitud mínima, en caracteres, y devuelve error si no se cumple. pub fn validate_strength(plain: &str) -> Result<(), AuthError> { let min = SETTINGS.password.min_length; - if plain.len() < min { + if plain.chars().count() < min { Err(AuthError::PasswordTooShort(min)) } else { Ok(()) diff --git a/extensions/pagetop-user/src/permission.rs b/extensions/pagetop-user/src/permission.rs index 85db7794..8dc7f444 100644 --- a/extensions/pagetop-user/src/permission.rs +++ b/extensions/pagetop-user/src/permission.rs @@ -180,9 +180,14 @@ pub enum UserPermission { AdminUsers, /// Acceder al mantenimiento de roles (listado, alta, edición, borrado). AdminRoles, - /// Acceder al listado de permisos y a la asignación de permisos a roles. + /// Acceder al listado de permisos y, junto con `AdminRoles`, a la asignación de permisos a + /// roles. + /// + /// Es el permiso más sensible del catálogo: con `AdminRoles`, quien lo tiene puede conceder + /// cualquier permiso al rol "authenticated", que tienen todas las cuentas, incluida la suya. AdminPermissions, - /// Bloquear y desbloquear cuentas de usuario. + /// Bloquear y activar cuentas de usuario, desde la edición del usuario; requiere también + /// `AdminUsers`. BlockAccounts, } @@ -253,7 +258,7 @@ fn builtin_group_label(group: &str) -> Lc { let key = match group { GROUP_USERS => "group-users", GROUP_ADMINISTRATION => "group-administration", - _ => unreachable!("grupo de permisos integrado desconocido: {group}"), + _ => unreachable!("unknown built-in permission group: {group}"), }; Lc::t(key, &LOCALES_USER) } diff --git a/extensions/pagetop-user/src/service/role_admin.rs b/extensions/pagetop-user/src/service/role_admin.rs index 8c3cdecf..13966f5e 100644 --- a/extensions/pagetop-user/src/service/role_admin.rs +++ b/extensions/pagetop-user/src/service/role_admin.rs @@ -168,19 +168,37 @@ pub(crate) struct NewRoleData<'a> { pub weight: i32, } +/// Longitud máxima, en caracteres, del nombre técnico de un rol, la de su columna. `u16` porque +/// también limita el campo del formulario (`maxlength`), igual que [`ROLE_LABEL_MAX_CHARS`]. +pub(crate) const ROLE_MACHINE_NAME_MAX_CHARS: u16 = 64; + +/// Longitud máxima, en caracteres, de la etiqueta de un rol, la de su columna. +pub(crate) const ROLE_LABEL_MAX_CHARS: u16 = 128; + // Sólo minúsculas ASCII, dígitos y guiones bajos (ver el texto de ayuda del formulario, // "help-machine-name-immutable"); el machine_name es inmutable tras la creación. fn is_valid_machine_name(name: &str) -> bool { - !name.is_empty() + (1..=usize::from(ROLE_MACHINE_NAME_MAX_CHARS)).contains(&name.len()) && name .bytes() .all(|b| b.is_ascii_lowercase() || b.is_ascii_digit() || b == b'_') } +// Etiqueta sin espacios en los extremos; no puede quedar vacía ni superar la longitud máxima. +fn validate_label(label: &str) -> Result<&str, AuthError> { + let label = label.trim(); + let max = usize::from(ROLE_LABEL_MAX_CHARS); + if label.is_empty() || label.chars().count() > max { + return Err(AuthError::InvalidRoleLabel(max)); + } + Ok(label) +} + pub(crate) async fn create_role(data: NewRoleData<'_>) -> Result { if !is_valid_machine_name(data.machine_name) { return Err(AuthError::InvalidMachineName); } + let label = validate_label(data.label)?; if role::Entity::find() .filter(role::Column::MachineName.eq(data.machine_name)) @@ -195,7 +213,7 @@ pub(crate) async fn create_role(data: NewRoleData<'_>) -> Result let new_role = role::ActiveModel { id: ActiveValue::NotSet, machine_name: Set(data.machine_name.to_owned()), - label: Set(data.label.to_owned()), + label: Set(label.to_owned()), description: Set(data.description.map(str::to_owned)), weight: Set(data.weight), locked: Set(false), @@ -219,11 +237,12 @@ pub(crate) async fn update_role(role_id: i32, data: RoleUpdateData<'_>) -> Resul if role.locked { return Err(AuthError::RoleLocked); } + let label = validate_label(data.label)?; let now = Utc::now(); role::ActiveModel { id: Set(role_id), - label: Set(data.label.to_owned()), + label: Set(label.to_owned()), description: Set(data.description.map(str::to_owned)), weight: Set(data.weight), updated_at: Set(now), @@ -272,7 +291,18 @@ pub(crate) async fn set_role_permissions( } let now = Utc::now(); - let keys = permission_keys.to_vec(); + // Sin repetidos: una clave repetida en el formulario violaría la clave primaria. + let mut keys = permission_keys.to_vec(); + keys.sort_unstable(); + keys.dedup(); + let rows: Vec<_> = keys + .into_iter() + .map(|key| role_permission::ActiveModel { + role_id: Set(role_id), + permission_key: Set(key), + granted_at: Set(now), + }) + .collect(); dbconn() .transaction::<_, _, AuthError>(|txn| { Box::pin(async move { @@ -280,14 +310,10 @@ pub(crate) async fn set_role_permissions( .filter(role_permission::Column::RoleId.eq(role_id)) .exec(txn) .await?; - for key in keys { - role_permission::Entity::insert(role_permission::ActiveModel { - role_id: Set(role_id), - permission_key: Set(key), - granted_at: Set(now), - }) - .exec(txn) - .await?; + if !rows.is_empty() { + role_permission::Entity::insert_many(rows) + .exec_without_returning(txn) + .await?; } Ok(()) }) diff --git a/extensions/pagetop-user/src/service/user_admin.rs b/extensions/pagetop-user/src/service/user_admin.rs index ce0e13bd..07d1b5de 100644 --- a/extensions/pagetop-user/src/service/user_admin.rs +++ b/extensions/pagetop-user/src/service/user_admin.rs @@ -3,6 +3,7 @@ use std::collections::HashMap; use pagetop::prelude::*; +use pagetop_seaorm::db::query::{Expr, Func, LikeExpr}; use pagetop_seaorm::db::{ ActiveModelTrait, ActiveValue, ColumnTrait, Condition, DatabaseTransaction, DbErr, EntityTrait, Order, Paginated, PaginatorTrait, QueryFilter, QueryOrder, Set, TransactionTrait, dbconn, @@ -10,9 +11,10 @@ use pagetop_seaorm::db::{ }; use crate::account::UserStatus; -use crate::config::{user_language_applies, user_timezone_applies}; +use crate::config::{SETTINGS, user_language_applies, user_timezone_applies}; use crate::entity::{role, user, user_role}; use crate::error::AuthError; +use crate::identity::{self, Email, Username}; use crate::password; use crate::session; @@ -70,11 +72,23 @@ pub(crate) async fn list_users( let mut select = user::Entity::find(); if let Some(q) = params.query.as_deref().and_then(util::non_blank) { + // Sin distinguir mayúsculas: las claves ya están en minúsculas y el nombre visible se + // compara en minúsculas, igual en cualquier base de datos (con `LIKE`, PostgreSQL las + // distingue y SQLite o MySQL no). select = select.filter( Condition::any() - .add(user::Column::Username.contains(q)) - .add(user::Column::Email.contains(q)) - .add(user::Column::DisplayName.contains(q)), + .add( + Expr::col(user::Column::UsernameKey) + .like(contains_pattern(&identity::username_key(q))), + ) + .add( + Expr::col(user::Column::EmailKey) + .like(contains_pattern(&identity::email_key(q))), + ) + .add( + Expr::expr(Func::lower(Expr::col(user::Column::DisplayName))) + .like(contains_pattern(&q.to_lowercase())), + ), ); } @@ -84,8 +98,8 @@ pub(crate) async fn list_users( Order::Asc }; select = match params.sort { - UserSortField::Username => select.order_by(user::Column::Username, order), - UserSortField::Email => select.order_by(user::Column::Email, order), + UserSortField::Username => select.order_by(user::Column::UsernameKey, order), + UserSortField::Email => select.order_by(user::Column::EmailKey, order), UserSortField::CreatedAt => select.order_by(user::Column::CreatedAt, order), }; @@ -95,6 +109,22 @@ pub(crate) async fn list_users( .await } +// Patrón `LIKE` que busca `text` en cualquier posición, con los comodines `%` y `_` escapados para +// que se busquen tal cual (p. ej. el `_` de `demo_user`). Se escapan con `!`, no con `\`, que +// MySQL interpreta también dentro de las cadenas. +fn contains_pattern(text: &str) -> LikeExpr { + let mut pattern = String::with_capacity(text.len() + 2); + pattern.push('%'); + for c in text.chars() { + if matches!(c, '%' | '_' | '!') { + pattern.push('!'); + } + pattern.push(c); + } + pattern.push('%'); + LikeExpr::new(pattern).escape('!') +} + async fn user_items(users: Vec) -> Result, AuthError> { let user_ids: Vec = users.iter().map(|u| u.id).collect(); let role_rows = user_role::Entity::find() @@ -176,6 +206,8 @@ pub(crate) struct NewUserData<'a> { /// El usuario y sus roles se crean en una sola transacción: si falla cualquier inserción (p. ej. /// porque se ha eliminado uno de los roles mientras tanto), no se crea nada. pub(crate) async fn create_user(data: NewUserData<'_>) -> Result { + let username = identity::username(data.username, SETTINGS.identity_policy, None)?; + let email = identity::email(data.email)?; password::validate_strength(data.password)?; password::passwords_match(data.password, data.confirm_password)?; // El idioma y la zona horaria que no se aplican no se ofrecen en el formulario: se ignora lo @@ -191,16 +223,15 @@ pub(crate) async fn create_user(data: NewUserData<'_>) -> Result None }; let theme = validate_theme(data.theme)?; - ensure_username_available(data.username, None).await?; - ensure_email_available(data.email, None).await?; + validate_display_name(data.display_name)?; + ensure_username_available(&username, None).await?; + ensure_email_available(&email, None).await?; - let hash = password::hash_password(data.password)?; + let hash = password::hash_password_async(data.password).await?; let now = Utc::now(); - let new_user = user::ActiveModel { + let mut new_user = user::ActiveModel { id: ActiveValue::NotSet, - username: Set(data.username.to_owned()), - email: Set(data.email.to_owned()), email_verified_at: Set(Some(now)), password_hash: Set(hash), status: Set(UserStatus::Active.as_i16()), @@ -216,7 +247,10 @@ pub(crate) async fn create_user(data: NewUserData<'_>) -> Result is_admin: Set(data.is_admin), created_at: Set(now), updated_at: Set(now), + ..Default::default() }; + username.set_on(&mut new_user); + email.set_on(&mut new_user); let role_ids = assignable_roles(data.initial_role_ids); dbconn() @@ -240,6 +274,18 @@ pub(crate) async fn create_user(data: NewUserData<'_>) -> Result /// formulario (`maxlength`). pub(crate) const ABOUT_MAX_CHARS: u16 = 2000; +/// Longitud máxima, en caracteres, del nombre visible, la de su columna. +pub(crate) const DISPLAY_NAME_MAX_CHARS: u16 = 128; + +// Comprueba que el nombre visible no supere la longitud de su columna. +fn validate_display_name(display_name: Option<&str>) -> Result<(), AuthError> { + let max = usize::from(DISPLAY_NAME_MAX_CHARS); + if display_name.is_some_and(|name| name.chars().count() > max) { + return Err(AuthError::DisplayNameTooLong(max)); + } + Ok(()) +} + pub(crate) struct UserUpdateData<'a> { pub username: &'a str, pub email: &'a str, @@ -248,9 +294,21 @@ 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, } 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?; + let username = identity::username( + data.username, + SETTINGS.identity_policy, + Some(¤t.username_key), + )?; + let email = identity::email(data.email)?; // El idioma y la zona horaria que no se aplican tampoco se ofrecen en el formulario, así que no // llegan: se conserva lo guardado por si se vuelven a aplicar. let language = if user_language_applies() { @@ -261,7 +319,7 @@ pub(crate) async fn update_user(user_id: i32, data: UserUpdateData<'_>) -> Resul let timezone = if user_timezone_applies() { let timezone = match validate_timezone(data.timezone) { Err(AuthError::InvalidTimezone) => { - keep_current_timezone(user_id, data.timezone).await? + keep_current_timezone(data.timezone, current.timezone.as_deref())? } result => result?, }; @@ -270,6 +328,7 @@ pub(crate) async fn update_user(user_id: i32, data: UserUpdateData<'_>) -> Resul ActiveValue::NotSet }; let theme = validate_theme(data.theme)?; + validate_display_name(data.display_name)?; // El navegador envía los saltos de línea de un `