From deb75b775e391e213601fa7c57674cd41cf83dc8 Mon Sep 17 00:00:00 2001 From: Davis Wolfermann Date: Sat, 31 Oct 2026 22:27:15 +0100 Subject: [PATCH 1/5] feat(server): implement step-up/start --- ...3ee22ba61bd30c9b052781a085c9be8c5dbe0.json | 40 ++++++ rust/crates/keygo-server/src/api/mod.rs | 3 +- .../src/api/routes/auth/handshake.rs | 57 ++++++++ .../keygo-server/src/api/routes/auth/login.rs | 49 +------ .../keygo-server/src/api/routes/auth/mod.rs | 3 + .../src/api/routes/auth/step_up.rs | 128 ++++++++++++++++++ rust/crates/keygo-server/src/api/state.rs | 4 +- .../keygo-server/src/cache/login_states.rs | 51 +++++-- .../keygo-server/src/db/opaque_records.rs | 68 ++++++++-- .../keygo-server/src/service/login/mod.rs | 3 - .../keygo-server/src/service/login/start.rs | 34 +++-- rust/crates/keygo-server/src/service/mod.rs | 1 + .../keygo-server/src/service/step_up/mod.rs | 3 + .../keygo-server/src/service/step_up/start.rs | 103 ++++++++++++++ rust/crates/keygo-server/src/testing.rs | 50 ++++++- 15 files changed, 515 insertions(+), 82 deletions(-) create mode 100644 rust/crates/keygo-server/.sqlx/query-3c45f38b931d7a3af76c65b65123ee22ba61bd30c9b052781a085c9be8c5dbe0.json create mode 100644 rust/crates/keygo-server/src/api/routes/auth/handshake.rs create mode 100644 rust/crates/keygo-server/src/api/routes/auth/step_up.rs create mode 100644 rust/crates/keygo-server/src/service/step_up/mod.rs create mode 100644 rust/crates/keygo-server/src/service/step_up/start.rs diff --git a/rust/crates/keygo-server/.sqlx/query-3c45f38b931d7a3af76c65b65123ee22ba61bd30c9b052781a085c9be8c5dbe0.json b/rust/crates/keygo-server/.sqlx/query-3c45f38b931d7a3af76c65b65123ee22ba61bd30c9b052781a085c9be8c5dbe0.json new file mode 100644 index 000000000..5c2e34e57 --- /dev/null +++ b/rust/crates/keygo-server/.sqlx/query-3c45f38b931d7a3af76c65b65123ee22ba61bd30c9b052781a085c9be8c5dbe0.json @@ -0,0 +1,40 @@ +{ + "db_name": "PostgreSQL", + "query": "select suite, record from opaque_records where user_id = $1", + "describe": { + "columns": [ + { + "ordinal": 0, + "name": "suite", + "type_info": "Text", + "origin": { + "Table": { + "table": "opaque_records", + "name": "suite" + } + } + }, + { + "ordinal": 1, + "name": "record", + "type_info": "Bytea", + "origin": { + "Table": { + "table": "opaque_records", + "name": "record" + } + } + } + ], + "parameters": { + "Left": [ + "Uuid" + ] + }, + "nullable": [ + false, + false + ] + }, + "hash": "3c45f38b931d7a3af76c65b65123ee22ba61bd30c9b052781a085c9be8c5dbe0" +} diff --git a/rust/crates/keygo-server/src/api/mod.rs b/rust/crates/keygo-server/src/api/mod.rs index 0620e77e3..d951dc2c1 100644 --- a/rust/crates/keygo-server/src/api/mod.rs +++ b/rust/crates/keygo-server/src/api/mod.rs @@ -50,7 +50,7 @@ fn single_header(headers: &HeaderMap, name: A) -> Option<&Heade #[cfg(test)] mod tests { use super::*; - use crate::cache::LoginStates; + use crate::cache::{LoginStates, StepUpStates}; use crate::domain::InvitePepper; use crate::service::registration::Signup; use axum::body::Body; @@ -90,6 +90,7 @@ mod tests { db: sqlx::postgres::PgPoolOptions::new() .connect_lazy_with(sqlx::postgres::PgConnectOptions::new()), login_states: LoginStates::new(), + step_up_states: StepUpStates::new(), dpop_verifier: Arc::new(DpopVerifier::new()), token_issuer: Arc::new(crate::testing::token_issuer()), } diff --git a/rust/crates/keygo-server/src/api/routes/auth/handshake.rs b/rust/crates/keygo-server/src/api/routes/auth/handshake.rs new file mode 100644 index 000000000..948c73731 --- /dev/null +++ b/rust/crates/keygo-server/src/api/routes/auth/handshake.rs @@ -0,0 +1,57 @@ +use crate::api::{ErrorCode, HttpError}; +use crate::domain::LoginId; +use crate::service::login; +use keygo_opaque::CredentialResponse; +use serde::Serialize; + +// Sign-in and step-up run the same OPAQUE login, so they share its error codes and bodies. +impl HttpError for login::Error { + fn code(&self) -> ErrorCode { + match self { + Self::Expired => ErrorCode::LoginExpired, + Self::Opaque(err) => err.code(), + Self::Db(_) => ErrorCode::Internal, + } + } +} + +#[derive(Serialize)] +pub struct StartResponse { + login_id: LoginId, + credential_response: CredentialResponse, + expires_in: u64, +} + +impl From for StartResponse { + fn from(started: login::Started) -> Self { + Self { + login_id: started.login_id, + credential_response: started.credential_response, + expires_in: started.expires_in.as_secs(), + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::api::error::render; + use axum::http::StatusCode; + use keygo_opaque::OpaqueError; + + #[tokio::test] + async fn expired_logins_are_bad_requests() { + let (status, body) = render(login::Error::Expired).await; + + assert_eq!(status, StatusCode::BAD_REQUEST); + assert_eq!(body["code"], "login_expired"); + } + + #[tokio::test] + async fn failed_login_finish_matches_failed_start() { + let (status, body) = render(login::Error::Opaque(OpaqueError::InvalidLogin)).await; + + assert_eq!(status, StatusCode::UNAUTHORIZED); + assert_eq!(body["code"], "invalid_credentials"); + } +} diff --git a/rust/crates/keygo-server/src/api/routes/auth/login.rs b/rust/crates/keygo-server/src/api/routes/auth/login.rs index f0ccf2216..8c0b1a4c4 100644 --- a/rust/crates/keygo-server/src/api/routes/auth/login.rs +++ b/rust/crates/keygo-server/src/api/routes/auth/login.rs @@ -1,12 +1,13 @@ use crate::api::dpop::SingleUseDpopProof; +use crate::api::routes::auth::handshake::StartResponse; use crate::api::routes::auth::session::Session; -use crate::api::{AppState, ErrorCode, HttpError, Json, ServerResult}; +use crate::api::{AppState, Json, ServerResult}; use crate::domain::{Device, LoginId, UserId, Username}; use crate::service::login::{self, FinishLogin, StartLogin}; use axum::Router; use axum::extract::State; use axum::routing::post; -use keygo_opaque::{CredentialFinalization, CredentialRequest, CredentialResponse, DpopBinding}; +use keygo_opaque::{CredentialFinalization, CredentialRequest, DpopBinding}; use serde::{Deserialize, Serialize}; pub fn router() -> Router { @@ -15,16 +16,6 @@ pub fn router() -> Router { .route("/finish", post(finish)) } -impl HttpError for login::Error { - fn code(&self) -> ErrorCode { - match self { - Self::Expired => ErrorCode::LoginExpired, - Self::Opaque(err) => err.code(), - Self::Db(_) => ErrorCode::Internal, - } - } -} - #[derive(Deserialize)] struct StartRequest { /// Parsed in the handler so a bad name answers `invalid_username`, not `invalid_request`. @@ -32,13 +23,6 @@ struct StartRequest { credential_request: CredentialRequest, } -#[derive(Serialize)] -struct StartResponse { - login_id: LoginId, - credential_response: CredentialResponse, - expires_in: u64, -} - async fn start( State(state): State, Json(request): Json, @@ -50,11 +34,7 @@ async fn start( let started = login::start(&state.db, &state.login_states, &state.opaque_state, input).await?; - Ok(Json(StartResponse { - login_id: started.login_id, - credential_response: started.credential_response, - expires_in: started.expires_in.as_secs(), - })) + Ok(Json(started.into())) } #[derive(Deserialize)] @@ -98,13 +78,12 @@ async fn finish( #[cfg(test)] mod tests { use super::*; - use crate::api::error::render; use crate::testing::{ PASSWORD, app_state, count, device_json, post_to, post_with_proof, proof_post, prover, register, replayable_post, send, }; use axum::http::StatusCode; - use keygo_opaque::OpaqueError; + use keygo_opaque::CredentialResponse; use keygo_opaque::client::ClientLogin; use keygo_opaque::server::ServerSetup; use serde_json::{Value, json}; @@ -140,22 +119,6 @@ mod tests { }) } - #[tokio::test] - async fn expired_logins_are_bad_requests() { - let (status, body) = render(login::Error::Expired).await; - - assert_eq!(status, StatusCode::BAD_REQUEST); - assert_eq!(body["code"], "login_expired"); - } - - #[tokio::test] - async fn failed_login_finish_matches_failed_start() { - let (status, body) = render(login::Error::Opaque(OpaqueError::InvalidLogin)).await; - - assert_eq!(status, StatusCode::UNAUTHORIZED); - assert_eq!(body["code"], "invalid_credentials"); - } - #[sqlx::test] async fn logs_in_over_http(db: PgPool) { let setup = ServerSetup::generate(); @@ -163,7 +126,7 @@ mod tests { let user_id = register(&db, &setup, "ada").await; let (client, started) = start_over_http(&state, "Ada").await; - assert_eq!(started["expires_in"], login::TTL.as_secs()); + assert_eq!(started["expires_in"], state.login_states.ttl().as_secs()); let prover = prover(); let body = finish_body(&started["login_id"], client, &started, prover.jkt()); diff --git a/rust/crates/keygo-server/src/api/routes/auth/mod.rs b/rust/crates/keygo-server/src/api/routes/auth/mod.rs index 80b89ea3a..6150d1b0b 100644 --- a/rust/crates/keygo-server/src/api/routes/auth/mod.rs +++ b/rust/crates/keygo-server/src/api/routes/auth/mod.rs @@ -5,10 +5,12 @@ use axum::Router; use axum::extract::DefaultBodyLimit; use axum::routing::post; +mod handshake; mod login; mod logout; mod register; mod session; +mod step_up; mod token; /// Every auth endpoint is reachable without a token, so a body beyond the largest legitimate one (a @@ -19,6 +21,7 @@ pub fn router() -> Router { Router::new() .nest("/register", register::router()) .nest("/login", login::router()) + .nest("/step-up", step_up::router()) .route("/token", post(token)) .route("/logout", post(logout)) .layer(DefaultBodyLimit::max(MAX_BODY_BYTES)) diff --git a/rust/crates/keygo-server/src/api/routes/auth/step_up.rs b/rust/crates/keygo-server/src/api/routes/auth/step_up.rs new file mode 100644 index 000000000..de3ea67d4 --- /dev/null +++ b/rust/crates/keygo-server/src/api/routes/auth/step_up.rs @@ -0,0 +1,128 @@ +use crate::api::authenticated::Authenticated; +use crate::api::routes::auth::handshake::StartResponse; +use crate::api::{AppState, Json, ServerResult}; +use crate::service::step_up::{self, StartStepUp}; +use axum::Router; +use axum::extract::State; +use axum::routing::post; +use keygo_opaque::CredentialRequest; +use serde::Deserialize; + +pub fn router() -> Router { + Router::new().route("/start", post(start)) +} + +#[derive(Deserialize)] +struct StartRequest { + credential_request: CredentialRequest, +} + +async fn start( + State(state): State, + authenticated: Authenticated, + Json(request): Json, +) -> ServerResult> { + let input = StartStepUp { + user_id: authenticated.claims().user_id(), + credential_request: request.credential_request, + }; + + let started = + step_up::start(&state.db, &state.step_up_states, &state.opaque_state, input).await?; + + Ok(Json(started.into())) +} + +#[cfg(test)] +mod tests { + use crate::api::AppState; + use crate::db::devices; + use crate::domain::DeviceId; + use crate::testing::{ + PASSWORD, app_state, device_info, device_json, issue_session, post_to, post_with_proof, + post_with_token, prover, register, + }; + use axum::http::StatusCode; + use keygo_dpop::DpopProver; + use keygo_dpop::testing::TestSigner; + use keygo_opaque::CredentialResponse; + use keygo_opaque::client::ClientLogin; + use keygo_opaque::server::ServerSetup; + use serde_json::{Value, json}; + use sqlx::PgPool; + + const START: &str = "/api/v1/auth/step-up/start"; + + /// A registered user signed in on a second device, bound to the prover's key. + async fn signed_in(db: &PgPool, prover: &DpopProver) -> (AppState, String) { + let setup = ServerSetup::generate(); + let state = app_state(db, &setup); + let user_id = register(db, &setup, "ada").await; + let device_id = DeviceId::random(); + let mut conn = db.acquire().await.unwrap(); + devices::insert(&mut conn, device_id, user_id, &device_info()) + .await + .unwrap(); + let issued = issue_session(db, user_id, device_id, prover.jkt()).await; + (state, issued.access_token.expose().to_owned()) + } + + fn start_body() -> (ClientLogin, Value) { + let (client, request) = ClientLogin::start(PASSWORD).unwrap(); + (client, json!({ "credential_request": request.to_base64() })) + } + + #[sqlx::test] + async fn starts_a_step_up_over_http(db: PgPool) { + let prover = prover(); + let (state, access_token) = signed_in(&db, &prover).await; + let (client, body) = start_body(); + + let (status, started) = post_with_token(&state, &prover, START, &access_token, body).await; + + assert_eq!(status, StatusCode::OK); + assert_eq!(started["expires_in"], state.step_up_states.ttl().as_secs()); + let response = + CredentialResponse::from_base64(started["credential_response"].as_str().unwrap()) + .unwrap(); + assert!(client.finish(PASSWORD, response).is_ok()); + assert_eq!(state.step_up_states.count(), 1); + assert_eq!(state.login_states.count(), 0); + } + + #[sqlx::test] + async fn start_requires_an_access_token(db: PgPool) { + let (_, body) = start_body(); + + let (status, response) = + post_to(app_state(&db, &ServerSetup::generate()), START, body).await; + + assert_eq!(status, StatusCode::UNAUTHORIZED); + assert_eq!(response["code"], "invalid_token"); + } + + #[sqlx::test] + async fn a_step_up_cannot_be_finished_as_a_sign_in(db: PgPool) { + let prover = prover(); + let (state, access_token) = signed_in(&db, &prover).await; + let (client, body) = start_body(); + let (_, started) = post_with_token(&state, &prover, START, &access_token, body).await; + let response = + CredentialResponse::from_base64(started["credential_response"].as_str().unwrap()) + .unwrap(); + let finish = client.finish(PASSWORD, response).unwrap(); + let body = json!({ + "login_id": started["login_id"], + "credential_finalization": finish.finalization.to_base64(), + "dpop_binding": finish.session_key.dpop_binding(prover.jkt()).to_base64(), + "device": device_json(), + }); + + let (status, response) = + post_with_proof(&state, &prover, "/api/v1/auth/login/finish", body).await; + + assert_eq!(status, StatusCode::BAD_REQUEST); + assert_eq!(response["code"], "login_expired"); + assert_eq!(state.step_up_states.count(), 1); + } +} diff --git a/rust/crates/keygo-server/src/api/state.rs b/rust/crates/keygo-server/src/api/state.rs index c0496b083..388648955 100644 --- a/rust/crates/keygo-server/src/api/state.rs +++ b/rust/crates/keygo-server/src/api/state.rs @@ -1,4 +1,4 @@ -use crate::cache::LoginStates; +use crate::cache::{LoginStates, StepUpStates}; use crate::config::DeploymentConfig; use crate::domain::TokenIssuer; use crate::service::registration::Signup; @@ -15,6 +15,7 @@ pub struct AppState { pub opaque_state: keygo_opaque::server::ServerSetup, pub db: PgPool, pub login_states: LoginStates, + pub step_up_states: StepUpStates, pub dpop_verifier: Arc, pub token_issuer: Arc, } @@ -34,6 +35,7 @@ impl AppState { opaque_state: secrets.opaque_setup()?, db, login_states: LoginStates::new(), + step_up_states: StepUpStates::new(), dpop_verifier: Arc::new(DpopVerifier::new()), token_issuer: Arc::new(TokenIssuer::new(secrets.access_token_key()?, issuer)), }) diff --git a/rust/crates/keygo-server/src/cache/login_states.rs b/rust/crates/keygo-server/src/cache/login_states.rs index 199a8f74b..a3debda6b 100644 --- a/rust/crates/keygo-server/src/cache/login_states.rs +++ b/rust/crates/keygo-server/src/cache/login_states.rs @@ -8,39 +8,54 @@ const TTL: Duration = Duration::from_mins(1); const MAX_ENTRIES: u64 = 10_000; #[derive(Clone)] -pub struct Pending { - /// `None` on the fake path for an unknown username. - pub user_id: Option, +pub struct Pending { + pub user_id: U, pub state: ServerLogin, } +/// Server halves of OPAQUE logins waiting for their `finish`. Sign-in and step-up each get their +/// own store, so a `login_id` from one flow can never be finished through the other. #[derive(Clone)] -pub struct LoginStates(Cache); +pub struct LoginStore { + states: Cache>, + ttl: Duration, +} + +/// The user id is `None` on the fake path for an unknown username. +pub type LoginStates = LoginStore>; + +/// The user from the access token: step-up has no fake path. +pub type StepUpStates = LoginStore; -impl LoginStates { +impl LoginStore { pub fn new() -> Self { Self::with_ttl(TTL) } pub fn with_ttl(ttl: Duration) -> Self { - Self( - Cache::builder() + Self { + states: Cache::builder() .max_capacity(MAX_ENTRIES) .time_to_live(ttl) .build(), - ) + ttl, + } } - pub fn insert(&self, key: LoginId, value: Pending) { - self.0.insert(key, value); + pub fn ttl(&self) -> Duration { + self.ttl } - pub fn take(&self, key: &LoginId) -> Option { + pub fn insert(&self, key: LoginId, value: Pending) { + self.states.insert(key, value); + } + + pub fn take(&self, key: &LoginId) -> Option> { // Not `Cache::remove`: that returns an entry even after it expired, until maintenance drops // it. `and_compute_with` reads the entry the way `get` does, so it never sees an expired one, // and it runs calls on the same key one at a time, so a state can be taken only once. let result = self - .0 + .states .entry_by_ref(key) .and_compute_with(|entry| match entry { Some(_) => Op::Remove, @@ -54,8 +69,8 @@ impl LoginStates { #[cfg(test)] pub fn count(&self) -> u64 { - self.0.run_pending_tasks(); - self.0.entry_count() + self.states.run_pending_tasks(); + self.states.entry_count() } } @@ -65,7 +80,7 @@ mod tests { use keygo_opaque::client::ClientLogin; use keygo_opaque::server::ServerSetup; - fn pending() -> Pending { + fn pending() -> Pending> { let (_, request) = ClientLogin::start(b"password").unwrap(); let (state, _) = ServerLogin::start(&ServerSetup::generate(), None, request, b"identifier").unwrap(); @@ -75,6 +90,12 @@ mod tests { } } + #[test] + fn logins_live_a_minute() { + assert_eq!(LoginStates::new().ttl(), Duration::from_secs(60)); + assert_eq!(StepUpStates::new().ttl(), Duration::from_secs(60)); + } + #[test] fn a_state_is_taken_once() { let states = LoginStates::new(); diff --git a/rust/crates/keygo-server/src/db/opaque_records.rs b/rust/crates/keygo-server/src/db/opaque_records.rs index 19ee25b04..810815fd7 100644 --- a/rust/crates/keygo-server/src/db/opaque_records.rs +++ b/rust/crates/keygo-server/src/db/opaque_records.rs @@ -44,20 +44,35 @@ pub async fn find_by_username( return Ok(None); }; - if row.suite != SUITE_ID { + Ok(Some(Record { + user_id: row.user_id.into(), + file: decode(&row.suite, row.record)?, + })) +} + +pub async fn find_by_user_id( + conn: &mut PgConnection, + user_id: UserId, +) -> sqlx::Result> { + let row = sqlx::query!( + "select suite, record from opaque_records where user_id = $1", + user_id.as_uuid(), + ) + .fetch_optional(conn) + .await?; + + row.map(|row| decode(&row.suite, row.record)).transpose() +} + +fn decode(suite: &str, record: Vec) -> sqlx::Result { + if suite != SUITE_ID { return Err(corrupt(format!( - "opaque record uses unknown suite {:?}", - row.suite + "opaque record uses unknown suite {suite:?}" ))); } - let record = Zeroizing::new(row.record); - let file = PasswordFile::from_bytes(&record).map_err(corrupt)?; - - Ok(Some(Record { - user_id: row.user_id.into(), - file, - })) + let record = Zeroizing::new(record); + PasswordFile::from_bytes(&record).map_err(corrupt) } #[cfg(test)] @@ -116,6 +131,39 @@ mod tests { assert_eq!(*record.file.to_bytes(), *file.to_bytes()); } + #[sqlx::test] + async fn record_is_found_by_user_id(db: PgPool) { + let user_id = insert_user(&db, "ada").await; + let file = password_file(user_id); + let mut conn = db.acquire().await.unwrap(); + insert(&mut conn, user_id, &file).await.unwrap(); + + let found = find_by_user_id(&mut conn, user_id).await.unwrap().unwrap(); + + assert_eq!(*found.to_bytes(), *file.to_bytes()); + } + + #[sqlx::test] + async fn user_without_a_record_has_none(db: PgPool) { + let user_id = insert_user(&db, "ada").await; + let mut conn = db.acquire().await.unwrap(); + + for id in [user_id, UserId::random()] { + assert!(find_by_user_id(&mut conn, id).await.unwrap().is_none()); + } + } + + #[sqlx::test] + async fn undecodable_record_by_user_id_is_corrupt(db: PgPool) { + let user_id = insert_user(&db, "ada").await; + insert_raw(&db, user_id, SUITE_ID, &[0]).await; + let mut conn = db.acquire().await.unwrap(); + + let err = find_by_user_id(&mut conn, user_id).await.err().unwrap(); + + assert!(matches!(err, sqlx::Error::Decode(_))); + } + #[sqlx::test] async fn record_stores_the_suite(db: PgPool) { let user_id = insert_user(&db, "ada").await; diff --git a/rust/crates/keygo-server/src/service/login/mod.rs b/rust/crates/keygo-server/src/service/login/mod.rs index 0a3af0c21..71a2b7db8 100644 --- a/rust/crates/keygo-server/src/service/login/mod.rs +++ b/rust/crates/keygo-server/src/service/login/mod.rs @@ -5,9 +5,6 @@ pub use finish::*; pub use start::*; use keygo_opaque::OpaqueError; -use std::time::Duration; - -pub const TTL: Duration = Duration::from_mins(1); #[derive(Debug, thiserror::Error)] pub enum Error { diff --git a/rust/crates/keygo-server/src/service/login/start.rs b/rust/crates/keygo-server/src/service/login/start.rs index 432b32a15..a31aa3ea2 100644 --- a/rust/crates/keygo-server/src/service/login/start.rs +++ b/rust/crates/keygo-server/src/service/login/start.rs @@ -1,9 +1,9 @@ -use crate::cache::{LoginStates, Pending}; +use crate::cache::{LoginStates, LoginStore, Pending}; use crate::db::opaque_records; use crate::domain::{LoginId, Username}; -use crate::service::login::{Error, TTL}; +use crate::service::login::Error; use keygo_opaque::server::{ServerLogin, ServerSetup}; -use keygo_opaque::{CredentialRequest, CredentialResponse}; +use keygo_opaque::{CredentialRequest, CredentialResponse, PasswordFile}; use sqlx::PgPool; use std::time::Duration; @@ -48,16 +48,34 @@ pub async fn start( None => (None, None, fake_identifier(&username)), }; + respond( + login_states, + setup, + user_id, + password_file, + &identifier, + credential_request, + ) +} + +pub fn respond( + states: &LoginStore, + setup: &ServerSetup, + user_id: U, + password_file: Option, + identifier: &[u8], + credential_request: CredentialRequest, +) -> Result { let (state, credential_response) = - ServerLogin::start(setup, password_file, credential_request, &identifier)?; + ServerLogin::start(setup, password_file, credential_request, identifier)?; let login_id = LoginId::random(); - login_states.insert(login_id, Pending { user_id, state }); + states.insert(login_id, Pending { user_id, state }); Ok(Started { login_id, credential_response, - expires_in: TTL, + expires_in: states.ttl(), }) } @@ -95,7 +113,7 @@ mod tests { let (_, started) = start_login(&db, &login_states, &setup, "ada").await; - assert_eq!(started.expires_in, TTL); + assert_eq!(started.expires_in, login_states.ttl()); let pending = login_states.take(&started.login_id).unwrap(); assert_eq!(pending.user_id, Some(user_id)); } @@ -106,7 +124,7 @@ mod tests { let (_, started) = start_login(&db, &login_states, &ServerSetup::generate(), "ada").await; - assert_eq!(started.expires_in, TTL); + assert_eq!(started.expires_in, login_states.ttl()); let pending = login_states.take(&started.login_id).unwrap(); assert_eq!(pending.user_id, None); } diff --git a/rust/crates/keygo-server/src/service/mod.rs b/rust/crates/keygo-server/src/service/mod.rs index 03e35c62e..8814f40bb 100644 --- a/rust/crates/keygo-server/src/service/mod.rs +++ b/rust/crates/keygo-server/src/service/mod.rs @@ -3,3 +3,4 @@ pub mod invite; pub mod login; pub mod registration; pub mod session; +pub mod step_up; diff --git a/rust/crates/keygo-server/src/service/step_up/mod.rs b/rust/crates/keygo-server/src/service/step_up/mod.rs new file mode 100644 index 000000000..d2a875010 --- /dev/null +++ b/rust/crates/keygo-server/src/service/step_up/mod.rs @@ -0,0 +1,3 @@ +mod start; + +pub use start::*; diff --git a/rust/crates/keygo-server/src/service/step_up/start.rs b/rust/crates/keygo-server/src/service/step_up/start.rs new file mode 100644 index 000000000..bfdc2bf5f --- /dev/null +++ b/rust/crates/keygo-server/src/service/step_up/start.rs @@ -0,0 +1,103 @@ +use crate::cache::StepUpStates; +use crate::db::opaque_records; +use crate::domain::UserId; +use crate::service::login::{self, Error, Started}; +use keygo_opaque::server::ServerSetup; +use keygo_opaque::{CredentialRequest, OpaqueError}; +use sqlx::PgPool; + +pub struct StartStepUp { + pub user_id: UserId, + pub credential_request: CredentialRequest, +} + +pub async fn start( + db: &PgPool, + step_up_states: &StepUpStates, + setup: &ServerSetup, + input: StartStepUp, +) -> Result { + let StartStepUp { + user_id, + credential_request, + } = input; + + let mut conn = db.acquire().await?; + // Unlike the login/start endpoint, there is no fake path here as the caller is already authenticated + let password_file = opaque_records::find_by_user_id(&mut conn, user_id) + .await? + .ok_or(OpaqueError::InvalidLogin)?; + + login::respond( + step_up_states, + setup, + user_id, + Some(password_file), + user_id.as_uuid().as_bytes(), + credential_request, + ) +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::testing::{PASSWORD, register}; + use keygo_opaque::client::ClientLogin; + + async fn start_step_up( + db: &PgPool, + states: &StepUpStates, + setup: &ServerSetup, + user_id: UserId, + ) -> (ClientLogin, Result) { + let (client, credential_request) = ClientLogin::start(PASSWORD).unwrap(); + let input = StartStepUp { + user_id, + credential_request, + }; + (client, start(db, states, setup, input).await) + } + + #[sqlx::test] + async fn start_stores_state_for_the_user(db: PgPool) { + let states = StepUpStates::new(); + let setup = ServerSetup::generate(); + let user_id = register(&db, &setup, "ada").await; + + let (_, started) = start_step_up(&db, &states, &setup, user_id).await; + let started = started.unwrap(); + + assert_eq!(started.expires_in, states.ttl()); + let pending = states.take(&started.login_id).unwrap(); + assert_eq!(pending.user_id, user_id); + } + + #[sqlx::test] + async fn start_answers_with_the_registered_record(db: PgPool) { + let states = StepUpStates::new(); + let setup = ServerSetup::generate(); + let user_id = register(&db, &setup, "ada").await; + + let (client, started) = start_step_up(&db, &states, &setup, user_id).await; + + assert!( + client + .finish(PASSWORD, started.unwrap().credential_response) + .is_ok() + ); + } + + #[sqlx::test] + async fn start_refuses_a_user_without_a_record(db: PgPool) { + let states = StepUpStates::new(); + + let (_, started) = + start_step_up(&db, &states, &ServerSetup::generate(), UserId::random()).await; + + assert!(matches!( + started, + Err(Error::Opaque(OpaqueError::InvalidLogin)) + )); + assert_eq!(states.count(), 0); + } +} diff --git a/rust/crates/keygo-server/src/testing.rs b/rust/crates/keygo-server/src/testing.rs index cc58c4e21..1ce615ebd 100644 --- a/rust/crates/keygo-server/src/testing.rs +++ b/rust/crates/keygo-server/src/testing.rs @@ -1,5 +1,5 @@ use crate::api::{AppState, router}; -use crate::cache::LoginStates; +use crate::cache::{LoginStates, StepUpStates}; use crate::db::{devices, invites, sessions, users}; use crate::domain::{ AccessTokenKey, Device, DeviceId, DeviceInfo, InviteHash, InvitePepper, SessionId, TokenIssuer, @@ -216,6 +216,7 @@ pub fn app_state(db: &PgPool, setup: &ServerSetup) -> AppState { opaque_state: setup.clone(), db: db.clone(), login_states: LoginStates::new(), + step_up_states: StepUpStates::new(), dpop_verifier: Arc::new(DpopVerifier::new()), token_issuer: Arc::new(token_issuer()), } @@ -271,6 +272,53 @@ pub fn proof_post( request } +/// Posts as the session behind `access_token` and answers a nonce challenge once, like +/// `post_with_proof`. +pub async fn post_with_token( + state: &AppState, + prover: &DpopProver, + uri: &str, + access_token: &str, + body: Value, +) -> (StatusCode, Value) { + let request = token_post(state, prover, uri, access_token, &body, None); + let (status, headers, response) = send(state, request).await; + if response["code"] != "use_dpop_nonce" { + return (status, response); + } + + let nonce = headers["dpop-nonce"].to_str().unwrap(); + let request = token_post(state, prover, uri, access_token, &body, Some(nonce)); + let (status, _, response) = send(state, request).await; + (status, response) +} +fn token_post( + state: &AppState, + prover: &DpopProver, + uri: &str, + access_token: &str, + body: &Value, + nonce: Option<&str>, +) -> Request { + let htu = state.public_url.join(uri).unwrap(); + let proof = prover + .proof(&ProofRequest { + htm: Htm::Post, + htu: htu.as_str(), + access_token: Some(access_token), + nonce, + }) + .unwrap(); + let mut request = json_post(uri, body); + let headers = request.headers_mut(); + headers.insert("dpop", proof.parse().unwrap()); + headers.insert( + "authorization", + format!("DPoP {access_token}").parse().unwrap(), + ); + request +} + /// Signs one proof carrying the verifier's nonce and builds identical requests around it, the way /// an attacker replays a captured request. Fetching the nonce takes a challenge, which keeps state. pub async fn replayable_post( From f436cab8d9be9f3c4ee852184b2eeb75a690c8e8 Mon Sep 17 00:00:00 2001 From: Davis Wolfermann Date: Sat, 31 Oct 2026 23:13:34 +0100 Subject: [PATCH 2/5] refactor(server): cleanup --- .../src/api/routes/auth/handshake.rs | 12 +- .../src/api/routes/auth/logout.rs | 55 ++------- .../src/api/routes/auth/step_up.rs | 33 ++---- .../keygo-server/src/db/opaque_records.rs | 2 +- rust/crates/keygo-server/src/domain/ids.rs | 14 +++ .../keygo-server/src/service/handshake.rs | 42 +++++++ .../keygo-server/src/service/login/finish.rs | 2 +- .../keygo-server/src/service/login/mod.rs | 12 -- .../keygo-server/src/service/login/start.rs | 42 ++----- rust/crates/keygo-server/src/service/mod.rs | 1 + .../src/service/registration/start.rs | 2 +- .../keygo-server/src/service/step_up/start.rs | 6 +- rust/crates/keygo-server/src/testing.rs | 108 +++++++++--------- 13 files changed, 148 insertions(+), 183 deletions(-) create mode 100644 rust/crates/keygo-server/src/service/handshake.rs diff --git a/rust/crates/keygo-server/src/api/routes/auth/handshake.rs b/rust/crates/keygo-server/src/api/routes/auth/handshake.rs index 948c73731..fa3110201 100644 --- a/rust/crates/keygo-server/src/api/routes/auth/handshake.rs +++ b/rust/crates/keygo-server/src/api/routes/auth/handshake.rs @@ -1,11 +1,11 @@ use crate::api::{ErrorCode, HttpError}; use crate::domain::LoginId; -use crate::service::login; +use crate::service::handshake; use keygo_opaque::CredentialResponse; use serde::Serialize; // Sign-in and step-up run the same OPAQUE login, so they share its error codes and bodies. -impl HttpError for login::Error { +impl HttpError for handshake::Error { fn code(&self) -> ErrorCode { match self { Self::Expired => ErrorCode::LoginExpired, @@ -22,8 +22,8 @@ pub struct StartResponse { expires_in: u64, } -impl From for StartResponse { - fn from(started: login::Started) -> Self { +impl From for StartResponse { + fn from(started: handshake::Started) -> Self { Self { login_id: started.login_id, credential_response: started.credential_response, @@ -41,7 +41,7 @@ mod tests { #[tokio::test] async fn expired_logins_are_bad_requests() { - let (status, body) = render(login::Error::Expired).await; + let (status, body) = render(handshake::Error::Expired).await; assert_eq!(status, StatusCode::BAD_REQUEST); assert_eq!(body["code"], "login_expired"); @@ -49,7 +49,7 @@ mod tests { #[tokio::test] async fn failed_login_finish_matches_failed_start() { - let (status, body) = render(login::Error::Opaque(OpaqueError::InvalidLogin)).await; + let (status, body) = render(handshake::Error::Opaque(OpaqueError::InvalidLogin)).await; assert_eq!(status, StatusCode::UNAUTHORIZED); assert_eq!(body["code"], "invalid_credentials"); diff --git a/rust/crates/keygo-server/src/api/routes/auth/logout.rs b/rust/crates/keygo-server/src/api/routes/auth/logout.rs index 87665804d..583b3df84 100644 --- a/rust/crates/keygo-server/src/api/routes/auth/logout.rs +++ b/rust/crates/keygo-server/src/api/routes/auth/logout.rs @@ -16,66 +16,29 @@ pub async fn logout( mod tests { use crate::api::AppState; use crate::domain::RefreshToken; - use crate::service::session::Issued; - use crate::testing::{app_state, insert_device, issue_session, post_with_proof, prover, send}; + use crate::testing::{ + app_state, post_with_proof, prover, send_with_nonce, signed_in, with_proof, + }; use axum::body::Body; - use axum::http::header::AUTHORIZATION; use axum::http::{Request, StatusCode}; + use keygo_dpop::DpopProver; use keygo_dpop::testing::TestSigner; - use keygo_dpop::{DpopProver, Htm, ProofRequest}; use keygo_opaque::server::ServerSetup; use serde_json::{Value, json}; use sqlx::PgPool; const LOGOUT: &str = "/api/v1/auth/logout"; - async fn signed_in(db: &PgPool, prover: &DpopProver) -> (AppState, Issued) { - let state = app_state(db, &ServerSetup::generate()); - let (user_id, device_id) = insert_device(db).await; - let issued = issue_session(db, user_id, device_id, prover.jkt()).await; - (state, issued) - } - - fn logout_request( - state: &AppState, - prover: &DpopProver, - access_token: &str, - nonce: Option<&str>, - ) -> Request { - let htu = state.public_url.join(LOGOUT).unwrap(); - let proof = prover - .proof(&ProofRequest { - htm: Htm::Post, - htu: htu.as_str(), - access_token: Some(access_token), - nonce, - }) - .unwrap(); - Request::post(LOGOUT) - .header(AUTHORIZATION, format!("DPoP {access_token}")) - .header("dpop", proof) - .body(Body::empty()) - .unwrap() - } - - /// Logs out with a fresh proof and answers a nonce challenge once, like a real client. async fn logout( state: &AppState, prover: &DpopProver, access_token: &str, ) -> (StatusCode, Value) { - let (status, headers, body) = - send(state, logout_request(state, prover, access_token, None)).await; - if body["code"] != "use_dpop_nonce" { - return (status, body); - } - let nonce = headers["dpop-nonce"].to_str().unwrap(); - let (status, _, body) = send( - state, - logout_request(state, prover, access_token, Some(nonce)), - ) - .await; - (status, body) + send_with_nonce(state, |nonce| { + let request = Request::post(LOGOUT).body(Body::empty()).unwrap(); + with_proof(state, prover, request, Some(access_token), nonce) + }) + .await } fn token_body(refresh_token: &RefreshToken) -> Value { diff --git a/rust/crates/keygo-server/src/api/routes/auth/step_up.rs b/rust/crates/keygo-server/src/api/routes/auth/step_up.rs index de3ea67d4..0eb465072 100644 --- a/rust/crates/keygo-server/src/api/routes/auth/step_up.rs +++ b/rust/crates/keygo-server/src/api/routes/auth/step_up.rs @@ -35,16 +35,11 @@ async fn start( #[cfg(test)] mod tests { - use crate::api::AppState; - use crate::db::devices; - use crate::domain::DeviceId; use crate::testing::{ - PASSWORD, app_state, device_info, device_json, issue_session, post_to, post_with_proof, - post_with_token, prover, register, + PASSWORD, app_state, device_json, post_to, post_with_proof, post_with_token, prover, + signed_in, }; use axum::http::StatusCode; - use keygo_dpop::DpopProver; - use keygo_dpop::testing::TestSigner; use keygo_opaque::CredentialResponse; use keygo_opaque::client::ClientLogin; use keygo_opaque::server::ServerSetup; @@ -53,20 +48,6 @@ mod tests { const START: &str = "/api/v1/auth/step-up/start"; - /// A registered user signed in on a second device, bound to the prover's key. - async fn signed_in(db: &PgPool, prover: &DpopProver) -> (AppState, String) { - let setup = ServerSetup::generate(); - let state = app_state(db, &setup); - let user_id = register(db, &setup, "ada").await; - let device_id = DeviceId::random(); - let mut conn = db.acquire().await.unwrap(); - devices::insert(&mut conn, device_id, user_id, &device_info()) - .await - .unwrap(); - let issued = issue_session(db, user_id, device_id, prover.jkt()).await; - (state, issued.access_token.expose().to_owned()) - } - fn start_body() -> (ClientLogin, Value) { let (client, request) = ClientLogin::start(PASSWORD).unwrap(); (client, json!({ "credential_request": request.to_base64() })) @@ -75,10 +56,11 @@ mod tests { #[sqlx::test] async fn starts_a_step_up_over_http(db: PgPool) { let prover = prover(); - let (state, access_token) = signed_in(&db, &prover).await; + let (state, issued) = signed_in(&db, &prover).await; let (client, body) = start_body(); - let (status, started) = post_with_token(&state, &prover, START, &access_token, body).await; + let (status, started) = + post_with_token(&state, &prover, START, issued.access_token.expose(), body).await; assert_eq!(status, StatusCode::OK); assert_eq!(started["expires_in"], state.step_up_states.ttl().as_secs()); @@ -104,9 +86,10 @@ mod tests { #[sqlx::test] async fn a_step_up_cannot_be_finished_as_a_sign_in(db: PgPool) { let prover = prover(); - let (state, access_token) = signed_in(&db, &prover).await; + let (state, issued) = signed_in(&db, &prover).await; let (client, body) = start_body(); - let (_, started) = post_with_token(&state, &prover, START, &access_token, body).await; + let (_, started) = + post_with_token(&state, &prover, START, issued.access_token.expose(), body).await; let response = CredentialResponse::from_base64(started["credential_response"].as_str().unwrap()) .unwrap(); diff --git a/rust/crates/keygo-server/src/db/opaque_records.rs b/rust/crates/keygo-server/src/db/opaque_records.rs index 810815fd7..358f1dbf7 100644 --- a/rust/crates/keygo-server/src/db/opaque_records.rs +++ b/rust/crates/keygo-server/src/db/opaque_records.rs @@ -88,7 +88,7 @@ mod tests { let setup = ServerSetup::generate(); let (client, request) = ClientRegistration::start(PASSWORD).unwrap(); let response = - server::registration_start(&setup, request, user_id.as_uuid().as_bytes()).unwrap(); + server::registration_start(&setup, request, user_id.opaque_identifier()).unwrap(); let finish = client.finish(PASSWORD, response).unwrap(); server::registration_finish(finish.upload) } diff --git a/rust/crates/keygo-server/src/domain/ids.rs b/rust/crates/keygo-server/src/domain/ids.rs index 066382885..f6f56d40f 100644 --- a/rust/crates/keygo-server/src/domain/ids.rs +++ b/rust/crates/keygo-server/src/domain/ids.rs @@ -109,6 +109,13 @@ impl RegistrationId { } } +impl UserId { + /// What OPAQUE binds the password file to: registration, login and step-up must all agree on it. + pub const fn opaque_identifier(&self) -> &[u8] { + self.0.as_bytes() + } +} + #[cfg(test)] mod tests { use super::*; @@ -140,6 +147,13 @@ mod tests { assert!(RegistrationId::from_base64("_____________________w==").is_err()); } + #[test] + fn opaque_identifier_is_pinned() { + let user_id = UserId::from(Uuid::from_bytes([7; LEN])); + + assert_eq!(user_id.opaque_identifier(), [7; LEN]); + } + #[test] fn error_names_the_field() { let err = LoginId::from_base64("").unwrap_err(); diff --git a/rust/crates/keygo-server/src/service/handshake.rs b/rust/crates/keygo-server/src/service/handshake.rs new file mode 100644 index 000000000..88b4b1513 --- /dev/null +++ b/rust/crates/keygo-server/src/service/handshake.rs @@ -0,0 +1,42 @@ +use crate::cache::{LoginStore, Pending}; +use crate::domain::LoginId; +use keygo_opaque::server::{ServerLogin, ServerSetup}; +use keygo_opaque::{CredentialRequest, CredentialResponse, OpaqueError, PasswordFile}; +use std::time::Duration; + +#[derive(Debug, thiserror::Error)] +pub enum Error { + #[error("login expired or unknown")] + Expired, + #[error(transparent)] + Opaque(#[from] OpaqueError), + #[error("database error")] + Db(#[from] sqlx::Error), +} + +pub struct Started { + pub login_id: LoginId, + pub credential_response: CredentialResponse, + pub expires_in: Duration, +} + +pub(super) fn begin( + states: &LoginStore, + setup: &ServerSetup, + user_id: U, + password_file: Option, + identifier: &[u8], + credential_request: CredentialRequest, +) -> Result { + let (state, credential_response) = + ServerLogin::start(setup, password_file, credential_request, identifier)?; + + let login_id = LoginId::random(); + states.insert(login_id, Pending { user_id, state }); + + Ok(Started { + login_id, + credential_response, + expires_in: states.ttl(), + }) +} diff --git a/rust/crates/keygo-server/src/service/login/finish.rs b/rust/crates/keygo-server/src/service/login/finish.rs index 1fedfdcee..62069add6 100644 --- a/rust/crates/keygo-server/src/service/login/finish.rs +++ b/rust/crates/keygo-server/src/service/login/finish.rs @@ -2,7 +2,7 @@ use crate::cache::LoginStates; use crate::db::users; use crate::domain::{Device, LoginId, TokenIssuer, UserId, Username}; use crate::service; -use crate::service::login::Error; +use crate::service::handshake::Error; use crate::service::session::Issued; use keygo_opaque::{CredentialFinalization, DpopBinding, OpaqueError}; use sqlx::PgPool; diff --git a/rust/crates/keygo-server/src/service/login/mod.rs b/rust/crates/keygo-server/src/service/login/mod.rs index 71a2b7db8..5c75081fc 100644 --- a/rust/crates/keygo-server/src/service/login/mod.rs +++ b/rust/crates/keygo-server/src/service/login/mod.rs @@ -3,15 +3,3 @@ mod start; pub use finish::*; pub use start::*; - -use keygo_opaque::OpaqueError; - -#[derive(Debug, thiserror::Error)] -pub enum Error { - #[error("login expired or unknown")] - Expired, - #[error(transparent)] - Opaque(#[from] OpaqueError), - #[error("database error")] - Db(#[from] sqlx::Error), -} diff --git a/rust/crates/keygo-server/src/service/login/start.rs b/rust/crates/keygo-server/src/service/login/start.rs index a31aa3ea2..0aff41abd 100644 --- a/rust/crates/keygo-server/src/service/login/start.rs +++ b/rust/crates/keygo-server/src/service/login/start.rs @@ -1,23 +1,16 @@ -use crate::cache::{LoginStates, LoginStore, Pending}; +use crate::cache::LoginStates; use crate::db::opaque_records; -use crate::domain::{LoginId, Username}; -use crate::service::login::Error; -use keygo_opaque::server::{ServerLogin, ServerSetup}; -use keygo_opaque::{CredentialRequest, CredentialResponse, PasswordFile}; +use crate::domain::Username; +use crate::service::handshake::{self, Error, Started}; +use keygo_opaque::CredentialRequest; +use keygo_opaque::server::ServerSetup; use sqlx::PgPool; -use std::time::Duration; pub struct StartLogin { pub username: Username, pub credential_request: CredentialRequest, } -pub struct Started { - pub login_id: LoginId, - pub credential_response: CredentialResponse, - pub expires_in: Duration, -} - /// Answers known and unknown usernames alike: an unknown one runs OPAQUE against a fake record /// whose identifier is stable per name, so the client fails at `finish` exactly as for a wrong /// password and the response never says whether the account exists. The identifier needs no @@ -43,12 +36,12 @@ pub async fn start( Some(record) => ( Some(record.user_id), Some(record.file), - record.user_id.as_uuid().as_bytes().to_vec(), + record.user_id.opaque_identifier().to_vec(), ), None => (None, None, fake_identifier(&username)), }; - respond( + handshake::begin( login_states, setup, user_id, @@ -58,27 +51,6 @@ pub async fn start( ) } -pub fn respond( - states: &LoginStore, - setup: &ServerSetup, - user_id: U, - password_file: Option, - identifier: &[u8], - credential_request: CredentialRequest, -) -> Result { - let (state, credential_response) = - ServerLogin::start(setup, password_file, credential_request, identifier)?; - - let login_id = LoginId::random(); - states.insert(login_id, Pending { user_id, state }); - - Ok(Started { - login_id, - credential_response, - expires_in: states.ttl(), - }) -} - /// The domain tag keeps a fake identifier from ever encoding like a real one, a 16-byte user id. /// Usernames never contain NUL, so the separator keeps tag and name unambiguous. fn fake_identifier(username: &Username) -> Vec { diff --git a/rust/crates/keygo-server/src/service/mod.rs b/rust/crates/keygo-server/src/service/mod.rs index 8814f40bb..35e6d1172 100644 --- a/rust/crates/keygo-server/src/service/mod.rs +++ b/rust/crates/keygo-server/src/service/mod.rs @@ -1,4 +1,5 @@ pub mod device; +pub mod handshake; pub mod invite; pub mod login; pub mod registration; diff --git a/rust/crates/keygo-server/src/service/registration/start.rs b/rust/crates/keygo-server/src/service/registration/start.rs index 60c60a3ff..8d817df19 100644 --- a/rust/crates/keygo-server/src/service/registration/start.rs +++ b/rust/crates/keygo-server/src/service/registration/start.rs @@ -78,7 +78,7 @@ pub async fn start( // Pure computation, so it runs before the transaction to keep the reservation's lock short. let registration_response = - server::registration_start(setup, registration_request, user_id.as_uuid().as_bytes())?; + server::registration_start(setup, registration_request, user_id.opaque_identifier())?; let mut tx = db.begin().await?; let registration_id = RegistrationId::random(); diff --git a/rust/crates/keygo-server/src/service/step_up/start.rs b/rust/crates/keygo-server/src/service/step_up/start.rs index bfdc2bf5f..a71637840 100644 --- a/rust/crates/keygo-server/src/service/step_up/start.rs +++ b/rust/crates/keygo-server/src/service/step_up/start.rs @@ -1,7 +1,7 @@ use crate::cache::StepUpStates; use crate::db::opaque_records; use crate::domain::UserId; -use crate::service::login::{self, Error, Started}; +use crate::service::handshake::{self, Error, Started}; use keygo_opaque::server::ServerSetup; use keygo_opaque::{CredentialRequest, OpaqueError}; use sqlx::PgPool; @@ -28,12 +28,12 @@ pub async fn start( .await? .ok_or(OpaqueError::InvalidLogin)?; - login::respond( + handshake::begin( step_up_states, setup, user_id, Some(password_file), - user_id.as_uuid().as_bytes(), + user_id.opaque_identifier(), credential_request, ) } diff --git a/rust/crates/keygo-server/src/testing.rs b/rust/crates/keygo-server/src/testing.rs index 1ce615ebd..31ba55091 100644 --- a/rust/crates/keygo-server/src/testing.rs +++ b/rust/crates/keygo-server/src/testing.rs @@ -5,11 +5,12 @@ use crate::domain::{ AccessTokenKey, Device, DeviceId, DeviceInfo, InviteHash, InvitePepper, SessionId, TokenIssuer, UserId, Username, }; -use crate::service::invite; use crate::service::login::{self, FinishLogin, StartLogin}; use crate::service::registration::{self, FinishRegistration, Signup, StartRegistration}; use crate::service::session::{self, Issued}; +use crate::service::{handshake, invite}; use axum::body::Body; +use axum::http::header::AUTHORIZATION; use axum::http::{HeaderMap, Request, StatusCode}; use http_body_util::BodyExt; use keygo_dpop::DpopVerifier; @@ -120,12 +121,24 @@ pub async fn issue_session( tx.commit().await.unwrap(); issued } +/// A registered user signed in on a device bound to the prover's key. +pub async fn signed_in(db: &PgPool, prover: &DpopProver) -> (AppState, Issued) { + let setup = ServerSetup::generate(); + let user_id = register(db, &setup, "ada").await; + let device_id = DeviceId::random(); + let mut conn = db.acquire().await.unwrap(); + devices::insert(&mut conn, device_id, user_id, &device_info()) + .await + .unwrap(); + let issued = issue_session(db, user_id, device_id, prover.jkt()).await; + (app_state(db, &setup), issued) +} pub async fn start_login( db: &PgPool, login_states: &LoginStates, setup: &ServerSetup, name: &str, -) -> (ClientLogin, login::Started) { +) -> (ClientLogin, handshake::Started) { let (client, credential_request) = ClientLogin::start(PASSWORD).unwrap(); let input = StartLogin { username: username(name), @@ -138,7 +151,7 @@ pub async fn start_login( } pub fn finish_login( client: ClientLogin, - started: login::Started, + started: handshake::Started, device_id: Option, ) -> FinishLogin { let finish = client @@ -233,47 +246,30 @@ pub fn prover() -> DpopProver { DpopProver::new(TestSigner::new()) } -/// Posts with a fresh proof and answers a nonce challenge once, the way a real client would. -pub async fn post_with_proof( +/// Sends the request `build` makes and, on a nonce challenge, once more with the nonce, the way a +/// real client would. +pub async fn send_with_nonce( state: &AppState, - prover: &DpopProver, - uri: &str, - body: Value, + build: impl Fn(Option<&str>) -> Request, ) -> (StatusCode, Value) { - let request = proof_post(state, prover, uri, &body, None); - let (status, headers, response) = send(state, request).await; - if response["code"] != "use_dpop_nonce" { - return (status, response); + let (status, headers, body) = send(state, build(None)).await; + if body["code"] != "use_dpop_nonce" { + return (status, body); } let nonce = headers["dpop-nonce"].to_str().unwrap(); - let request = proof_post(state, prover, uri, &body, Some(nonce)); - let (status, _, response) = send(state, request).await; - (status, response) + let (status, _, body) = send(state, build(Some(nonce))).await; + (status, body) } -pub fn proof_post( +pub async fn post_with_proof( state: &AppState, prover: &DpopProver, uri: &str, - body: &Value, - nonce: Option<&str>, -) -> Request { - let htu = state.public_url.join(uri).unwrap(); - let proof = prover - .proof(&ProofRequest { - htm: Htm::Post, - htu: htu.as_str(), - access_token: None, - nonce, - }) - .unwrap(); - let mut request = json_post(uri, body); - request.headers_mut().insert("dpop", proof.parse().unwrap()); - request + body: Value, +) -> (StatusCode, Value) { + send_with_nonce(state, |nonce| proof_post(state, prover, uri, &body, nonce)).await } - -/// Posts as the session behind `access_token` and answers a nonce challenge once, like -/// `post_with_proof`. +/// Posts as the session behind `access_token`. pub async fn post_with_token( state: &AppState, prover: &DpopProver, @@ -281,41 +277,47 @@ pub async fn post_with_token( access_token: &str, body: Value, ) -> (StatusCode, Value) { - let request = token_post(state, prover, uri, access_token, &body, None); - let (status, headers, response) = send(state, request).await; - if response["code"] != "use_dpop_nonce" { - return (status, response); - } - - let nonce = headers["dpop-nonce"].to_str().unwrap(); - let request = token_post(state, prover, uri, access_token, &body, Some(nonce)); - let (status, _, response) = send(state, request).await; - (status, response) + send_with_nonce(state, |nonce| { + let request = json_post(uri, &body); + with_proof(state, prover, request, Some(access_token), nonce) + }) + .await } -fn token_post( +pub fn proof_post( state: &AppState, prover: &DpopProver, uri: &str, - access_token: &str, body: &Value, nonce: Option<&str>, ) -> Request { - let htu = state.public_url.join(uri).unwrap(); + with_proof(state, prover, json_post(uri, body), None, nonce) +} +/// Signs a proof for the POST `request` makes and attaches it, with the access token it is bound +/// to when one is given. +pub fn with_proof( + state: &AppState, + prover: &DpopProver, + mut request: Request, + access_token: Option<&str>, + nonce: Option<&str>, +) -> Request { + let htu = state.public_url.join(request.uri().path()).unwrap(); let proof = prover .proof(&ProofRequest { htm: Htm::Post, htu: htu.as_str(), - access_token: Some(access_token), + access_token, nonce, }) .unwrap(); - let mut request = json_post(uri, body); let headers = request.headers_mut(); headers.insert("dpop", proof.parse().unwrap()); - headers.insert( - "authorization", - format!("DPoP {access_token}").parse().unwrap(), - ); + if let Some(access_token) = access_token { + headers.insert( + AUTHORIZATION, + format!("DPoP {access_token}").parse().unwrap(), + ); + } request } From 01e68b9a2a8956d00131df5ed1b25223451cd24c Mon Sep 17 00:00:00 2001 From: Davis Wolfermann Date: Sun, 1 Nov 2026 00:08:13 +0100 Subject: [PATCH 3/5] feat(server): implement step-up/finish --- ...86b4e59699fe2e24518d029bae987264eef4a.json | 15 ++ .../src/api/routes/auth/step_up.rs | 250 +++++++++++++++++- rust/crates/keygo-server/src/db/sessions.rs | 15 ++ .../src/service/step_up/finish.rs | 49 ++++ .../keygo-server/src/service/step_up/mod.rs | 2 + 5 files changed, 325 insertions(+), 6 deletions(-) create mode 100644 rust/crates/keygo-server/.sqlx/query-aceadb1c5ec90befc10e1217c4386b4e59699fe2e24518d029bae987264eef4a.json create mode 100644 rust/crates/keygo-server/src/service/step_up/finish.rs diff --git a/rust/crates/keygo-server/.sqlx/query-aceadb1c5ec90befc10e1217c4386b4e59699fe2e24518d029bae987264eef4a.json b/rust/crates/keygo-server/.sqlx/query-aceadb1c5ec90befc10e1217c4386b4e59699fe2e24518d029bae987264eef4a.json new file mode 100644 index 000000000..d0ece52a8 --- /dev/null +++ b/rust/crates/keygo-server/.sqlx/query-aceadb1c5ec90befc10e1217c4386b4e59699fe2e24518d029bae987264eef4a.json @@ -0,0 +1,15 @@ +{ + "db_name": "PostgreSQL", + "query": "update sessions set auth_time = to_timestamp($1::int8) where id = $2", + "describe": { + "columns": [], + "parameters": { + "Left": [ + "Int8", + "Uuid" + ] + }, + "nullable": [] + }, + "hash": "aceadb1c5ec90befc10e1217c4386b4e59699fe2e24518d029bae987264eef4a" +} diff --git a/rust/crates/keygo-server/src/api/routes/auth/step_up.rs b/rust/crates/keygo-server/src/api/routes/auth/step_up.rs index 0eb465072..934391d61 100644 --- a/rust/crates/keygo-server/src/api/routes/auth/step_up.rs +++ b/rust/crates/keygo-server/src/api/routes/auth/step_up.rs @@ -1,15 +1,18 @@ use crate::api::authenticated::Authenticated; use crate::api::routes::auth::handshake::StartResponse; use crate::api::{AppState, Json, ServerResult}; -use crate::service::step_up::{self, StartStepUp}; +use crate::domain::{ACCESS_TOKEN_LIFETIME, AccessToken, LoginId}; +use crate::service::step_up::{self, FinishStepUp, StartStepUp}; use axum::Router; use axum::extract::State; use axum::routing::post; -use keygo_opaque::CredentialRequest; -use serde::Deserialize; +use keygo_opaque::{CredentialFinalization, CredentialRequest, DpopBinding}; +use serde::{Deserialize, Serialize}; pub fn router() -> Router { - Router::new().route("/start", post(start)) + Router::new() + .route("/start", post(start)) + .route("/finish", post(finish)) } #[derive(Deserialize)] @@ -17,6 +20,20 @@ struct StartRequest { credential_request: CredentialRequest, } +#[derive(Deserialize)] +struct FinishRequest { + login_id: LoginId, + credential_finalization: CredentialFinalization, + dpop_binding: DpopBinding, +} + +#[derive(Serialize)] +struct FinishResponse { + access_token: AccessToken, + access_expires_in: u64, + auth_time: u64, +} + async fn start( State(state): State, authenticated: Authenticated, @@ -33,13 +50,44 @@ async fn start( Ok(Json(started.into())) } +async fn finish( + State(state): State, + authenticated: Authenticated, + Json(request): Json, +) -> ServerResult> { + let input = FinishStepUp { + session_id: authenticated.claims().session_id(), + user_id: authenticated.claims().user_id(), + login_id: request.login_id, + credential_finalization: request.credential_finalization, + binding: request.dpop_binding, + jkt: *authenticated.claims().jkt(), + }; + + let finished = + step_up::finish(&state.db, &state.step_up_states, &state.token_issuer, input).await?; + + Ok(Json(FinishResponse { + access_token: finished.access_token, + access_expires_in: ACCESS_TOKEN_LIFETIME.as_secs(), + auth_time: finished.auth_time, + })) +} + #[cfg(test)] mod tests { + use crate::api::AppState; + use crate::db::devices; + use crate::domain::{ + ACCESS_TOKEN_LIFETIME, AccessToken, DeviceId, FRESH_AUTH_WINDOW, SessionId, unix_now, + }; use crate::testing::{ - PASSWORD, app_state, device_json, post_to, post_with_proof, post_with_token, prover, - signed_in, + PASSWORD, app_state, count, device_info, device_json, issue_session, post_to, + post_with_proof, post_with_token, prover, signed_in, }; use axum::http::StatusCode; + use keygo_dpop::DpopProver; + use keygo_dpop::testing::TestSigner; use keygo_opaque::CredentialResponse; use keygo_opaque::client::ClientLogin; use keygo_opaque::server::ServerSetup; @@ -47,12 +95,76 @@ mod tests { use sqlx::PgPool; const START: &str = "/api/v1/auth/step-up/start"; + const FINISH: &str = "/api/v1/auth/step-up/finish"; fn start_body() -> (ClientLogin, Value) { let (client, request) = ClientLogin::start(PASSWORD).unwrap(); (client, json!({ "credential_request": request.to_base64() })) } + async fn start_over_http( + state: &AppState, + prover: &DpopProver, + access_token: &str, + ) -> (ClientLogin, Value) { + let (client, body) = start_body(); + let (status, started) = post_with_token(state, prover, START, access_token, body).await; + assert_eq!(status, StatusCode::OK); + (client, started) + } + + fn finish_body(client: ClientLogin, started: &Value, jkt: &[u8; 32]) -> Value { + let response = + CredentialResponse::from_base64(started["credential_response"].as_str().unwrap()) + .unwrap(); + let finish = client.finish(PASSWORD, response).unwrap(); + json!({ + "login_id": started["login_id"], + "credential_finalization": finish.finalization.to_base64(), + "dpop_binding": finish.session_key.dpop_binding(jkt).to_base64(), + }) + } + + struct Stale { + session_id: SessionId, + auth_time: u64, + access_token: String, + } + + /// Moves the session behind `access_token` past the step-up window, row and token alike. + async fn go_stale(state: &AppState, access_token: &AccessToken) -> Stale { + let claims = state.token_issuer.verify(access_token.expose()).unwrap(); + let auth_time = unix_now() - FRESH_AUTH_WINDOW.as_secs() - 1; + sqlx::query("update sessions set auth_time = to_timestamp($1) where id = $2") + .bind(auth_time as i64) + .bind(claims.session_id().as_uuid()) + .execute(&state.db) + .await + .unwrap(); + let token = state.token_issuer.issue( + claims.user_id(), + claims.session_id(), + auth_time, + claims.jkt(), + ); + Stale { + session_id: claims.session_id(), + auth_time, + access_token: token.expose().to_owned(), + } + } + + async fn auth_time_of(db: &PgPool, session_id: SessionId) -> u64 { + let auth_time: i64 = sqlx::query_scalar( + "select extract(epoch from auth_time)::int8 from sessions where id = $1", + ) + .bind(session_id.as_uuid()) + .fetch_one(db) + .await + .unwrap(); + auth_time as u64 + } + #[sqlx::test] async fn starts_a_step_up_over_http(db: PgPool) { let prover = prover(); @@ -108,4 +220,130 @@ mod tests { assert_eq!(response["code"], "login_expired"); assert_eq!(state.step_up_states.count(), 1); } + + #[sqlx::test] + async fn finish_makes_a_stale_session_fresh(db: PgPool) { + let prover = prover(); + let (state, issued) = signed_in(&db, &prover).await; + let stale = go_stale(&state, &issued.access_token).await; + let (client, started) = start_over_http(&state, &prover, &stale.access_token).await; + let body = finish_body(client, &started, prover.jkt()); + + let (status, finished) = + post_with_token(&state, &prover, FINISH, &stale.access_token, body).await; + + assert_eq!(status, StatusCode::OK); + let claims = state + .token_issuer + .verify(finished["access_token"].as_str().unwrap()) + .unwrap(); + assert!(claims.is_fresh()); + assert_eq!(claims.session_id(), stale.session_id); + assert_eq!(claims.jkt(), prover.jkt()); + assert_eq!(finished["auth_time"], claims.auth_time()); + assert_eq!( + finished["access_expires_in"], + ACCESS_TOKEN_LIFETIME.as_secs() + ); + assert_eq!( + auth_time_of(&db, stale.session_id).await, + claims.auth_time() + ); + assert_eq!(state.step_up_states.count(), 0); + } + + #[sqlx::test] + async fn finish_keeps_the_session_and_its_refresh_token(db: PgPool) { + let prover = prover(); + let (state, issued) = signed_in(&db, &prover).await; + let stale = go_stale(&state, &issued.access_token).await; + let (client, started) = start_over_http(&state, &prover, &stale.access_token).await; + let body = finish_body(client, &started, prover.jkt()); + let sessions = count(&db, "sessions").await; + + let (_, finished) = + post_with_token(&state, &prover, FINISH, &stale.access_token, body).await; + + assert!(finished.get("refresh_token").is_none()); + assert_eq!(count(&db, "sessions").await, sessions); + let rotated: bool = sqlx::query_scalar( + "select rotated_at is not null from refresh_tokens where session_id = $1", + ) + .bind(stale.session_id.as_uuid()) + .fetch_one(&db) + .await + .unwrap(); + assert!(!rotated); + } + + #[sqlx::test] + async fn binding_for_another_key_is_unauthorized(db: PgPool) { + let prover = prover(); + let (state, issued) = signed_in(&db, &prover).await; + let stale = go_stale(&state, &issued.access_token).await; + let (client, started) = start_over_http(&state, &prover, &stale.access_token).await; + let body = finish_body(client, &started, &[0x41; 32]); + + let (status, body) = + post_with_token(&state, &prover, FINISH, &stale.access_token, body).await; + + assert_eq!(status, StatusCode::UNAUTHORIZED); + assert_eq!(body["code"], "invalid_credentials"); + assert_eq!(auth_time_of(&db, stale.session_id).await, stale.auth_time); + assert_eq!(state.step_up_states.count(), 0); + } + + #[sqlx::test] + async fn a_relayed_step_up_does_not_freshen_another_session(db: PgPool) { + let victim = prover(); + let (state, issued) = signed_in(&db, &victim).await; + let user_id = state + .token_issuer + .verify(issued.access_token.expose()) + .unwrap() + .user_id(); + let attacker = DpopProver::new(TestSigner::from_seed(9)); + let device_id = DeviceId::random(); + let mut conn = db.acquire().await.unwrap(); + devices::insert(&mut conn, device_id, user_id, &device_info()) + .await + .unwrap(); + let attacker_session = issue_session(&db, user_id, device_id, attacker.jkt()).await; + let stale = go_stale(&state, &attacker_session.access_token).await; + // The victim's client binds the run to its own key; the attacker forwards it unchanged. + let (client, started) = start_over_http(&state, &attacker, &stale.access_token).await; + let body = finish_body(client, &started, victim.jkt()); + + let (status, body) = + post_with_token(&state, &attacker, FINISH, &stale.access_token, body).await; + + assert_eq!(status, StatusCode::UNAUTHORIZED); + assert_eq!(body["code"], "invalid_credentials"); + assert_eq!(auth_time_of(&db, stale.session_id).await, stale.auth_time); + } + + #[sqlx::test] + async fn replayed_finish_is_expired(db: PgPool) { + let prover = prover(); + let (state, issued) = signed_in(&db, &prover).await; + let token = issued.access_token.expose(); + let (client, started) = start_over_http(&state, &prover, token).await; + let body = finish_body(client, &started, prover.jkt()); + + let (accepted, _) = post_with_token(&state, &prover, FINISH, token, body.clone()).await; + let (status, body) = post_with_token(&state, &prover, FINISH, token, body).await; + + assert_eq!(accepted, StatusCode::OK); + assert_eq!(status, StatusCode::BAD_REQUEST); + assert_eq!(body["code"], "login_expired"); + } + + #[sqlx::test] + async fn finish_requires_an_access_token(db: PgPool) { + let (status, response) = + post_to(app_state(&db, &ServerSetup::generate()), FINISH, json!({})).await; + + assert_eq!(status, StatusCode::UNAUTHORIZED); + assert_eq!(response["code"], "invalid_token"); + } } diff --git a/rust/crates/keygo-server/src/db/sessions.rs b/rust/crates/keygo-server/src/db/sessions.rs index e3798f4bd..1566c5a48 100644 --- a/rust/crates/keygo-server/src/db/sessions.rs +++ b/rust/crates/keygo-server/src/db/sessions.rs @@ -26,6 +26,21 @@ pub async fn insert( Ok(()) } +pub async fn touch_auth_time( + conn: &mut PgConnection, + session_id: SessionId, + auth_time: u64, +) -> sqlx::Result<()> { + sqlx::query!( + "update sessions set auth_time = to_timestamp($1::int8) where id = $2", + i64::try_from(auth_time).expect("auth_time fits a timestamptz"), + session_id.as_uuid(), + ) + .execute(conn) + .await?; + Ok(()) +} + pub async fn revoke_by_device( conn: &mut PgConnection, device_id: DeviceId, diff --git a/rust/crates/keygo-server/src/service/step_up/finish.rs b/rust/crates/keygo-server/src/service/step_up/finish.rs new file mode 100644 index 000000000..91f02a9f2 --- /dev/null +++ b/rust/crates/keygo-server/src/service/step_up/finish.rs @@ -0,0 +1,49 @@ +use crate::cache::StepUpStates; +use crate::db::sessions; +use crate::domain::{AccessToken, LoginId, SessionId, TokenIssuer, UserId, unix_now}; +use crate::service::handshake::Error; +use keygo_opaque::{CredentialFinalization, DpopBinding}; +use sqlx::PgPool; + +pub struct FinishStepUp { + pub session_id: SessionId, + pub user_id: UserId, + pub login_id: LoginId, + pub credential_finalization: CredentialFinalization, + pub binding: DpopBinding, + pub jkt: [u8; 32], +} + +pub struct IssuedStepUp { + pub access_token: AccessToken, + pub auth_time: u64, +} + +pub async fn finish( + db: &PgPool, + step_up_states: &StepUpStates, + token_issuer: &TokenIssuer, + input: FinishStepUp, +) -> Result { + let FinishStepUp { + session_id, + user_id, + login_id, + credential_finalization, + binding, + jkt, + } = input; + + let pending = step_up_states.take(&login_id).ok_or(Error::Expired)?; + let session_key = pending.state.finish(credential_finalization)?; + session_key.verify_dpop_binding(&jkt, &binding)?; + + let auth_time = unix_now(); + let mut conn = db.acquire().await?; + sessions::touch_auth_time(&mut conn, session_id, auth_time).await?; + + Ok(IssuedStepUp { + access_token: token_issuer.issue(user_id, session_id, auth_time, &jkt), + auth_time, + }) +} diff --git a/rust/crates/keygo-server/src/service/step_up/mod.rs b/rust/crates/keygo-server/src/service/step_up/mod.rs index d2a875010..5c75081fc 100644 --- a/rust/crates/keygo-server/src/service/step_up/mod.rs +++ b/rust/crates/keygo-server/src/service/step_up/mod.rs @@ -1,3 +1,5 @@ +mod finish; mod start; +pub use finish::*; pub use start::*; From d0689214a7b3372b9d435eef081fc0780b85f730 Mon Sep 17 00:00:00 2001 From: Davis Wolfermann Date: Sun, 1 Nov 2026 00:47:54 +0100 Subject: [PATCH 4/5] refactor(server): share OPAQUE finish between login and step-up --- ...4851bfbd1e00935f2a410f8dfb7cf65a1246.json} | 4 +- .../src/api/routes/auth/session.rs | 22 +++- .../src/api/routes/auth/step_up.rs | 44 +++++-- rust/crates/keygo-server/src/db/sessions.rs | 46 ++++++- .../keygo-server/src/service/handshake.rs | 18 ++- .../keygo-server/src/service/login/finish.rs | 16 ++- .../keygo-server/src/service/session.rs | 24 ++++ .../src/service/step_up/finish.rs | 121 +++++++++++++++--- 8 files changed, 252 insertions(+), 43 deletions(-) rename rust/crates/keygo-server/.sqlx/{query-aceadb1c5ec90befc10e1217c4386b4e59699fe2e24518d029bae987264eef4a.json => query-4fad07c358db053c13108d6a82554851bfbd1e00935f2a410f8dfb7cf65a1246.json} (60%) diff --git a/rust/crates/keygo-server/.sqlx/query-aceadb1c5ec90befc10e1217c4386b4e59699fe2e24518d029bae987264eef4a.json b/rust/crates/keygo-server/.sqlx/query-4fad07c358db053c13108d6a82554851bfbd1e00935f2a410f8dfb7cf65a1246.json similarity index 60% rename from rust/crates/keygo-server/.sqlx/query-aceadb1c5ec90befc10e1217c4386b4e59699fe2e24518d029bae987264eef4a.json rename to rust/crates/keygo-server/.sqlx/query-4fad07c358db053c13108d6a82554851bfbd1e00935f2a410f8dfb7cf65a1246.json index d0ece52a8..56941dbf0 100644 --- a/rust/crates/keygo-server/.sqlx/query-aceadb1c5ec90befc10e1217c4386b4e59699fe2e24518d029bae987264eef4a.json +++ b/rust/crates/keygo-server/.sqlx/query-4fad07c358db053c13108d6a82554851bfbd1e00935f2a410f8dfb7cf65a1246.json @@ -1,6 +1,6 @@ { "db_name": "PostgreSQL", - "query": "update sessions set auth_time = to_timestamp($1::int8) where id = $2", + "query": "update sessions set auth_time = to_timestamp($1::int8)\n where id = $2 and revoked_at is null and expires_at > now()", "describe": { "columns": [], "parameters": { @@ -11,5 +11,5 @@ }, "nullable": [] }, - "hash": "aceadb1c5ec90befc10e1217c4386b4e59699fe2e24518d029bae987264eef4a" + "hash": "4fad07c358db053c13108d6a82554851bfbd1e00935f2a410f8dfb7cf65a1246" } diff --git a/rust/crates/keygo-server/src/api/routes/auth/session.rs b/rust/crates/keygo-server/src/api/routes/auth/session.rs index e27926d6f..abe60d5c6 100644 --- a/rust/crates/keygo-server/src/api/routes/auth/session.rs +++ b/rust/crates/keygo-server/src/api/routes/auth/session.rs @@ -3,10 +3,25 @@ use crate::service::session::Issued; use serde::Serialize; #[derive(Serialize)] -pub struct Session { - device_id: DeviceId, +pub struct Access { access_token: AccessToken, access_expires_in: u64, +} + +impl From for Access { + fn from(access_token: AccessToken) -> Self { + Self { + access_token, + access_expires_in: ACCESS_TOKEN_LIFETIME.as_secs(), + } + } +} + +#[derive(Serialize)] +pub struct Session { + device_id: DeviceId, + #[serde(flatten)] + access: Access, refresh_token: RefreshToken, refresh_expires_in: u64, } @@ -15,8 +30,7 @@ impl From for Session { fn from(value: Issued) -> Self { Self { device_id: value.device_id, - access_token: value.access_token, - access_expires_in: ACCESS_TOKEN_LIFETIME.as_secs(), + access: value.access_token.into(), refresh_token: value.refresh_token, refresh_expires_in: value.refresh_expires_in.as_secs(), } diff --git a/rust/crates/keygo-server/src/api/routes/auth/step_up.rs b/rust/crates/keygo-server/src/api/routes/auth/step_up.rs index 934391d61..27dabe28a 100644 --- a/rust/crates/keygo-server/src/api/routes/auth/step_up.rs +++ b/rust/crates/keygo-server/src/api/routes/auth/step_up.rs @@ -1,14 +1,32 @@ -use crate::api::authenticated::Authenticated; +use crate::api::authenticated::{AuthError, Authenticated}; use crate::api::routes::auth::handshake::StartResponse; -use crate::api::{AppState, Json, ServerResult}; -use crate::domain::{ACCESS_TOKEN_LIFETIME, AccessToken, LoginId}; -use crate::service::step_up::{self, FinishStepUp, StartStepUp}; +use crate::api::routes::auth::session::Access; +use crate::api::{AppState, ErrorCode, HttpError, Json, ServerResult}; +use crate::domain::LoginId; +use crate::service::step_up::{self, FinishError, FinishStepUp, StartStepUp}; use axum::Router; use axum::extract::State; +use axum::http::HeaderMap; use axum::routing::post; use keygo_opaque::{CredentialFinalization, CredentialRequest, DpopBinding}; use serde::{Deserialize, Serialize}; +impl HttpError for FinishError { + fn code(&self) -> ErrorCode { + match self { + Self::Handshake(err) => err.code(), + Self::SessionEnded => AuthError::Revoked(None).code(), + } + } + + fn headers(&self) -> HeaderMap { + match self { + Self::Handshake(err) => err.headers(), + Self::SessionEnded => AuthError::Revoked(None).headers(), + } + } +} + pub fn router() -> Router { Router::new() .route("/start", post(start)) @@ -29,8 +47,8 @@ struct FinishRequest { #[derive(Serialize)] struct FinishResponse { - access_token: AccessToken, - access_expires_in: u64, + #[serde(flatten)] + access: Access, auth_time: u64, } @@ -68,8 +86,7 @@ async fn finish( step_up::finish(&state.db, &state.step_up_states, &state.token_issuer, input).await?; Ok(Json(FinishResponse { - access_token: finished.access_token, - access_expires_in: ACCESS_TOKEN_LIFETIME.as_secs(), + access: finished.access_token.into(), auth_time: finished.auth_time, })) } @@ -77,10 +94,12 @@ async fn finish( #[cfg(test)] mod tests { use crate::api::AppState; + use crate::api::error::render; use crate::db::devices; use crate::domain::{ ACCESS_TOKEN_LIFETIME, AccessToken, DeviceId, FRESH_AUTH_WINDOW, SessionId, unix_now, }; + use crate::service::step_up::FinishError; use crate::testing::{ PASSWORD, app_state, count, device_info, device_json, issue_session, post_to, post_with_proof, post_with_token, prover, signed_in, @@ -346,4 +365,13 @@ mod tests { assert_eq!(status, StatusCode::UNAUTHORIZED); assert_eq!(response["code"], "invalid_token"); } + + #[tokio::test] + async fn a_session_ended_meanwhile_answers_like_a_revoked_one() { + let (status, body) = render(FinishError::SessionEnded).await; + + assert_eq!(status, StatusCode::UNAUTHORIZED); + assert_eq!(body["code"], "session_revoked"); + assert!(body.get("reason").is_none()); + } } diff --git a/rust/crates/keygo-server/src/db/sessions.rs b/rust/crates/keygo-server/src/db/sessions.rs index 1566c5a48..7c40fbeed 100644 --- a/rust/crates/keygo-server/src/db/sessions.rs +++ b/rust/crates/keygo-server/src/db/sessions.rs @@ -30,15 +30,17 @@ pub async fn touch_auth_time( conn: &mut PgConnection, session_id: SessionId, auth_time: u64, -) -> sqlx::Result<()> { - sqlx::query!( - "update sessions set auth_time = to_timestamp($1::int8) where id = $2", +) -> sqlx::Result { + let result = sqlx::query!( + "update sessions set auth_time = to_timestamp($1::int8) + where id = $2 and revoked_at is null and expires_at > now()", i64::try_from(auth_time).expect("auth_time fits a timestamptz"), session_id.as_uuid(), ) .execute(conn) .await?; - Ok(()) + + Ok(result.rows_affected() == 1) } pub async fn revoke_by_device( @@ -210,6 +212,42 @@ mod tests { assert_eq!(count(&db, "sessions").await, 0); } + async fn auth_time_of(db: &PgPool) -> i64 { + sqlx::query_scalar("select extract(epoch from auth_time)::int8 from sessions") + .fetch_one(db) + .await + .unwrap() + } + + #[sqlx::test] + async fn touch_auth_time_restarts_a_live_session(db: PgPool) { + let (_, id) = insert_session(&db).await; + let mut conn = db.acquire().await.unwrap(); + + assert!(touch_auth_time(&mut conn, id, AUTH_TIME).await.unwrap()); + assert_eq!(auth_time_of(&db).await, AUTH_TIME as i64); + } + + #[sqlx::test] + async fn touch_auth_time_leaves_a_revoked_session_alone(db: PgPool) { + let (_, id) = insert_session(&db).await; + let mut conn = db.acquire().await.unwrap(); + revoke(&mut conn, id, RevokeReason::Logout).await.unwrap(); + + assert!(!touch_auth_time(&mut conn, id, AUTH_TIME).await.unwrap()); + assert_eq!(auth_time_of(&db).await, 0); + } + + #[sqlx::test] + async fn touch_auth_time_leaves_an_expired_session_alone(db: PgPool) { + let (_, id) = insert_session(&db).await; + expire(&db, "sessions").await; + let mut conn = db.acquire().await.unwrap(); + + assert!(!touch_auth_time(&mut conn, id, AUTH_TIME).await.unwrap()); + assert_eq!(auth_time_of(&db).await, 0); + } + #[sqlx::test] async fn revoke_records_the_reason(db: PgPool) { let (device_id, _) = insert_session(&db).await; diff --git a/rust/crates/keygo-server/src/service/handshake.rs b/rust/crates/keygo-server/src/service/handshake.rs index 88b4b1513..0a0765fe0 100644 --- a/rust/crates/keygo-server/src/service/handshake.rs +++ b/rust/crates/keygo-server/src/service/handshake.rs @@ -1,7 +1,10 @@ use crate::cache::{LoginStore, Pending}; use crate::domain::LoginId; use keygo_opaque::server::{ServerLogin, ServerSetup}; -use keygo_opaque::{CredentialRequest, CredentialResponse, OpaqueError, PasswordFile}; +use keygo_opaque::{ + CredentialFinalization, CredentialRequest, CredentialResponse, DpopBinding, OpaqueError, + PasswordFile, +}; use std::time::Duration; #[derive(Debug, thiserror::Error)] @@ -40,3 +43,16 @@ pub(super) fn begin( expires_in: states.ttl(), }) } + +pub(super) fn complete( + states: &LoginStore, + login_id: &LoginId, + credential_finalization: CredentialFinalization, + binding: &DpopBinding, + jkt: &[u8; 32], +) -> Result { + let pending = states.take(login_id).ok_or(Error::Expired)?; + let session_key = pending.state.finish(credential_finalization)?; + session_key.verify_dpop_binding(jkt, binding)?; + Ok(pending.user_id) +} diff --git a/rust/crates/keygo-server/src/service/login/finish.rs b/rust/crates/keygo-server/src/service/login/finish.rs index 62069add6..7931c3242 100644 --- a/rust/crates/keygo-server/src/service/login/finish.rs +++ b/rust/crates/keygo-server/src/service/login/finish.rs @@ -2,7 +2,7 @@ use crate::cache::LoginStates; use crate::db::users; use crate::domain::{Device, LoginId, TokenIssuer, UserId, Username}; use crate::service; -use crate::service::handshake::Error; +use crate::service::handshake::{self, Error}; use crate::service::session::Issued; use keygo_opaque::{CredentialFinalization, DpopBinding, OpaqueError}; use sqlx::PgPool; @@ -21,8 +21,6 @@ pub struct Finished { pub session: Issued, } -/// The state is consumed before verifying, so a failed finish cannot be retried with the same -/// `login_id`: every password guess costs a fresh `start`. pub async fn finish( db: &PgPool, token_issuer: &TokenIssuer, @@ -37,13 +35,17 @@ pub async fn finish( jkt, } = input; - let pending = login_states.take(&login_id).ok_or(Error::Expired)?; - let session_key = pending.state.finish(credential_finalization)?; - session_key.verify_dpop_binding(&jkt, &binding)?; + let user_id = handshake::complete( + login_states, + &login_id, + credential_finalization, + &binding, + &jkt, + )?; // The fake path cannot produce a valid finalization, and an account deleted since `start` has // no user left to log into; both answer exactly like a wrong password. - let user_id = pending.user_id.ok_or(OpaqueError::InvalidLogin)?; + let user_id = user_id.ok_or(OpaqueError::InvalidLogin)?; let mut tx = db.begin().await?; let username = users::find_username(&mut tx, user_id) diff --git a/rust/crates/keygo-server/src/service/session.rs b/rust/crates/keygo-server/src/service/session.rs index c1b1e169e..6e5505cd4 100644 --- a/rust/crates/keygo-server/src/service/session.rs +++ b/rust/crates/keygo-server/src/service/session.rs @@ -38,6 +38,30 @@ pub async fn issue( }) } +pub struct Freshened { + pub access_token: AccessToken, + pub auth_time: u64, +} + +pub async fn freshen( + db: &PgPool, + token_issuer: &TokenIssuer, + user_id: UserId, + session_id: SessionId, + jkt: &[u8; 32], +) -> sqlx::Result> { + let auth_time = unix_now(); + let mut conn = db.acquire().await?; + if !sessions::touch_auth_time(&mut conn, session_id, auth_time).await? { + return Ok(None); + } + + Ok(Some(Freshened { + access_token: token_issuer.issue(user_id, session_id, auth_time, jkt), + auth_time, + })) +} + pub async fn logout(db: &PgPool, session_id: SessionId) -> sqlx::Result<()> { let mut conn = db.acquire().await?; sessions::revoke(&mut conn, session_id, RevokeReason::Logout).await diff --git a/rust/crates/keygo-server/src/service/step_up/finish.rs b/rust/crates/keygo-server/src/service/step_up/finish.rs index 91f02a9f2..f7859d1b0 100644 --- a/rust/crates/keygo-server/src/service/step_up/finish.rs +++ b/rust/crates/keygo-server/src/service/step_up/finish.rs @@ -1,9 +1,11 @@ use crate::cache::StepUpStates; -use crate::db::sessions; -use crate::domain::{AccessToken, LoginId, SessionId, TokenIssuer, UserId, unix_now}; -use crate::service::handshake::Error; +use crate::domain::{LoginId, SessionId, TokenIssuer, UserId}; +use crate::service; +use crate::service::handshake::{self, Error}; +use crate::service::session::Freshened; use keygo_opaque::{CredentialFinalization, DpopBinding}; use sqlx::PgPool; +use thiserror::Error; pub struct FinishStepUp { pub session_id: SessionId, @@ -14,9 +16,12 @@ pub struct FinishStepUp { pub jkt: [u8; 32], } -pub struct IssuedStepUp { - pub access_token: AccessToken, - pub auth_time: u64, +#[derive(Debug, Error)] +pub enum FinishError { + #[error(transparent)] + Handshake(#[from] Error), + #[error("session ended")] + SessionEnded, } pub async fn finish( @@ -24,7 +29,7 @@ pub async fn finish( step_up_states: &StepUpStates, token_issuer: &TokenIssuer, input: FinishStepUp, -) -> Result { +) -> Result { let FinishStepUp { session_id, user_id, @@ -34,16 +39,98 @@ pub async fn finish( jkt, } = input; - let pending = step_up_states.take(&login_id).ok_or(Error::Expired)?; - let session_key = pending.state.finish(credential_finalization)?; - session_key.verify_dpop_binding(&jkt, &binding)?; + let started_by = handshake::complete( + step_up_states, + &login_id, + credential_finalization, + &binding, + &jkt, + )?; + if started_by != user_id { + return Err(Error::Expired.into()); + } + + service::session::freshen(db, token_issuer, user_id, session_id, &jkt) + .await + .map_err(Error::from)? + .ok_or(FinishError::SessionEnded) +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::db::{devices, sessions}; + use crate::domain::{DeviceId, RevokeReason}; + use crate::service::step_up::{StartStepUp, start}; + use crate::testing::{JKT, PASSWORD, device_info, issue_session, register, token_issuer}; + use keygo_opaque::client::ClientLogin; + use keygo_opaque::server::ServerSetup; + + async fn step_up_as( + db: &PgPool, + states: &StepUpStates, + setup: &ServerSetup, + started_by: UserId, + finished_by: UserId, + session_id: SessionId, + ) -> Result { + let (client, credential_request) = ClientLogin::start(PASSWORD).unwrap(); + let input = StartStepUp { + user_id: started_by, + credential_request, + }; + let started = start(db, states, setup, input).await.unwrap(); + let finished = client + .finish(PASSWORD, started.credential_response) + .unwrap(); + let input = FinishStepUp { + session_id, + user_id: finished_by, + login_id: started.login_id, + credential_finalization: finished.finalization, + binding: finished.session_key.dpop_binding(&JKT), + jkt: JKT, + }; + + finish(db, states, &token_issuer(), input).await + } + + #[sqlx::test] + async fn finish_rejects_a_step_up_started_by_another_user(db: PgPool) { + let states = StepUpStates::new(); + let setup = ServerSetup::generate(); + let ada = register(&db, &setup, "ada").await; + let bob = register(&db, &setup, "bob").await; + + let result = step_up_as(&db, &states, &setup, ada, bob, SessionId::random()).await; + + assert!(matches!( + result, + Err(FinishError::Handshake(Error::Expired)) + )); + } + + #[sqlx::test] + async fn finish_refuses_a_session_that_ended_meanwhile(db: PgPool) { + let states = StepUpStates::new(); + let setup = ServerSetup::generate(); + let ada = register(&db, &setup, "ada").await; + let device_id = DeviceId::random(); + let mut conn = db.acquire().await.unwrap(); + devices::insert(&mut conn, device_id, ada, &device_info()) + .await + .unwrap(); + let issued = issue_session(&db, ada, device_id, &JKT).await; + let session_id = token_issuer() + .verify(issued.access_token.expose()) + .unwrap() + .session_id(); + sessions::revoke(&mut conn, session_id, RevokeReason::Logout) + .await + .unwrap(); - let auth_time = unix_now(); - let mut conn = db.acquire().await?; - sessions::touch_auth_time(&mut conn, session_id, auth_time).await?; + let result = step_up_as(&db, &states, &setup, ada, ada, session_id).await; - Ok(IssuedStepUp { - access_token: token_issuer.issue(user_id, session_id, auth_time, &jkt), - auth_time, - }) + assert!(matches!(result, Err(FinishError::SessionEnded))); + } } From d88a600511497669125d66f8f8d5c937f12074c5 Mon Sep 17 00:00:00 2001 From: Davis Wolfermann Date: Sun, 1 Nov 2026 15:07:56 +0100 Subject: [PATCH 5/5] fix(clippy): drop expected dead code --- rust/crates/keygo-server/src/domain/access_token.rs | 4 ---- 1 file changed, 4 deletions(-) diff --git a/rust/crates/keygo-server/src/domain/access_token.rs b/rust/crates/keygo-server/src/domain/access_token.rs index e0d5b0f34..c4ab0f57f 100644 --- a/rust/crates/keygo-server/src/domain/access_token.rs +++ b/rust/crates/keygo-server/src/domain/access_token.rs @@ -143,10 +143,6 @@ impl Claims { } } - #[cfg_attr( - not(test), - expect(dead_code, reason = "no route requires a fresh sign-in yet") - )] pub fn user_id(&self) -> UserId { self.user_id }