diff --git a/config/reference.toml b/config/reference.toml index 83c2b9ff..d1974e2b 100644 --- a/config/reference.toml +++ b/config/reference.toml @@ -120,6 +120,10 @@ trusted_origins = [] # Otros orígenes desde los que un navega # peticiones que cambian estado (POST, PUT...), p. ej. # ["https://app.example.com"]. Sin ellos, se rechazan con 403 # (protección CSRF). Formato: esquema://servidor[:puerto]. +secure_cookies = false # Marca las cookies como Secure, para que sólo viajen por + # HTTPS. Activar si la aplicación se sirve por HTTPS, aunque + # el HTTPS lo atienda un proxy inverso; si es por HTTP, el + # navegador no las guardaría (algunos sí en localhost). [upload] dir = "uploads" # Directorio de los archivos subidos, absoluto o relativo al @@ -338,9 +342,8 @@ login_strict = false # Dificulta que el navegador recuerde o a # credenciales en el formulario de acceso. [user.session] # Sesiones de usuario. -cookie_name = "pagetop" # Nombre de la cookie de sesión. -secure_cookie = false # Marca la cookie como Secure (sólo HTTPS). Activar en - # producción. +cookie_name = "pagetop" # Nombre de la cookie de sesión. Se marca como Secure + # según 'server.secure_cookies'. idle_secs = 7200 # Segundos sin uso tras los que caduca la sesión si no se # marca "recordarme" al acceder (2 horas). Se cuentan desde # la última petición. diff --git a/config/test.toml b/config/test.toml index b146d460..7544bea8 100644 --- a/config/test.toml +++ b/config/test.toml @@ -4,6 +4,7 @@ name = "Testing" [server] bind_port = 9000 trusted_origins = ["https://Trusted.example/"] +secure_cookies = true [upload] dir = "target/test-uploads" diff --git a/src/global.rs b/src/global.rs index d4a97dd6..bc7e13ab 100644 --- a/src/global.rs +++ b/src/global.rs @@ -281,6 +281,21 @@ pub struct ServerSettings { /// Cada origen es `esquema://servidor[:puerto]`, sin ruta. Uno no válido impide arrancar. #[serde(deserialize_with = "origins")] pub trusted_origins: Vec, + /// Marca las *cookies* de la aplicación como `Secure`, para que el navegador sólo las envíe por + /// HTTPS. + /// + /// Debe activarse cuando la aplicación se sirve por HTTPS, aunque el HTTPS lo atienda un + /// *proxy* inverso: si no, la *cookie* de una sesión iniciada viajaría también en cualquier + /// petición por HTTP sin cifrar. Afecta a las *cookies* de PageTop y a las de las extensiones + /// que usan [`web::cookie_header()`](crate::web::cookie_header), como la sesión de + /// `pagetop-user`. + /// + /// No debe activarse si la aplicación se sirve por HTTP: el navegador no guardaría las + /// *cookies* (algunos, como Chrome o Firefox, sí en `localhost`) y dejarían de funcionar el + /// inicio de sesión, los mensajes tras una redirección y los filtros recordados de los + /// listados. + #[default = false] + pub secure_cookies: bool, } // Orígenes para `trusted_origins`, tal y como los envía un navegador en la cabecera `Origin`: en diff --git a/src/response/flash.rs b/src/response/flash.rs index b56aef54..b9f8d5ce 100644 --- a/src/response/flash.rs +++ b/src/response/flash.rs @@ -7,15 +7,14 @@ use crate::core::component::{Context, MessageLevel, StatusMessage}; use crate::locale::Lc; use crate::response::ErrorPage; use crate::trace; -use crate::web::{Request, Response, http, push_percent_encoded}; +use crate::web::{Request, Response, cookie_header, http, push_percent_encoded}; use axum::middleware::Next; const COOKIE_NAME: &str = "pagetop_flash"; -// Atributos de la *cookie*. Basta con un minuto: es el tiempo de seguir una redirección. -const COOKIE_ATTRS: &str = "; Path=/; HttpOnly; SameSite=Lax; Max-Age=60"; -const EXPIRED_COOKIE: &str = "pagetop_flash=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0"; +// Duración de la *cookie*. Basta con un minuto: es el tiempo de seguir una redirección. +const COOKIE_MAX_AGE: u64 = 60; // Los navegadores admiten al menos 4096 bytes por *cookie*, contando nombre y atributos. const MAX_VALUE_LEN: usize = 3800; @@ -126,12 +125,9 @@ pub(crate) async fn keep_flash_messages(request: Request, next: Next) -> Respons for (level, text) in pending.map(|pending| pending.0).unwrap_or_default() { push_message(&mut value, level, &text); } - let cookie = if value.is_empty() { - EXPIRED_COOKIE.to_owned() - } else { - crate::util::join!(COOKIE_NAME, "=", value, COOKIE_ATTRS) - }; - if let Ok(cookie) = http::HeaderValue::from_str(&cookie) { + let max_age = if value.is_empty() { 0 } else { COOKIE_MAX_AGE }; + let cookie = cookie_header(COOKIE_NAME, &value, "/", Some(max_age)); + if let Ok(cookie) = http::HeaderValue::try_from(cookie) { response .headers_mut() .append(http::header::SET_COOKIE, cookie); diff --git a/src/web.rs b/src/web.rs index 4d0a4994..ef76e03e 100644 --- a/src/web.rs +++ b/src/web.rs @@ -45,6 +45,11 @@ //! //! Las extensiones pueden añadir las suyas; `pagetop-user`, por ejemplo, la de la sesión iniciada. //! +//! Las de PageTop y sus extensiones propias se crean con [`cookie_header()`], que les da los +//! mismos atributos: `HttpOnly`, `SameSite=Lax` y, si la aplicación se sirve por HTTPS y así se +//! indica en [`secure_cookies`](crate::global::ServerSettings::secure_cookies) de `[server]`, +//! `Secure`. +//! //! ## Sin aceptación de *cookies* //! //! PageTop y sus extensiones propias (las que se publican con él, como `pagetop-user`) están @@ -164,6 +169,10 @@ pub use routes::{Layers, Routes, StaticFiles}; mod endpoint; pub use endpoint::Endpoint; +// Cabecera `Set-Cookie` común a todas las *cookies* de PageTop y sus extensiones. +mod cookie; +pub use cookie::cookie_header; + // Estado de los listados (filtros, orden, página) recordado entre pantallas. mod remember; pub use remember::remember_query; diff --git a/src/web/cookie.rs b/src/web/cookie.rs new file mode 100644 index 00000000..c8efab02 --- /dev/null +++ b/src/web/cookie.rs @@ -0,0 +1,86 @@ +use crate::global; + +use std::fmt::Write; + +/// Devuelve el valor de una cabecera `Set-Cookie` con los atributos comunes de PageTop. +/// +/// Toda *cookie* lleva `HttpOnly`, para que el código JavaScript de la página no pueda leerla, y +/// `SameSite=Lax`, para que el navegador no la envíe en las peticiones que otros sitios hacen a la +/// aplicación, salvo cuando llevan al usuario a una de sus páginas con `GET` (al seguir un enlace, +/// por ejemplo). Lleva además `Secure` si está activado +/// [`secure_cookies`](crate::global::ServerSettings::secure_cookies) en `[server]`. +/// +/// - `name` y `value` sólo pueden contener caracteres válidos en una *cookie* (RFC 6265), y `path` +/// no puede contener `;`. La función no los comprueba ni los codifica: un `;` añadiría atributos +/// a la *cookie*. +/// - `path` es la ruta a partir de la cual el navegador envía la *cookie*, `"/"` para toda la +/// aplicación. +/// - `max_age` son los segundos que dura. Con `None` es una *cookie* de sesión, que el navegador +/// borra al cerrarse; con `Some(0)` borra la que tenga el navegador con el mismo nombre y ruta. +/// +/// Es la función que usan las *cookies* de PageTop y de sus extensiones propias, para que todas +/// sigan el mismo criterio. Cualquier *cookie* nueva debe cumplir además los criterios de +/// [*Cookies*](crate::web#cookies) para no requerir la aceptación del usuario. +/// +/// ```rust +/// # use pagetop::prelude::*; +/// let cookie = web::cookie_header("theme", "dark", "/", Some(3600)); +/// assert!(cookie.starts_with("theme=dark; Path=/; HttpOnly; SameSite=Lax")); +/// assert!(cookie.ends_with("; Max-Age=3600")); +/// ``` +pub fn cookie_header(name: &str, value: &str, path: &str, max_age: Option) -> String { + build( + name, + value, + path, + max_age, + global::SETTINGS.server.secure_cookies, + ) +} + +fn build(name: &str, value: &str, path: &str, max_age: Option, secure: bool) -> String { + let mut cookie = String::with_capacity(name.len() + value.len() + path.len() + 64); + cookie.push_str(name); + cookie.push('='); + cookie.push_str(value); + cookie.push_str("; Path="); + cookie.push_str(path); + cookie.push_str("; HttpOnly; SameSite=Lax"); + if secure { + cookie.push_str("; Secure"); + } + if let Some(secs) = max_age { + // Escribir en un `String` nunca falla. + let _ = write!(cookie, "; Max-Age={secs}"); + } + cookie +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn session_cookie_without_secure() { + assert_eq!( + build("pagetop_list_x", "q=a", "/items", None, false), + "pagetop_list_x=q=a; Path=/items; HttpOnly; SameSite=Lax" + ); + } + + #[test] + fn secure_goes_before_max_age() { + assert_eq!( + build("pagetop", "sid", "/", Some(1_209_600), true), + "pagetop=sid; Path=/; HttpOnly; SameSite=Lax; Secure; Max-Age=1209600" + ); + } + + #[test] + fn expired_cookie_keeps_secure() { + assert_eq!( + build("pagetop_flash", "", "/", Some(0), true), + "pagetop_flash=; Path=/; HttpOnly; SameSite=Lax; Secure; Max-Age=0" + ); + } +} diff --git a/src/web/remember.rs b/src/web/remember.rs index ba071f1c..67d5fb4f 100644 --- a/src/web/remember.rs +++ b/src/web/remember.rs @@ -1,7 +1,7 @@ use std::borrow::Cow; use crate::web::http::{HeaderMap, HeaderName, HeaderValue, Method, StatusCode, header}; -use crate::web::{IntoResponse, MethodRouter, Request, Response}; +use crate::web::{IntoResponse, MethodRouter, Request, Response, cookie_header}; use axum::extract::OriginalUri; use axum::middleware::{self, Next}; @@ -14,9 +14,6 @@ const NAME_LEN: usize = COOKIE_PREFIX.len() + 16; const SEC_FETCH_SITE: HeaderName = HeaderName::from_static("sec-fetch-site"); -// Atributos comunes. Sin `Max-Age` es una *cookie* de sesión. -const COOKIE_ATTRS: &str = "; HttpOnly; SameSite=Lax"; - // Estado más largo que esto no se recuerda: un listado no necesita tanto y la *cookie* viaja en // cada petición a su ruta y a las que cuelgan de ella. const MAX_STATE_LEN: usize = 1024; @@ -311,17 +308,12 @@ fn cookie_value<'a>(headers: &'a HeaderMap, name: &[u8]) -> Option<&'a [u8]> { } fn set_cookie(response: &mut Response, name: &[u8], value: &str, path: &str, expired: bool) { - let mut cookie = String::with_capacity(NAME_LEN + value.len() + path.len() + 40); - // El nombre es ASCII: el prefijo y cifras hexadecimales. - cookie.extend(name.iter().map(|&b| char::from(b))); - cookie.push('='); - cookie.push_str(value); - cookie.push_str("; Path="); - cookie.push_str(path); - cookie.push_str(COOKIE_ATTRS); - if expired { - cookie.push_str("; Max-Age=0"); - } + // El nombre es ASCII (el prefijo y cifras hexadecimales), así que siempre es UTF-8 válido. + let Ok(name) = str::from_utf8(name) else { + return; + }; + // Sin `Max-Age` es una *cookie* de sesión. + let cookie = cookie_header(name, value, path, expired.then_some(0)); if let Ok(cookie) = HeaderValue::try_from(cookie) { response.headers_mut().append(header::SET_COOKIE, cookie); } diff --git a/tests/response_flash.rs b/tests/response_flash.rs index c70a8178..96551bd6 100644 --- a/tests/response_flash.rs +++ b/tests/response_flash.rs @@ -63,13 +63,17 @@ fn flash_cookie(response: &Response) -> String { async fn messages_are_shown_on_the_next_page_and_then_cleared() { let saved = send(web::test::TestRequest::post().uri("/save")).await; assert_eq!(saved.status(), StatusCode::SEE_OTHER); - assert!(set_cookie(&saved).unwrap().contains("Max-Age=60")); + assert!( + set_cookie(&saved) + .unwrap() + .ends_with("; Secure; Max-Age=60") + ); let cookie = flash_cookie(&saved); let page = send(get("/done", Some(&cookie))).await; assert_eq!( set_cookie(&page), - Some("pagetop_flash=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0") + Some("pagetop_flash=; Path=/; HttpOnly; SameSite=Lax; Secure; Max-Age=0") ); let body = web::test::read_body_text(page).await; // Shown once, as plain text, before the content. diff --git a/tests/web_remember_query.rs b/tests/web_remember_query.rs index fa1d4977..e014bdad 100644 --- a/tests/web_remember_query.rs +++ b/tests/web_remember_query.rs @@ -100,6 +100,7 @@ async fn a_list_remembers_its_state_and_restores_it_when_requested_without_it() ); assert!(cookie.contains("Path=/items;"), "{cookie}"); assert!(cookie.contains("HttpOnly"), "{cookie}"); + assert!(cookie.contains("; Secure"), "{cookie}"); assert!(!cookie.contains("Max-Age"), "a session cookie: {cookie}"); let cookie = list_cookie(&filtered);