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/.sqlx/query-4fad07c358db053c13108d6a82554851bfbd1e00935f2a410f8dfb7cf65a1246.json b/rust/crates/keygo-server/.sqlx/query-4fad07c358db053c13108d6a82554851bfbd1e00935f2a410f8dfb7cf65a1246.json new file mode 100644 index 000000000..56941dbf0 --- /dev/null +++ b/rust/crates/keygo-server/.sqlx/query-4fad07c358db053c13108d6a82554851bfbd1e00935f2a410f8dfb7cf65a1246.json @@ -0,0 +1,15 @@ +{ + "db_name": "PostgreSQL", + "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": { + "Left": [ + "Int8", + "Uuid" + ] + }, + "nullable": [] + }, + "hash": "4fad07c358db053c13108d6a82554851bfbd1e00935f2a410f8dfb7cf65a1246" +} diff --git a/rust/crates/keygo-server/src/api/mod.rs b/rust/crates/keygo-server/src/api/mod.rs index 850f68a36..52755e291 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..fa3110201 --- /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::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 handshake::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: handshake::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(handshake::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(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/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/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/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/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 new file mode 100644 index 000000000..27dabe28a --- /dev/null +++ b/rust/crates/keygo-server/src/api/routes/auth/step_up.rs @@ -0,0 +1,377 @@ +use crate::api::authenticated::{AuthError, Authenticated}; +use crate::api::routes::auth::handshake::StartResponse; +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)) + .route("/finish", post(finish)) +} + +#[derive(Deserialize)] +struct StartRequest { + credential_request: CredentialRequest, +} + +#[derive(Deserialize)] +struct FinishRequest { + login_id: LoginId, + credential_finalization: CredentialFinalization, + dpop_binding: DpopBinding, +} + +#[derive(Serialize)] +struct FinishResponse { + #[serde(flatten)] + access: Access, + auth_time: u64, +} + +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())) +} + +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: finished.access_token.into(), + auth_time: finished.auth_time, + })) +} + +#[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, + }; + 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"; + 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(); + let (state, issued) = signed_in(&db, &prover).await; + let (client, body) = start_body(); + + 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()); + 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, issued) = signed_in(&db, &prover).await; + let (client, body) = start_body(); + 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(); + 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); + } + + #[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"); + } + + #[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/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..358f1dbf7 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)] @@ -73,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) } @@ -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/db/sessions.rs b/rust/crates/keygo-server/src/db/sessions.rs index e3798f4bd..7c40fbeed 100644 --- a/rust/crates/keygo-server/src/db/sessions.rs +++ b/rust/crates/keygo-server/src/db/sessions.rs @@ -26,6 +26,23 @@ pub async fn insert( Ok(()) } +pub async fn touch_auth_time( + conn: &mut PgConnection, + session_id: SessionId, + auth_time: u64, +) -> 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(result.rows_affected() == 1) +} + pub async fn revoke_by_device( conn: &mut PgConnection, device_id: DeviceId, @@ -195,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/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 } 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..0a0765fe0 --- /dev/null +++ b/rust/crates/keygo-server/src/service/handshake.rs @@ -0,0 +1,58 @@ +use crate::cache::{LoginStore, Pending}; +use crate::domain::LoginId; +use keygo_opaque::server::{ServerLogin, ServerSetup}; +use keygo_opaque::{ + CredentialFinalization, CredentialRequest, CredentialResponse, DpopBinding, 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(), + }) +} + +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 1fedfdcee..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::login::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/login/mod.rs b/rust/crates/keygo-server/src/service/login/mod.rs index 0a3af0c21..5c75081fc 100644 --- a/rust/crates/keygo-server/src/service/login/mod.rs +++ b/rust/crates/keygo-server/src/service/login/mod.rs @@ -3,18 +3,3 @@ mod start; 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 { - #[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 432b32a15..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, Pending}; +use crate::cache::LoginStates; use crate::db::opaque_records; -use crate::domain::{LoginId, Username}; -use crate::service::login::{Error, TTL}; -use keygo_opaque::server::{ServerLogin, ServerSetup}; -use keygo_opaque::{CredentialRequest, CredentialResponse}; +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,22 +36,19 @@ 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)), }; - let (state, credential_response) = - ServerLogin::start(setup, password_file, credential_request, &identifier)?; - - let login_id = LoginId::random(); - login_states.insert(login_id, Pending { user_id, state }); - - Ok(Started { - login_id, - credential_response, - expires_in: TTL, - }) + handshake::begin( + login_states, + setup, + user_id, + password_file, + &identifier, + credential_request, + ) } /// The domain tag keeps a fake identifier from ever encoding like a real one, a 16-byte user id. @@ -95,7 +85,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 +96,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..35e6d1172 100644 --- a/rust/crates/keygo-server/src/service/mod.rs +++ b/rust/crates/keygo-server/src/service/mod.rs @@ -1,5 +1,7 @@ pub mod device; +pub mod handshake; 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/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/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 new file mode 100644 index 000000000..f7859d1b0 --- /dev/null +++ b/rust/crates/keygo-server/src/service/step_up/finish.rs @@ -0,0 +1,136 @@ +use crate::cache::StepUpStates; +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, + pub user_id: UserId, + pub login_id: LoginId, + pub credential_finalization: CredentialFinalization, + pub binding: DpopBinding, + pub jkt: [u8; 32], +} + +#[derive(Debug, Error)] +pub enum FinishError { + #[error(transparent)] + Handshake(#[from] Error), + #[error("session ended")] + SessionEnded, +} + +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 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 result = step_up_as(&db, &states, &setup, ada, ada, session_id).await; + + assert!(matches!(result, Err(FinishError::SessionEnded))); + } +} 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..5c75081fc --- /dev/null +++ b/rust/crates/keygo-server/src/service/step_up/mod.rs @@ -0,0 +1,5 @@ +mod finish; +mod start; + +pub use finish::*; +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..a71637840 --- /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::handshake::{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)?; + + handshake::begin( + step_up_states, + setup, + user_id, + Some(password_file), + user_id.opaque_identifier(), + 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..31ba55091 100644 --- a/rust/crates/keygo-server/src/testing.rs +++ b/rust/crates/keygo-server/src/testing.rs @@ -1,15 +1,16 @@ 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, 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 @@ -216,6 +229,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()), } @@ -232,23 +246,42 @@ 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. +/// 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, + build: impl Fn(Option<&str>) -> Request, +) -> (StatusCode, Value) { + 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 (status, _, body) = send(state, build(Some(nonce))).await; + (status, body) +} pub async fn post_with_proof( state: &AppState, prover: &DpopProver, uri: &str, body: Value, ) -> (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 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) + send_with_nonce(state, |nonce| proof_post(state, prover, uri, &body, nonce)).await +} +/// Posts as the session behind `access_token`. +pub async fn post_with_token( + state: &AppState, + prover: &DpopProver, + uri: &str, + access_token: &str, + body: Value, +) -> (StatusCode, Value) { + send_with_nonce(state, |nonce| { + let request = json_post(uri, &body); + with_proof(state, prover, request, Some(access_token), nonce) + }) + .await } pub fn proof_post( state: &AppState, @@ -257,17 +290,34 @@ pub fn proof_post( 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: None, + access_token, nonce, }) .unwrap(); - let mut request = json_post(uri, body); - request.headers_mut().insert("dpop", proof.parse().unwrap()); + let headers = request.headers_mut(); + headers.insert("dpop", proof.parse().unwrap()); + if let Some(access_token) = access_token { + headers.insert( + AUTHORIZATION, + format!("DPoP {access_token}").parse().unwrap(), + ); + } request }