✨ (user): Integra pagetop-mail y valida identidades

- Envía por correo la recuperación de contraseña y, con
  `require_email_verification`, la verificación de cuentas nuevas, que
  se confirma con un botón (los escáneres de correo abren los enlaces).
- Nueva política de nombres de usuario (`identity_policy`): sin `@`, sin
  distinguir mayúsculas y sin nombres confusables (UTS #39). Email
  validado con pagetop-mail.
- Tokens de un solo uso atómicos y ligados al usuario. Los correos a
  direcciones sin verificar no incluyen datos elegidos por el usuario.
- Bloqueo por intentos fallidos con su ventana de recuento, y el mismo
  tiempo de respuesta exista o no la cuenta. Argon2 en `spawn_blocking`.
- Límites de longitud del nombre visible y de los roles, y botones sólo
  con el permiso que exigen. Más correcciones en formularios y búsqueda.
This commit is contained in:
Manuel Cillero 2026-10-19 07:57:38 +02:00
parent a9b1b3b2a3
commit bd54980d0f
34 changed files with 2053 additions and 355 deletions

408
Cargo.lock generated
View file

@ -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"

View file

@ -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" }

View file

@ -124,7 +124,8 @@ transport = "log" # Entrega de los correos:
# "memory" -> se guardan en memoria (sólo pruebas).
#from = "Mi Aplicación <no-reply@example.com>"
# 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.

View file

@ -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 <no-reply@example.com>"`). 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<String>,
/// Dirección de respuesta por defecto, para los correos que no indican una propia.
pub reply_to: Option<String>,

View file

@ -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

View file

@ -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<String, AuthError> {
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<i32, AuthError> {
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<Utc>,
) -> 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<DateTime<Utc>>,
now: DateTime<Utc>,
policy: FailedLoginPolicy,
) -> (i32, Option<DateTime<Utc>>) {
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<Utc> {
DateTime::from_timestamp(1_800_000_000 + secs, 0).unwrap()
}
fn outcome(count: i32, last: Option<i64>, now: i64) -> (i32, Option<DateTime<Utc>>) {
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));
}
}

View file

@ -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()

View file

@ -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)
}
}
})

View file

@ -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

View file

@ -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<Lc>,
/// 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<String>) -> Self {
self.username = username.into();
self
}
pub fn with_waypoint(mut self, waypoint: impl Into<Waypoint>) -> Self {
self.waypoint = waypoint.into();
self

View file

@ -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<Markup, ComponentError> {
// `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")

View file

@ -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)));

View file

@ -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<Lc>,
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<String>) -> 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<String>) -> Self {
self.email = email.into();
self
}
}

View file

@ -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<UserSettings> = 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

View file

@ -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;

View file

@ -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<DateTimeUtc>,
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<String>,
pub last_login_at: Option<DateTimeUtc>,
/// Ú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<DateTimeUtc>,
/// 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<DateTimeUtc>,
pub locked_until: Option<DateTimeUtc>,
/// Acceso irrestricto al sistema, sin pasar por roles ni permisos.
pub is_admin: bool,

View file

@ -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<AuthError>,
},
#[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,

View file

@ -26,10 +26,12 @@ fn current_user_id(request: &HttpRequest) -> Option<i32> {
request.extension::<Account>().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;

View file

@ -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),

View file

@ -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);

View file

@ -327,6 +327,8 @@ async fn render_edit_page(
let can_toggle_admin = request
.extension::<Account>()
.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;

View file

@ -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<PasswordResetFormData>,
) -> Result<Markup, ErrorPage> {
// 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<Markup, ErrorPage> {
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<PasswordResetConfirmFormData>,
) -> 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<Markup, ErrorPage> {
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<RoutePath>, cookie: &str) -> Response {
(
web::http::StatusCode::SEE_OTHER,

View file

@ -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<Username, AuthError> {
let value = raw.trim().nfkc().collect::<String>();
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::<String>().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::<String>().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<Email, AuthError> {
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>",
"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(&current)).is_ok());
assert!(username("Eva Pérez", IdentityPolicy::Strict, Some(&current)).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 <ana@example.com>",
too_long.as_str(),
] {
assert!(
matches!(super::email(invalid), Err(AuthError::InvalidEmail)),
"{invalid:?} must be rejected"
);
}
}
}

View file

@ -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<Markup, ErrorPage> {
.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(

View file

@ -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.

View file

@ -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.

View file

@ -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<String>,
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<Markup> {
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<String>, 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<String>,
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#"<a href="https://evil.example">ana</a>"#;
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("&lt;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}"
);
}
}

View file

@ -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,
}

View file

@ -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<String, AuthError> {
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<String> =
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(())

View file

@ -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)
}

View file

@ -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<i32, AuthError> {
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<i32, AuthError>
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(())
})

View file

