🔒️ Protección CSRF y límite de logins por IP

- CSRF sin tokens en el núcleo: se rechazan con 403 las peticiones que
  cambian estado si el navegador indica otro origen (`Sec-Fetch-Site`, y
  `Origin` frente a `Host`), con el criterio de Go. Sin interruptor.
- Nuevo `[server] trusted_origins`, validado y normalizado al arrancar.
- (user): `max_ip_failed_logins` limita por IP los logins fallidos; el
  intento se anota antes de Argon2 para que no se salte en paralelo.
- (user): avisos para la página siguiente tras registro, verificación,
  restablecimiento de contraseña y cambio de email.
- `flows.rs` ignora las marcas de componentes aplazados al comparar.
This commit is contained in:
Manuel Cillero 2026-11-02 14:34:05 +01:00
parent c9fdc7afc7
commit 574010374d
19 changed files with 639 additions and 35 deletions

View file

@ -149,8 +149,12 @@ por intentos fallidos (`max_failed_logins`), como los del inicio de sesión.
Para que nadie pueda usar la aplicación para enviar correos a direcciones ajenas, las recuperaciones
de contraseña y los cambios de dirección se limitan por cuenta (`max_password_resets` y
`max_email_changes`), y ellos y los registros, también por dirección IP (`max_ip_requests`). Detrás
de un *proxy* inverso, el límite por IP requiere configurar `server.client_ip_header`.
`max_email_changes`), y ellos y los registros, también por dirección IP (`max_ip_requests`).
Los inicios de sesión fallidos se limitan también por dirección IP (`max_ip_failed_logins`), para
frenar a quien prueba unas pocas contraseñas habituales en muchas cuentas sin llegar a bloquear
ninguna. Detrás de un *proxy* inverso, los límites por IP requieren configurar
`server.client_ip_header`.
## Créditos

View file

@ -19,6 +19,7 @@ base_url = "https://example.com/"
require_email_verification = true
max_failed_logins = 3
max_ip_requests = 3
max_ip_failed_logins = 3
max_email_changes = 2
# Costes mínimos de Argon2id: las pruebas cifran muchas contraseñas.

View file

