✨ (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:
parent
a9b1b3b2a3
commit
bd54980d0f
34 changed files with 2053 additions and 355 deletions
408
Cargo.lock
generated
408
Cargo.lock
generated
|
|
@ -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"
|
||||
|
|
|
|||
|
|
@ -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" }
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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>,
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
|
|
|
|||
|
|
@ -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(
|
||||
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;
|
||||
.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)
|
||||
}
|
||||
}
|
||||
})
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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")
|
||||
|
|
|
|||
|
|
@ -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)));
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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),
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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())
|
||||
if !is_valid_token(uid, &token, TokenKind::PasswordReset)
|
||||
.await
|
||||
.ok()
|
||||
.flatten()
|
||||
.is_some_and(|r| r.expires_at > now)
|
||||
};
|
||||
if !valid {
|
||||
.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,40 +317,86 @@ pub async fn password_reset_confirm_post(
|
|||
.await;
|
||||
match result {
|
||||
Ok(()) => Redirect::see_other(cx.route(LOGIN_PATH)),
|
||||
Err(_) => Page::new(request)
|
||||
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(Lc::t("error-token-invalid", &LOCALES_USER)),
|
||||
)
|
||||
.with_child(PasswordResetConfirmForm::new().with_error(error))
|
||||
.render()
|
||||
.await
|
||||
.into_response(),
|
||||
.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())
|
||||
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>(())
|
||||
}
|
||||
|
|
@ -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,
|
||||
|
|
|
|||
353
extensions/pagetop-user/src/identity.rs
Normal file
353
extensions/pagetop-user/src/identity.rs
Normal 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(¤t)).is_ok());
|
||||
assert!(username("Eva Pérez", IdentityPolicy::Strict, Some(¤t)).is_err());
|
||||
}
|
||||
|
||||
#[pagetop::test]
|
||||
async fn emails_keep_their_case_and_compare_without_it() {
|
||||
let email = email(" Ana@Example.COM ").unwrap();
|
||||
assert_eq!(email.value, "Ana@Example.COM");
|
||||
assert_eq!(email.key, "ana@example.com");
|
||||
assert_eq!(email_key("ANA@example.com "), email.key);
|
||||
let too_long = format!("{}@example.com", "a".repeat(250));
|
||||
for invalid in [
|
||||
"",
|
||||
"ana",
|
||||
"ana@",
|
||||
"Ana <ana@example.com>",
|
||||
too_long.as_str(),
|
||||
] {
|
||||
assert!(
|
||||
matches!(super::email(invalid), Err(AuthError::InvalidEmail)),
|
||||
"{invalid:?} must be rejected"
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -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(
|
||||
|
|
|
|||
|
|
@ -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,6 +53,35 @@ 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.
|
||||
|
|
@ -63,7 +94,10 @@ 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-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.
|
||||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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,6 +53,35 @@ 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.
|
||||
|
|
@ -63,7 +94,10 @@ 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-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.
|
||||
|
|
@ -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.
|
||||
|
|
|
|||
210
extensions/pagetop-user/src/mail.rs
Normal file
210
extensions/pagetop-user/src/mail.rs
Normal 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("<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}"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
@ -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,
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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(())
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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,13 +310,9 @@ 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)
|
||||
if !rows.is_empty() {
|
||||
role_permission::Entity::insert_many(rows)
|
||||
.exec_without_returning(txn)
|
||||
.await?;
|
||||
}
|
||||
Ok(())
|
||||
|
|
|
|||
|
|
@ -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(¤t.username_key),
|
||||
)?;
|
||||
let email = identity::email(data.email)?;
|
||||
// El idioma y la zona horaria que no se aplican tampoco se ofrecen en el formulario, así que no
|
||||
// llegan: se conserva lo guardado por si se vuelven a aplicar.
|
||||
let language = if user_language_applies() {
|
||||
|
|
@ -261,7 +319,7 @@ pub(crate) async fn update_user(user_id: i32, data: UserUpdateData<'_>) -> Resul
|
|||
let timezone = if user_timezone_applies() {
|
||||
let timezone = match validate_timezone(data.timezone) {
|
||||
Err(AuthError::InvalidTimezone) => {
|
||||
keep_current_timezone(user_id, data.timezone).await?
|
||||
keep_current_timezone(data.timezone, current.timezone.as_deref())?
|
||||
}
|
||||
result => result?,
|
||||
};
|
||||
|
|
@ -270,6 +328,7 @@ pub(crate) async fn update_user(user_id: i32, data: UserUpdateData<'_>) -> Resul
|
|||
ActiveValue::NotSet
|
||||
};
|
||||
let theme = validate_theme(data.theme)?;
|
||||
validate_display_name(data.display_name)?;
|
||||
// El navegador envía los saltos de línea de un `<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));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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),
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue