From 98a576840687ba07f407b1c8f61b02ae5ce59b37 Mon Sep 17 00:00:00 2001 From: Manuel Cillero Date: Mon, 12 Oct 2026 08:34:14 +0200 Subject: [PATCH] =?UTF-8?q?=E2=9C=A8=20(user):=20Caducidad=20de=20sesi?= =?UTF-8?q?=C3=B3n=20por=20inactividad?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - La sesión caduca tras un tiempo sin uso, no desde el login, y se prorroga como mucho cada `write_interval_secs`; la cookie de "recordarme" se renueva con ella. - Nueva subsección `[user.session]` con `cookie_name` ("pagetop"), `secure_cookie`, `idle_secs`, `remember_idle_secs` y `write_interval_secs`. --- extensions/pagetop-user/src/config.rs | 99 ++++---- extensions/pagetop-user/src/entity/session.rs | 1 + .../pagetop-user/src/handlers/account.rs | 5 +- extensions/pagetop-user/src/handlers/auth.rs | 2 +- extensions/pagetop-user/src/middleware.rs | 23 +- .../m20260629_000005_create_sessions.rs | 3 + extensions/pagetop-user/src/session.rs | 230 ++++++++++++++---- 7 files changed, 263 insertions(+), 100 deletions(-) diff --git a/extensions/pagetop-user/src/config.rs b/extensions/pagetop-user/src/config.rs index 5975c638..f36d987c 100644 --- a/extensions/pagetop-user/src/config.rs +++ b/extensions/pagetop-user/src/config.rs @@ -16,35 +16,36 @@ use std::sync::LazyLock; include_config!(CONFIG_USER: UserTopConfig => [ // Política de registro y verificación. - "user.allow_registration" => true, - "user.require_email_verification" => false, + "user.allow_registration" => true, + "user.require_email_verification" => false, // Sesiones. - "user.session_cookie_name" => "pgt_session", - "user.session_ttl_secs" => 1_209_600_i64, // 14 días - "user.session_idle_ttl_secs" => 7_200_i64, // 2 horas - "user.secure_cookie" => false, + "user.session.cookie_name" => "pagetop", + "user.session.secure_cookie" => false, + "user.session.idle_secs" => 7_200_i64, // 2 horas + "user.session.remember_idle_secs" => 1_209_600_i64, // 14 días + "user.session.write_interval_secs" => 60_i64, // 1 minuto // Anti-fuerza-bruta. - "user.max_failed_logins" => 5_i32, - "user.failed_login_window_secs" => 900_i64, // 15 min - "user.locked_for_secs" => 600_i64, // 10 min + "user.max_failed_logins" => 5_i32, + "user.failed_login_window_secs" => 900_i64, // 15 min + "user.locked_for_secs" => 600_i64, // 10 min // Contraseñas (Argon2id). - "user.password.argon2_m_cost" => 19456_u32, - "user.password.argon2_t_cost" => 2_u32, - "user.password.argon2_p_cost" => 1_u32, - "user.password.min_length" => 8_u64, + "user.password.argon2_m_cost" => 19456_u32, + "user.password.argon2_t_cost" => 2_u32, + "user.password.argon2_p_cost" => 1_u32, + "user.password.min_length" => 8_u64, // Semilla del primer administrador. - "user.seed.admin_username" => "admin", - "user.seed.admin_email" => "admin@example.com", + "user.seed.admin_username" => "admin", + "user.seed.admin_email" => "admin@example.com", // Listados de administración (usuarios, roles...). - "user.admin.list_page_size" => 20_u64, + "user.admin.list_page_size" => 20_u64, // Modo de login. - "user.login_strict" => false, + "user.login_strict" => false, ]); // **< UserTopConfig >****************************************************************************** @@ -63,23 +64,20 @@ pub static SETTINGS: LazyLock = LazyLock::new(|| CONFIG_USER.user.clon // **< Settings >*********************************************************************************** /// Ajustes de la extensión `pagetop-user`, accesibles en la sección `[user]` del TOML. -#[derive(Clone, Debug, Default, Deserialize)] +#[derive(Clone, Debug, Deserialize)] pub struct Settings { // Política de registro y verificación. pub allow_registration: bool, pub require_email_verification: bool, - // Sesiones. - pub session_cookie_name: String, - pub session_ttl_secs: i64, - pub session_idle_ttl_secs: i64, - pub secure_cookie: bool, - // Anti-fuerza-bruta. pub max_failed_logins: i32, pub failed_login_window_secs: i64, pub locked_for_secs: i64, + // Sesiones. + pub session: SessionConfig, + // Contraseñas. pub password: PasswordConfig, @@ -94,6 +92,40 @@ pub struct Settings { pub login_strict: bool, } +/// Ajustes de la sección `[user.session]`. +#[derive(Clone, Debug, Deserialize)] +pub struct SessionConfig { + /// Nombre de la cookie de sesión. + pub cookie_name: String, + /// Marca la cookie de sesión como `Secure` (sólo HTTPS). Debe activarse en producción. + pub secure_cookie: bool, + /// Segundos sin uso tras los que caduca una sesión iniciada sin "recordarme". El tiempo se + /// cuenta desde la última petición, con la precisión que fija + /// [`write_interval_secs`](Self::write_interval_secs). + pub idle_secs: i64, + /// Segundos sin uso tras los que caduca una sesión iniciada con "recordarme". El tiempo se + /// cuenta desde la última petición, con la precisión que fija + /// [`write_interval_secs`](Self::write_interval_secs). + pub remember_idle_secs: i64, + /// Segundos mínimos entre dos actualizaciones de la misma sesión en la base de datos. + /// + /// Cada petición de una sesión válida la prorroga, pero sólo se escribe en la base de datos + /// (y se renueva la cookie de "recordarme") si ha pasado al menos este tiempo desde la última + /// actualización. A cambio, una sesión puede caducar hasta este tiempo antes de lo configurado + /// en [`idle_secs`](Self::idle_secs) y [`remember_idle_secs`](Self::remember_idle_secs). Con + /// `0` se escribe en cada petición. + /// + /// El valor por defecto (60) sirve para la mayoría de aplicaciones. Conviene cambiarlo: + /// + /// - **Al alza** (p. ej. 180, como Drupal) si hay muchos usuarios simultáneos o la base de + /// datos es remota o lenta, para reducir las escrituras. + /// - **A la baja** (o `0`) si las sesiones caducan tras pocos minutos sin uso y ese margen de + /// adelanto no es aceptable. + /// + /// Debe ser siempre muy inferior a `idle_secs`. + pub write_interval_secs: i64, +} + /// Ajustes de la sección `[user.password]`. #[derive(Clone, Debug, Deserialize)] pub struct PasswordConfig { @@ -103,19 +135,8 @@ pub struct PasswordConfig { pub min_length: usize, } -impl Default for PasswordConfig { - fn default() -> Self { - PasswordConfig { - argon2_m_cost: 19456, - argon2_t_cost: 2, - argon2_p_cost: 1, - min_length: 8, - } - } -} - /// Ajustes de la sección `[user.seed]`. -#[derive(Clone, Debug, Default, Deserialize)] +#[derive(Clone, Debug, Deserialize)] pub struct SeedConfig { pub admin_username: String, pub admin_email: String, @@ -129,12 +150,6 @@ pub struct AdminConfig { pub list_page_size: u64, } -impl Default for AdminConfig { - fn default() -> Self { - AdminConfig { list_page_size: 20 } - } -} - // **< Preferencias del usuario >******************************************************************* // Si se aplica el idioma propio del usuario: no con `lang_negotiation = "ConfigOnly"`, que usa diff --git a/extensions/pagetop-user/src/entity/session.rs b/extensions/pagetop-user/src/entity/session.rs index 105dd2f3..31ff1296 100644 --- a/extensions/pagetop-user/src/entity/session.rs +++ b/extensions/pagetop-user/src/entity/session.rs @@ -7,6 +7,7 @@ pub struct Model { pub sid: String, pub user_id: i32, pub data: String, + pub remember: bool, pub last_activity_at: Option, pub expires_at: DateTimeUtc, pub created_at: DateTimeUtc, diff --git a/extensions/pagetop-user/src/handlers/account.rs b/extensions/pagetop-user/src/handlers/account.rs index 1077c9e2..90a18848 100644 --- a/extensions/pagetop-user/src/handlers/account.rs +++ b/extensions/pagetop-user/src/handlers/account.rs @@ -342,10 +342,7 @@ pub(crate) async fn password_post( let sid = session::extract_sid(Some(request.headers())); let result = match password::passwords_match(&form.password, &form.confirm_password) { - Ok(()) => { - auth::change_own_password(id, &form.current_password, &form.password, sid.as_deref()) - .await - } + Ok(()) => auth::change_own_password(id, &form.current_password, &form.password, sid).await, Err(err) => Err(err), }; diff --git a/extensions/pagetop-user/src/handlers/auth.rs b/extensions/pagetop-user/src/handlers/auth.rs index 42da1ace..1cfac9cf 100644 --- a/extensions/pagetop-user/src/handlers/auth.rs +++ b/extensions/pagetop-user/src/handlers/auth.rs @@ -117,7 +117,7 @@ pub async fn login_post( pub async fn logout_post(request: HttpRequest) -> Response { let cx = Context::new(request.clone()); if let Some(sid) = session::extract_sid(Some(request.headers())) { - auth::logout(&sid).await.ok(); + auth::logout(sid).await.ok(); } let expiry = session::expiry_cookie(); if request.is_htmx() { diff --git a/extensions/pagetop-user/src/middleware.rs b/extensions/pagetop-user/src/middleware.rs index d72dff07..ff81b280 100644 --- a/extensions/pagetop-user/src/middleware.rs +++ b/extensions/pagetop-user/src/middleware.rs @@ -15,18 +15,37 @@ use crate::session; /// /// - Siempre inserta [`pagetop::auth::CurrentUser`] (anónimo o autenticado). /// - Si hay sesión activa, inserta también el [`Account`] con roles y permisos. +/// - Si se ha prorrogado una sesión iniciada con "recordarme", renueva su cookie en la respuesta. pub(crate) async fn session_middleware( mut req: web::Request, next: web::middleware::Next, ) -> Response { - let (current_user, maybe_account) = session::resolve_session(req.headers()).await; + let (current_user, maybe_account, renewed_cookie) = + session::resolve_session(req.headers()).await; req.extensions_mut().insert(current_user); if let Some(account) = maybe_account { req.extensions_mut().insert(account); } - next.run(req).await + let mut response = next.run(req).await; + + // No se pisa una cookie que ya fije el handler (p. ej. la de expiración al cerrar sesión). + if let Some(cookie) = renewed_cookie + && !response + .headers() + .contains_key(web::http::header::SET_COOKIE) + { + match web::http::HeaderValue::try_from(cookie) { + Ok(value) => { + response + .headers_mut() + .insert(web::http::header::SET_COOKIE, value); + } + Err(_) => trace::warn!("session: invalid renewed cookie, header discarded"), + } + } + response } // **< check_rbac_permission >********************************************************************** diff --git a/extensions/pagetop-user/src/migration/m20260629_000005_create_sessions.rs b/extensions/pagetop-user/src/migration/m20260629_000005_create_sessions.rs index 943166f6..bdf4a39d 100644 --- a/extensions/pagetop-user/src/migration/m20260629_000005_create_sessions.rs +++ b/extensions/pagetop-user/src/migration/m20260629_000005_create_sessions.rs @@ -15,6 +15,8 @@ impl MigrationTrait for Migration { .col(integer(Sessions::UserId)) // Datos de sesión en JSON (flash messages, etc.) .col(text(Sessions::Data).default("{}")) + // Iniciada con "recordarme": determina el tiempo de inactividad permitido. + .col(boolean(Sessions::Remember).default(false)) .col(timestamp_null(Sessions::LastActivityAt)) .col(timestamp(Sessions::ExpiresAt).default(Expr::current_timestamp())) .col(timestamp(Sessions::CreatedAt).default(Expr::current_timestamp())) @@ -65,6 +67,7 @@ pub enum Sessions { Sid, UserId, Data, + Remember, LastActivityAt, ExpiresAt, CreatedAt, diff --git a/extensions/pagetop-user/src/session.rs b/extensions/pagetop-user/src/session.rs index 36923f55..7748fdc7 100644 --- a/extensions/pagetop-user/src/session.rs +++ b/extensions/pagetop-user/src/session.rs @@ -1,9 +1,8 @@ -//! Gestión de sesiones de usuario (creación, carga, destrucción). +//! Gestión de sesiones de usuario (creación, carga, prórroga y destrucción). use pagetop::prelude::*; -use pagetop_seaorm::db::{ - ActiveModelTrait, ColumnTrait, DbErr, EntityTrait, QueryFilter, Set, dbconn, -}; +use pagetop_seaorm::db::query::Expr; +use pagetop_seaorm::db::{ColumnTrait, DbErr, EntityTrait, QueryFilter, Set, dbconn}; use crate::AUTHENTICATED_ROLE_ID; use crate::account::{Account, PermissionSet, UserStatus}; @@ -34,17 +33,17 @@ fn bytes_to_hex(bytes: &[u8]) -> String { /// Construye el valor de la cabecera `Set-Cookie` para la cookie de sesión. pub fn build_cookie(sid: &str, remember: bool) -> String { let mut cookie = util::join!( - &SETTINGS.session_cookie_name, + &SETTINGS.session.cookie_name, "=", sid, "; HttpOnly; SameSite=Lax; Path=/" ); - if SETTINGS.secure_cookie { + if SETTINGS.session.secure_cookie { cookie.push_str("; Secure"); } if remember { cookie.push_str("; Max-Age="); - cookie.push_str(&SETTINGS.session_ttl_secs.to_string()); + cookie.push_str(&SETTINGS.session.remember_idle_secs.to_string()); } cookie } @@ -52,61 +51,70 @@ pub fn build_cookie(sid: &str, remember: bool) -> String { /// Construye la cookie de expiración (Max-Age=0) para borrar la sesión del navegador. pub fn expiry_cookie() -> String { util::join!( - &SETTINGS.session_cookie_name, + &SETTINGS.session.cookie_name, "=; HttpOnly; SameSite=Lax; Path=/; Max-Age=0" ) } -/// Extrae el session ID de las cabeceras HTTP de la petición, si existe. -pub fn extract_sid(headers: Option<&web::http::HeaderMap>) -> Option { - let cookie_str = headers?.get(web::http::header::COOKIE)?.to_str().ok()?; - - let name = SETTINGS.session_cookie_name.as_str(); - for part in cookie_str.split(';') { - let part = part.trim(); - if let Some(value) = part.strip_prefix(name).and_then(|s| s.strip_prefix('=')) { - return Some(value.trim().to_owned()); - } - } - None +/// Extrae el session ID de las cabeceras HTTP de la petición, si existe y tiene el formato de los +/// que genera [`generate_sid`]. +pub fn extract_sid(headers: Option<&web::http::HeaderMap>) -> Option<&str> { + let name = SETTINGS.session.cookie_name.as_str(); + // Con HTTP/2 el navegador puede repartir las cookies en varias cabeceras `cookie`. + headers? + .get_all(web::http::header::COOKIE) + .iter() + .filter_map(|value| value.to_str().ok()) + .flat_map(|cookies| cookies.split(';')) + .filter_map(|part| part.trim().strip_prefix(name)?.strip_prefix('=')) + .map(str::trim) + // Descarta valores que no pueden ser un session ID sin llegar a consultar la base de datos. + .find(|sid| sid.len() == 64 && sid.bytes().all(|b| b.is_ascii_hexdigit())) } // **< resolve_session >**************************************************************************** -/// Lee la cookie de sesión de las cabeceras y resuelve el par `(CurrentUser, Option)`. +/// Lee la cookie de sesión de las cabeceras y resuelve la terna +/// `(CurrentUser, Option, Option)` de [`load_user_from_session`]. /// -/// Si no hay cookie o la sesión ha expirado, devuelve `(CurrentUser::anonymous(), None)`. -/// Se llama desde el middleware de sesión, que es async. -pub async fn resolve_session(headers: &web::http::HeaderMap) -> (CurrentUser, Option) { +/// Si no hay una cookie de sesión válida, o la sesión no existe o ha expirado, devuelve +/// `(CurrentUser::anonymous(), None, None)`. Se llama desde el middleware de sesión, que es async. +pub async fn resolve_session( + headers: &web::http::HeaderMap, +) -> (CurrentUser, Option, Option) { let Some(sid) = extract_sid(Some(headers)) else { - return (CurrentUser::anonymous(), None); + return (CurrentUser::anonymous(), None, None); }; - load_user_from_session(&sid).await + load_user_from_session(sid).await } // **< load_user_from_session >********************************************************************* -/// Carga el par `(CurrentUser, Option)` a partir de un session ID. +/// Carga el usuario de una sesión a partir de su session ID y, si ha pasado al menos +/// `write_interval_secs` desde la última vez, prorroga la sesión por haberse usado. /// -/// Devuelve `(CurrentUser::anonymous(), None)` si la sesión no existe o ha expirado. -pub async fn load_user_from_session(sid: &str) -> (CurrentUser, Option) { +/// Devuelve la terna `(CurrentUser, Option, Option)`, cuyo tercer elemento es la +/// cabecera `Set-Cookie` que renueva la cookie persistente cuando se prorroga una sesión iniciada +/// con "recordarme". Devuelve `(CurrentUser::anonymous(), None, None)` si la sesión no existe o ha +/// expirado. +pub async fn load_user_from_session(sid: &str) -> (CurrentUser, Option, Option) { let now = Utc::now(); // Buscar sesión activa y no expirada. let Ok(Some(sess)) = session::Entity::find_by_id(sid).one(dbconn()).await else { - return (CurrentUser::anonymous(), None); + return (CurrentUser::anonymous(), None, None); }; if sess.expires_at < now { - return (CurrentUser::anonymous(), None); + return (CurrentUser::anonymous(), None, None); } // Cargar usuario con estado activo. let Ok(Some(mut user_model)) = user::Entity::find_by_id(sess.user_id).one(dbconn()).await else { - return (CurrentUser::anonymous(), None); + return (CurrentUser::anonymous(), None, None); }; if UserStatus::from_i16(user_model.status) != UserStatus::Active { - return (CurrentUser::anonymous(), None); + return (CurrentUser::anonymous(), None, None); } // Cargar roles explícitos del usuario. @@ -115,7 +123,7 @@ pub async fn load_user_from_session(sid: &str) -> (CurrentUser, Option) .all(dbconn()) .await else { - return (CurrentUser::anonymous(), None); + return (CurrentUser::anonymous(), None, None); }; let role_ids: Vec = user_role_rows.iter().map(|ur| ur.role_id).collect(); @@ -125,7 +133,7 @@ pub async fn load_user_from_session(sid: &str) -> (CurrentUser, Option) .all(dbconn()) .await else { - return (CurrentUser::anonymous(), None); + return (CurrentUser::anonymous(), None, None); }; let is_admin = user_model.is_admin; @@ -146,21 +154,32 @@ pub async fn load_user_from_session(sid: &str) -> (CurrentUser, Option) .all(dbconn()) .await else { - return (CurrentUser::anonymous(), None); + return (CurrentUser::anonymous(), None, None); }; PermissionSet::new(perm_rows.into_iter().map(|p| p.permission_key)) }; - // Actualizar last_activity_at con throttle: sólo una vez por minuto. - let throttle = Duration::minutes(1); - if sess - .last_activity_at - .map(|t| now - t > throttle) - .unwrap_or(true) - { - let mut active: session::ActiveModel = sess.into(); - active.last_activity_at = Set(Some(now)); - let _ = active.update(dbconn()).await; + let mut renewed_cookie = None; + if let Some(expires_at) = renewed_expiry( + sess.last_activity_at, + now, + idle_period(sess.remember), + Duration::seconds(SETTINGS.session.write_interval_secs), + ) { + if sess.remember { + renewed_cookie = Some(build_cookie(sid, true)); + } + // Un `UPDATE` directo, sin devolver la fila: `ActiveModel::update()` la recupera con + // `RETURNING` o, en MySQL, con una consulta adicional. + let result = session::Entity::update_many() + .col_expr(session::Column::LastActivityAt, Expr::value(now)) + .col_expr(session::Column::ExpiresAt, Expr::value(expires_at)) + .filter(session::Column::Sid.eq(sid)) + .exec(dbconn()) + .await; + if let Err(err) = result { + trace::warn!("session: failed to renew expiry: {err}"); + } } let language = user_model.language.take(); @@ -172,7 +191,29 @@ pub async fn load_user_from_session(sid: &str) -> (CurrentUser, Option) .with_timezone(timezone.as_deref()) .with_theme(theme.as_deref()); - (current_user, Some(account)) + (current_user, Some(account), renewed_cookie) +} + +// Tiempo sin uso tras el que caduca una sesión, según se iniciara o no con "recordarme". +fn idle_period(remember: bool) -> Duration { + Duration::seconds(if remember { + SETTINGS.session.remember_idle_secs + } else { + SETTINGS.session.idle_secs + }) +} + +// Nueva caducidad de una sesión usada en `now`, o `None` si se prorrogó hace menos de `interval`. +fn renewed_expiry( + last_activity: Option>, + now: DateTime, + idle: Duration, + interval: Duration, +) -> Option> { + match last_activity { + Some(t) if now - t < interval => None, + _ => Some(now + idle), + } } // **< create_session >***************************************************************************** @@ -181,16 +222,14 @@ pub async fn load_user_from_session(sid: &str) -> (CurrentUser, Option) pub async fn create_session(user_id: i32, remember: bool) -> Result { let sid = generate_sid(); let now = Utc::now(); - let ttl = Duration::seconds(SETTINGS.session_ttl_secs); - let idle = Duration::seconds(SETTINGS.session_idle_ttl_secs); - let expires_at = if remember { now + ttl } else { now + idle }; let new_session = session::ActiveModel { sid: Set(sid.clone()), user_id: Set(user_id), data: Set("{}".into()), + remember: Set(remember), last_activity_at: Set(Some(now)), - expires_at: Set(expires_at), + expires_at: Set(now + idle_period(remember)), created_at: Set(now), }; session::Entity::insert(new_session).exec(dbconn()).await?; @@ -222,3 +261,92 @@ pub async fn destroy_other_sessions(user_id: i32, keep_sid: &str) -> Result<(), .await?; Ok(()) } + +// **< Tests >************************************************************************************** + +#[cfg(test)] +mod tests { + use super::{DateTime, Duration, SETTINGS, Utc, extract_sid, renewed_expiry, web}; + + const IDLE_SECS: i64 = 7_200; + const INTERVAL_SECS: i64 = 60; + + fn at(secs: i64) -> DateTime { + DateTime::from_timestamp(1_800_000_000 + secs, 0).unwrap() + } + + fn renew(last_activity: Option, now: i64, interval: i64) -> Option> { + renewed_expiry( + last_activity.map(at), + at(now), + Duration::seconds(IDLE_SECS), + Duration::seconds(interval), + ) + } + + #[test] + fn renews_session_without_recorded_activity() { + assert_eq!(renew(None, 0, INTERVAL_SECS), Some(at(IDLE_SECS))); + } + + #[test] + fn skips_renewal_within_interval() { + assert_eq!(renew(Some(0), 30, INTERVAL_SECS), None); + assert_eq!(renew(Some(0), INTERVAL_SECS - 1, INTERVAL_SECS), None); + assert_eq!( + renew(Some(0), INTERVAL_SECS, INTERVAL_SECS), + Some(at(INTERVAL_SECS + IDLE_SECS)) + ); + } + + #[test] + fn zero_interval_renews_on_every_request() { + assert_eq!(renew(Some(0), 0, 0), Some(at(IDLE_SECS))); + } + + #[test] + fn expiry_counts_from_last_use_not_from_login() { + // A session used again after the interval gets a full idle period from that use. + let used = IDLE_SECS - 10; + assert_eq!( + renew(Some(0), used, INTERVAL_SECS), + Some(at(used + IDLE_SECS)) + ); + } + + const SID: &str = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"; + + fn cookie_headers(values: &[&str]) -> web::http::HeaderMap { + let mut headers = web::http::HeaderMap::new(); + for value in values { + let value = web::http::HeaderValue::from_str(value).unwrap(); + headers.append(web::http::header::COOKIE, value); + } + headers + } + + #[test] + fn extracts_sid_among_other_cookies() { + let name = &SETTINGS.session.cookie_name; + let headers = cookie_headers(&[&format!("a=1; {name}={SID}; b=2")]); + assert_eq!(extract_sid(Some(&headers)), Some(SID)); + } + + #[test] + fn extracts_sid_from_split_cookie_headers() { + // HTTP/2 clients may send each cookie in its own header field. + let name = &SETTINGS.session.cookie_name; + let headers = cookie_headers(&["a=1", &format!("{name}={SID}")]); + assert_eq!(extract_sid(Some(&headers)), Some(SID)); + } + + #[test] + fn skips_cookies_with_a_longer_name_or_invalid_value() { + let name = &SETTINGS.session.cookie_name; + let headers = cookie_headers(&[&format!("{name}x={SID}; {name}=bogus")]); + assert_eq!(extract_sid(Some(&headers)), None); + + let headers = cookie_headers(&[&format!("{name}=bogus; {name}={SID}")]); + assert_eq!(extract_sid(Some(&headers)), Some(SID)); + } +}