@ -126,6 +126,30 @@ pub struct UserSettings {
/// dirección IP: cada una deja de contar al cumplirse este tiempo.
#[default = 3_600]
pub ip_request_window_secs: i64,
/// Inicios de sesión fallidos que se admiten desde una misma dirección IP en
/// [`ip_failed_login_window_secs`].
///
/// Complementa a [`max_failed_logins`], que bloquea una cuenta tras varios fallos: sin este
/// límite, cualquiera podría probar unas pocas contraseñas habituales en muchas cuentas
/// distintas sin llegar a bloquear ninguna. Alcanzado el límite, el formulario rechaza los
/// intentos de esa dirección, sin comprobar la contraseña, hasta que el fallo más antiguo de
/// los contados deja de contar. Los accesos correctos no cuentan ni ponen el recuento a cero.
/// Las direcciones IPv6 cuentan por su red `/64`.
///
/// Como en [`max_ip_requests`], la dirección es la de
/// [`pagetop::web::HttpRequest::client_ip()`], las peticiones de dirección desconocida no se
/// limitan, y con varias instancias el límite es por instancia. Con `0` no hay límite.
///
/// [`ip_failed_login_window_secs`]: Self::ip_failed_login_window_secs
/// [`max_failed_logins`]: Self::max_failed_logins
/// [`max_ip_requests`]: Self::max_ip_requests
/// [`pagetop::web::HttpRequest::client_ip()`]: pagetop::web::HttpRequest::client_ip
#[default = 30]
pub max_ip_failed_logins: u32,
/// Periodo en segundos, hacia atrás desde cada intento, en el que se cuentan los inicios de
/// sesión fallidos de una misma dirección IP.
#[default = 900]
pub ip_failed_login_window_secs: i64,
/// Sesiones, en la subsección `[user.session]`.
pub session: SessionSettings,

View file

@ -486,7 +486,11 @@ pub(crate) async fn email_confirm_post(
match auth::confirm_email_change(uid, &token).await {
Ok(()) => {
let cx = Context::new(request);
Redirect::see_other(cx.route(PROFILE_PATH)).into_response()
Redirect::see_other(cx.route(PROFILE_PATH)).with_message(
&cx,
MessageLevel::Info,
Lc::t("msg-email-changed", &LOCALES_USER),
)
}
Err(AuthError::EmailTaken) => {
let title = Lc::t("title-confirm-email-change", &LOCALES_USER);

View file

@ -87,7 +87,16 @@ pub async fn login_post(
) -> Response {
let cx = Context::new(request.clone());
let next = waypoint.or(cx.route("/"));
let result = auth::login(&form.username, &form.password, form.remember).await;
// Una dirección que ya ha fallado demasiadas veces no llega a comprobar la contraseña (Argon2).
let result = if throttle::allow_login(&request) {
let result = auth::login(&form.username, &form.password, form.remember).await;
if !matches!(result, Err(AuthError::InvalidCredentials)) {
throttle::forget_login(&request);
}
result
} else {
Err(AuthError::TooManyRequests)
};
match result {
Ok(sid) => {
let cookie = session::build_cookie(&sid, form.remember);
@ -98,6 +107,7 @@ pub async fn login_post(
AuthError::AccountBlocked => "error-account-blocked",
AuthError::AccountPending => "error-account-pending",
AuthError::AccountLocked => "error-account-locked",
AuthError::TooManyRequests => "error-too-many-requests",
_ => "error-invalid-credentials",
};
Page::new(request)
@ -190,7 +200,11 @@ pub async fn register_post(
)
.await
}
Ok(_) => Redirect::see_other(cx.route(LOGIN_PATH)),
Ok(_) => Redirect::see_other(cx.route(LOGIN_PATH)).with_message(
&cx,
MessageLevel::Info,
Lc::t("msg-account-created", &LOCALES_USER),
),
Err(err) => Page::new(request)
.with_title(Lc::t("title-register", &LOCALES_USER))
.with_child(
@ -326,7 +340,11 @@ pub async fn password_reset_confirm_post(
}
.await;
match result {
Ok(()) => Redirect::see_other(cx.route(LOGIN_PATH)),
Ok(()) => Redirect::see_other(cx.route(LOGIN_PATH)).with_message(
&cx,
MessageLevel::Info,
Lc::t("msg-password-reset-done", &LOCALES_USER),
),
Err(err) => {
let error = match err {
AuthError::InvalidToken => Lc::t("error-token-invalid", &LOCALES_USER),
@ -407,7 +425,11 @@ pub async fn verify_email_post(
}
.await;
match result {
Ok(()) => Redirect::see_other(cx.route(LOGIN_PATH)),
Ok(()) => Redirect::see_other(cx.route(LOGIN_PATH)).with_message(
&cx,
MessageLevel::Info,
Lc::t("msg-email-verified", &LOCALES_USER),
),
Err(_) => ErrorPage::NotFound(Some(request)).into_response(),
}
}

View file

@ -150,8 +150,12 @@ por intentos fallidos (`max_failed_logins`), como los del inicio de sesión.
Para que nadie pueda usar la aplicación para enviar correos a direcciones ajenas, las recuperaciones
de contraseña y los cambios de dirección se limitan por cuenta (`max_password_resets` y
`max_email_changes`), y ellos y los registros, también por dirección IP (`max_ip_requests`). Detrás
de un *proxy* inverso, el límite por IP requiere configurar `server.client_ip_header`.
`max_email_changes`), y ellos y los registros, también por dirección IP (`max_ip_requests`).
Los inicios de sesión fallidos se limitan también por dirección IP (`max_ip_failed_logins`), para
frenar a quien prueba unas pocas contraseñas habituales en muchas cuentas sin llegar a bloquear
ninguna. Detrás de un *proxy* inverso, los límites por IP requieren configurar
`server.client_ip_header`.
*/
use pagetop::prelude::*;

View file

@ -74,6 +74,11 @@ msg-email-change-pending =
msg-confirm-email-change = Press the button to use this email address in your account.
msg-account-created = Your account has been created. You can now sign in.
msg-email-verified = Your email address has been confirmed.
msg-password-reset-done = Your password has been changed. Sign in with the new one.
msg-email-changed = Your email address has been changed.
# **< Emails >**
mail-greeting = Hello { $username },

View file

@ -74,6 +74,11 @@ msg-email-change-pending =
msg-confirm-email-change = Pulsa el botón para usar esta dirección de correo en tu cuenta.
msg-account-created = Tu cuenta se ha creado. Ya puedes iniciar sesión.
msg-email-verified = Tu dirección de correo se ha confirmado.
msg-password-reset-done = Tu contraseña se ha cambiado. Inicia sesión con la nueva.
msg-email-changed = Tu dirección de correo se ha cambiado.
# **< Correos >**
mail-greeting = Hola, { $username }:

View file

@ -1,4 +1,5 @@
//! Límite de solicitudes por dirección IP (`user.max_ip_requests`).
//! Límites de solicitudes por dirección IP: las que envían un correo o crean una cuenta
//! (`user.max_ip_requests`) y los inicios de sesión fallidos (`user.max_ip_failed_logins`).
use pagetop::prelude::*;
@ -15,12 +16,20 @@ struct Requests {
purged_at: Instant,
}
static REQUESTS: LazyLock<Mutex<Requests>> = LazyLock::new(|| {
Mutex::new(Requests {
by_ip: HashMap::new(),
purged_at: Instant::now(),
// Cada límite lleva su propia cuenta.
type Log = LazyLock<Mutex<Requests>>;
const fn new_log() -> Log {
LazyLock::new(|| {
Mutex::new(Requests {
by_ip: HashMap::new(),
purged_at: Instant::now(),
})
})
});
}
static REQUESTS: Log = new_log();
static FAILED_LOGINS: Log = new_log();
/// Anota una solicitud de la dirección del cliente y devuelve si se admite, según
/// [`max_ip_requests`](crate::config::UserSettings::max_ip_requests).
@ -31,14 +40,12 @@ pub(crate) fn allow(request: &HttpRequest) -> bool {
let Some(ip) = request.client_ip() else {
return true;
};
let window =
StdDuration::from_secs(u64::try_from(SETTINGS.ip_request_window_secs).unwrap_or(0));
let allowed = allow_at(
&mut REQUESTS.lock().unwrap_or_else(PoisonError::into_inner),
&mut lock(&REQUESTS),
network(ip),
Instant::now(),
SETTINGS.max_ip_requests,
window,
window(SETTINGS.ip_request_window_secs),
);
if !allowed {
trace::warn!("Request limit reached for address {ip}");
@ -46,6 +53,44 @@ pub(crate) fn allow(request: &HttpRequest) -> bool {
allowed
}
/// Anota un intento de inicio de sesión de la dirección del cliente y devuelve si se admite, según
/// [`max_ip_failed_logins`](crate::config::UserSettings::max_ip_failed_logins).
///
/// El intento se anota antes de comprobar la contraseña, para que varios intentos simultáneos no
/// puedan superar el límite; si no resulta fallido, se retira con [`forget_login()`].
pub(crate) fn allow_login(request: &HttpRequest) -> bool {
let Some(ip) = request.client_ip() else {
return true;
};
let allowed = allow_at(
&mut lock(&FAILED_LOGINS),
network(ip),
Instant::now(),
SETTINGS.max_ip_failed_logins,
window(SETTINGS.ip_failed_login_window_secs),
);
if !allowed {
trace::warn!("Failed login limit reached for address {ip}");
}
allowed
}
/// Retira un intento anotado por [`allow_login()`] que no ha resultado fallido.
pub(crate) fn forget_login(request: &HttpRequest) {
if let Some(ip) = request.client_ip() {
forget_at(&mut lock(&FAILED_LOGINS), network(ip));
}
}
fn lock(log: &Log) -> std::sync::MutexGuard<'_, Requests> {
log.lock().unwrap_or_else(PoisonError::into_inner)
}
fn window(secs: i64) -> StdDuration {
StdDuration::from_secs(u64::try_from(secs).unwrap_or(0))
}
// Anota la solicitud si se admite.
fn allow_at(
requests: &mut Requests,
ip: IpAddr,
@ -76,6 +121,13 @@ fn allow_at(
true
}
// Retira la solicitud más reciente de la dirección. Todas cuentan igual, así que da lo mismo cuál.
fn forget_at(requests: &mut Requests, ip: IpAddr) {
if let Some(times) = requests.by_ip.get_mut(&ip) {
times.pop_back();
}
}
// Una dirección IPv6 cuenta por su red `/64`: un mismo equipo o red local suele disponer de una red
// entera y podría cambiar de dirección en cada solicitud.
fn network(ip: IpAddr) -> IpAddr {
@ -121,6 +173,18 @@ mod tests {
assert!(!allow_at(&mut log, ip("192.0.2.1"), at(61), 2, WINDOW));
}
#[pagetop::test]
async fn forgotten_requests_free_their_place() {
let start = Instant::now();
let mut log = requests(start);
assert!(allow_at(&mut log, ip("192.0.2.1"), start, 1, WINDOW));
forget_at(&mut log, ip("192.0.2.1"));
assert!(allow_at(&mut log, ip("192.0.2.1"), start, 1, WINDOW));
assert!(!allow_at(&mut log, ip("192.0.2.1"), start, 1, WINDOW));
// Unknown addresses are ignored.
forget_at(&mut log, ip("192.0.2.2"));
}
#[pagetop::test]
async fn zero_maximum_never_limits() {
let start = Instant::now();

View file

@ -1,7 +1,8 @@
// End-to-end account flows against a real database. `config/common.toml` gives these tests an
// in-memory SQLite database with a single connection, the memory mail transport, email
// verification on sign-up, `max_failed_logins = 3`, `max_ip_requests = 3` and
// `max_email_changes = 2` (`max_password_resets` keeps its default, 3).
// verification on sign-up, `max_failed_logins = 3`, `max_ip_requests = 3`,
// `max_ip_failed_logins = 3` and `max_email_changes = 2` (`max_password_resets` keeps its
// default, 3).
//
// Every scenario shares the same database, so they run one after another in a single test (and a
// single runtime, which also keeps the database connection alive). Each one uses its own accounts
@ -195,6 +196,7 @@ async fn account_flows() {
email_changes_are_limited_by_account(&client).await;
password_resets_are_limited_by_account(&client).await;
requests_are_limited_by_address(&client).await;
failed_logins_are_limited_by_address(&client).await;
}
async fn registration_requires_confirming_the_address(client: &Client) {
@ -223,6 +225,10 @@ async fn registration_requires_confirming_the_address(client: &Client) {
let reply = client.post(path(&verify), "", None).await;
assert_eq!(reply.status, Status::SEE_OTHER);
assert_eq!(path(reply.location()), "/user/login");
// The login page tells so.
let flash = reply.header("set-cookie").split(';').next().unwrap();
let page = client.get("/user/login", Some(flash)).await;
assert!(page.body.contains("Your email address has been confirmed"));
assert!(client.login("ana", "ana-password").await.is_some());
assert!(
client
@ -235,6 +241,21 @@ async fn registration_requires_confirming_the_address(client: &Client) {
assert_eq!(client.get(&verify, None).await.status, Status::NOT_FOUND);
}
// Deferred components leave a mark (`<!-- placeholder ... -->`) with a value of its own on every
// page, so two answers are never identical byte for byte.
fn without_marks(body: &str) -> String {
let mut rest = body;
let mut out = String::with_capacity(body.len());
while let Some(start) = rest.find("<!-- placeholder ") {
out.push_str(&rest[..start]);
rest = rest[start..]
.split_once(" -->")
.map_or("", |(_, after)| after);
}
out.push_str(rest);
out
}
async fn password_reset_links_are_single_use(client: &Client) {
verified_account(client, "bea", "bea@example.com", "bea-password").await;
@ -246,7 +267,7 @@ async fn password_reset_links_are_single_use(client: &Client) {
.post("/user/password/reset", "email=bea%40example.com", None)
.await;
assert_eq!(unknown.status, Status::OK);
assert_eq!(unknown.body, reply.body);
assert_eq!(without_marks(&unknown.body), without_marks(&reply.body));
no_mail_to("nobody@example.com").await;
let reset = link(&mail_to("bea@example.com").await, "/user/password/reset/");
@ -745,3 +766,34 @@ async fn requests_are_limited_by_address(client: &Client) {
let reply = client.send(register([192, 0, 2, 10])).await;
assert!(!reply.body.contains("Too many requests"));
}
async fn failed_logins_are_limited_by_address(client: &Client) {
verified_account(client, "iris", "iris@example.com", "iris-password").await;
let login = |ip: [u8; 4], username: &str, password: &str| {
web::test::TestRequest::post()
.with_extension(web::ConnectInfo(SocketAddr::from((ip, 4711))))
.uri("/user/login")
.form(form(&[("username", username), ("password", password)]))
};
// One guess on each of several accounts: none of them gets locked.
for username in ["iris", "nobody", "carla"] {
let reply = client
.send(login([192, 0, 2, 20], username, "123456"))
.await;
assert_eq!(reply.status, Status::OK);
assert!(!reply.body.contains("Too many requests"));
}
// The address is refused, even with the right password.
let reply = client
.send(login([192, 0, 2, 20], "iris", "iris-password"))
.await;
assert_eq!(reply.status, Status::OK);
assert!(reply.body.contains("Too many requests"));
// Other addresses keep their own count, and the account was never locked.
let reply = client
.send(login([192, 0, 2, 21], "iris", "iris-password"))
.await;
assert_eq!(reply.status, Status::SEE_OTHER);
}