@ -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<user::Model>) -> Result<Vec<UserListItem>, AuthError> {
let user_ids: Vec<i32> = 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<i32, AuthError> {
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<i32, AuthError>
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<i32, AuthError>
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<i32, AuthError>
/// 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(&current.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 `<textarea>` como `\r\n`, pero `maxlength` puede
// contarlos como un único carácter: se normalizan antes de medir para no rechazar un texto que
// el formulario sí admitió.
@ -281,14 +340,12 @@ pub(crate) async fn update_user(user_id: i32, data: UserUpdateData<'_>) -> Resul
{
return Err(AuthError::AboutTooLong(max_about));
}
ensure_username_available(data.username, Some(user_id)).await?;
ensure_email_available(data.email, Some(user_id)).await?;
ensure_username_available(&username, Some(user_id)).await?;
ensure_email_available(&email, Some(user_id)).await?;
let now = Utc::now();
user::ActiveModel {
let mut model = user::ActiveModel {
id: Set(user_id),
username: Set(data.username.to_owned()),
email: Set(data.email.to_owned()),
display_name: Set(data.display_name.map(str::to_owned)),
about: Set(about),
language,
@ -296,9 +353,13 @@ pub(crate) async fn update_user(user_id: i32, data: UserUpdateData<'_>) -> Resul
theme: Set(theme.map(str::to_owned)),
updated_at: Set(now),
..Default::default()
};
if *email.key() != current.email_key {
model.email_verified_at = Set(data.email_verified.then_some(now));
}
.update(dbconn())
.await?;
username.set_on(&mut model);
email.set_on(&mut model);
model.update(dbconn()).await?;
Ok(())
}
@ -432,20 +493,23 @@ pub(crate) async fn set_user_admin(
// **< admin_reset_password >***********************************************************************
/// Restablece la contraseña de un usuario como acción administrativa e invalida sus sesiones
/// activas.
/// Restablece la contraseña de un usuario como acción administrativa, invalida sus sesiones
/// activas y levanta el bloqueo temporal por intentos fallidos.
pub(crate) async fn admin_reset_password(
user_id: i32,
new_password: &str,
) -> Result<(), AuthError> {
find_user(user_id).await?;
password::validate_strength(new_password)?;
let hash = password::hash_password(new_password)?;
let hash = password::hash_password_async(new_password).await?;
let now = Utc::now();
user::ActiveModel {
id: Set(user_id),
password_hash: Set(hash),
failed_login_count: Set(0),
failed_login_at: Set(None),
locked_until: Set(None),
updated_at: Set(now),
..Default::default()
}
@ -502,27 +566,28 @@ fn validate_timezone(timezone: Option<&str>) -> Result<Option<&str>, AuthError>
Ok(timezone)
}
// Acepta una zona que ya no se ofrece si es la que el usuario tenía guardada: el selector la sigue
// mostrando para que volver a guardar el formulario sin tocarla no la descarte. Sólo se consulta la
// base de datos cuando la zona recibida no se ofrece.
async fn keep_current_timezone(
user_id: i32,
timezone: Option<&str>,
) -> Result<Option<&str>, AuthError> {
// Acepta una zona que ya no se ofrece si es la que el usuario tenía guardada (`current`): el
// selector la sigue mostrando para que volver a guardar el formulario sin tocarla no la descarte.
fn keep_current_timezone<'a>(
timezone: Option<&'a str>,
current: Option<&str>,
) -> Result<Option<&'a str>, AuthError> {
let timezone = timezone.and_then(util::non_blank);
let current = find_user(user_id).await?.timezone;
if timezone.is_some() && timezone == current.as_deref() {
if timezone.is_some() && timezone == current {
Ok(timezone)
} else {
Err(AuthError::InvalidTimezone)
}
}
async fn ensure_username_available(
username: &str,
// Comprueba que no exista otra cuenta con el mismo nombre de usuario o con uno que se confunda con
// él: los dos casos comparten el esqueleto.
pub(crate) async fn ensure_username_available(
username: &Username,
exclude_id: Option<i32>,
) -> Result<(), AuthError> {
let mut query = user::Entity::find().filter(user::Column::Username.eq(username));
let mut query =
user::Entity::find().filter(user::Column::UsernameSkeleton.eq(username.skeleton()));
if let Some(id) = exclude_id {
query = query.filter(user::Column::Id.ne(id));
}
@ -532,8 +597,12 @@ async fn ensure_username_available(
Ok(())
}
async fn ensure_email_available(email: &str, exclude_id: Option<i32>) -> Result<(), AuthError> {
let mut query = user::Entity::find().filter(user::Column::Email.eq(email));
// Comprueba que no exista otra cuenta con el mismo email, sin distinguir mayúsculas.
pub(crate) async fn ensure_email_available(
email: &Email,
exclude_id: Option<i32>,
) -> Result<(), AuthError> {
let mut query = user::Entity::find().filter(user::Column::EmailKey.eq(email.key()));
if let Some(id) = exclude_id {
query = query.filter(user::Column::Id.ne(id));
}

View file

@ -183,6 +183,15 @@ pub async fn load_user_from_session(sid: &str) -> (CurrentUser, Option<Account>,
if let Err(err) = result {
trace::warn!("session: failed to renew expiry: {err}");
}
// Último acceso del usuario, con la misma precisión que la prórroga de la sesión.
let result = user::Entity::update_many()
.col_expr(user::Column::LastAccessAt, Expr::value(now))
.filter(user::Column::Id.eq(sess.user_id))
.exec(dbconn())
.await;
if let Err(err) = result {
trace::warn!("session: failed to record last access: {err}");
}
}
let language = user_model.language.take();
@ -222,10 +231,19 @@ fn renewed_expiry(
// **< create_session >*****************************************************************************
/// Crea una nueva sesión en base de datos y devuelve el session ID.
///
/// Borra antes las sesiones caducadas del usuario: las que se abandonan sin cerrar sesión no se
/// borran de otro modo, y así no se acumulan con cada inicio de sesión.
pub async fn create_session(user_id: i32, remember: bool) -> Result<String, DbErr> {
let sid = generate_sid();
let now = Utc::now();
session::Entity::delete_many()
.filter(session::Column::UserId.eq(user_id))
.filter(session::Column::ExpiresAt.lt(now))
.exec(dbconn())
.await?;
let new_session = session::ActiveModel {
sid: Set(sid.clone()),
user_id: Set(user_id),

View file

@ -2,10 +2,8 @@
//! email...).
use pagetop::prelude::*;
use pagetop_seaorm::db::{
ActiveModelTrait, ActiveValue, ColumnTrait, EntityTrait, IntoActiveModel, QueryFilter, Set,
dbconn,
};
use pagetop_seaorm::db::query::Expr;
use pagetop_seaorm::db::{ActiveValue, ColumnTrait, EntityTrait, QueryFilter, Set, dbconn};
use crate::entity::user_token;
use crate::error::AuthError;
@ -97,30 +95,42 @@ pub async fn create_token(user_id: i32, kind: TokenKind) -> Result<String, AuthE
Ok(token)
}
// **< consume_token >******************************************************************************
/// Verifica que el token en claro sea válido (existe, no ha expirado y no ha sido consumido)
/// y lo marca como consumido. Devuelve el `user_id` asociado.
pub async fn consume_token(token: &str, kind: TokenKind) -> Result<i32, AuthError> {
let hash = hash_token(token);
let now = Utc::now();
// **< is_valid_token / consume_token >*************************************************************
/// Comprueba, sin consumirlo, que el token en claro sea válido para el usuario: existe, es del tipo
/// indicado, no ha caducado y no se ha consumido.
pub async fn is_valid_token(user_id: i32, token: &str, kind: TokenKind) -> Result<bool, AuthError> {
let row = user_token::Entity::find()
.filter(user_token::Column::TokenHash.eq(&hash))
.filter(user_token::Column::TokenHash.eq(hash_token(token)))
.filter(user_token::Column::UserId.eq(user_id))
.filter(user_token::Column::Kind.eq(kind.as_str()))
.filter(user_token::Column::ConsumedAt.is_null())
.filter(user_token::Column::ExpiresAt.gt(Utc::now()))
.one(dbconn())
.await?
.ok_or(AuthError::InvalidToken)?;
if row.consumed_at.is_some() || row.expires_at < now {
return Err(AuthError::InvalidToken);
}
let user_id = row.user_id;
let mut active = row.into_active_model();
active.consumed_at = Set(Some(now));
active.updated_at = Set(now);
active.update(dbconn()).await?;
Ok(user_id)
.await?;
Ok(row.is_some())
}
/// Consume el token en claro del usuario si es válido (ver [`is_valid_token()`]).
///
/// Falla con [`AuthError::InvalidToken`] si no lo es. Se marca como consumido en una sola
/// sentencia condicionada a que siga sin consumir: dos peticiones simultáneas con el mismo enlace
/// no pueden usarlo las dos.
pub async fn consume_token(user_id: i32, token: &str, kind: TokenKind) -> Result<(), AuthError> {
let now = Utc::now();
let result = user_token::Entity::update_many()
.col_expr(user_token::Column::ConsumedAt, Expr::value(now))
.col_expr(user_token::Column::UpdatedAt, Expr::value(now))
.filter(user_token::Column::TokenHash.eq(hash_token(token)))
.filter(user_token::Column::UserId.eq(user_id))
.filter(user_token::Column::Kind.eq(kind.as_str()))
.filter(user_token::Column::ConsumedAt.is_null())
.filter(user_token::Column::ExpiresAt.gt(now))
.exec(dbconn())
.await?;
if result.rows_affected == 1 {
Ok(())
} else {
Err(AuthError::InvalidToken)
}
}