From aba76762bf235353e386654771ed5bf8b29ecc65 Mon Sep 17 00:00:00 2001 From: Davis Date: Mon, 9 Nov 2026 17:40:14 +0100 Subject: [PATCH 01/52] refactor(server): split keygo-server into lib and bin Expose the server internals through a library target so the router and CLI can be reached from other crates. Add a `test-support` feature that gates the `testing` module and its optional dependencies. Drop the dead_code expectation on `Claims::auth_time`, which the library's public `AppState` now makes reachable. Co-Authored-By: Claude Opus 5.5 --- rust/crates/keygo-server/Cargo.toml | 5 +++++ .../crates/keygo-server/src/domain/access_token.rs | 4 ---- rust/crates/keygo-server/src/lib.rs | 11 +++++++++++ rust/crates/keygo-server/src/main.rs | 14 +------------- 4 files changed, 17 insertions(+), 17 deletions(-) create mode 100644 rust/crates/keygo-server/src/lib.rs diff --git a/rust/crates/keygo-server/Cargo.toml b/rust/crates/keygo-server/Cargo.toml index 60fe71ef1..0f0207656 100644 --- a/rust/crates/keygo-server/Cargo.toml +++ b/rust/crates/keygo-server/Cargo.toml @@ -4,6 +4,9 @@ description = "KeyGo self-hostable sync server." version.workspace = true edition.workspace = true +[features] +test-support = ["dep:http-body-util", "dep:tower", "keygo-dpop/test-support"] + [dependencies] keygo-core = { path = "../keygo-core" } keygo-opaque = { path = "../keygo-opaque" } @@ -17,6 +20,8 @@ serde = { workspace = true, features = ["derive"] } serde_json.workspace = true hmac.workspace = true sha2 = { workspace = true, features = ["zeroize"] } +http-body-util = { version = "0.1.5", optional = true } +tower = { version = "0.5.3", features = ["util"], optional = true } anstream = "1.0.0" anstyle = "1.0.14" diff --git a/rust/crates/keygo-server/src/domain/access_token.rs b/rust/crates/keygo-server/src/domain/access_token.rs index a27517f5c..703277cc7 100644 --- a/rust/crates/keygo-server/src/domain/access_token.rs +++ b/rust/crates/keygo-server/src/domain/access_token.rs @@ -151,10 +151,6 @@ impl Claims { self.session_id } - #[cfg_attr( - not(test), - expect(dead_code, reason = "no route requires a fresh sign-in yet") - )] pub fn auth_time(&self) -> u64 { self.auth_time } diff --git a/rust/crates/keygo-server/src/lib.rs b/rust/crates/keygo-server/src/lib.rs new file mode 100644 index 000000000..650046ebf --- /dev/null +++ b/rust/crates/keygo-server/src/lib.rs @@ -0,0 +1,11 @@ +pub mod api; +mod cache; +pub mod cli; +mod config; +mod db; +mod domain; +mod secrets; +mod server; +mod service; +#[cfg(any(test, feature = "test-support"))] +pub mod testing; diff --git a/rust/crates/keygo-server/src/main.rs b/rust/crates/keygo-server/src/main.rs index fc5831e21..097e7cd88 100644 --- a/rust/crates/keygo-server/src/main.rs +++ b/rust/crates/keygo-server/src/main.rs @@ -1,18 +1,6 @@ -use crate::cli::Cli; +use keygo_server::cli::Cli; use std::process::ExitCode; -mod api; -mod cache; -mod cli; -mod config; -mod db; -mod domain; -mod secrets; -mod server; -mod service; -#[cfg(test)] -mod testing; - fn main() -> ExitCode { match Cli::start() { Ok(()) => ExitCode::SUCCESS, From 04ce2e4bc01a6c38dbbbac66ea93468acf22fb5e Mon Sep 17 00:00:00 2001 From: Davis Date: Mon, 9 Nov 2026 17:46:57 +0100 Subject: [PATCH 02/52] feat(api): add keygo-api with ErrorCode and ApiError Co-Authored-By: Claude Opus 5.5 --- rust/Cargo.lock | 9 ++ rust/crates/keygo-api/Cargo.toml | 11 +++ rust/crates/keygo-api/src/error.rs | 113 ++++++++++++++++++++++ rust/crates/keygo-api/src/lib.rs | 5 + rust/crates/keygo-server/Cargo.toml | 1 + rust/crates/keygo-server/src/api/error.rs | 80 +++++---------- 6 files changed, 165 insertions(+), 54 deletions(-) create mode 100644 rust/crates/keygo-api/Cargo.toml create mode 100644 rust/crates/keygo-api/src/error.rs create mode 100644 rust/crates/keygo-api/src/lib.rs diff --git a/rust/Cargo.lock b/rust/Cargo.lock index b3709f88e..5d0c6ebe2 100644 --- a/rust/Cargo.lock +++ b/rust/Cargo.lock @@ -1593,6 +1593,14 @@ dependencies = [ "cpufeatures 0.3.1", ] +[[package]] +name = "keygo-api" +version = "0.1.0" +dependencies = [ + "serde", + "serde_json", +] + [[package]] name = "keygo-client" version = "0.1.0" @@ -1684,6 +1692,7 @@ dependencies = [ "hmac 0.13.0", "http-body-util", "humantime", + "keygo-api", "keygo-core", "keygo-dpop", "keygo-opaque", diff --git a/rust/crates/keygo-api/Cargo.toml b/rust/crates/keygo-api/Cargo.toml new file mode 100644 index 000000000..ad94278bd --- /dev/null +++ b/rust/crates/keygo-api/Cargo.toml @@ -0,0 +1,11 @@ +[package] +name = "keygo-api" +description = "KeyGo sync API wire types, shared by the server and the client." +version.workspace = true +edition.workspace = true + +[dependencies] +serde = { workspace = true, features = ["derive"] } + +[dev-dependencies] +serde_json.workspace = true diff --git a/rust/crates/keygo-api/src/error.rs b/rust/crates/keygo-api/src/error.rs new file mode 100644 index 000000000..932c67b0e --- /dev/null +++ b/rust/crates/keygo-api/src/error.rs @@ -0,0 +1,113 @@ +use serde::{Deserialize, Serialize}; + +/// Every `code` the API answers with; clients match on the serialized name. +/// +/// A code this build does not know decodes as [`ErrorCode::Unknown`], so a +/// newer server never breaks an older client. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum ErrorCode { + // general + Internal, + InvalidRequest, + NotFound, + RateLimited, + // auth + InvalidUsername, + InvalidCredentials, + UsernameTaken, + UserIdTaken, + InviteRequired, + InviteInvalid, + RegistrationExpired, + LoginExpired, + // session + FreshAuthRequired, + InvalidToken, + RefreshExpired, + SessionRevoked, + // dpop + InvalidDpopProof, + UseDpopNonce, + #[serde(other)] + Unknown, +} + +/// The JSON body of every error response. +#[derive(Debug, Serialize, Deserialize)] +pub struct ApiError { + pub code: ErrorCode, + pub message: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub reason: Option, +} + +#[cfg(test)] +mod tests { + use super::*; + use serde_json::json; + + #[test] + fn every_code_keeps_its_wire_name() { + for (code, name) in [ + (ErrorCode::Internal, "internal"), + (ErrorCode::InvalidRequest, "invalid_request"), + (ErrorCode::NotFound, "not_found"), + (ErrorCode::RateLimited, "rate_limited"), + (ErrorCode::InvalidUsername, "invalid_username"), + (ErrorCode::InvalidCredentials, "invalid_credentials"), + (ErrorCode::UsernameTaken, "username_taken"), + (ErrorCode::UserIdTaken, "user_id_taken"), + (ErrorCode::InviteRequired, "invite_required"), + (ErrorCode::InviteInvalid, "invite_invalid"), + (ErrorCode::RegistrationExpired, "registration_expired"), + (ErrorCode::LoginExpired, "login_expired"), + (ErrorCode::FreshAuthRequired, "fresh_auth_required"), + (ErrorCode::InvalidToken, "invalid_token"), + (ErrorCode::RefreshExpired, "refresh_expired"), + (ErrorCode::SessionRevoked, "session_revoked"), + (ErrorCode::InvalidDpopProof, "invalid_dpop_proof"), + (ErrorCode::UseDpopNonce, "use_dpop_nonce"), + ] { + assert_eq!(serde_json::to_value(code).unwrap(), name); + assert_eq!( + serde_json::from_value::(name.into()).unwrap(), + code + ); + } + } + + #[test] + fn unknown_code_decodes_as_unknown() { + assert_eq!( + serde_json::from_value::("brand_new".into()).unwrap(), + ErrorCode::Unknown, + ); + } + + #[test] + fn absent_reason_is_omitted() { + let error = ApiError { + code: ErrorCode::NotFound, + message: "m".into(), + reason: None, + }; + assert_eq!( + serde_json::to_value(&error).unwrap(), + json!({"code": "not_found", "message": "m"}) + ); + } + + #[test] + fn present_reason_is_written() { + let error = ApiError { + code: ErrorCode::SessionRevoked, + message: "m".into(), + reason: Some("logout".into()), + }; + assert_eq!( + serde_json::to_value(&error).unwrap(), + json!({"code": "session_revoked", "message": "m", "reason": "logout"}), + ); + } +} diff --git a/rust/crates/keygo-api/src/lib.rs b/rust/crates/keygo-api/src/lib.rs new file mode 100644 index 000000000..a9a2ad12f --- /dev/null +++ b/rust/crates/keygo-api/src/lib.rs @@ -0,0 +1,5 @@ +#![forbid(unsafe_code)] + +mod error; + +pub use error::{ApiError, ErrorCode}; diff --git a/rust/crates/keygo-server/Cargo.toml b/rust/crates/keygo-server/Cargo.toml index 0f0207656..af4283d68 100644 --- a/rust/crates/keygo-server/Cargo.toml +++ b/rust/crates/keygo-server/Cargo.toml @@ -8,6 +8,7 @@ edition.workspace = true test-support = ["dep:http-body-util", "dep:tower", "keygo-dpop/test-support"] [dependencies] +keygo-api = { path = "../keygo-api" } keygo-core = { path = "../keygo-core" } keygo-opaque = { path = "../keygo-opaque" } keygo-dpop = { path = "../keygo-dpop" } diff --git a/rust/crates/keygo-server/src/api/error.rs b/rust/crates/keygo-server/src/api/error.rs index 06f6b3aaa..1ee4f7eb2 100644 --- a/rust/crates/keygo-server/src/api/error.rs +++ b/rust/crates/keygo-server/src/api/error.rs @@ -2,60 +2,31 @@ use crate::domain::{InvalidBlob, UsernameError}; use axum::extract::rejection::JsonRejection; use axum::http::{HeaderMap, StatusCode}; use axum::response::{IntoResponse, Response}; +use keygo_api::ApiError; use keygo_opaque::OpaqueError; -use serde::Serialize; -use serde_json::json; use thiserror::Error; -/// Every `code` the API answers with; clients match on the serialized name. -#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)] -#[serde(rename_all = "snake_case")] -pub enum ErrorCode { - // general - Internal, - InvalidRequest, - NotFound, - RateLimited, - // auth - InvalidUsername, - InvalidCredentials, - UsernameTaken, - UserIdTaken, - InviteRequired, - InviteInvalid, - RegistrationExpired, - LoginExpired, - // session - FreshAuthRequired, - InvalidToken, - RefreshExpired, - SessionRevoked, - // dpop - InvalidDpopProof, - UseDpopNonce, -} +pub use keygo_api::ErrorCode; -impl ErrorCode { - pub fn status(self) -> StatusCode { - match self { - Self::Internal => StatusCode::INTERNAL_SERVER_ERROR, - Self::InvalidRequest - | Self::InvalidUsername - | Self::RegistrationExpired - | Self::LoginExpired - | Self::InvalidDpopProof - | Self::UseDpopNonce => StatusCode::BAD_REQUEST, - Self::InvalidCredentials - | Self::InvalidToken - | Self::RefreshExpired - | Self::SessionRevoked => StatusCode::UNAUTHORIZED, - Self::InviteRequired | Self::InviteInvalid | Self::FreshAuthRequired => { - StatusCode::FORBIDDEN - } - Self::NotFound => StatusCode::NOT_FOUND, - Self::UsernameTaken | Self::UserIdTaken => StatusCode::CONFLICT, - Self::RateLimited => StatusCode::TOO_MANY_REQUESTS, +fn status_of(code: ErrorCode) -> StatusCode { + match code { + ErrorCode::Internal | ErrorCode::Unknown => StatusCode::INTERNAL_SERVER_ERROR, + ErrorCode::InvalidRequest + | ErrorCode::InvalidUsername + | ErrorCode::RegistrationExpired + | ErrorCode::LoginExpired + | ErrorCode::InvalidDpopProof + | ErrorCode::UseDpopNonce => StatusCode::BAD_REQUEST, + ErrorCode::InvalidCredentials + | ErrorCode::InvalidToken + | ErrorCode::RefreshExpired + | ErrorCode::SessionRevoked => StatusCode::UNAUTHORIZED, + ErrorCode::InviteRequired | ErrorCode::InviteInvalid | ErrorCode::FreshAuthRequired => { + StatusCode::FORBIDDEN } + ErrorCode::NotFound => StatusCode::NOT_FOUND, + ErrorCode::UsernameTaken | ErrorCode::UserIdTaken => StatusCode::CONFLICT, + ErrorCode::RateLimited => StatusCode::TOO_MANY_REQUESTS, } } @@ -63,7 +34,7 @@ pub trait HttpError: std::error::Error + Send + Sync + 'static { fn code(&self) -> ErrorCode; fn status(&self) -> StatusCode { - self.code().status() + status_of(self.code()) } fn headers(&self) -> HeaderMap { @@ -97,10 +68,11 @@ impl IntoResponse for ServerError { self.0.to_string() }; - let mut body = json!({"code": code, "message": message}); - if let Some(reason) = reason { - body["reason"] = reason.into(); - } + let body = ApiError { + code, + message, + reason: reason.map(str::to_owned), + }; (status, headers, axum::Json(body)).into_response() } From 0e094e0e566181a44d0edf528006908c7be10d45 Mon Sep 17 00:00:00 2001 From: Davis Date: Mon, 9 Nov 2026 17:54:29 +0100 Subject: [PATCH 03/52] refactor(server): share ids, usernames and device types through keygo-api Co-Authored-By: Claude Opus 5.5 --- CLAUDE.md | 5 +- rust/Cargo.lock | 9 +- rust/crates/keygo-api/Cargo.toml | 12 ++ .../src/domain/device.rs | 6 +- rust/crates/keygo-api/src/domain/ids.rs | 107 +++++++++++++ rust/crates/keygo-api/src/domain/mod.rs | 14 ++ rust/crates/keygo-api/src/domain/session.rs | 22 +++ .../src/domain/string_enum.rs | 0 .../src/domain/username.rs | 0 rust/crates/keygo-api/src/lib.rs | 1 + rust/crates/keygo-core/src/ids.rs | 17 +- rust/crates/keygo-core/src/lib.rs | 2 +- rust/crates/keygo-server/Cargo.toml | 4 +- .../keygo-server/src/domain/access_token.rs | 12 +- rust/crates/keygo-server/src/domain/ids.rs | 146 +----------------- rust/crates/keygo-server/src/domain/mod.rs | 13 +- .../crates/keygo-server/src/domain/session.rs | 17 -- 17 files changed, 201 insertions(+), 186 deletions(-) rename rust/crates/{keygo-server => keygo-api}/src/domain/device.rs (98%) create mode 100644 rust/crates/keygo-api/src/domain/ids.rs create mode 100644 rust/crates/keygo-api/src/domain/mod.rs create mode 100644 rust/crates/keygo-api/src/domain/session.rs rename rust/crates/{keygo-server => keygo-api}/src/domain/string_enum.rs (100%) rename rust/crates/{keygo-server => keygo-api}/src/domain/username.rs (100%) diff --git a/CLAUDE.md b/CLAUDE.md index df071e2c2..8c72c8f34 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -199,8 +199,9 @@ Caddy as TLS proxy; `.env.example` sets `DOMAIN` and signups). multiple statements. - **Trailing commas** on multi-line parameter lists and collection literals. - **Rust constructors** — ids are made with `random()`, secret material (keys, tokens, codes) with - `generate()`. Ids the client and server share live in `keygo-core`; server-only ids come from the - `random_id!`/`uuid_id!` macros in `domain/ids.rs`. + `generate()`. Ids the client and server share live in `keygo-core`; the wire handles `LoginId` + and `RegistrationId` come from `random_id!` in `keygo-api`, and their `random()` needs its + `server` feature. Server-only ids stay in `keygo-server`. ## Testing diff --git a/rust/Cargo.lock b/rust/Cargo.lock index 5d0c6ebe2..a6958808d 100644 --- a/rust/Cargo.lock +++ b/rust/Cargo.lock @@ -1597,8 +1597,15 @@ dependencies = [ name = "keygo-api" version = "0.1.0" dependencies = [ + "base64 0.23.1", + "getrandom 0.4.3", + "keygo-core", "serde", "serde_json", + "thiserror", + "unicode-normalization", + "unicode-properties", + "uuid", ] [[package]] @@ -1710,8 +1717,6 @@ dependencies = [ "tower-http", "tracing", "tracing-subscriber", - "unicode-normalization", - "unicode-properties", "url", "uuid", "zeroize", diff --git a/rust/crates/keygo-api/Cargo.toml b/rust/crates/keygo-api/Cargo.toml index ad94278bd..febbbf71d 100644 --- a/rust/crates/keygo-api/Cargo.toml +++ b/rust/crates/keygo-api/Cargo.toml @@ -4,8 +4,20 @@ description = "KeyGo sync API wire types, shared by the server and the client." version.workspace = true edition.workspace = true +[features] +server = ["dep:getrandom"] + [dependencies] +keygo-core = { path = "../keygo-core" } + serde = { workspace = true, features = ["derive"] } +thiserror.workspace = true +uuid.workspace = true +base64.workspace = true +getrandom = { workspace = true, optional = true } +unicode-normalization = "0.1.25" +unicode-properties = { version = "0.1.4", default-features = false, features = ["general-category"] } [dev-dependencies] +getrandom.workspace = true serde_json.workspace = true diff --git a/rust/crates/keygo-server/src/domain/device.rs b/rust/crates/keygo-api/src/domain/device.rs similarity index 98% rename from rust/crates/keygo-server/src/domain/device.rs rename to rust/crates/keygo-api/src/domain/device.rs index 1bff999e5..c83a195c5 100644 --- a/rust/crates/keygo-server/src/domain/device.rs +++ b/rust/crates/keygo-api/src/domain/device.rs @@ -1,5 +1,5 @@ -use super::DeviceId; use super::string_enum::string_enum; +use keygo_core::DeviceId; use serde::{Deserialize, Serialize}; use thiserror::Error; use unicode_properties::{GeneralCategory, UnicodeGeneralCategory}; @@ -113,7 +113,7 @@ pub struct DeviceInfo { pub app_version: AppVersion, } -#[derive(Debug, Deserialize)] +#[derive(Debug, Serialize, Deserialize)] pub struct DeviceClaim { #[serde(rename = "device_id")] pub id: Option, @@ -121,7 +121,7 @@ pub struct DeviceClaim { pub info: DeviceInfo, } -#[derive(Debug, Serialize)] +#[derive(Debug, Serialize, Deserialize)] pub struct Device { pub id: DeviceId, #[serde(flatten)] diff --git a/rust/crates/keygo-api/src/domain/ids.rs b/rust/crates/keygo-api/src/domain/ids.rs new file mode 100644 index 000000000..451c44270 --- /dev/null +++ b/rust/crates/keygo-api/src/domain/ids.rs @@ -0,0 +1,107 @@ +use base64::Engine; +use base64::engine::general_purpose::URL_SAFE_NO_PAD; +use serde::{Deserialize, Deserializer, Serialize, Serializer}; +use thiserror::Error; + +const LEN: usize = 16; + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Error)] +#[error("{field} must be {LEN} bytes of base64url without padding")] +pub struct InvalidId { + field: &'static str, +} + +/// Declares an opaque handle of 16 random bytes that travels as base64url without padding. +macro_rules! random_id { + ($($(#[$attr:meta])* $name:ident as $field:literal;)+) => {$( + $(#[$attr])* + #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] + pub struct $name([u8; LEN]); + + impl $name { + #[cfg(any(test, feature = "server"))] + pub fn random() -> Self { + let mut bytes = [0u8; LEN]; + getrandom::fill(&mut bytes).expect("OS random number generator unavailable"); + Self(bytes) + } + + pub fn to_base64(self) -> String { + URL_SAFE_NO_PAD.encode(self.0) + } + + pub fn from_base64(text: &str) -> Result { + const INVALID: InvalidId = InvalidId { field: $field }; + let bytes = URL_SAFE_NO_PAD.decode(text).map_err(|_| INVALID)?; + bytes.try_into().map(Self).map_err(|_| INVALID) + } + } + + impl Serialize for $name { + fn serialize(&self, serializer: S) -> Result { + serializer.serialize_str(&self.to_base64()) + } + } + + impl<'de> Deserialize<'de> for $name { + fn deserialize>(deserializer: D) -> Result { + let text = String::deserialize(deserializer)?; + Self::from_base64(&text).map_err(serde::de::Error::custom) + } + } + )+}; +} + +random_id! { + /// Handle for a pending registration, between `register/start` and `register/finish`. + RegistrationId as "registration_id"; + + /// Handle for a login handshake, between `login/start` and `login/finish`. + LoginId as "login_id"; +} + +impl RegistrationId { + #[cfg(any(test, feature = "server"))] + pub const fn as_bytes(&self) -> &[u8; LEN] { + &self.0 + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn random_ids_differ() { + assert_ne!(RegistrationId::random(), RegistrationId::random()); + } + + #[test] + fn base64_round_trips() { + let id = RegistrationId::random(); + + assert_eq!(RegistrationId::from_base64(&id.to_base64()), Ok(id)); + } + + #[test] + fn serializes_as_unpadded_base64url() { + let id = RegistrationId([0xff; LEN]); + + assert_eq!(serde_json::to_value(id).unwrap(), "_____________________w"); + } + + #[test] + fn rejects_wrong_length_and_alphabet() { + assert!(RegistrationId::from_base64(&URL_SAFE_NO_PAD.encode([0; 15])).is_err()); + assert!(RegistrationId::from_base64(&URL_SAFE_NO_PAD.encode([0; 17])).is_err()); + assert!(RegistrationId::from_base64("+++++++++++++++++++++w").is_err()); + assert!(RegistrationId::from_base64("_____________________w==").is_err()); + } + + #[test] + fn error_names_the_field() { + let err = LoginId::from_base64("").unwrap_err(); + + assert!(err.to_string().starts_with("login_id ")); + } +} diff --git a/rust/crates/keygo-api/src/domain/mod.rs b/rust/crates/keygo-api/src/domain/mod.rs new file mode 100644 index 000000000..f873085b1 --- /dev/null +++ b/rust/crates/keygo-api/src/domain/mod.rs @@ -0,0 +1,14 @@ +mod device; +mod ids; +mod session; +mod string_enum; +mod username; + +pub use device::{ + AppVersion, AppVersionError, Device, DeviceClaim, DeviceInfo, DeviceName, DeviceNameError, + Platform, +}; +pub use ids::{InvalidId, LoginId, RegistrationId}; +pub use session::RevokeReason; +pub use string_enum::UnknownVariant; +pub use username::{Username, UsernameError}; diff --git a/rust/crates/keygo-api/src/domain/session.rs b/rust/crates/keygo-api/src/domain/session.rs new file mode 100644 index 000000000..b2c955197 --- /dev/null +++ b/rust/crates/keygo-api/src/domain/session.rs @@ -0,0 +1,22 @@ +use super::string_enum::string_enum; + +string_enum! { + pub enum RevokeReason { + Replaced => "replaced", + ReuseDetected => "reuse_detected", + Logout => "logout", + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn revoke_reason_round_trips_its_stored_name() { + for &reason in RevokeReason::ALL { + assert_eq!(reason.as_str().parse::().unwrap(), reason); + } + assert!("logout_typo".parse::().is_err()); + } +} diff --git a/rust/crates/keygo-server/src/domain/string_enum.rs b/rust/crates/keygo-api/src/domain/string_enum.rs similarity index 100% rename from rust/crates/keygo-server/src/domain/string_enum.rs rename to rust/crates/keygo-api/src/domain/string_enum.rs diff --git a/rust/crates/keygo-server/src/domain/username.rs b/rust/crates/keygo-api/src/domain/username.rs similarity index 100% rename from rust/crates/keygo-server/src/domain/username.rs rename to rust/crates/keygo-api/src/domain/username.rs diff --git a/rust/crates/keygo-api/src/lib.rs b/rust/crates/keygo-api/src/lib.rs index a9a2ad12f..179fd77f8 100644 --- a/rust/crates/keygo-api/src/lib.rs +++ b/rust/crates/keygo-api/src/lib.rs @@ -1,5 +1,6 @@ #![forbid(unsafe_code)] +pub mod domain; mod error; pub use error::{ApiError, ErrorCode}; diff --git a/rust/crates/keygo-core/src/ids.rs b/rust/crates/keygo-core/src/ids.rs index 8552710c9..9e4d9df8b 100644 --- a/rust/crates/keygo-core/src/ids.rs +++ b/rust/crates/keygo-core/src/ids.rs @@ -25,4 +25,19 @@ macro_rules! id { }; } -id!(UserId, VaultId, ItemId, NamespaceId); +id!(UserId, VaultId, ItemId, NamespaceId, DeviceId, SessionId); + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn device_id_travels_as_the_uuids_string_form() { + let id = DeviceId::from(Uuid::nil()); + + assert_eq!( + serde_json::to_value(id).unwrap(), + "00000000-0000-0000-0000-000000000000" + ); + } +} diff --git a/rust/crates/keygo-core/src/lib.rs b/rust/crates/keygo-core/src/lib.rs index 0e95c46e0..131b44a43 100644 --- a/rust/crates/keygo-core/src/lib.rs +++ b/rust/crates/keygo-core/src/lib.rs @@ -15,6 +15,6 @@ mod sealed; #[cfg(feature = "crypto")] pub use crypto::*; pub use error::{CryptoError, CryptoResult}; -pub use ids::{ItemId, NamespaceId, UserId, VaultId}; +pub use ids::{DeviceId, ItemId, NamespaceId, SessionId, UserId, VaultId}; pub use keys::{AccountRootKey, BackupKey, ItemKey, NamespaceKey, RootKek, VaultKey}; pub use sealed::{KEY_LEN, NONCE_LEN, Sealed, TAG_LEN}; diff --git a/rust/crates/keygo-server/Cargo.toml b/rust/crates/keygo-server/Cargo.toml index af4283d68..8cd3a07b1 100644 --- a/rust/crates/keygo-server/Cargo.toml +++ b/rust/crates/keygo-server/Cargo.toml @@ -8,7 +8,7 @@ edition.workspace = true test-support = ["dep:http-body-util", "dep:tower", "keygo-dpop/test-support"] [dependencies] -keygo-api = { path = "../keygo-api" } +keygo-api = { path = "../keygo-api", features = ["server"] } keygo-core = { path = "../keygo-core" } keygo-opaque = { path = "../keygo-opaque" } keygo-dpop = { path = "../keygo-dpop" } @@ -39,8 +39,6 @@ tracing-subscriber = { version = "0.3.23", features = ["env-filter"] } tower-http = { version = "0.7.1", features = ["set-header", "trace"] } uuid = { workspace = true, features = ["v4"] } sqlx = { version = "0.9.0", default-features = false, features = ["runtime-tokio", "postgres", "migrate", "macros", "uuid", "time"] } -unicode-normalization = "0.1.25" -unicode-properties = { version = "0.1.4", default-features = false, features = ["general-category"] } humantime = "2.4.0" time = { version = "0.3.55", features = ["formatting", "macros"] } moka = { version = "0.12.16", features = ["sync"] } diff --git a/rust/crates/keygo-server/src/domain/access_token.rs b/rust/crates/keygo-server/src/domain/access_token.rs index 703277cc7..d5a705799 100644 --- a/rust/crates/keygo-server/src/domain/access_token.rs +++ b/rust/crates/keygo-server/src/domain/access_token.rs @@ -370,7 +370,7 @@ mod tests { let claims = Claims::new_at( String::new(), UserId::from(uuid::Uuid::nil()), - SessionId::nil(), + SessionId::from(uuid::Uuid::nil()), 0, &JKT, 1_000, @@ -386,7 +386,7 @@ mod tests { Claims::new_at( String::new(), UserId::from(uuid::Uuid::nil()), - SessionId::nil(), + SessionId::from(uuid::Uuid::nil()), 0, &JKT, 0, @@ -550,7 +550,7 @@ mod tests { let claims = Claims::new_at( String::new(), UserId::from(uuid::Uuid::nil()), - SessionId::nil(), + SessionId::from(uuid::Uuid::nil()), 1_000, &JKT, 1_000, @@ -567,7 +567,7 @@ mod tests { let token = key.sign(&Claims::new_at( ISS.into(), UserId::from(uuid::Uuid::nil()), - SessionId::nil(), + SessionId::from(uuid::Uuid::nil()), unix_now(), &JKT, unix_now(), @@ -598,7 +598,7 @@ mod tests { let key = || AccessTokenKey::new(&SEED); let token = TokenIssuer::new(key(), "https://other.example").issue( UserId::from(uuid::Uuid::nil()), - SessionId::nil(), + SessionId::from(uuid::Uuid::nil()), unix_now(), &JKT, ); @@ -616,7 +616,7 @@ mod tests { let token = issuer.issue( UserId::from(uuid::Uuid::nil()), - SessionId::nil(), + SessionId::from(uuid::Uuid::nil()), auth_time, &JKT, ); diff --git a/rust/crates/keygo-server/src/domain/ids.rs b/rust/crates/keygo-server/src/domain/ids.rs index ec739172e..d3276901e 100644 --- a/rust/crates/keygo-server/src/domain/ids.rs +++ b/rust/crates/keygo-server/src/domain/ids.rs @@ -1,113 +1,4 @@ -use base64::Engine; -use base64::engine::general_purpose::URL_SAFE_NO_PAD; -use serde::{Deserialize, Deserializer, Serialize, Serializer}; -use thiserror::Error; -use uuid::Uuid; - -/// An account. Client-generated at registration and equal to the app's local user id. -pub use keygo_core::UserId; - -const LEN: usize = 16; - -#[derive(Debug, Clone, Copy, PartialEq, Eq, Error)] -#[error("{field} must be {LEN} bytes of base64url without padding")] -pub struct InvalidId { - field: &'static str, -} - -/// Declares an opaque handle of 16 random bytes that travels as base64url without padding. -macro_rules! random_id { - ($($(#[$attr:meta])* $name:ident as $field:literal;)+) => {$( - $(#[$attr])* - #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] - pub struct $name([u8; LEN]); - - impl $name { - pub fn random() -> Self { - let mut bytes = [0u8; LEN]; - getrandom::fill(&mut bytes).expect("OS random number generator unavailable"); - Self(bytes) - } - - pub fn to_base64(self) -> String { - URL_SAFE_NO_PAD.encode(self.0) - } - - pub fn from_base64(text: &str) -> Result { - const INVALID: InvalidId = InvalidId { field: $field }; - let bytes = URL_SAFE_NO_PAD.decode(text).map_err(|_| INVALID)?; - bytes.try_into().map(Self).map_err(|_| INVALID) - } - } - - impl Serialize for $name { - fn serialize(&self, serializer: S) -> Result { - serializer.serialize_str(&self.to_base64()) - } - } - - impl<'de> Deserialize<'de> for $name { - fn deserialize>(deserializer: D) -> Result { - let text = String::deserialize(deserializer)?; - Self::from_base64(&text).map_err(serde::de::Error::custom) - } - } - )+}; -} - -/// Declares a UUID-backed id that travels as the UUID's string form. -macro_rules! uuid_id { - ($($(#[$attr:meta])* $name:ident;)+) => {$( - $(#[$attr])* - #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)] - pub struct $name(Uuid); - - impl $name { - #[allow(dead_code, reason = "user ids are client-generated, so only tests mint one")] - pub fn random() -> Self { - Self(Uuid::new_v4()) - } - - #[cfg(test)] - #[allow(dead_code, reason = "not every id needs a fixed value in tests")] - pub const fn nil() -> Self { - Self(Uuid::nil()) - } - - pub const fn as_uuid(self) -> Uuid { - self.0 - } - } - - impl From for $name { - fn from(value: Uuid) -> Self { - Self(value) - } - } - )+}; -} - -random_id! { - /// Handle for a pending registration, between `register/start` and `register/finish`. - RegistrationId as "registration_id"; - - /// Handle for a login handshake, between `login/start` and `login/finish`. - LoginId as "login_id"; -} - -uuid_id! { - /// A login session; the refresh-token family hangs off it. - SessionId; - - /// A device registered to an account. - DeviceId; -} - -impl RegistrationId { - pub const fn as_bytes(&self) -> &[u8; LEN] { - &self.0 - } -} +use keygo_core::UserId; /// What OPAQUE binds the password file to: registration, login and step-up must all agree on it. pub const fn opaque_identifier(user_id: &UserId) -> &[u8] { @@ -117,33 +8,7 @@ pub const fn opaque_identifier(user_id: &UserId) -> &[u8] { #[cfg(test)] mod tests { use super::*; - - #[test] - fn random_ids_differ() { - assert_ne!(RegistrationId::random(), RegistrationId::random()); - } - - #[test] - fn base64_round_trips() { - let id = RegistrationId::random(); - - assert_eq!(RegistrationId::from_base64(&id.to_base64()), Ok(id)); - } - - #[test] - fn serializes_as_unpadded_base64url() { - let id = RegistrationId([0xff; LEN]); - - assert_eq!(serde_json::to_value(id).unwrap(), "_____________________w"); - } - - #[test] - fn rejects_wrong_length_and_alphabet() { - assert!(RegistrationId::from_base64(&URL_SAFE_NO_PAD.encode([0; 15])).is_err()); - assert!(RegistrationId::from_base64(&URL_SAFE_NO_PAD.encode([0; 17])).is_err()); - assert!(RegistrationId::from_base64("+++++++++++++++++++++w").is_err()); - assert!(RegistrationId::from_base64("_____________________w==").is_err()); - } + use uuid::Uuid; #[test] fn opaque_identifier_is_pinned() { @@ -166,11 +31,4 @@ mod tests { user_id ); } - - #[test] - fn error_names_the_field() { - let err = LoginId::from_base64("").unwrap_err(); - - assert!(err.to_string().starts_with("login_id ")); - } } diff --git a/rust/crates/keygo-server/src/domain/mod.rs b/rust/crates/keygo-server/src/domain/mod.rs index 1d77121e3..e291f9f47 100644 --- a/rust/crates/keygo-server/src/domain/mod.rs +++ b/rust/crates/keygo-server/src/domain/mod.rs @@ -1,5 +1,4 @@ mod access_token; -mod device; mod ids; mod invite_code; mod invite_hash; @@ -7,21 +6,21 @@ mod invite_id; mod key_bundle; mod sealed_blob; mod session; -mod string_enum; mod time; -mod username; #[cfg(test)] pub use access_token::FRESH_AUTH_WINDOW; pub use access_token::{ACCESS_TOKEN_LIFETIME, AccessToken, AccessTokenKey, Claims, TokenIssuer}; -pub use device::{Device, DeviceClaim, DeviceInfo}; -pub use ids::{DeviceId, LoginId, RegistrationId, SessionId, UserId, opaque_identifier}; +pub use ids::opaque_identifier; pub use invite_code::{InviteCode, InvitePepper}; pub use invite_hash::InviteHash; pub use invite_id::InviteId; pub use key_bundle::KeyBundle; +pub use keygo_api::domain::{ + Device, DeviceClaim, DeviceInfo, LoginId, RegistrationId, RevokeReason, Username, UsernameError, +}; +pub use keygo_core::{DeviceId, SessionId, UserId}; pub use sealed_blob::InvalidBlob; pub use sealed_blob::{SealedBlob, check_wrapped_ark}; -pub use session::{REFRESH_TTL, RefreshToken, RevokeReason, SESSION_LIFETIME, SESSION_RETENTION}; +pub use session::{REFRESH_TTL, RefreshToken, SESSION_LIFETIME, SESSION_RETENTION}; pub use time::unix_now; -pub use username::{Username, UsernameError}; diff --git a/rust/crates/keygo-server/src/domain/session.rs b/rust/crates/keygo-server/src/domain/session.rs index 1c79ccca3..922308464 100644 --- a/rust/crates/keygo-server/src/domain/session.rs +++ b/rust/crates/keygo-server/src/domain/session.rs @@ -1,4 +1,3 @@ -use super::string_enum::string_enum; use base64::Engine; use base64::engine::general_purpose::URL_SAFE_NO_PAD; use serde::{Deserialize, Deserializer, Serialize, Serializer}; @@ -17,14 +16,6 @@ const TOKEN_BYTES: usize = 32; const ENCODED_LEN: usize = PREFIX.len() + base64::encoded_len(TOKEN_BYTES, false).expect("encoded length can be represented by usize"); -string_enum! { - pub enum RevokeReason { - Replaced => "replaced", - ReuseDetected => "reuse_detected", - Logout => "logout", - } -} - #[derive(Zeroize, ZeroizeOnDrop)] pub struct RefreshToken([u8; TOKEN_BYTES]); @@ -137,14 +128,6 @@ mod tests { ); } - #[test] - fn revoke_reason_round_trips_its_stored_name() { - for &reason in RevokeReason::ALL { - assert_eq!(reason.as_str().parse::().unwrap(), reason); - } - assert!("logout_typo".parse::().is_err()); - } - #[test] fn parse_round_trips_the_encoding() { let token = RefreshToken::generate(); From 0c35462fab3870f33a5542fc6a8cbbcfb519d1db Mon Sep 17 00:00:00 2001 From: Davis Date: Mon, 9 Nov 2026 18:01:20 +0100 Subject: [PATCH 04/52] refactor(server): share tokens and key bundles through keygo-api Co-Authored-By: Claude Opus 5.5 --- rust/Cargo.lock | 4 + rust/crates/keygo-api/Cargo.toml | 7 +- .../keygo-api/src/domain/access_token.rs | 29 +++ .../src/domain/key_bundle.rs | 2 +- rust/crates/keygo-api/src/domain/mod.rs | 8 +- .../src/domain/sealed_blob.rs | 0 rust/crates/keygo-api/src/domain/session.rs | 210 +++++++++++++++++ .../keygo-server/src/domain/access_token.rs | 15 +- rust/crates/keygo-server/src/domain/mod.rs | 12 +- .../crates/keygo-server/src/domain/session.rs | 212 ------------------ 10 files changed, 263 insertions(+), 236 deletions(-) create mode 100644 rust/crates/keygo-api/src/domain/access_token.rs rename rust/crates/{keygo-server => keygo-api}/src/domain/key_bundle.rs (80%) rename rust/crates/{keygo-server => keygo-api}/src/domain/sealed_blob.rs (100%) diff --git a/rust/Cargo.lock b/rust/Cargo.lock index a6958808d..bb9b4dbe5 100644 --- a/rust/Cargo.lock +++ b/rust/Cargo.lock @@ -1599,13 +1599,17 @@ version = "0.1.0" dependencies = [ "base64 0.23.1", "getrandom 0.4.3", + "hex", + "keygo-api", "keygo-core", "serde", "serde_json", + "sha2 0.11.1", "thiserror", "unicode-normalization", "unicode-properties", "uuid", + "zeroize", ] [[package]] diff --git a/rust/crates/keygo-api/Cargo.toml b/rust/crates/keygo-api/Cargo.toml index febbbf71d..bb07180b7 100644 --- a/rust/crates/keygo-api/Cargo.toml +++ b/rust/crates/keygo-api/Cargo.toml @@ -5,7 +5,7 @@ version.workspace = true edition.workspace = true [features] -server = ["dep:getrandom"] +server = ["dep:getrandom", "dep:sha2"] [dependencies] keygo-core = { path = "../keygo-core" } @@ -15,9 +15,14 @@ thiserror.workspace = true uuid.workspace = true base64.workspace = true getrandom = { workspace = true, optional = true } +sha2 = { workspace = true, optional = true } +zeroize = { workspace = true, features = ["derive"] } unicode-normalization = "0.1.25" unicode-properties = { version = "0.1.4", default-features = false, features = ["general-category"] } [dev-dependencies] +keygo-api = { path = ".", features = ["server"] } getrandom.workspace = true serde_json.workspace = true +sha2.workspace = true +hex = "0.4.3" diff --git a/rust/crates/keygo-api/src/domain/access_token.rs b/rust/crates/keygo-api/src/domain/access_token.rs new file mode 100644 index 000000000..5e365518f --- /dev/null +++ b/rust/crates/keygo-api/src/domain/access_token.rs @@ -0,0 +1,29 @@ +use serde::{Deserialize, Serialize}; +use zeroize::{Zeroize, ZeroizeOnDrop}; + +#[derive(Serialize, Deserialize, Zeroize, ZeroizeOnDrop)] +pub struct AccessToken(String); + +impl AccessToken { + pub fn expose(&self) -> &str { + &self.0 + } + + #[cfg(feature = "server")] + pub fn from_signed(token: String) -> Self { + Self(token) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use serde_json::json; + + #[test] + fn round_trips_as_a_plain_string() { + let token: AccessToken = serde_json::from_value(json!("a.b.c")).unwrap(); + assert_eq!(token.expose(), "a.b.c"); + assert_eq!(serde_json::to_value(&token).unwrap(), "a.b.c"); + } +} diff --git a/rust/crates/keygo-server/src/domain/key_bundle.rs b/rust/crates/keygo-api/src/domain/key_bundle.rs similarity index 80% rename from rust/crates/keygo-server/src/domain/key_bundle.rs rename to rust/crates/keygo-api/src/domain/key_bundle.rs index a248d05c0..0169122b6 100644 --- a/rust/crates/keygo-server/src/domain/key_bundle.rs +++ b/rust/crates/keygo-api/src/domain/key_bundle.rs @@ -1,4 +1,4 @@ -use crate::domain::SealedBlob; +use super::SealedBlob; use serde::{Deserialize, Serialize}; #[derive(Serialize, Deserialize)] diff --git a/rust/crates/keygo-api/src/domain/mod.rs b/rust/crates/keygo-api/src/domain/mod.rs index f873085b1..c4bafa1a7 100644 --- a/rust/crates/keygo-api/src/domain/mod.rs +++ b/rust/crates/keygo-api/src/domain/mod.rs @@ -1,14 +1,20 @@ +mod access_token; mod device; mod ids; +mod key_bundle; +mod sealed_blob; mod session; mod string_enum; mod username; +pub use access_token::AccessToken; pub use device::{ AppVersion, AppVersionError, Device, DeviceClaim, DeviceInfo, DeviceName, DeviceNameError, Platform, }; pub use ids::{InvalidId, LoginId, RegistrationId}; -pub use session::RevokeReason; +pub use key_bundle::KeyBundle; +pub use sealed_blob::{InvalidBlob, SealedBlob, check_wrapped_ark}; +pub use session::{ParseRefreshTokenError, RefreshToken, RevokeReason}; pub use string_enum::UnknownVariant; pub use username::{Username, UsernameError}; diff --git a/rust/crates/keygo-server/src/domain/sealed_blob.rs b/rust/crates/keygo-api/src/domain/sealed_blob.rs similarity index 100% rename from rust/crates/keygo-server/src/domain/sealed_blob.rs rename to rust/crates/keygo-api/src/domain/sealed_blob.rs diff --git a/rust/crates/keygo-api/src/domain/session.rs b/rust/crates/keygo-api/src/domain/session.rs index b2c955197..bf21d80fc 100644 --- a/rust/crates/keygo-api/src/domain/session.rs +++ b/rust/crates/keygo-api/src/domain/session.rs @@ -1,4 +1,12 @@ use super::string_enum::string_enum; +use base64::Engine; +use base64::engine::general_purpose::URL_SAFE_NO_PAD; +use serde::{Deserialize, Deserializer, Serialize, Serializer}; +#[cfg(feature = "server")] +use sha2::{Digest, Sha256}; +use std::str::FromStr; +use thiserror::Error; +use zeroize::{Zeroize, ZeroizeOnDrop, Zeroizing}; string_enum! { pub enum RevokeReason { @@ -8,6 +16,80 @@ string_enum! { } } +const PREFIX: &str = "kgr_"; +const TOKEN_BYTES: usize = 32; +const ENCODED_LEN: usize = PREFIX.len() + + base64::encoded_len(TOKEN_BYTES, false).expect("encoded length can be represented by usize"); + +#[derive(Zeroize, ZeroizeOnDrop)] +pub struct RefreshToken([u8; TOKEN_BYTES]); + +impl RefreshToken { + #[cfg(feature = "server")] + pub fn generate() -> Self { + let mut token = [0u8; TOKEN_BYTES]; + getrandom::fill(token.as_mut_slice()).expect("OS random number generator unavailable"); + Self(token) + } + + pub fn expose_encoded(&self) -> Zeroizing { + let mut out = Zeroizing::new(String::with_capacity(ENCODED_LEN)); + out.push_str(PREFIX); + URL_SAFE_NO_PAD.encode_string(self.0, &mut out); + out + } + + #[cfg(feature = "server")] + pub fn digest(&self) -> [u8; TOKEN_BYTES] { + Sha256::digest(self.0).into() + } +} + +impl Serialize for RefreshToken { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + serializer.serialize_str(&self.expose_encoded()) + } +} + +#[derive(Debug, Error)] +pub enum ParseRefreshTokenError { + #[error("invalid prefix")] + InvalidPrefix, + #[error("invalid token")] + InvalidToken, +} + +impl FromStr for RefreshToken { + type Err = ParseRefreshTokenError; + + fn from_str(s: &str) -> Result { + let Some(token) = s.strip_prefix(PREFIX) else { + return Err(ParseRefreshTokenError::InvalidPrefix); + }; + + if token.len() != ENCODED_LEN - PREFIX.len() { + return Err(ParseRefreshTokenError::InvalidToken); + } + + let mut out = RefreshToken([0; TOKEN_BYTES]); + URL_SAFE_NO_PAD + .decode_slice(token, &mut out.0) + .map_err(|_| ParseRefreshTokenError::InvalidToken)?; + + Ok(out) + } +} + +impl<'de> Deserialize<'de> for RefreshToken { + fn deserialize>(deserializer: D) -> Result { + let text = Zeroizing::new(String::deserialize(deserializer)?); + text.parse().map_err(serde::de::Error::custom) + } +} + #[cfg(test)] mod tests { use super::*; @@ -19,4 +101,132 @@ mod tests { } assert!("logout_typo".parse::().is_err()); } + + #[test] + fn generated_tokens_differ() { + assert_ne!( + RefreshToken::generate().digest(), + RefreshToken::generate().digest(), + ); + } + + #[test] + fn encodes_as_prefixed_unpadded_base64url() { + let encoded = RefreshToken([0xff; TOKEN_BYTES]).expose_encoded(); + + assert_eq!( + encoded.as_str(), + "kgr___________________________________________8" + ); + assert_eq!(encoded.len(), ENCODED_LEN); + } + + #[test] + fn encoding_round_trips_the_secret() { + let token = RefreshToken::generate(); + let encoded = token.expose_encoded(); + + let raw = URL_SAFE_NO_PAD + .decode(encoded.strip_prefix(PREFIX).unwrap()) + .unwrap(); + + assert_eq!(raw, token.0); + } + + #[test] + fn serializes_as_the_encoded_token() { + let token = RefreshToken::generate(); + + assert_eq!( + serde_json::to_value(&token).unwrap(), + token.expose_encoded().as_str(), + ); + } + + #[test] + fn parse_round_trips_the_encoding() { + let token = RefreshToken::generate(); + + let parsed: RefreshToken = token.expose_encoded().parse().unwrap(); + + assert_eq!(parsed.0, token.0); + } + + #[test] + fn parse_rejects_a_missing_prefix() { + let encoded = RefreshToken::generate().expose_encoded(); + let unprefixed = encoded.strip_prefix(PREFIX).unwrap(); + + assert!(matches!( + unprefixed.parse::(), + Err(ParseRefreshTokenError::InvalidPrefix), + )); + assert!(matches!( + format!("kga_{unprefixed}").parse::(), + Err(ParseRefreshTokenError::InvalidPrefix), + )); + } + + #[test] + fn parse_rejects_the_wrong_length() { + let encoded = RefreshToken::generate().expose_encoded(); + + for text in [ + &encoded[..ENCODED_LEN - 1], + &format!("{}A", encoded.as_str()), + ] { + assert!(matches!( + text.parse::(), + Err(ParseRefreshTokenError::InvalidToken), + )); + } + } + + #[test] + fn parse_rejects_non_base64url() { + let text = format!("{PREFIX}{}", "+".repeat(ENCODED_LEN - PREFIX.len())); + + assert!(matches!( + text.parse::(), + Err(ParseRefreshTokenError::InvalidToken), + )); + } + + #[test] + fn parse_rejects_non_canonical_trailing_bits() { + // Same bytes as the canonical "…8", but the unused low bits of the last char are set. + let text = "kgr___________________________________________9"; + + assert!(matches!( + text.parse::(), + Err(ParseRefreshTokenError::InvalidToken), + )); + } + + #[test] + fn deserializes_from_the_encoded_token() { + let token = RefreshToken::generate(); + let json = serde_json::to_value(&token).unwrap(); + + let parsed: RefreshToken = serde_json::from_value(json).unwrap(); + + assert_eq!(parsed.0, token.0); + } + + #[test] + fn deserialize_rejects_a_malformed_token() { + assert!(serde_json::from_str::(r#""kgr_short""#).is_err()); + assert!( + serde_json::from_value::(serde_json::json!(vec![0u8; TOKEN_BYTES])) + .is_err() + ); + } + + #[test] + fn digest_is_sha256_of_the_raw_secret() { + assert_eq!( + hex::encode(RefreshToken([0; TOKEN_BYTES]).digest()), + "66687aadf862bd776c8fc18b8e9f8e20089714856ee233b3902a591d0d5f2925", + ); + } } diff --git a/rust/crates/keygo-server/src/domain/access_token.rs b/rust/crates/keygo-server/src/domain/access_token.rs index d5a705799..72765f6b2 100644 --- a/rust/crates/keygo-server/src/domain/access_token.rs +++ b/rust/crates/keygo-server/src/domain/access_token.rs @@ -1,4 +1,4 @@ -use crate::domain::{SessionId, UserId, unix_now}; +use crate::domain::{AccessToken, SessionId, UserId, unix_now}; use base64::Engine; use base64::engine::general_purpose::URL_SAFE_NO_PAD; use ed25519_dalek::{Signature, Signer, SigningKey}; @@ -7,7 +7,6 @@ use serde::{Deserialize, Serialize}; use sha2::{Digest, Sha256}; use std::time::Duration; use thiserror::Error; -use zeroize::{Zeroize, ZeroizeOnDrop}; pub const ACCESS_TOKEN_LIFETIME: Duration = Duration::from_mins(10); pub const FRESH_AUTH_WINDOW: Duration = Duration::from_mins(5); @@ -101,9 +100,6 @@ struct Header { kid: String, } -#[derive(Serialize, Zeroize, ZeroizeOnDrop)] -pub struct AccessToken(String); - #[derive(Debug, Clone, Copy, PartialEq, Eq, Error)] pub enum TokenError { #[error("token is not a well-formed access token")] @@ -168,13 +164,6 @@ impl Claims { } } -impl AccessToken { - #[cfg(test)] - pub(crate) fn expose(&self) -> &str { - &self.0 - } -} - impl AccessTokenKey { pub fn new(seed: &[u8; 32]) -> Self { let signing = SigningKey::from_bytes(seed); @@ -194,7 +183,7 @@ impl AccessTokenKey { let input = format!("{}.{}", encode(&header), encode(claims)); let signature = self.signing.sign(input.as_bytes()); - AccessToken(format!( + AccessToken::from_signed(format!( "{input}.{}", URL_SAFE_NO_PAD.encode(signature.to_bytes()) )) diff --git a/rust/crates/keygo-server/src/domain/mod.rs b/rust/crates/keygo-server/src/domain/mod.rs index e291f9f47..99b60eaa0 100644 --- a/rust/crates/keygo-server/src/domain/mod.rs +++ b/rust/crates/keygo-server/src/domain/mod.rs @@ -3,24 +3,20 @@ mod ids; mod invite_code; mod invite_hash; mod invite_id; -mod key_bundle; -mod sealed_blob; mod session; mod time; #[cfg(test)] pub use access_token::FRESH_AUTH_WINDOW; -pub use access_token::{ACCESS_TOKEN_LIFETIME, AccessToken, AccessTokenKey, Claims, TokenIssuer}; +pub use access_token::{ACCESS_TOKEN_LIFETIME, AccessTokenKey, Claims, TokenIssuer}; pub use ids::opaque_identifier; pub use invite_code::{InviteCode, InvitePepper}; pub use invite_hash::InviteHash; pub use invite_id::InviteId; -pub use key_bundle::KeyBundle; pub use keygo_api::domain::{ - Device, DeviceClaim, DeviceInfo, LoginId, RegistrationId, RevokeReason, Username, UsernameError, + AccessToken, Device, DeviceClaim, DeviceInfo, InvalidBlob, KeyBundle, LoginId, RefreshToken, + RegistrationId, RevokeReason, SealedBlob, Username, UsernameError, check_wrapped_ark, }; pub use keygo_core::{DeviceId, SessionId, UserId}; -pub use sealed_blob::InvalidBlob; -pub use sealed_blob::{SealedBlob, check_wrapped_ark}; -pub use session::{REFRESH_TTL, RefreshToken, SESSION_LIFETIME, SESSION_RETENTION}; +pub use session::{REFRESH_TTL, SESSION_LIFETIME, SESSION_RETENTION}; pub use time::unix_now; diff --git a/rust/crates/keygo-server/src/domain/session.rs b/rust/crates/keygo-server/src/domain/session.rs index 922308464..adb631ac5 100644 --- a/rust/crates/keygo-server/src/domain/session.rs +++ b/rust/crates/keygo-server/src/domain/session.rs @@ -1,217 +1,5 @@ -use base64::Engine; -use base64::engine::general_purpose::URL_SAFE_NO_PAD; -use serde::{Deserialize, Deserializer, Serialize, Serializer}; -use sha2::{Digest, Sha256}; -use std::str::FromStr; use std::time::Duration; -use thiserror::Error; -use zeroize::{Zeroize, ZeroizeOnDrop, Zeroizing}; pub const SESSION_LIFETIME: Duration = Duration::from_hours(180 * 24); pub const REFRESH_TTL: Duration = Duration::from_hours(30 * 24); pub const SESSION_RETENTION: Duration = Duration::from_hours(30 * 24); - -const PREFIX: &str = "kgr_"; -const TOKEN_BYTES: usize = 32; -const ENCODED_LEN: usize = PREFIX.len() - + base64::encoded_len(TOKEN_BYTES, false).expect("encoded length can be represented by usize"); - -#[derive(Zeroize, ZeroizeOnDrop)] -pub struct RefreshToken([u8; TOKEN_BYTES]); - -impl RefreshToken { - pub fn generate() -> Self { - let mut token = [0u8; TOKEN_BYTES]; - getrandom::fill(token.as_mut_slice()).expect("OS random number generator unavailable"); - Self(token) - } - - pub fn expose_encoded(&self) -> Zeroizing { - let mut out = Zeroizing::new(String::with_capacity(ENCODED_LEN)); - out.push_str(PREFIX); - URL_SAFE_NO_PAD.encode_string(self.0, &mut out); - out - } - - pub fn digest(&self) -> [u8; TOKEN_BYTES] { - Sha256::digest(self.0).into() - } -} - -impl Serialize for RefreshToken { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - serializer.serialize_str(&self.expose_encoded()) - } -} - -#[derive(Debug, Error)] -pub enum ParseRefreshTokenError { - #[error("invalid prefix")] - InvalidPrefix, - #[error("invalid token")] - InvalidToken, -} - -impl FromStr for RefreshToken { - type Err = ParseRefreshTokenError; - - fn from_str(s: &str) -> Result { - let Some(token) = s.strip_prefix(PREFIX) else { - return Err(ParseRefreshTokenError::InvalidPrefix); - }; - - if token.len() != ENCODED_LEN - PREFIX.len() { - return Err(ParseRefreshTokenError::InvalidToken); - } - - let mut out = RefreshToken([0; TOKEN_BYTES]); - URL_SAFE_NO_PAD - .decode_slice(token, &mut out.0) - .map_err(|_| ParseRefreshTokenError::InvalidToken)?; - - Ok(out) - } -} - -impl<'de> Deserialize<'de> for RefreshToken { - fn deserialize>(deserializer: D) -> Result { - let text = Zeroizing::new(String::deserialize(deserializer)?); - text.parse().map_err(serde::de::Error::custom) - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn generated_tokens_differ() { - assert_ne!( - RefreshToken::generate().digest(), - RefreshToken::generate().digest(), - ); - } - - #[test] - fn encodes_as_prefixed_unpadded_base64url() { - let encoded = RefreshToken([0xff; TOKEN_BYTES]).expose_encoded(); - - assert_eq!( - encoded.as_str(), - "kgr___________________________________________8" - ); - assert_eq!(encoded.len(), ENCODED_LEN); - } - - #[test] - fn encoding_round_trips_the_secret() { - let token = RefreshToken::generate(); - let encoded = token.expose_encoded(); - - let raw = URL_SAFE_NO_PAD - .decode(encoded.strip_prefix(PREFIX).unwrap()) - .unwrap(); - - assert_eq!(raw, token.0); - } - - #[test] - fn serializes_as_the_encoded_token() { - let token = RefreshToken::generate(); - - assert_eq!( - serde_json::to_value(&token).unwrap(), - token.expose_encoded().as_str(), - ); - } - - #[test] - fn parse_round_trips_the_encoding() { - let token = RefreshToken::generate(); - - let parsed: RefreshToken = token.expose_encoded().parse().unwrap(); - - assert_eq!(parsed.0, token.0); - } - - #[test] - fn parse_rejects_a_missing_prefix() { - let encoded = RefreshToken::generate().expose_encoded(); - let unprefixed = encoded.strip_prefix(PREFIX).unwrap(); - - assert!(matches!( - unprefixed.parse::(), - Err(ParseRefreshTokenError::InvalidPrefix), - )); - assert!(matches!( - format!("kga_{unprefixed}").parse::(), - Err(ParseRefreshTokenError::InvalidPrefix), - )); - } - - #[test] - fn parse_rejects_the_wrong_length() { - let encoded = RefreshToken::generate().expose_encoded(); - - for text in [ - &encoded[..ENCODED_LEN - 1], - &format!("{}A", encoded.as_str()), - ] { - assert!(matches!( - text.parse::(), - Err(ParseRefreshTokenError::InvalidToken), - )); - } - } - - #[test] - fn parse_rejects_non_base64url() { - let text = format!("{PREFIX}{}", "+".repeat(ENCODED_LEN - PREFIX.len())); - - assert!(matches!( - text.parse::(), - Err(ParseRefreshTokenError::InvalidToken), - )); - } - - #[test] - fn parse_rejects_non_canonical_trailing_bits() { - // Same bytes as the canonical "…8", but the unused low bits of the last char are set. - let text = "kgr___________________________________________9"; - - assert!(matches!( - text.parse::(), - Err(ParseRefreshTokenError::InvalidToken), - )); - } - - #[test] - fn deserializes_from_the_encoded_token() { - let token = RefreshToken::generate(); - let json = serde_json::to_value(&token).unwrap(); - - let parsed: RefreshToken = serde_json::from_value(json).unwrap(); - - assert_eq!(parsed.0, token.0); - } - - #[test] - fn deserialize_rejects_a_malformed_token() { - assert!(serde_json::from_str::(r#""kgr_short""#).is_err()); - assert!( - serde_json::from_value::(serde_json::json!(vec![0u8; TOKEN_BYTES])) - .is_err() - ); - } - - #[test] - fn digest_is_sha256_of_the_raw_secret() { - assert_eq!( - hex::encode(RefreshToken([0; TOKEN_BYTES]).digest()), - "66687aadf862bd776c8fc18b8e9f8e20089714856ee233b3902a591d0d5f2925", - ); - } -} From 85f0193a8bd53ed9569dfd43dacf841a7344280a Mon Sep 17 00:00:00 2001 From: Davis Date: Mon, 9 Nov 2026 18:06:45 +0100 Subject: [PATCH 05/52] fix(api): use the defined server gate for token minting Co-Authored-By: Claude Opus 5.5 --- rust/Cargo.lock | 1 - rust/crates/keygo-api/Cargo.toml | 1 - rust/crates/keygo-api/src/domain/access_token.rs | 2 +- rust/crates/keygo-api/src/domain/key_bundle.rs | 2 +- rust/crates/keygo-api/src/domain/session.rs | 6 +++--- 5 files changed, 5 insertions(+), 7 deletions(-) diff --git a/rust/Cargo.lock b/rust/Cargo.lock index bb9b4dbe5..b2795cbae 100644 --- a/rust/Cargo.lock +++ b/rust/Cargo.lock @@ -1600,7 +1600,6 @@ dependencies = [ "base64 0.23.1", "getrandom 0.4.3", "hex", - "keygo-api", "keygo-core", "serde", "serde_json", diff --git a/rust/crates/keygo-api/Cargo.toml b/rust/crates/keygo-api/Cargo.toml index bb07180b7..bcf6f1274 100644 --- a/rust/crates/keygo-api/Cargo.toml +++ b/rust/crates/keygo-api/Cargo.toml @@ -21,7 +21,6 @@ unicode-normalization = "0.1.25" unicode-properties = { version = "0.1.4", default-features = false, features = ["general-category"] } [dev-dependencies] -keygo-api = { path = ".", features = ["server"] } getrandom.workspace = true serde_json.workspace = true sha2.workspace = true diff --git a/rust/crates/keygo-api/src/domain/access_token.rs b/rust/crates/keygo-api/src/domain/access_token.rs index 5e365518f..fca25aa76 100644 --- a/rust/crates/keygo-api/src/domain/access_token.rs +++ b/rust/crates/keygo-api/src/domain/access_token.rs @@ -9,7 +9,7 @@ impl AccessToken { &self.0 } - #[cfg(feature = "server")] + #[cfg(any(test, feature = "server"))] pub fn from_signed(token: String) -> Self { Self(token) } diff --git a/rust/crates/keygo-api/src/domain/key_bundle.rs b/rust/crates/keygo-api/src/domain/key_bundle.rs index 0169122b6..a248d05c0 100644 --- a/rust/crates/keygo-api/src/domain/key_bundle.rs +++ b/rust/crates/keygo-api/src/domain/key_bundle.rs @@ -1,4 +1,4 @@ -use super::SealedBlob; +use crate::domain::SealedBlob; use serde::{Deserialize, Serialize}; #[derive(Serialize, Deserialize)] diff --git a/rust/crates/keygo-api/src/domain/session.rs b/rust/crates/keygo-api/src/domain/session.rs index bf21d80fc..e9ea367b1 100644 --- a/rust/crates/keygo-api/src/domain/session.rs +++ b/rust/crates/keygo-api/src/domain/session.rs @@ -2,7 +2,7 @@ use super::string_enum::string_enum; use base64::Engine; use base64::engine::general_purpose::URL_SAFE_NO_PAD; use serde::{Deserialize, Deserializer, Serialize, Serializer}; -#[cfg(feature = "server")] +#[cfg(any(test, feature = "server"))] use sha2::{Digest, Sha256}; use std::str::FromStr; use thiserror::Error; @@ -25,7 +25,7 @@ const ENCODED_LEN: usize = PREFIX.len() pub struct RefreshToken([u8; TOKEN_BYTES]); impl RefreshToken { - #[cfg(feature = "server")] + #[cfg(any(test, feature = "server"))] pub fn generate() -> Self { let mut token = [0u8; TOKEN_BYTES]; getrandom::fill(token.as_mut_slice()).expect("OS random number generator unavailable"); @@ -39,7 +39,7 @@ impl RefreshToken { out } - #[cfg(feature = "server")] + #[cfg(any(test, feature = "server"))] pub fn digest(&self) -> [u8; TOKEN_BYTES] { Sha256::digest(self.0).into() } From 2c1a8415e8cf9dfcc1de3b33ee847037bbfee685 Mon Sep 17 00:00:00 2001 From: Davis Date: Mon, 9 Nov 2026 18:15:08 +0100 Subject: [PATCH 06/52] refactor(server): move auth and device DTOs to keygo-api Co-Authored-By: Claude Opus 5.5 --- rust/Cargo.lock | 1 + rust/crates/keygo-api/Cargo.toml | 1 + rust/crates/keygo-api/src/auth/handshake.rs | 11 ++ rust/crates/keygo-api/src/auth/login.rs | 28 +++ rust/crates/keygo-api/src/auth/mod.rs | 24 +++ rust/crates/keygo-api/src/auth/register.rs | 35 ++++ rust/crates/keygo-api/src/auth/step_up.rs | 23 +++ rust/crates/keygo-api/src/auth/token.rs | 7 + rust/crates/keygo-api/src/devices.rs | 7 + rust/crates/keygo-api/src/endpoint.rs | 43 ++++ rust/crates/keygo-api/src/endpoints.rs | 184 ++++++++++++++++++ rust/crates/keygo-api/src/lib.rs | 19 ++ rust/crates/keygo-api/src/meta.rs | 8 + rust/crates/keygo-server/src/api/mod.rs | 48 ++++- .../src/api/routes/auth/handshake.rs | 11 +- .../keygo-server/src/api/routes/auth/login.rs | 32 +-- .../src/api/routes/auth/register.rs | 38 +--- .../src/api/routes/auth/session.rs | 31 +-- .../src/api/routes/auth/step_up.rs | 29 +-- .../keygo-server/src/api/routes/auth/token.rs | 11 +- .../keygo-server/src/api/routes/devices.rs | 9 +- .../keygo-server/src/api/routes/meta.rs | 11 +- 22 files changed, 465 insertions(+), 146 deletions(-) create mode 100644 rust/crates/keygo-api/src/auth/handshake.rs create mode 100644 rust/crates/keygo-api/src/auth/login.rs create mode 100644 rust/crates/keygo-api/src/auth/mod.rs create mode 100644 rust/crates/keygo-api/src/auth/register.rs create mode 100644 rust/crates/keygo-api/src/auth/step_up.rs create mode 100644 rust/crates/keygo-api/src/auth/token.rs create mode 100644 rust/crates/keygo-api/src/devices.rs create mode 100644 rust/crates/keygo-api/src/endpoint.rs create mode 100644 rust/crates/keygo-api/src/endpoints.rs create mode 100644 rust/crates/keygo-api/src/meta.rs diff --git a/rust/Cargo.lock b/rust/Cargo.lock index b2795cbae..e73345a2b 100644 --- a/rust/Cargo.lock +++ b/rust/Cargo.lock @@ -1601,6 +1601,7 @@ dependencies = [ "getrandom 0.4.3", "hex", "keygo-core", + "keygo-opaque", "serde", "serde_json", "sha2 0.11.1", diff --git a/rust/crates/keygo-api/Cargo.toml b/rust/crates/keygo-api/Cargo.toml index bcf6f1274..7ba2d94d4 100644 --- a/rust/crates/keygo-api/Cargo.toml +++ b/rust/crates/keygo-api/Cargo.toml @@ -9,6 +9,7 @@ server = ["dep:getrandom", "dep:sha2"] [dependencies] keygo-core = { path = "../keygo-core" } +keygo-opaque = { path = "../keygo-opaque" } serde = { workspace = true, features = ["derive"] } thiserror.workspace = true diff --git a/rust/crates/keygo-api/src/auth/handshake.rs b/rust/crates/keygo-api/src/auth/handshake.rs new file mode 100644 index 000000000..5c44bd14e --- /dev/null +++ b/rust/crates/keygo-api/src/auth/handshake.rs @@ -0,0 +1,11 @@ +use crate::domain::LoginId; +use keygo_opaque::CredentialResponse; +use serde::{Deserialize, Serialize}; + +/// The first answer of an OPAQUE login, shared by sign-in and step-up. +#[derive(Serialize, Deserialize)] +pub struct StartResponse { + pub login_id: LoginId, + pub credential_response: CredentialResponse, + pub expires_in: u64, +} diff --git a/rust/crates/keygo-api/src/auth/login.rs b/rust/crates/keygo-api/src/auth/login.rs new file mode 100644 index 000000000..b591c61d0 --- /dev/null +++ b/rust/crates/keygo-api/src/auth/login.rs @@ -0,0 +1,28 @@ +use super::Session; +use crate::domain::{DeviceClaim, KeyBundle, LoginId, Username}; +use keygo_core::UserId; +use keygo_opaque::{CredentialFinalization, CredentialRequest, DpopBinding}; +use serde::{Deserialize, Serialize}; + +#[derive(Serialize, Deserialize)] +pub struct StartRequest { + /// Parsed in the handler so a bad name answers `invalid_username`, not `invalid_request`. + pub username: String, + pub credential_request: CredentialRequest, +} + +#[derive(Serialize, Deserialize)] +pub struct FinishRequest { + pub login_id: LoginId, + pub credential_finalization: CredentialFinalization, + pub device: DeviceClaim, + pub dpop_binding: DpopBinding, +} + +#[derive(Serialize, Deserialize)] +pub struct FinishResponse { + pub user_id: UserId, + pub username: Username, + pub key_bundle: KeyBundle, + pub session: Session, +} diff --git a/rust/crates/keygo-api/src/auth/mod.rs b/rust/crates/keygo-api/src/auth/mod.rs new file mode 100644 index 000000000..27a5a616f --- /dev/null +++ b/rust/crates/keygo-api/src/auth/mod.rs @@ -0,0 +1,24 @@ +use crate::domain::{AccessToken, RefreshToken}; +use keygo_core::DeviceId; +use serde::{Deserialize, Serialize}; + +pub mod handshake; +pub mod login; +pub mod register; +pub mod step_up; +pub mod token; + +#[derive(Serialize, Deserialize)] +pub struct Access { + pub access_token: AccessToken, + pub access_expires_in: u64, +} + +#[derive(Serialize, Deserialize)] +pub struct Session { + pub device_id: DeviceId, + #[serde(flatten)] + pub access: Access, + pub refresh_token: RefreshToken, + pub refresh_expires_in: u64, +} diff --git a/rust/crates/keygo-api/src/auth/register.rs b/rust/crates/keygo-api/src/auth/register.rs new file mode 100644 index 000000000..68843d67b --- /dev/null +++ b/rust/crates/keygo-api/src/auth/register.rs @@ -0,0 +1,35 @@ +use super::Session; +use crate::domain::{DeviceInfo, KeyBundle, RegistrationId, Username}; +use keygo_core::UserId; +use keygo_opaque::{RegistrationRequest, RegistrationResponse, RegistrationUpload}; +use serde::{Deserialize, Serialize}; + +#[derive(Serialize, Deserialize)] +pub struct StartRequest { + /// Parsed in the handler so a bad name answers `invalid_username`, not `invalid_request`. + pub username: String, + pub user_id: UserId, + pub invite: Option, + pub registration_request: RegistrationRequest, +} + +#[derive(Serialize, Deserialize)] +pub struct StartResponse { + pub registration_id: RegistrationId, + pub registration_response: RegistrationResponse, + pub expires_in: u64, +} + +#[derive(Serialize, Deserialize)] +pub struct FinishRequest { + pub registration_id: RegistrationId, + pub registration_upload: RegistrationUpload, + pub key_bundle: KeyBundle, + pub device: DeviceInfo, +} + +#[derive(Serialize, Deserialize)] +pub struct FinishResponse { + pub username: Username, + pub session: Session, +} diff --git a/rust/crates/keygo-api/src/auth/step_up.rs b/rust/crates/keygo-api/src/auth/step_up.rs new file mode 100644 index 000000000..afc9980a1 --- /dev/null +++ b/rust/crates/keygo-api/src/auth/step_up.rs @@ -0,0 +1,23 @@ +use super::Access; +use crate::domain::LoginId; +use keygo_opaque::{CredentialFinalization, CredentialRequest, DpopBinding}; +use serde::{Deserialize, Serialize}; + +#[derive(Serialize, Deserialize)] +pub struct StartRequest { + pub credential_request: CredentialRequest, +} + +#[derive(Serialize, Deserialize)] +pub struct FinishRequest { + pub login_id: LoginId, + pub credential_finalization: CredentialFinalization, + pub dpop_binding: DpopBinding, +} + +#[derive(Serialize, Deserialize)] +pub struct FinishResponse { + #[serde(flatten)] + pub access: Access, + pub auth_time: u64, +} diff --git a/rust/crates/keygo-api/src/auth/token.rs b/rust/crates/keygo-api/src/auth/token.rs new file mode 100644 index 000000000..ec7e031da --- /dev/null +++ b/rust/crates/keygo-api/src/auth/token.rs @@ -0,0 +1,7 @@ +use crate::domain::RefreshToken; +use serde::{Deserialize, Serialize}; + +#[derive(Serialize, Deserialize)] +pub struct TokenRequest { + pub refresh_token: RefreshToken, +} diff --git a/rust/crates/keygo-api/src/devices.rs b/rust/crates/keygo-api/src/devices.rs new file mode 100644 index 000000000..29edbb76a --- /dev/null +++ b/rust/crates/keygo-api/src/devices.rs @@ -0,0 +1,7 @@ +use crate::domain::Device; +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Serialize, Deserialize)] +pub struct Devices { + pub devices: Vec, +} diff --git a/rust/crates/keygo-api/src/endpoint.rs b/rust/crates/keygo-api/src/endpoint.rs new file mode 100644 index 000000000..61960c8e9 --- /dev/null +++ b/rust/crates/keygo-api/src/endpoint.rs @@ -0,0 +1,43 @@ +use serde::Serialize; +use serde::de::DeserializeOwned; +use std::borrow::Cow; + +/// What a request must carry for the server to accept it. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum Auth { + /// Nothing. + None, + /// A DPoP proof, but no access token. + Proof, + /// An access token and the DPoP proof it is bound to. + AccessToken, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum Method { + Get, + Post, + Delete, +} + +impl Method { + pub const fn as_str(self) -> &'static str { + match self { + Self::Get => "GET", + Self::Post => "POST", + Self::Delete => "DELETE", + } + } +} + +/// One route of the sync API, with the types that cross the wire. +pub trait Endpoint { + /// `()` when the route takes no body. + type Request: Serialize + DeserializeOwned; + /// `()` when the route answers 204. + type Response: Serialize + DeserializeOwned; + const METHOD: Method; + const AUTH: Auth; + + fn path(&self) -> Cow<'static, str>; +} diff --git a/rust/crates/keygo-api/src/endpoints.rs b/rust/crates/keygo-api/src/endpoints.rs new file mode 100644 index 000000000..e8a273ce3 --- /dev/null +++ b/rust/crates/keygo-api/src/endpoints.rs @@ -0,0 +1,184 @@ +use crate::endpoint::{Auth, Endpoint, Method}; +use crate::{auth, devices, meta}; +use keygo_core::DeviceId; +use std::borrow::Cow; +use uuid::Uuid; + +pub struct Meta; + +impl Endpoint for Meta { + type Request = (); + type Response = meta::ServerInfo; + const METHOD: Method = Method::Get; + const AUTH: Auth = Auth::None; + + fn path(&self) -> Cow<'static, str> { + Cow::Borrowed("/api/v1/meta") + } +} + +pub struct RegisterStart; + +impl Endpoint for RegisterStart { + type Request = auth::register::StartRequest; + type Response = auth::register::StartResponse; + const METHOD: Method = Method::Post; + const AUTH: Auth = Auth::None; + + fn path(&self) -> Cow<'static, str> { + Cow::Borrowed("/api/v1/auth/register/start") + } +} + +pub struct RegisterFinish; + +impl Endpoint for RegisterFinish { + type Request = auth::register::FinishRequest; + type Response = auth::register::FinishResponse; + const METHOD: Method = Method::Post; + const AUTH: Auth = Auth::Proof; + + fn path(&self) -> Cow<'static, str> { + Cow::Borrowed("/api/v1/auth/register/finish") + } +} + +pub struct LoginStart; + +impl Endpoint for LoginStart { + type Request = auth::login::StartRequest; + type Response = auth::handshake::StartResponse; + const METHOD: Method = Method::Post; + const AUTH: Auth = Auth::None; + + fn path(&self) -> Cow<'static, str> { + Cow::Borrowed("/api/v1/auth/login/start") + } +} + +pub struct LoginFinish; + +impl Endpoint for LoginFinish { + type Request = auth::login::FinishRequest; + type Response = auth::login::FinishResponse; + const METHOD: Method = Method::Post; + const AUTH: Auth = Auth::Proof; + + fn path(&self) -> Cow<'static, str> { + Cow::Borrowed("/api/v1/auth/login/finish") + } +} + +pub struct StepUpStart; + +impl Endpoint for StepUpStart { + type Request = auth::step_up::StartRequest; + type Response = auth::handshake::StartResponse; + const METHOD: Method = Method::Post; + const AUTH: Auth = Auth::AccessToken; + + fn path(&self) -> Cow<'static, str> { + Cow::Borrowed("/api/v1/auth/step-up/start") + } +} + +pub struct StepUpFinish; + +impl Endpoint for StepUpFinish { + type Request = auth::step_up::FinishRequest; + type Response = auth::step_up::FinishResponse; + const METHOD: Method = Method::Post; + const AUTH: Auth = Auth::AccessToken; + + fn path(&self) -> Cow<'static, str> { + Cow::Borrowed("/api/v1/auth/step-up/finish") + } +} + +pub struct Token; + +impl Endpoint for Token { + type Request = auth::token::TokenRequest; + type Response = auth::Session; + const METHOD: Method = Method::Post; + const AUTH: Auth = Auth::Proof; + + fn path(&self) -> Cow<'static, str> { + Cow::Borrowed("/api/v1/auth/token") + } +} + +pub struct Logout; + +impl Endpoint for Logout { + type Request = (); + type Response = (); + const METHOD: Method = Method::Post; + const AUTH: Auth = Auth::AccessToken; + + fn path(&self) -> Cow<'static, str> { + Cow::Borrowed("/api/v1/auth/logout") + } +} + +pub struct ListDevices; + +impl Endpoint for ListDevices { + type Request = (); + type Response = devices::Devices; + const METHOD: Method = Method::Get; + const AUTH: Auth = Auth::AccessToken; + + fn path(&self) -> Cow<'static, str> { + Cow::Borrowed("/api/v1/devices") + } +} + +pub struct DeleteDevice { + pub id: DeviceId, +} + +impl Endpoint for DeleteDevice { + type Request = (); + type Response = (); + const METHOD: Method = Method::Delete; + const AUTH: Auth = Auth::AccessToken; + + fn path(&self) -> Cow<'static, str> { + Cow::Owned(format!("/api/v1/devices/{}", self.id.as_uuid())) + } +} + +/// An endpoint reduced to what a router or a test needs to know about it. +#[derive(Debug)] +pub struct Route { + pub method: Method, + pub path: String, + pub auth: Auth, +} + +fn route(endpoint: E) -> Route { + Route { + method: E::METHOD, + path: endpoint.path().into_owned(), + auth: E::AUTH, + } +} + +pub fn all_routes() -> Vec { + vec![ + route(Meta), + route(RegisterStart), + route(RegisterFinish), + route(LoginStart), + route(LoginFinish), + route(StepUpStart), + route(StepUpFinish), + route(Token), + route(Logout), + route(ListDevices), + route(DeleteDevice { + id: Uuid::nil().into(), + }), + ] +} diff --git a/rust/crates/keygo-api/src/lib.rs b/rust/crates/keygo-api/src/lib.rs index 179fd77f8..fac2c3914 100644 --- a/rust/crates/keygo-api/src/lib.rs +++ b/rust/crates/keygo-api/src/lib.rs @@ -1,6 +1,25 @@ #![forbid(unsafe_code)] +pub mod auth; +pub mod devices; pub mod domain; +mod endpoint; +pub mod endpoints; mod error; +pub mod meta; +pub use endpoint::{Auth, Endpoint, Method}; pub use error::{ApiError, ErrorCode}; + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn every_endpoint_is_listed() { + let declared = include_str!("endpoints.rs") + .matches("impl Endpoint for ") + .count(); + assert_eq!(endpoints::all_routes().len(), declared); + } +} diff --git a/rust/crates/keygo-api/src/meta.rs b/rust/crates/keygo-api/src/meta.rs new file mode 100644 index 000000000..08aea5f70 --- /dev/null +++ b/rust/crates/keygo-api/src/meta.rs @@ -0,0 +1,8 @@ +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Serialize, Deserialize)] +pub struct ServerInfo { + pub version: String, + pub public_url: String, + pub allow_signups: bool, +} diff --git a/rust/crates/keygo-server/src/api/mod.rs b/rust/crates/keygo-server/src/api/mod.rs index 136421785..5d0ff70c4 100644 --- a/rust/crates/keygo-server/src/api/mod.rs +++ b/rust/crates/keygo-server/src/api/mod.rs @@ -55,8 +55,10 @@ mod tests { use crate::domain::InvitePepper; use crate::service::registration::Signup; use axum::body::Body; - use axum::http::{Request, StatusCode}; + use axum::http::{Method as HttpMethod, Request, StatusCode}; use http_body_util::BodyExt; + use keygo_api::endpoints::Route; + use keygo_api::{Auth, Method}; use keygo_dpop::DpopVerifier; use routes::auth::MAX_BODY_BYTES; use serde_json::{Value, json}; @@ -82,6 +84,23 @@ mod tests { (status, body.to_vec()) } + async fn send_empty(route: &Route) -> (StatusCode, Vec) { + let method = match route.method { + Method::Get => HttpMethod::GET, + Method::Post => HttpMethod::POST, + Method::Delete => HttpMethod::DELETE, + }; + let request = Request::builder() + .method(method) + .uri(&route.path) + .body(Body::empty()) + .unwrap(); + let response = router(state()).oneshot(request).await.unwrap(); + let status = response.status(); + let body = response.into_body().collect().await.unwrap().to_bytes(); + (status, body.to_vec()) + } + pub(super) fn state() -> AppState { AppState { public_url: url::Url::parse("http://localhost").unwrap(), @@ -125,6 +144,33 @@ mod tests { ); } + #[tokio::test] + async fn every_endpoint_is_routed() { + for route in keygo_api::endpoints::all_routes() { + let (status, _) = send_empty(&route).await; + assert_ne!(status, StatusCode::NOT_FOUND, "{route:?}"); + assert_ne!(status, StatusCode::METHOD_NOT_ALLOWED, "{route:?}"); + } + } + + #[tokio::test] + async fn every_endpoint_demands_its_declared_auth() { + for route in keygo_api::endpoints::all_routes() { + let (status, body) = send_empty(&route).await; + let code = serde_json::from_slice::(&body) + .ok() + .map(|body| body["code"].clone()); + match route.auth { + Auth::AccessToken => assert_eq!(code, Some(json!("invalid_token")), "{route:?}"), + Auth::Proof => assert_eq!(code, Some(json!("invalid_dpop_proof")), "{route:?}"), + Auth::None => assert!( + status == StatusCode::OK || status == StatusCode::UNSUPPORTED_MEDIA_TYPE, + "{route:?}", + ), + } + } + } + #[tokio::test] async fn unknown_route_is_not_found() { let (status, body) = get(state(), "/api/v1/nope").await; 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 fa3110201..44beb7900 100644 --- a/rust/crates/keygo-server/src/api/routes/auth/handshake.rs +++ b/rust/crates/keygo-server/src/api/routes/auth/handshake.rs @@ -1,8 +1,6 @@ use crate::api::{ErrorCode, HttpError}; -use crate::domain::LoginId; use crate::service::handshake; -use keygo_opaque::CredentialResponse; -use serde::Serialize; +use keygo_api::auth::handshake::StartResponse; // Sign-in and step-up run the same OPAQUE login, so they share its error codes and bodies. impl HttpError for handshake::Error { @@ -15,13 +13,6 @@ impl HttpError for handshake::Error { } } -#[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 { 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 5e82007d3..2c69b82f9 100644 --- a/rust/crates/keygo-server/src/api/routes/auth/login.rs +++ b/rust/crates/keygo-server/src/api/routes/auth/login.rs @@ -1,14 +1,12 @@ use crate::api::dpop::SingleUseDpopProof; -use crate::api::routes::auth::handshake::StartResponse; -use crate::api::routes::auth::session::Session; use crate::api::{AppState, Json, ServerResult}; -use crate::domain::{DeviceClaim, KeyBundle, LoginId, UserId, Username}; +use crate::domain::Username; use crate::service::login::{self, FinishLogin, StartLogin}; use axum::Router; use axum::extract::State; use axum::routing::post; -use keygo_opaque::{CredentialFinalization, CredentialRequest, DpopBinding}; -use serde::{Deserialize, Serialize}; +use keygo_api::auth::handshake::StartResponse; +use keygo_api::auth::login::{FinishRequest, FinishResponse, StartRequest}; pub fn router() -> Router { Router::new() @@ -16,13 +14,6 @@ pub fn router() -> Router { .route("/finish", post(finish)) } -#[derive(Deserialize)] -struct StartRequest { - /// Parsed in the handler so a bad name answers `invalid_username`, not `invalid_request`. - username: String, - credential_request: CredentialRequest, -} - async fn start( State(state): State, Json(request): Json, @@ -37,22 +28,6 @@ async fn start( Ok(Json(started.into())) } -#[derive(Deserialize)] -struct FinishRequest { - login_id: LoginId, - credential_finalization: CredentialFinalization, - device: DeviceClaim, - dpop_binding: DpopBinding, -} - -#[derive(Serialize)] -struct FinishResponse { - user_id: UserId, - username: Username, - key_bundle: KeyBundle, - session: Session, -} - async fn finish( State(state): State, proof: SingleUseDpopProof, @@ -80,6 +55,7 @@ async fn finish( #[cfg(test)] mod tests { use super::*; + use crate::domain::LoginId; use crate::testing::{ PASSWORD, app_state, count, device_json, key_bundle_json, post_to, post_with_proof, proof_post, prover, register, replayable_post, send, diff --git a/rust/crates/keygo-server/src/api/routes/auth/register.rs b/rust/crates/keygo-server/src/api/routes/auth/register.rs index f604a36de..8b1f69d1b 100644 --- a/rust/crates/keygo-server/src/api/routes/auth/register.rs +++ b/rust/crates/keygo-server/src/api/routes/auth/register.rs @@ -1,14 +1,12 @@ use crate::api::dpop::SingleUseDpopProof; -use crate::api::routes::auth::session::Session; use crate::api::{AppState, ErrorCode, HttpError, Json, ServerResult}; -use crate::domain::{DeviceInfo, KeyBundle, RegistrationId, UserId, Username}; +use crate::domain::Username; use crate::service::registration::{self, FinishRegistration, StartRegistration}; use axum::Router; use axum::extract::State; use axum::http::StatusCode; use axum::routing::post; -use keygo_opaque::{RegistrationRequest, RegistrationResponse, RegistrationUpload}; -use serde::{Deserialize, Serialize}; +use keygo_api::auth::register::{FinishRequest, FinishResponse, StartRequest, StartResponse}; pub fn router() -> Router { Router::new() @@ -16,22 +14,6 @@ pub fn router() -> Router { .route("/finish", post(finish)) } -#[derive(Deserialize)] -struct StartRequest { - /// Parsed in the handler so a bad name answers `invalid_username`, not `invalid_request`. - username: String, - user_id: UserId, - invite: Option, - registration_request: RegistrationRequest, -} - -#[derive(Serialize)] -struct StartResponse { - registration_id: RegistrationId, - registration_response: RegistrationResponse, - expires_in: u64, -} - impl HttpError for registration::StartError { fn code(&self) -> ErrorCode { match self { @@ -67,20 +49,6 @@ async fn start( })) } -#[derive(Deserialize)] -struct FinishRequest { - registration_id: RegistrationId, - registration_upload: RegistrationUpload, - key_bundle: KeyBundle, - device: DeviceInfo, -} - -#[derive(Serialize)] -struct FinishResponse { - username: Username, - session: Session, -} - impl HttpError for registration::FinishError { fn code(&self) -> ErrorCode { match self { @@ -120,12 +88,14 @@ async fn finish( mod tests { use super::*; use crate::api::error::render; + use crate::domain::{RegistrationId, UserId}; use crate::testing::{ WRAPPED_ARK, app_state, count, create_invite, device_json, invite_only, key_bundle_json, post, post_to, post_with_proof, proof_post, prover, register, replayable_post, send, }; use base64::Engine; use base64::engine::general_purpose::URL_SAFE_NO_PAD; + use keygo_opaque::RegistrationResponse; use keygo_opaque::client::ClientRegistration; use keygo_opaque::server::ServerSetup; use serde_json::{Value, json}; 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 abe60d5c6..849153d48 100644 --- a/rust/crates/keygo-server/src/api/routes/auth/session.rs +++ b/rust/crates/keygo-server/src/api/routes/auth/session.rs @@ -1,36 +1,19 @@ -use crate::domain::{ACCESS_TOKEN_LIFETIME, AccessToken, DeviceId, RefreshToken}; +use crate::domain::{ACCESS_TOKEN_LIFETIME, AccessToken}; use crate::service::session::Issued; -use serde::Serialize; +use keygo_api::auth::{Access, Session}; -#[derive(Serialize)] -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(), - } +pub fn access(access_token: AccessToken) -> Access { + Access { + 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, -} - impl From for Session { fn from(value: Issued) -> Self { Self { device_id: value.device_id, - access: value.access_token.into(), + access: access(value.access_token), 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 27dabe28a..a5438caec 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,13 @@ use crate::api::authenticated::{AuthError, Authenticated}; -use crate::api::routes::auth::handshake::StartResponse; -use crate::api::routes::auth::session::Access; +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}; +use keygo_api::auth::handshake::StartResponse; +use keygo_api::auth::step_up::{FinishRequest, FinishResponse, StartRequest}; impl HttpError for FinishError { fn code(&self) -> ErrorCode { @@ -33,25 +31,6 @@ pub fn router() -> Router { .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, @@ -86,7 +65,7 @@ async fn finish( step_up::finish(&state.db, &state.step_up_states, &state.token_issuer, input).await?; Ok(Json(FinishResponse { - access: finished.access_token.into(), + access: access(finished.access_token), auth_time: finished.auth_time, })) } diff --git a/rust/crates/keygo-server/src/api/routes/auth/token.rs b/rust/crates/keygo-server/src/api/routes/auth/token.rs index 0dc798253..235baec32 100644 --- a/rust/crates/keygo-server/src/api/routes/auth/token.rs +++ b/rust/crates/keygo-server/src/api/routes/auth/token.rs @@ -1,18 +1,13 @@ use crate::api::dpop::SingleUseDpopProof; -use crate::api::routes::auth::session::Session; use crate::api::{AppState, ErrorCode, HttpError, Json, ServerResult}; -use crate::domain::{RefreshToken, RevokeReason}; +use crate::domain::RevokeReason; use crate::service::session; use crate::service::session::RefreshError; use axum::Router; use axum::extract::State; use axum::routing::post; -use serde::Deserialize; - -#[derive(Deserialize)] -pub struct TokenRequest { - refresh_token: RefreshToken, -} +use keygo_api::auth::Session; +use keygo_api::auth::token::TokenRequest; impl HttpError for RefreshError { fn code(&self) -> ErrorCode { diff --git a/rust/crates/keygo-server/src/api/routes/devices.rs b/rust/crates/keygo-server/src/api/routes/devices.rs index e29733805..ebfee9f41 100644 --- a/rust/crates/keygo-server/src/api/routes/devices.rs +++ b/rust/crates/keygo-server/src/api/routes/devices.rs @@ -1,13 +1,13 @@ use crate::api::authenticated::Authenticated; use crate::api::{AppState, ErrorCode, HttpError, Json, ServerResult}; -use crate::domain::{Device, DeviceId}; +use crate::domain::DeviceId; use crate::service::device; use crate::service::device::DeleteDeviceError; use axum::Router; use axum::extract::{Path, State}; use axum::http::StatusCode; use axum::routing::{delete, get}; -use serde::Serialize; +use keygo_api::devices::Devices; pub fn router() -> Router { Router::new() @@ -24,11 +24,6 @@ impl HttpError for DeleteDeviceError { } } -#[derive(Serialize)] -struct Devices { - devices: Vec, -} - async fn devices( State(state): State, authenticated: Authenticated, diff --git a/rust/crates/keygo-server/src/api/routes/meta.rs b/rust/crates/keygo-server/src/api/routes/meta.rs index 5b0502e33..cc35569f4 100644 --- a/rust/crates/keygo-server/src/api/routes/meta.rs +++ b/rust/crates/keygo-server/src/api/routes/meta.rs @@ -3,23 +3,16 @@ use crate::service::registration::Signup; use axum::extract::State; use axum::routing::get; use axum::{Json, Router}; -use serde::Serialize; +use keygo_api::meta::ServerInfo; pub fn router() -> Router { Router::new().route("/", get(info)) } -#[derive(Serialize)] -struct ServerInfo { - version: &'static str, - public_url: String, - allow_signups: bool, -} - /// What a client needs to know before talking to this server. async fn info(State(state): State) -> Json { Json(ServerInfo { - version: env!("CARGO_PKG_VERSION"), + version: env!("CARGO_PKG_VERSION").to_owned(), public_url: state.public_url.to_string(), allow_signups: matches!(state.signup, Signup::Open), }) From 0e68db4a1f0cd29ecf9baca6f2f1711a0c189f52 Mon Sep 17 00:00:00 2001 From: Davis Date: Mon, 9 Nov 2026 18:21:01 +0100 Subject: [PATCH 07/52] test(api): pin request and response json Co-Authored-By: Claude Opus 5.5 --- CLAUDE.md | 1 + rust/crates/keygo-api/tests/wire.rs | 376 ++++++++++++++++++++++++++++ 2 files changed, 377 insertions(+) create mode 100644 rust/crates/keygo-api/tests/wire.rs diff --git a/CLAUDE.md b/CLAUDE.md index 8c72c8f34..0d7fe96f9 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -65,6 +65,7 @@ Rust workspace (`rust/`, toolchain pinned in `rust-toolchain.toml`, edition 2024 | Crate | Purpose | |-----------------|-------------------------------------------------------------------------------| | `keygo-core` | Key hierarchy, ids, `Sealed`, shared by client and server. Crypto sits behind the `crypto` feature; the server must leave it off, so it can store wrapped keys but never hold one | +| `keygo-api` | Sync API wire types (requests, responses, ids, tokens, `ErrorCode`) and the endpoint table, shared by server and client; no HTTP stack. JSON shapes are wire identity, pinned by `tests/wire.rs` | | `keygo-client` | App-only: ARK session, passkeys, TOTP, backup format, card formatting. The server must not depend on it. `keygo_client::crypto` re-exports `keygo-core` | | `keygo-uniffi` | UniFFI bindings exposing `keygo-client` to Kotlin (`libkeygo_bindings.so`) | | `keygo-opaque` | OPAQUE (opaque-ke, ristretto255 + Argon2) client/server wrapper, `forbid(unsafe_code)` | diff --git a/rust/crates/keygo-api/tests/wire.rs b/rust/crates/keygo-api/tests/wire.rs new file mode 100644 index 000000000..0cac81c0f --- /dev/null +++ b/rust/crates/keygo-api/tests/wire.rs @@ -0,0 +1,376 @@ +//! Wire identity: every JSON shape the API exchanges, written out by hand. +//! A failure here means a field name or shape changed, which breaks deployed clients. + +use keygo_api::auth::handshake; +use keygo_api::auth::login; +use keygo_api::auth::register; +use keygo_api::auth::step_up; +use keygo_api::auth::token::TokenRequest; +use keygo_api::auth::{Access, Session}; +use keygo_api::devices::Devices; +use keygo_api::meta::ServerInfo; +use keygo_opaque::client::{ClientLogin, ClientRegistration}; +use keygo_opaque::server::{self, ServerLogin, ServerSetup}; +use keygo_opaque::{ + CredentialFinalization, CredentialRequest, CredentialResponse, DpopBinding, + RegistrationRequest, RegistrationResponse, RegistrationUpload, +}; +use serde::Serialize; +use serde::de::DeserializeOwned; +use serde_json::{Value, json}; + +const NIL: &str = "00000000-0000-0000-0000-000000000000"; +const HANDSHAKE_ID: &str = "_____________________w"; +const REFRESH: &str = "kgr___________________________________________8"; + +fn pin(value: &T, expected: Value) { + assert_eq!(serde_json::to_value(value).unwrap(), expected); + let decoded: T = serde_json::from_value(expected.clone()).unwrap(); + assert_eq!(serde_json::to_value(&decoded).unwrap(), expected); +} + +fn from(value: Value) -> T { + serde_json::from_value(value).unwrap() +} + +fn wrapped_ark() -> String { + "BwcH".repeat(20) +} + +fn device() -> Value { + json!({"name": "Pixel 9", "platform": "android", "app_version": "2.3.0"}) +} + +fn device_with(extra: (&str, Value)) -> Value { + let mut value = device(); + value[extra.0] = extra.1; + value +} + +fn key_bundle() -> Value { + json!({"wrapped_ark": wrapped_ark()}) +} + +fn session_json() -> Value { + json!({ + "device_id": NIL, + "access_token": "a.b.c", + "access_expires_in": 900, + "refresh_token": REFRESH, + "refresh_expires_in": 2592000, + }) +} + +fn sample_session() -> Session { + from(session_json()) +} + +/// One real OPAQUE registration and login, with each message kept as its base64 text. +struct Messages { + registration_request: (RegistrationRequest, String), + registration_response: (RegistrationResponse, String), + registration_upload: (RegistrationUpload, String), + credential_request: (CredentialRequest, String), + credential_response: (CredentialResponse, String), + credential_finalization: (CredentialFinalization, String), + dpop_binding: (DpopBinding, String), +} + +fn messages() -> Messages { + let password = b"correct horse battery staple"; + let setup = ServerSetup::generate(); + + let (registration, request) = ClientRegistration::start(password).unwrap(); + let registration_request = request.to_base64(); + let response = server::registration_start(&setup, request, b"account-1").unwrap(); + let registration_response = response.to_base64(); + let finish = registration.finish(password, response).unwrap(); + let registration_upload = finish.upload.to_base64(); + let file = server::registration_finish(finish.upload); + + let (client, request) = ClientLogin::start(password).unwrap(); + let credential_request = request.to_base64(); + let (server, response) = ServerLogin::start(&setup, Some(file), request, b"account-1").unwrap(); + let credential_response = response.to_base64(); + let login = client.finish(password, response).unwrap(); + let credential_finalization = login.finalization.to_base64(); + let binding = login.session_key.dpop_binding(&[0x40; 32]); + let dpop_binding = binding.to_base64(); + server.finish(login.finalization).unwrap(); + + Messages { + registration_request: ( + RegistrationRequest::from_base64(®istration_request).unwrap(), + registration_request, + ), + registration_response: ( + RegistrationResponse::from_base64(®istration_response).unwrap(), + registration_response, + ), + registration_upload: ( + RegistrationUpload::from_base64(®istration_upload).unwrap(), + registration_upload, + ), + credential_request: ( + CredentialRequest::from_base64(&credential_request).unwrap(), + credential_request, + ), + credential_response: ( + CredentialResponse::from_base64(&credential_response).unwrap(), + credential_response, + ), + credential_finalization: ( + CredentialFinalization::from_base64(&credential_finalization).unwrap(), + credential_finalization, + ), + dpop_binding: (binding, dpop_binding), + } +} + +#[test] +fn register_start_request() { + let m = messages(); + let make = |invite: Option<&str>| register::StartRequest { + username: "alice".into(), + user_id: from(json!(NIL)), + invite: invite.map(String::from), + registration_request: RegistrationRequest::from_base64(&m.registration_request.1).unwrap(), + }; + let expected = |invite: Value| { + json!({ + "username": "alice", + "user_id": NIL, + "invite": invite, + "registration_request": m.registration_request.1, + }) + }; + pin(&make(Some("code")), expected(json!("code"))); + pin(&make(None), expected(Value::Null)); +} + +#[test] +fn register_start_response() { + let m = messages(); + pin( + ®ister::StartResponse { + registration_id: from(json!(HANDSHAKE_ID)), + registration_response: m.registration_response.0, + expires_in: 300, + }, + json!({ + "registration_id": HANDSHAKE_ID, + "registration_response": m.registration_response.1, + "expires_in": 300, + }), + ); +} + +#[test] +fn register_finish_request() { + let m = messages(); + pin( + ®ister::FinishRequest { + registration_id: from(json!(HANDSHAKE_ID)), + registration_upload: m.registration_upload.0, + key_bundle: from(key_bundle()), + device: from(device()), + }, + json!({ + "registration_id": HANDSHAKE_ID, + "registration_upload": m.registration_upload.1, + "key_bundle": {"wrapped_ark": wrapped_ark()}, + "device": {"name": "Pixel 9", "platform": "android", "app_version": "2.3.0"}, + }), + ); +} + +#[test] +fn register_finish_response() { + pin( + ®ister::FinishResponse { + username: from(json!("alice")), + session: sample_session(), + }, + json!({"username": "alice", "session": session_json()}), + ); +} + +#[test] +fn login_start_request() { + let m = messages(); + pin( + &login::StartRequest { + username: "alice".into(), + credential_request: m.credential_request.0, + }, + json!({"username": "alice", "credential_request": m.credential_request.1}), + ); +} + +#[test] +fn handshake_start_response() { + let m = messages(); + pin( + &handshake::StartResponse { + login_id: from(json!(HANDSHAKE_ID)), + credential_response: m.credential_response.0, + expires_in: 60, + }, + json!({ + "login_id": HANDSHAKE_ID, + "credential_response": m.credential_response.1, + "expires_in": 60, + }), + ); +} + +fn login_finish(device_id: Option<&str>) -> (login::FinishRequest, Value) { + let m = messages(); + let claim = match device_id { + Some(id) => device_with(("device_id", json!(id))), + None => device_with(("device_id", Value::Null)), + }; + let request = login::FinishRequest { + login_id: from(json!(HANDSHAKE_ID)), + credential_finalization: m.credential_finalization.0, + device: from(claim.clone()), + dpop_binding: m.dpop_binding.0, + }; + let expected = json!({ + "login_id": HANDSHAKE_ID, + "credential_finalization": m.credential_finalization.1, + "device": claim, + "dpop_binding": m.dpop_binding.1, + }); + (request, expected) +} + +#[test] +fn login_finish_request_with_device() { + let (request, expected) = login_finish(Some(NIL)); + assert_eq!(expected["device"]["device_id"], NIL); + pin(&request, expected); +} + +#[test] +fn login_finish_request_without_device() { + let (request, expected) = login_finish(None); + assert_eq!(expected["device"]["device_id"], Value::Null); + pin(&request, expected); +} + +#[test] +fn login_finish_response() { + pin( + &login::FinishResponse { + user_id: from(json!(NIL)), + username: from(json!("alice")), + key_bundle: from(key_bundle()), + session: sample_session(), + }, + json!({ + "user_id": NIL, + "username": "alice", + "key_bundle": {"wrapped_ark": wrapped_ark()}, + "session": session_json(), + }), + ); +} + +#[test] +fn step_up_start_request() { + let m = messages(); + pin( + &step_up::StartRequest { + credential_request: m.credential_request.0, + }, + json!({"credential_request": m.credential_request.1}), + ); +} + +#[test] +fn step_up_finish_request() { + let m = messages(); + pin( + &step_up::FinishRequest { + login_id: from(json!(HANDSHAKE_ID)), + credential_finalization: m.credential_finalization.0, + dpop_binding: m.dpop_binding.0, + }, + json!({ + "login_id": HANDSHAKE_ID, + "credential_finalization": m.credential_finalization.1, + "dpop_binding": m.dpop_binding.1, + }), + ); +} + +#[test] +fn step_up_finish_response() { + pin( + &step_up::FinishResponse { + access: Access { + access_token: from(json!("a.b.c")), + access_expires_in: 900, + }, + auth_time: 1_700_000_000, + }, + json!({"access_token": "a.b.c", "access_expires_in": 900, "auth_time": 1_700_000_000u64}), + ); +} + +#[test] +fn token_request() { + pin( + &TokenRequest { + refresh_token: from(json!(REFRESH)), + }, + json!({"refresh_token": REFRESH}), + ); +} + +#[test] +fn session() { + pin(&sample_session(), session_json()); +} + +#[test] +fn devices() { + let listed = json!({ + "devices": [ + { + "id": NIL, + "name": "Pixel 9", + "platform": "android", + "app_version": "2.3.0", + "created_at": 1_600_000_000u64, + "last_seen_at": 1_700_000_000u64, + "auth_time": 1_700_000_100u64, + "logged_in": true, + }, + { + "id": NIL, + "name": "Pixel 9", + "platform": "android", + "app_version": "2.3.0", + "created_at": 1_600_000_000u64, + "last_seen_at": 1_700_000_000u64, + "auth_time": null, + "logged_in": false, + }, + ], + }); + pin(&from::(listed.clone()), listed); +} + +#[test] +fn server_info() { + pin( + &ServerInfo { + version: "0.1.0".into(), + public_url: "https://keygo.example".into(), + allow_signups: true, + }, + json!({"version": "0.1.0", "public_url": "https://keygo.example", "allow_signups": true}), + ); +} From aac738e3ca26a19e42484d1dc57b3b4efae45fdb Mon Sep 17 00:00:00 2001 From: Davis Date: Mon, 9 Nov 2026 18:29:18 +0100 Subject: [PATCH 08/52] feat(client): add SyncClient over Transport, DpopKey and TokenStore Co-Authored-By: Claude Opus 5.5 --- .github/workflows/ci.yaml | 6 + rust/Cargo.lock | 3 + rust/crates/keygo-client/Cargo.toml | 9 + rust/crates/keygo-client/src/lib.rs | 1 + rust/crates/keygo-client/src/sync/client.rs | 212 ++++++++++++++++++ rust/crates/keygo-client/src/sync/error.rs | 70 ++++++ rust/crates/keygo-client/src/sync/mod.rs | 19 ++ rust/crates/keygo-client/src/sync/pipeline.rs | 107 +++++++++ rust/crates/keygo-client/src/sync/signer.rs | 47 ++++ rust/crates/keygo-client/src/sync/state.rs | 20 ++ rust/crates/keygo-client/src/sync/testing.rs | 180 +++++++++++++++ rust/crates/keygo-client/src/sync/tokens.rs | 23 ++ .../crates/keygo-client/src/sync/transport.rs | 36 +++ rust/crates/keygo-dpop/src/lib.rs | 1 + rust/crates/keygo-dpop/src/testing.rs | 15 ++ 15 files changed, 749 insertions(+) create mode 100644 rust/crates/keygo-client/src/sync/client.rs create mode 100644 rust/crates/keygo-client/src/sync/error.rs create mode 100644 rust/crates/keygo-client/src/sync/mod.rs create mode 100644 rust/crates/keygo-client/src/sync/pipeline.rs create mode 100644 rust/crates/keygo-client/src/sync/signer.rs create mode 100644 rust/crates/keygo-client/src/sync/state.rs create mode 100644 rust/crates/keygo-client/src/sync/testing.rs create mode 100644 rust/crates/keygo-client/src/sync/tokens.rs create mode 100644 rust/crates/keygo-client/src/sync/transport.rs diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml index f1e7007e3..0f13050f0 100644 --- a/.github/workflows/ci.yaml +++ b/.github/workflows/ci.yaml @@ -72,6 +72,12 @@ jobs: grep -q 'keygo-core feature "crypto"' <<<"$client" server=$(cargo tree -p keygo-server -e features) if grep -E 'keygo-client|keygo-core feature "crypto"' <<<"$server"; then exit 1; fi + - name: keygo-client cannot mint server ids or tokens + run: | + server=$(cargo tree -p keygo-server -e features) + grep -q 'keygo-api feature "server"' <<<"$server" + client=$(cargo tree -p keygo-client -e features) + if grep 'keygo-api feature "server"' <<<"$client"; then exit 1; fi # Rust-native tests (no NDK). Runs in parallel with android-test once lint passes. rust-test: diff --git a/rust/Cargo.lock b/rust/Cargo.lock index e73345a2b..bb4686eb5 100644 --- a/rust/Cargo.lock +++ b/rust/Cargo.lock @@ -1622,7 +1622,10 @@ dependencies = [ "coset", "csv", "email_address", + "keygo-api", "keygo-core", + "keygo-dpop", + "keygo-opaque", "passkey", "passkey-authenticator", "passkey-types", diff --git a/rust/crates/keygo-client/Cargo.toml b/rust/crates/keygo-client/Cargo.toml index 0e20912d1..dc0d1a2ad 100644 --- a/rust/crates/keygo-client/Cargo.toml +++ b/rust/crates/keygo-client/Cargo.toml @@ -3,8 +3,15 @@ name = "keygo-client" version.workspace = true edition.workspace = true +[features] +# Exposes `sync::testing` (fake transport, token store, key and clock) to other crates' tests. +test-support = ["keygo-dpop/test-support"] + [dependencies] keygo-core = { path = "../keygo-core", features = ["crypto"] } +keygo-api = { path = "../keygo-api" } +keygo-opaque = { path = "../keygo-opaque" } +keygo-dpop = { path = "../keygo-dpop" } thiserror.workspace = true uuid.workspace = true @@ -26,6 +33,8 @@ email_address = "0.2.9" subtle = "2.6" totp-rs = { version = "6.0.0", features = ["otpauth", "zeroize"] } url = "2.5.8" +tokio = { workspace = true, features = ["sync"] } [dev-dependencies] +keygo-dpop = { path = "../keygo-dpop", features = ["test-support"] } tokio = { workspace = true, features = ["rt", "macros"] } diff --git a/rust/crates/keygo-client/src/lib.rs b/rust/crates/keygo-client/src/lib.rs index a8fcb9c61..d09d77257 100644 --- a/rust/crates/keygo-client/src/lib.rs +++ b/rust/crates/keygo-client/src/lib.rs @@ -6,5 +6,6 @@ pub mod backup; pub mod card; pub use keygo_core as crypto; pub mod passkey; +pub mod sync; pub mod totp; mod url; diff --git a/rust/crates/keygo-client/src/sync/client.rs b/rust/crates/keygo-client/src/sync/client.rs new file mode 100644 index 000000000..15c8572a9 --- /dev/null +++ b/rust/crates/keygo-client/src/sync/client.rs @@ -0,0 +1,212 @@ +use super::error::SyncResult; +use super::signer::{DpopKey, ForeignSigner}; +use super::state::{AuthState, Clock, SystemClock}; +use super::tokens::TokenStore; +use super::transport::Transport; +use keygo_api::endpoints::Meta; +use keygo_api::meta::ServerInfo; +use keygo_dpop::DpopProver; +use std::sync::Arc; +use tokio::sync::Mutex; +use url::Url; + +// The proof, token, clock and auth state are used by the authenticated paths added later. +#[allow(dead_code)] +pub struct SyncClient { + pub(super) base_url: Url, + pub(super) transport: Arc, + pub(super) prover: DpopProver, + pub(super) tokens: Arc, + pub(super) clock: Arc, + pub(super) auth: Mutex, +} + +impl SyncClient { + pub fn new( + base_url: Url, + transport: Arc, + key: Arc, + tokens: Arc, + ) -> SyncResult { + Ok(Self { + base_url, + transport, + prover: DpopProver::new(ForeignSigner::new(key)?), + tokens, + clock: Arc::new(SystemClock), + auth: Mutex::new(AuthState::default()), + }) + } + + #[cfg(any(test, feature = "test-support"))] + pub fn with_clock(mut self, clock: Arc) -> Self { + self.clock = clock; + self + } + + pub async fn meta(&self) -> SyncResult { + self.call(&Meta, &()).await + } +} + +#[cfg(test)] +mod tests { + use super::super::error::SyncError; + use super::super::signer::SignError; + use super::super::testing::{FakeDpopKey, FakeTokenStore, FakeTransport}; + use super::*; + + const INFO: &str = r#"{"version":"1","public_url":"https://kg.example","allow_signups":true}"#; + + fn client() -> (SyncClient, Arc) { + let transport = FakeTransport::new(); + let client = SyncClient::new( + Url::parse("https://kg.example").unwrap(), + transport.clone(), + Arc::new(FakeDpopKey::new()), + Arc::new(FakeTokenStore::new()), + ) + .unwrap(); + (client, transport) + } + + fn header<'a>(request: &'a super::super::HttpRequest, name: &str) -> Option<&'a str> { + request + .headers + .iter() + .find(|h| h.name == name) + .map(|h| h.value.as_str()) + } + + #[tokio::test] + async fn none_auth_sends_no_proof_or_token() { + let (client, transport) = client(); + transport.push(200, &[], INFO.as_bytes()); + + client.meta().await.unwrap(); + + let requests = transport.requests(); + assert_eq!(requests.len(), 1); + assert_eq!(header(&requests[0], "dpop"), None); + assert_eq!(header(&requests[0], "authorization"), None); + assert_eq!(requests[0].method, keygo_api::Method::Get); + assert_eq!(requests[0].url, "https://kg.example/api/v1/meta"); + } + + #[tokio::test] + async fn unit_request_has_no_body_or_content_type() { + let (client, transport) = client(); + transport.push(200, &[], INFO.as_bytes()); + + client.meta().await.unwrap(); + + let request = &transport.requests()[0]; + assert!(request.body.is_empty()); + assert_eq!(header(request, "content-type"), None); + } + + #[tokio::test] + async fn error_codes_map_to_sync_errors() { + for (code, expected) in [ + ("invalid_credentials", SyncError::InvalidCredentials), + ("invalid_username", SyncError::InvalidUsername), + ("username_taken", SyncError::UsernameTaken), + ("invite_required", SyncError::InviteRequired), + ("invite_invalid", SyncError::InviteInvalid), + ("fresh_auth_required", SyncError::FreshAuthRequired), + ("rate_limited", SyncError::RateLimited), + ] { + let (client, transport) = client(); + let body = format!(r#"{{"code":"{code}","message":"m"}}"#); + transport.push(400, &[], body.as_bytes()); + + assert_eq!(client.meta().await.unwrap_err(), expected, "{code}"); + } + } + + #[tokio::test] + async fn rate_limited_is_not_retried() { + let (client, transport) = client(); + transport.push( + 429, + &[], + br#"{"code":"rate_limited","message":"slow down"}"#, + ); + + assert_eq!(client.meta().await.unwrap_err(), SyncError::RateLimited); + assert_eq!(transport.requests().len(), 1); + } + + #[tokio::test] + async fn unknown_code_is_a_server_error() { + let (client, transport) = client(); + transport.push(400, &[], br#"{"code":"brand_new","message":"m"}"#); + + assert_eq!( + client.meta().await.unwrap_err(), + SyncError::Server { + code: "unknown".into(), + message: "m".into(), + }, + ); + } + + #[tokio::test] + async fn html_200_is_an_invalid_response() { + let (client, transport) = client(); + transport.push(200, &[], b""); + + assert!(matches!( + client.meta().await.unwrap_err(), + SyncError::Server { code, .. } if code == "invalid_response", + )); + } + + #[tokio::test] + async fn html_502_is_a_server_error() { + let (client, transport) = client(); + transport.push(502, &[], b""); + + assert!(matches!( + client.meta().await.unwrap_err(), + SyncError::Server { code, .. } if code == "http_502", + )); + } + + #[tokio::test] + async fn transport_failure_is_network() { + let (client, transport) = client(); + transport.push_network_error("offline"); + + assert_eq!( + client.meta().await.unwrap_err(), + SyncError::Network { + message: "offline".into(), + }, + ); + } + + struct ShortKey; + + impl DpopKey for ShortKey { + fn public_key(&self) -> Vec { + vec![1, 2, 3] + } + + fn sign(&self, _: Vec) -> Result, SignError> { + unreachable!() + } + } + + #[test] + fn bad_public_key_is_rejected_at_construction() { + let result = SyncClient::new( + Url::parse("https://kg.example").unwrap(), + FakeTransport::new(), + Arc::new(ShortKey), + Arc::new(FakeTokenStore::new()), + ); + + assert!(matches!(result, Err(SyncError::Client { .. }))); + } +} diff --git a/rust/crates/keygo-client/src/sync/error.rs b/rust/crates/keygo-client/src/sync/error.rs new file mode 100644 index 000000000..476596749 --- /dev/null +++ b/rust/crates/keygo-client/src/sync/error.rs @@ -0,0 +1,70 @@ +use keygo_api::domain::RevokeReason; +use keygo_api::{ApiError, ErrorCode}; + +pub type SyncResult = Result; + +#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)] +pub enum SyncError { + #[error("invalid credentials")] + InvalidCredentials, + #[error("invalid username")] + InvalidUsername, + #[error("username taken")] + UsernameTaken, + #[error("invite required")] + InviteRequired, + #[error("invite invalid")] + InviteInvalid, + #[error("fresh authentication required")] + FreshAuthRequired, + #[error("signed out")] + SignedOut { reason: Option }, + #[error("rate limited")] + RateLimited, + #[error("network error: {message}")] + Network { message: String }, + #[error("server error {code}: {message}")] + Server { code: String, message: String }, + #[error("client error: {message}")] + Client { message: String }, +} + +impl SyncError { + pub(super) fn invalid_response(message: impl Into) -> Self { + Self::Server { + code: "invalid_response".into(), + message: message.into(), + } + } +} + +/// Maps a non-2xx response. `session_revoked` and `refresh_expired` are handled by the refresh path. +pub(super) fn from_response(status: u16, body: &[u8]) -> SyncError { + let Ok(error) = serde_json::from_slice::(body) else { + return SyncError::Server { + code: format!("http_{status}"), + message: String::from_utf8_lossy(body).chars().take(200).collect(), + }; + }; + + match error.code { + ErrorCode::InvalidCredentials => SyncError::InvalidCredentials, + ErrorCode::InvalidUsername => SyncError::InvalidUsername, + ErrorCode::UsernameTaken => SyncError::UsernameTaken, + ErrorCode::InviteRequired => SyncError::InviteRequired, + ErrorCode::InviteInvalid => SyncError::InviteInvalid, + ErrorCode::FreshAuthRequired => SyncError::FreshAuthRequired, + ErrorCode::RateLimited => SyncError::RateLimited, + code => SyncError::Server { + code: wire_name(code), + message: error.message, + }, + } +} + +fn wire_name(code: ErrorCode) -> String { + serde_json::to_value(code) + .ok() + .and_then(|v| v.as_str().map(str::to_owned)) + .unwrap_or_else(|| "unknown".into()) +} diff --git a/rust/crates/keygo-client/src/sync/mod.rs b/rust/crates/keygo-client/src/sync/mod.rs new file mode 100644 index 000000000..51bbbfb84 --- /dev/null +++ b/rust/crates/keygo-client/src/sync/mod.rs @@ -0,0 +1,19 @@ +//! The sync client: the auth protocol over three host-supplied traits +//! ([`Transport`], [`DpopKey`], [`TokenStore`]). No HTTP stack lives here. + +mod client; +mod error; +mod pipeline; +mod signer; +mod state; +#[cfg(any(test, feature = "test-support"))] +pub mod testing; +mod tokens; +mod transport; + +pub use client::SyncClient; +pub use error::{SyncError, SyncResult}; +pub use signer::{DpopKey, ForeignSigner, SignError}; +pub use state::{Clock, SystemClock}; +pub use tokens::{StoredSession, TokenStore, TokenStoreError}; +pub use transport::{Header, HttpRequest, HttpResponse, Transport, TransportError}; diff --git a/rust/crates/keygo-client/src/sync/pipeline.rs b/rust/crates/keygo-client/src/sync/pipeline.rs new file mode 100644 index 000000000..cbb8ef42b --- /dev/null +++ b/rust/crates/keygo-client/src/sync/pipeline.rs @@ -0,0 +1,107 @@ +use super::client::SyncClient; +use super::error::{SyncError, SyncResult, from_response}; +use super::transport::{Header, HttpRequest, HttpResponse}; +use keygo_api::{Auth, Endpoint}; +use serde::Serialize; +use serde::de::DeserializeOwned; + +/// A serialized `null` (the `()` body) is sent as no body at all. +fn encode_body(value: &T) -> SyncResult>> { + let json = serde_json::to_value(value).map_err(|e| SyncError::Client { + message: format!("request does not serialize: {e}"), + })?; + if json.is_null() { + return Ok(None); + } + serde_json::to_vec(&json) + .map(Some) + .map_err(|e| SyncError::Client { + message: format!("request does not serialize: {e}"), + }) +} + +/// An empty body decodes as `null`, so `()` accepts a 204. +fn decode_body(body: &[u8]) -> SyncResult { + let body = if body.is_empty() { + b"null".as_slice() + } else { + body + }; + serde_json::from_slice(body).map_err(|e| SyncError::invalid_response(e.to_string())) +} + +impl SyncClient { + pub(super) async fn exchange(&self, request: HttpRequest) -> SyncResult { + self.transport + .send(request) + .await + .map_err(|e| SyncError::Network { message: e.message }) + } + + pub(super) async fn call( + &self, + endpoint: &E, + body: &E::Request, + ) -> SyncResult { + match E::AUTH { + Auth::None => {} + // Replaced by the DPoP proof and access token paths in later tasks; never send these bare. + Auth::Proof | Auth::AccessToken => { + return Err(SyncError::Client { + message: "authenticated calls are not supported yet".into(), + }); + } + } + + let url = format!( + "{}{}", + self.base_url.as_str().trim_end_matches('/'), + endpoint.path(), + ); + let mut headers = Vec::new(); + let body = match encode_body(body)? { + Some(bytes) => { + headers.push(Header { + name: "content-type".into(), + value: "application/json".into(), + }); + bytes + } + None => Vec::new(), + }; + + let response = self + .exchange(HttpRequest { + method: E::METHOD, + url, + headers, + body, + }) + .await?; + + if (200..300).contains(&response.status) { + decode_body(&response.body) + } else { + Err(from_response(response.status, &response.body)) + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use keygo_api::meta::ServerInfo; + + #[test] + fn empty_body_decodes_as_unit() { + assert_eq!(decode_body::<()>(b""), Ok(())); + } + + #[test] + fn empty_body_is_not_a_struct() { + assert!(matches!( + decode_body::(b""), + Err(SyncError::Server { code, .. }) if code == "invalid_response", + )); + } +} diff --git a/rust/crates/keygo-client/src/sync/signer.rs b/rust/crates/keygo-client/src/sync/signer.rs new file mode 100644 index 000000000..3747734b1 --- /dev/null +++ b/rust/crates/keygo-client/src/sync/signer.rs @@ -0,0 +1,47 @@ +use super::error::{SyncError, SyncResult}; +use keygo_dpop::{DpopSigner, Signature, VerifyingKey}; +use std::sync::Arc; + +#[derive(Debug, thiserror::Error)] +#[error("{message}")] +pub struct SignError { + pub message: String, +} + +/// A hardware-backed P-256 key held by the host. +pub trait DpopKey: Send + Sync { + /// The 65-byte uncompressed P-256 point. + fn public_key(&self) -> Vec; + /// SHA256withECDSA over `message`, DER encoded. + fn sign(&self, message: Vec) -> Result, SignError>; +} + +pub struct ForeignSigner { + key: Arc, + verifying: VerifyingKey, +} + +impl ForeignSigner { + pub fn new(key: Arc) -> SyncResult { + let verifying = + VerifyingKey::from_sec1_bytes(&key.public_key()).map_err(|_| SyncError::Client { + message: "the DPoP public key is not a P-256 point".into(), + })?; + Ok(Self { key, verifying }) + } +} + +impl DpopSigner for ForeignSigner { + type Error = SignError; + + fn verifying_key(&self) -> &VerifyingKey { + &self.verifying + } + + fn sign(&self, msg: &[u8]) -> Result { + let der = self.key.sign(msg.to_vec())?; + Signature::from_der(&der).map_err(|_| SignError { + message: "the DPoP signature is not DER".into(), + }) + } +} diff --git a/rust/crates/keygo-client/src/sync/state.rs b/rust/crates/keygo-client/src/sync/state.rs new file mode 100644 index 000000000..8688f9cbc --- /dev/null +++ b/rust/crates/keygo-client/src/sync/state.rs @@ -0,0 +1,20 @@ +use std::time::{SystemTime, UNIX_EPOCH}; + +/// What the client remembers between calls. Later tasks add the nonce and the access token. +#[derive(Default)] +pub(super) struct AuthState {} + +pub trait Clock: Send + Sync { + fn now_secs(&self) -> u64; +} + +pub struct SystemClock; + +impl Clock for SystemClock { + fn now_secs(&self) -> u64 { + SystemTime::now() + .duration_since(UNIX_EPOCH) + .map(|d| d.as_secs()) + .unwrap_or(0) + } +} diff --git a/rust/crates/keygo-client/src/sync/testing.rs b/rust/crates/keygo-client/src/sync/testing.rs new file mode 100644 index 000000000..5a1b983a5 --- /dev/null +++ b/rust/crates/keygo-client/src/sync/testing.rs @@ -0,0 +1,180 @@ +//! Fakes for the three host traits and the clock. + +use super::signer::{DpopKey, SignError}; +use super::state::Clock; +use super::tokens::{StoredSession, TokenStore, TokenStoreError}; +use super::transport::{Header, HttpRequest, HttpResponse, Transport, TransportError}; +use async_trait::async_trait; +use keygo_dpop::testing::TestSigner; +use std::collections::VecDeque; +use std::sync::atomic::{AtomicBool, AtomicU64, Ordering}; +use std::sync::{Arc, Mutex}; + +/// Answers from a script and records what it was sent. +pub struct FakeTransport { + script: Mutex>>, + requests: Mutex>, +} + +impl FakeTransport { + pub fn new() -> Arc { + Arc::new(Self { + script: Mutex::default(), + requests: Mutex::default(), + }) + } + + pub fn push(&self, status: u16, headers: &[(&str, &str)], body: &[u8]) { + self.script.lock().unwrap().push_back(Ok(HttpResponse { + status, + headers: headers + .iter() + .map(|(name, value)| Header { + name: (*name).into(), + value: (*value).into(), + }) + .collect(), + body: body.to_vec(), + })); + } + + pub fn push_network_error(&self, message: &str) { + self.script.lock().unwrap().push_back(Err(TransportError { + message: message.into(), + })); + } + + pub fn requests(&self) -> Vec { + self.requests.lock().unwrap().clone() + } +} + +#[async_trait] +impl Transport for FakeTransport { + async fn send(&self, request: HttpRequest) -> Result { + // Lets concurrent tests really interleave. + tokio::task::yield_now().await; + self.requests.lock().unwrap().push(request); + self.script + .lock() + .unwrap() + .pop_front() + .expect("FakeTransport script is empty") + } +} + +/// Keeps the session in memory. `RefreshToken` is not `Clone`, so it is stored encoded. +pub struct FakeTokenStore { + stored: Mutex>, + fail_saves: AtomicBool, +} + +impl FakeTokenStore { + pub fn new() -> Self { + Self { + stored: Mutex::new(None), + fail_saves: AtomicBool::new(false), + } + } + + pub fn seed(&self, session: StoredSession) { + *self.stored.lock().unwrap() = Some(encode(&session)); + } + + /// The stored refresh token in its encoded form. + pub fn current_refresh_token(&self) -> Option { + self.stored.lock().unwrap().as_ref().map(|s| s.1.clone()) + } + + pub fn fail_saves(&self) { + self.fail_saves.store(true, Ordering::SeqCst); + } +} + +impl Default for FakeTokenStore { + fn default() -> Self { + Self::new() + } +} + +fn encode(session: &StoredSession) -> (keygo_core::DeviceId, String, u64) { + ( + session.device_id, + session.refresh_token.expose_encoded().to_string(), + session.refresh_expires_at, + ) +} + +#[async_trait] +impl TokenStore for FakeTokenStore { + async fn load(&self) -> Result, TokenStoreError> { + Ok(self + .stored + .lock() + .unwrap() + .as_ref() + .map(|(id, token, exp)| StoredSession { + device_id: *id, + refresh_token: token.parse().expect("stored token is valid"), + refresh_expires_at: *exp, + })) + } + + async fn save(&self, session: StoredSession) -> Result<(), TokenStoreError> { + if self.fail_saves.load(Ordering::SeqCst) { + return Err(TokenStoreError { + message: "save failed".into(), + }); + } + *self.stored.lock().unwrap() = Some(encode(&session)); + Ok(()) + } + + async fn clear(&self) -> Result<(), TokenStoreError> { + *self.stored.lock().unwrap() = None; + Ok(()) + } +} + +/// The same key as [`TestSigner::new`]. +pub struct FakeDpopKey(TestSigner); + +impl FakeDpopKey { + pub fn new() -> Self { + Self(TestSigner::new()) + } +} + +impl Default for FakeDpopKey { + fn default() -> Self { + Self::new() + } +} + +impl DpopKey for FakeDpopKey { + fn public_key(&self) -> Vec { + self.0.public_key_sec1() + } + + fn sign(&self, message: Vec) -> Result, SignError> { + Ok(self.0.sign_der(&message)) + } +} + +pub struct FixedClock(AtomicU64); + +impl FixedClock { + pub fn new(now_secs: u64) -> Arc { + Arc::new(Self(AtomicU64::new(now_secs))) + } + + pub fn advance(&self, secs: u64) { + self.0.fetch_add(secs, Ordering::SeqCst); + } +} + +impl Clock for FixedClock { + fn now_secs(&self) -> u64 { + self.0.load(Ordering::SeqCst) + } +} diff --git a/rust/crates/keygo-client/src/sync/tokens.rs b/rust/crates/keygo-client/src/sync/tokens.rs new file mode 100644 index 000000000..02b0bf32c --- /dev/null +++ b/rust/crates/keygo-client/src/sync/tokens.rs @@ -0,0 +1,23 @@ +use async_trait::async_trait; +use keygo_api::domain::RefreshToken; +use keygo_core::DeviceId; + +pub struct StoredSession { + pub device_id: DeviceId, + pub refresh_token: RefreshToken, + pub refresh_expires_at: u64, +} + +#[derive(Debug, thiserror::Error)] +#[error("{message}")] +pub struct TokenStoreError { + pub message: String, +} + +/// Durable home of the refresh token. The host decides how it is protected. +#[async_trait] +pub trait TokenStore: Send + Sync { + async fn load(&self) -> Result, TokenStoreError>; + async fn save(&self, session: StoredSession) -> Result<(), TokenStoreError>; + async fn clear(&self) -> Result<(), TokenStoreError>; +} diff --git a/rust/crates/keygo-client/src/sync/transport.rs b/rust/crates/keygo-client/src/sync/transport.rs new file mode 100644 index 000000000..257193896 --- /dev/null +++ b/rust/crates/keygo-client/src/sync/transport.rs @@ -0,0 +1,36 @@ +use async_trait::async_trait; +use keygo_api::Method; + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct Header { + pub name: String, + pub value: String, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct HttpRequest { + pub method: Method, + pub url: String, + pub headers: Vec
, + pub body: Vec, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct HttpResponse { + pub status: u16, + pub headers: Vec
, + pub body: Vec, +} + +#[derive(Debug, thiserror::Error)] +#[error("{message}")] +pub struct TransportError { + pub message: String, +} + +/// Sends one HTTP request. The host owns TLS, timeouts and connection pooling; +/// it must not retry, follow auth challenges or log bodies. +#[async_trait] +pub trait Transport: Send + Sync { + async fn send(&self, request: HttpRequest) -> Result; +} diff --git a/rust/crates/keygo-dpop/src/lib.rs b/rust/crates/keygo-dpop/src/lib.rs index 4d05bb6ce..483eef9f3 100644 --- a/rust/crates/keygo-dpop/src/lib.rs +++ b/rust/crates/keygo-dpop/src/lib.rs @@ -12,6 +12,7 @@ use std::time::{SystemTime, UNIX_EPOCH}; pub use jwk::JwkError; pub use nonce::Nonce; +pub use p256::ecdsa::{Signature, VerifyingKey}; pub use proof::{DpopError, DpopProver, DpopSigner, ProofRequest}; pub use verify::{Bound, Checked, DpopVerifier, Expected, InvalidProof, VerifyError}; pub use wire::{DecodeError, Htm}; diff --git a/rust/crates/keygo-dpop/src/testing.rs b/rust/crates/keygo-dpop/src/testing.rs index 543e11f05..a5fa38967 100644 --- a/rust/crates/keygo-dpop/src/testing.rs +++ b/rust/crates/keygo-dpop/src/testing.rs @@ -13,6 +13,21 @@ impl TestSigner { pub fn from_seed(seed: u8) -> Self { Self(SigningKey::from_slice(&[seed; 32]).unwrap()) } + + /// The 65-byte uncompressed SEC1 point, as a platform keystore exports it. + pub fn public_key_sec1(&self) -> Vec { + self.0 + .verifying_key() + .to_sec1_point(false) + .as_bytes() + .to_vec() + } + + /// An ASN.1 DER signature, as a platform keystore produces it. + pub fn sign_der(&self, msg: &[u8]) -> Vec { + let sig: Signature = self.0.sign(msg); + sig.to_der().as_bytes().to_vec() + } } impl Default for TestSigner { From d6dcadeb082e957e26e07c33095afc782e3439fd Mon Sep 17 00:00:00 2001 From: Davis Date: Mon, 9 Nov 2026 18:36:07 +0100 Subject: [PATCH 09/52] feat(client): sign DPoP proofs and answer nonce challenges Co-Authored-By: Claude Opus 5.5 --- rust/crates/keygo-client/src/sync/client.rs | 6 +- rust/crates/keygo-client/src/sync/pipeline.rs | 336 ++++++++++++++++-- rust/crates/keygo-client/src/sync/state.rs | 7 +- 3 files changed, 313 insertions(+), 36 deletions(-) diff --git a/rust/crates/keygo-client/src/sync/client.rs b/rust/crates/keygo-client/src/sync/client.rs index 15c8572a9..edc0225d5 100644 --- a/rust/crates/keygo-client/src/sync/client.rs +++ b/rust/crates/keygo-client/src/sync/client.rs @@ -10,13 +10,15 @@ use std::sync::Arc; use tokio::sync::Mutex; use url::Url; -// The proof, token, clock and auth state are used by the authenticated paths added later. -#[allow(dead_code)] pub struct SyncClient { pub(super) base_url: Url, pub(super) transport: Arc, pub(super) prover: DpopProver, + // Used by the access token path (Task 9). + #[allow(dead_code)] pub(super) tokens: Arc, + // Used by the access token path (Task 9). + #[allow(dead_code)] pub(super) clock: Arc, pub(super) auth: Mutex, } diff --git a/rust/crates/keygo-client/src/sync/pipeline.rs b/rust/crates/keygo-client/src/sync/pipeline.rs index cbb8ef42b..49ddf5204 100644 --- a/rust/crates/keygo-client/src/sync/pipeline.rs +++ b/rust/crates/keygo-client/src/sync/pipeline.rs @@ -1,7 +1,8 @@ use super::client::SyncClient; use super::error::{SyncError, SyncResult, from_response}; use super::transport::{Header, HttpRequest, HttpResponse}; -use keygo_api::{Auth, Endpoint}; +use keygo_api::{ApiError, Auth, Endpoint, ErrorCode, Method}; +use keygo_dpop::{Htm, ProofRequest}; use serde::Serialize; use serde::de::DeserializeOwned; @@ -30,55 +31,146 @@ fn decode_body(body: &[u8]) -> SyncResult { serde_json::from_slice(body).map_err(|e| SyncError::invalid_response(e.to_string())) } +fn proof_method(method: Method) -> Htm { + match method { + Method::Get => Htm::Get, + Method::Post => Htm::Post, + Method::Delete => Htm::Delete, + } +} + +fn header_value<'a>(response: &'a HttpResponse, name: &str) -> Option<&'a str> { + response + .headers + .iter() + .find(|h| h.name.eq_ignore_ascii_case(name)) + .map(|h| h.value.as_str()) +} + +fn is_nonce_challenge(response: &HttpResponse) -> bool { + serde_json::from_slice::(&response.body) + .is_ok_and(|error| error.code == ErrorCode::UseDpopNonce) +} + impl SyncClient { - pub(super) async fn exchange(&self, request: HttpRequest) -> SyncResult { + fn url(&self, path: &str) -> String { + format!("{}{}", self.base_url.as_str().trim_end_matches('/'), path) + } + + async fn send(&self, request: HttpRequest) -> SyncResult { self.transport .send(request) .await .map_err(|e| SyncError::Network { message: e.message }) } + /// Signs and sends one request. A `use_dpop_nonce` challenge that carries a nonce is answered + /// once with a re-signed request; a second challenge is returned as the response. Every + /// `DPoP-Nonce` header the server sends replaces `nonce`. + pub(super) async fn exchange( + &self, + method: Method, + path: &str, + access_token: Option<&str>, + body: Option<&[u8]>, + nonce: &mut Option, + ) -> SyncResult { + let url = self.url(path); + + let mut retried = false; + loop { + let proof = self + .prover + .proof(&ProofRequest { + htm: proof_method(method), + htu: &url, + access_token, + nonce: nonce.as_deref(), + }) + .map_err(|e| SyncError::Client { + message: format!("could not sign the DPoP proof: {e}"), + })?; + + let mut headers = vec![Header { + name: "dpop".into(), + value: proof, + }]; + if let Some(token) = access_token { + headers.push(Header { + name: "authorization".into(), + value: format!("DPoP {token}"), + }); + } + if body.is_some() { + headers.push(Header { + name: "content-type".into(), + value: "application/json".into(), + }); + } + + let response = self + .send(HttpRequest { + method, + url: url.clone(), + headers, + body: body.map(<[u8]>::to_vec).unwrap_or_default(), + }) + .await?; + + let fresh = header_value(&response, "dpop-nonce").map(str::to_owned); + if let Some(fresh) = &fresh { + *nonce = Some(fresh.clone()); + } + + if !retried && fresh.is_some() && is_nonce_challenge(&response) { + retried = true; + continue; + } + return Ok(response); + } + } + pub(super) async fn call( &self, endpoint: &E, body: &E::Request, ) -> SyncResult { - match E::AUTH { - Auth::None => {} - // Replaced by the DPoP proof and access token paths in later tasks; never send these bare. - Auth::Proof | Auth::AccessToken => { + let body = encode_body(body)?; + let path = endpoint.path(); + + let response = match E::AUTH { + Auth::None => { + let mut headers = Vec::new(); + if body.is_some() { + headers.push(Header { + name: "content-type".into(), + value: "application/json".into(), + }); + } + self.send(HttpRequest { + method: E::METHOD, + url: self.url(&path), + headers, + body: body.unwrap_or_default(), + }) + .await? + } + Auth::Proof => { + let mut nonce = self.auth.lock().await.nonce.clone(); + let response = self + .exchange(E::METHOD, &path, None, body.as_deref(), &mut nonce) + .await; + self.auth.lock().await.nonce = nonce; + response? + } + // Replaced by the access token path in a later task; never send this bare. + Auth::AccessToken => { return Err(SyncError::Client { message: "authenticated calls are not supported yet".into(), }); } - } - - let url = format!( - "{}{}", - self.base_url.as_str().trim_end_matches('/'), - endpoint.path(), - ); - let mut headers = Vec::new(); - let body = match encode_body(body)? { - Some(bytes) => { - headers.push(Header { - name: "content-type".into(), - value: "application/json".into(), - }); - bytes - } - None => Vec::new(), }; - let response = self - .exchange(HttpRequest { - method: E::METHOD, - url, - headers, - body, - }) - .await?; - if (200..300).contains(&response.status) { decode_body(&response.body) } else { @@ -104,4 +196,184 @@ mod tests { Err(SyncError::Server { code, .. }) if code == "invalid_response", )); } + + use super::super::client::SyncClient; + use super::super::signer::{DpopKey, SignError}; + use super::super::testing::{FakeDpopKey, FakeTokenStore, FakeTransport}; + use base64::Engine; + use base64::engine::general_purpose::URL_SAFE_NO_PAD; + use keygo_api::auth::token::TokenRequest; + use keygo_api::endpoints::Token; + use serde_json::{Value, json}; + use std::sync::Arc; + use url::Url; + + const SESSION: &str = r#"{"device_id":"00000000-0000-0000-0000-000000000001","access_token":"a.b.c","access_expires_in":300,"refresh_token":"kgr___________________________________________8","refresh_expires_in":86400}"#; + const CHALLENGE: &[u8] = br#"{"code":"use_dpop_nonce","message":"m"}"#; + + fn client_for(base: &str, key: Arc) -> (SyncClient, Arc) { + let transport = FakeTransport::new(); + let client = SyncClient::new( + Url::parse(base).unwrap(), + transport.clone(), + key, + Arc::new(FakeTokenStore::new()), + ) + .unwrap(); + (client, transport) + } + + fn client() -> (SyncClient, Arc) { + client_for("https://kg.example", Arc::new(FakeDpopKey::new())) + } + + fn token_request() -> TokenRequest { + serde_json::from_value(json!({ + "refresh_token": "kgr___________________________________________8", + })) + .unwrap() + } + + fn proof_claims(request: &HttpRequest) -> Value { + let proof = header(request, "dpop").expect("request carries a dpop header"); + let claims = proof.split('.').nth(1).unwrap(); + serde_json::from_slice(&URL_SAFE_NO_PAD.decode(claims).unwrap()).unwrap() + } + + fn header<'a>(request: &'a HttpRequest, name: &str) -> Option<&'a str> { + request + .headers + .iter() + .find(|h| h.name == name) + .map(|h| h.value.as_str()) + } + + #[tokio::test] + async fn proof_endpoint_signs_without_ath() { + let (client, transport) = client(); + transport.push(200, &[], SESSION.as_bytes()); + + client.call(&Token, &token_request()).await.ok().unwrap(); + + let request = &transport.requests()[0]; + let claims = proof_claims(request); + assert_eq!(claims["htm"], "POST"); + assert_eq!(claims["htu"], "https://kg.example/api/v1/auth/token"); + assert!(claims.get("ath").is_none()); + assert_eq!(header(request, "authorization"), None); + } + + #[tokio::test] + async fn nonce_challenge_retries_with_the_new_nonce() { + let (client, transport) = client(); + transport.push(400, &[("DPoP-Nonce", "n1")], CHALLENGE); + transport.push(200, &[], SESSION.as_bytes()); + + client.call(&Token, &token_request()).await.ok().unwrap(); + + let requests = transport.requests(); + assert_eq!(requests.len(), 2); + let (first, second) = (proof_claims(&requests[0]), proof_claims(&requests[1])); + assert!(first.get("nonce").is_none()); + assert_eq!(second["nonce"], "n1"); + assert_ne!(first["jti"], second["jti"]); + } + + #[tokio::test] + async fn second_nonce_challenge_is_returned() { + let (client, transport) = client(); + transport.push(400, &[("DPoP-Nonce", "n1")], CHALLENGE); + transport.push(400, &[("DPoP-Nonce", "n2")], CHALLENGE); + + let error = client.call(&Token, &token_request()).await.err().unwrap(); + + assert_eq!(transport.requests().len(), 2); + assert!(matches!(error, SyncError::Server { code, .. } if code == "use_dpop_nonce")); + } + + #[tokio::test] + async fn challenge_without_header_is_returned() { + let (client, transport) = client(); + transport.push(400, &[], CHALLENGE); + + let error = client.call(&Token, &token_request()).await.err().unwrap(); + + assert_eq!(transport.requests().len(), 1); + assert!(matches!(error, SyncError::Server { code, .. } if code == "use_dpop_nonce")); + } + + #[tokio::test] + async fn last_nonce_is_reused() { + let (client, transport) = client(); + transport.push(400, &[("DPoP-Nonce", "n1")], CHALLENGE); + transport.push(200, &[], SESSION.as_bytes()); + transport.push(200, &[], SESSION.as_bytes()); + + client.call(&Token, &token_request()).await.ok().unwrap(); + client.call(&Token, &token_request()).await.ok().unwrap(); + + let requests = transport.requests(); + assert_eq!(requests.len(), 3); + assert_eq!(proof_claims(&requests[2])["nonce"], "n1"); + } + + #[tokio::test] + async fn nonce_on_a_success_is_kept() { + let (client, transport) = client(); + transport.push(200, &[("DPoP-Nonce", "n1")], SESSION.as_bytes()); + transport.push(200, &[], SESSION.as_bytes()); + + client.call(&Token, &token_request()).await.ok().unwrap(); + client.call(&Token, &token_request()).await.ok().unwrap(); + + let requests = transport.requests(); + assert_eq!(requests.len(), 2); + assert_eq!(proof_claims(&requests[1])["nonce"], "n1"); + } + + #[tokio::test] + async fn trailing_slash_in_base_url_is_harmless() { + let (plain, plain_transport) = client(); + let (slashed, slashed_transport) = + client_for("https://kg.example/", Arc::new(FakeDpopKey::new())); + plain_transport.push(200, &[], SESSION.as_bytes()); + slashed_transport.push(200, &[], SESSION.as_bytes()); + + plain.call(&Token, &token_request()).await.ok().unwrap(); + slashed.call(&Token, &token_request()).await.ok().unwrap(); + + let (a, b) = ( + &plain_transport.requests()[0], + &slashed_transport.requests()[0], + ); + assert_eq!(a.url, b.url); + assert_eq!(proof_claims(a)["htu"], proof_claims(b)["htu"]); + } + + struct FailingKey(FakeDpopKey); + + impl DpopKey for FailingKey { + fn public_key(&self) -> Vec { + self.0.public_key() + } + + fn sign(&self, _: Vec) -> Result, SignError> { + Err(SignError { + message: "keystore locked".into(), + }) + } + } + + #[tokio::test] + async fn keystore_failure_is_a_client_error() { + let (client, transport) = client_for( + "https://kg.example", + Arc::new(FailingKey(FakeDpopKey::new())), + ); + + let error = client.call(&Token, &token_request()).await.err().unwrap(); + + assert!(matches!(error, SyncError::Client { .. })); + assert!(transport.requests().is_empty()); + } } diff --git a/rust/crates/keygo-client/src/sync/state.rs b/rust/crates/keygo-client/src/sync/state.rs index 8688f9cbc..365b401bd 100644 --- a/rust/crates/keygo-client/src/sync/state.rs +++ b/rust/crates/keygo-client/src/sync/state.rs @@ -1,8 +1,11 @@ use std::time::{SystemTime, UNIX_EPOCH}; -/// What the client remembers between calls. Later tasks add the nonce and the access token. +/// What the client remembers between calls. Later tasks add the access token. #[derive(Default)] -pub(super) struct AuthState {} +pub(super) struct AuthState { + /// The last `DPoP-Nonce` the server sent. + pub(super) nonce: Option, +} pub trait Clock: Send + Sync { fn now_secs(&self) -> u64; From 739cae203c549cb53020219a8a894998155c1f72 Mon Sep 17 00:00:00 2001 From: Davis Date: Mon, 9 Nov 2026 18:53:24 +0100 Subject: [PATCH 10/52] feat(client): refresh access tokens and manage devices Replace the fail-closed access token arm: a call needs a live token, and a missing or expired one is refreshed under the AuthState mutex, so concurrent callers share one refresh. An invalid_token refreshes only if the generation still matches, then retries once. The rotated refresh token is saved before the access token is kept, a session_revoked or refresh_expired from any call ends the session, and logout always clears local state. Header, HttpRequest and HttpResponse stop printing header values and bodies in their Debug output. Co-Authored-By: Claude Opus 5.5 --- rust/crates/keygo-client/src/sync/client.rs | 24 +- rust/crates/keygo-client/src/sync/error.rs | 2 +- rust/crates/keygo-client/src/sync/pipeline.rs | 631 +++++++++++++++++- rust/crates/keygo-client/src/sync/state.rs | 23 +- .../crates/keygo-client/src/sync/transport.rs | 79 ++- 5 files changed, 738 insertions(+), 21 deletions(-) diff --git a/rust/crates/keygo-client/src/sync/client.rs b/rust/crates/keygo-client/src/sync/client.rs index edc0225d5..52fdfde8b 100644 --- a/rust/crates/keygo-client/src/sync/client.rs +++ b/rust/crates/keygo-client/src/sync/client.rs @@ -3,8 +3,10 @@ use super::signer::{DpopKey, ForeignSigner}; use super::state::{AuthState, Clock, SystemClock}; use super::tokens::TokenStore; use super::transport::Transport; -use keygo_api::endpoints::Meta; +use keygo_api::domain::Device; +use keygo_api::endpoints::{DeleteDevice, ListDevices, Logout, Meta}; use keygo_api::meta::ServerInfo; +use keygo_core::DeviceId; use keygo_dpop::DpopProver; use std::sync::Arc; use tokio::sync::Mutex; @@ -14,11 +16,7 @@ pub struct SyncClient { pub(super) base_url: Url, pub(super) transport: Arc, pub(super) prover: DpopProver, - // Used by the access token path (Task 9). - #[allow(dead_code)] pub(super) tokens: Arc, - // Used by the access token path (Task 9). - #[allow(dead_code)] pub(super) clock: Arc, pub(super) auth: Mutex, } @@ -49,6 +47,22 @@ impl SyncClient { pub async fn meta(&self) -> SyncResult { self.call(&Meta, &()).await } + + pub async fn devices(&self) -> SyncResult> { + Ok(self.call(&ListDevices, &()).await?.devices) + } + + pub async fn delete_device(&self, id: DeviceId) -> SyncResult<()> { + self.call(&DeleteDevice { id }, &()).await + } + + /// Ends the session here even if the server cannot be told, and reports whether it was. + pub async fn logout(&self) -> SyncResult<()> { + let sent = self.call(&Logout, &()).await; + let mut state = self.auth.lock().await; + self.end_session(&mut state).await; + sent + } } #[cfg(test)] diff --git a/rust/crates/keygo-client/src/sync/error.rs b/rust/crates/keygo-client/src/sync/error.rs index 476596749..70f0cc9f4 100644 --- a/rust/crates/keygo-client/src/sync/error.rs +++ b/rust/crates/keygo-client/src/sync/error.rs @@ -38,7 +38,7 @@ impl SyncError { } } -/// Maps a non-2xx response. `session_revoked` and `refresh_expired` are handled by the refresh path. +/// Maps a non-2xx response. `session_revoked` and `refresh_expired` end the session before this. pub(super) fn from_response(status: u16, body: &[u8]) -> SyncError { let Ok(error) = serde_json::from_slice::(body) else { return SyncError::Server { diff --git a/rust/crates/keygo-client/src/sync/pipeline.rs b/rust/crates/keygo-client/src/sync/pipeline.rs index 49ddf5204..50d2a5d17 100644 --- a/rust/crates/keygo-client/src/sync/pipeline.rs +++ b/rust/crates/keygo-client/src/sync/pipeline.rs @@ -1,10 +1,16 @@ use super::client::SyncClient; use super::error::{SyncError, SyncResult, from_response}; +use super::state::{AccessState, AuthState}; +use super::tokens::{StoredSession, TokenStoreError}; use super::transport::{Header, HttpRequest, HttpResponse}; +use keygo_api::auth::Session; +use keygo_api::auth::token::TokenRequest; +use keygo_api::endpoints::Token; use keygo_api::{ApiError, Auth, Endpoint, ErrorCode, Method}; use keygo_dpop::{Htm, ProofRequest}; use serde::Serialize; use serde::de::DeserializeOwned; +use zeroize::Zeroizing; /// A serialized `null` (the `()` body) is sent as no body at all. fn encode_body(value: &T) -> SyncResult>> { @@ -52,6 +58,41 @@ fn is_nonce_challenge(response: &HttpResponse) -> bool { .is_ok_and(|error| error.code == ErrorCode::UseDpopNonce) } +fn is_success(response: &HttpResponse) -> bool { + (200..300).contains(&response.status) +} + +/// The error body of a failed response. A 2xx is never an error, whatever its body says. +fn api_error(response: &HttpResponse) -> Option { + if is_success(response) { + return None; + } + serde_json::from_slice(&response.body).ok() +} + +fn is_invalid_token(response: &HttpResponse) -> bool { + api_error(response).is_some_and(|error| error.code == ErrorCode::InvalidToken) +} + +/// The `SignedOut` a response means, if the server says the session is over. A reason this build +/// does not know is `None`, so a newer server still signs an older app out. +fn sign_out_error(response: &HttpResponse) -> Option { + let error = api_error(response)?; + matches!( + error.code, + ErrorCode::SessionRevoked | ErrorCode::RefreshExpired + ) + .then(|| SyncError::SignedOut { + reason: error.reason.and_then(|reason| reason.parse().ok()), + }) +} + +fn store_failure(error: TokenStoreError) -> SyncError { + SyncError::Client { + message: format!("token store failed: {error}"), + } +} + impl SyncClient { fn url(&self, path: &str) -> String { format!("{}{}", self.base_url.as_str().trim_end_matches('/'), path) @@ -130,6 +171,127 @@ impl SyncClient { } } + /// Forgets the session, in memory and in the store. The caller holds the `AuthState` lock, so + /// a refresh that is still running cannot save a token after this. + /// + /// A store that fails to clear changes nothing about what the caller is told; the stale entry + /// is cleared again the next time the server refuses it. + pub(super) async fn end_session(&self, state: &mut AuthState) { + state.reset(); + let _ = self.tokens.clear().await; + } + + /// Spends the stored refresh token on a new session and returns the new access token. `state` + /// is the locked `AuthState`, held for the whole refresh so concurrent callers share its + /// result. It goes straight to `exchange`, because `call` would take the lock again. + /// + /// The rotated token is saved before the access token is kept. Nothing is kept if that save + /// fails, or if the caller is dropped before it returns: `access` and `generation` change + /// only after the last `await`. + async fn refresh_locked(&self, state: &mut AuthState) -> SyncResult> { + let stored = self + .tokens + .load() + .await + .map_err(store_failure)? + .ok_or(SyncError::SignedOut { reason: None })?; + + let request = TokenRequest { + refresh_token: stored.refresh_token, + }; + // Not `encode_body`: this body is a secret and should not linger in a `Value`. + let body = Zeroizing::new(serde_json::to_vec(&request).map_err(|e| SyncError::Client { + message: format!("request does not serialize: {e}"), + })?); + + // Read before sending, so a token never looks like it lives longer than it does. + let now = self.clock.now_secs(); + let response = self + .exchange( + Token::METHOD, + &Token.path(), + None, + Some(body.as_slice()), + &mut state.nonce, + ) + .await?; + + if !is_success(&response) { + if let Some(signed_out) = sign_out_error(&response) { + self.end_session(state).await; + return Err(signed_out); + } + return Err(from_response(response.status, &response.body)); + } + + let body = Zeroizing::new(response.body); + let session: Session = decode_body(&body)?; + + self.tokens + .save(StoredSession { + device_id: session.device_id, + refresh_token: session.refresh_token, + refresh_expires_at: now.saturating_add(session.refresh_expires_in), + }) + .await + .map_err(store_failure)?; + + let token = Zeroizing::new(session.access.access_token.expose().to_owned()); + state.access = Some(AccessState { + token: session.access.access_token, + expires_at: now.saturating_add(session.access.access_expires_in), + }); + state.generation += 1; + Ok(token) + } + + /// A live access token, refreshed first if there is none, with the generation it belongs to + /// and the nonce to send. The lock is released on return: only a refresh holds it across the + /// network, never the request itself. + async fn access_token(&self) -> SyncResult<(Zeroizing, u64, Option)> { + let mut state = self.auth.lock().await; + let now = self.clock.now_secs(); + let live = state + .access + .as_ref() + .filter(|access| now < access.expires_at); + let token = match live { + Some(access) => Zeroizing::new(access.token.expose().to_owned()), + None => self.refresh_locked(&mut state).await?, + }; + Ok((token, state.generation, state.nonce.clone())) + } + + /// Sends one request with the access token. An `invalid_token` earns one refresh and one + /// retry; the refresh is skipped when another caller has already replaced the rejected token. + async fn authenticated( + &self, + method: Method, + path: &str, + body: Option<&[u8]>, + ) -> SyncResult { + let mut retried = false; + loop { + let (token, generation, mut nonce) = self.access_token().await?; + + let response = self + .exchange(method, path, Some(token.as_str()), body, &mut nonce) + .await; + self.auth.lock().await.nonce = nonce; + let response = response?; + + if retried || !is_invalid_token(&response) { + return Ok(response); + } + retried = true; + + let mut state = self.auth.lock().await; + if state.generation == generation { + self.refresh_locked(&mut state).await?; + } + } + } + pub(super) async fn call( &self, endpoint: &E, @@ -163,19 +325,21 @@ impl SyncClient { self.auth.lock().await.nonce = nonce; response? } - // Replaced by the access token path in a later task; never send this bare. Auth::AccessToken => { - return Err(SyncError::Client { - message: "authenticated calls are not supported yet".into(), - }); + self.authenticated(E::METHOD, &path, body.as_deref()) + .await? } }; - if (200..300).contains(&response.status) { - decode_body(&response.body) - } else { - Err(from_response(response.status, &response.body)) + if is_success(&response) { + return decode_body(&response.body); } + if let Some(signed_out) = sign_out_error(&response) { + let mut state = self.auth.lock().await; + self.end_session(&mut state).await; + return Err(signed_out); + } + Err(from_response(response.status, &response.body)) } } @@ -199,11 +363,11 @@ mod tests { use super::super::client::SyncClient; use super::super::signer::{DpopKey, SignError}; - use super::super::testing::{FakeDpopKey, FakeTokenStore, FakeTransport}; + use super::super::testing::{FakeDpopKey, FakeTokenStore, FakeTransport, FixedClock}; use base64::Engine; use base64::engine::general_purpose::URL_SAFE_NO_PAD; - use keygo_api::auth::token::TokenRequest; - use keygo_api::endpoints::Token; + use keygo_api::domain::RevokeReason; + use keygo_core::DeviceId; use serde_json::{Value, json}; use std::sync::Arc; use url::Url; @@ -376,4 +540,449 @@ mod tests { assert!(matches!(error, SyncError::Client { .. })); assert!(transport.requests().is_empty()); } + + const OLD_REFRESH: &str = "kgr___________________________________________8"; + const ROTATED_REFRESH: &str = "kgr_AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"; + const DEVICES: &[u8] = br#"{"devices":[]}"#; + /// Requests `fresh` has already spent. + const FRESH: usize = 2; + + /// A `200` from `/auth/token`. + fn session(access_token: &str) -> Vec { + serde_json::to_vec(&json!({ + "device_id": "00000000-0000-0000-0000-000000000001", + "access_token": access_token, + "access_expires_in": 600, + "refresh_token": ROTATED_REFRESH, + "refresh_expires_in": 86400, + })) + .unwrap() + } + + fn error_body(code: &str) -> Vec { + serde_json::to_vec(&json!({"code": code, "message": "m"})).unwrap() + } + + fn revoked_body(reason: &str) -> Vec { + serde_json::to_vec(&json!({ + "code": "session_revoked", + "message": "m", + "reason": reason, + })) + .unwrap() + } + + struct Harness { + client: SyncClient, + transport: Arc, + store: Arc, + clock: Arc, + } + + impl Harness { + fn token_requests(&self) -> usize { + self.transport + .requests() + .iter() + .filter(|r| r.url.ends_with("/api/v1/auth/token")) + .count() + } + + fn stored_refresh_token(&self) -> Option { + self.store.current_refresh_token() + } + + async fn assert_signed_out_locally(&self) { + let sent = self.transport.requests().len(); + + assert_eq!( + self.client.devices().await.unwrap_err(), + SyncError::SignedOut { reason: None }, + ); + assert_eq!(self.transport.requests().len(), sent); + assert_eq!(self.stored_refresh_token(), None); + } + } + + fn unseeded() -> Harness { + let transport = FakeTransport::new(); + let store = Arc::new(FakeTokenStore::new()); + let clock = FixedClock::new(1_000); + let client = SyncClient::new( + Url::parse("https://kg.example").unwrap(), + transport.clone(), + Arc::new(FakeDpopKey::new()), + store.clone(), + ) + .unwrap() + .with_clock(clock.clone()); + Harness { + client, + transport, + store, + clock, + } + } + + fn seeded() -> Harness { + let harness = unseeded(); + harness.store.seed(StoredSession { + device_id: DeviceId::random(), + refresh_token: OLD_REFRESH.parse().unwrap(), + refresh_expires_at: 1_000_000, + }); + harness + } + + /// Holds a live access token: one refresh and one `devices()` have run. + async fn fresh() -> Harness { + let harness = seeded(); + harness.transport.push(200, &[], &session("a.b.c")); + harness.transport.push(200, &[], DEVICES); + harness.client.devices().await.unwrap(); + harness + } + + #[tokio::test] + async fn no_stored_session_signs_out_without_sending() { + let h = unseeded(); + + assert_eq!( + h.client.devices().await.unwrap_err(), + SyncError::SignedOut { reason: None }, + ); + assert!(h.transport.requests().is_empty()); + } + + #[tokio::test] + async fn access_token_sends_token_and_bound_proof() { + let h = seeded(); + h.transport.push(200, &[], &session("a.b.c")); + h.transport.push(200, &[], DEVICES); + + h.client.devices().await.unwrap(); + + let request = &h.transport.requests()[1]; + assert_eq!(header(request, "authorization"), Some("DPoP a.b.c")); + let claims = proof_claims(request); + assert_eq!(claims["htm"], "GET"); + assert_eq!(claims["htu"], "https://kg.example/api/v1/devices"); + assert!(claims["ath"].is_string()); + } + + #[tokio::test] + async fn refresh_carries_its_token_in_the_body_only() { + let h = fresh().await; + + let request = &h.transport.requests()[0]; + assert_eq!(request.url, "https://kg.example/api/v1/auth/token"); + assert_eq!(header(request, "authorization"), None); + assert!(proof_claims(request).get("ath").is_none()); + let body: Value = serde_json::from_slice(&request.body).unwrap(); + assert_eq!(body, json!({"refresh_token": OLD_REFRESH})); + } + + #[tokio::test] + async fn rotated_refresh_token_is_saved_and_spent_next() { + let h = fresh().await; + assert_eq!(h.stored_refresh_token().as_deref(), Some(ROTATED_REFRESH)); + + h.clock.advance(601); + h.transport.push(200, &[], &session("d.e.f")); + h.transport.push(200, &[], DEVICES); + h.client.devices().await.unwrap(); + + let requests = h.transport.requests(); + let body: Value = serde_json::from_slice(&requests[FRESH].body).unwrap(); + assert_eq!(body, json!({"refresh_token": ROTATED_REFRESH})); + assert_eq!( + header(&requests[FRESH + 1], "authorization"), + Some("DPoP d.e.f"), + ); + } + + #[tokio::test] + async fn fresh_token_is_reused() { + let h = seeded(); + h.transport.push(200, &[], &session("a.b.c")); + h.transport.push(200, &[], DEVICES); + h.transport.push(200, &[], DEVICES); + + h.client.devices().await.unwrap(); + h.clock.advance(599); + h.client.devices().await.unwrap(); + + assert_eq!(h.transport.requests().len(), 3); + assert_eq!(h.token_requests(), 1); + } + + #[tokio::test] + async fn expired_token_refreshes_before_sending() { + let h = seeded(); + for _ in 0..2 { + h.transport.push(200, &[], &session("a.b.c")); + h.transport.push(200, &[], DEVICES); + } + + h.client.devices().await.unwrap(); + h.clock.advance(601); + h.client.devices().await.unwrap(); + + let urls: Vec<_> = h.transport.requests().into_iter().map(|r| r.url).collect(); + assert_eq!( + urls, + [ + "https://kg.example/api/v1/auth/token", + "https://kg.example/api/v1/devices", + "https://kg.example/api/v1/auth/token", + "https://kg.example/api/v1/devices", + ], + ); + } + + #[tokio::test] + async fn token_is_expired_at_its_expiry_second() { + let h = fresh().await; + h.clock.advance(600); + h.transport.push(200, &[], &session("d.e.f")); + h.transport.push(200, &[], DEVICES); + + h.client.devices().await.unwrap(); + + assert_eq!(h.token_requests(), 2); + } + + #[tokio::test] + async fn concurrent_callers_refresh_once() { + let h = seeded(); + h.transport.push(200, &[], &session("a.b.c")); + h.transport.push(200, &[], DEVICES); + h.transport.push(200, &[], DEVICES); + + let (first, second) = tokio::join!(h.client.devices(), h.client.devices()); + + first.unwrap(); + second.unwrap(); + assert_eq!(h.token_requests(), 1); + } + + #[tokio::test] + async fn concurrent_rejected_callers_refresh_once() { + let h = fresh().await; + h.transport.push(401, &[], &error_body("invalid_token")); + h.transport.push(401, &[], &error_body("invalid_token")); + h.transport.push(200, &[], &session("d.e.f")); + h.transport.push(200, &[], DEVICES); + h.transport.push(200, &[], DEVICES); + + let (first, second) = tokio::join!(h.client.devices(), h.client.devices()); + + first.unwrap(); + second.unwrap(); + // One from `fresh`, one here. + assert_eq!(h.token_requests(), 2); + } + + #[tokio::test] + async fn failed_save_is_returned_and_the_token_is_not_used() { + let h = seeded(); + h.store.fail_saves(); + h.transport.push(200, &[], &session("a.b.c")); + + let error = h.client.devices().await.unwrap_err(); + + assert!(matches!(error, SyncError::Client { .. })); + assert_eq!(h.transport.requests().len(), 1); + + // The token was not kept for later either: the next call has to refresh again. + h.transport.push(200, &[], &session("a.b.c")); + let error = h.client.devices().await.unwrap_err(); + + assert!(matches!(error, SyncError::Client { .. })); + assert_eq!(h.token_requests(), 2); + assert_eq!(h.transport.requests().len(), 2); + } + + #[tokio::test] + async fn invalid_token_refreshes_and_retries_once() { + let h = fresh().await; + h.transport.push(401, &[], &error_body("invalid_token")); + h.transport.push(200, &[], &session("d.e.f")); + h.transport.push(200, &[], DEVICES); + + h.client.devices().await.unwrap(); + + let requests = h.transport.requests(); + assert_eq!(requests.len() - FRESH, 3); + assert_eq!( + header(&requests[FRESH + 2], "authorization"), + Some("DPoP d.e.f"), + ); + } + + #[tokio::test] + async fn second_invalid_token_is_returned() { + let h = fresh().await; + h.transport.push(401, &[], &error_body("invalid_token")); + h.transport.push(200, &[], &session("d.e.f")); + h.transport.push(401, &[], &error_body("invalid_token")); + + let error = h.client.devices().await.unwrap_err(); + + assert!(matches!(error, SyncError::Server { code, .. } if code == "invalid_token")); + assert_eq!(h.transport.requests().len() - FRESH, 3); + } + + #[tokio::test] + async fn nonce_and_invalid_token_each_retry_once() { + let h = fresh().await; + h.transport.push(400, &[("DPoP-Nonce", "n1")], CHALLENGE); + h.transport.push(401, &[], &error_body("invalid_token")); + h.transport.push(200, &[], &session("d.e.f")); + h.transport.push(200, &[], DEVICES); + + h.client.devices().await.unwrap(); + + assert_eq!(h.transport.requests().len() - FRESH, 4); + } + + #[tokio::test] + async fn session_revoked_clears_store_and_keeps_reason() { + let h = seeded(); + h.transport.push(401, &[], &revoked_body("reuse_detected")); + + assert_eq!( + h.client.devices().await.unwrap_err(), + SyncError::SignedOut { + reason: Some(RevokeReason::ReuseDetected), + }, + ); + assert_eq!(h.stored_refresh_token(), None); + } + + #[tokio::test] + async fn session_revoked_on_an_ordinary_call_ends_the_session() { + let h = fresh().await; + h.transport.push(401, &[], &revoked_body("logout")); + + assert_eq!( + h.client.devices().await.unwrap_err(), + SyncError::SignedOut { + reason: Some(RevokeReason::Logout), + }, + ); + h.assert_signed_out_locally().await; + } + + #[tokio::test] + async fn refresh_expired_clears_store() { + let h = seeded(); + h.transport.push(401, &[], &error_body("refresh_expired")); + + assert_eq!( + h.client.devices().await.unwrap_err(), + SyncError::SignedOut { reason: None }, + ); + assert_eq!(h.stored_refresh_token(), None); + } + + #[tokio::test] + async fn unknown_revoke_reason_still_signs_out() { + let h = seeded(); + h.transport.push(401, &[], &revoked_body("brand_new")); + + assert_eq!( + h.client.devices().await.unwrap_err(), + SyncError::SignedOut { reason: None }, + ); + assert_eq!(h.stored_refresh_token(), None); + } + + #[tokio::test] + async fn a_success_status_never_signs_out() { + let h = fresh().await; + h.transport.push(200, &[], &error_body("session_revoked")); + + let error = h.client.devices().await.unwrap_err(); + + assert!(matches!(error, SyncError::Server { code, .. } if code == "invalid_response")); + assert_eq!(h.stored_refresh_token().as_deref(), Some(ROTATED_REFRESH)); + } + + #[tokio::test] + async fn network_failure_during_refresh_keeps_store() { + let h = seeded(); + h.transport.push_network_error("offline"); + + let error = h.client.devices().await.unwrap_err(); + + assert!(matches!(error, SyncError::Network { .. })); + assert_eq!(h.stored_refresh_token().as_deref(), Some(OLD_REFRESH)); + } + + #[tokio::test] + async fn logout_ends_the_session() { + let h = fresh().await; + h.transport.push(204, &[], b""); + + h.client.logout().await.unwrap(); + + let request = &h.transport.requests()[FRESH]; + assert_eq!(request.url, "https://kg.example/api/v1/auth/logout"); + assert_eq!(header(request, "authorization"), Some("DPoP a.b.c")); + h.assert_signed_out_locally().await; + } + + #[tokio::test] + async fn logout_clears_local_state_when_offline() { + let h = fresh().await; + h.transport.push_network_error("offline"); + + let error = h.client.logout().await.unwrap_err(); + + assert!(matches!(error, SyncError::Network { .. })); + h.assert_signed_out_locally().await; + } + + #[tokio::test] + async fn fresh_auth_required_is_not_retried() { + let h = fresh().await; + let id = DeviceId::random(); + h.transport + .push(403, &[], &error_body("fresh_auth_required")); + + assert_eq!( + h.client.delete_device(id).await.unwrap_err(), + SyncError::FreshAuthRequired, + ); + + let requests = h.transport.requests(); + assert_eq!(requests.len() - FRESH, 1); + assert_eq!(requests[FRESH].method, Method::Delete); + assert_eq!( + requests[FRESH].url, + format!("https://kg.example/api/v1/devices/{}", id.as_uuid()), + ); + } + + #[tokio::test] + async fn a_refresh_dropped_midway_leaves_nothing_behind() { + let h = seeded(); + + // The fake transport yields once before it answers, so this drops the call while it holds + // the lock and is waiting on `/auth/token`. + tokio::select! { + biased; + _ = h.client.devices() => panic!("the call should still be waiting"), + () = std::future::ready(()) => {} + } + assert!(h.transport.requests().is_empty()); + assert_eq!(h.stored_refresh_token().as_deref(), Some(OLD_REFRESH)); + + h.transport.push(200, &[], &session("a.b.c")); + h.transport.push(200, &[], DEVICES); + h.client.devices().await.unwrap(); + + assert_eq!(h.transport.requests().len(), 2); + } } diff --git a/rust/crates/keygo-client/src/sync/state.rs b/rust/crates/keygo-client/src/sync/state.rs index 365b401bd..a9e366235 100644 --- a/rust/crates/keygo-client/src/sync/state.rs +++ b/rust/crates/keygo-client/src/sync/state.rs @@ -1,10 +1,31 @@ +use keygo_api::domain::AccessToken; use std::time::{SystemTime, UNIX_EPOCH}; -/// What the client remembers between calls. Later tasks add the access token. +pub(super) struct AccessState { + pub(super) token: AccessToken, + /// Unix seconds. The token is usable while the clock reads less than this. + pub(super) expires_at: u64, +} + +/// What the client remembers between calls. #[derive(Default)] pub(super) struct AuthState { + pub(super) access: Option, /// The last `DPoP-Nonce` the server sent. pub(super) nonce: Option, + /// Changes whenever `access` does. A call remembers the value its token came with, so when + /// that token is rejected it can tell whether someone has already replaced it. + pub(super) generation: u64, +} + +impl AuthState { + /// Forgets the session. `generation` moves on rather than restarting, so a call still holding + /// a token from before cannot mistake a later one for its own. + pub(super) fn reset(&mut self) { + self.access = None; + self.nonce = None; + self.generation += 1; + } } pub trait Clock: Send + Sync { diff --git a/rust/crates/keygo-client/src/sync/transport.rs b/rust/crates/keygo-client/src/sync/transport.rs index 257193896..a4df9fe53 100644 --- a/rust/crates/keygo-client/src/sync/transport.rs +++ b/rust/crates/keygo-client/src/sync/transport.rs @@ -1,13 +1,14 @@ use async_trait::async_trait; use keygo_api::Method; +use std::fmt; -#[derive(Debug, Clone, PartialEq, Eq)] +#[derive(Clone, PartialEq, Eq)] pub struct Header { pub name: String, pub value: String, } -#[derive(Debug, Clone, PartialEq, Eq)] +#[derive(Clone, PartialEq, Eq)] pub struct HttpRequest { pub method: Method, pub url: String, @@ -15,13 +16,49 @@ pub struct HttpRequest { pub body: Vec, } -#[derive(Debug, Clone, PartialEq, Eq)] +#[derive(Clone, PartialEq, Eq)] pub struct HttpResponse { pub status: u16, pub headers: Vec
, pub body: Vec, } +// Header values hold proofs and access tokens, and bodies hold refresh tokens, so none of these +// print them. +impl fmt::Debug for Header { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("Header") + .field("name", &self.name) + .field("value", &format_args!("")) + .finish() + } +} + +impl fmt::Debug for HttpRequest { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("HttpRequest") + .field("method", &self.method) + .field("url", &self.url) + .field("headers", &header_names(&self.headers)) + .field("body_len", &self.body.len()) + .finish() + } +} + +impl fmt::Debug for HttpResponse { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("HttpResponse") + .field("status", &self.status) + .field("headers", &header_names(&self.headers)) + .field("body_len", &self.body.len()) + .finish() + } +} + +fn header_names(headers: &[Header]) -> Vec<&str> { + headers.iter().map(|h| h.name.as_str()).collect() +} + #[derive(Debug, thiserror::Error)] #[error("{message}")] pub struct TransportError { @@ -34,3 +71,39 @@ pub struct TransportError { pub trait Transport: Send + Sync { async fn send(&self, request: HttpRequest) -> Result; } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn debug_output_hides_tokens_and_bodies() { + let request = HttpRequest { + method: Method::Post, + url: "https://kg.example/api/v1/auth/token".into(), + headers: vec![Header { + name: "authorization".into(), + value: "DPoP secret-access-token".into(), + }], + body: br#"{"refresh_token":"secret-refresh-token"}"#.to_vec(), + }; + let response = HttpResponse { + status: 200, + headers: request.headers.clone(), + body: request.body.clone(), + }; + + for output in [format!("{request:?}"), format!("{response:?}")] { + assert!(!output.contains("secret-access-token"), "{output}"); + assert!(!output.contains("secret-refresh-token"), "{output}"); + assert!(output.contains("authorization"), "{output}"); + assert!( + output.contains(&format!("body_len: {}", request.body.len())), + "{output}", + ); + } + let header = format!("{:?}", request.headers[0]); + assert!(!header.contains("secret-access-token"), "{header}"); + assert!(header.contains(""), "{header}"); + } +} From a38d9775d561ebf7c274b27e35bb28fa3221fc1c Mon Sep 17 00:00:00 2001 From: Davis Date: Mon, 9 Nov 2026 19:06:49 +0100 Subject: [PATCH 11/52] fix(client): report a logout that could not clear the token When the logout could not be sent and the store could not be cleared, a refresh token the server still accepts stayed on disk, while logout returned a harmless looking Network error. The next call would load it and silently restore the session. end_session now returns the store's result. logout reports the store failure for that double fault only; after a sent logout the entry is dead on the server, so the send result stands. The session-revoked paths still discard it, since the server has already killed the token. Co-Authored-By: Claude Opus 5.5 --- rust/crates/keygo-client/src/sync/client.rs | 11 ++++- rust/crates/keygo-client/src/sync/pipeline.rs | 42 +++++++++++++++---- rust/crates/keygo-client/src/sync/testing.rs | 11 +++++ 3 files changed, 55 insertions(+), 9 deletions(-) diff --git a/rust/crates/keygo-client/src/sync/client.rs b/rust/crates/keygo-client/src/sync/client.rs index 52fdfde8b..e10afdea2 100644 --- a/rust/crates/keygo-client/src/sync/client.rs +++ b/rust/crates/keygo-client/src/sync/client.rs @@ -1,4 +1,5 @@ use super::error::SyncResult; +use super::pipeline::store_failure; use super::signer::{DpopKey, ForeignSigner}; use super::state::{AuthState, Clock, SystemClock}; use super::tokens::TokenStore; @@ -57,11 +58,17 @@ impl SyncClient { } /// Ends the session here even if the server cannot be told, and reports whether it was. + /// + /// When the server could not be told and the store could not be cleared either, a token the + /// server still accepts stays on disk, so the store failure is returned instead. pub async fn logout(&self) -> SyncResult<()> { let sent = self.call(&Logout, &()).await; let mut state = self.auth.lock().await; - self.end_session(&mut state).await; - sent + let cleared = self.end_session(&mut state).await; + match (sent, cleared) { + (Err(_), Err(error)) => Err(store_failure(error)), + (sent, _) => sent, + } } } diff --git a/rust/crates/keygo-client/src/sync/pipeline.rs b/rust/crates/keygo-client/src/sync/pipeline.rs index 50d2a5d17..4b5f51664 100644 --- a/rust/crates/keygo-client/src/sync/pipeline.rs +++ b/rust/crates/keygo-client/src/sync/pipeline.rs @@ -87,7 +87,7 @@ fn sign_out_error(response: &HttpResponse) -> Option { }) } -fn store_failure(error: TokenStoreError) -> SyncError { +pub(super) fn store_failure(error: TokenStoreError) -> SyncError { SyncError::Client { message: format!("token store failed: {error}"), } @@ -174,11 +174,12 @@ impl SyncClient { /// Forgets the session, in memory and in the store. The caller holds the `AuthState` lock, so /// a refresh that is still running cannot save a token after this. /// - /// A store that fails to clear changes nothing about what the caller is told; the stale entry - /// is cleared again the next time the server refuses it. - pub(super) async fn end_session(&self, state: &mut AuthState) { + /// `AuthState` is reset even when the store fails. What that failure means is the caller's to + /// decide: an entry the server has already killed is only refused and cleared again, but one + /// it still accepts would bring the session back on the next call. + pub(super) async fn end_session(&self, state: &mut AuthState) -> Result<(), TokenStoreError> { state.reset(); - let _ = self.tokens.clear().await; + self.tokens.clear().await } /// Spends the stored refresh token on a new session and returns the new access token. `state` @@ -218,7 +219,8 @@ impl SyncClient { if !is_success(&response) { if let Some(signed_out) = sign_out_error(&response) { - self.end_session(state).await; + // The server has killed this token, so an entry left behind is only refused again. + let _ = self.end_session(state).await; return Err(signed_out); } return Err(from_response(response.status, &response.body)); @@ -336,7 +338,8 @@ impl SyncClient { } if let Some(signed_out) = sign_out_error(&response) { let mut state = self.auth.lock().await; - self.end_session(&mut state).await; + // The server has killed this token, so an entry left behind is only refused again. + let _ = self.end_session(&mut state).await; return Err(signed_out); } Err(from_response(response.status, &response.body)) @@ -944,6 +947,31 @@ mod tests { h.assert_signed_out_locally().await; } + #[tokio::test] + async fn offline_logout_reports_a_failed_clear() { + let h = fresh().await; + h.store.fail_clears(); + h.transport.push_network_error("offline"); + + let error = h.client.logout().await.unwrap_err(); + + assert!(matches!(error, SyncError::Client { .. })); + assert!(h.client.auth.lock().await.access.is_none()); + // Why this cannot pass as an offline logout: the server still accepts this token. + assert_eq!(h.stored_refresh_token().as_deref(), Some(ROTATED_REFRESH)); + } + + #[tokio::test] + async fn sent_logout_ignores_a_failed_clear() { + let h = fresh().await; + h.store.fail_clears(); + h.transport.push(204, &[], b""); + + h.client.logout().await.unwrap(); + + assert!(h.client.auth.lock().await.access.is_none()); + } + #[tokio::test] async fn fresh_auth_required_is_not_retried() { let h = fresh().await; diff --git a/rust/crates/keygo-client/src/sync/testing.rs b/rust/crates/keygo-client/src/sync/testing.rs index 5a1b983a5..57771352d 100644 --- a/rust/crates/keygo-client/src/sync/testing.rs +++ b/rust/crates/keygo-client/src/sync/testing.rs @@ -67,6 +67,7 @@ impl Transport for FakeTransport { pub struct FakeTokenStore { stored: Mutex>, fail_saves: AtomicBool, + fail_clears: AtomicBool, } impl FakeTokenStore { @@ -74,6 +75,7 @@ impl FakeTokenStore { Self { stored: Mutex::new(None), fail_saves: AtomicBool::new(false), + fail_clears: AtomicBool::new(false), } } @@ -89,6 +91,10 @@ impl FakeTokenStore { pub fn fail_saves(&self) { self.fail_saves.store(true, Ordering::SeqCst); } + + pub fn fail_clears(&self) { + self.fail_clears.store(true, Ordering::SeqCst); + } } impl Default for FakeTokenStore { @@ -131,6 +137,11 @@ impl TokenStore for FakeTokenStore { } async fn clear(&self) -> Result<(), TokenStoreError> { + if self.fail_clears.load(Ordering::SeqCst) { + return Err(TokenStoreError { + message: "clear failed".into(), + }); + } *self.stored.lock().unwrap() = None; Ok(()) } From e420a2e3c560225724a38aeed67091130b84c46d Mon Sep 17 00:00:00 2001 From: Davis Date: Mon, 9 Nov 2026 19:15:36 +0100 Subject: [PATCH 12/52] test(e2e): drive SyncClient against the router Adds SyncClient::step_up, stub register/login, and the keygo-e2e crate. AuthState::replace_access keeps generation in step with access. Co-Authored-By: Claude Opus 5.5 --- CLAUDE.md | 1 + rust/Cargo.lock | 20 ++ rust/crates/keygo-client/src/sync/client.rs | 93 ++++++- rust/crates/keygo-client/src/sync/mod.rs | 2 +- rust/crates/keygo-client/src/sync/pipeline.rs | 12 +- rust/crates/keygo-client/src/sync/state.rs | 29 ++- rust/crates/keygo-e2e/Cargo.toml | 23 ++ rust/crates/keygo-e2e/src/lib.rs | 3 + rust/crates/keygo-e2e/tests/sync.rs | 239 ++++++++++++++++++ 9 files changed, 408 insertions(+), 14 deletions(-) create mode 100644 rust/crates/keygo-e2e/Cargo.toml create mode 100644 rust/crates/keygo-e2e/src/lib.rs create mode 100644 rust/crates/keygo-e2e/tests/sync.rs diff --git a/CLAUDE.md b/CLAUDE.md index 0d7fe96f9..68949138e 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -70,6 +70,7 @@ Rust workspace (`rust/`, toolchain pinned in `rust-toolchain.toml`, edition 2024 | `keygo-uniffi` | UniFFI bindings exposing `keygo-client` to Kotlin (`libkeygo_bindings.so`) | | `keygo-opaque` | OPAQUE (opaque-ke, ristretto255 + Argon2) client/server wrapper, `forbid(unsafe_code)` | | `keygo-server` | Self-hostable sync server (axum + sqlx/Postgres + clap CLI), see Sync Server | +| `keygo-e2e` | Test-only: drives the real `SyncClient` against the real server router (in-process, real OPAQUE and DPoP) | | `tools/uniffi-bindgen` | Bindgen runner used by `make bindgen` | ## Key Patterns diff --git a/rust/Cargo.lock b/rust/Cargo.lock index bb4686eb5..1078c51e1 100644 --- a/rust/Cargo.lock +++ b/rust/Cargo.lock @@ -1674,6 +1674,26 @@ dependencies = [ "zeroize", ] +[[package]] +name = "keygo-e2e" +version = "0.1.0" +dependencies = [ + "async-trait", + "axum", + "http-body-util", + "keygo-api", + "keygo-client", + "keygo-core", + "keygo-dpop", + "keygo-opaque", + "keygo-server", + "serde_json", + "sqlx", + "tokio", + "tower", + "url", +] + [[package]] name = "keygo-opaque" version = "0.1.0" diff --git a/rust/crates/keygo-client/src/sync/client.rs b/rust/crates/keygo-client/src/sync/client.rs index e10afdea2..1fd8118fc 100644 --- a/rust/crates/keygo-client/src/sync/client.rs +++ b/rust/crates/keygo-client/src/sync/client.rs @@ -1,18 +1,31 @@ +use super::error::SyncError; use super::error::SyncResult; use super::pipeline::store_failure; use super::signer::{DpopKey, ForeignSigner}; -use super::state::{AuthState, Clock, SystemClock}; +use super::state::{AccessState, AuthState, Clock, SystemClock}; use super::tokens::TokenStore; use super::transport::Transport; -use keygo_api::domain::Device; -use keygo_api::endpoints::{DeleteDevice, ListDevices, Logout, Meta}; +use crate::ark_session::ArkSession; +use keygo_api::auth::step_up::{FinishRequest, StartRequest}; +use keygo_api::domain::{Device, DeviceInfo, Username}; +use keygo_api::endpoints::{DeleteDevice, ListDevices, Logout, Meta, StepUpFinish, StepUpStart}; use keygo_api::meta::ServerInfo; -use keygo_core::DeviceId; +use keygo_core::{DeviceId, UserId}; use keygo_dpop::DpopProver; +use keygo_opaque::OpaqueError; +use keygo_opaque::client::ClientLogin; use std::sync::Arc; use tokio::sync::Mutex; use url::Url; +/// Who signed in, and as which device. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct Account { + pub user_id: UserId, + pub username: Username, + pub device_id: DeviceId, +} + pub struct SyncClient { pub(super) base_url: Url, pub(super) transport: Arc, @@ -57,6 +70,63 @@ impl SyncClient { self.call(&DeleteDevice { id }, &()).await } + /// Proves the password again to the server, which then treats this session as freshly + /// authenticated. Only the access token changes: the refresh token and the store are untouched. + pub async fn step_up(&self, password: &str) -> SyncResult<()> { + let (login, credential_request) = + ClientLogin::start(password.as_bytes()).map_err(opaque_failure)?; + let started = self + .call(&StepUpStart, &StartRequest { credential_request }) + .await?; + let finish = login + .finish(password.as_bytes(), started.credential_response) + .map_err(opaque_failure)?; + let dpop_binding = finish.session_key.dpop_binding(self.prover.jkt()); + + // Read before sending, so a token never looks like it lives longer than it does. + let now = self.clock.now_secs(); + let response = self + .call( + &StepUpFinish, + &FinishRequest { + login_id: started.login_id, + credential_finalization: finish.finalization, + dpop_binding, + }, + ) + .await?; + + self.auth.lock().await.replace_access(AccessState { + token: response.access.access_token, + expires_at: now.saturating_add(response.access.access_expires_in), + }); + Ok(()) + } + + /// Not implemented until the key bundle's wrapping is decided. + pub async fn register( + &self, + _ark: &ArkSession, + _user_id: UserId, + _username: &str, + _password: &str, + _invite: Option<&str>, + _device: DeviceInfo, + ) -> SyncResult { + Err(undecided()) + } + + /// Not implemented until the key bundle's wrapping is decided. + pub async fn login( + &self, + _ark: &ArkSession, + _username: &str, + _password: &str, + _device: DeviceInfo, + ) -> SyncResult { + Err(undecided()) + } + /// Ends the session here even if the server cannot be told, and reports whether it was. /// /// When the server could not be told and the store could not be cleared either, a token the @@ -72,6 +142,21 @@ impl SyncClient { } } +fn undecided() -> SyncError { + SyncError::Client { + message: "key bundle wrapping is not decided".into(), + } +} + +fn opaque_failure(error: OpaqueError) -> SyncError { + match error { + OpaqueError::InvalidLogin | OpaqueError::EmptyPassword => SyncError::InvalidCredentials, + other => SyncError::Client { + message: other.to_string(), + }, + } +} + #[cfg(test)] mod tests { use super::super::error::SyncError; diff --git a/rust/crates/keygo-client/src/sync/mod.rs b/rust/crates/keygo-client/src/sync/mod.rs index 51bbbfb84..e75c944cd 100644 --- a/rust/crates/keygo-client/src/sync/mod.rs +++ b/rust/crates/keygo-client/src/sync/mod.rs @@ -11,7 +11,7 @@ pub mod testing; mod tokens; mod transport; -pub use client::SyncClient; +pub use client::{Account, SyncClient}; pub use error::{SyncError, SyncResult}; pub use signer::{DpopKey, ForeignSigner, SignError}; pub use state::{Clock, SystemClock}; diff --git a/rust/crates/keygo-client/src/sync/pipeline.rs b/rust/crates/keygo-client/src/sync/pipeline.rs index 4b5f51664..925b9b94e 100644 --- a/rust/crates/keygo-client/src/sync/pipeline.rs +++ b/rust/crates/keygo-client/src/sync/pipeline.rs @@ -239,11 +239,10 @@ impl SyncClient { .map_err(store_failure)?; let token = Zeroizing::new(session.access.access_token.expose().to_owned()); - state.access = Some(AccessState { + state.replace_access(AccessState { token: session.access.access_token, expires_at: now.saturating_add(session.access.access_expires_in), }); - state.generation += 1; Ok(token) } @@ -253,10 +252,7 @@ impl SyncClient { async fn access_token(&self) -> SyncResult<(Zeroizing, u64, Option)> { let mut state = self.auth.lock().await; let now = self.clock.now_secs(); - let live = state - .access - .as_ref() - .filter(|access| now < access.expires_at); + let live = state.access().filter(|access| now < access.expires_at); let token = match live { Some(access) => Zeroizing::new(access.token.expose().to_owned()), None => self.refresh_locked(&mut state).await?, @@ -956,7 +952,7 @@ mod tests { let error = h.client.logout().await.unwrap_err(); assert!(matches!(error, SyncError::Client { .. })); - assert!(h.client.auth.lock().await.access.is_none()); + assert!(h.client.auth.lock().await.access().is_none()); // Why this cannot pass as an offline logout: the server still accepts this token. assert_eq!(h.stored_refresh_token().as_deref(), Some(ROTATED_REFRESH)); } @@ -969,7 +965,7 @@ mod tests { h.client.logout().await.unwrap(); - assert!(h.client.auth.lock().await.access.is_none()); + assert!(h.client.auth.lock().await.access().is_none()); } #[tokio::test] diff --git a/rust/crates/keygo-client/src/sync/state.rs b/rust/crates/keygo-client/src/sync/state.rs index a9e366235..c3856b94f 100644 --- a/rust/crates/keygo-client/src/sync/state.rs +++ b/rust/crates/keygo-client/src/sync/state.rs @@ -10,7 +10,7 @@ pub(super) struct AccessState { /// What the client remembers between calls. #[derive(Default)] pub(super) struct AuthState { - pub(super) access: Option, + access: Option, /// The last `DPoP-Nonce` the server sent. pub(super) nonce: Option, /// Changes whenever `access` does. A call remembers the value its token came with, so when @@ -21,6 +21,16 @@ pub(super) struct AuthState { impl AuthState { /// Forgets the session. `generation` moves on rather than restarting, so a call still holding /// a token from before cannot mistake a later one for its own. + pub(super) fn access(&self) -> Option<&AccessState> { + self.access.as_ref() + } + + /// The only way to set the access token, so `generation` cannot be left behind. + pub(super) fn replace_access(&mut self, access: AccessState) { + self.access = Some(access); + self.generation += 1; + } + pub(super) fn reset(&mut self) { self.access = None; self.nonce = None; @@ -42,3 +52,20 @@ impl Clock for SystemClock { .unwrap_or(0) } } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn replacing_access_moves_the_generation() { + let mut state = AuthState::default(); + let before = state.generation; + state.replace_access(AccessState { + token: AccessToken::from_signed("a.b.c".into()), + expires_at: 1, + }); + assert_eq!(state.generation, before + 1); + assert!(state.access().is_some()); + } +} diff --git a/rust/crates/keygo-e2e/Cargo.toml b/rust/crates/keygo-e2e/Cargo.toml new file mode 100644 index 000000000..255799693 --- /dev/null +++ b/rust/crates/keygo-e2e/Cargo.toml @@ -0,0 +1,23 @@ +[package] +name = "keygo-e2e" +description = "Drives the real sync client against the real server router." +version.workspace = true +edition.workspace = true +publish = false + +[dev-dependencies] +keygo-api = { path = "../keygo-api" } +keygo-core = { path = "../keygo-core" } +keygo-client = { path = "../keygo-client", features = ["test-support"] } +keygo-dpop = { path = "../keygo-dpop", features = ["test-support"] } +keygo-opaque = { path = "../keygo-opaque" } +keygo-server = { path = "../keygo-server", features = ["test-support"] } + +async-trait = "0.1.89" +axum = "0.8.9" +http-body-util = "0.1.5" +tower = { version = "0.5.3", features = ["util"] } +sqlx = { version = "0.9.0", default-features = false, features = ["runtime-tokio", "postgres", "migrate", "macros", "uuid", "time"] } +tokio = { workspace = true, features = ["macros", "rt-multi-thread"] } +serde_json.workspace = true +url = "2.5.8" diff --git a/rust/crates/keygo-e2e/src/lib.rs b/rust/crates/keygo-e2e/src/lib.rs new file mode 100644 index 000000000..341f98125 --- /dev/null +++ b/rust/crates/keygo-e2e/src/lib.rs @@ -0,0 +1,3 @@ +//! End-to-end tests: the real `SyncClient` against the real `keygo-server` router, with real +//! OPAQUE and real DPoP. This is the only crate that builds both sides together, so it is where +//! the shipped server's feature set (no `crypto`) stays untouched by the client's. diff --git a/rust/crates/keygo-e2e/tests/sync.rs b/rust/crates/keygo-e2e/tests/sync.rs new file mode 100644 index 000000000..dfbc0b919 --- /dev/null +++ b/rust/crates/keygo-e2e/tests/sync.rs @@ -0,0 +1,239 @@ +use async_trait::async_trait; +use axum::body::Body; +use axum::http::{HeaderName, HeaderValue, Request}; +use http_body_util::BodyExt; +use keygo_api::Method; +use keygo_api::domain::{Device, RevokeReason}; +use keygo_client::sync::testing::{FakeDpopKey, FakeTokenStore, FixedClock}; +use keygo_client::sync::{ + Header, HttpRequest, HttpResponse, StoredSession, SyncClient, SyncError, Transport, + TransportError, +}; +use keygo_dpop::testing::TestSigner; +use keygo_server::api::{AppState, router}; +use keygo_server::testing; +use sqlx::PgPool; +use std::sync::Arc; +use std::time::{SystemTime, UNIX_EPOCH}; +use tower::ServiceExt; +use url::Url; + +/// Hands requests to the router in-process, the way a real transport hands them to the network. +struct TowerTransport(AppState); + +#[async_trait] +impl Transport for TowerTransport { + async fn send(&self, request: HttpRequest) -> Result { + let fail = |e: &dyn std::fmt::Display| TransportError { + message: e.to_string(), + }; + let method = match request.method { + Method::Get => "GET", + Method::Post => "POST", + Method::Delete => "DELETE", + }; + let mut built = Request::builder().method(method).uri(&request.url); + for header in &request.headers { + built = built.header( + HeaderName::try_from(header.name.as_str()).map_err(|e| fail(&e))?, + HeaderValue::try_from(header.value.as_str()).map_err(|e| fail(&e))?, + ); + } + let built = built.body(Body::from(request.body)).map_err(|e| fail(&e))?; + + let response = router(self.0.clone()) + .oneshot(built) + .await + .map_err(|e| fail(&e))?; + let status = response.status().as_u16(); + let headers = response + .headers() + .iter() + .map(|(name, value)| Header { + name: name.as_str().to_owned(), + value: value.to_str().unwrap_or_default().to_owned(), + }) + .collect(); + let body = response + .into_body() + .collect() + .await + .map_err(|e| fail(&e))? + .to_bytes() + .to_vec(); + Ok(HttpResponse { + status, + headers, + body, + }) + } +} + +struct Harness { + client: SyncClient, + store: Arc, + clock: Arc, + state: AppState, + prover: keygo_dpop::DpopProver, + device_id: keygo_core::DeviceId, + access_token: String, + seed_token: String, +} + +fn now() -> u64 { + SystemTime::now() + .duration_since(UNIX_EPOCH) + .unwrap() + .as_secs() +} + +async fn harness(db: &PgPool) -> Harness { + let prover = testing::prover(); + let (state, issued) = testing::signed_in(db, &prover).await; + let seed_token = issued.refresh_token.expose_encoded().to_string(); + let access_token = issued.access_token.expose().to_owned(); + let device_id = issued.device_id; + + let store = Arc::new(FakeTokenStore::new()); + store.seed(StoredSession { + device_id, + refresh_token: issued.refresh_token, + refresh_expires_at: now() + issued.refresh_expires_in.as_secs(), + }); + let clock = FixedClock::new(now()); + let client = SyncClient::new( + Url::parse(testing::ISS).unwrap(), + Arc::new(TowerTransport(state.clone())), + Arc::new(FakeDpopKey::new()), + store.clone(), + ) + .unwrap() + .with_clock(clock.clone()); + + Harness { + client, + store, + clock, + state, + prover, + device_id, + access_token, + seed_token, + } +} + +fn password() -> &'static str { + std::str::from_utf8(testing::PASSWORD).unwrap() +} + +fn other(devices: &[Device], mine: keygo_core::DeviceId) -> keygo_core::DeviceId { + devices.iter().find(|d| d.id != mine).unwrap().id +} + +#[sqlx::test(migrations = "../keygo-server/migrations")] +async fn meta_reports_the_server(db: PgPool) { + let h = harness(&db).await; + + let info = h.client.meta().await.unwrap(); + + assert!(info.allow_signups); + assert_eq!(info.public_url, "http://localhost/"); +} + +#[sqlx::test(migrations = "../keygo-server/migrations")] +async fn first_call_refreshes_and_rotates(db: PgPool) { + let h = harness(&db).await; + + assert_eq!(h.client.devices().await.unwrap().len(), 2); + + assert_ne!(h.store.current_refresh_token().unwrap(), h.seed_token); +} + +#[sqlx::test(migrations = "../keygo-server/migrations")] +async fn expired_access_token_refreshes_again(db: PgPool) { + let h = harness(&db).await; + h.client.devices().await.unwrap(); + let first = h.store.current_refresh_token().unwrap(); + + h.clock.advance(601); + h.client.devices().await.unwrap(); + + assert_ne!(h.store.current_refresh_token().unwrap(), first); +} + +#[sqlx::test(migrations = "../keygo-server/migrations")] +async fn revoked_session_signs_out(db: PgPool) { + let h = harness(&db).await; + let (status, _) = testing::post_with_token( + &h.state, + &h.prover, + "/api/v1/auth/logout", + &h.access_token, + serde_json::Value::Null, + ) + .await; + assert!(status.is_success(), "{status}"); + + assert_eq!( + h.client.devices().await.unwrap_err(), + SyncError::SignedOut { + reason: Some(RevokeReason::Logout), + }, + ); + assert_eq!(h.store.current_refresh_token(), None); +} + +#[sqlx::test(migrations = "../keygo-server/migrations")] +async fn fresh_auth_required_then_step_up_then_retry(db: PgPool) { + let h = harness(&db).await; + sqlx::query("update sessions set auth_time = to_timestamp($1) where device_id = $2") + .bind((now() - 301) as f64) + .bind(h.device_id.as_uuid()) + .execute(&db) + .await + .unwrap(); + + let devices = h.client.devices().await.unwrap(); + let other = other(&devices, h.device_id); + assert_eq!( + h.client.delete_device(other).await.unwrap_err(), + SyncError::FreshAuthRequired, + ); + + h.client.step_up(password()).await.unwrap(); + h.client.delete_device(other).await.unwrap(); + + assert_eq!(h.client.devices().await.unwrap().len(), 1); +} + +#[sqlx::test(migrations = "../keygo-server/migrations")] +async fn step_up_replaces_the_access_token_without_rotating(db: PgPool) { + let h = harness(&db).await; + h.client.devices().await.unwrap(); + let stored = h.store.current_refresh_token().unwrap(); + + h.client.step_up(password()).await.unwrap(); + h.client.devices().await.unwrap(); + + assert_eq!(h.store.current_refresh_token().unwrap(), stored); +} + +#[sqlx::test(migrations = "../keygo-server/migrations")] +async fn wrong_step_up_password_is_invalid_credentials(db: PgPool) { + let h = harness(&db).await; + + assert_eq!( + h.client.step_up("wrong").await.unwrap_err(), + SyncError::InvalidCredentials, + ); +} + +#[sqlx::test(migrations = "../keygo-server/migrations")] +async fn empty_step_up_password_is_invalid_credentials(db: PgPool) { + let h = harness(&db).await; + + assert_eq!( + h.client.step_up("").await.unwrap_err(), + SyncError::InvalidCredentials, + ); +} From 7283750674f7ff75bb68ad026121206f419f91eb Mon Sep 17 00:00:00 2001 From: Davis Date: Mon, 9 Nov 2026 19:39:17 +0100 Subject: [PATCH 13/52] feat(uniffi): export SyncClient and its foreign traits Co-Authored-By: Claude Opus 5.5 --- rust/Cargo.lock | 4 + rust/crates/keygo-uniffi/Cargo.toml | 8 + rust/crates/keygo-uniffi/src/lib.rs | 1 + rust/crates/keygo-uniffi/src/sync.rs | 703 ++++++++++++++++++++++++++ rust/crates/keygo-uniffi/src/types.rs | 10 +- 5 files changed, 725 insertions(+), 1 deletion(-) create mode 100644 rust/crates/keygo-uniffi/src/sync.rs diff --git a/rust/Cargo.lock b/rust/Cargo.lock index 1078c51e1..02ddc84c3 100644 --- a/rust/Cargo.lock +++ b/rust/Cargo.lock @@ -1753,11 +1753,15 @@ dependencies = [ name = "keygo-uniffi" version = "0.1.0" dependencies = [ + "async-trait", + "keygo-api", "keygo-client", "thiserror", "tokio", "uniffi", + "url", "uuid", + "zeroize", ] [[package]] diff --git a/rust/crates/keygo-uniffi/Cargo.toml b/rust/crates/keygo-uniffi/Cargo.toml index 3c385a069..3139ff564 100644 --- a/rust/crates/keygo-uniffi/Cargo.toml +++ b/rust/crates/keygo-uniffi/Cargo.toml @@ -8,9 +8,17 @@ name = "keygo_bindings" crate-type = ["cdylib"] [dependencies] +keygo-api = { path = "../keygo-api" } keygo-client = { path = "../keygo-client" } thiserror.workspace = true uuid.workspace = true +zeroize.workspace = true +async-trait = "0.1.89" tokio = { workspace = true, features = ["rt", "rt-multi-thread"] } uniffi = { workspace = true, features = ["tokio"] } +url = "2.5.8" + +[dev-dependencies] +keygo-client = { path = "../keygo-client", features = ["test-support"] } +tokio = { workspace = true, features = ["macros", "sync", "time"] } diff --git a/rust/crates/keygo-uniffi/src/lib.rs b/rust/crates/keygo-uniffi/src/lib.rs index f82cb37a7..dcb181d56 100644 --- a/rust/crates/keygo-uniffi/src/lib.rs +++ b/rust/crates/keygo-uniffi/src/lib.rs @@ -4,6 +4,7 @@ mod card; mod item; mod key_wrap; mod passkey; +mod sync; mod totp; mod types; mod vault; diff --git a/rust/crates/keygo-uniffi/src/sync.rs b/rust/crates/keygo-uniffi/src/sync.rs new file mode 100644 index 000000000..dd4d7e1a7 --- /dev/null +++ b/rust/crates/keygo-uniffi/src/sync.rs @@ -0,0 +1,703 @@ +use crate::ark_session::ArkSession; +use async_trait::async_trait; +use keygo_api::domain::{AppVersion, Device, DeviceInfo, DeviceName, Platform}; +use keygo_api::meta::ServerInfo; +use keygo_client::crypto::{DeviceId, UserId}; +use keygo_client::sync::{ + Account as CoreAccount, DpopKey as CoreDpopKey, Header, HttpRequest as CoreHttpRequest, + HttpResponse as CoreHttpResponse, SignError as CoreSignError, + StoredSession as CoreStoredSession, SyncClient as CoreSyncClient, SyncError as CoreSyncError, + SyncResult, TokenStore as CoreTokenStore, TokenStoreError as CoreTokenStoreError, + Transport as CoreTransport, TransportError as CoreTransportError, +}; +use std::fmt::Display; +use std::sync::Arc; +use url::Url; +use zeroize::Zeroizing; + +#[derive(Debug, thiserror::Error, uniffi::Error)] +pub enum SyncError { + #[error("invalid credentials")] + InvalidCredentials, + #[error("invalid username")] + InvalidUsername, + #[error("username taken")] + UsernameTaken, + #[error("invite required")] + InviteRequired, + #[error("invite invalid")] + InviteInvalid, + #[error("fresh authentication required")] + FreshAuthRequired, + /// `reason` is the wire value: `replaced`, `reuse_detected` or `logout`. + #[error("signed out")] + SignedOut { reason: Option }, + #[error("rate limited")] + RateLimited, + #[error("network error: {reason}")] + Network { reason: String }, + #[error("server error {code}: {reason}")] + Server { code: String, reason: String }, + #[error("client error: {reason}")] + Client { reason: String }, +} + +impl From for SyncError { + fn from(value: CoreSyncError) -> Self { + match value { + CoreSyncError::InvalidCredentials => Self::InvalidCredentials, + CoreSyncError::InvalidUsername => Self::InvalidUsername, + CoreSyncError::UsernameTaken => Self::UsernameTaken, + CoreSyncError::InviteRequired => Self::InviteRequired, + CoreSyncError::InviteInvalid => Self::InviteInvalid, + CoreSyncError::FreshAuthRequired => Self::FreshAuthRequired, + CoreSyncError::SignedOut { reason } => Self::SignedOut { + reason: reason.map(|r| r.as_str().to_owned()), + }, + CoreSyncError::RateLimited => Self::RateLimited, + CoreSyncError::Network { message } => Self::Network { reason: message }, + CoreSyncError::Server { code, message } => Self::Server { + code, + reason: message, + }, + CoreSyncError::Client { message } => Self::Client { reason: message }, + } + } +} + +#[derive(Debug, thiserror::Error, uniffi::Error)] +pub enum TransportError { + #[error("{reason}")] + Failed { reason: String }, +} + +impl From for TransportError { + fn from(error: uniffi::UnexpectedUniFFICallbackError) -> Self { + Self::Failed { + reason: error.reason, + } + } +} + +impl From for CoreTransportError { + fn from(error: TransportError) -> Self { + let TransportError::Failed { reason } = error; + Self { message: reason } + } +} + +#[derive(Debug, thiserror::Error, uniffi::Error)] +pub enum SignError { + #[error("{reason}")] + Failed { reason: String }, +} + +impl From for SignError { + fn from(error: uniffi::UnexpectedUniFFICallbackError) -> Self { + Self::Failed { + reason: error.reason, + } + } +} + +impl From for CoreSignError { + fn from(error: SignError) -> Self { + let SignError::Failed { reason } = error; + Self { message: reason } + } +} + +#[derive(Debug, thiserror::Error, uniffi::Error)] +pub enum TokenStoreError { + #[error("{reason}")] + Failed { reason: String }, +} + +impl From for TokenStoreError { + fn from(error: uniffi::UnexpectedUniFFICallbackError) -> Self { + Self::Failed { + reason: error.reason, + } + } +} + +impl From for CoreTokenStoreError { + fn from(error: TokenStoreError) -> Self { + let TokenStoreError::Failed { reason } = error; + Self { message: reason } + } +} + +#[uniffi::remote(Record)] +pub struct Header { + pub name: String, + pub value: String, +} + +#[derive(uniffi::Record)] +pub struct HttpRequest { + pub method: String, + pub url: String, + pub headers: Vec
, + pub body: Vec, +} + +impl From for HttpRequest { + fn from(request: CoreHttpRequest) -> Self { + Self { + method: request.method.as_str().to_owned(), + url: request.url, + headers: request.headers, + body: request.body, + } + } +} + +#[derive(uniffi::Record)] +pub struct HttpResponse { + pub status: u16, + pub headers: Vec
, + pub body: Vec, +} + +impl From for CoreHttpResponse { + fn from(response: HttpResponse) -> Self { + Self { + status: response.status, + headers: response.headers, + body: response.body, + } + } +} + +#[derive(uniffi::Record)] +pub struct StoredSession { + pub device_id: DeviceId, + pub refresh_token: String, + pub refresh_expires_at: u64, +} + +impl From for StoredSession { + fn from(session: CoreStoredSession) -> Self { + Self { + device_id: session.device_id, + refresh_token: session.refresh_token.expose_encoded().to_string(), + refresh_expires_at: session.refresh_expires_at, + } + } +} + +#[derive(uniffi::Record)] +pub struct DeviceDetails { + pub name: String, + pub app_version: String, +} + +impl DeviceDetails { + fn into_core(self) -> Result { + Ok(DeviceInfo { + name: DeviceName::parse(&self.name).map_err(invalid_device)?, + platform: Platform::Android, + app_version: AppVersion::parse(&self.app_version).map_err(invalid_device)?, + }) + } +} + +fn invalid_device(error: impl Display) -> SyncError { + SyncError::Client { + reason: format!("invalid device details: {error}"), + } +} + +#[derive(uniffi::Record)] +pub struct SyncDevice { + pub id: DeviceId, + pub name: String, + pub platform: String, + pub app_version: String, + pub created_at: u64, + pub last_seen_at: u64, + pub auth_time: Option, + pub logged_in: bool, +} + +impl From for SyncDevice { + fn from(device: Device) -> Self { + Self { + id: device.id, + name: device.info.name.as_str().to_owned(), + platform: device.info.platform.as_str().to_owned(), + app_version: device.info.app_version.as_str().to_owned(), + created_at: device.created_at, + last_seen_at: device.last_seen_at, + auth_time: device.auth_time, + logged_in: device.logged_in, + } + } +} + +#[uniffi::remote(Record)] +pub struct ServerInfo { + pub version: String, + pub public_url: String, + pub allow_signups: bool, +} + +#[derive(uniffi::Record)] +pub struct Account { + pub user_id: UserId, + pub username: String, + pub device_id: DeviceId, +} + +impl From for Account { + fn from(account: CoreAccount) -> Self { + Self { + user_id: account.user_id, + username: account.username.as_str().to_owned(), + device_id: account.device_id, + } + } +} + +/// Sends one HTTP request. The host owns TLS, timeouts and connection pooling; it must not retry, +/// follow auth challenges or log bodies. +#[uniffi::export(with_foreign)] +#[async_trait] +pub trait HttpTransport: Send + Sync { + async fn send(&self, request: HttpRequest) -> Result; +} + +/// A hardware-backed P-256 key held by the host. +#[uniffi::export(with_foreign)] +pub trait DpopKey: Send + Sync { + /// The 65-byte uncompressed P-256 point. + fn public_key(&self) -> Vec; + /// SHA256withECDSA over `message`, DER encoded. + fn sign(&self, message: Vec) -> Result, SignError>; +} + +/// Durable home of the refresh token. The host decides how it is protected. +#[uniffi::export(with_foreign)] +#[async_trait] +pub trait TokenStore: Send + Sync { + async fn load(&self) -> Result, TokenStoreError>; + async fn save(&self, session: StoredSession) -> Result<(), TokenStoreError>; + async fn clear(&self) -> Result<(), TokenStoreError>; +} + +struct TransportAdapter(Arc); + +#[async_trait] +impl CoreTransport for TransportAdapter { + async fn send(&self, request: CoreHttpRequest) -> Result { + Ok(self.0.send(request.into()).await?.into()) + } +} + +struct KeyAdapter(Arc); + +impl CoreDpopKey for KeyAdapter { + fn public_key(&self) -> Vec { + self.0.public_key() + } + + fn sign(&self, message: Vec) -> Result, CoreSignError> { + Ok(self.0.sign(message)?) + } +} + +struct StoreAdapter(Arc); + +#[async_trait] +impl CoreTokenStore for StoreAdapter { + /// A token that no longer parses counts as no session, so the user just signs in again. + async fn load(&self) -> Result, CoreTokenStoreError> { + let Some(stored) = self.0.load().await? else { + return Ok(None); + }; + let refresh_token = Zeroizing::new(stored.refresh_token); + Ok(refresh_token + .parse() + .ok() + .map(|refresh_token| CoreStoredSession { + device_id: stored.device_id, + refresh_token, + refresh_expires_at: stored.refresh_expires_at, + })) + } + + async fn save(&self, session: CoreStoredSession) -> Result<(), CoreTokenStoreError> { + Ok(self.0.save(session.into()).await?) + } + + async fn clear(&self) -> Result<(), CoreTokenStoreError> { + Ok(self.0.clear().await?) + } +} + +/// Runs `call` as its own task and waits for it. Dropping the returned future only stops the +/// waiting, and a panic in the task ends at the `JoinError` instead of crossing the FFI. +async fn detached(call: C) -> Result +where + T: Send + 'static, + C: Future> + Send + 'static, +{ + tokio::spawn(call) + .await + .map_err(|_| SyncError::Client { + reason: "the sync task did not finish".into(), + })? + .map_err(Into::into) +} + +/// The sync client, over the host's HTTP stack, DPoP key and token store. +/// +/// Every call runs as its own task, so cancelling the coroutine waiting for one leaves it running. +/// Refresh tokens rotate with no grace window: abandoning a refresh the server has committed would +/// lose the new token, and the next refresh would revoke the session as `reuse_detected`. +#[derive(uniffi::Object)] +pub struct SyncClient { + inner: Arc, +} + +#[uniffi::export(async_runtime = "tokio")] +impl SyncClient { + #[uniffi::constructor] + pub fn new( + base_url: String, + transport: Arc, + dpop_key: Arc, + tokens: Arc, + ) -> Result, SyncError> { + let base_url = Url::parse(&base_url).map_err(|e| SyncError::Client { + reason: format!("invalid server url: {e}"), + })?; + let inner = CoreSyncClient::new( + base_url, + Arc::new(TransportAdapter(transport)), + Arc::new(KeyAdapter(dpop_key)), + Arc::new(StoreAdapter(tokens)), + )?; + Ok(Arc::new(Self { + inner: Arc::new(inner), + })) + } + + pub async fn meta(&self) -> Result { + let client = self.inner.clone(); + detached(async move { client.meta().await }).await + } + + pub async fn register( + &self, + ark: Arc, + user_id: UserId, + username: String, + password: String, + invite: Option, + device: DeviceDetails, + ) -> Result { + let password = Zeroizing::new(password); + let device = device.into_core()?; + let client = self.inner.clone(); + let account = detached(async move { + client + .register( + &ark.session, + user_id, + &username, + &password, + invite.as_deref(), + device, + ) + .await + }) + .await?; + Ok(account.into()) + } + + pub async fn login( + &self, + ark: Arc, + username: String, + password: String, + device: DeviceDetails, + ) -> Result { + let password = Zeroizing::new(password); + let device = device.into_core()?; + let client = self.inner.clone(); + let account = detached(async move { + client + .login(&ark.session, &username, &password, device) + .await + }) + .await?; + Ok(account.into()) + } + + pub async fn step_up(&self, password: String) -> Result<(), SyncError> { + let password = Zeroizing::new(password); + let client = self.inner.clone(); + detached(async move { client.step_up(&password).await }).await + } + + pub async fn devices(&self) -> Result, SyncError> { + let client = self.inner.clone(); + let devices = detached(async move { client.devices().await }).await?; + Ok(devices.into_iter().map(SyncDevice::from).collect()) + } + + pub async fn delete_device(&self, id: DeviceId) -> Result<(), SyncError> { + let client = self.inner.clone(); + detached(async move { client.delete_device(id).await }).await + } + + pub async fn logout(&self) -> Result<(), SyncError> { + let client = self.inner.clone(); + detached(async move { client.logout().await }).await + } +} + +#[cfg(test)] +mod tests { + use super::*; + use keygo_api::Method; + use keygo_api::domain::RevokeReason; + use keygo_client::sync::testing::FakeDpopKey; + use std::sync::Mutex; + use std::time::Duration; + use tokio::sync::Notify; + use tokio::time::timeout; + + /// Decodes to 32 bytes of `0xff`. + const STORED_TOKEN: &str = "kgr___________________________________________8"; + /// Decodes to 32 bytes of zero: what the server rotates [`STORED_TOKEN`] to. + const ROTATED_TOKEN: &str = "kgr_AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"; + const ROTATED_SESSION: &str = r#"{"device_id":"00000000-0000-0000-0000-000000000001","access_token":"a.b.c","access_expires_in":300,"refresh_token":"kgr_AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA","refresh_expires_in":86400}"#; + + #[derive(Default)] + struct MemoryStore { + session: Mutex>, + saved: Notify, + } + + impl MemoryStore { + fn holding(refresh_token: &str) -> Arc { + Arc::new(Self { + session: Mutex::new(Some(StoredSession { + device_id: DeviceId::random(), + refresh_token: refresh_token.into(), + refresh_expires_at: u64::MAX, + })), + saved: Notify::new(), + }) + } + + fn refresh_token(&self) -> Option { + let session = self.session.lock().unwrap(); + session.as_ref().map(|s| s.refresh_token.clone()) + } + } + + #[async_trait] + impl TokenStore for MemoryStore { + async fn load(&self) -> Result, TokenStoreError> { + let session = self.session.lock().unwrap(); + Ok(session.as_ref().map(|s| StoredSession { + device_id: s.device_id, + refresh_token: s.refresh_token.clone(), + refresh_expires_at: s.refresh_expires_at, + })) + } + + async fn save(&self, session: StoredSession) -> Result<(), TokenStoreError> { + *self.session.lock().unwrap() = Some(session); + self.saved.notify_one(); + Ok(()) + } + + async fn clear(&self) -> Result<(), TokenStoreError> { + *self.session.lock().unwrap() = None; + Ok(()) + } + } + + struct PanickingStore; + + #[async_trait] + impl TokenStore for PanickingStore { + async fn load(&self) -> Result, TokenStoreError> { + panic!("the store blew up") + } + + async fn save(&self, _: StoredSession) -> Result<(), TokenStoreError> { + unreachable!() + } + + async fn clear(&self) -> Result<(), TokenStoreError> { + unreachable!() + } + } + + #[derive(Default)] + struct RecordingTransport { + methods: Mutex>, + } + + #[async_trait] + impl HttpTransport for RecordingTransport { + async fn send(&self, request: HttpRequest) -> Result { + self.methods.lock().unwrap().push(request.method); + Ok(HttpResponse { + status: 204, + headers: Vec::new(), + body: Vec::new(), + }) + } + } + + /// Announces each request and holds it until released, then answers with a rotated session. + #[derive(Default)] + struct GatedTransport { + reached: Notify, + release: Notify, + } + + #[async_trait] + impl HttpTransport for GatedTransport { + async fn send(&self, _: HttpRequest) -> Result { + self.reached.notify_one(); + self.release.notified().await; + Ok(HttpResponse { + status: 200, + headers: Vec::new(), + body: ROTATED_SESSION.as_bytes().to_vec(), + }) + } + } + + struct TestKey(FakeDpopKey); + + impl DpopKey for TestKey { + fn public_key(&self) -> Vec { + CoreDpopKey::public_key(&self.0) + } + + fn sign(&self, message: Vec) -> Result, SignError> { + CoreDpopKey::sign(&self.0, message).map_err(|e| SignError::Failed { reason: e.message }) + } + } + + fn client(transport: Arc, tokens: Arc) -> Arc { + SyncClient::new( + "https://kg.example".into(), + transport, + Arc::new(TestKey(FakeDpopKey::new())), + tokens, + ) + .unwrap() + } + + #[tokio::test] + async fn corrupt_refresh_token_loads_as_no_session() { + let adapter = StoreAdapter(MemoryStore::holding("garbage")); + + assert!(adapter.load().await.unwrap().is_none()); + } + + #[tokio::test] + async fn stored_session_round_trips_through_the_adapter() { + let adapter = StoreAdapter(Arc::new(MemoryStore::default())); + let device_id = DeviceId::random(); + + adapter + .save(CoreStoredSession { + device_id, + refresh_token: STORED_TOKEN.parse().unwrap(), + refresh_expires_at: 99, + }) + .await + .unwrap(); + let loaded = adapter.load().await.unwrap().unwrap(); + + assert_eq!(loaded.refresh_token.expose_encoded().as_str(), STORED_TOKEN); + assert_eq!(loaded.device_id, device_id); + assert_eq!(loaded.refresh_expires_at, 99); + } + + #[test] + fn signed_out_carries_the_wire_reason() { + let error = SyncError::from(CoreSyncError::SignedOut { + reason: Some(RevokeReason::ReuseDetected), + }); + + assert!(matches!( + error, + SyncError::SignedOut { reason } if reason.as_deref() == Some("reuse_detected"), + )); + } + + #[test] + fn device_details_reject_control_characters() { + let device = DeviceDetails { + name: "a\u{202e}b".into(), + app_version: "2.3.0".into(), + }; + + assert!(matches!(device.into_core(), Err(SyncError::Client { .. }),)); + } + + #[tokio::test] + async fn transport_adapter_passes_method_as_text() { + let transport = Arc::new(RecordingTransport::default()); + let adapter = TransportAdapter(transport.clone()); + + adapter + .send(CoreHttpRequest { + method: Method::Delete, + url: "https://kg.example/api/v1/devices/1".into(), + headers: Vec::new(), + body: Vec::new(), + }) + .await + .unwrap(); + + assert_eq!(*transport.methods.lock().unwrap(), ["DELETE"]); + } + + /// A Kotlin coroutine that is cancelled drops the future. The rotated refresh token must still + /// reach the store, because rotation has no grace window and losing it signs the user out. + #[tokio::test] + async fn a_dropped_call_still_finishes() { + let transport = Arc::new(GatedTransport::default()); + let store = MemoryStore::holding(STORED_TOKEN); + let client = client(transport.clone(), store.clone()); + + let mut call = Box::pin(client.devices()); + tokio::select! { + _ = &mut call => panic!("the call finished before the transport answered"), + () = transport.reached.notified() => {}, + } + drop(call); + transport.release.notify_one(); + + timeout(Duration::from_secs(5), store.saved.notified()) + .await + .expect("the dropped call never saved the rotated token"); + assert_eq!(store.refresh_token().as_deref(), Some(ROTATED_TOKEN)); + } + + #[tokio::test] + async fn a_panicking_call_is_a_client_error() { + let client = client( + Arc::new(RecordingTransport::default()), + Arc::new(PanickingStore), + ); + + assert!(matches!( + client.devices().await, + Err(SyncError::Client { .. }), + )); + } +} diff --git a/rust/crates/keygo-uniffi/src/types.rs b/rust/crates/keygo-uniffi/src/types.rs index 295acb49f..fac485ebc 100644 --- a/rust/crates/keygo-uniffi/src/types.rs +++ b/rust/crates/keygo-uniffi/src/types.rs @@ -1,4 +1,6 @@ -use keygo_client::crypto::{ItemId, ItemKey, KeyMaterial, NamespaceId, UserId, VaultId, VaultKey}; +use keygo_client::crypto::{ + DeviceId, ItemId, ItemKey, KeyMaterial, NamespaceId, UserId, VaultId, VaultKey, +}; use uuid::Uuid; uniffi::custom_type!(Uuid, String, { @@ -31,6 +33,12 @@ uniffi::custom_type!(NamespaceId, Uuid, { lower: |id| id.0, }); +uniffi::custom_type!(DeviceId, Uuid, { + remote, + try_lift: |u| Ok(DeviceId(u)), + lower: |id| id.0, +}); + uniffi::custom_type!(VaultKey, Vec, { remote, try_lift: |bytes| VaultKey::from_bytes(&bytes).map_err(|e| uniffi::deps::anyhow::anyhow!("{e}")), From 89f55360fde5de0fc96424b68e82b219f4dd1cc7 Mon Sep 17 00:00:00 2001 From: Davis Date: Mon, 9 Nov 2026 19:53:31 +0100 Subject: [PATCH 14/52] fix(uniffi): report a failing DPoP public key as a SyncError Co-Authored-By: Claude Opus 5.5 --- rust/crates/keygo-uniffi/src/sync.rs | 50 ++++++++++++++++++++++++---- 1 file changed, 43 insertions(+), 7 deletions(-) diff --git a/rust/crates/keygo-uniffi/src/sync.rs b/rust/crates/keygo-uniffi/src/sync.rs index dd4d7e1a7..8637dee24 100644 --- a/rust/crates/keygo-uniffi/src/sync.rs +++ b/rust/crates/keygo-uniffi/src/sync.rs @@ -272,7 +272,7 @@ pub trait HttpTransport: Send + Sync { #[uniffi::export(with_foreign)] pub trait DpopKey: Send + Sync { /// The 65-byte uncompressed P-256 point. - fn public_key(&self) -> Vec; + fn public_key(&self) -> Result, SignError>; /// SHA256withECDSA over `message`, DER encoded. fn sign(&self, message: Vec) -> Result, SignError>; } @@ -295,15 +295,19 @@ impl CoreTransport for TransportAdapter { } } -struct KeyAdapter(Arc); +/// Holds the public key `SyncClient::new` read, because the core trait's `public_key` cannot fail. +struct KeyAdapter { + key: Arc, + public_key: Vec, +} impl CoreDpopKey for KeyAdapter { fn public_key(&self) -> Vec { - self.0.public_key() + self.public_key.clone() } fn sign(&self, message: Vec) -> Result, CoreSignError> { - Ok(self.0.sign(message)?) + Ok(self.key.sign(message)?) } } @@ -373,10 +377,16 @@ impl SyncClient { let base_url = Url::parse(&base_url).map_err(|e| SyncError::Client { reason: format!("invalid server url: {e}"), })?; + let public_key = dpop_key.public_key().map_err(|e| SyncError::Client { + reason: format!("could not read the DPoP public key: {e}"), + })?; let inner = CoreSyncClient::new( base_url, Arc::new(TransportAdapter(transport)), - Arc::new(KeyAdapter(dpop_key)), + Arc::new(KeyAdapter { + key: dpop_key, + public_key, + }), Arc::new(StoreAdapter(tokens)), )?; Ok(Arc::new(Self { @@ -580,8 +590,8 @@ mod tests { struct TestKey(FakeDpopKey); impl DpopKey for TestKey { - fn public_key(&self) -> Vec { - CoreDpopKey::public_key(&self.0) + fn public_key(&self) -> Result, SignError> { + Ok(CoreDpopKey::public_key(&self.0)) } fn sign(&self, message: Vec) -> Result, SignError> { @@ -589,6 +599,20 @@ mod tests { } } + struct ThrowingKey; + + impl DpopKey for ThrowingKey { + fn public_key(&self) -> Result, SignError> { + Err(SignError::Failed { + reason: "the keystore is locked".into(), + }) + } + + fn sign(&self, _: Vec) -> Result, SignError> { + unreachable!() + } + } + fn client(transport: Arc, tokens: Arc) -> Arc { SyncClient::new( "https://kg.example".into(), @@ -700,4 +724,16 @@ mod tests { Err(SyncError::Client { .. }), )); } + + #[test] + fn a_throwing_public_key_is_a_client_error() { + let result = SyncClient::new( + "https://kg.example".into(), + Arc::new(RecordingTransport::default()), + Arc::new(ThrowingKey), + Arc::new(MemoryStore::default()), + ); + + assert!(matches!(result, Err(SyncError::Client { .. }))); + } } From a4203eeb1cc1978831d27b1aead555dfec40b89a Mon Sep 17 00:00:00 2001 From: Davis Date: Mon, 9 Nov 2026 19:59:01 +0100 Subject: [PATCH 15/52] feat(sync): add OkHttp transport and FakeSyncClient Co-Authored-By: Claude Opus 5.5 --- CLAUDE.md | 1 + .../de/davis/keygo/rust/FakeSyncClient.kt | 52 ++++++++ core/sync/build.gradle.kts | 18 +++ .../keygo/core/sync/data/OkHttpTransport.kt | 87 +++++++++++++ .../keygo/core/sync/di/CoreSyncModule.kt | 18 +++ .../core/sync/data/OkHttpTransportTest.kt | 120 ++++++++++++++++++ gradle/libs.versions.toml | 1 + settings.gradle.kts | 1 + 8 files changed, 298 insertions(+) create mode 100644 core/rust/src/testFixtures/kotlin/de/davis/keygo/rust/FakeSyncClient.kt create mode 100644 core/sync/build.gradle.kts create mode 100644 core/sync/src/main/kotlin/de/davis/keygo/core/sync/data/OkHttpTransport.kt create mode 100644 core/sync/src/main/kotlin/de/davis/keygo/core/sync/di/CoreSyncModule.kt create mode 100644 core/sync/src/test/kotlin/de/davis/keygo/core/sync/data/OkHttpTransportTest.kt diff --git a/CLAUDE.md b/CLAUDE.md index 68949138e..b03c7f00e 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -47,6 +47,7 @@ Android password manager using Clean Architecture per module: | `:core:identity` | Key wrapping, auth data, proto schemas (`core/identity/src/main/proto/`) | | `:core:item` | Room database, login/item entities | | `:core:ui` | Shared composables and UI utilities | +| `:core:sync` | OkHttp `HttpTransport` for the Rust `SyncClient` | | `:core:util` | Shared utilities, `Result` type | | `:feature:auth` | Auth/session flow (login gate, biometric prompt routing) | | `:feature:autofill` | Android autofill service (framework + Chrome/inline datasets) | diff --git a/core/rust/src/testFixtures/kotlin/de/davis/keygo/rust/FakeSyncClient.kt b/core/rust/src/testFixtures/kotlin/de/davis/keygo/rust/FakeSyncClient.kt new file mode 100644 index 000000000..df3e92181 --- /dev/null +++ b/core/rust/src/testFixtures/kotlin/de/davis/keygo/rust/FakeSyncClient.kt @@ -0,0 +1,52 @@ +package de.davis.keygo.rust + +import de.davisalessandro.keygo.rust.Account +import de.davisalessandro.keygo.rust.ArkSession +import de.davisalessandro.keygo.rust.DeviceDetails +import de.davisalessandro.keygo.rust.DeviceId +import de.davisalessandro.keygo.rust.ServerInfo +import de.davisalessandro.keygo.rust.SyncClientInterface +import de.davisalessandro.keygo.rust.SyncDevice +import de.davisalessandro.keygo.rust.UserId + +/** + * Each method returns its result var, or throws it when it is a failure. Results without a useful + * default stay null until a test sets them, and reading one then fails loudly. + */ +class FakeSyncClient : SyncClientInterface { + + var deleteDeviceResult: Result = Result.success(Unit) + var devicesResult: Result> = Result.success(emptyList()) + var loginResult: Result? = null + var logoutResult: Result = Result.success(Unit) + var metaResult: Result? = null + var registerResult: Result? = null + var stepUpResult: Result = Result.success(Unit) + + override suspend fun deleteDevice(id: DeviceId) = deleteDeviceResult.getOrThrow() + + override suspend fun devices(): List = devicesResult.getOrThrow() + + override suspend fun login( + ark: ArkSession, + username: String, + password: String, + device: DeviceDetails, + ): Account = checkNotNull(loginResult) { "loginResult not set" }.getOrThrow() + + override suspend fun logout() = logoutResult.getOrThrow() + + override suspend fun meta(): ServerInfo = + checkNotNull(metaResult) { "metaResult not set" }.getOrThrow() + + override suspend fun register( + ark: ArkSession, + userId: UserId, + username: String, + password: String, + invite: String?, + device: DeviceDetails, + ): Account = checkNotNull(registerResult) { "registerResult not set" }.getOrThrow() + + override suspend fun stepUp(password: String) = stepUpResult.getOrThrow() +} diff --git a/core/sync/build.gradle.kts b/core/sync/build.gradle.kts new file mode 100644 index 000000000..033447896 --- /dev/null +++ b/core/sync/build.gradle.kts @@ -0,0 +1,18 @@ +plugins { + alias(libs.plugins.keygo.android.library) +} + +android { + namespace = "de.davis.keygo.core.sync" +} + +dependencies { + api(projects.core.rust) + + implementation(libs.okhttp) + implementation(libs.kotlinx.coroutines.core) + + testImplementation(libs.okhttp.jvm) + testImplementation(libs.okhttp.mockwebserver) + testImplementation(testFixtures(projects.core.rust)) +} diff --git a/core/sync/src/main/kotlin/de/davis/keygo/core/sync/data/OkHttpTransport.kt b/core/sync/src/main/kotlin/de/davis/keygo/core/sync/data/OkHttpTransport.kt new file mode 100644 index 000000000..fa65b7aae --- /dev/null +++ b/core/sync/src/main/kotlin/de/davis/keygo/core/sync/data/OkHttpTransport.kt @@ -0,0 +1,87 @@ +package de.davis.keygo.core.sync.data + +import de.davisalessandro.keygo.rust.Header +import de.davisalessandro.keygo.rust.HttpRequest +import de.davisalessandro.keygo.rust.HttpResponse +import de.davisalessandro.keygo.rust.HttpTransport +import de.davisalessandro.keygo.rust.TransportException +import kotlinx.coroutines.suspendCancellableCoroutine +import okhttp3.Call +import okhttp3.Callback +import okhttp3.OkHttpClient +import okhttp3.Request +import okhttp3.RequestBody.Companion.toRequestBody +import okhttp3.Response +import okhttp3.internal.http.HttpMethod +import java.io.IOException +import java.util.concurrent.TimeUnit +import kotlin.coroutines.resume +import kotlin.coroutines.resumeWithException + +/** + * Sends the requests the Rust sync client builds. Headers, auth included, pass through untouched. + * Never log [HttpRequest] or [HttpResponse]: their `toString()` prints tokens. + */ +class OkHttpTransport(client: OkHttpClient) : HttpTransport { + + // A DPoP proof is bound to one URL, so a redirect could not succeed anyway. + private val client = client.newBuilder() + .retryOnConnectionFailure(false) + .followRedirects(false) + .followSslRedirects(false) + .callTimeout(CALL_TIMEOUT_SECONDS, TimeUnit.SECONDS) + .build() + + override suspend fun send(request: HttpRequest): HttpResponse { + val okRequest = try { + request.toOkHttp() + } catch (e: IllegalArgumentException) { + throw e.toTransportException() + } + + return suspendCancellableCoroutine { continuation -> + val call = client.newCall(okRequest) + continuation.invokeOnCancellation { call.cancel() } + call.enqueue(object : Callback { + override fun onFailure(call: Call, e: IOException) { + continuation.resumeWithException(e.toTransportException()) + } + + override fun onResponse(call: Call, response: Response) { + val result = try { + response.use { it.toRust() } + } catch (e: IOException) { + continuation.resumeWithException(e.toTransportException()) + return + } + continuation.resume(result) + } + }) + } + } + + private fun HttpRequest.toOkHttp(): Request { + val requestBody = + if (body.isEmpty() && !HttpMethod.requiresRequestBody(method)) null + else body.toRequestBody(null) + + return Request.Builder() + .url(url) + .apply { headers.forEach { addHeader(it.name, it.value) } } + .method(method, requestBody) + .build() + } + + private fun Response.toRust() = HttpResponse( + status = code.toUShort(), + headers = headers.map { (name, value) -> Header(name = name, value = value) }, + body = body.bytes(), + ) + + private fun Exception.toTransportException() = + TransportException.Failed(reason = message ?: this::class.java.simpleName) + + private companion object { + const val CALL_TIMEOUT_SECONDS = 30L + } +} diff --git a/core/sync/src/main/kotlin/de/davis/keygo/core/sync/di/CoreSyncModule.kt b/core/sync/src/main/kotlin/de/davis/keygo/core/sync/di/CoreSyncModule.kt new file mode 100644 index 000000000..ff450012b --- /dev/null +++ b/core/sync/src/main/kotlin/de/davis/keygo/core/sync/di/CoreSyncModule.kt @@ -0,0 +1,18 @@ +package de.davis.keygo.core.sync.di + +import de.davis.keygo.core.sync.data.OkHttpTransport +import de.davisalessandro.keygo.rust.HttpTransport +import okhttp3.OkHttpClient +import org.koin.core.annotation.ComponentScan +import org.koin.core.annotation.Configuration +import org.koin.core.annotation.Module +import org.koin.core.annotation.Single + +@Module +@Configuration +@ComponentScan("de.davis.keygo.core.sync") +object CoreSyncModule { + + @Single + internal fun provideHttpTransport(): HttpTransport = OkHttpTransport(OkHttpClient()) +} diff --git a/core/sync/src/test/kotlin/de/davis/keygo/core/sync/data/OkHttpTransportTest.kt b/core/sync/src/test/kotlin/de/davis/keygo/core/sync/data/OkHttpTransportTest.kt new file mode 100644 index 000000000..f41c4d023 --- /dev/null +++ b/core/sync/src/test/kotlin/de/davis/keygo/core/sync/data/OkHttpTransportTest.kt @@ -0,0 +1,120 @@ +package de.davis.keygo.core.sync.data + +import de.davisalessandro.keygo.rust.Header +import de.davisalessandro.keygo.rust.HttpRequest +import de.davisalessandro.keygo.rust.TransportException +import kotlinx.coroutines.test.runTest +import mockwebserver3.MockResponse +import mockwebserver3.MockWebServer +import mockwebserver3.SocketEffect +import okhttp3.OkHttpClient +import kotlin.test.AfterTest +import kotlin.test.BeforeTest +import kotlin.test.Test +import kotlin.test.assertContentEquals +import kotlin.test.assertEquals +import kotlin.test.assertFailsWith + +class OkHttpTransportTest { + + private val server = MockWebServer() + private val transport = OkHttpTransport(OkHttpClient()) + + @BeforeTest + fun setUp() = server.start() + + @AfterTest + fun tearDown() = server.close() + + private fun request( + method: String, + body: ByteArray = byteArrayOf(), + headers: List
= emptyList(), + ) = HttpRequest( + method = method, + url = server.url("/api").toString(), + headers = headers, + body = body, + ) + + @Test + fun round_trips_method_headers_and_body_bytes() = runTest { + val payload = byteArrayOf(0, 1, 2, -1, -128, 127) + server.enqueue( + MockResponse.Builder() + .code(201) + .addHeader("x-reply", "yes") + .body(okio.Buffer().write(payload)) + .build(), + ) + + val response = transport.send( + request("POST", payload, listOf(Header(name = "dpop", value = "proof"))), + ) + + val recorded = server.takeRequest() + assertEquals("POST", recorded.method) + assertEquals("proof", recorded.headers["dpop"]) + assertContentEquals(payload, recorded.body!!.toByteArray()) + assertEquals(201.toUShort(), response.status) + assertEquals("yes", response.headers.first { it.name.equals("x-reply", true) }.value) + assertContentEquals(payload, response.body) + } + + @Test + fun post_with_empty_body_is_sent() = runTest { + server.enqueue(MockResponse.Builder().build()) + + transport.send(request("POST")) + + val recorded = server.takeRequest() + assertEquals("POST", recorded.method) + assertEquals(0, recorded.bodySize) + } + + @Test + fun get_sends_no_body() = runTest { + server.enqueue(MockResponse.Builder().build()) + + transport.send(request("GET")) + + val recorded = server.takeRequest() + assertEquals("GET", recorded.method) + assertEquals(0, recorded.bodySize) + } + + @Test + fun does_not_retry_after_a_connection_failure() = runTest { + server.enqueue( + MockResponse.Builder() + .onResponseStart(SocketEffect.CloseSocket()) + .build(), + ) + + assertFailsWith { transport.send(request("GET")) } + assertEquals(1, server.requestCount) + } + + @Test + fun does_not_follow_redirects() = runTest { + server.enqueue( + MockResponse.Builder() + .code(302) + .addHeader("Location", server.url("/elsewhere").toString()) + .build(), + ) + + val response = transport.send(request("GET")) + + assertEquals(302.toUShort(), response.status) + assertEquals(1, server.requestCount) + } + + @Test + fun io_failure_throws_transport_exception() = runTest { + val unreachable = request("GET") + server.close() + + assertFailsWith { transport.send(unreachable) } + } +} diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index 78d29ed35..d2b50af69 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -115,6 +115,7 @@ squareup-kotlinpoet = { group = "com.squareup", name = "kotlinpoet-ksp", version okhttp = { group = "com.squareup.okhttp3", name = "okhttp", version.ref = "okhttp" } okhttp-jvm = { group = "com.squareup.okhttp3", name = "okhttp-jvm", version.ref = "okhttp" } +okhttp-mockwebserver = { group = "com.squareup.okhttp3", name = "mockwebserver3", version.ref = "okhttp" } gosimple-nbvcxz = { group = "me.gosimple", name = "nbvcxz", version.ref = "nbvcxz" } diff --git a/settings.gradle.kts b/settings.gradle.kts index 82d2505ab..a713d6c9e 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -37,6 +37,7 @@ include(":core:security") include(":core:biometrics") include(":core:ui") include(":core:rust") +include(":core:sync") include(":feature:credentials") include(":feature:list_screen") include(":feature:item:core") From dbbf1ef374018ec1e1ef87d405ba47005cfc2358 Mon Sep 17 00:00:00 2001 From: Davis Date: Mon, 9 Nov 2026 20:18:26 +0100 Subject: [PATCH 16/52] fix(client): build the crate's tests without the server feature Build the state test's token through serde, enable tokio/rt under test-support, zeroize sha2 in keygo-api itself, move the reset doc onto reset(), add core/sync/consumer-rules.pro, and cover the real client's logout against the real router. Co-Authored-By: Claude Opus 5.5 --- core/sync/consumer-rules.pro | 0 rust/crates/keygo-api/Cargo.toml | 2 +- rust/crates/keygo-client/Cargo.toml | 2 +- rust/crates/keygo-client/src/sync/state.rs | 6 +++--- rust/crates/keygo-e2e/tests/sync.rs | 18 ++++++++++++++++++ 5 files changed, 23 insertions(+), 5 deletions(-) create mode 100644 core/sync/consumer-rules.pro diff --git a/core/sync/consumer-rules.pro b/core/sync/consumer-rules.pro new file mode 100644 index 000000000..e69de29bb diff --git a/rust/crates/keygo-api/Cargo.toml b/rust/crates/keygo-api/Cargo.toml index 7ba2d94d4..5549f424b 100644 --- a/rust/crates/keygo-api/Cargo.toml +++ b/rust/crates/keygo-api/Cargo.toml @@ -16,7 +16,7 @@ thiserror.workspace = true uuid.workspace = true base64.workspace = true getrandom = { workspace = true, optional = true } -sha2 = { workspace = true, optional = true } +sha2 = { workspace = true, optional = true, features = ["zeroize"] } zeroize = { workspace = true, features = ["derive"] } unicode-normalization = "0.1.25" unicode-properties = { version = "0.1.4", default-features = false, features = ["general-category"] } diff --git a/rust/crates/keygo-client/Cargo.toml b/rust/crates/keygo-client/Cargo.toml index dc0d1a2ad..b66ade11c 100644 --- a/rust/crates/keygo-client/Cargo.toml +++ b/rust/crates/keygo-client/Cargo.toml @@ -5,7 +5,7 @@ edition.workspace = true [features] # Exposes `sync::testing` (fake transport, token store, key and clock) to other crates' tests. -test-support = ["keygo-dpop/test-support"] +test-support = ["keygo-dpop/test-support", "tokio/rt"] [dependencies] keygo-core = { path = "../keygo-core", features = ["crypto"] } diff --git a/rust/crates/keygo-client/src/sync/state.rs b/rust/crates/keygo-client/src/sync/state.rs index c3856b94f..50fb9991b 100644 --- a/rust/crates/keygo-client/src/sync/state.rs +++ b/rust/crates/keygo-client/src/sync/state.rs @@ -19,8 +19,6 @@ pub(super) struct AuthState { } impl AuthState { - /// Forgets the session. `generation` moves on rather than restarting, so a call still holding - /// a token from before cannot mistake a later one for its own. pub(super) fn access(&self) -> Option<&AccessState> { self.access.as_ref() } @@ -31,6 +29,8 @@ impl AuthState { self.generation += 1; } + /// Forgets the session. `generation` moves on rather than restarting, so a call still holding + /// a token from before cannot mistake a later one for its own. pub(super) fn reset(&mut self) { self.access = None; self.nonce = None; @@ -62,7 +62,7 @@ mod tests { let mut state = AuthState::default(); let before = state.generation; state.replace_access(AccessState { - token: AccessToken::from_signed("a.b.c".into()), + token: serde_json::from_value(serde_json::json!("a.b.c")).unwrap(), expires_at: 1, }); assert_eq!(state.generation, before + 1); diff --git a/rust/crates/keygo-e2e/tests/sync.rs b/rust/crates/keygo-e2e/tests/sync.rs index dfbc0b919..ee228ac34 100644 --- a/rust/crates/keygo-e2e/tests/sync.rs +++ b/rust/crates/keygo-e2e/tests/sync.rs @@ -237,3 +237,21 @@ async fn empty_step_up_password_is_invalid_credentials(db: PgPool) { SyncError::InvalidCredentials, ); } + +#[sqlx::test(migrations = "../keygo-server/migrations")] +async fn client_logout_ends_the_session_on_the_server(db: PgPool) { + let h = harness(&db).await; + + h.client.logout().await.unwrap(); + assert_eq!(h.store.current_refresh_token(), None); + + let (status, _) = testing::post_with_token( + &h.state, + &h.prover, + "/api/v1/auth/logout", + &h.access_token, + serde_json::Value::Null, + ) + .await; + assert!(!status.is_success(), "{status}"); +} From 28ce90abef8395eabe22b810558f68b5a3bd32a0 Mon Sep 17 00:00:00 2001 From: Davis Date: Mon, 9 Nov 2026 20:32:28 +0100 Subject: [PATCH 17/52] fix(client): keep a rotated token the store refused A failed save dropped the new refresh token while the store still held the spent one, so the next refresh tripped reuse detection and signed the user out over a transient disk error. Following section 10 of the auth spec, the rotated session now stays in AuthState and wins over the store until a save succeeds, and each authenticated call writes it again. The call that hit the failure succeeds on the new token. Co-Authored-By: Claude Opus 5.5 --- rust/crates/keygo-client/src/sync/pipeline.rs | 131 ++++++++++++++---- rust/crates/keygo-client/src/sync/state.rs | 5 + rust/crates/keygo-client/src/sync/testing.rs | 4 + rust/crates/keygo-client/src/sync/tokens.rs | 15 ++ rust/crates/keygo-e2e/tests/sync.rs | 12 ++ 5 files changed, 137 insertions(+), 30 deletions(-) diff --git a/rust/crates/keygo-client/src/sync/pipeline.rs b/rust/crates/keygo-client/src/sync/pipeline.rs index 925b9b94e..103a28402 100644 --- a/rust/crates/keygo-client/src/sync/pipeline.rs +++ b/rust/crates/keygo-client/src/sync/pipeline.rs @@ -182,24 +182,37 @@ impl SyncClient { self.tokens.clear().await } - /// Spends the stored refresh token on a new session and returns the new access token. `state` + /// Writes a rotated session the store refused. Another refusal is not the caller's failure: + /// the copy in `state` stays the live one, and the next call writes it again. + async fn flush_unsaved(&self, state: &mut AuthState) { + let Some(unsaved) = &state.unsaved else { + return; + }; + if self.tokens.save(unsaved.duplicate()).await.is_ok() { + state.unsaved = None; + } + } + + /// Spends the live refresh token on a new session and returns the new access token. `state` /// is the locked `AuthState`, held for the whole refresh so concurrent callers share its /// result. It goes straight to `exchange`, because `call` would take the lock again. /// - /// The rotated token is saved before the access token is kept. Nothing is kept if that save - /// fails, or if the caller is dropped before it returns: `access` and `generation` change - /// only after the last `await`. + /// The rotated session goes into `state` before it is written, so neither a refused save nor + /// a caller dropped during the write can lose the only copy of the live token. async fn refresh_locked(&self, state: &mut AuthState) -> SyncResult> { - let stored = self - .tokens - .load() - .await - .map_err(store_failure)? - .ok_or(SyncError::SignedOut { reason: None })?; - - let request = TokenRequest { - refresh_token: stored.refresh_token, + let refresh_token = match &state.unsaved { + Some(unsaved) => unsaved.duplicate().refresh_token, + None => { + self.tokens + .load() + .await + .map_err(store_failure)? + .ok_or(SyncError::SignedOut { reason: None })? + .refresh_token + } }; + + let request = TokenRequest { refresh_token }; // Not `encode_body`: this body is a secret and should not linger in a `Value`. let body = Zeroizing::new(serde_json::to_vec(&request).map_err(|e| SyncError::Client { message: format!("request does not serialize: {e}"), @@ -229,14 +242,12 @@ impl SyncClient { let body = Zeroizing::new(response.body); let session: Session = decode_body(&body)?; - self.tokens - .save(StoredSession { - device_id: session.device_id, - refresh_token: session.refresh_token, - refresh_expires_at: now.saturating_add(session.refresh_expires_in), - }) - .await - .map_err(store_failure)?; + state.unsaved = Some(StoredSession { + device_id: session.device_id, + refresh_token: session.refresh_token, + refresh_expires_at: now.saturating_add(session.refresh_expires_in), + }); + self.flush_unsaved(state).await; let token = Zeroizing::new(session.access.access_token.expose().to_owned()); state.replace_access(AccessState { @@ -251,6 +262,7 @@ impl SyncClient { /// network, never the request itself. async fn access_token(&self) -> SyncResult<(Zeroizing, u64, Option)> { let mut state = self.auth.lock().await; + self.flush_unsaved(&mut state).await; let now = self.clock.now_secs(); let live = state.access().filter(|access| now < access.expires_at); let token = match live { @@ -783,23 +795,82 @@ mod tests { } #[tokio::test] - async fn failed_save_is_returned_and_the_token_is_not_used() { + async fn failed_save_still_uses_the_rotated_token() { let h = seeded(); h.store.fail_saves(); h.transport.push(200, &[], &session("a.b.c")); + h.transport.push(200, &[], DEVICES); - let error = h.client.devices().await.unwrap_err(); + h.client.devices().await.unwrap(); - assert!(matches!(error, SyncError::Client { .. })); - assert_eq!(h.transport.requests().len(), 1); + let requests = h.transport.requests(); + assert_eq!(requests.len(), 2); + assert_eq!(header(&requests[1], "authorization"), Some("DPoP a.b.c")); + assert_eq!(h.stored_refresh_token().as_deref(), Some(OLD_REFRESH)); + } - // The token was not kept for later either: the next call has to refresh again. + #[tokio::test] + async fn failed_save_is_retried_on_the_next_call() { + let h = seeded(); + h.store.fail_saves(); h.transport.push(200, &[], &session("a.b.c")); - let error = h.client.devices().await.unwrap_err(); + h.transport.push(200, &[], DEVICES); + h.client.devices().await.unwrap(); - assert!(matches!(error, SyncError::Client { .. })); - assert_eq!(h.token_requests(), 2); - assert_eq!(h.transport.requests().len(), 2); + h.store.allow_saves(); + h.transport.push(200, &[], DEVICES); + h.client.devices().await.unwrap(); + + assert_eq!(h.token_requests(), 1); + assert_eq!(h.stored_refresh_token().as_deref(), Some(ROTATED_REFRESH)); + } + + #[tokio::test] + async fn refresh_after_a_failed_save_spends_the_rotated_token() { + let h = seeded(); + h.store.fail_saves(); + h.transport.push(200, &[], &session("a.b.c")); + h.transport.push(200, &[], DEVICES); + h.client.devices().await.unwrap(); + + h.clock.advance(601); + h.transport.push(200, &[], &session("d.e.f")); + h.transport.push(200, &[], DEVICES); + h.client.devices().await.unwrap(); + + let requests = h.transport.requests(); + let body: Value = serde_json::from_slice(&requests[2].body).unwrap(); + assert_eq!(body, json!({"refresh_token": ROTATED_REFRESH})); + assert_eq!(header(&requests[3], "authorization"), Some("DPoP d.e.f")); + } + + #[tokio::test] + async fn concurrent_callers_share_a_token_the_store_refused() { + let h = seeded(); + h.store.fail_saves(); + h.transport.push(200, &[], &session("a.b.c")); + h.transport.push(200, &[], DEVICES); + h.transport.push(200, &[], DEVICES); + + let (first, second) = tokio::join!(h.client.devices(), h.client.devices()); + + first.unwrap(); + second.unwrap(); + assert_eq!(h.token_requests(), 1); + } + + #[tokio::test] + async fn signing_out_forgets_a_token_the_store_refused() { + let h = seeded(); + h.store.fail_saves(); + h.transport.push(200, &[], &session("a.b.c")); + h.transport.push(200, &[], DEVICES); + h.client.devices().await.unwrap(); + + h.transport.push(401, &[], &revoked_body("reuse_detected")); + h.client.devices().await.unwrap_err(); + + h.assert_signed_out_locally().await; } #[tokio::test] diff --git a/rust/crates/keygo-client/src/sync/state.rs b/rust/crates/keygo-client/src/sync/state.rs index 50fb9991b..73fd43d00 100644 --- a/rust/crates/keygo-client/src/sync/state.rs +++ b/rust/crates/keygo-client/src/sync/state.rs @@ -1,3 +1,4 @@ +use super::tokens::StoredSession; use keygo_api::domain::AccessToken; use std::time::{SystemTime, UNIX_EPOCH}; @@ -16,6 +17,9 @@ pub(super) struct AuthState { /// Changes whenever `access` does. A call remembers the value its token came with, so when /// that token is rejected it can tell whether someone has already replaced it. pub(super) generation: u64, + /// A rotated session the store has not accepted yet. While this is set the store still holds + /// the spent token, which the server would treat as reuse, so this copy wins over the store. + pub(super) unsaved: Option, } impl AuthState { @@ -34,6 +38,7 @@ impl AuthState { pub(super) fn reset(&mut self) { self.access = None; self.nonce = None; + self.unsaved = None; self.generation += 1; } } diff --git a/rust/crates/keygo-client/src/sync/testing.rs b/rust/crates/keygo-client/src/sync/testing.rs index 57771352d..13aaf8432 100644 --- a/rust/crates/keygo-client/src/sync/testing.rs +++ b/rust/crates/keygo-client/src/sync/testing.rs @@ -92,6 +92,10 @@ impl FakeTokenStore { self.fail_saves.store(true, Ordering::SeqCst); } + pub fn allow_saves(&self) { + self.fail_saves.store(false, Ordering::SeqCst); + } + pub fn fail_clears(&self) { self.fail_clears.store(true, Ordering::SeqCst); } diff --git a/rust/crates/keygo-client/src/sync/tokens.rs b/rust/crates/keygo-client/src/sync/tokens.rs index 02b0bf32c..4b689b351 100644 --- a/rust/crates/keygo-client/src/sync/tokens.rs +++ b/rust/crates/keygo-client/src/sync/tokens.rs @@ -8,6 +8,21 @@ pub struct StoredSession { pub refresh_expires_at: u64, } +impl StoredSession { + /// A second copy of the session. `RefreshToken` is not `Clone`, so it goes through its encoding. + pub(super) fn duplicate(&self) -> Self { + Self { + device_id: self.device_id, + refresh_token: self + .refresh_token + .expose_encoded() + .parse() + .expect("a refresh token parses its own encoding"), + refresh_expires_at: self.refresh_expires_at, + } + } +} + #[derive(Debug, thiserror::Error)] #[error("{message}")] pub struct TokenStoreError { diff --git a/rust/crates/keygo-e2e/tests/sync.rs b/rust/crates/keygo-e2e/tests/sync.rs index ee228ac34..7616f117b 100644 --- a/rust/crates/keygo-e2e/tests/sync.rs +++ b/rust/crates/keygo-e2e/tests/sync.rs @@ -255,3 +255,15 @@ async fn client_logout_ends_the_session_on_the_server(db: PgPool) { .await; assert!(!status.is_success(), "{status}"); } + +#[sqlx::test(migrations = "../keygo-server/migrations")] +async fn refused_save_does_not_trip_reuse_detection(db: PgPool) { + let h = harness(&db).await; + h.store.fail_saves(); + + h.client.devices().await.unwrap(); + h.clock.advance(601); + h.client.devices().await.unwrap(); + + assert_eq!(h.store.current_refresh_token().unwrap(), h.seed_token); +} From 48a410c46d58dc67a8bc3ad57a8bb7aa59e18fdd Mon Sep 17 00:00:00 2001 From: Davis Date: Mon, 9 Nov 2026 20:44:45 +0100 Subject: [PATCH 18/52] test(client): pin every path of a token the store refused A review showed the refused-save tests would miss several ways of breaking the logic, two of which bring reuse detection back. Cover failed refreshes, a second rotation, invalid_token, a caller dropped during the write, every sign-out path, and trusting the store again once a retry succeeds. Also tell TokenStore implementers that save runs under the auth lock, and correct three comments. Co-Authored-By: Claude Opus 5.5 --- rust/crates/keygo-client/src/sync/client.rs | 2 +- rust/crates/keygo-client/src/sync/pipeline.rs | 242 ++++++++++++++++-- rust/crates/keygo-client/src/sync/state.rs | 2 +- rust/crates/keygo-client/src/sync/tokens.rs | 4 + rust/crates/keygo-uniffi/src/sync.rs | 4 + 5 files changed, 232 insertions(+), 22 deletions(-) diff --git a/rust/crates/keygo-client/src/sync/client.rs b/rust/crates/keygo-client/src/sync/client.rs index 1fd8118fc..0948810e7 100644 --- a/rust/crates/keygo-client/src/sync/client.rs +++ b/rust/crates/keygo-client/src/sync/client.rs @@ -130,7 +130,7 @@ impl SyncClient { /// Ends the session here even if the server cannot be told, and reports whether it was. /// /// When the server could not be told and the store could not be cleared either, a token the - /// server still accepts stays on disk, so the store failure is returned instead. + /// server may still accept stays on disk, so the store failure is returned instead. pub async fn logout(&self) -> SyncResult<()> { let sent = self.call(&Logout, &()).await; let mut state = self.auth.lock().await; diff --git a/rust/crates/keygo-client/src/sync/pipeline.rs b/rust/crates/keygo-client/src/sync/pipeline.rs index 103a28402..d019d2a84 100644 --- a/rust/crates/keygo-client/src/sync/pipeline.rs +++ b/rust/crates/keygo-client/src/sync/pipeline.rs @@ -182,8 +182,8 @@ impl SyncClient { self.tokens.clear().await } - /// Writes a rotated session the store refused. Another refusal is not the caller's failure: - /// the copy in `state` stays the live one, and the next call writes it again. + /// Writes the rotated session held in `state`, if any. A refusal is not the caller's failure: + /// `state` keeps the live copy and the next call writes it again. async fn flush_unsaved(&self, state: &mut AuthState) { let Some(unsaved) = &state.unsaved else { return; @@ -375,12 +375,14 @@ mod tests { use super::super::client::SyncClient; use super::super::signer::{DpopKey, SignError}; use super::super::testing::{FakeDpopKey, FakeTokenStore, FakeTransport, FixedClock}; + use super::super::tokens::TokenStore; use base64::Engine; use base64::engine::general_purpose::URL_SAFE_NO_PAD; use keygo_api::domain::RevokeReason; use keygo_core::DeviceId; use serde_json::{Value, json}; use std::sync::Arc; + use std::sync::atomic::{AtomicBool, Ordering}; use url::Url; const SESSION: &str = r#"{"device_id":"00000000-0000-0000-0000-000000000001","access_token":"a.b.c","access_expires_in":300,"refresh_token":"kgr___________________________________________8","refresh_expires_in":86400}"#; @@ -554,17 +556,22 @@ mod tests { const OLD_REFRESH: &str = "kgr___________________________________________8"; const ROTATED_REFRESH: &str = "kgr_AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"; + const NEXT_REFRESH: &str = "kgr_AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE"; const DEVICES: &[u8] = br#"{"devices":[]}"#; /// Requests `fresh` has already spent. const FRESH: usize = 2; /// A `200` from `/auth/token`. fn session(access_token: &str) -> Vec { + session_with(access_token, ROTATED_REFRESH) + } + + fn session_with(access_token: &str, refresh_token: &str) -> Vec { serde_json::to_vec(&json!({ "device_id": "00000000-0000-0000-0000-000000000001", "access_token": access_token, "access_expires_in": 600, - "refresh_token": ROTATED_REFRESH, + "refresh_token": refresh_token, "refresh_expires_in": 86400, })) .unwrap() @@ -603,6 +610,19 @@ mod tests { self.store.current_refresh_token() } + /// Every refresh token sent so far, in order. + fn spent_tokens(&self) -> Vec { + self.transport + .requests() + .iter() + .filter(|r| r.url.ends_with("/api/v1/auth/token")) + .map(|r| { + let body: Value = serde_json::from_slice(&r.body).unwrap(); + body["refresh_token"].as_str().unwrap().to_owned() + }) + .collect() + } + async fn assert_signed_out_locally(&self) { let sent = self.transport.requests().len(); @@ -654,6 +674,40 @@ mod tests { harness } + /// Holds a rotated token the store refused, with saves still failing. + async fn refused() -> Harness { + let harness = seeded(); + harness.store.fail_saves(); + harness.transport.push(200, &[], &session("a.b.c")); + harness.transport.push(200, &[], DEVICES); + harness.client.devices().await.unwrap(); + harness + } + + /// Saves any session it is given, except that while `hang` is set `save` never returns. + struct HangingStore { + inner: FakeTokenStore, + hang: AtomicBool, + } + + #[async_trait::async_trait] + impl TokenStore for HangingStore { + async fn load(&self) -> Result, TokenStoreError> { + self.inner.load().await + } + + async fn save(&self, session: StoredSession) -> Result<(), TokenStoreError> { + if self.hang.load(Ordering::SeqCst) { + std::future::pending::<()>().await; + } + self.inner.save(session).await + } + + async fn clear(&self) -> Result<(), TokenStoreError> { + self.inner.clear().await + } + } + #[tokio::test] async fn no_stored_session_signs_out_without_sending() { let h = unseeded(); @@ -811,11 +865,7 @@ mod tests { #[tokio::test] async fn failed_save_is_retried_on_the_next_call() { - let h = seeded(); - h.store.fail_saves(); - h.transport.push(200, &[], &session("a.b.c")); - h.transport.push(200, &[], DEVICES); - h.client.devices().await.unwrap(); + let h = refused().await; h.store.allow_saves(); h.transport.push(200, &[], DEVICES); @@ -826,24 +876,144 @@ mod tests { } #[tokio::test] - async fn refresh_after_a_failed_save_spends_the_rotated_token() { - let h = seeded(); - h.store.fail_saves(); - h.transport.push(200, &[], &session("a.b.c")); + async fn the_store_is_trusted_again_after_a_retry_succeeds() { + let h = refused().await; + h.store.allow_saves(); + h.transport.push(200, &[], DEVICES); + h.client.devices().await.unwrap(); + + // Only a client that went back to the store can see this entry. + h.store.seed(StoredSession { + device_id: DeviceId::random(), + refresh_token: NEXT_REFRESH.parse().unwrap(), + refresh_expires_at: 1_000_000, + }); + h.clock.advance(601); + h.transport.push(200, &[], &session("d.e.f")); h.transport.push(200, &[], DEVICES); h.client.devices().await.unwrap(); + assert_eq!(h.spent_tokens(), [OLD_REFRESH, NEXT_REFRESH]); + } + + #[tokio::test] + async fn refresh_after_a_failed_save_spends_the_rotated_token() { + let h = refused().await; + h.clock.advance(601); h.transport.push(200, &[], &session("d.e.f")); h.transport.push(200, &[], DEVICES); h.client.devices().await.unwrap(); + assert_eq!(h.spent_tokens(), [OLD_REFRESH, ROTATED_REFRESH]); let requests = h.transport.requests(); - let body: Value = serde_json::from_slice(&requests[2].body).unwrap(); - assert_eq!(body, json!({"refresh_token": ROTATED_REFRESH})); assert_eq!(header(&requests[3], "authorization"), Some("DPoP d.e.f")); } + #[tokio::test] + async fn a_failed_refresh_keeps_a_token_the_store_refused() { + let h = refused().await; + + h.clock.advance(601); + h.transport.push_network_error("offline"); + h.client.devices().await.unwrap_err(); + h.transport.push(500, &[], &error_body("internal")); + h.client.devices().await.unwrap_err(); + h.transport + .push(200, &[], &session_with("d.e.f", NEXT_REFRESH)); + h.transport.push(200, &[], DEVICES); + h.client.devices().await.unwrap(); + + assert_eq!( + h.spent_tokens(), + [ + OLD_REFRESH, + ROTATED_REFRESH, + ROTATED_REFRESH, + ROTATED_REFRESH, + ], + ); + } + + #[tokio::test] + async fn a_second_rotation_replaces_a_token_the_store_refused() { + let h = refused().await; + + h.clock.advance(601); + h.transport + .push(200, &[], &session_with("d.e.f", NEXT_REFRESH)); + h.transport.push(200, &[], DEVICES); + h.client.devices().await.unwrap(); + h.clock.advance(601); + h.transport.push(200, &[], &session("g.h.i")); + h.transport.push(200, &[], DEVICES); + h.client.devices().await.unwrap(); + + assert_eq!( + h.spent_tokens(), + [OLD_REFRESH, ROTATED_REFRESH, NEXT_REFRESH], + ); + } + + #[tokio::test] + async fn invalid_token_after_a_failed_save_spends_the_rotated_token() { + let h = refused().await; + + h.transport.push(401, &[], &error_body("invalid_token")); + h.transport + .push(200, &[], &session_with("d.e.f", NEXT_REFRESH)); + h.transport.push(200, &[], DEVICES); + h.client.devices().await.unwrap(); + + assert_eq!(h.spent_tokens(), [OLD_REFRESH, ROTATED_REFRESH]); + } + + #[tokio::test] + async fn a_caller_dropped_during_the_write_keeps_the_rotated_token() { + let store = Arc::new(HangingStore { + inner: FakeTokenStore::new(), + hang: AtomicBool::new(true), + }); + store.inner.seed(StoredSession { + device_id: DeviceId::random(), + refresh_token: OLD_REFRESH.parse().unwrap(), + refresh_expires_at: 1_000_000, + }); + let transport = FakeTransport::new(); + let client = SyncClient::new( + Url::parse("https://kg.example").unwrap(), + transport.clone(), + Arc::new(FakeDpopKey::new()), + store.clone(), + ) + .unwrap() + .with_clock(FixedClock::new(1_000)); + + transport.push(200, &[], &session("a.b.c")); + tokio::select! { + biased; + _ = client.devices() => panic!("the save should still be hanging"), + () = async { + for _ in 0..16 { + tokio::task::yield_now().await; + } + } => {} + } + assert_eq!(transport.requests().len(), 1); + + store.hang.store(false, Ordering::SeqCst); + transport.push(200, &[], &session_with("d.e.f", NEXT_REFRESH)); + transport.push(200, &[], DEVICES); + client.devices().await.unwrap(); + + let body: Value = serde_json::from_slice(&transport.requests()[1].body).unwrap(); + assert_eq!(body, json!({"refresh_token": ROTATED_REFRESH})); + assert_eq!( + store.inner.current_refresh_token().as_deref(), + Some(NEXT_REFRESH), + ); + } + #[tokio::test] async fn concurrent_callers_share_a_token_the_store_refused() { let h = seeded(); @@ -860,16 +1030,48 @@ mod tests { } #[tokio::test] - async fn signing_out_forgets_a_token_the_store_refused() { - let h = seeded(); - h.store.fail_saves(); - h.transport.push(200, &[], &session("a.b.c")); - h.transport.push(200, &[], DEVICES); - h.client.devices().await.unwrap(); + async fn an_ordinary_call_signing_out_forgets_a_token_the_store_refused() { + let h = refused().await; h.transport.push(401, &[], &revoked_body("reuse_detected")); h.client.devices().await.unwrap_err(); + h.store.allow_saves(); + h.assert_signed_out_locally().await; + } + + #[tokio::test] + async fn a_revoked_refresh_forgets_a_token_the_store_refused() { + let h = refused().await; + + h.clock.advance(601); + h.transport.push(401, &[], &revoked_body("reuse_detected")); + h.client.devices().await.unwrap_err(); + + h.store.allow_saves(); + h.assert_signed_out_locally().await; + } + + #[tokio::test] + async fn an_expired_refresh_forgets_a_token_the_store_refused() { + let h = refused().await; + + h.clock.advance(601); + h.transport.push(401, &[], &error_body("refresh_expired")); + h.client.devices().await.unwrap_err(); + + h.store.allow_saves(); + h.assert_signed_out_locally().await; + } + + #[tokio::test] + async fn logout_forgets_a_token_the_store_refused() { + let h = refused().await; + + h.transport.push(204, &[], b""); + h.client.logout().await.unwrap(); + + h.store.allow_saves(); h.assert_signed_out_locally().await; } diff --git a/rust/crates/keygo-client/src/sync/state.rs b/rust/crates/keygo-client/src/sync/state.rs index 73fd43d00..5d2e6ec23 100644 --- a/rust/crates/keygo-client/src/sync/state.rs +++ b/rust/crates/keygo-client/src/sync/state.rs @@ -17,7 +17,7 @@ pub(super) struct AuthState { /// Changes whenever `access` does. A call remembers the value its token came with, so when /// that token is rejected it can tell whether someone has already replaced it. pub(super) generation: u64, - /// A rotated session the store has not accepted yet. While this is set the store still holds + /// A rotated session the store has not accepted yet. Until it does, the store may still hold /// the spent token, which the server would treat as reuse, so this copy wins over the store. pub(super) unsaved: Option, } diff --git a/rust/crates/keygo-client/src/sync/tokens.rs b/rust/crates/keygo-client/src/sync/tokens.rs index 4b689b351..242167888 100644 --- a/rust/crates/keygo-client/src/sync/tokens.rs +++ b/rust/crates/keygo-client/src/sync/tokens.rs @@ -30,6 +30,10 @@ pub struct TokenStoreError { } /// Durable home of the refresh token. The host decides how it is protected. +/// +/// `save` runs while the client holds its auth lock, so it must return in bounded time: one that +/// never returns blocks every later call, including logout. A refused `save` is repeated on later +/// calls. #[async_trait] pub trait TokenStore: Send + Sync { async fn load(&self) -> Result, TokenStoreError>; diff --git a/rust/crates/keygo-uniffi/src/sync.rs b/rust/crates/keygo-uniffi/src/sync.rs index 8637dee24..efbdf565d 100644 --- a/rust/crates/keygo-uniffi/src/sync.rs +++ b/rust/crates/keygo-uniffi/src/sync.rs @@ -278,6 +278,10 @@ pub trait DpopKey: Send + Sync { } /// Durable home of the refresh token. The host decides how it is protected. +/// +/// `save` runs while the client holds its auth lock, so it must return in bounded time: one that +/// never returns blocks every later call, including logout. A refused `save` is repeated on later +/// calls. #[uniffi::export(with_foreign)] #[async_trait] pub trait TokenStore: Send + Sync { From 894c231e4f85d4bd127eb326f43d96ef25b4bc81 Mon Sep 17 00:00:00 2001 From: Davis Date: Tue, 10 Nov 2026 11:40:22 +0100 Subject: [PATCH 19/52] build(uniffi): give the tokio runtime a worker pool uniffi's tokio support runs on async-compat. Its multi-thread feature keeps one slow call from blocking the others. Co-Authored-By: Claude Opus 5.5 --- rust/Cargo.lock | 1 + rust/crates/keygo-uniffi/Cargo.toml | 2 ++ 2 files changed, 3 insertions(+) diff --git a/rust/Cargo.lock b/rust/Cargo.lock index 02ddc84c3..cfdf2e041 100644 --- a/rust/Cargo.lock +++ b/rust/Cargo.lock @@ -1753,6 +1753,7 @@ dependencies = [ name = "keygo-uniffi" version = "0.1.0" dependencies = [ + "async-compat", "async-trait", "keygo-api", "keygo-client", diff --git a/rust/crates/keygo-uniffi/Cargo.toml b/rust/crates/keygo-uniffi/Cargo.toml index 3139ff564..46129d536 100644 --- a/rust/crates/keygo-uniffi/Cargo.toml +++ b/rust/crates/keygo-uniffi/Cargo.toml @@ -14,6 +14,8 @@ thiserror.workspace = true uuid.workspace = true zeroize.workspace = true +# Not used directly: gives uniffi's tokio runtime a worker pool, so a slow call cannot block the rest. +async-compat = { version = "0.2.6", features = ["multi-thread"] } async-trait = "0.1.89" tokio = { workspace = true, features = ["rt", "rt-multi-thread"] } uniffi = { workspace = true, features = ["tokio"] } From dbb2c0da685a584fa48ee1d9369dd443d7394ffc Mon Sep 17 00:00:00 2001 From: Davis Date: Tue, 10 Nov 2026 11:40:22 +0100 Subject: [PATCH 20/52] refactor(api): declare the fixed endpoints in a table A macro now generates each endpoint and the route list together, so a fixed endpoint can no longer be left out of all_routes. That makes the source-counting every_endpoint_is_listed test unnecessary. Co-Authored-By: Claude Opus 5.5 --- rust/crates/keygo-api/src/endpoints.rs | 185 ++++++------------------- rust/crates/keygo-api/src/lib.rs | 13 -- 2 files changed, 43 insertions(+), 155 deletions(-) diff --git a/rust/crates/keygo-api/src/endpoints.rs b/rust/crates/keygo-api/src/endpoints.rs index e8a273ce3..f6d4d1a5f 100644 --- a/rust/crates/keygo-api/src/endpoints.rs +++ b/rust/crates/keygo-api/src/endpoints.rs @@ -4,134 +4,46 @@ use keygo_core::DeviceId; use std::borrow::Cow; use uuid::Uuid; -pub struct Meta; - -impl Endpoint for Meta { - type Request = (); - type Response = meta::ServerInfo; - const METHOD: Method = Method::Get; - const AUTH: Auth = Auth::None; - - fn path(&self) -> Cow<'static, str> { - Cow::Borrowed("/api/v1/meta") - } -} - -pub struct RegisterStart; - -impl Endpoint for RegisterStart { - type Request = auth::register::StartRequest; - type Response = auth::register::StartResponse; - const METHOD: Method = Method::Post; - const AUTH: Auth = Auth::None; - - fn path(&self) -> Cow<'static, str> { - Cow::Borrowed("/api/v1/auth/register/start") - } -} - -pub struct RegisterFinish; - -impl Endpoint for RegisterFinish { - type Request = auth::register::FinishRequest; - type Response = auth::register::FinishResponse; - const METHOD: Method = Method::Post; - const AUTH: Auth = Auth::Proof; - - fn path(&self) -> Cow<'static, str> { - Cow::Borrowed("/api/v1/auth/register/finish") - } -} - -pub struct LoginStart; - -impl Endpoint for LoginStart { - type Request = auth::login::StartRequest; - type Response = auth::handshake::StartResponse; - const METHOD: Method = Method::Post; - const AUTH: Auth = Auth::None; - - fn path(&self) -> Cow<'static, str> { - Cow::Borrowed("/api/v1/auth/login/start") - } -} - -pub struct LoginFinish; - -impl Endpoint for LoginFinish { - type Request = auth::login::FinishRequest; - type Response = auth::login::FinishResponse; - const METHOD: Method = Method::Post; - const AUTH: Auth = Auth::Proof; - - fn path(&self) -> Cow<'static, str> { - Cow::Borrowed("/api/v1/auth/login/finish") - } -} - -pub struct StepUpStart; - -impl Endpoint for StepUpStart { - type Request = auth::step_up::StartRequest; - type Response = auth::handshake::StartResponse; - const METHOD: Method = Method::Post; - const AUTH: Auth = Auth::AccessToken; - - fn path(&self) -> Cow<'static, str> { - Cow::Borrowed("/api/v1/auth/step-up/start") - } -} - -pub struct StepUpFinish; - -impl Endpoint for StepUpFinish { - type Request = auth::step_up::FinishRequest; - type Response = auth::step_up::FinishResponse; - const METHOD: Method = Method::Post; - const AUTH: Auth = Auth::AccessToken; - - fn path(&self) -> Cow<'static, str> { - Cow::Borrowed("/api/v1/auth/step-up/finish") - } -} - -pub struct Token; - -impl Endpoint for Token { - type Request = auth::token::TokenRequest; - type Response = auth::Session; - const METHOD: Method = Method::Post; - const AUTH: Auth = Auth::Proof; - - fn path(&self) -> Cow<'static, str> { - Cow::Borrowed("/api/v1/auth/token") - } -} - -pub struct Logout; - -impl Endpoint for Logout { - type Request = (); - type Response = (); - const METHOD: Method = Method::Post; - const AUTH: Auth = Auth::AccessToken; - - fn path(&self) -> Cow<'static, str> { - Cow::Borrowed("/api/v1/auth/logout") - } +macro_rules! endpoints { + ($($name:ident: $method:ident $path:literal, $auth:ident, $request:ty => $response:ty;)+) => { + $( + pub struct $name; + + impl Endpoint for $name { + type Request = $request; + type Response = $response; + const METHOD: Method = Method::$method; + const AUTH: Auth = Auth::$auth; + + fn path(&self) -> Cow<'static, str> { + Cow::Borrowed($path) + } + } + )+ + + fn fixed_routes() -> Vec { + vec![$(route($name)),+] + } + }; } -pub struct ListDevices; - -impl Endpoint for ListDevices { - type Request = (); - type Response = devices::Devices; - const METHOD: Method = Method::Get; - const AUTH: Auth = Auth::AccessToken; - - fn path(&self) -> Cow<'static, str> { - Cow::Borrowed("/api/v1/devices") - } +endpoints! { + Meta: Get "/api/v1/meta", None, () => meta::ServerInfo; + RegisterStart: Post "/api/v1/auth/register/start", None, + auth::register::StartRequest => auth::register::StartResponse; + RegisterFinish: Post "/api/v1/auth/register/finish", Proof, + auth::register::FinishRequest => auth::register::FinishResponse; + LoginStart: Post "/api/v1/auth/login/start", None, + auth::login::StartRequest => auth::handshake::StartResponse; + LoginFinish: Post "/api/v1/auth/login/finish", Proof, + auth::login::FinishRequest => auth::login::FinishResponse; + StepUpStart: Post "/api/v1/auth/step-up/start", AccessToken, + auth::step_up::StartRequest => auth::handshake::StartResponse; + StepUpFinish: Post "/api/v1/auth/step-up/finish", AccessToken, + auth::step_up::FinishRequest => auth::step_up::FinishResponse; + Token: Post "/api/v1/auth/token", Proof, auth::token::TokenRequest => auth::Session; + Logout: Post "/api/v1/auth/logout", AccessToken, () => (); + ListDevices: Get "/api/v1/devices", AccessToken, () => devices::Devices; } pub struct DeleteDevice { @@ -149,7 +61,6 @@ impl Endpoint for DeleteDevice { } } -/// An endpoint reduced to what a router or a test needs to know about it. #[derive(Debug)] pub struct Route { pub method: Method, @@ -166,19 +77,9 @@ fn route(endpoint: E) -> Route { } pub fn all_routes() -> Vec { - vec![ - route(Meta), - route(RegisterStart), - route(RegisterFinish), - route(LoginStart), - route(LoginFinish), - route(StepUpStart), - route(StepUpFinish), - route(Token), - route(Logout), - route(ListDevices), - route(DeleteDevice { - id: Uuid::nil().into(), - }), - ] + let mut routes = fixed_routes(); + routes.push(route(DeleteDevice { + id: Uuid::nil().into(), + })); + routes } diff --git a/rust/crates/keygo-api/src/lib.rs b/rust/crates/keygo-api/src/lib.rs index fac2c3914..624a372f3 100644 --- a/rust/crates/keygo-api/src/lib.rs +++ b/rust/crates/keygo-api/src/lib.rs @@ -10,16 +10,3 @@ pub mod meta; pub use endpoint::{Auth, Endpoint, Method}; pub use error::{ApiError, ErrorCode}; - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn every_endpoint_is_listed() { - let declared = include_str!("endpoints.rs") - .matches("impl Endpoint for ") - .count(); - assert_eq!(endpoints::all_routes().len(), declared); - } -} From e25ba504ac7529c6e1d8198d1838d06edc4832bd Mon Sep 17 00:00:00 2001 From: Davis Date: Tue, 10 Nov 2026 11:40:22 +0100 Subject: [PATCH 21/52] test: share request helpers in the wire, server and e2e tests Use Method::as_str and SystemClock instead of local copies, and send every server test request through one helper. Drop every_endpoint_is_routed, which every_endpoint_demands_its_declared_auth already walks the same routes for. Co-Authored-By: Claude Opus 5.5 --- rust/crates/keygo-api/tests/wire.rs | 12 ++------ rust/crates/keygo-e2e/tests/sync.rs | 29 ++++++------------- rust/crates/keygo-server/src/api/mod.rs | 37 +++++++------------------ 3 files changed, 20 insertions(+), 58 deletions(-) diff --git a/rust/crates/keygo-api/tests/wire.rs b/rust/crates/keygo-api/tests/wire.rs index 0cac81c0f..e95e4c60c 100644 --- a/rust/crates/keygo-api/tests/wire.rs +++ b/rust/crates/keygo-api/tests/wire.rs @@ -41,12 +41,6 @@ fn device() -> Value { json!({"name": "Pixel 9", "platform": "android", "app_version": "2.3.0"}) } -fn device_with(extra: (&str, Value)) -> Value { - let mut value = device(); - value[extra.0] = extra.1; - value -} - fn key_bundle() -> Value { json!({"wrapped_ark": wrapped_ark()}) } @@ -226,10 +220,8 @@ fn handshake_start_response() { fn login_finish(device_id: Option<&str>) -> (login::FinishRequest, Value) { let m = messages(); - let claim = match device_id { - Some(id) => device_with(("device_id", json!(id))), - None => device_with(("device_id", Value::Null)), - }; + let mut claim = device(); + claim["device_id"] = json!(device_id); let request = login::FinishRequest { login_id: from(json!(HANDSHAKE_ID)), credential_finalization: m.credential_finalization.0, diff --git a/rust/crates/keygo-e2e/tests/sync.rs b/rust/crates/keygo-e2e/tests/sync.rs index 7616f117b..04ee9177e 100644 --- a/rust/crates/keygo-e2e/tests/sync.rs +++ b/rust/crates/keygo-e2e/tests/sync.rs @@ -2,23 +2,20 @@ use async_trait::async_trait; use axum::body::Body; use axum::http::{HeaderName, HeaderValue, Request}; use http_body_util::BodyExt; -use keygo_api::Method; use keygo_api::domain::{Device, RevokeReason}; use keygo_client::sync::testing::{FakeDpopKey, FakeTokenStore, FixedClock}; use keygo_client::sync::{ - Header, HttpRequest, HttpResponse, StoredSession, SyncClient, SyncError, Transport, - TransportError, + Clock, Header, HttpRequest, HttpResponse, StoredSession, SyncClient, SyncError, SystemClock, + Transport, TransportError, }; use keygo_dpop::testing::TestSigner; use keygo_server::api::{AppState, router}; use keygo_server::testing; use sqlx::PgPool; use std::sync::Arc; -use std::time::{SystemTime, UNIX_EPOCH}; use tower::ServiceExt; use url::Url; -/// Hands requests to the router in-process, the way a real transport hands them to the network. struct TowerTransport(AppState); #[async_trait] @@ -27,12 +24,9 @@ impl Transport for TowerTransport { let fail = |e: &dyn std::fmt::Display| TransportError { message: e.to_string(), }; - let method = match request.method { - Method::Get => "GET", - Method::Post => "POST", - Method::Delete => "DELETE", - }; - let mut built = Request::builder().method(method).uri(&request.url); + let mut built = Request::builder() + .method(request.method.as_str()) + .uri(&request.url); for header in &request.headers { built = built.header( HeaderName::try_from(header.name.as_str()).map_err(|e| fail(&e))?, @@ -80,13 +74,6 @@ struct Harness { seed_token: String, } -fn now() -> u64 { - SystemTime::now() - .duration_since(UNIX_EPOCH) - .unwrap() - .as_secs() -} - async fn harness(db: &PgPool) -> Harness { let prover = testing::prover(); let (state, issued) = testing::signed_in(db, &prover).await; @@ -98,9 +85,9 @@ async fn harness(db: &PgPool) -> Harness { store.seed(StoredSession { device_id, refresh_token: issued.refresh_token, - refresh_expires_at: now() + issued.refresh_expires_in.as_secs(), + refresh_expires_at: SystemClock.now_secs() + issued.refresh_expires_in.as_secs(), }); - let clock = FixedClock::new(now()); + let clock = FixedClock::new(SystemClock.now_secs()); let client = SyncClient::new( Url::parse(testing::ISS).unwrap(), Arc::new(TowerTransport(state.clone())), @@ -187,7 +174,7 @@ async fn revoked_session_signs_out(db: PgPool) { async fn fresh_auth_required_then_step_up_then_retry(db: PgPool) { let h = harness(&db).await; sqlx::query("update sessions set auth_time = to_timestamp($1) where device_id = $2") - .bind((now() - 301) as f64) + .bind((SystemClock.now_secs() - 301) as f64) .bind(h.device_id.as_uuid()) .execute(&db) .await diff --git a/rust/crates/keygo-server/src/api/mod.rs b/rust/crates/keygo-server/src/api/mod.rs index 5d0ff70c4..0a7b7d695 100644 --- a/rust/crates/keygo-server/src/api/mod.rs +++ b/rust/crates/keygo-server/src/api/mod.rs @@ -55,50 +55,42 @@ mod tests { use crate::domain::InvitePepper; use crate::service::registration::Signup; use axum::body::Body; - use axum::http::{Method as HttpMethod, Request, StatusCode}; + use axum::http::{Request, StatusCode}; use http_body_util::BodyExt; + use keygo_api::Auth; use keygo_api::endpoints::Route; - use keygo_api::{Auth, Method}; use keygo_dpop::DpopVerifier; use routes::auth::MAX_BODY_BYTES; use serde_json::{Value, json}; use std::sync::Arc; use tower::ServiceExt; - async fn get(state: AppState, uri: &str) -> (StatusCode, Vec) { - let request = Request::get(uri).body(Body::empty()).unwrap(); + async fn send(state: AppState, request: Request) -> (StatusCode, Vec) { let response = router(state).oneshot(request).await.unwrap(); let status = response.status(); let body = response.into_body().collect().await.unwrap().to_bytes(); (status, body.to_vec()) } + async fn get(state: AppState, uri: &str) -> (StatusCode, Vec) { + send(state, Request::get(uri).body(Body::empty()).unwrap()).await + } + async fn post_json(state: AppState, uri: &str, body: Value) -> (StatusCode, Vec) { let request = Request::post(uri) .header("content-type", "application/json") .body(Body::from(body.to_string())) .unwrap(); - let response = router(state).oneshot(request).await.unwrap(); - let status = response.status(); - let body = response.into_body().collect().await.unwrap().to_bytes(); - (status, body.to_vec()) + send(state, request).await } async fn send_empty(route: &Route) -> (StatusCode, Vec) { - let method = match route.method { - Method::Get => HttpMethod::GET, - Method::Post => HttpMethod::POST, - Method::Delete => HttpMethod::DELETE, - }; let request = Request::builder() - .method(method) + .method(route.method.as_str()) .uri(&route.path) .body(Body::empty()) .unwrap(); - let response = router(state()).oneshot(request).await.unwrap(); - let status = response.status(); - let body = response.into_body().collect().await.unwrap().to_bytes(); - (status, body.to_vec()) + send(state(), request).await } pub(super) fn state() -> AppState { @@ -144,15 +136,6 @@ mod tests { ); } - #[tokio::test] - async fn every_endpoint_is_routed() { - for route in keygo_api::endpoints::all_routes() { - let (status, _) = send_empty(&route).await; - assert_ne!(status, StatusCode::NOT_FOUND, "{route:?}"); - assert_ne!(status, StatusCode::METHOD_NOT_ALLOWED, "{route:?}"); - } - } - #[tokio::test] async fn every_endpoint_demands_its_declared_auth() { for route in keygo_api::endpoints::all_routes() { From 1697ebfb011e643ffc40c9bbd3418e33b4834691 Mon Sep 17 00:00:00 2001 From: Davis Date: Tue, 10 Nov 2026 11:40:22 +0100 Subject: [PATCH 22/52] refactor(sync): let DpopKey::public_key fail, make save borrow A public key the host cannot read is now reported by the client's own constructor, so the uniffi adapter no longer has to read it up front and cache it. TokenStore::save borrows the session, which saves copying the refresh token on every attempt. Co-Authored-By: Claude Opus 5.5 --- rust/crates/keygo-client/src/sync/client.rs | 4 +-- rust/crates/keygo-client/src/sync/pipeline.rs | 6 ++-- rust/crates/keygo-client/src/sync/signer.rs | 8 +++-- rust/crates/keygo-client/src/sync/testing.rs | 8 ++--- rust/crates/keygo-client/src/sync/tokens.rs | 2 +- rust/crates/keygo-uniffi/src/sync.rs | 30 +++++++------------ 6 files changed, 26 insertions(+), 32 deletions(-) diff --git a/rust/crates/keygo-client/src/sync/client.rs b/rust/crates/keygo-client/src/sync/client.rs index 0948810e7..d59a46124 100644 --- a/rust/crates/keygo-client/src/sync/client.rs +++ b/rust/crates/keygo-client/src/sync/client.rs @@ -297,8 +297,8 @@ mod tests { struct ShortKey; impl DpopKey for ShortKey { - fn public_key(&self) -> Vec { - vec![1, 2, 3] + fn public_key(&self) -> Result, SignError> { + Ok(vec![1, 2, 3]) } fn sign(&self, _: Vec) -> Result, SignError> { diff --git a/rust/crates/keygo-client/src/sync/pipeline.rs b/rust/crates/keygo-client/src/sync/pipeline.rs index d019d2a84..37da67cfb 100644 --- a/rust/crates/keygo-client/src/sync/pipeline.rs +++ b/rust/crates/keygo-client/src/sync/pipeline.rs @@ -188,7 +188,7 @@ impl SyncClient { let Some(unsaved) = &state.unsaved else { return; }; - if self.tokens.save(unsaved.duplicate()).await.is_ok() { + if self.tokens.save(unsaved).await.is_ok() { state.unsaved = None; } } @@ -530,7 +530,7 @@ mod tests { struct FailingKey(FakeDpopKey); impl DpopKey for FailingKey { - fn public_key(&self) -> Vec { + fn public_key(&self) -> Result, SignError> { self.0.public_key() } @@ -696,7 +696,7 @@ mod tests { self.inner.load().await } - async fn save(&self, session: StoredSession) -> Result<(), TokenStoreError> { + async fn save(&self, session: &StoredSession) -> Result<(), TokenStoreError> { if self.hang.load(Ordering::SeqCst) { std::future::pending::<()>().await; } diff --git a/rust/crates/keygo-client/src/sync/signer.rs b/rust/crates/keygo-client/src/sync/signer.rs index 3747734b1..d530ea5b9 100644 --- a/rust/crates/keygo-client/src/sync/signer.rs +++ b/rust/crates/keygo-client/src/sync/signer.rs @@ -11,8 +11,9 @@ pub struct SignError { /// A hardware-backed P-256 key held by the host. pub trait DpopKey: Send + Sync { /// The 65-byte uncompressed P-256 point. - fn public_key(&self) -> Vec; + fn public_key(&self) -> Result, SignError>; /// SHA256withECDSA over `message`, DER encoded. + /// Can be called from several threads at once. fn sign(&self, message: Vec) -> Result, SignError>; } @@ -23,8 +24,11 @@ pub struct ForeignSigner { impl ForeignSigner { pub fn new(key: Arc) -> SyncResult { + let public_key = key.public_key().map_err(|e| SyncError::Client { + message: format!("could not read the DPoP public key: {e}"), + })?; let verifying = - VerifyingKey::from_sec1_bytes(&key.public_key()).map_err(|_| SyncError::Client { + VerifyingKey::from_sec1_bytes(&public_key).map_err(|_| SyncError::Client { message: "the DPoP public key is not a P-256 point".into(), })?; Ok(Self { key, verifying }) diff --git a/rust/crates/keygo-client/src/sync/testing.rs b/rust/crates/keygo-client/src/sync/testing.rs index 13aaf8432..9b5794baa 100644 --- a/rust/crates/keygo-client/src/sync/testing.rs +++ b/rust/crates/keygo-client/src/sync/testing.rs @@ -130,13 +130,13 @@ impl TokenStore for FakeTokenStore { })) } - async fn save(&self, session: StoredSession) -> Result<(), TokenStoreError> { + async fn save(&self, session: &StoredSession) -> Result<(), TokenStoreError> { if self.fail_saves.load(Ordering::SeqCst) { return Err(TokenStoreError { message: "save failed".into(), }); } - *self.stored.lock().unwrap() = Some(encode(&session)); + *self.stored.lock().unwrap() = Some(encode(session)); Ok(()) } @@ -167,8 +167,8 @@ impl Default for FakeDpopKey { } impl DpopKey for FakeDpopKey { - fn public_key(&self) -> Vec { - self.0.public_key_sec1() + fn public_key(&self) -> Result, SignError> { + Ok(self.0.public_key_sec1()) } fn sign(&self, message: Vec) -> Result, SignError> { diff --git a/rust/crates/keygo-client/src/sync/tokens.rs b/rust/crates/keygo-client/src/sync/tokens.rs index 242167888..0567e2706 100644 --- a/rust/crates/keygo-client/src/sync/tokens.rs +++ b/rust/crates/keygo-client/src/sync/tokens.rs @@ -37,6 +37,6 @@ pub struct TokenStoreError { #[async_trait] pub trait TokenStore: Send + Sync { async fn load(&self) -> Result, TokenStoreError>; - async fn save(&self, session: StoredSession) -> Result<(), TokenStoreError>; + async fn save(&self, session: &StoredSession) -> Result<(), TokenStoreError>; async fn clear(&self) -> Result<(), TokenStoreError>; } diff --git a/rust/crates/keygo-uniffi/src/sync.rs b/rust/crates/keygo-uniffi/src/sync.rs index efbdf565d..b86465600 100644 --- a/rust/crates/keygo-uniffi/src/sync.rs +++ b/rust/crates/keygo-uniffi/src/sync.rs @@ -177,8 +177,8 @@ pub struct StoredSession { pub refresh_expires_at: u64, } -impl From for StoredSession { - fn from(session: CoreStoredSession) -> Self { +impl From<&CoreStoredSession> for StoredSession { + fn from(session: &CoreStoredSession) -> Self { Self { device_id: session.device_id, refresh_token: session.refresh_token.expose_encoded().to_string(), @@ -299,19 +299,15 @@ impl CoreTransport for TransportAdapter { } } -/// Holds the public key `SyncClient::new` read, because the core trait's `public_key` cannot fail. -struct KeyAdapter { - key: Arc, - public_key: Vec, -} +struct KeyAdapter(Arc); impl CoreDpopKey for KeyAdapter { - fn public_key(&self) -> Vec { - self.public_key.clone() + fn public_key(&self) -> Result, CoreSignError> { + Ok(self.0.public_key()?) } fn sign(&self, message: Vec) -> Result, CoreSignError> { - Ok(self.key.sign(message)?) + Ok(self.0.sign(message)?) } } @@ -335,7 +331,7 @@ impl CoreTokenStore for StoreAdapter { })) } - async fn save(&self, session: CoreStoredSession) -> Result<(), CoreTokenStoreError> { + async fn save(&self, session: &CoreStoredSession) -> Result<(), CoreTokenStoreError> { Ok(self.0.save(session.into()).await?) } @@ -381,16 +377,10 @@ impl SyncClient { let base_url = Url::parse(&base_url).map_err(|e| SyncError::Client { reason: format!("invalid server url: {e}"), })?; - let public_key = dpop_key.public_key().map_err(|e| SyncError::Client { - reason: format!("could not read the DPoP public key: {e}"), - })?; let inner = CoreSyncClient::new( base_url, Arc::new(TransportAdapter(transport)), - Arc::new(KeyAdapter { - key: dpop_key, - public_key, - }), + Arc::new(KeyAdapter(dpop_key)), Arc::new(StoreAdapter(tokens)), )?; Ok(Arc::new(Self { @@ -595,7 +585,7 @@ mod tests { impl DpopKey for TestKey { fn public_key(&self) -> Result, SignError> { - Ok(CoreDpopKey::public_key(&self.0)) + CoreDpopKey::public_key(&self.0).map_err(|e| SignError::Failed { reason: e.message }) } fn sign(&self, message: Vec) -> Result, SignError> { @@ -640,7 +630,7 @@ mod tests { let device_id = DeviceId::random(); adapter - .save(CoreStoredSession { + .save(&CoreStoredSession { device_id, refresh_token: STORED_TOKEN.parse().unwrap(), refresh_expires_at: 99, From d592d4216856894abfdbd437c3ad9a27d4054cb7 Mon Sep 17 00:00:00 2001 From: Davis Date: Tue, 10 Nov 2026 11:40:22 +0100 Subject: [PATCH 23/52] refactor(client): simplify the request pipeline Split exchange into send_signed and an explicit single retry, move the nonce copy into exchange_unlocked, and let replace_access build its own AccessState. Stop exporting ForeignSigner. Move the duplicated client test helpers into sync::testing, and shorten the comments. Co-Authored-By: Claude Opus 5.5 --- rust/crates/keygo-client/src/sync/client.rs | 67 +-- rust/crates/keygo-client/src/sync/mod.rs | 2 +- rust/crates/keygo-client/src/sync/pipeline.rs | 414 +++++++++--------- rust/crates/keygo-client/src/sync/state.rs | 31 +- rust/crates/keygo-client/src/sync/testing.rs | 74 ++-- 5 files changed, 285 insertions(+), 303 deletions(-) diff --git a/rust/crates/keygo-client/src/sync/client.rs b/rust/crates/keygo-client/src/sync/client.rs index d59a46124..95dd76895 100644 --- a/rust/crates/keygo-client/src/sync/client.rs +++ b/rust/crates/keygo-client/src/sync/client.rs @@ -1,8 +1,7 @@ -use super::error::SyncError; -use super::error::SyncResult; +use super::error::{SyncError, SyncResult}; use super::pipeline::store_failure; use super::signer::{DpopKey, ForeignSigner}; -use super::state::{AccessState, AuthState, Clock, SystemClock}; +use super::state::{AuthState, Clock, SystemClock}; use super::tokens::TokenStore; use super::transport::Transport; use crate::ark_session::ArkSession; @@ -18,7 +17,6 @@ use std::sync::Arc; use tokio::sync::Mutex; use url::Url; -/// Who signed in, and as which device. #[derive(Debug, Clone, PartialEq, Eq)] pub struct Account { pub user_id: UserId, @@ -70,8 +68,7 @@ impl SyncClient { self.call(&DeleteDevice { id }, &()).await } - /// Proves the password again to the server, which then treats this session as freshly - /// authenticated. Only the access token changes: the refresh token and the store are untouched. + /// Proves the password again. Replaces only the access token: the refresh token stays as it is. pub async fn step_up(&self, password: &str) -> SyncResult<()> { let (login, credential_request) = ClientLogin::start(password.as_bytes()).map_err(opaque_failure)?; @@ -83,8 +80,7 @@ impl SyncClient { .map_err(opaque_failure)?; let dpop_binding = finish.session_key.dpop_binding(self.prover.jkt()); - // Read before sending, so a token never looks like it lives longer than it does. - let now = self.clock.now_secs(); + let sent_at = self.clock.now_secs(); let response = self .call( &StepUpFinish, @@ -96,10 +92,10 @@ impl SyncClient { ) .await?; - self.auth.lock().await.replace_access(AccessState { - token: response.access.access_token, - expires_at: now.saturating_add(response.access.access_expires_in), - }); + self.auth + .lock() + .await + .replace_access(response.access, sent_at); Ok(()) } @@ -127,10 +123,8 @@ impl SyncClient { Err(undecided()) } - /// Ends the session here even if the server cannot be told, and reports whether it was. - /// - /// When the server could not be told and the store could not be cleared either, a token the - /// server may still accept stays on disk, so the store failure is returned instead. + /// Always ends the session locally. Returns the server's result, unless the server was not told + /// and the store could not be cleared: a token the server may still accept is then left on disk. pub async fn logout(&self) -> SyncResult<()> { let sent = self.call(&Logout, &()).await; let mut state = self.auth.lock().await; @@ -161,34 +155,14 @@ fn opaque_failure(error: OpaqueError) -> SyncError { mod tests { use super::super::error::SyncError; use super::super::signer::SignError; - use super::super::testing::{FakeDpopKey, FakeTokenStore, FakeTransport}; + use super::super::testing::{FakeTokenStore, FakeTransport, error_body, fake_client, header}; use super::*; const INFO: &str = r#"{"version":"1","public_url":"https://kg.example","allow_signups":true}"#; - fn client() -> (SyncClient, Arc) { - let transport = FakeTransport::new(); - let client = SyncClient::new( - Url::parse("https://kg.example").unwrap(), - transport.clone(), - Arc::new(FakeDpopKey::new()), - Arc::new(FakeTokenStore::new()), - ) - .unwrap(); - (client, transport) - } - - fn header<'a>(request: &'a super::super::HttpRequest, name: &str) -> Option<&'a str> { - request - .headers - .iter() - .find(|h| h.name == name) - .map(|h| h.value.as_str()) - } - #[tokio::test] async fn none_auth_sends_no_proof_or_token() { - let (client, transport) = client(); + let (client, transport) = fake_client(); transport.push(200, &[], INFO.as_bytes()); client.meta().await.unwrap(); @@ -203,7 +177,7 @@ mod tests { #[tokio::test] async fn unit_request_has_no_body_or_content_type() { - let (client, transport) = client(); + let (client, transport) = fake_client(); transport.push(200, &[], INFO.as_bytes()); client.meta().await.unwrap(); @@ -224,9 +198,8 @@ mod tests { ("fresh_auth_required", SyncError::FreshAuthRequired), ("rate_limited", SyncError::RateLimited), ] { - let (client, transport) = client(); - let body = format!(r#"{{"code":"{code}","message":"m"}}"#); - transport.push(400, &[], body.as_bytes()); + let (client, transport) = fake_client(); + transport.push(400, &[], &error_body(code)); assert_eq!(client.meta().await.unwrap_err(), expected, "{code}"); } @@ -234,7 +207,7 @@ mod tests { #[tokio::test] async fn rate_limited_is_not_retried() { - let (client, transport) = client(); + let (client, transport) = fake_client(); transport.push( 429, &[], @@ -247,7 +220,7 @@ mod tests { #[tokio::test] async fn unknown_code_is_a_server_error() { - let (client, transport) = client(); + let (client, transport) = fake_client(); transport.push(400, &[], br#"{"code":"brand_new","message":"m"}"#); assert_eq!( @@ -261,7 +234,7 @@ mod tests { #[tokio::test] async fn html_200_is_an_invalid_response() { - let (client, transport) = client(); + let (client, transport) = fake_client(); transport.push(200, &[], b""); assert!(matches!( @@ -272,7 +245,7 @@ mod tests { #[tokio::test] async fn html_502_is_a_server_error() { - let (client, transport) = client(); + let (client, transport) = fake_client(); transport.push(502, &[], b""); assert!(matches!( @@ -283,7 +256,7 @@ mod tests { #[tokio::test] async fn transport_failure_is_network() { - let (client, transport) = client(); + let (client, transport) = fake_client(); transport.push_network_error("offline"); assert_eq!( diff --git a/rust/crates/keygo-client/src/sync/mod.rs b/rust/crates/keygo-client/src/sync/mod.rs index e75c944cd..4143ec334 100644 --- a/rust/crates/keygo-client/src/sync/mod.rs +++ b/rust/crates/keygo-client/src/sync/mod.rs @@ -13,7 +13,7 @@ mod transport; pub use client::{Account, SyncClient}; pub use error::{SyncError, SyncResult}; -pub use signer::{DpopKey, ForeignSigner, SignError}; +pub use signer::{DpopKey, SignError}; pub use state::{Clock, SystemClock}; pub use tokens::{StoredSession, TokenStore, TokenStoreError}; pub use transport::{Header, HttpRequest, HttpResponse, Transport, TransportError}; diff --git a/rust/crates/keygo-client/src/sync/pipeline.rs b/rust/crates/keygo-client/src/sync/pipeline.rs index 37da67cfb..c3560c7de 100644 --- a/rust/crates/keygo-client/src/sync/pipeline.rs +++ b/rust/crates/keygo-client/src/sync/pipeline.rs @@ -1,6 +1,6 @@ use super::client::SyncClient; use super::error::{SyncError, SyncResult, from_response}; -use super::state::{AccessState, AuthState}; +use super::state::AuthState; use super::tokens::{StoredSession, TokenStoreError}; use super::transport::{Header, HttpRequest, HttpResponse}; use keygo_api::auth::Session; @@ -12,19 +12,23 @@ use serde::Serialize; use serde::de::DeserializeOwned; use zeroize::Zeroizing; +fn to_json(value: &T) -> SyncResult> { + serde_json::to_vec(value).map_err(|e| SyncError::Client { + message: format!("request does not serialize: {e}"), + }) +} + /// A serialized `null` (the `()` body) is sent as no body at all. fn encode_body(value: &T) -> SyncResult>> { - let json = serde_json::to_value(value).map_err(|e| SyncError::Client { - message: format!("request does not serialize: {e}"), - })?; - if json.is_null() { - return Ok(None); - } - serde_json::to_vec(&json) - .map(Some) - .map_err(|e| SyncError::Client { - message: format!("request does not serialize: {e}"), - }) + let json = to_json(value)?; + Ok((json != b"null").then_some(json)) +} + +fn json_content_type() -> Header { + Header { + name: "content-type".into(), + value: "application/json".into(), + } } /// An empty body decodes as `null`, so `()` accepts a 204. @@ -53,6 +57,15 @@ fn header_value<'a>(response: &'a HttpResponse, name: &str) -> Option<&'a str> { .map(|h| h.value.as_str()) } +/// Returns whether the response carried a nonce. +fn remember_nonce(response: &HttpResponse, nonce: &mut Option) -> bool { + let fresh = header_value(response, "dpop-nonce"); + if let Some(fresh) = fresh { + *nonce = Some(fresh.to_owned()); + } + fresh.is_some() +} + fn is_nonce_challenge(response: &HttpResponse) -> bool { serde_json::from_slice::(&response.body) .is_ok_and(|error| error.code == ErrorCode::UseDpopNonce) @@ -62,7 +75,7 @@ fn is_success(response: &HttpResponse) -> bool { (200..300).contains(&response.status) } -/// The error body of a failed response. A 2xx is never an error, whatever its body says. +/// A 2xx is never an error, whatever its body says. fn api_error(response: &HttpResponse) -> Option { if is_success(response) { return None; @@ -74,8 +87,7 @@ fn is_invalid_token(response: &HttpResponse) -> bool { api_error(response).is_some_and(|error| error.code == ErrorCode::InvalidToken) } -/// The `SignedOut` a response means, if the server says the session is over. A reason this build -/// does not know is `None`, so a newer server still signs an older app out. +/// An unknown revoke reason becomes `None`, so a newer server can still sign an older app out. fn sign_out_error(response: &HttpResponse) -> Option { let error = api_error(response)?; matches!( @@ -105,9 +117,52 @@ impl SyncClient { .map_err(|e| SyncError::Network { message: e.message }) } - /// Signs and sends one request. A `use_dpop_nonce` challenge that carries a nonce is answered - /// once with a re-signed request; a second challenge is returned as the response. Every - /// `DPoP-Nonce` header the server sends replaces `nonce`. + async fn send_signed( + &self, + method: Method, + url: &str, + access_token: Option<&str>, + body: Option<&[u8]>, + nonce: Option<&str>, + ) -> SyncResult { + let proof = self + .prover + .proof(&ProofRequest { + htm: proof_method(method), + htu: url, + access_token, + nonce, + }) + .map_err(|e| SyncError::Client { + message: format!("could not sign the DPoP proof: {e}"), + })?; + + let mut headers = vec![Header { + name: "dpop".into(), + value: proof, + }]; + if let Some(token) = access_token { + headers.push(Header { + name: "authorization".into(), + value: format!("DPoP {token}"), + }); + } + if body.is_some() { + headers.push(json_content_type()); + } + + self.send(HttpRequest { + method, + url: url.to_owned(), + headers, + body: body.map(<[u8]>::to_vec).unwrap_or_default(), + }) + .await + } + + /// Signs and sends one request, and re-signs once if the server answers with a nonce challenge + /// that carries a nonce. + /// Every `DPoP-Nonce` header the server sends replaces `nonce`. pub(super) async fn exchange( &self, method: Method, @@ -118,72 +173,51 @@ impl SyncClient { ) -> SyncResult { let url = self.url(path); - let mut retried = false; - loop { - let proof = self - .prover - .proof(&ProofRequest { - htm: proof_method(method), - htu: &url, - access_token, - nonce: nonce.as_deref(), - }) - .map_err(|e| SyncError::Client { - message: format!("could not sign the DPoP proof: {e}"), - })?; - - let mut headers = vec![Header { - name: "dpop".into(), - value: proof, - }]; - if let Some(token) = access_token { - headers.push(Header { - name: "authorization".into(), - value: format!("DPoP {token}"), - }); - } - if body.is_some() { - headers.push(Header { - name: "content-type".into(), - value: "application/json".into(), - }); - } - - let response = self - .send(HttpRequest { - method, - url: url.clone(), - headers, - body: body.map(<[u8]>::to_vec).unwrap_or_default(), - }) - .await?; - - let fresh = header_value(&response, "dpop-nonce").map(str::to_owned); - if let Some(fresh) = &fresh { - *nonce = Some(fresh.clone()); - } - - if !retried && fresh.is_some() && is_nonce_challenge(&response) { - retried = true; - continue; - } + let response = self + .send_signed(method, &url, access_token, body, nonce.as_deref()) + .await?; + if !remember_nonce(&response, nonce) || !is_nonce_challenge(&response) { return Ok(response); } + + let response = self + .send_signed(method, &url, access_token, body, nonce.as_deref()) + .await?; + remember_nonce(&response, nonce); + Ok(response) + } + + /// Works on a copy of the nonce, so the `AuthState` lock is not held across the network. + async fn exchange_unlocked( + &self, + method: Method, + path: &str, + access_token: Option<&str>, + body: Option<&[u8]>, + mut nonce: Option, + ) -> SyncResult { + let response = self + .exchange(method, path, access_token, body, &mut nonce) + .await; + self.auth.lock().await.nonce = nonce; + response } - /// Forgets the session, in memory and in the store. The caller holds the `AuthState` lock, so - /// a refresh that is still running cannot save a token after this. + /// The caller holds the `AuthState` lock, so a running refresh cannot save a token after this. /// - /// `AuthState` is reset even when the store fails. What that failure means is the caller's to - /// decide: an entry the server has already killed is only refused and cleared again, but one - /// it still accepts would bring the session back on the next call. + /// `AuthState` is reset even if the store fails. The caller judges that failure: a leftover token + /// the server still accepts would bring the session back. pub(super) async fn end_session(&self, state: &mut AuthState) -> Result<(), TokenStoreError> { state.reset(); self.tokens.clear().await } - /// Writes the rotated session held in `state`, if any. A refusal is not the caller's failure: - /// `state` keeps the live copy and the next call writes it again. + /// The server has killed this token, so a failed clear is harmless. + async fn forget_killed_session(&self, state: &mut AuthState) { + let _ = self.end_session(state).await; + } + + /// If the store refuses, `state` keeps the live copy and the next call tries again. async fn flush_unsaved(&self, state: &mut AuthState) { let Some(unsaved) = &state.unsaved else { return; @@ -193,12 +227,11 @@ impl SyncClient { } } - /// Spends the live refresh token on a new session and returns the new access token. `state` - /// is the locked `AuthState`, held for the whole refresh so concurrent callers share its - /// result. It goes straight to `exchange`, because `call` would take the lock again. + /// Holds the `AuthState` lock for the whole refresh, so concurrent callers share one result. + /// Uses `exchange` directly because `call` would take the lock again. /// - /// The rotated session goes into `state` before it is written, so neither a refused save nor - /// a caller dropped during the write can lose the only copy of the live token. + /// The rotated session goes into `state` before the write, so a refused save or a dropped caller + /// cannot lose the only copy of the live token. async fn refresh_locked(&self, state: &mut AuthState) -> SyncResult> { let refresh_token = match &state.unsaved { Some(unsaved) => unsaved.duplicate().refresh_token, @@ -213,13 +246,9 @@ impl SyncClient { }; let request = TokenRequest { refresh_token }; - // Not `encode_body`: this body is a secret and should not linger in a `Value`. - let body = Zeroizing::new(serde_json::to_vec(&request).map_err(|e| SyncError::Client { - message: format!("request does not serialize: {e}"), - })?); + let body = Zeroizing::new(to_json(&request)?); - // Read before sending, so a token never looks like it lives longer than it does. - let now = self.clock.now_secs(); + let sent_at = self.clock.now_secs(); let response = self .exchange( Token::METHOD, @@ -231,12 +260,13 @@ impl SyncClient { .await?; if !is_success(&response) { - if let Some(signed_out) = sign_out_error(&response) { - // The server has killed this token, so an entry left behind is only refused again. - let _ = self.end_session(state).await; - return Err(signed_out); - } - return Err(from_response(response.status, &response.body)); + return Err(match sign_out_error(&response) { + Some(signed_out) => { + self.forget_killed_session(state).await; + signed_out + } + None => from_response(response.status, &response.body), + }); } let body = Zeroizing::new(response.body); @@ -245,21 +275,16 @@ impl SyncClient { state.unsaved = Some(StoredSession { device_id: session.device_id, refresh_token: session.refresh_token, - refresh_expires_at: now.saturating_add(session.refresh_expires_in), + refresh_expires_at: sent_at.saturating_add(session.refresh_expires_in), }); self.flush_unsaved(state).await; let token = Zeroizing::new(session.access.access_token.expose().to_owned()); - state.replace_access(AccessState { - token: session.access.access_token, - expires_at: now.saturating_add(session.access.access_expires_in), - }); + state.replace_access(session.access, sent_at); Ok(token) } - /// A live access token, refreshed first if there is none, with the generation it belongs to - /// and the nonce to send. The lock is released on return: only a refresh holds it across the - /// network, never the request itself. + /// Only a refresh holds the lock across the network. It is released before the request itself. async fn access_token(&self) -> SyncResult<(Zeroizing, u64, Option)> { let mut state = self.auth.lock().await; self.flush_unsaved(&mut state).await; @@ -272,8 +297,8 @@ impl SyncClient { Ok((token, state.generation, state.nonce.clone())) } - /// Sends one request with the access token. An `invalid_token` earns one refresh and one - /// retry; the refresh is skipped when another caller has already replaced the rejected token. + /// An `invalid_token` earns one retry. The refresh before it is skipped if another caller has + /// already replaced the token. async fn authenticated( &self, method: Method, @@ -282,13 +307,11 @@ impl SyncClient { ) -> SyncResult { let mut retried = false; loop { - let (token, generation, mut nonce) = self.access_token().await?; + let (token, generation, nonce) = self.access_token().await?; let response = self - .exchange(method, path, Some(token.as_str()), body, &mut nonce) - .await; - self.auth.lock().await.nonce = nonce; - let response = response?; + .exchange_unlocked(method, path, Some(token.as_str()), body, nonce) + .await?; if retried || !is_invalid_token(&response) { return Ok(response); @@ -312,28 +335,18 @@ impl SyncClient { let response = match E::AUTH { Auth::None => { - let mut headers = Vec::new(); - if body.is_some() { - headers.push(Header { - name: "content-type".into(), - value: "application/json".into(), - }); - } self.send(HttpRequest { method: E::METHOD, url: self.url(&path), - headers, + headers: body.is_some().then(json_content_type).into_iter().collect(), body: body.unwrap_or_default(), }) .await? } Auth::Proof => { - let mut nonce = self.auth.lock().await.nonce.clone(); - let response = self - .exchange(E::METHOD, &path, None, body.as_deref(), &mut nonce) - .await; - self.auth.lock().await.nonce = nonce; - response? + let nonce = self.auth.lock().await.nonce.clone(); + self.exchange_unlocked(E::METHOD, &path, None, body.as_deref(), nonce) + .await? } Auth::AccessToken => { self.authenticated(E::METHOD, &path, body.as_deref()) @@ -344,20 +357,35 @@ impl SyncClient { if is_success(&response) { return decode_body(&response.body); } - if let Some(signed_out) = sign_out_error(&response) { - let mut state = self.auth.lock().await; - // The server has killed this token, so an entry left behind is only refused again. - let _ = self.end_session(&mut state).await; - return Err(signed_out); - } - Err(from_response(response.status, &response.body)) + Err(match sign_out_error(&response) { + Some(signed_out) => { + self.forget_killed_session(&mut *self.auth.lock().await) + .await; + signed_out + } + None => from_response(response.status, &response.body), + }) } } #[cfg(test)] mod tests { + use super::super::signer::{DpopKey, SignError}; + use super::super::testing::{ + FakeDpopKey, FakeTokenStore, FakeTransport, FixedClock, client_for, error_body, + fake_client, header, + }; + use super::super::tokens::TokenStore; use super::*; + use base64::Engine; + use base64::engine::general_purpose::URL_SAFE_NO_PAD; + use keygo_api::domain::RevokeReason; use keygo_api::meta::ServerInfo; + use keygo_core::DeviceId; + use serde_json::{Value, json}; + use std::sync::Arc; + use std::sync::atomic::{AtomicBool, Ordering}; + use url::Url; #[test] fn empty_body_decodes_as_unit() { @@ -372,43 +400,11 @@ mod tests { )); } - use super::super::client::SyncClient; - use super::super::signer::{DpopKey, SignError}; - use super::super::testing::{FakeDpopKey, FakeTokenStore, FakeTransport, FixedClock}; - use super::super::tokens::TokenStore; - use base64::Engine; - use base64::engine::general_purpose::URL_SAFE_NO_PAD; - use keygo_api::domain::RevokeReason; - use keygo_core::DeviceId; - use serde_json::{Value, json}; - use std::sync::Arc; - use std::sync::atomic::{AtomicBool, Ordering}; - use url::Url; - const SESSION: &str = r#"{"device_id":"00000000-0000-0000-0000-000000000001","access_token":"a.b.c","access_expires_in":300,"refresh_token":"kgr___________________________________________8","refresh_expires_in":86400}"#; const CHALLENGE: &[u8] = br#"{"code":"use_dpop_nonce","message":"m"}"#; - fn client_for(base: &str, key: Arc) -> (SyncClient, Arc) { - let transport = FakeTransport::new(); - let client = SyncClient::new( - Url::parse(base).unwrap(), - transport.clone(), - key, - Arc::new(FakeTokenStore::new()), - ) - .unwrap(); - (client, transport) - } - - fn client() -> (SyncClient, Arc) { - client_for("https://kg.example", Arc::new(FakeDpopKey::new())) - } - fn token_request() -> TokenRequest { - serde_json::from_value(json!({ - "refresh_token": "kgr___________________________________________8", - })) - .unwrap() + serde_json::from_value(json!({"refresh_token": OLD_REFRESH})).unwrap() } fn proof_claims(request: &HttpRequest) -> Value { @@ -417,17 +413,9 @@ mod tests { serde_json::from_slice(&URL_SAFE_NO_PAD.decode(claims).unwrap()).unwrap() } - fn header<'a>(request: &'a HttpRequest, name: &str) -> Option<&'a str> { - request - .headers - .iter() - .find(|h| h.name == name) - .map(|h| h.value.as_str()) - } - #[tokio::test] async fn proof_endpoint_signs_without_ath() { - let (client, transport) = client(); + let (client, transport) = fake_client(); transport.push(200, &[], SESSION.as_bytes()); client.call(&Token, &token_request()).await.ok().unwrap(); @@ -442,7 +430,7 @@ mod tests { #[tokio::test] async fn nonce_challenge_retries_with_the_new_nonce() { - let (client, transport) = client(); + let (client, transport) = fake_client(); transport.push(400, &[("DPoP-Nonce", "n1")], CHALLENGE); transport.push(200, &[], SESSION.as_bytes()); @@ -458,7 +446,7 @@ mod tests { #[tokio::test] async fn second_nonce_challenge_is_returned() { - let (client, transport) = client(); + let (client, transport) = fake_client(); transport.push(400, &[("DPoP-Nonce", "n1")], CHALLENGE); transport.push(400, &[("DPoP-Nonce", "n2")], CHALLENGE); @@ -470,7 +458,7 @@ mod tests { #[tokio::test] async fn challenge_without_header_is_returned() { - let (client, transport) = client(); + let (client, transport) = fake_client(); transport.push(400, &[], CHALLENGE); let error = client.call(&Token, &token_request()).await.err().unwrap(); @@ -481,7 +469,7 @@ mod tests { #[tokio::test] async fn last_nonce_is_reused() { - let (client, transport) = client(); + let (client, transport) = fake_client(); transport.push(400, &[("DPoP-Nonce", "n1")], CHALLENGE); transport.push(200, &[], SESSION.as_bytes()); transport.push(200, &[], SESSION.as_bytes()); @@ -496,7 +484,7 @@ mod tests { #[tokio::test] async fn nonce_on_a_success_is_kept() { - let (client, transport) = client(); + let (client, transport) = fake_client(); transport.push(200, &[("DPoP-Nonce", "n1")], SESSION.as_bytes()); transport.push(200, &[], SESSION.as_bytes()); @@ -510,7 +498,7 @@ mod tests { #[tokio::test] async fn trailing_slash_in_base_url_is_harmless() { - let (plain, plain_transport) = client(); + let (plain, plain_transport) = fake_client(); let (slashed, slashed_transport) = client_for("https://kg.example/", Arc::new(FakeDpopKey::new())); plain_transport.push(200, &[], SESSION.as_bytes()); @@ -561,7 +549,6 @@ mod tests { /// Requests `fresh` has already spent. const FRESH: usize = 2; - /// A `200` from `/auth/token`. fn session(access_token: &str) -> Vec { session_with(access_token, ROTATED_REFRESH) } @@ -577,10 +564,6 @@ mod tests { .unwrap() } - fn error_body(code: &str) -> Vec { - serde_json::to_vec(&json!({"code": code, "message": "m"})).unwrap() - } - fn revoked_body(reason: &str) -> Vec { serde_json::to_vec(&json!({ "code": "session_revoked", @@ -599,18 +582,9 @@ mod tests { impl Harness { fn token_requests(&self) -> usize { - self.transport - .requests() - .iter() - .filter(|r| r.url.ends_with("/api/v1/auth/token")) - .count() - } - - fn stored_refresh_token(&self) -> Option { - self.store.current_refresh_token() + self.spent_tokens().len() } - /// Every refresh token sent so far, in order. fn spent_tokens(&self) -> Vec { self.transport .requests() @@ -631,7 +605,7 @@ mod tests { SyncError::SignedOut { reason: None }, ); assert_eq!(self.transport.requests().len(), sent); - assert_eq!(self.stored_refresh_token(), None); + assert_eq!(self.store.current_refresh_token(), None); } } @@ -665,26 +639,25 @@ mod tests { harness } - /// Holds a live access token: one refresh and one `devices()` have run. - async fn fresh() -> Harness { - let harness = seeded(); + async fn after_first_call(harness: Harness) -> Harness { harness.transport.push(200, &[], &session("a.b.c")); harness.transport.push(200, &[], DEVICES); harness.client.devices().await.unwrap(); harness } + /// Holds a live access token: one refresh and one `devices()` have run. + async fn fresh() -> Harness { + after_first_call(seeded()).await + } + /// Holds a rotated token the store refused, with saves still failing. async fn refused() -> Harness { let harness = seeded(); harness.store.fail_saves(); - harness.transport.push(200, &[], &session("a.b.c")); - harness.transport.push(200, &[], DEVICES); - harness.client.devices().await.unwrap(); - harness + after_first_call(harness).await } - /// Saves any session it is given, except that while `hang` is set `save` never returns. struct HangingStore { inner: FakeTokenStore, hang: AtomicBool, @@ -750,7 +723,10 @@ mod tests { #[tokio::test] async fn rotated_refresh_token_is_saved_and_spent_next() { let h = fresh().await; - assert_eq!(h.stored_refresh_token().as_deref(), Some(ROTATED_REFRESH)); + assert_eq!( + h.store.current_refresh_token().as_deref(), + Some(ROTATED_REFRESH) + ); h.clock.advance(601); h.transport.push(200, &[], &session("d.e.f")); @@ -860,7 +836,10 @@ mod tests { let requests = h.transport.requests(); assert_eq!(requests.len(), 2); assert_eq!(header(&requests[1], "authorization"), Some("DPoP a.b.c")); - assert_eq!(h.stored_refresh_token().as_deref(), Some(OLD_REFRESH)); + assert_eq!( + h.store.current_refresh_token().as_deref(), + Some(OLD_REFRESH) + ); } #[tokio::test] @@ -872,7 +851,10 @@ mod tests { h.client.devices().await.unwrap(); assert_eq!(h.token_requests(), 1); - assert_eq!(h.stored_refresh_token().as_deref(), Some(ROTATED_REFRESH)); + assert_eq!( + h.store.current_refresh_token().as_deref(), + Some(ROTATED_REFRESH) + ); } #[tokio::test] @@ -1129,7 +1111,7 @@ mod tests { reason: Some(RevokeReason::ReuseDetected), }, ); - assert_eq!(h.stored_refresh_token(), None); + assert_eq!(h.store.current_refresh_token(), None); } #[tokio::test] @@ -1155,7 +1137,7 @@ mod tests { h.client.devices().await.unwrap_err(), SyncError::SignedOut { reason: None }, ); - assert_eq!(h.stored_refresh_token(), None); + assert_eq!(h.store.current_refresh_token(), None); } #[tokio::test] @@ -1167,7 +1149,7 @@ mod tests { h.client.devices().await.unwrap_err(), SyncError::SignedOut { reason: None }, ); - assert_eq!(h.stored_refresh_token(), None); + assert_eq!(h.store.current_refresh_token(), None); } #[tokio::test] @@ -1178,7 +1160,10 @@ mod tests { let error = h.client.devices().await.unwrap_err(); assert!(matches!(error, SyncError::Server { code, .. } if code == "invalid_response")); - assert_eq!(h.stored_refresh_token().as_deref(), Some(ROTATED_REFRESH)); + assert_eq!( + h.store.current_refresh_token().as_deref(), + Some(ROTATED_REFRESH) + ); } #[tokio::test] @@ -1189,7 +1174,10 @@ mod tests { let error = h.client.devices().await.unwrap_err(); assert!(matches!(error, SyncError::Network { .. })); - assert_eq!(h.stored_refresh_token().as_deref(), Some(OLD_REFRESH)); + assert_eq!( + h.store.current_refresh_token().as_deref(), + Some(OLD_REFRESH) + ); } #[tokio::test] @@ -1226,8 +1214,11 @@ mod tests { assert!(matches!(error, SyncError::Client { .. })); assert!(h.client.auth.lock().await.access().is_none()); - // Why this cannot pass as an offline logout: the server still accepts this token. - assert_eq!(h.stored_refresh_token().as_deref(), Some(ROTATED_REFRESH)); + // The server still accepts this token, so this cannot pass as an offline logout. + assert_eq!( + h.store.current_refresh_token().as_deref(), + Some(ROTATED_REFRESH) + ); } #[tokio::test] @@ -1274,7 +1265,10 @@ mod tests { () = std::future::ready(()) => {} } assert!(h.transport.requests().is_empty()); - assert_eq!(h.stored_refresh_token().as_deref(), Some(OLD_REFRESH)); + assert_eq!( + h.store.current_refresh_token().as_deref(), + Some(OLD_REFRESH) + ); h.transport.push(200, &[], &session("a.b.c")); h.transport.push(200, &[], DEVICES); diff --git a/rust/crates/keygo-client/src/sync/state.rs b/rust/crates/keygo-client/src/sync/state.rs index 5d2e6ec23..d08aa1870 100644 --- a/rust/crates/keygo-client/src/sync/state.rs +++ b/rust/crates/keygo-client/src/sync/state.rs @@ -1,4 +1,5 @@ use super::tokens::StoredSession; +use keygo_api::auth::Access; use keygo_api::domain::AccessToken; use std::time::{SystemTime, UNIX_EPOCH}; @@ -8,14 +9,12 @@ pub(super) struct AccessState { pub(super) expires_at: u64, } -/// What the client remembers between calls. #[derive(Default)] pub(super) struct AuthState { access: Option, - /// The last `DPoP-Nonce` the server sent. pub(super) nonce: Option, - /// Changes whenever `access` does. A call remembers the value its token came with, so when - /// that token is rejected it can tell whether someone has already replaced it. + /// Moves whenever `access` changes. A call whose token was rejected uses it to tell whether + /// someone has already replaced that token. pub(super) generation: u64, /// A rotated session the store has not accepted yet. Until it does, the store may still hold /// the spent token, which the server would treat as reuse, so this copy wins over the store. @@ -28,13 +27,18 @@ impl AuthState { } /// The only way to set the access token, so `generation` cannot be left behind. - pub(super) fn replace_access(&mut self, access: AccessState) { - self.access = Some(access); + /// + /// `sent_at` is read before the request, so a token never looks like it lives longer than it does. + pub(super) fn replace_access(&mut self, access: Access, sent_at: u64) { + self.access = Some(AccessState { + token: access.access_token, + expires_at: sent_at.saturating_add(access.access_expires_in), + }); self.generation += 1; } - /// Forgets the session. `generation` moves on rather than restarting, so a call still holding - /// a token from before cannot mistake a later one for its own. + /// `generation` moves on rather than restarting, so a call holding an old token cannot mistake + /// a new one for its own. pub(super) fn reset(&mut self) { self.access = None; self.nonce = None; @@ -66,10 +70,13 @@ mod tests { fn replacing_access_moves_the_generation() { let mut state = AuthState::default(); let before = state.generation; - state.replace_access(AccessState { - token: serde_json::from_value(serde_json::json!("a.b.c")).unwrap(), - expires_at: 1, - }); + state.replace_access( + Access { + access_token: serde_json::from_value(serde_json::json!("a.b.c")).unwrap(), + access_expires_in: 1, + }, + 0, + ); assert_eq!(state.generation, before + 1); assert!(state.access().is_some()); } diff --git a/rust/crates/keygo-client/src/sync/testing.rs b/rust/crates/keygo-client/src/sync/testing.rs index 9b5794baa..3a82f0008 100644 --- a/rust/crates/keygo-client/src/sync/testing.rs +++ b/rust/crates/keygo-client/src/sync/testing.rs @@ -1,5 +1,4 @@ -//! Fakes for the three host traits and the clock. - +use super::client::SyncClient; use super::signer::{DpopKey, SignError}; use super::state::Clock; use super::tokens::{StoredSession, TokenStore, TokenStoreError}; @@ -9,8 +8,36 @@ use keygo_dpop::testing::TestSigner; use std::collections::VecDeque; use std::sync::atomic::{AtomicBool, AtomicU64, Ordering}; use std::sync::{Arc, Mutex}; +use url::Url; + +pub fn client_for(base: &str, key: Arc) -> (SyncClient, Arc) { + let transport = FakeTransport::new(); + let client = SyncClient::new( + Url::parse(base).unwrap(), + transport.clone(), + key, + Arc::new(FakeTokenStore::new()), + ) + .unwrap(); + (client, transport) +} + +pub fn fake_client() -> (SyncClient, Arc) { + client_for("https://kg.example", Arc::new(FakeDpopKey::new())) +} + +pub fn header<'a>(request: &'a HttpRequest, name: &str) -> Option<&'a str> { + request + .headers + .iter() + .find(|h| h.name == name) + .map(|h| h.value.as_str()) +} + +pub fn error_body(code: &str) -> Vec { + serde_json::to_vec(&serde_json::json!({"code": code, "message": "m"})).unwrap() +} -/// Answers from a script and records what it was sent. pub struct FakeTransport { script: Mutex>>, requests: Mutex>, @@ -63,29 +90,28 @@ impl Transport for FakeTransport { } } -/// Keeps the session in memory. `RefreshToken` is not `Clone`, so it is stored encoded. +#[derive(Default)] pub struct FakeTokenStore { - stored: Mutex>, + stored: Mutex>, fail_saves: AtomicBool, fail_clears: AtomicBool, } impl FakeTokenStore { pub fn new() -> Self { - Self { - stored: Mutex::new(None), - fail_saves: AtomicBool::new(false), - fail_clears: AtomicBool::new(false), - } + Self::default() } pub fn seed(&self, session: StoredSession) { - *self.stored.lock().unwrap() = Some(encode(&session)); + *self.stored.lock().unwrap() = Some(session); } - /// The stored refresh token in its encoded form. pub fn current_refresh_token(&self) -> Option { - self.stored.lock().unwrap().as_ref().map(|s| s.1.clone()) + self.stored + .lock() + .unwrap() + .as_ref() + .map(|s| s.refresh_token.expose_encoded().to_string()) } pub fn fail_saves(&self) { @@ -101,20 +127,6 @@ impl FakeTokenStore { } } -impl Default for FakeTokenStore { - fn default() -> Self { - Self::new() - } -} - -fn encode(session: &StoredSession) -> (keygo_core::DeviceId, String, u64) { - ( - session.device_id, - session.refresh_token.expose_encoded().to_string(), - session.refresh_expires_at, - ) -} - #[async_trait] impl TokenStore for FakeTokenStore { async fn load(&self) -> Result, TokenStoreError> { @@ -123,11 +135,7 @@ impl TokenStore for FakeTokenStore { .lock() .unwrap() .as_ref() - .map(|(id, token, exp)| StoredSession { - device_id: *id, - refresh_token: token.parse().expect("stored token is valid"), - refresh_expires_at: *exp, - })) + .map(StoredSession::duplicate)) } async fn save(&self, session: &StoredSession) -> Result<(), TokenStoreError> { @@ -136,7 +144,7 @@ impl TokenStore for FakeTokenStore { message: "save failed".into(), }); } - *self.stored.lock().unwrap() = Some(encode(session)); + *self.stored.lock().unwrap() = Some(session.duplicate()); Ok(()) } From 86f3f981cbc17e360d119fec8e6f3030db007690 Mon Sep 17 00:00:00 2001 From: Davis Date: Tue, 10 Nov 2026 11:40:22 +0100 Subject: [PATCH 24/52] refactor(uniffi): remove sync binding boilerplate Generate the callback error types with a macro, expose HttpResponse as a remote record, and make detached a method that hands out the client. Co-Authored-By: Claude Opus 5.5 --- rust/crates/keygo-uniffi/src/sync.rs | 221 +++++++++++---------------- 1 file changed, 87 insertions(+), 134 deletions(-) diff --git a/rust/crates/keygo-uniffi/src/sync.rs b/rust/crates/keygo-uniffi/src/sync.rs index b86465600..428ea46f5 100644 --- a/rust/crates/keygo-uniffi/src/sync.rs +++ b/rust/crates/keygo-uniffi/src/sync.rs @@ -5,9 +5,9 @@ use keygo_api::meta::ServerInfo; use keygo_client::crypto::{DeviceId, UserId}; use keygo_client::sync::{ Account as CoreAccount, DpopKey as CoreDpopKey, Header, HttpRequest as CoreHttpRequest, - HttpResponse as CoreHttpResponse, SignError as CoreSignError, - StoredSession as CoreStoredSession, SyncClient as CoreSyncClient, SyncError as CoreSyncError, - SyncResult, TokenStore as CoreTokenStore, TokenStoreError as CoreTokenStoreError, + HttpResponse, SignError as CoreSignError, StoredSession as CoreStoredSession, + SyncClient as CoreSyncClient, SyncError as CoreSyncError, SyncResult, + TokenStore as CoreTokenStore, TokenStoreError as CoreTokenStoreError, Transport as CoreTransport, TransportError as CoreTransportError, }; use std::fmt::Display; @@ -65,68 +65,36 @@ impl From for SyncError { } } -#[derive(Debug, thiserror::Error, uniffi::Error)] -pub enum TransportError { - #[error("{reason}")] - Failed { reason: String }, -} - -impl From for TransportError { - fn from(error: uniffi::UnexpectedUniFFICallbackError) -> Self { - Self::Failed { - reason: error.reason, +macro_rules! callback_error { + ($($name:ident => $core:ident),+ $(,)?) => {$( + #[derive(Debug, thiserror::Error, uniffi::Error)] + pub enum $name { + #[error("{reason}")] + Failed { reason: String }, } - } -} - -impl From for CoreTransportError { - fn from(error: TransportError) -> Self { - let TransportError::Failed { reason } = error; - Self { message: reason } - } -} - -#[derive(Debug, thiserror::Error, uniffi::Error)] -pub enum SignError { - #[error("{reason}")] - Failed { reason: String }, -} -impl From for SignError { - fn from(error: uniffi::UnexpectedUniFFICallbackError) -> Self { - Self::Failed { - reason: error.reason, + impl From for $name { + fn from(error: uniffi::UnexpectedUniFFICallbackError) -> Self { + Self::Failed { + reason: error.reason, + } + } } - } -} - -impl From for CoreSignError { - fn from(error: SignError) -> Self { - let SignError::Failed { reason } = error; - Self { message: reason } - } -} -#[derive(Debug, thiserror::Error, uniffi::Error)] -pub enum TokenStoreError { - #[error("{reason}")] - Failed { reason: String }, -} - -impl From for TokenStoreError { - fn from(error: uniffi::UnexpectedUniFFICallbackError) -> Self { - Self::Failed { - reason: error.reason, + impl From<$name> for $core { + fn from(error: $name) -> Self { + let $name::Failed { reason } = error; + Self { message: reason } + } } - } + )+}; } -impl From for CoreTokenStoreError { - fn from(error: TokenStoreError) -> Self { - let TokenStoreError::Failed { reason } = error; - Self { message: reason } - } -} +callback_error!( + TransportError => CoreTransportError, + SignError => CoreSignError, + TokenStoreError => CoreTokenStoreError, +); #[uniffi::remote(Record)] pub struct Header { @@ -153,23 +121,13 @@ impl From for HttpRequest { } } -#[derive(uniffi::Record)] +#[uniffi::remote(Record)] pub struct HttpResponse { pub status: u16, pub headers: Vec
, pub body: Vec, } -impl From for CoreHttpResponse { - fn from(response: HttpResponse) -> Self { - Self { - status: response.status, - headers: response.headers, - body: response.body, - } - } -} - #[derive(uniffi::Record)] pub struct StoredSession { pub device_id: DeviceId, @@ -260,8 +218,8 @@ impl From for Account { } } -/// Sends one HTTP request. The host owns TLS, timeouts and connection pooling; it must not retry, -/// follow auth challenges or log bodies. +/// The host owns TLS, timeouts and pooling. +/// It must not retry, follow auth challenges or log bodies. #[uniffi::export(with_foreign)] #[async_trait] pub trait HttpTransport: Send + Sync { @@ -274,14 +232,12 @@ pub trait DpopKey: Send + Sync { /// The 65-byte uncompressed P-256 point. fn public_key(&self) -> Result, SignError>; /// SHA256withECDSA over `message`, DER encoded. + /// Can be called from several threads at once. fn sign(&self, message: Vec) -> Result, SignError>; } -/// Durable home of the refresh token. The host decides how it is protected. -/// -/// `save` runs while the client holds its auth lock, so it must return in bounded time: one that -/// never returns blocks every later call, including logout. A refused `save` is repeated on later -/// calls. +/// `save` runs under the client's auth lock, so it must return in bounded time: a hung `save` +/// blocks every later call, including logout. A refused `save` is retried on later calls. #[uniffi::export(with_foreign)] #[async_trait] pub trait TokenStore: Send + Sync { @@ -294,8 +250,8 @@ struct TransportAdapter(Arc); #[async_trait] impl CoreTransport for TransportAdapter { - async fn send(&self, request: CoreHttpRequest) -> Result { - Ok(self.0.send(request.into()).await?.into()) + async fn send(&self, request: CoreHttpRequest) -> Result { + Ok(self.0.send(request.into()).await?) } } @@ -340,31 +296,31 @@ impl CoreTokenStore for StoreAdapter { } } -/// Runs `call` as its own task and waits for it. Dropping the returned future only stops the -/// waiting, and a panic in the task ends at the `JoinError` instead of crossing the FFI. -async fn detached(call: C) -> Result -where - T: Send + 'static, - C: Future> + Send + 'static, -{ - tokio::spawn(call) - .await - .map_err(|_| SyncError::Client { - reason: "the sync task did not finish".into(), - })? - .map_err(Into::into) -} - -/// The sync client, over the host's HTTP stack, DPoP key and token store. -/// -/// Every call runs as its own task, so cancelling the coroutine waiting for one leaves it running. -/// Refresh tokens rotate with no grace window: abandoning a refresh the server has committed would -/// lose the new token, and the next refresh would revoke the session as `reuse_detected`. +/// Every call runs as its own task: abandoning a refresh the server has committed would lose the +/// new token, and the next refresh would revoke the session as `reuse_detected`. #[derive(uniffi::Object)] pub struct SyncClient { inner: Arc, } +impl SyncClient { + /// Dropping the returned future only stops the waiting, and a panic in the task stops at the + /// `JoinError` instead of crossing the FFI. + async fn detached(&self, call: F) -> Result + where + T: Send + 'static, + F: FnOnce(Arc) -> C + Send, + C: Future> + Send + 'static, + { + tokio::spawn(call(self.inner.clone())) + .await + .map_err(|_| SyncError::Client { + reason: "the sync task did not finish".into(), + })? + .map_err(Into::into) + } +} + #[uniffi::export(async_runtime = "tokio")] impl SyncClient { #[uniffi::constructor] @@ -389,8 +345,8 @@ impl SyncClient { } pub async fn meta(&self) -> Result { - let client = self.inner.clone(); - detached(async move { client.meta().await }).await + self.detached(|client| async move { client.meta().await }) + .await } pub async fn register( @@ -404,20 +360,20 @@ impl SyncClient { ) -> Result { let password = Zeroizing::new(password); let device = device.into_core()?; - let client = self.inner.clone(); - let account = detached(async move { - client - .register( - &ark.session, - user_id, - &username, - &password, - invite.as_deref(), - device, - ) - .await - }) - .await?; + let account = self + .detached(|client| async move { + client + .register( + &ark.session, + user_id, + &username, + &password, + invite.as_deref(), + device, + ) + .await + }) + .await?; Ok(account.into()) } @@ -430,36 +386,37 @@ impl SyncClient { ) -> Result { let password = Zeroizing::new(password); let device = device.into_core()?; - let client = self.inner.clone(); - let account = detached(async move { - client - .login(&ark.session, &username, &password, device) - .await - }) - .await?; + let account = self + .detached(|client| async move { + client + .login(&ark.session, &username, &password, device) + .await + }) + .await?; Ok(account.into()) } pub async fn step_up(&self, password: String) -> Result<(), SyncError> { let password = Zeroizing::new(password); - let client = self.inner.clone(); - detached(async move { client.step_up(&password).await }).await + self.detached(|client| async move { client.step_up(&password).await }) + .await } pub async fn devices(&self) -> Result, SyncError> { - let client = self.inner.clone(); - let devices = detached(async move { client.devices().await }).await?; + let devices = self + .detached(|client| async move { client.devices().await }) + .await?; Ok(devices.into_iter().map(SyncDevice::from).collect()) } pub async fn delete_device(&self, id: DeviceId) -> Result<(), SyncError> { - let client = self.inner.clone(); - detached(async move { client.delete_device(id).await }).await + self.detached(|client| async move { client.delete_device(id).await }) + .await } pub async fn logout(&self) -> Result<(), SyncError> { - let client = self.inner.clone(); - detached(async move { client.logout().await }).await + self.detached(|client| async move { client.logout().await }) + .await } } @@ -474,9 +431,7 @@ mod tests { use tokio::sync::Notify; use tokio::time::timeout; - /// Decodes to 32 bytes of `0xff`. const STORED_TOKEN: &str = "kgr___________________________________________8"; - /// Decodes to 32 bytes of zero: what the server rotates [`STORED_TOKEN`] to. const ROTATED_TOKEN: &str = "kgr_AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"; const ROTATED_SESSION: &str = r#"{"device_id":"00000000-0000-0000-0000-000000000001","access_token":"a.b.c","access_expires_in":300,"refresh_token":"kgr_AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA","refresh_expires_in":86400}"#; @@ -561,7 +516,6 @@ mod tests { } } - /// Announces each request and holds it until released, then answers with a rotated session. #[derive(Default)] struct GatedTransport { reached: Notify, @@ -684,8 +638,7 @@ mod tests { assert_eq!(*transport.methods.lock().unwrap(), ["DELETE"]); } - /// A Kotlin coroutine that is cancelled drops the future. The rotated refresh token must still - /// reach the store, because rotation has no grace window and losing it signs the user out. + /// A cancelled Kotlin coroutine drops the future, but the rotated token must still reach the store. #[tokio::test] async fn a_dropped_call_still_finishes() { let transport = Arc::new(GatedTransport::default()); From f6de20eb9b1424d455bfd3ab0c0876da227492e9 Mon Sep 17 00:00:00 2001 From: Davis Date: Tue, 10 Nov 2026 11:40:22 +0100 Subject: [PATCH 25/52] refactor(sync): simplify OkHttpTransport Stop using OkHttp's internal HttpMethod, since POST is the only method the API sends that requires a body, and resume the continuation from one place. Co-Authored-By: Claude Opus 5.5 --- .../keygo/core/sync/data/OkHttpTransport.kt | 16 +++++----------- 1 file changed, 5 insertions(+), 11 deletions(-) diff --git a/core/sync/src/main/kotlin/de/davis/keygo/core/sync/data/OkHttpTransport.kt b/core/sync/src/main/kotlin/de/davis/keygo/core/sync/data/OkHttpTransport.kt index fa65b7aae..a3d046cdc 100644 --- a/core/sync/src/main/kotlin/de/davis/keygo/core/sync/data/OkHttpTransport.kt +++ b/core/sync/src/main/kotlin/de/davis/keygo/core/sync/data/OkHttpTransport.kt @@ -12,19 +12,15 @@ import okhttp3.OkHttpClient import okhttp3.Request import okhttp3.RequestBody.Companion.toRequestBody import okhttp3.Response -import okhttp3.internal.http.HttpMethod import java.io.IOException import java.util.concurrent.TimeUnit import kotlin.coroutines.resume import kotlin.coroutines.resumeWithException -/** - * Sends the requests the Rust sync client builds. Headers, auth included, pass through untouched. - * Never log [HttpRequest] or [HttpResponse]: their `toString()` prints tokens. - */ +/** Never log [HttpRequest] or [HttpResponse]: their `toString()` prints tokens. */ class OkHttpTransport(client: OkHttpClient) : HttpTransport { - // A DPoP proof is bound to one URL, so a redirect could not succeed anyway. + // No redirects: a DPoP proof is bound to one URL. private val client = client.newBuilder() .retryOnConnectionFailure(false) .followRedirects(false) @@ -48,13 +44,11 @@ class OkHttpTransport(client: OkHttpClient) : HttpTransport { } override fun onResponse(call: Call, response: Response) { - val result = try { - response.use { it.toRust() } + try { + continuation.resume(response.use { it.toRust() }) } catch (e: IOException) { continuation.resumeWithException(e.toTransportException()) - return } - continuation.resume(result) } }) } @@ -62,7 +56,7 @@ class OkHttpTransport(client: OkHttpClient) : HttpTransport { private fun HttpRequest.toOkHttp(): Request { val requestBody = - if (body.isEmpty() && !HttpMethod.requiresRequestBody(method)) null + if (body.isEmpty() && method != "POST") null else body.toRequestBody(null) return Request.Builder() From 1ac26a709e8408ffb152fd83cb34e05e1c3d5882 Mon Sep 17 00:00:00 2001 From: Davis Date: Tue, 10 Nov 2026 11:40:22 +0100 Subject: [PATCH 26/52] docs: trim comments on the sync API and test fixtures Co-Authored-By: Claude Opus 5.5 --- .../kotlin/de/davis/keygo/rust/FakeSyncClient.kt | 4 ---- rust/crates/keygo-api/src/auth/handshake.rs | 2 +- rust/crates/keygo-api/src/domain/ids.rs | 4 ++-- rust/crates/keygo-api/src/endpoint.rs | 2 -- rust/crates/keygo-api/src/error.rs | 7 ++----- rust/crates/keygo-client/Cargo.toml | 1 - rust/crates/keygo-client/src/sync/error.rs | 2 +- rust/crates/keygo-client/src/sync/tokens.rs | 9 +++------ rust/crates/keygo-client/src/sync/transport.rs | 4 ++-- rust/crates/keygo-dpop/src/testing.rs | 4 ++-- rust/crates/keygo-e2e/src/lib.rs | 5 ++--- 11 files changed, 15 insertions(+), 29 deletions(-) diff --git a/core/rust/src/testFixtures/kotlin/de/davis/keygo/rust/FakeSyncClient.kt b/core/rust/src/testFixtures/kotlin/de/davis/keygo/rust/FakeSyncClient.kt index df3e92181..910409f1c 100644 --- a/core/rust/src/testFixtures/kotlin/de/davis/keygo/rust/FakeSyncClient.kt +++ b/core/rust/src/testFixtures/kotlin/de/davis/keygo/rust/FakeSyncClient.kt @@ -9,10 +9,6 @@ import de.davisalessandro.keygo.rust.SyncClientInterface import de.davisalessandro.keygo.rust.SyncDevice import de.davisalessandro.keygo.rust.UserId -/** - * Each method returns its result var, or throws it when it is a failure. Results without a useful - * default stay null until a test sets them, and reading one then fails loudly. - */ class FakeSyncClient : SyncClientInterface { var deleteDeviceResult: Result = Result.success(Unit) diff --git a/rust/crates/keygo-api/src/auth/handshake.rs b/rust/crates/keygo-api/src/auth/handshake.rs index 5c44bd14e..42238fad0 100644 --- a/rust/crates/keygo-api/src/auth/handshake.rs +++ b/rust/crates/keygo-api/src/auth/handshake.rs @@ -2,7 +2,7 @@ use crate::domain::LoginId; use keygo_opaque::CredentialResponse; use serde::{Deserialize, Serialize}; -/// The first answer of an OPAQUE login, shared by sign-in and step-up. +/// Shared by sign-in and step-up. #[derive(Serialize, Deserialize)] pub struct StartResponse { pub login_id: LoginId, diff --git a/rust/crates/keygo-api/src/domain/ids.rs b/rust/crates/keygo-api/src/domain/ids.rs index 451c44270..3ea2c5ad1 100644 --- a/rust/crates/keygo-api/src/domain/ids.rs +++ b/rust/crates/keygo-api/src/domain/ids.rs @@ -53,10 +53,10 @@ macro_rules! random_id { } random_id! { - /// Handle for a pending registration, between `register/start` and `register/finish`. + /// Handle for one pending registration, from start to finish. RegistrationId as "registration_id"; - /// Handle for a login handshake, between `login/start` and `login/finish`. + /// Handle for one OPAQUE login or step-up, from start to finish. LoginId as "login_id"; } diff --git a/rust/crates/keygo-api/src/endpoint.rs b/rust/crates/keygo-api/src/endpoint.rs index 61960c8e9..fdc674807 100644 --- a/rust/crates/keygo-api/src/endpoint.rs +++ b/rust/crates/keygo-api/src/endpoint.rs @@ -5,7 +5,6 @@ use std::borrow::Cow; /// What a request must carry for the server to accept it. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum Auth { - /// Nothing. None, /// A DPoP proof, but no access token. Proof, @@ -30,7 +29,6 @@ impl Method { } } -/// One route of the sync API, with the types that cross the wire. pub trait Endpoint { /// `()` when the route takes no body. type Request: Serialize + DeserializeOwned; diff --git a/rust/crates/keygo-api/src/error.rs b/rust/crates/keygo-api/src/error.rs index 932c67b0e..0f5391a76 100644 --- a/rust/crates/keygo-api/src/error.rs +++ b/rust/crates/keygo-api/src/error.rs @@ -1,9 +1,7 @@ use serde::{Deserialize, Serialize}; -/// Every `code` the API answers with; clients match on the serialized name. -/// -/// A code this build does not know decodes as [`ErrorCode::Unknown`], so a -/// newer server never breaks an older client. +/// Clients match on the serialized name. A code this build does not know becomes +/// `Unknown`, so a newer server cannot break an older client. #[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum ErrorCode { @@ -33,7 +31,6 @@ pub enum ErrorCode { Unknown, } -/// The JSON body of every error response. #[derive(Debug, Serialize, Deserialize)] pub struct ApiError { pub code: ErrorCode, diff --git a/rust/crates/keygo-client/Cargo.toml b/rust/crates/keygo-client/Cargo.toml index b66ade11c..0bcdba854 100644 --- a/rust/crates/keygo-client/Cargo.toml +++ b/rust/crates/keygo-client/Cargo.toml @@ -4,7 +4,6 @@ version.workspace = true edition.workspace = true [features] -# Exposes `sync::testing` (fake transport, token store, key and clock) to other crates' tests. test-support = ["keygo-dpop/test-support", "tokio/rt"] [dependencies] diff --git a/rust/crates/keygo-client/src/sync/error.rs b/rust/crates/keygo-client/src/sync/error.rs index 70f0cc9f4..74fc6796d 100644 --- a/rust/crates/keygo-client/src/sync/error.rs +++ b/rust/crates/keygo-client/src/sync/error.rs @@ -38,7 +38,7 @@ impl SyncError { } } -/// Maps a non-2xx response. `session_revoked` and `refresh_expired` end the session before this. +/// `session_revoked` and `refresh_expired` never reach this: they end the session first. pub(super) fn from_response(status: u16, body: &[u8]) -> SyncError { let Ok(error) = serde_json::from_slice::(body) else { return SyncError::Server { diff --git a/rust/crates/keygo-client/src/sync/tokens.rs b/rust/crates/keygo-client/src/sync/tokens.rs index 0567e2706..3e2816908 100644 --- a/rust/crates/keygo-client/src/sync/tokens.rs +++ b/rust/crates/keygo-client/src/sync/tokens.rs @@ -9,7 +9,7 @@ pub struct StoredSession { } impl StoredSession { - /// A second copy of the session. `RefreshToken` is not `Clone`, so it goes through its encoding. + /// `RefreshToken` is not `Clone`, so this copies through its encoding. pub(super) fn duplicate(&self) -> Self { Self { device_id: self.device_id, @@ -29,11 +29,8 @@ pub struct TokenStoreError { pub message: String, } -/// Durable home of the refresh token. The host decides how it is protected. -/// -/// `save` runs while the client holds its auth lock, so it must return in bounded time: one that -/// never returns blocks every later call, including logout. A refused `save` is repeated on later -/// calls. +/// `save` runs under the client's auth lock, so it must return in bounded time: a hung `save` +/// blocks every later call, including logout. A refused `save` is retried on later calls. #[async_trait] pub trait TokenStore: Send + Sync { async fn load(&self) -> Result, TokenStoreError>; diff --git a/rust/crates/keygo-client/src/sync/transport.rs b/rust/crates/keygo-client/src/sync/transport.rs index a4df9fe53..1d063c050 100644 --- a/rust/crates/keygo-client/src/sync/transport.rs +++ b/rust/crates/keygo-client/src/sync/transport.rs @@ -65,8 +65,8 @@ pub struct TransportError { pub message: String, } -/// Sends one HTTP request. The host owns TLS, timeouts and connection pooling; -/// it must not retry, follow auth challenges or log bodies. +/// The host owns TLS, timeouts and pooling. +/// It must not retry, follow auth challenges or log bodies. #[async_trait] pub trait Transport: Send + Sync { async fn send(&self, request: HttpRequest) -> Result; diff --git a/rust/crates/keygo-dpop/src/testing.rs b/rust/crates/keygo-dpop/src/testing.rs index a5fa38967..d4ae21957 100644 --- a/rust/crates/keygo-dpop/src/testing.rs +++ b/rust/crates/keygo-dpop/src/testing.rs @@ -14,7 +14,7 @@ impl TestSigner { Self(SigningKey::from_slice(&[seed; 32]).unwrap()) } - /// The 65-byte uncompressed SEC1 point, as a platform keystore exports it. + /// Matches what a platform keystore exports. pub fn public_key_sec1(&self) -> Vec { self.0 .verifying_key() @@ -23,7 +23,7 @@ impl TestSigner { .to_vec() } - /// An ASN.1 DER signature, as a platform keystore produces it. + /// Matches what a platform keystore produces. pub fn sign_der(&self, msg: &[u8]) -> Vec { let sig: Signature = self.0.sign(msg); sig.to_der().as_bytes().to_vec() diff --git a/rust/crates/keygo-e2e/src/lib.rs b/rust/crates/keygo-e2e/src/lib.rs index 341f98125..664a2a768 100644 --- a/rust/crates/keygo-e2e/src/lib.rs +++ b/rust/crates/keygo-e2e/src/lib.rs @@ -1,3 +1,2 @@ -//! End-to-end tests: the real `SyncClient` against the real `keygo-server` router, with real -//! OPAQUE and real DPoP. This is the only crate that builds both sides together, so it is where -//! the shipped server's feature set (no `crypto`) stays untouched by the client's. +//! The real `SyncClient` against the real `keygo-server` router, with real OPAQUE and DPoP. +//! Only this crate builds both sides, so the client's features never reach the shipped server. From cff175cd2cdd541237eee3005c2e426ec08c55fe Mon Sep 17 00:00:00 2001 From: Davis Date: Tue, 10 Nov 2026 12:58:57 +0100 Subject: [PATCH 27/52] refactor(client): add better url parsing --- rust/crates/keygo-api/src/endpoint.rs | 2 +- rust/crates/keygo-client/src/sync/client.rs | 15 +++++++++++++++ rust/crates/keygo-client/src/sync/error.rs | 2 ++ rust/crates/keygo-client/src/sync/pipeline.rs | 8 ++++---- rust/crates/keygo-uniffi/src/sync.rs | 5 +++++ 5 files changed, 27 insertions(+), 5 deletions(-) diff --git a/rust/crates/keygo-api/src/endpoint.rs b/rust/crates/keygo-api/src/endpoint.rs index fdc674807..340bef45d 100644 --- a/rust/crates/keygo-api/src/endpoint.rs +++ b/rust/crates/keygo-api/src/endpoint.rs @@ -1,5 +1,5 @@ -use serde::Serialize; use serde::de::DeserializeOwned; +use serde::Serialize; use std::borrow::Cow; /// What a request must carry for the server to accept it. diff --git a/rust/crates/keygo-client/src/sync/client.rs b/rust/crates/keygo-client/src/sync/client.rs index 95dd76895..6a359b289 100644 --- a/rust/crates/keygo-client/src/sync/client.rs +++ b/rust/crates/keygo-client/src/sync/client.rs @@ -33,6 +33,20 @@ pub struct SyncClient { pub(super) auth: Mutex, } +fn check_base_url(url: &Url) -> SyncResult<()> { + let is_origin = matches!(url.scheme(), "http" | "https") + && url.has_host() + && url.path() == "/" + && url.query().is_none() + && url.fragment().is_none(); + if is_origin { + return Ok(()); + } + Err(SyncError::Client { + message: "the server url must be a plain http(s) origin".into(), + }) +} + impl SyncClient { pub fn new( base_url: Url, @@ -40,6 +54,7 @@ impl SyncClient { key: Arc, tokens: Arc, ) -> SyncResult { + check_base_url(&base_url)?; Ok(Self { base_url, transport, diff --git a/rust/crates/keygo-client/src/sync/error.rs b/rust/crates/keygo-client/src/sync/error.rs index 74fc6796d..669602692 100644 --- a/rust/crates/keygo-client/src/sync/error.rs +++ b/rust/crates/keygo-client/src/sync/error.rs @@ -27,6 +27,8 @@ pub enum SyncError { Server { code: String, message: String }, #[error("client error: {message}")] Client { message: String }, + #[error(transparent)] + InvalidUrl(#[from] url::ParseError), } impl SyncError { diff --git a/rust/crates/keygo-client/src/sync/pipeline.rs b/rust/crates/keygo-client/src/sync/pipeline.rs index c3560c7de..4254d41ee 100644 --- a/rust/crates/keygo-client/src/sync/pipeline.rs +++ b/rust/crates/keygo-client/src/sync/pipeline.rs @@ -106,8 +106,8 @@ pub(super) fn store_failure(error: TokenStoreError) -> SyncError { } impl SyncClient { - fn url(&self, path: &str) -> String { - format!("{}{}", self.base_url.as_str().trim_end_matches('/'), path) + fn url(&self, path: &str) -> SyncResult { + Ok(self.base_url.join(path)?.to_string()) } async fn send(&self, request: HttpRequest) -> SyncResult { @@ -171,7 +171,7 @@ impl SyncClient { body: Option<&[u8]>, nonce: &mut Option, ) -> SyncResult { - let url = self.url(path); + let url = self.url(path)?; let response = self .send_signed(method, &url, access_token, body, nonce.as_deref()) @@ -337,7 +337,7 @@ impl SyncClient { Auth::None => { self.send(HttpRequest { method: E::METHOD, - url: self.url(&path), + url: self.url(&path)?, headers: body.is_some().then(json_content_type).into_iter().collect(), body: body.unwrap_or_default(), }) diff --git a/rust/crates/keygo-uniffi/src/sync.rs b/rust/crates/keygo-uniffi/src/sync.rs index 428ea46f5..bd4664776 100644 --- a/rust/crates/keygo-uniffi/src/sync.rs +++ b/rust/crates/keygo-uniffi/src/sync.rs @@ -40,6 +40,8 @@ pub enum SyncError { Server { code: String, reason: String }, #[error("client error: {reason}")] Client { reason: String }, + #[error("{message}")] + InvalidUrl { message: String }, } impl From for SyncError { @@ -61,6 +63,9 @@ impl From for SyncError { reason: message, }, CoreSyncError::Client { message } => Self::Client { reason: message }, + CoreSyncError::InvalidUrl(e) => Self::InvalidUrl { + message: e.to_string(), + }, } } } From bf0410ecfdc366616fe1db3070574999c928f34f Mon Sep 17 00:00:00 2001 From: Davis Date: Tue, 10 Nov 2026 15:42:18 +0100 Subject: [PATCH 28/52] refactor: drop DpopKey indirection --- rust/Cargo.lock | 1 + rust/crates/keygo-client/src/sync/client.rs | 36 +------- rust/crates/keygo-client/src/sync/mod.rs | 6 +- rust/crates/keygo-client/src/sync/pipeline.rs | 32 ++++--- rust/crates/keygo-client/src/sync/signer.rs | 46 +--------- rust/crates/keygo-client/src/sync/testing.rs | 27 +++--- rust/crates/keygo-dpop/src/proof.rs | 17 +++- rust/crates/keygo-e2e/tests/sync.rs | 4 +- rust/crates/keygo-uniffi/Cargo.toml | 2 + rust/crates/keygo-uniffi/src/sync.rs | 92 +++++++++++++++---- 10 files changed, 140 insertions(+), 123 deletions(-) diff --git a/rust/Cargo.lock b/rust/Cargo.lock index cfdf2e041..3265e9bbd 100644 --- a/rust/Cargo.lock +++ b/rust/Cargo.lock @@ -1757,6 +1757,7 @@ dependencies = [ "async-trait", "keygo-api", "keygo-client", + "keygo-dpop", "thiserror", "tokio", "uniffi", diff --git a/rust/crates/keygo-client/src/sync/client.rs b/rust/crates/keygo-client/src/sync/client.rs index 6a359b289..4da1857ac 100644 --- a/rust/crates/keygo-client/src/sync/client.rs +++ b/rust/crates/keygo-client/src/sync/client.rs @@ -1,6 +1,6 @@ use super::error::{SyncError, SyncResult}; use super::pipeline::store_failure; -use super::signer::{DpopKey, ForeignSigner}; +use super::signer::SharedSigner; use super::state::{AuthState, Clock, SystemClock}; use super::tokens::TokenStore; use super::transport::Transport; @@ -27,7 +27,7 @@ pub struct Account { pub struct SyncClient { pub(super) base_url: Url, pub(super) transport: Arc, - pub(super) prover: DpopProver, + pub(super) prover: DpopProver, pub(super) tokens: Arc, pub(super) clock: Arc, pub(super) auth: Mutex, @@ -51,14 +51,14 @@ impl SyncClient { pub fn new( base_url: Url, transport: Arc, - key: Arc, + signer: SharedSigner, tokens: Arc, ) -> SyncResult { check_base_url(&base_url)?; Ok(Self { base_url, transport, - prover: DpopProver::new(ForeignSigner::new(key)?), + prover: DpopProver::new(signer), tokens, clock: Arc::new(SystemClock), auth: Mutex::new(AuthState::default()), @@ -169,9 +169,7 @@ fn opaque_failure(error: OpaqueError) -> SyncError { #[cfg(test)] mod tests { use super::super::error::SyncError; - use super::super::signer::SignError; - use super::super::testing::{FakeTokenStore, FakeTransport, error_body, fake_client, header}; - use super::*; + use super::super::testing::{error_body, fake_client, header}; const INFO: &str = r#"{"version":"1","public_url":"https://kg.example","allow_signups":true}"#; @@ -281,28 +279,4 @@ mod tests { }, ); } - - struct ShortKey; - - impl DpopKey for ShortKey { - fn public_key(&self) -> Result, SignError> { - Ok(vec![1, 2, 3]) - } - - fn sign(&self, _: Vec) -> Result, SignError> { - unreachable!() - } - } - - #[test] - fn bad_public_key_is_rejected_at_construction() { - let result = SyncClient::new( - Url::parse("https://kg.example").unwrap(), - FakeTransport::new(), - Arc::new(ShortKey), - Arc::new(FakeTokenStore::new()), - ); - - assert!(matches!(result, Err(SyncError::Client { .. }))); - } } diff --git a/rust/crates/keygo-client/src/sync/mod.rs b/rust/crates/keygo-client/src/sync/mod.rs index 4143ec334..a67a4b69f 100644 --- a/rust/crates/keygo-client/src/sync/mod.rs +++ b/rust/crates/keygo-client/src/sync/mod.rs @@ -1,5 +1,5 @@ -//! The sync client: the auth protocol over three host-supplied traits -//! ([`Transport`], [`DpopKey`], [`TokenStore`]). No HTTP stack lives here. +//! The sync client: the auth protocol over three host-supplied dependencies +//! ([`Transport`], [`SharedSigner`], [`TokenStore`]). No HTTP stack lives here. mod client; mod error; @@ -13,7 +13,7 @@ mod transport; pub use client::{Account, SyncClient}; pub use error::{SyncError, SyncResult}; -pub use signer::{DpopKey, SignError}; +pub use signer::{SharedSigner, SignError}; pub use state::{Clock, SystemClock}; pub use tokens::{StoredSession, TokenStore, TokenStoreError}; pub use transport::{Header, HttpRequest, HttpResponse, Transport, TransportError}; diff --git a/rust/crates/keygo-client/src/sync/pipeline.rs b/rust/crates/keygo-client/src/sync/pipeline.rs index 4254d41ee..58a4307dc 100644 --- a/rust/crates/keygo-client/src/sync/pipeline.rs +++ b/rust/crates/keygo-client/src/sync/pipeline.rs @@ -370,10 +370,10 @@ impl SyncClient { #[cfg(test)] mod tests { - use super::super::signer::{DpopKey, SignError}; + use super::super::signer::SignError; use super::super::testing::{ - FakeDpopKey, FakeTokenStore, FakeTransport, FixedClock, client_for, error_body, - fake_client, header, + FakeSigner, FakeTokenStore, FakeTransport, FixedClock, client_for, error_body, fake_client, + header, }; use super::super::tokens::TokenStore; use super::*; @@ -382,6 +382,7 @@ mod tests { use keygo_api::domain::RevokeReason; use keygo_api::meta::ServerInfo; use keygo_core::DeviceId; + use keygo_dpop::{DpopSigner, Signature, VerifyingKey}; use serde_json::{Value, json}; use std::sync::Arc; use std::sync::atomic::{AtomicBool, Ordering}; @@ -500,7 +501,7 @@ mod tests { async fn trailing_slash_in_base_url_is_harmless() { let (plain, plain_transport) = fake_client(); let (slashed, slashed_transport) = - client_for("https://kg.example/", Arc::new(FakeDpopKey::new())); + client_for("https://kg.example/", Arc::new(FakeSigner::new())); plain_transport.push(200, &[], SESSION.as_bytes()); slashed_transport.push(200, &[], SESSION.as_bytes()); @@ -515,14 +516,16 @@ mod tests { assert_eq!(proof_claims(a)["htu"], proof_claims(b)["htu"]); } - struct FailingKey(FakeDpopKey); + struct FailingSigner(FakeSigner); - impl DpopKey for FailingKey { - fn public_key(&self) -> Result, SignError> { - self.0.public_key() + impl DpopSigner for FailingSigner { + type Error = SignError; + + fn verifying_key(&self) -> &VerifyingKey { + self.0.verifying_key() } - fn sign(&self, _: Vec) -> Result, SignError> { + fn sign(&self, _: &[u8]) -> Result { Err(SignError { message: "keystore locked".into(), }) @@ -533,12 +536,15 @@ mod tests { async fn keystore_failure_is_a_client_error() { let (client, transport) = client_for( "https://kg.example", - Arc::new(FailingKey(FakeDpopKey::new())), + Arc::new(FailingSigner(FakeSigner::new())), ); let error = client.call(&Token, &token_request()).await.err().unwrap(); - assert!(matches!(error, SyncError::Client { .. })); + assert!(matches!( + error, + SyncError::Client { message } if message.contains("keystore locked"), + )); assert!(transport.requests().is_empty()); } @@ -616,7 +622,7 @@ mod tests { let client = SyncClient::new( Url::parse("https://kg.example").unwrap(), transport.clone(), - Arc::new(FakeDpopKey::new()), + Arc::new(FakeSigner::new()), store.clone(), ) .unwrap() @@ -965,7 +971,7 @@ mod tests { let client = SyncClient::new( Url::parse("https://kg.example").unwrap(), transport.clone(), - Arc::new(FakeDpopKey::new()), + Arc::new(FakeSigner::new()), store.clone(), ) .unwrap() diff --git a/rust/crates/keygo-client/src/sync/signer.rs b/rust/crates/keygo-client/src/sync/signer.rs index d530ea5b9..12a35bff8 100644 --- a/rust/crates/keygo-client/src/sync/signer.rs +++ b/rust/crates/keygo-client/src/sync/signer.rs @@ -1,5 +1,4 @@ -use super::error::{SyncError, SyncResult}; -use keygo_dpop::{DpopSigner, Signature, VerifyingKey}; +use keygo_dpop::DpopSigner; use std::sync::Arc; #[derive(Debug, thiserror::Error)] @@ -8,44 +7,5 @@ pub struct SignError { pub message: String, } -/// A hardware-backed P-256 key held by the host. -pub trait DpopKey: Send + Sync { - /// The 65-byte uncompressed P-256 point. - fn public_key(&self) -> Result, SignError>; - /// SHA256withECDSA over `message`, DER encoded. - /// Can be called from several threads at once. - fn sign(&self, message: Vec) -> Result, SignError>; -} - -pub struct ForeignSigner { - key: Arc, - verifying: VerifyingKey, -} - -impl ForeignSigner { - pub fn new(key: Arc) -> SyncResult { - let public_key = key.public_key().map_err(|e| SyncError::Client { - message: format!("could not read the DPoP public key: {e}"), - })?; - let verifying = - VerifyingKey::from_sec1_bytes(&public_key).map_err(|_| SyncError::Client { - message: "the DPoP public key is not a P-256 point".into(), - })?; - Ok(Self { key, verifying }) - } -} - -impl DpopSigner for ForeignSigner { - type Error = SignError; - - fn verifying_key(&self) -> &VerifyingKey { - &self.verifying - } - - fn sign(&self, msg: &[u8]) -> Result { - let der = self.key.sign(msg.to_vec())?; - Signature::from_der(&der).map_err(|_| SignError { - message: "the DPoP signature is not DER".into(), - }) - } -} +/// The key that binds this device's tokens, held by the host +pub type SharedSigner = Arc + Send + Sync>; diff --git a/rust/crates/keygo-client/src/sync/testing.rs b/rust/crates/keygo-client/src/sync/testing.rs index 3a82f0008..b7201cfdc 100644 --- a/rust/crates/keygo-client/src/sync/testing.rs +++ b/rust/crates/keygo-client/src/sync/testing.rs @@ -1,21 +1,22 @@ use super::client::SyncClient; -use super::signer::{DpopKey, SignError}; +use super::signer::{SharedSigner, SignError}; use super::state::Clock; use super::tokens::{StoredSession, TokenStore, TokenStoreError}; use super::transport::{Header, HttpRequest, HttpResponse, Transport, TransportError}; use async_trait::async_trait; use keygo_dpop::testing::TestSigner; +use keygo_dpop::{DpopSigner, Signature, VerifyingKey}; use std::collections::VecDeque; use std::sync::atomic::{AtomicBool, AtomicU64, Ordering}; use std::sync::{Arc, Mutex}; use url::Url; -pub fn client_for(base: &str, key: Arc) -> (SyncClient, Arc) { +pub fn client_for(base: &str, signer: SharedSigner) -> (SyncClient, Arc) { let transport = FakeTransport::new(); let client = SyncClient::new( Url::parse(base).unwrap(), transport.clone(), - key, + signer, Arc::new(FakeTokenStore::new()), ) .unwrap(); @@ -23,7 +24,7 @@ pub fn client_for(base: &str, key: Arc) -> (SyncClient, Arc (SyncClient, Arc) { - client_for("https://kg.example", Arc::new(FakeDpopKey::new())) + client_for("https://kg.example", Arc::new(FakeSigner::new())) } pub fn header<'a>(request: &'a HttpRequest, name: &str) -> Option<&'a str> { @@ -160,27 +161,29 @@ impl TokenStore for FakeTokenStore { } /// The same key as [`TestSigner::new`]. -pub struct FakeDpopKey(TestSigner); +pub struct FakeSigner(TestSigner); -impl FakeDpopKey { +impl FakeSigner { pub fn new() -> Self { Self(TestSigner::new()) } } -impl Default for FakeDpopKey { +impl Default for FakeSigner { fn default() -> Self { Self::new() } } -impl DpopKey for FakeDpopKey { - fn public_key(&self) -> Result, SignError> { - Ok(self.0.public_key_sec1()) +impl DpopSigner for FakeSigner { + type Error = SignError; + + fn verifying_key(&self) -> &VerifyingKey { + self.0.verifying_key() } - fn sign(&self, message: Vec) -> Result, SignError> { - Ok(self.0.sign_der(&message)) + fn sign(&self, msg: &[u8]) -> Result { + self.0.sign(msg).map_err(|never| match never {}) } } diff --git a/rust/crates/keygo-dpop/src/proof.rs b/rust/crates/keygo-dpop/src/proof.rs index 00140f286..21ebc3f8b 100644 --- a/rust/crates/keygo-dpop/src/proof.rs +++ b/rust/crates/keygo-dpop/src/proof.rs @@ -4,6 +4,7 @@ use crate::{Htm, htu, unix_now}; use base64::Engine; use base64::engine::general_purpose::URL_SAFE_NO_PAD; use p256::ecdsa::{Signature, VerifyingKey}; +use std::sync::Arc; pub trait DpopSigner { type Error: std::error::Error; @@ -14,6 +15,18 @@ pub trait DpopSigner { fn sign(&self, msg: &[u8]) -> Result; } +impl DpopSigner for Arc { + type Error = S::Error; + + fn verifying_key(&self) -> &VerifyingKey { + S::verifying_key(self) + } + + fn sign(&self, msg: &[u8]) -> Result { + S::sign(self, msg) + } +} + pub struct ProofRequest<'a> { pub htm: Htm, /// The request URL. Query and fragment are dropped before it goes into the proof. @@ -84,8 +97,8 @@ impl DpopProver { #[derive(Debug, thiserror::Error)] pub enum DpopError { - #[error("signer failed")] - Signer(#[source] E), + #[error("signer failed: {0}")] + Signer(E), #[error("random number generator failed")] Rng(#[from] getrandom::Error), #[error("htu is not an absolute URI")] diff --git a/rust/crates/keygo-e2e/tests/sync.rs b/rust/crates/keygo-e2e/tests/sync.rs index 04ee9177e..e70513448 100644 --- a/rust/crates/keygo-e2e/tests/sync.rs +++ b/rust/crates/keygo-e2e/tests/sync.rs @@ -3,7 +3,7 @@ use axum::body::Body; use axum::http::{HeaderName, HeaderValue, Request}; use http_body_util::BodyExt; use keygo_api::domain::{Device, RevokeReason}; -use keygo_client::sync::testing::{FakeDpopKey, FakeTokenStore, FixedClock}; +use keygo_client::sync::testing::{FakeSigner, FakeTokenStore, FixedClock}; use keygo_client::sync::{ Clock, Header, HttpRequest, HttpResponse, StoredSession, SyncClient, SyncError, SystemClock, Transport, TransportError, @@ -91,7 +91,7 @@ async fn harness(db: &PgPool) -> Harness { let client = SyncClient::new( Url::parse(testing::ISS).unwrap(), Arc::new(TowerTransport(state.clone())), - Arc::new(FakeDpopKey::new()), + Arc::new(FakeSigner::new()), store.clone(), ) .unwrap() diff --git a/rust/crates/keygo-uniffi/Cargo.toml b/rust/crates/keygo-uniffi/Cargo.toml index 46129d536..b1758bb1d 100644 --- a/rust/crates/keygo-uniffi/Cargo.toml +++ b/rust/crates/keygo-uniffi/Cargo.toml @@ -10,6 +10,7 @@ crate-type = ["cdylib"] [dependencies] keygo-api = { path = "../keygo-api" } keygo-client = { path = "../keygo-client" } +keygo-dpop = { path = "../keygo-dpop" } thiserror.workspace = true uuid.workspace = true zeroize.workspace = true @@ -23,4 +24,5 @@ url = "2.5.8" [dev-dependencies] keygo-client = { path = "../keygo-client", features = ["test-support"] } +keygo-dpop = { path = "../keygo-dpop", features = ["test-support"] } tokio = { workspace = true, features = ["macros", "sync", "time"] } diff --git a/rust/crates/keygo-uniffi/src/sync.rs b/rust/crates/keygo-uniffi/src/sync.rs index bd4664776..4cc64b8fd 100644 --- a/rust/crates/keygo-uniffi/src/sync.rs +++ b/rust/crates/keygo-uniffi/src/sync.rs @@ -4,12 +4,13 @@ use keygo_api::domain::{AppVersion, Device, DeviceInfo, DeviceName, Platform}; use keygo_api::meta::ServerInfo; use keygo_client::crypto::{DeviceId, UserId}; use keygo_client::sync::{ - Account as CoreAccount, DpopKey as CoreDpopKey, Header, HttpRequest as CoreHttpRequest, - HttpResponse, SignError as CoreSignError, StoredSession as CoreStoredSession, - SyncClient as CoreSyncClient, SyncError as CoreSyncError, SyncResult, - TokenStore as CoreTokenStore, TokenStoreError as CoreTokenStoreError, - Transport as CoreTransport, TransportError as CoreTransportError, + Account as CoreAccount, Header, HttpRequest as CoreHttpRequest, HttpResponse, + SignError as CoreSignError, StoredSession as CoreStoredSession, SyncClient as CoreSyncClient, + SyncError as CoreSyncError, SyncResult, TokenStore as CoreTokenStore, + TokenStoreError as CoreTokenStoreError, Transport as CoreTransport, + TransportError as CoreTransportError, }; +use keygo_dpop::{DpopSigner, Signature, VerifyingKey}; use std::fmt::Display; use std::sync::Arc; use url::Url; @@ -260,15 +261,36 @@ impl CoreTransport for TransportAdapter { } } -struct KeyAdapter(Arc); +struct ForeignSigner { + key: Arc, + verifying: VerifyingKey, +} + +impl ForeignSigner { + fn new(key: Arc) -> Result { + let public_key = key.public_key().map_err(|e| SyncError::Client { + reason: format!("could not read the DPoP public key: {e}"), + })?; + let verifying = + VerifyingKey::from_sec1_bytes(&public_key).map_err(|_| SyncError::Client { + reason: "the DPoP public key is not a P-256 point".into(), + })?; + Ok(Self { key, verifying }) + } +} + +impl DpopSigner for ForeignSigner { + type Error = CoreSignError; -impl CoreDpopKey for KeyAdapter { - fn public_key(&self) -> Result, CoreSignError> { - Ok(self.0.public_key()?) + fn verifying_key(&self) -> &VerifyingKey { + &self.verifying } - fn sign(&self, message: Vec) -> Result, CoreSignError> { - Ok(self.0.sign(message)?) + fn sign(&self, msg: &[u8]) -> Result { + let der = self.key.sign(msg.to_vec())?; + Signature::from_der(&der).map_err(|_| CoreSignError { + message: "the DPoP signature is not DER".into(), + }) } } @@ -341,7 +363,7 @@ impl SyncClient { let inner = CoreSyncClient::new( base_url, Arc::new(TransportAdapter(transport)), - Arc::new(KeyAdapter(dpop_key)), + Arc::new(ForeignSigner::new(dpop_key)?), Arc::new(StoreAdapter(tokens)), )?; Ok(Arc::new(Self { @@ -430,7 +452,7 @@ mod tests { use super::*; use keygo_api::Method; use keygo_api::domain::RevokeReason; - use keygo_client::sync::testing::FakeDpopKey; + use keygo_dpop::testing::TestSigner; use std::sync::Mutex; use std::time::Duration; use tokio::sync::Notify; @@ -540,15 +562,27 @@ mod tests { } } - struct TestKey(FakeDpopKey); + struct TestKey(TestSigner); impl DpopKey for TestKey { fn public_key(&self) -> Result, SignError> { - CoreDpopKey::public_key(&self.0).map_err(|e| SignError::Failed { reason: e.message }) + Ok(self.0.public_key_sec1()) } fn sign(&self, message: Vec) -> Result, SignError> { - CoreDpopKey::sign(&self.0, message).map_err(|e| SignError::Failed { reason: e.message }) + Ok(self.0.sign_der(&message)) + } + } + + struct ShortKey; + + impl DpopKey for ShortKey { + fn public_key(&self) -> Result, SignError> { + Ok(vec![1, 2, 3]) + } + + fn sign(&self, _: Vec) -> Result, SignError> { + unreachable!() } } @@ -570,7 +604,7 @@ mod tests { SyncClient::new( "https://kg.example".into(), transport, - Arc::new(TestKey(FakeDpopKey::new())), + Arc::new(TestKey(TestSigner::new())), tokens, ) .unwrap() @@ -688,4 +722,28 @@ mod tests { assert!(matches!(result, Err(SyncError::Client { .. }))); } + + #[test] + fn bad_public_key_is_rejected_at_construction() { + let result = SyncClient::new( + "https://kg.example".into(), + Arc::new(RecordingTransport::default()), + Arc::new(ShortKey), + Arc::new(MemoryStore::default()), + ); + + assert!(matches!(result, Err(SyncError::Client { .. }))); + } + + #[test] + fn foreign_signer_decodes_what_a_keystore_produces() { + let expected = TestSigner::new(); + let signer = ForeignSigner::new(Arc::new(TestKey(TestSigner::new()))).unwrap(); + + assert_eq!(signer.verifying_key(), expected.verifying_key()); + assert_eq!( + signer.sign(b"message").unwrap(), + expected.sign(b"message").unwrap(), + ); + } } From a153aeadb9180c16d6496509bc5557b78e2eee8c Mon Sep 17 00:00:00 2001 From: Davis Date: Tue, 10 Nov 2026 16:53:44 +0100 Subject: [PATCH 29/52] refactor: fold exchange and exchange_unlocked --- rust/crates/keygo-client/src/sync/client.rs | 3 + rust/crates/keygo-client/src/sync/pipeline.rs | 116 ++++++++++-------- rust/crates/keygo-client/src/sync/state.rs | 2 - 3 files changed, 67 insertions(+), 54 deletions(-) diff --git a/rust/crates/keygo-client/src/sync/client.rs b/rust/crates/keygo-client/src/sync/client.rs index 4da1857ac..51bc612ab 100644 --- a/rust/crates/keygo-client/src/sync/client.rs +++ b/rust/crates/keygo-client/src/sync/client.rs @@ -31,6 +31,8 @@ pub struct SyncClient { pub(super) tokens: Arc, pub(super) clock: Arc, pub(super) auth: Mutex, + /// Outside `auth` because a refresh holds that lock across the network, and it signs too. + pub(super) nonce: std::sync::Mutex>, } fn check_base_url(url: &Url) -> SyncResult<()> { @@ -62,6 +64,7 @@ impl SyncClient { tokens, clock: Arc::new(SystemClock), auth: Mutex::new(AuthState::default()), + nonce: std::sync::Mutex::default(), }) } diff --git a/rust/crates/keygo-client/src/sync/pipeline.rs b/rust/crates/keygo-client/src/sync/pipeline.rs index 58a4307dc..1b9a3365b 100644 --- a/rust/crates/keygo-client/src/sync/pipeline.rs +++ b/rust/crates/keygo-client/src/sync/pipeline.rs @@ -10,6 +10,7 @@ use keygo_api::{ApiError, Auth, Endpoint, ErrorCode, Method}; use keygo_dpop::{Htm, ProofRequest}; use serde::Serialize; use serde::de::DeserializeOwned; +use std::sync::{MutexGuard, PoisonError}; use zeroize::Zeroizing; fn to_json(value: &T) -> SyncResult> { @@ -57,18 +58,8 @@ fn header_value<'a>(response: &'a HttpResponse, name: &str) -> Option<&'a str> { .map(|h| h.value.as_str()) } -/// Returns whether the response carried a nonce. -fn remember_nonce(response: &HttpResponse, nonce: &mut Option) -> bool { - let fresh = header_value(response, "dpop-nonce"); - if let Some(fresh) = fresh { - *nonce = Some(fresh.to_owned()); - } - fresh.is_some() -} - fn is_nonce_challenge(response: &HttpResponse) -> bool { - serde_json::from_slice::(&response.body) - .is_ok_and(|error| error.code == ErrorCode::UseDpopNonce) + api_error(response).is_some_and(|error| error.code == ErrorCode::UseDpopNonce) } fn is_success(response: &HttpResponse) -> bool { @@ -110,6 +101,20 @@ impl SyncClient { Ok(self.base_url.join(path)?.to_string()) } + /// Never hold the guard across an `await`. + fn nonce_slot(&self) -> MutexGuard<'_, Option> { + self.nonce.lock().unwrap_or_else(PoisonError::into_inner) + } + + /// Returns whether the response carried a nonce. + fn remember_nonce(&self, response: &HttpResponse) -> bool { + let fresh = header_value(response, "dpop-nonce"); + if let Some(fresh) = fresh { + *self.nonce_slot() = Some(fresh.to_owned()); + } + fresh.is_some() + } + async fn send(&self, request: HttpRequest) -> SyncResult { self.transport .send(request) @@ -123,15 +128,15 @@ impl SyncClient { url: &str, access_token: Option<&str>, body: Option<&[u8]>, - nonce: Option<&str>, ) -> SyncResult { + let nonce = self.nonce_slot().clone(); let proof = self .prover .proof(&ProofRequest { htm: proof_method(method), htu: url, access_token, - nonce, + nonce: nonce.as_deref(), }) .map_err(|e| SyncError::Client { message: format!("could not sign the DPoP proof: {e}"), @@ -162,53 +167,33 @@ impl SyncClient { /// Signs and sends one request, and re-signs once if the server answers with a nonce challenge /// that carries a nonce. - /// Every `DPoP-Nonce` header the server sends replaces `nonce`. + /// Every `DPoP-Nonce` header the server sends replaces the stored nonce. pub(super) async fn exchange( &self, method: Method, path: &str, access_token: Option<&str>, body: Option<&[u8]>, - nonce: &mut Option, ) -> SyncResult { let url = self.url(path)?; - let response = self - .send_signed(method, &url, access_token, body, nonce.as_deref()) - .await?; - if !remember_nonce(&response, nonce) || !is_nonce_challenge(&response) { + let response = self.send_signed(method, &url, access_token, body).await?; + if !self.remember_nonce(&response) || !is_nonce_challenge(&response) { return Ok(response); } - let response = self - .send_signed(method, &url, access_token, body, nonce.as_deref()) - .await?; - remember_nonce(&response, nonce); + let response = self.send_signed(method, &url, access_token, body).await?; + self.remember_nonce(&response); Ok(response) } - /// Works on a copy of the nonce, so the `AuthState` lock is not held across the network. - async fn exchange_unlocked( - &self, - method: Method, - path: &str, - access_token: Option<&str>, - body: Option<&[u8]>, - mut nonce: Option, - ) -> SyncResult { - let response = self - .exchange(method, path, access_token, body, &mut nonce) - .await; - self.auth.lock().await.nonce = nonce; - response - } - /// The caller holds the `AuthState` lock, so a running refresh cannot save a token after this. /// /// `AuthState` is reset even if the store fails. The caller judges that failure: a leftover token /// the server still accepts would bring the session back. pub(super) async fn end_session(&self, state: &mut AuthState) -> Result<(), TokenStoreError> { state.reset(); + *self.nonce_slot() = None; self.tokens.clear().await } @@ -250,13 +235,7 @@ impl SyncClient { let sent_at = self.clock.now_secs(); let response = self - .exchange( - Token::METHOD, - &Token.path(), - None, - Some(body.as_slice()), - &mut state.nonce, - ) + .exchange(Token::METHOD, &Token.path(), None, Some(body.as_slice())) .await?; if !is_success(&response) { @@ -285,7 +264,7 @@ impl SyncClient { } /// Only a refresh holds the lock across the network. It is released before the request itself. - async fn access_token(&self) -> SyncResult<(Zeroizing, u64, Option)> { + async fn access_token(&self) -> SyncResult<(Zeroizing, u64)> { let mut state = self.auth.lock().await; self.flush_unsaved(&mut state).await; let now = self.clock.now_secs(); @@ -294,7 +273,7 @@ impl SyncClient { Some(access) => Zeroizing::new(access.token.expose().to_owned()), None => self.refresh_locked(&mut state).await?, }; - Ok((token, state.generation, state.nonce.clone())) + Ok((token, state.generation)) } /// An `invalid_token` earns one retry. The refresh before it is skipped if another caller has @@ -307,10 +286,10 @@ impl SyncClient { ) -> SyncResult { let mut retried = false; loop { - let (token, generation, nonce) = self.access_token().await?; + let (token, generation) = self.access_token().await?; let response = self - .exchange_unlocked(method, path, Some(token.as_str()), body, nonce) + .exchange(method, path, Some(token.as_str()), body) .await?; if retried || !is_invalid_token(&response) { @@ -344,8 +323,7 @@ impl SyncClient { .await? } Auth::Proof => { - let nonce = self.auth.lock().await.nonce.clone(); - self.exchange_unlocked(E::METHOD, &path, None, body.as_deref(), nonce) + self.exchange(E::METHOD, &path, None, body.as_deref()) .await? } Auth::AccessToken => { @@ -497,6 +475,40 @@ mod tests { assert_eq!(proof_claims(&requests[1])["nonce"], "n1"); } + #[tokio::test] + async fn a_response_without_a_nonce_keeps_a_newer_one() { + let (client, transport) = fake_client(); + transport.push(200, &[("DPoP-Nonce", "n1")], SESSION.as_bytes()); + transport.push(200, &[], SESSION.as_bytes()); + transport.push(200, &[], SESSION.as_bytes()); + + let request = token_request(); + let (first, second) = + tokio::join!(client.call(&Token, &request), client.call(&Token, &request),); + first.ok().unwrap(); + second.ok().unwrap(); + client.call(&Token, &request).await.ok().unwrap(); + + assert_eq!(proof_claims(&transport.requests()[2])["nonce"], "n1"); + } + + #[tokio::test] + async fn ending_the_session_forgets_the_nonce() { + let h = fresh().await; + h.transport.push(204, &[("DPoP-Nonce", "n1")], b""); + h.client.logout().await.unwrap(); + + h.transport.push(200, &[], SESSION.as_bytes()); + h.client.call(&Token, &token_request()).await.ok().unwrap(); + + let requests = h.transport.requests(); + assert!( + proof_claims(requests.last().unwrap()) + .get("nonce") + .is_none() + ); + } + #[tokio::test] async fn trailing_slash_in_base_url_is_harmless() { let (plain, plain_transport) = fake_client(); diff --git a/rust/crates/keygo-client/src/sync/state.rs b/rust/crates/keygo-client/src/sync/state.rs index d08aa1870..a78d57cb5 100644 --- a/rust/crates/keygo-client/src/sync/state.rs +++ b/rust/crates/keygo-client/src/sync/state.rs @@ -12,7 +12,6 @@ pub(super) struct AccessState { #[derive(Default)] pub(super) struct AuthState { access: Option, - pub(super) nonce: Option, /// Moves whenever `access` changes. A call whose token was rejected uses it to tell whether /// someone has already replaced that token. pub(super) generation: u64, @@ -41,7 +40,6 @@ impl AuthState { /// a new one for its own. pub(super) fn reset(&mut self) { self.access = None; - self.nonce = None; self.unsaved = None; self.generation += 1; } From a296a3682570bff50fd01bd57b4c99cad8e35acc Mon Sep 17 00:00:00 2001 From: Davis Date: Tue, 10 Nov 2026 18:03:19 +0100 Subject: [PATCH 30/52] refactor: simplify rust client --- rust/crates/keygo-api/src/auth/token.rs | 4 +- rust/crates/keygo-api/tests/wire.rs | 3 +- rust/crates/keygo-client/src/sync/pipeline.rs | 171 ++++++++---------- rust/crates/keygo-client/src/sync/state.rs | 8 +- rust/crates/keygo-client/src/sync/testing.rs | 14 ++ rust/crates/keygo-client/src/sync/tokens.rs | 17 -- .../crates/keygo-client/src/sync/transport.rs | 2 - rust/crates/keygo-uniffi/src/sync.rs | 106 +++++------ 8 files changed, 140 insertions(+), 185 deletions(-) diff --git a/rust/crates/keygo-api/src/auth/token.rs b/rust/crates/keygo-api/src/auth/token.rs index ec7e031da..2e1550996 100644 --- a/rust/crates/keygo-api/src/auth/token.rs +++ b/rust/crates/keygo-api/src/auth/token.rs @@ -2,6 +2,6 @@ use crate::domain::RefreshToken; use serde::{Deserialize, Serialize}; #[derive(Serialize, Deserialize)] -pub struct TokenRequest { - pub refresh_token: RefreshToken, +pub struct TokenRequest { + pub refresh_token: T, } diff --git a/rust/crates/keygo-api/tests/wire.rs b/rust/crates/keygo-api/tests/wire.rs index e95e4c60c..f11372a99 100644 --- a/rust/crates/keygo-api/tests/wire.rs +++ b/rust/crates/keygo-api/tests/wire.rs @@ -8,6 +8,7 @@ use keygo_api::auth::step_up; use keygo_api::auth::token::TokenRequest; use keygo_api::auth::{Access, Session}; use keygo_api::devices::Devices; +use keygo_api::domain::RefreshToken; use keygo_api::meta::ServerInfo; use keygo_opaque::client::{ClientLogin, ClientRegistration}; use keygo_opaque::server::{self, ServerLogin, ServerSetup}; @@ -315,7 +316,7 @@ fn step_up_finish_response() { fn token_request() { pin( &TokenRequest { - refresh_token: from(json!(REFRESH)), + refresh_token: from::(json!(REFRESH)), }, json!({"refresh_token": REFRESH}), ); diff --git a/rust/crates/keygo-client/src/sync/pipeline.rs b/rust/crates/keygo-client/src/sync/pipeline.rs index 1b9a3365b..ffa01538c 100644 --- a/rust/crates/keygo-client/src/sync/pipeline.rs +++ b/rust/crates/keygo-client/src/sync/pipeline.rs @@ -10,6 +10,7 @@ use keygo_api::{ApiError, Auth, Endpoint, ErrorCode, Method}; use keygo_dpop::{Htm, ProofRequest}; use serde::Serialize; use serde::de::DeserializeOwned; +use std::ops::DerefMut; use std::sync::{MutexGuard, PoisonError}; use zeroize::Zeroizing; @@ -50,44 +51,42 @@ fn proof_method(method: Method) -> Htm { } } -fn header_value<'a>(response: &'a HttpResponse, name: &str) -> Option<&'a str> { - response - .headers - .iter() - .find(|h| h.name.eq_ignore_ascii_case(name)) - .map(|h| h.value.as_str()) -} - -fn is_nonce_challenge(response: &HttpResponse) -> bool { - api_error(response).is_some_and(|error| error.code == ErrorCode::UseDpopNonce) -} +impl HttpResponse { + fn header_value(&self, name: &str) -> Option<&str> { + self.headers + .iter() + .find(|h| h.name.eq_ignore_ascii_case(name)) + .map(|h| h.value.as_str()) + } -fn is_success(response: &HttpResponse) -> bool { - (200..300).contains(&response.status) -} + fn is_success(&self) -> bool { + (200..300).contains(&self.status) + } -/// A 2xx is never an error, whatever its body says. -fn api_error(response: &HttpResponse) -> Option { - if is_success(response) { - return None; + /// A 2xx is never an error, whatever its body says. + fn api_error(&self) -> Option { + if self.is_success() { + return None; + } + serde_json::from_slice(&self.body).ok() } - serde_json::from_slice(&response.body).ok() -} -fn is_invalid_token(response: &HttpResponse) -> bool { - api_error(response).is_some_and(|error| error.code == ErrorCode::InvalidToken) -} + fn is_invalid_token(&self) -> bool { + self.api_error() + .is_some_and(|error| error.code == ErrorCode::InvalidToken) + } -/// An unknown revoke reason becomes `None`, so a newer server can still sign an older app out. -fn sign_out_error(response: &HttpResponse) -> Option { - let error = api_error(response)?; - matches!( - error.code, - ErrorCode::SessionRevoked | ErrorCode::RefreshExpired - ) - .then(|| SyncError::SignedOut { - reason: error.reason.and_then(|reason| reason.parse().ok()), - }) + /// An unknown revoke reason becomes `None`, so a newer server can still sign an older app out. + fn sign_out_error(&self) -> Option { + let error = self.api_error()?; + matches!( + error.code, + ErrorCode::SessionRevoked | ErrorCode::RefreshExpired + ) + .then(|| SyncError::SignedOut { + reason: error.reason.and_then(|reason| reason.parse().ok()), + }) + } } pub(super) fn store_failure(error: TokenStoreError) -> SyncError { @@ -101,18 +100,18 @@ impl SyncClient { Ok(self.base_url.join(path)?.to_string()) } - /// Never hold the guard across an `await`. fn nonce_slot(&self) -> MutexGuard<'_, Option> { self.nonce.lock().unwrap_or_else(PoisonError::into_inner) } - /// Returns whether the response carried a nonce. - fn remember_nonce(&self, response: &HttpResponse) -> bool { - let fresh = header_value(response, "dpop-nonce"); - if let Some(fresh) = fresh { - *self.nonce_slot() = Some(fresh.to_owned()); - } - fresh.is_some() + fn remember_nonce_and_check_challenge(&self, response: &HttpResponse) -> bool { + let Some(fresh) = response.header_value("dpop-nonce") else { + return false; + }; + *self.nonce_slot() = Some(fresh.to_owned()); + response + .api_error() + .is_some_and(|error| error.code == ErrorCode::UseDpopNonce) } async fn send(&self, request: HttpRequest) -> SyncResult { @@ -178,30 +177,20 @@ impl SyncClient { let url = self.url(path)?; let response = self.send_signed(method, &url, access_token, body).await?; - if !self.remember_nonce(&response) || !is_nonce_challenge(&response) { - return Ok(response); + if self.remember_nonce_and_check_challenge(&response) { + let retried = self.send_signed(method, &url, access_token, body).await?; + self.remember_nonce_and_check_challenge(&retried); + return Ok(retried); } - - let response = self.send_signed(method, &url, access_token, body).await?; - self.remember_nonce(&response); Ok(response) } - /// The caller holds the `AuthState` lock, so a running refresh cannot save a token after this. - /// - /// `AuthState` is reset even if the store fails. The caller judges that failure: a leftover token - /// the server still accepts would bring the session back. pub(super) async fn end_session(&self, state: &mut AuthState) -> Result<(), TokenStoreError> { state.reset(); *self.nonce_slot() = None; self.tokens.clear().await } - /// The server has killed this token, so a failed clear is harmless. - async fn forget_killed_session(&self, state: &mut AuthState) { - let _ = self.end_session(state).await; - } - /// If the store refuses, `state` keeps the live copy and the next call tries again. async fn flush_unsaved(&self, state: &mut AuthState) { let Some(unsaved) = &state.unsaved else { @@ -212,16 +201,14 @@ impl SyncClient { } } - /// Holds the `AuthState` lock for the whole refresh, so concurrent callers share one result. - /// Uses `exchange` directly because `call` would take the lock again. - /// - /// The rotated session goes into `state` before the write, so a refused save or a dropped caller - /// cannot lose the only copy of the live token. - async fn refresh_locked(&self, state: &mut AuthState) -> SyncResult> { + async fn refresh(&self, state: &mut AuthState) -> SyncResult> { + // If the previous refresh could not successfully store the refresh token, it is + // kept in-memory, so we will use that one instead. let refresh_token = match &state.unsaved { - Some(unsaved) => unsaved.duplicate().refresh_token, + Some(unsaved) => &unsaved.refresh_token, None => { - self.tokens + &self + .tokens .load() .await .map_err(store_failure)? @@ -230,22 +217,15 @@ impl SyncClient { } }; - let request = TokenRequest { refresh_token }; - let body = Zeroizing::new(to_json(&request)?); + let body = Zeroizing::new(to_json(&TokenRequest { refresh_token })?); let sent_at = self.clock.now_secs(); let response = self .exchange(Token::METHOD, &Token.path(), None, Some(body.as_slice())) .await?; - if !is_success(&response) { - return Err(match sign_out_error(&response) { - Some(signed_out) => { - self.forget_killed_session(state).await; - signed_out - } - None => from_response(response.status, &response.body), - }); + if !response.is_success() { + return Err(self.failure(state, &response).await); } let body = Zeroizing::new(response.body); @@ -264,14 +244,18 @@ impl SyncClient { } /// Only a refresh holds the lock across the network. It is released before the request itself. - async fn access_token(&self) -> SyncResult<(Zeroizing, u64)> { + async fn access_token(&self, rejected: Option) -> SyncResult<(Zeroizing, u64)> { let mut state = self.auth.lock().await; self.flush_unsaved(&mut state).await; + let now = self.clock.now_secs(); - let live = state.access().filter(|access| now < access.expires_at); + let usable = Some(state.generation) != rejected; + let live = state + .access() + .filter(|access| usable && now < access.expires_at); let token = match live { Some(access) => Zeroizing::new(access.token.expose().to_owned()), - None => self.refresh_locked(&mut state).await?, + None => self.refresh(&mut state).await?, }; Ok((token, state.generation)) } @@ -284,23 +268,18 @@ impl SyncClient { path: &str, body: Option<&[u8]>, ) -> SyncResult { - let mut retried = false; + let mut rejected = None; loop { - let (token, generation) = self.access_token().await?; + let (token, generation) = self.access_token(rejected).await?; let response = self .exchange(method, path, Some(token.as_str()), body) .await?; - if retried || !is_invalid_token(&response) { + if rejected.is_some() || !response.is_invalid_token() { return Ok(response); } - retried = true; - - let mut state = self.auth.lock().await; - if state.generation == generation { - self.refresh_locked(&mut state).await?; - } + rejected = Some(generation); } } @@ -332,17 +311,21 @@ impl SyncClient { } }; - if is_success(&response) { + if response.is_success() { return decode_body(&response.body); } - Err(match sign_out_error(&response) { - Some(signed_out) => { - self.forget_killed_session(&mut *self.auth.lock().await) - .await; - signed_out - } - None => from_response(response.status, &response.body), - }) + Err(self + .failure(self.auth.lock().await.deref_mut(), &response) + .await) + } + + async fn failure(&self, state: &mut AuthState, response: &HttpResponse) -> SyncError { + let Some(signed_out) = response.sign_out_error() else { + return from_response(response.status, &response.body); + }; + // The server has killed this token, so a failed clear is harmless. + let _ = self.end_session(state).await; + signed_out } } diff --git a/rust/crates/keygo-client/src/sync/state.rs b/rust/crates/keygo-client/src/sync/state.rs index a78d57cb5..82a5099c0 100644 --- a/rust/crates/keygo-client/src/sync/state.rs +++ b/rust/crates/keygo-client/src/sync/state.rs @@ -5,7 +5,6 @@ use std::time::{SystemTime, UNIX_EPOCH}; pub(super) struct AccessState { pub(super) token: AccessToken, - /// Unix seconds. The token is usable while the clock reads less than this. pub(super) expires_at: u64, } @@ -25,9 +24,6 @@ impl AuthState { self.access.as_ref() } - /// The only way to set the access token, so `generation` cannot be left behind. - /// - /// `sent_at` is read before the request, so a token never looks like it lives longer than it does. pub(super) fn replace_access(&mut self, access: Access, sent_at: u64) { self.access = Some(AccessState { token: access.access_token, @@ -36,11 +32,11 @@ impl AuthState { self.generation += 1; } - /// `generation` moves on rather than restarting, so a call holding an old token cannot mistake - /// a new one for its own. pub(super) fn reset(&mut self) { self.access = None; self.unsaved = None; + + // Keep counting up, so a request started before the reset can tell its token is stale self.generation += 1; } } diff --git a/rust/crates/keygo-client/src/sync/testing.rs b/rust/crates/keygo-client/src/sync/testing.rs index b7201cfdc..f2f911b9c 100644 --- a/rust/crates/keygo-client/src/sync/testing.rs +++ b/rust/crates/keygo-client/src/sync/testing.rs @@ -128,6 +128,20 @@ impl FakeTokenStore { } } +impl StoredSession { + pub(super) fn duplicate(&self) -> Self { + Self { + device_id: self.device_id, + refresh_token: self + .refresh_token + .expose_encoded() + .parse() + .expect("a refresh token parses its own encoding"), + refresh_expires_at: self.refresh_expires_at, + } + } +} + #[async_trait] impl TokenStore for FakeTokenStore { async fn load(&self) -> Result, TokenStoreError> { diff --git a/rust/crates/keygo-client/src/sync/tokens.rs b/rust/crates/keygo-client/src/sync/tokens.rs index 3e2816908..2e2d12ccf 100644 --- a/rust/crates/keygo-client/src/sync/tokens.rs +++ b/rust/crates/keygo-client/src/sync/tokens.rs @@ -8,29 +8,12 @@ pub struct StoredSession { pub refresh_expires_at: u64, } -impl StoredSession { - /// `RefreshToken` is not `Clone`, so this copies through its encoding. - pub(super) fn duplicate(&self) -> Self { - Self { - device_id: self.device_id, - refresh_token: self - .refresh_token - .expose_encoded() - .parse() - .expect("a refresh token parses its own encoding"), - refresh_expires_at: self.refresh_expires_at, - } - } -} - #[derive(Debug, thiserror::Error)] #[error("{message}")] pub struct TokenStoreError { pub message: String, } -/// `save` runs under the client's auth lock, so it must return in bounded time: a hung `save` -/// blocks every later call, including logout. A refused `save` is retried on later calls. #[async_trait] pub trait TokenStore: Send + Sync { async fn load(&self) -> Result, TokenStoreError>; diff --git a/rust/crates/keygo-client/src/sync/transport.rs b/rust/crates/keygo-client/src/sync/transport.rs index 1d063c050..2eae668ed 100644 --- a/rust/crates/keygo-client/src/sync/transport.rs +++ b/rust/crates/keygo-client/src/sync/transport.rs @@ -65,8 +65,6 @@ pub struct TransportError { pub message: String, } -/// The host owns TLS, timeouts and pooling. -/// It must not retry, follow auth challenges or log bodies. #[async_trait] pub trait Transport: Send + Sync { async fn send(&self, request: HttpRequest) -> Result; diff --git a/rust/crates/keygo-uniffi/src/sync.rs b/rust/crates/keygo-uniffi/src/sync.rs index 4cc64b8fd..91403db8c 100644 --- a/rust/crates/keygo-uniffi/src/sync.rs +++ b/rust/crates/keygo-uniffi/src/sync.rs @@ -224,8 +224,7 @@ impl From for Account { } } -/// The host owns TLS, timeouts and pooling. -/// It must not retry, follow auth challenges or log bodies. +/// The host owns TLS, timeouts and pooling. It must not retry, follow auth challenges or log bodies. #[uniffi::export(with_foreign)] #[async_trait] pub trait HttpTransport: Send + Sync { @@ -237,13 +236,11 @@ pub trait HttpTransport: Send + Sync { pub trait DpopKey: Send + Sync { /// The 65-byte uncompressed P-256 point. fn public_key(&self) -> Result, SignError>; - /// SHA256withECDSA over `message`, DER encoded. - /// Can be called from several threads at once. + + /// SHA256withECDSA over `message`, DER encoded. Can be called from several threads at once. fn sign(&self, message: Vec) -> Result, SignError>; } -/// `save` runs under the client's auth lock, so it must return in bounded time: a hung `save` -/// blocks every later call, including logout. A refused `save` is retried on later calls. #[uniffi::export(with_foreign)] #[async_trait] pub trait TokenStore: Send + Sync { @@ -323,29 +320,20 @@ impl CoreTokenStore for StoreAdapter { } } -/// Every call runs as its own task: abandoning a refresh the server has committed would lose the -/// new token, and the next refresh would revoke the session as `reuse_detected`. #[derive(uniffi::Object)] pub struct SyncClient { inner: Arc, } -impl SyncClient { - /// Dropping the returned future only stops the waiting, and a panic in the task stops at the - /// `JoinError` instead of crossing the FFI. - async fn detached(&self, call: F) -> Result - where - T: Send + 'static, - F: FnOnce(Arc) -> C + Send, - C: Future> + Send + 'static, - { - tokio::spawn(call(self.inner.clone())) - .await - .map_err(|_| SyncError::Client { - reason: "the sync task did not finish".into(), - })? - .map_err(Into::into) - } +async fn detached( + call: impl Future> + Send + 'static, +) -> Result { + tokio::spawn(call) + .await + .map_err(|_| SyncError::Client { + reason: "the sync task did not finish".into(), + })? + .map_err(Into::into) } #[uniffi::export(async_runtime = "tokio")] @@ -371,13 +359,12 @@ impl SyncClient { })) } - pub async fn meta(&self) -> Result { - self.detached(|client| async move { client.meta().await }) - .await + pub async fn meta(self: Arc) -> Result { + detached(async move { self.inner.meta().await }).await } pub async fn register( - &self, + self: Arc, ark: Arc, user_id: UserId, username: String, @@ -387,25 +374,24 @@ impl SyncClient { ) -> Result { let password = Zeroizing::new(password); let device = device.into_core()?; - let account = self - .detached(|client| async move { - client - .register( - &ark.session, - user_id, - &username, - &password, - invite.as_deref(), - device, - ) - .await - }) - .await?; + let account = detached(async move { + self.inner + .register( + &ark.session, + user_id, + &username, + &password, + invite.as_deref(), + device, + ) + .await + }) + .await?; Ok(account.into()) } pub async fn login( - &self, + self: Arc, ark: Arc, username: String, password: String, @@ -413,37 +399,31 @@ impl SyncClient { ) -> Result { let password = Zeroizing::new(password); let device = device.into_core()?; - let account = self - .detached(|client| async move { - client - .login(&ark.session, &username, &password, device) - .await - }) - .await?; + let account = detached(async move { + self.inner + .login(&ark.session, &username, &password, device) + .await + }) + .await?; Ok(account.into()) } - pub async fn step_up(&self, password: String) -> Result<(), SyncError> { + pub async fn step_up(self: Arc, password: String) -> Result<(), SyncError> { let password = Zeroizing::new(password); - self.detached(|client| async move { client.step_up(&password).await }) - .await + detached(async move { self.inner.step_up(&password).await }).await } - pub async fn devices(&self) -> Result, SyncError> { - let devices = self - .detached(|client| async move { client.devices().await }) - .await?; + pub async fn devices(self: Arc) -> Result, SyncError> { + let devices = detached(async move { self.inner.devices().await }).await?; Ok(devices.into_iter().map(SyncDevice::from).collect()) } - pub async fn delete_device(&self, id: DeviceId) -> Result<(), SyncError> { - self.detached(|client| async move { client.delete_device(id).await }) - .await + pub async fn delete_device(self: Arc, id: DeviceId) -> Result<(), SyncError> { + detached(async move { self.inner.delete_device(id).await }).await } - pub async fn logout(&self) -> Result<(), SyncError> { - self.detached(|client| async move { client.logout().await }) - .await + pub async fn logout(self: Arc) -> Result<(), SyncError> { + detached(async move { self.inner.logout().await }).await } } From df5247519a06b5b2d6b58aa55bbbe548d0cb99b4 Mon Sep 17 00:00:00 2001 From: Davis Date: Tue, 10 Nov 2026 18:04:00 +0100 Subject: [PATCH 31/52] refactor: rename exchange and send_signed --- rust/crates/keygo-client/src/sync/pipeline.rs | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-) diff --git a/rust/crates/keygo-client/src/sync/pipeline.rs b/rust/crates/keygo-client/src/sync/pipeline.rs index ffa01538c..0056a81da 100644 --- a/rust/crates/keygo-client/src/sync/pipeline.rs +++ b/rust/crates/keygo-client/src/sync/pipeline.rs @@ -121,7 +121,7 @@ impl SyncClient { .map_err(|e| SyncError::Network { message: e.message }) } - async fn send_signed( + async fn send_signed_once( &self, method: Method, url: &str, @@ -167,7 +167,7 @@ impl SyncClient { /// Signs and sends one request, and re-signs once if the server answers with a nonce challenge /// that carries a nonce. /// Every `DPoP-Nonce` header the server sends replaces the stored nonce. - pub(super) async fn exchange( + pub(super) async fn send_singed( &self, method: Method, path: &str, @@ -176,9 +176,13 @@ impl SyncClient { ) -> SyncResult { let url = self.url(path)?; - let response = self.send_signed(method, &url, access_token, body).await?; + let response = self + .send_signed_once(method, &url, access_token, body) + .await?; if self.remember_nonce_and_check_challenge(&response) { - let retried = self.send_signed(method, &url, access_token, body).await?; + let retried = self + .send_signed_once(method, &url, access_token, body) + .await?; self.remember_nonce_and_check_challenge(&retried); return Ok(retried); } @@ -221,7 +225,7 @@ impl SyncClient { let sent_at = self.clock.now_secs(); let response = self - .exchange(Token::METHOD, &Token.path(), None, Some(body.as_slice())) + .send_singed(Token::METHOD, &Token.path(), None, Some(body.as_slice())) .await?; if !response.is_success() { @@ -273,7 +277,7 @@ impl SyncClient { let (token, generation) = self.access_token(rejected).await?; let response = self - .exchange(method, path, Some(token.as_str()), body) + .send_singed(method, path, Some(token.as_str()), body) .await?; if rejected.is_some() || !response.is_invalid_token() { @@ -302,7 +306,7 @@ impl SyncClient { .await? } Auth::Proof => { - self.exchange(E::METHOD, &path, None, body.as_deref()) + self.send_singed(E::METHOD, &path, None, body.as_deref()) .await? } Auth::AccessToken => { From acace2934aeaaadd6fd9d262b7d8e545f2c881f5 Mon Sep 17 00:00:00 2001 From: Davis Date: Tue, 10 Nov 2026 20:24:59 +0100 Subject: [PATCH 32/52] feat(client): implement sync client registration --- rust/crates/keygo-client/src/ark_session.rs | 14 +- rust/crates/keygo-client/src/sync/client.rs | 263 ++++++++++++++++-- rust/crates/keygo-client/src/sync/error.rs | 2 + rust/crates/keygo-client/src/sync/pipeline.rs | 14 +- rust/crates/keygo-client/src/sync/testing.rs | 59 +++- .../crates/keygo-core/src/crypto/hierarchy.rs | 46 +++ rust/crates/keygo-core/src/keys.rs | 1 + rust/crates/keygo-core/src/lib.rs | 2 +- rust/crates/keygo-core/src/sealed.rs | 10 + rust/crates/keygo-e2e/tests/sync.rs | 111 ++++++++ rust/crates/keygo-uniffi/src/sync.rs | 12 +- 11 files changed, 492 insertions(+), 42 deletions(-) diff --git a/rust/crates/keygo-client/src/ark_session.rs b/rust/crates/keygo-client/src/ark_session.rs index 348062718..029e3bbe8 100644 --- a/rust/crates/keygo-client/src/ark_session.rs +++ b/rust/crates/keygo-client/src/ark_session.rs @@ -1,8 +1,10 @@ use crate::crypto::kdf::new_salt; use crate::crypto::{ AccountRootKey, CryptoError, Encrypts, KeyMaterial, NamespaceDataAad, NamespaceId, - NamespaceKey, NamespaceKeyAad, RootKek, Sealed, SecretKind, UserId, VaultId, VaultKey, Wraps, + NamespaceKey, NamespaceKeyAad, RootKek, Sealed, SecretKind, ServerKek, UserId, VaultId, + VaultKey, Wraps, }; +use keygo_opaque::ExportKey; use std::sync::{Mutex, MutexGuard}; use subtle::ConstantTimeEq; use zeroize::Zeroizing; @@ -147,6 +149,16 @@ impl ArkSession { Ok(PasswordWrappedArk { salt, wrapped }) } + pub fn wrap_for_server( + &self, + export_key: &ExportKey, + user_id: UserId, + ) -> ArkSessionResult> { + let kek = ServerKek::from_export_key(export_key.as_bytes(), user_id) + .map_err(ArkSessionError::Derivation)?; + self.with_live_ark(|ark| Ok(kek.wrap_key(ark, &user_id)?)) + } + pub fn wrap_vault_key( &self, vault_key: &VaultKey, diff --git a/rust/crates/keygo-client/src/sync/client.rs b/rust/crates/keygo-client/src/sync/client.rs index 51bc612ab..44b73d578 100644 --- a/rust/crates/keygo-client/src/sync/client.rs +++ b/rust/crates/keygo-client/src/sync/client.rs @@ -4,15 +4,18 @@ use super::signer::SharedSigner; use super::state::{AuthState, Clock, SystemClock}; use super::tokens::TokenStore; use super::transport::Transport; -use crate::ark_session::ArkSession; -use keygo_api::auth::step_up::{FinishRequest, StartRequest}; -use keygo_api::domain::{Device, DeviceInfo, Username}; -use keygo_api::endpoints::{DeleteDevice, ListDevices, Logout, Meta, StepUpFinish, StepUpStart}; +use crate::ark_session::{ArkSession, ArkSessionError}; +use keygo_api::auth::{register, step_up}; +use keygo_api::domain::{Device, DeviceInfo, KeyBundle, Username}; +use keygo_api::endpoints::{ + DeleteDevice, ListDevices, Logout, Meta, RegisterFinish, RegisterStart, StepUpFinish, + StepUpStart, +}; use keygo_api::meta::ServerInfo; use keygo_core::{DeviceId, UserId}; use keygo_dpop::DpopProver; use keygo_opaque::OpaqueError; -use keygo_opaque::client::ClientLogin; +use keygo_opaque::client::{ClientLogin, ClientRegistration}; use std::sync::Arc; use tokio::sync::Mutex; use url::Url; @@ -91,7 +94,7 @@ impl SyncClient { let (login, credential_request) = ClientLogin::start(password.as_bytes()).map_err(opaque_failure)?; let started = self - .call(&StepUpStart, &StartRequest { credential_request }) + .call(&StepUpStart, &step_up::StartRequest { credential_request }) .await?; let finish = login .finish(password.as_bytes(), started.credential_response) @@ -102,7 +105,7 @@ impl SyncClient { let response = self .call( &StepUpFinish, - &FinishRequest { + &step_up::FinishRequest { login_id: started.login_id, credential_finalization: finish.finalization, dpop_binding, @@ -117,17 +120,73 @@ impl SyncClient { Ok(()) } - /// Not implemented until the key bundle's wrapping is decided. pub async fn register( &self, - _ark: &ArkSession, - _user_id: UserId, - _username: &str, - _password: &str, - _invite: Option<&str>, - _device: DeviceInfo, + ark: &ArkSession, + user_id: UserId, + username: String, + password: &str, + invite: Option, + device: DeviceInfo, ) -> SyncResult { - Err(undecided()) + if !ark.is_active() { + return Err(SyncError::VaultLocked); + } + let (client, registration_request) = + ClientRegistration::start(password.as_bytes()).map_err(client_failure)?; + + // A previous account's refresh token must not stay valid on the server. + match self.logout().await { + Ok(()) | Err(SyncError::SignedOut { .. }) => {} + Err(error) => return Err(error), + } + + let started = self + .call( + &RegisterStart, + ®ister::StartRequest { + username, + user_id, + invite, + registration_request, + }, + ) + .await?; + let finish = client + .finish(password.as_bytes(), started.registration_response) + .map_err(|error| SyncError::invalid_response(error.to_string()))?; + + let wrapped_ark = ark + .wrap_for_server(&finish.export_key, user_id) + .map_err(|error| match error { + ArkSessionError::Locked => SyncError::VaultLocked, + other => client_failure(other), + })? + .into(); + let key_bundle = KeyBundle { wrapped_ark }; + + let sent_at = self.clock.now_secs(); + let response = self + .call( + &RegisterFinish, + ®ister::FinishRequest { + registration_id: started.registration_id, + registration_upload: finish.upload, + key_bundle, + device, + }, + ) + .await?; + + let account = Account { + user_id, + username: response.username, + device_id: response.session.device_id, + }; + let mut state = self.auth.lock().await; + self.adopt_session(&mut state, response.session, sent_at) + .await; + Ok(account) } /// Not implemented until the key bundle's wrapping is decided. @@ -160,12 +219,16 @@ fn undecided() -> SyncError { } } +fn client_failure(error: impl std::fmt::Display) -> SyncError { + SyncError::Client { + message: error.to_string(), + } +} + fn opaque_failure(error: OpaqueError) -> SyncError { match error { OpaqueError::InvalidLogin | OpaqueError::EmptyPassword => SyncError::InvalidCredentials, - other => SyncError::Client { - message: other.to_string(), - }, + other => client_failure(other), } } @@ -270,6 +333,170 @@ mod tests { )); } + mod register { + use super::super::super::testing::{FakeSigner, client_with_store, header}; + use super::super::super::transport::HttpRequest; + use super::super::SyncError; + use crate::ark_session::ArkSession; + use base64::Engine; + use base64::engine::general_purpose::URL_SAFE_NO_PAD; + use keygo_api::domain::DeviceInfo; + use keygo_core::UserId; + use keygo_opaque::server::{self, ServerSetup}; + use keygo_opaque::{OpaqueError, RegistrationRequest}; + use serde_json::{Value, json}; + use std::sync::Arc; + + const REGISTRATION_ID: &str = "BwcHBwcHBwcHBwcHBwcHBw"; + const REFRESH: &str = "kgr_AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"; + + fn unlocked() -> (ArkSession, UserId) { + let ark = ArkSession::new(); + let user_id = ark.create_account("local password").unwrap().user_id; + (ark, user_id) + } + + fn device() -> DeviceInfo { + serde_json::from_value(json!({ + "name": "Pixel 9", + "platform": "android", + "app_version": "2.3.0", + })) + .unwrap() + } + + fn body(request: &HttpRequest) -> Value { + serde_json::from_slice(&request.body).unwrap() + } + + /// What a real server answers to `register/start`. + fn start_reply(request: &HttpRequest) -> Vec { + let registration_request: RegistrationRequest = + serde_json::from_value(body(request)["registration_request"].clone()).unwrap(); + let response = + server::registration_start(&ServerSetup::generate(), registration_request, b"u") + .unwrap(); + serde_json::to_vec(&json!({ + "registration_id": REGISTRATION_ID, + "registration_response": response, + "expires_in": 300, + })) + .unwrap() + } + + fn finish_reply() -> Vec { + serde_json::to_vec(&json!({ + "username": "ada", + "session": { + "device_id": "00000000-0000-0000-0000-000000000001", + "access_token": "a.b.c", + "access_expires_in": 600, + "refresh_token": REFRESH, + "refresh_expires_in": 86400, + }, + })) + .unwrap() + } + + #[tokio::test] + async fn registers_and_keeps_the_session() { + let (client, transport, store) = + client_with_store("https://kg.example", Arc::new(FakeSigner::new())); + transport.push_with(200, start_reply); + transport.push(200, &[], &finish_reply()); + let (ark, user_id) = unlocked(); + + let account = client + .register(&ark, user_id, "Ada".into(), "pw", None, device()) + .await + .unwrap(); + + assert_eq!(account.user_id, user_id); + assert_eq!(account.username.as_str(), "ada"); + assert_eq!(store.current_refresh_token().as_deref(), Some(REFRESH)); + + let requests = transport.requests(); + assert_eq!(requests.len(), 2, "a signed-out client sends no logout"); + assert_eq!(header(&requests[0], "dpop"), None); + assert!(header(&requests[1], "dpop").is_some()); + + let finish = body(&requests[1]); + assert_eq!(finish["registration_id"], REGISTRATION_ID); + let wrapped_ark = URL_SAFE_NO_PAD + .decode(finish["key_bundle"]["wrapped_ark"].as_str().unwrap()) + .unwrap(); + assert_eq!(wrapped_ark.len(), 60); + } + + #[tokio::test] + async fn locked_vault_sends_nothing() { + let (client, transport, _) = + client_with_store("https://kg.example", Arc::new(FakeSigner::new())); + + let error = client + .register( + &ArkSession::new(), + UserId::random(), + "ada".into(), + "pw", + None, + device(), + ) + .await + .unwrap_err(); + + assert_eq!(error, SyncError::VaultLocked); + assert!(transport.requests().is_empty()); + } + + #[tokio::test] + async fn empty_password_sends_nothing() { + let (client, transport, _) = + client_with_store("https://kg.example", Arc::new(FakeSigner::new())); + let (ark, user_id) = unlocked(); + + let error = client + .register(&ark, user_id, "ada".into(), "", None, device()) + .await + .unwrap_err(); + + assert!(matches!(error, SyncError::Client { .. }), "{error:?}"); + assert!(transport.requests().is_empty()); + } + + /// A server that echoes the blinded element would learn the OPRF output; the client + /// refuses, and that is the server's fault, not a wrong password. + #[tokio::test] + async fn reflected_response_is_an_invalid_response() { + let (client, transport, _) = + client_with_store("https://kg.example", Arc::new(FakeSigner::new())); + transport.push_with(200, |request| { + let blinded = URL_SAFE_NO_PAD + .decode(body(request)["registration_request"].as_str().unwrap()) + .unwrap(); + let reflected = [blinded, ServerSetup::generate().public_key()].concat(); + serde_json::to_vec(&json!({ + "registration_id": REGISTRATION_ID, + "registration_response": URL_SAFE_NO_PAD.encode(reflected), + "expires_in": 300, + })) + .unwrap() + }); + let (ark, user_id) = unlocked(); + + let error = client + .register(&ark, user_id, "ada".into(), "pw", None, device()) + .await + .unwrap_err(); + + assert_eq!( + error, + SyncError::invalid_response(OpaqueError::ReflectedValue.to_string()), + ); + assert_eq!(transport.requests().len(), 1, "finish is never sent"); + } + } + #[tokio::test] async fn transport_failure_is_network() { let (client, transport) = fake_client(); diff --git a/rust/crates/keygo-client/src/sync/error.rs b/rust/crates/keygo-client/src/sync/error.rs index 669602692..f8969e046 100644 --- a/rust/crates/keygo-client/src/sync/error.rs +++ b/rust/crates/keygo-client/src/sync/error.rs @@ -21,6 +21,8 @@ pub enum SyncError { SignedOut { reason: Option }, #[error("rate limited")] RateLimited, + #[error("vault locked")] + VaultLocked, #[error("network error: {message}")] Network { message: String }, #[error("server error {code}: {message}")] diff --git a/rust/crates/keygo-client/src/sync/pipeline.rs b/rust/crates/keygo-client/src/sync/pipeline.rs index 0056a81da..11ac9c411 100644 --- a/rust/crates/keygo-client/src/sync/pipeline.rs +++ b/rust/crates/keygo-client/src/sync/pipeline.rs @@ -235,16 +235,24 @@ impl SyncClient { let body = Zeroizing::new(response.body); let session: Session = decode_body(&body)?; + let token = Zeroizing::new(session.access.access_token.expose().to_owned()); + self.adopt_session(state, session, sent_at).await; + Ok(token) + } + + pub(super) async fn adopt_session( + &self, + state: &mut AuthState, + session: Session, + sent_at: u64, + ) { state.unsaved = Some(StoredSession { device_id: session.device_id, refresh_token: session.refresh_token, refresh_expires_at: sent_at.saturating_add(session.refresh_expires_in), }); self.flush_unsaved(state).await; - - let token = Zeroizing::new(session.access.access_token.expose().to_owned()); state.replace_access(session.access, sent_at); - Ok(token) } /// Only a refresh holds the lock across the network. It is released before the request itself. diff --git a/rust/crates/keygo-client/src/sync/testing.rs b/rust/crates/keygo-client/src/sync/testing.rs index f2f911b9c..fa2597f55 100644 --- a/rust/crates/keygo-client/src/sync/testing.rs +++ b/rust/crates/keygo-client/src/sync/testing.rs @@ -12,15 +12,24 @@ use std::sync::{Arc, Mutex}; use url::Url; pub fn client_for(base: &str, signer: SharedSigner) -> (SyncClient, Arc) { + let (client, transport, _) = client_with_store(base, signer); + (client, transport) +} + +pub fn client_with_store( + base: &str, + signer: SharedSigner, +) -> (SyncClient, Arc, Arc) { let transport = FakeTransport::new(); + let store = Arc::new(FakeTokenStore::new()); let client = SyncClient::new( Url::parse(base).unwrap(), transport.clone(), signer, - Arc::new(FakeTokenStore::new()), + store.clone(), ) .unwrap(); - (client, transport) + (client, transport, store) } pub fn fake_client() -> (SyncClient, Arc) { @@ -39,8 +48,10 @@ pub fn error_body(code: &str) -> Vec { serde_json::to_vec(&serde_json::json!({"code": code, "message": "m"})).unwrap() } +type Reply = Box Result + Send>; + pub struct FakeTransport { - script: Mutex>>, + script: Mutex>, requests: Mutex>, } @@ -53,7 +64,7 @@ impl FakeTransport { } pub fn push(&self, status: u16, headers: &[(&str, &str)], body: &[u8]) { - self.script.lock().unwrap().push_back(Ok(HttpResponse { + let response = HttpResponse { status, headers: headers .iter() @@ -63,13 +74,36 @@ impl FakeTransport { }) .collect(), body: body.to_vec(), - })); + }; + self.reply(move |_| Ok(response)); + } + + /// Answers with a body built from the request, for replies that depend on what the client + /// generated, such as an OPAQUE response. + pub fn push_with( + &self, + status: u16, + body: impl FnOnce(&HttpRequest) -> Vec + Send + 'static, + ) { + self.reply(move |request| { + Ok(HttpResponse { + status, + headers: Vec::new(), + body: body(request), + }) + }); } pub fn push_network_error(&self, message: &str) { - self.script.lock().unwrap().push_back(Err(TransportError { - message: message.into(), - })); + let message = message.to_owned(); + self.reply(move |_| Err(TransportError { message })); + } + + fn reply( + &self, + reply: impl FnOnce(&HttpRequest) -> Result + Send + 'static, + ) { + self.script.lock().unwrap().push_back(Box::new(reply)); } pub fn requests(&self) -> Vec { @@ -82,12 +116,15 @@ impl Transport for FakeTransport { async fn send(&self, request: HttpRequest) -> Result { // Lets concurrent tests really interleave. tokio::task::yield_now().await; - self.requests.lock().unwrap().push(request); - self.script + let reply = self + .script .lock() .unwrap() .pop_front() - .expect("FakeTransport script is empty") + .expect("FakeTransport script is empty"); + let response = reply(&request); + self.requests.lock().unwrap().push(request); + response } } diff --git a/rust/crates/keygo-core/src/crypto/hierarchy.rs b/rust/crates/keygo-core/src/crypto/hierarchy.rs index 21a49a136..c0a03c553 100644 --- a/rust/crates/keygo-core/src/crypto/hierarchy.rs +++ b/rust/crates/keygo-core/src/crypto/hierarchy.rs @@ -9,16 +9,23 @@ use crate::crypto::aad::{Aad, aad}; use crate::crypto::kdf::argon2::{Argon2Params, derive_argon2id}; use crate::crypto::{CipherKey, Encrypts, KeyMaterial, Wraps}; +use crate::keys::ServerKek; use crate::{ AccountRootKey, CryptoResult, ItemId, ItemKey, NamespaceId, NamespaceKey, RootKek, UserId, VaultId, VaultKey, }; use aead::Generate; +use hkdf::Hkdf; use serde::{Serialize, Serializer}; +use sha2::Sha256; +use zeroize::Zeroizing; /// Part of every password KEK's salt; must never change. const PASSWORD_DOMAIN: &[u8] = b"v1:kek/pwd"; +/// The HKDF info of every server KEK; must never change. +const OPAQUE_KEK_DOMAIN: &[u8] = b"v1:kek/opaque"; + /// Part of every namespace-key wrap AAD; must never change. const NAMESPACE_KEY_DOMAIN: &str = "v1:ns/key"; @@ -110,6 +117,7 @@ macro_rules! wraps { } wraps! { + ServerKek -> AccountRootKey with UserId, RootKek -> AccountRootKey with UserId, // TODO: bind the credential epoch AccountRootKey -> VaultKey with VaultId, // TODO: bind vault_key_epoch AccountRootKey -> NamespaceKey with NamespaceKeyAad, @@ -131,6 +139,16 @@ impl RootKek { } } +impl ServerKek { + pub fn from_export_key(key: &[u8], user_id: UserId) -> CryptoResult { + let mut derived = Zeroizing::new([0u8; 32]); + Hkdf::::new(Some(user_id.as_uuid().as_bytes()), key) + .expand(OPAQUE_KEK_DOMAIN, derived.as_mut()) + .expect("32 bytes is a valid HKDF-SHA256 output length"); + Self::from_bytes(derived.as_slice()) + } +} + macro_rules! impl_generate { ($($key:ident),+) => { $(impl $key { @@ -180,6 +198,34 @@ mod tests { ); } + fn user(byte: u8) -> UserId { + UserId::from(uuid::Uuid::from_bytes([byte; 16])) + } + + /// Pins `OPAQUE_KEK_DOMAIN` and the salt; drift makes every server-held ARK unopenable. + #[test] + fn opaque_kek_domain_is_pinned() { + assert_eq!(OPAQUE_KEK_DOMAIN, b"v1:kek/opaque"); + + let kek = ServerKek::from_export_key(&[9; 64], user(3)).unwrap(); + + // Cross-checked against RFC 5869 HKDF-SHA256 outside Rust. + assert_eq!( + kek.as_bytes(), + &[ + 27, 101, 7, 214, 170, 93, 0, 161, 91, 141, 171, 209, 225, 137, 214, 134, 221, 88, + 108, 144, 212, 175, 208, 136, 181, 194, 182, 0, 55, 168, 52, 233, + ][..] + ); + } + + #[test] + fn server_kek_depends_on_the_user() { + let a = ServerKek::from_export_key(&[9; 64], user(3)).unwrap(); + let b = ServerKek::from_export_key(&[9; 64], user(4)).unwrap(); + assert_ne!(a.as_bytes(), b.as_bytes()); + } + /// Pins every label; drift makes that field undecryptable everywhere. #[test] fn secret_kind_labels_are_pinned() { diff --git a/rust/crates/keygo-core/src/keys.rs b/rust/crates/keygo-core/src/keys.rs index 348f2a750..383c4ed43 100644 --- a/rust/crates/keygo-core/src/keys.rs +++ b/rust/crates/keygo-core/src/keys.rs @@ -42,6 +42,7 @@ macro_rules! symmetric_key { pub(crate) use symmetric_key; symmetric_key! { + pub struct ServerKek, pub struct RootKek, pub struct AccountRootKey, diff --git a/rust/crates/keygo-core/src/lib.rs b/rust/crates/keygo-core/src/lib.rs index 131b44a43..bbcbfd012 100644 --- a/rust/crates/keygo-core/src/lib.rs +++ b/rust/crates/keygo-core/src/lib.rs @@ -16,5 +16,5 @@ mod sealed; pub use crypto::*; pub use error::{CryptoError, CryptoResult}; pub use ids::{DeviceId, ItemId, NamespaceId, SessionId, UserId, VaultId}; -pub use keys::{AccountRootKey, BackupKey, ItemKey, NamespaceKey, RootKek, VaultKey}; +pub use keys::*; pub use sealed::{KEY_LEN, NONCE_LEN, Sealed, TAG_LEN}; diff --git a/rust/crates/keygo-core/src/sealed.rs b/rust/crates/keygo-core/src/sealed.rs index 782472901..01c250996 100644 --- a/rust/crates/keygo-core/src/sealed.rs +++ b/rust/crates/keygo-core/src/sealed.rs @@ -14,6 +14,16 @@ pub struct Sealed { pub(crate) content: PhantomData Box>, } +impl From> for Sealed<[u8]> { + fn from(value: Sealed) -> Self { + Self { + nonce: value.nonce, + ciphertext: value.ciphertext, + content: PhantomData, + } + } +} + impl Sealed { pub fn from_parts(nonce: &[u8], ciphertext: Vec) -> CryptoResult { let nonce = nonce diff --git a/rust/crates/keygo-e2e/tests/sync.rs b/rust/crates/keygo-e2e/tests/sync.rs index e70513448..4cd5e8e99 100644 --- a/rust/crates/keygo-e2e/tests/sync.rs +++ b/rust/crates/keygo-e2e/tests/sync.rs @@ -3,12 +3,15 @@ use axum::body::Body; use axum::http::{HeaderName, HeaderValue, Request}; use http_body_util::BodyExt; use keygo_api::domain::{Device, RevokeReason}; +use keygo_client::ark_session::ArkSession; use keygo_client::sync::testing::{FakeSigner, FakeTokenStore, FixedClock}; use keygo_client::sync::{ Clock, Header, HttpRequest, HttpResponse, StoredSession, SyncClient, SyncError, SystemClock, Transport, TransportError, }; +use keygo_core::{AccountRootKey, KeyMaterial, Sealed, ServerKek, UserId, Wraps}; use keygo_dpop::testing::TestSigner; +use keygo_opaque::server::ServerSetup; use keygo_server::api::{AppState, router}; use keygo_server::testing; use sqlx::PgPool; @@ -109,6 +112,40 @@ async fn harness(db: &PgPool) -> Harness { } } +/// A client with nothing stored, against a server with no session for it. +fn signed_out(db: &PgPool) -> (SyncClient, Arc, AppState) { + let state = testing::app_state(db, &ServerSetup::generate()); + let store = Arc::new(FakeTokenStore::new()); + let client = SyncClient::new( + Url::parse(testing::ISS).unwrap(), + Arc::new(TowerTransport(state.clone())), + Arc::new(FakeSigner::new()), + store.clone(), + ) + .unwrap(); + (client, store, state) +} + +fn local_account() -> (ArkSession, UserId) { + let ark = ArkSession::new(); + let user_id = ark.create_account(password()).unwrap().user_id; + (ark, user_id) +} + +async fn register(client: &SyncClient, ark: &ArkSession, user_id: UserId, name: &str) { + client + .register( + ark, + user_id, + name.into(), + password(), + None, + testing::device_info(), + ) + .await + .unwrap(); +} + fn password() -> &'static str { std::str::from_utf8(testing::PASSWORD).unwrap() } @@ -243,6 +280,80 @@ async fn client_logout_ends_the_session_on_the_server(db: PgPool) { assert!(!status.is_success(), "{status}"); } +#[sqlx::test(migrations = "../keygo-server/migrations")] +async fn register_signs_the_device_in(db: PgPool) { + let (client, store, _) = signed_out(&db); + let (ark, user_id) = local_account(); + + let account = client + .register( + &ark, + user_id, + "Ada".into(), + password(), + None, + testing::device_info(), + ) + .await + .unwrap(); + + assert_eq!(account.user_id, user_id); + assert_eq!(account.username.as_str(), "ada"); + assert!(store.current_refresh_token().is_some()); + let devices = client.devices().await.unwrap(); + assert_eq!(devices.len(), 1); + assert_eq!(devices[0].id, account.device_id); +} + +#[sqlx::test(migrations = "../keygo-server/migrations")] +async fn server_wrapped_ark_opens_after_sign_in(db: PgPool) { + let (client, _, state) = signed_out(&db); + let (ark, user_id) = local_account(); + register(&client, &ark, user_id, "ada").await; + + let (login, started) = + testing::start_login(&db, &state.login_states, &state.opaque_state, "ada").await; + let export_key = login + .finish(testing::PASSWORD, started.credential_response) + .unwrap() + .export_key; + let stored: Vec = + sqlx::query_scalar("select wrapped_ark from key_bundles where user_id = $1") + .bind(user_id.as_uuid()) + .fetch_one(&db) + .await + .unwrap(); + + let opened = ServerKek::from_export_key(export_key.as_bytes(), user_id) + .unwrap() + .unwrap_key( + &Sealed::::from_bytes(&stored).unwrap(), + &user_id, + ) + .unwrap(); + + assert_eq!(opened.as_bytes(), ark.export_ark().unwrap().as_slice()); +} + +#[sqlx::test(migrations = "../keygo-server/migrations")] +async fn registering_while_signed_in_ends_the_old_session(db: PgPool) { + let h = harness(&db).await; + let (ark, user_id) = local_account(); + + register(&h.client, &ark, user_id, "bob").await; + + let (status, _) = testing::post_with_token( + &h.state, + &h.prover, + "/api/v1/auth/logout", + &h.access_token, + serde_json::Value::Null, + ) + .await; + assert!(!status.is_success(), "{status}"); + assert_ne!(h.store.current_refresh_token().unwrap(), h.seed_token); +} + #[sqlx::test(migrations = "../keygo-server/migrations")] async fn refused_save_does_not_trip_reuse_detection(db: PgPool) { let h = harness(&db).await; diff --git a/rust/crates/keygo-uniffi/src/sync.rs b/rust/crates/keygo-uniffi/src/sync.rs index 91403db8c..f64e37186 100644 --- a/rust/crates/keygo-uniffi/src/sync.rs +++ b/rust/crates/keygo-uniffi/src/sync.rs @@ -35,6 +35,8 @@ pub enum SyncError { SignedOut { reason: Option }, #[error("rate limited")] RateLimited, + #[error("vault locked")] + Locked, #[error("network error: {reason}")] Network { reason: String }, #[error("server error {code}: {reason}")] @@ -58,6 +60,7 @@ impl From for SyncError { reason: reason.map(|r| r.as_str().to_owned()), }, CoreSyncError::RateLimited => Self::RateLimited, + CoreSyncError::VaultLocked => Self::Locked, CoreSyncError::Network { message } => Self::Network { reason: message }, CoreSyncError::Server { code, message } => Self::Server { code, @@ -376,14 +379,7 @@ impl SyncClient { let device = device.into_core()?; let account = detached(async move { self.inner - .register( - &ark.session, - user_id, - &username, - &password, - invite.as_deref(), - device, - ) + .register(&ark.session, user_id, username, &password, invite, device) .await }) .await?; From ab6db0f83188b60636609d9a4fe4cac02567ac36 Mon Sep 17 00:00:00 2001 From: Davis Date: Thu, 12 Nov 2026 10:59:24 +0100 Subject: [PATCH 33/52] feat(client): implement sync client login --- rust/crates/keygo-client/src/ark_session.rs | 22 +++++ rust/crates/keygo-client/src/sync/client.rs | 82 ++++++++++++++----- rust/crates/keygo-client/src/sync/pipeline.rs | 10 ++- rust/crates/keygo-core/src/sealed.rs | 10 +++ rust/crates/keygo-uniffi/src/ark_session.rs | 3 + rust/crates/keygo-uniffi/src/sync.rs | 2 +- 6 files changed, 107 insertions(+), 22 deletions(-) diff --git a/rust/crates/keygo-client/src/ark_session.rs b/rust/crates/keygo-client/src/ark_session.rs index 029e3bbe8..23dc325a1 100644 --- a/rust/crates/keygo-client/src/ark_session.rs +++ b/rust/crates/keygo-client/src/ark_session.rs @@ -13,6 +13,8 @@ use zeroize::Zeroizing; pub enum ArkSessionError { #[error("No active session")] Locked, + #[error("Session holds a different account")] + AccountMismatch, #[error("Wrong password")] WrongPassword, #[error("Key derivation failed: {0}")] @@ -94,6 +96,26 @@ impl ArkSession { }) } + pub fn unlock_with_server( + &self, + export_key: &ExportKey, + wrapped: &Sealed, + user_id: UserId, + ) -> ArkSessionResult<()> { + let ark = ServerKek::from_export_key(export_key.as_bytes(), user_id) + .map_err(ArkSessionError::Derivation)? + .unwrap_key(wrapped, &user_id)?; + + let mut live = self.lock(); + match live.as_ref() { + None => *live = Some(ark), + Some(current) if bool::from(current.as_bytes().ct_eq(ark.as_bytes())) => {} + Some(_) => return Err(ArkSessionError::AccountMismatch), + } + + Ok(()) + } + pub fn unlock_with_password( &self, password: &str, diff --git a/rust/crates/keygo-client/src/sync/client.rs b/rust/crates/keygo-client/src/sync/client.rs index 44b73d578..c82b5b359 100644 --- a/rust/crates/keygo-client/src/sync/client.rs +++ b/rust/crates/keygo-client/src/sync/client.rs @@ -5,17 +5,18 @@ use super::state::{AuthState, Clock, SystemClock}; use super::tokens::TokenStore; use super::transport::Transport; use crate::ark_session::{ArkSession, ArkSessionError}; -use keygo_api::auth::{register, step_up}; -use keygo_api::domain::{Device, DeviceInfo, KeyBundle, Username}; +use keygo_api::auth::{login, register, step_up}; +use keygo_api::domain::{Device, DeviceClaim, DeviceInfo, KeyBundle, Username}; use keygo_api::endpoints::{ - DeleteDevice, ListDevices, Logout, Meta, RegisterFinish, RegisterStart, StepUpFinish, - StepUpStart, + DeleteDevice, ListDevices, LoginFinish, LoginStart, Logout, Meta, RegisterFinish, + RegisterStart, StepUpFinish, StepUpStart, }; use keygo_api::meta::ServerInfo; use keygo_core::{DeviceId, UserId}; use keygo_dpop::DpopProver; use keygo_opaque::OpaqueError; use keygo_opaque::client::{ClientLogin, ClientRegistration}; +use std::fmt::Debug; use std::sync::Arc; use tokio::sync::Mutex; use url::Url; @@ -183,21 +184,70 @@ impl SyncClient { username: response.username, device_id: response.session.device_id, }; - let mut state = self.auth.lock().await; - self.adopt_session(&mut state, response.session, sent_at) - .await; + self.adopt_session(response.session, sent_at).await; Ok(account) } - /// Not implemented until the key bundle's wrapping is decided. pub async fn login( &self, - _ark: &ArkSession, - _username: &str, - _password: &str, - _device: DeviceInfo, + ark: &ArkSession, + username: String, + password: &str, + device: DeviceInfo, ) -> SyncResult { - Err(undecided()) + let (client, credential_request) = + ClientLogin::start(password.as_bytes()).map_err(opaque_failure)?; + let started = self + .call( + &LoginStart, + &login::StartRequest { + username, + credential_request, + }, + ) + .await?; + let finish = client + .finish(password.as_bytes(), started.credential_response) + .map_err(opaque_failure)?; + let dpop_binding = finish.session_key.dpop_binding(self.prover.jkt()); + + let sent_at = self.clock.now_secs(); + let response = self + .call( + &LoginFinish, + &login::FinishRequest { + login_id: started.login_id, + credential_finalization: finish.finalization, + device: DeviceClaim { + id: None, + info: device, + }, + dpop_binding, + }, + ) + .await?; + + let account = Account { + user_id: response.user_id, + username: response.username, + device_id: response.session.device_id, + }; + + // We dont catch the error early, because the server already created the session and the + // device. To revoke that session from the server, we adopt the session so logout is available. + let unlocked = ark.unlock_with_server( + &finish.export_key, + &response.key_bundle.wrapped_ark.into(), + response.user_id, + ); + self.adopt_session(response.session, sent_at).await; + + if let Err(error) = unlocked { + let _ = self.logout().await; + return Err(client_failure(error)); + } + + Ok(account) } /// Always ends the session locally. Returns the server's result, unless the server was not told @@ -213,12 +263,6 @@ impl SyncClient { } } -fn undecided() -> SyncError { - SyncError::Client { - message: "key bundle wrapping is not decided".into(), - } -} - fn client_failure(error: impl std::fmt::Display) -> SyncError { SyncError::Client { message: error.to_string(), diff --git a/rust/crates/keygo-client/src/sync/pipeline.rs b/rust/crates/keygo-client/src/sync/pipeline.rs index 11ac9c411..be544c2a6 100644 --- a/rust/crates/keygo-client/src/sync/pipeline.rs +++ b/rust/crates/keygo-client/src/sync/pipeline.rs @@ -236,11 +236,17 @@ impl SyncClient { let session: Session = decode_body(&body)?; let token = Zeroizing::new(session.access.access_token.expose().to_owned()); - self.adopt_session(state, session, sent_at).await; + self.adopt_session_with_state(state, session, sent_at).await; Ok(token) } - pub(super) async fn adopt_session( + pub(super) async fn adopt_session(&self, session: Session, sent_at: u64) { + let mut state = self.auth.lock().await; + self.adopt_session_with_state(&mut state, session, sent_at) + .await; + } + + async fn adopt_session_with_state( &self, state: &mut AuthState, session: Session, diff --git a/rust/crates/keygo-core/src/sealed.rs b/rust/crates/keygo-core/src/sealed.rs index 01c250996..ff1943a47 100644 --- a/rust/crates/keygo-core/src/sealed.rs +++ b/rust/crates/keygo-core/src/sealed.rs @@ -24,6 +24,16 @@ impl From> for Sealed<[u8]> { } } +impl From> for Sealed { + fn from(value: Sealed<[u8]>) -> Self { + Self { + nonce: value.nonce, + ciphertext: value.ciphertext, + content: PhantomData, + } + } +} + impl Sealed { pub fn from_parts(nonce: &[u8], ciphertext: Vec) -> CryptoResult { let nonce = nonce diff --git a/rust/crates/keygo-uniffi/src/ark_session.rs b/rust/crates/keygo-uniffi/src/ark_session.rs index 4a18d2aa7..00b44fb76 100644 --- a/rust/crates/keygo-uniffi/src/ark_session.rs +++ b/rust/crates/keygo-uniffi/src/ark_session.rs @@ -11,6 +11,8 @@ use std::sync::Arc; pub enum ArkSessionError { #[error("No active session")] Locked, + #[error("Session holds a different account")] + AccountMismatch, #[error("Wrong password")] WrongPassword, #[error("Key derivation failed: {0}")] @@ -25,6 +27,7 @@ impl From for ArkSessionError { fn from(value: CoreArkSessionError) -> Self { match value { CoreArkSessionError::Locked => Self::Locked, + CoreArkSessionError::AccountMismatch => Self::AccountMismatch, CoreArkSessionError::WrongPassword => Self::WrongPassword, CoreArkSessionError::Derivation(e) => Self::Derivation(e.to_string()), CoreArkSessionError::KeyWrap(CryptoError::DecryptionFailed) => Self::DecryptionFailed, diff --git a/rust/crates/keygo-uniffi/src/sync.rs b/rust/crates/keygo-uniffi/src/sync.rs index f64e37186..ff2eb78c4 100644 --- a/rust/crates/keygo-uniffi/src/sync.rs +++ b/rust/crates/keygo-uniffi/src/sync.rs @@ -397,7 +397,7 @@ impl SyncClient { let device = device.into_core()?; let account = detached(async move { self.inner - .login(&ark.session, &username, &password, device) + .login(&ark.session, username, &password, device) .await }) .await?; From b6f109f1866c2b1ae0f0266852a97824da0b78bf Mon Sep 17 00:00:00 2001 From: Davis Date: Fri, 13 Nov 2026 13:07:46 +0100 Subject: [PATCH 34/52] refactor(core): rename ServerKek to OpaqueKek Co-Authored-By: Claude Opus 5.5 --- rust/crates/keygo-client/src/ark_session.rs | 6 +++--- rust/crates/keygo-core/src/crypto/hierarchy.rs | 17 ++++++++--------- rust/crates/keygo-core/src/keys.rs | 2 +- rust/crates/keygo-core/src/lib.rs | 2 +- rust/crates/keygo-e2e/tests/sync.rs | 4 ++-- 5 files changed, 15 insertions(+), 16 deletions(-) diff --git a/rust/crates/keygo-client/src/ark_session.rs b/rust/crates/keygo-client/src/ark_session.rs index 23dc325a1..a7bcc9332 100644 --- a/rust/crates/keygo-client/src/ark_session.rs +++ b/rust/crates/keygo-client/src/ark_session.rs @@ -1,7 +1,7 @@ use crate::crypto::kdf::new_salt; use crate::crypto::{ AccountRootKey, CryptoError, Encrypts, KeyMaterial, NamespaceDataAad, NamespaceId, - NamespaceKey, NamespaceKeyAad, RootKek, Sealed, SecretKind, ServerKek, UserId, VaultId, + NamespaceKey, NamespaceKeyAad, OpaqueKek, RootKek, Sealed, SecretKind, UserId, VaultId, VaultKey, Wraps, }; use keygo_opaque::ExportKey; @@ -102,7 +102,7 @@ impl ArkSession { wrapped: &Sealed, user_id: UserId, ) -> ArkSessionResult<()> { - let ark = ServerKek::from_export_key(export_key.as_bytes(), user_id) + let ark = OpaqueKek::from_export_key(export_key.as_bytes(), user_id) .map_err(ArkSessionError::Derivation)? .unwrap_key(wrapped, &user_id)?; @@ -176,7 +176,7 @@ impl ArkSession { export_key: &ExportKey, user_id: UserId, ) -> ArkSessionResult> { - let kek = ServerKek::from_export_key(export_key.as_bytes(), user_id) + let kek = OpaqueKek::from_export_key(export_key.as_bytes(), user_id) .map_err(ArkSessionError::Derivation)?; self.with_live_ark(|ark| Ok(kek.wrap_key(ark, &user_id)?)) } diff --git a/rust/crates/keygo-core/src/crypto/hierarchy.rs b/rust/crates/keygo-core/src/crypto/hierarchy.rs index c0a03c553..696f9c9dd 100644 --- a/rust/crates/keygo-core/src/crypto/hierarchy.rs +++ b/rust/crates/keygo-core/src/crypto/hierarchy.rs @@ -9,10 +9,9 @@ use crate::crypto::aad::{Aad, aad}; use crate::crypto::kdf::argon2::{Argon2Params, derive_argon2id}; use crate::crypto::{CipherKey, Encrypts, KeyMaterial, Wraps}; -use crate::keys::ServerKek; use crate::{ - AccountRootKey, CryptoResult, ItemId, ItemKey, NamespaceId, NamespaceKey, RootKek, UserId, - VaultId, VaultKey, + AccountRootKey, CryptoResult, ItemId, ItemKey, NamespaceId, NamespaceKey, OpaqueKek, RootKek, + UserId, VaultId, VaultKey, }; use aead::Generate; use hkdf::Hkdf; @@ -23,7 +22,7 @@ use zeroize::Zeroizing; /// Part of every password KEK's salt; must never change. const PASSWORD_DOMAIN: &[u8] = b"v1:kek/pwd"; -/// The HKDF info of every server KEK; must never change. +/// The HKDF info of every OPAQUE KEK; must never change. const OPAQUE_KEK_DOMAIN: &[u8] = b"v1:kek/opaque"; /// Part of every namespace-key wrap AAD; must never change. @@ -117,7 +116,7 @@ macro_rules! wraps { } wraps! { - ServerKek -> AccountRootKey with UserId, + OpaqueKek -> AccountRootKey with UserId, RootKek -> AccountRootKey with UserId, // TODO: bind the credential epoch AccountRootKey -> VaultKey with VaultId, // TODO: bind vault_key_epoch AccountRootKey -> NamespaceKey with NamespaceKeyAad, @@ -139,7 +138,7 @@ impl RootKek { } } -impl ServerKek { +impl OpaqueKek { pub fn from_export_key(key: &[u8], user_id: UserId) -> CryptoResult { let mut derived = Zeroizing::new([0u8; 32]); Hkdf::::new(Some(user_id.as_uuid().as_bytes()), key) @@ -207,7 +206,7 @@ mod tests { fn opaque_kek_domain_is_pinned() { assert_eq!(OPAQUE_KEK_DOMAIN, b"v1:kek/opaque"); - let kek = ServerKek::from_export_key(&[9; 64], user(3)).unwrap(); + let kek = OpaqueKek::from_export_key(&[9; 64], user(3)).unwrap(); // Cross-checked against RFC 5869 HKDF-SHA256 outside Rust. assert_eq!( @@ -221,8 +220,8 @@ mod tests { #[test] fn server_kek_depends_on_the_user() { - let a = ServerKek::from_export_key(&[9; 64], user(3)).unwrap(); - let b = ServerKek::from_export_key(&[9; 64], user(4)).unwrap(); + let a = OpaqueKek::from_export_key(&[9; 64], user(3)).unwrap(); + let b = OpaqueKek::from_export_key(&[9; 64], user(4)).unwrap(); assert_ne!(a.as_bytes(), b.as_bytes()); } diff --git a/rust/crates/keygo-core/src/keys.rs b/rust/crates/keygo-core/src/keys.rs index 383c4ed43..96a596dd1 100644 --- a/rust/crates/keygo-core/src/keys.rs +++ b/rust/crates/keygo-core/src/keys.rs @@ -42,7 +42,7 @@ macro_rules! symmetric_key { pub(crate) use symmetric_key; symmetric_key! { - pub struct ServerKek, + pub struct OpaqueKek, pub struct RootKek, pub struct AccountRootKey, diff --git a/rust/crates/keygo-core/src/lib.rs b/rust/crates/keygo-core/src/lib.rs index bbcbfd012..a7356bda9 100644 --- a/rust/crates/keygo-core/src/lib.rs +++ b/rust/crates/keygo-core/src/lib.rs @@ -16,5 +16,5 @@ mod sealed; pub use crypto::*; pub use error::{CryptoError, CryptoResult}; pub use ids::{DeviceId, ItemId, NamespaceId, SessionId, UserId, VaultId}; -pub use keys::*; +pub use keys::{AccountRootKey, BackupKey, ItemKey, NamespaceKey, OpaqueKek, RootKek, VaultKey}; pub use sealed::{KEY_LEN, NONCE_LEN, Sealed, TAG_LEN}; diff --git a/rust/crates/keygo-e2e/tests/sync.rs b/rust/crates/keygo-e2e/tests/sync.rs index 4cd5e8e99..b3998e785 100644 --- a/rust/crates/keygo-e2e/tests/sync.rs +++ b/rust/crates/keygo-e2e/tests/sync.rs @@ -9,7 +9,7 @@ use keygo_client::sync::{ Clock, Header, HttpRequest, HttpResponse, StoredSession, SyncClient, SyncError, SystemClock, Transport, TransportError, }; -use keygo_core::{AccountRootKey, KeyMaterial, Sealed, ServerKek, UserId, Wraps}; +use keygo_core::{AccountRootKey, KeyMaterial, OpaqueKek, Sealed, UserId, Wraps}; use keygo_dpop::testing::TestSigner; use keygo_opaque::server::ServerSetup; use keygo_server::api::{AppState, router}; @@ -324,7 +324,7 @@ async fn server_wrapped_ark_opens_after_sign_in(db: PgPool) { .await .unwrap(); - let opened = ServerKek::from_export_key(export_key.as_bytes(), user_id) + let opened = OpaqueKek::from_export_key(export_key.as_bytes(), user_id) .unwrap() .unwrap_key( &Sealed::::from_bytes(&stored).unwrap(), From 425a9865b045e58472e89b1e0b395c83e750f600 Mon Sep 17 00:00:00 2001 From: Davis Date: Fri, 13 Nov 2026 13:07:58 +0100 Subject: [PATCH 35/52] refactor(core): make retagging a sealed blob explicit Co-Authored-By: Claude Opus 5.5 --- rust/crates/keygo-api/src/domain/key_bundle.rs | 8 ++++++++ rust/crates/keygo-client/src/sync/client.rs | 2 +- rust/crates/keygo-core/src/sealed.rs | 13 ++++++++----- 3 files changed, 17 insertions(+), 6 deletions(-) diff --git a/rust/crates/keygo-api/src/domain/key_bundle.rs b/rust/crates/keygo-api/src/domain/key_bundle.rs index a248d05c0..863f49dbb 100644 --- a/rust/crates/keygo-api/src/domain/key_bundle.rs +++ b/rust/crates/keygo-api/src/domain/key_bundle.rs @@ -1,7 +1,15 @@ use crate::domain::SealedBlob; +use keygo_core::{AccountRootKey, Sealed}; use serde::{Deserialize, Serialize}; #[derive(Serialize, Deserialize)] pub struct KeyBundle { pub wrapped_ark: SealedBlob, } + +impl KeyBundle { + /// The protocol fixes this field as the ARK wrapped under the account's OPAQUE KEK. + pub fn into_wrapped_ark(self) -> Sealed { + self.wrapped_ark.assume() + } +} diff --git a/rust/crates/keygo-client/src/sync/client.rs b/rust/crates/keygo-client/src/sync/client.rs index c82b5b359..b29828bb8 100644 --- a/rust/crates/keygo-client/src/sync/client.rs +++ b/rust/crates/keygo-client/src/sync/client.rs @@ -237,7 +237,7 @@ impl SyncClient { // device. To revoke that session from the server, we adopt the session so logout is available. let unlocked = ark.unlock_with_server( &finish.export_key, - &response.key_bundle.wrapped_ark.into(), + &response.key_bundle.into_wrapped_ark(), response.user_id, ); self.adopt_session(response.session, sent_at).await; diff --git a/rust/crates/keygo-core/src/sealed.rs b/rust/crates/keygo-core/src/sealed.rs index ff1943a47..645cb196d 100644 --- a/rust/crates/keygo-core/src/sealed.rs +++ b/rust/crates/keygo-core/src/sealed.rs @@ -24,11 +24,14 @@ impl From> for Sealed<[u8]> { } } -impl From> for Sealed { - fn from(value: Sealed<[u8]>) -> Self { - Self { - nonce: value.nonce, - ciphertext: value.ciphertext, +impl Sealed<[u8]> { + /// Claims an untyped blob holds a `T`. Only for a wire field whose kind the protocol fixes: + /// nothing checks the claim before the unwrap, so it is not a `From`, which any blob could + /// reach by accident. The AAD still rejects a blob of another kind at unwrap time. + pub fn assume(self) -> Sealed { + Sealed { + nonce: self.nonce, + ciphertext: self.ciphertext, content: PhantomData, } } From 38d9cc6f0acf80dce1f73ab1176264cfe4cd2a85 Mon Sep 17 00:00:00 2001 From: Davis Date: Fri, 13 Nov 2026 13:08:00 +0100 Subject: [PATCH 36/52] fix(client): zeroize response bodies Co-Authored-By: Claude Opus 5.5 --- rust/crates/keygo-client/src/sync/pipeline.rs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/rust/crates/keygo-client/src/sync/pipeline.rs b/rust/crates/keygo-client/src/sync/pipeline.rs index be544c2a6..69f7b9130 100644 --- a/rust/crates/keygo-client/src/sync/pipeline.rs +++ b/rust/crates/keygo-client/src/sync/pipeline.rs @@ -330,7 +330,9 @@ impl SyncClient { }; if response.is_success() { - return decode_body(&response.body); + // Sign-in responses carry tokens. + let body = Zeroizing::new(response.body); + return decode_body(&body); } Err(self .failure(self.auth.lock().await.deref_mut(), &response) From f74f79ec7be5819086ecb3604eb5d8f363527910 Mon Sep 17 00:00:00 2001 From: Davis Date: Fri, 13 Nov 2026 13:08:02 +0100 Subject: [PATCH 37/52] fix(client): treat an empty register password as invalid credentials Co-Authored-By: Claude Opus 5.5 --- rust/crates/keygo-client/src/sync/client.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/rust/crates/keygo-client/src/sync/client.rs b/rust/crates/keygo-client/src/sync/client.rs index b29828bb8..d043c87a4 100644 --- a/rust/crates/keygo-client/src/sync/client.rs +++ b/rust/crates/keygo-client/src/sync/client.rs @@ -134,7 +134,7 @@ impl SyncClient { return Err(SyncError::VaultLocked); } let (client, registration_request) = - ClientRegistration::start(password.as_bytes()).map_err(client_failure)?; + ClientRegistration::start(password.as_bytes()).map_err(opaque_failure)?; // A previous account's refresh token must not stay valid on the server. match self.logout().await { @@ -504,7 +504,7 @@ mod tests { .await .unwrap_err(); - assert!(matches!(error, SyncError::Client { .. }), "{error:?}"); + assert_eq!(error, SyncError::InvalidCredentials); assert!(transport.requests().is_empty()); } From 69f98ac7453e38716dc8bcb6fe7fa44475e0fcf1 Mon Sep 17 00:00:00 2001 From: Davis Date: Fri, 13 Nov 2026 13:08:04 +0100 Subject: [PATCH 38/52] refactor(uniffi): rename SyncError::Locked to VaultLocked Co-Authored-By: Claude Opus 5.5 --- rust/crates/keygo-uniffi/src/sync.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/rust/crates/keygo-uniffi/src/sync.rs b/rust/crates/keygo-uniffi/src/sync.rs index ff2eb78c4..aabd6fc40 100644 --- a/rust/crates/keygo-uniffi/src/sync.rs +++ b/rust/crates/keygo-uniffi/src/sync.rs @@ -36,7 +36,7 @@ pub enum SyncError { #[error("rate limited")] RateLimited, #[error("vault locked")] - Locked, + VaultLocked, #[error("network error: {reason}")] Network { reason: String }, #[error("server error {code}: {reason}")] @@ -60,7 +60,7 @@ impl From for SyncError { reason: reason.map(|r| r.as_str().to_owned()), }, CoreSyncError::RateLimited => Self::RateLimited, - CoreSyncError::VaultLocked => Self::Locked, + CoreSyncError::VaultLocked => Self::VaultLocked, CoreSyncError::Network { message } => Self::Network { reason: message }, CoreSyncError::Server { code, message } => Self::Server { code, From b9743dc2f6085484644ddace3f83d5c261c9df09 Mon Sep 17 00:00:00 2001 From: Davis Date: Fri, 13 Nov 2026 13:08:05 +0100 Subject: [PATCH 39/52] feat(client): report an account mismatch as its own error Co-Authored-By: Claude Opus 5.5 --- rust/crates/keygo-client/src/sync/client.rs | 16 ++++++++++++++-- rust/crates/keygo-client/src/sync/error.rs | 3 +++ rust/crates/keygo-uniffi/src/sync.rs | 4 ++++ 3 files changed, 21 insertions(+), 2 deletions(-) diff --git a/rust/crates/keygo-client/src/sync/client.rs b/rust/crates/keygo-client/src/sync/client.rs index d043c87a4..ef945a8a7 100644 --- a/rust/crates/keygo-client/src/sync/client.rs +++ b/rust/crates/keygo-client/src/sync/client.rs @@ -12,7 +12,7 @@ use keygo_api::endpoints::{ RegisterStart, StepUpFinish, StepUpStart, }; use keygo_api::meta::ServerInfo; -use keygo_core::{DeviceId, UserId}; +use keygo_core::{CryptoError, DeviceId, UserId}; use keygo_dpop::DpopProver; use keygo_opaque::OpaqueError; use keygo_opaque::client::{ClientLogin, ClientRegistration}; @@ -244,7 +244,7 @@ impl SyncClient { if let Err(error) = unlocked { let _ = self.logout().await; - return Err(client_failure(error)); + return Err(unlock_failure(error)); } Ok(account) @@ -269,6 +269,18 @@ fn client_failure(error: impl std::fmt::Display) -> SyncError { } } +/// The server's copy of the ARK not opening is the server's fault: OPAQUE already proved the +/// password, and the export key follows from it. +fn unlock_failure(error: ArkSessionError) -> SyncError { + match error { + ArkSessionError::AccountMismatch => SyncError::AccountMismatch, + ArkSessionError::KeyWrap( + error @ (CryptoError::KeyUnwrapFailed | CryptoError::DecryptionFailed), + ) => SyncError::invalid_response(format!("the server's key bundle: {error}")), + other => client_failure(other), + } +} + fn opaque_failure(error: OpaqueError) -> SyncError { match error { OpaqueError::InvalidLogin | OpaqueError::EmptyPassword => SyncError::InvalidCredentials, diff --git a/rust/crates/keygo-client/src/sync/error.rs b/rust/crates/keygo-client/src/sync/error.rs index f8969e046..ddc1fcdac 100644 --- a/rust/crates/keygo-client/src/sync/error.rs +++ b/rust/crates/keygo-client/src/sync/error.rs @@ -23,6 +23,9 @@ pub enum SyncError { RateLimited, #[error("vault locked")] VaultLocked, + /// The account signed in to holds a different ARK than the unlocked local vault. + #[error("account mismatch")] + AccountMismatch, #[error("network error: {message}")] Network { message: String }, #[error("server error {code}: {message}")] diff --git a/rust/crates/keygo-uniffi/src/sync.rs b/rust/crates/keygo-uniffi/src/sync.rs index aabd6fc40..d417d7044 100644 --- a/rust/crates/keygo-uniffi/src/sync.rs +++ b/rust/crates/keygo-uniffi/src/sync.rs @@ -37,6 +37,9 @@ pub enum SyncError { RateLimited, #[error("vault locked")] VaultLocked, + /// The account signed in to holds a different ARK than the unlocked local vault. + #[error("account mismatch")] + AccountMismatch, #[error("network error: {reason}")] Network { reason: String }, #[error("server error {code}: {reason}")] @@ -61,6 +64,7 @@ impl From for SyncError { }, CoreSyncError::RateLimited => Self::RateLimited, CoreSyncError::VaultLocked => Self::VaultLocked, + CoreSyncError::AccountMismatch => Self::AccountMismatch, CoreSyncError::Network { message } => Self::Network { reason: message }, CoreSyncError::Server { code, message } => Self::Server { code, From 865f802f8a81e5a8d103f7d398a49b16e68b4e91 Mon Sep 17 00:00:00 2001 From: Davis Date: Fri, 13 Nov 2026 13:08:38 +0100 Subject: [PATCH 40/52] fix(client): keep the session when registration fails Co-Authored-By: Claude Opus 5.5 --- rust/crates/keygo-client/src/sync/client.rs | 112 ++++++++++++++++++-- 1 file changed, 103 insertions(+), 9 deletions(-) diff --git a/rust/crates/keygo-client/src/sync/client.rs b/rust/crates/keygo-client/src/sync/client.rs index ef945a8a7..ced09a7ba 100644 --- a/rust/crates/keygo-client/src/sync/client.rs +++ b/rust/crates/keygo-client/src/sync/client.rs @@ -5,7 +5,7 @@ use super::state::{AuthState, Clock, SystemClock}; use super::tokens::TokenStore; use super::transport::Transport; use crate::ark_session::{ArkSession, ArkSessionError}; -use keygo_api::auth::{login, register, step_up}; +use keygo_api::auth::{Session, login, register, step_up}; use keygo_api::domain::{Device, DeviceClaim, DeviceInfo, KeyBundle, Username}; use keygo_api::endpoints::{ DeleteDevice, ListDevices, LoginFinish, LoginStart, Logout, Meta, RegisterFinish, @@ -121,8 +121,15 @@ impl SyncClient { Ok(()) } + /// Creates an account whose server copy of the ARK is the one `ark` holds, and signs in. + /// + /// `user_id` must be the local account's id: the server-wrapped ARK is bound to it, and the + /// server stores it as the account's id. `ark` cannot check this, since it holds no user id. + /// Any session this client held is logged out once the new one exists; a failed registration + /// leaves it as it was. pub async fn register( &self, + ark: &ArkSession, user_id: UserId, username: String, @@ -136,12 +143,6 @@ impl SyncClient { let (client, registration_request) = ClientRegistration::start(password.as_bytes()).map_err(opaque_failure)?; - // A previous account's refresh token must not stay valid on the server. - match self.logout().await { - Ok(()) | Err(SyncError::SignedOut { .. }) => {} - Err(error) => return Err(error), - } - let started = self .call( &RegisterStart, @@ -184,7 +185,7 @@ impl SyncClient { username: response.username, device_id: response.session.device_id, }; - self.adopt_session(response.session, sent_at).await; + self.replace_session(response.session, sent_at, None).await; Ok(account) } @@ -250,6 +251,17 @@ impl SyncClient { Ok(account) } + /// Adopts `session` in place of the one this client held. If the server reattached `claimed`, + /// it already ended that device's old session. Otherwise the old one is logged out first, so + /// its refresh token does not stay valid. That logout is best effort: the new session is live + /// on the server either way, and dropping it would only leave a second token nobody holds. + async fn replace_session(&self, session: Session, sent_at: u64, claimed: Option) { + if claimed != Some(session.device_id) { + let _ = self.logout().await; + } + self.adopt_session(session, sent_at).await; + } + /// Always ends the session locally. Returns the server's result, unless the server was not told /// and the store could not be cleared: a token the server may still accept is then left on disk. pub async fn logout(&self) -> SyncResult<()> { @@ -292,6 +304,9 @@ fn opaque_failure(error: OpaqueError) -> SyncError { mod tests { use super::super::error::SyncError; use super::super::testing::{error_body, fake_client, header}; + use super::super::tokens::StoredSession; + use super::super::transport::HttpRequest; + use serde_json::json; const INFO: &str = r#"{"version":"1","public_url":"https://kg.example","allow_signups":true}"#; @@ -390,9 +405,10 @@ mod tests { } mod register { - use super::super::super::testing::{FakeSigner, client_with_store, header}; + use super::super::super::testing::{FakeSigner, client_with_store, error_body, header}; use super::super::super::transport::HttpRequest; use super::super::SyncError; + use super::{OLD_REFRESH, old_session_reply, paths, previous_session}; use crate::ark_session::ArkSession; use base64::Engine; use base64::engine::general_purpose::URL_SAFE_NO_PAD; @@ -551,6 +567,84 @@ mod tests { ); assert_eq!(transport.requests().len(), 1, "finish is never sent"); } + + #[tokio::test] + async fn failed_register_keeps_the_previous_session() { + let (client, transport, store) = + client_with_store("https://kg.example", Arc::new(FakeSigner::new())); + store.seed(previous_session()); + transport.push(409, &[], &error_body("username_taken")); + let (ark, user_id) = unlocked(); + + let error = client + .register(&ark, user_id, "ada".into(), "pw", None, device()) + .await + .unwrap_err(); + + assert_eq!(error, SyncError::UsernameTaken); + assert_eq!(store.current_refresh_token().as_deref(), Some(OLD_REFRESH)); + assert_eq!(transport.requests().len(), 1, "no logout"); + } + + #[tokio::test] + async fn previous_session_is_logged_out_once_registered() { + let (client, transport, store) = + client_with_store("https://kg.example", Arc::new(FakeSigner::new())); + store.seed(previous_session()); + transport.push_with(200, start_reply); + transport.push(200, &[], &finish_reply()); + transport.push(200, &[], &old_session_reply()); + transport.push(204, &[], b""); + let (ark, user_id) = unlocked(); + + client + .register(&ark, user_id, "ada".into(), "pw", None, device()) + .await + .unwrap(); + + let paths = paths(&transport.requests()); + assert_eq!( + paths, + [ + "/api/v1/auth/register/start", + "/api/v1/auth/register/finish", + "/api/v1/auth/token", + "/api/v1/auth/logout", + ], + ); + assert_eq!(store.current_refresh_token().as_deref(), Some(REFRESH)); + } + } + + pub(super) const OLD_REFRESH: &str = "kgr___________________________________________8"; + const OLD_DEVICE: &str = "00000000-0000-0000-0000-00000000000d"; + + /// A session of whatever account this client was signed in to before. + pub(super) fn previous_session() -> StoredSession { + StoredSession { + device_id: serde_json::from_value(json!(OLD_DEVICE)).unwrap(), + refresh_token: OLD_REFRESH.parse().unwrap(), + refresh_expires_at: u64::MAX / 2, + } + } + + /// What the token endpoint answers when the previous session refreshes to log out. + pub(super) fn old_session_reply() -> Vec { + serde_json::to_vec(&json!({ + "device_id": OLD_DEVICE, + "access_token": "old.access.token", + "access_expires_in": 600, + "refresh_token": "kgr_AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE", + "refresh_expires_in": 86400, + })) + .unwrap() + } + + pub(super) fn paths(requests: &[HttpRequest]) -> Vec { + requests + .iter() + .map(|r| r.url.trim_start_matches("https://kg.example").to_owned()) + .collect() } #[tokio::test] From 7716b749f8097bbc3c01e92dbe41cdc275bebab5 Mon Sep 17 00:00:00 2001 From: Davis Date: Fri, 13 Nov 2026 13:09:02 +0100 Subject: [PATCH 41/52] fix(client): keep the previous session when login fails Co-Authored-By: Claude Opus 5.5 --- rust/crates/keygo-client/src/sync/client.rs | 43 +++++++++++++++------ 1 file changed, 32 insertions(+), 11 deletions(-) diff --git a/rust/crates/keygo-client/src/sync/client.rs b/rust/crates/keygo-client/src/sync/client.rs index ced09a7ba..4204c4d55 100644 --- a/rust/crates/keygo-client/src/sync/client.rs +++ b/rust/crates/keygo-client/src/sync/client.rs @@ -5,6 +5,7 @@ use super::state::{AuthState, Clock, SystemClock}; use super::tokens::TokenStore; use super::transport::Transport; use crate::ark_session::{ArkSession, ArkSessionError}; +use keygo_api::Endpoint; use keygo_api::auth::{Session, login, register, step_up}; use keygo_api::domain::{Device, DeviceClaim, DeviceInfo, KeyBundle, Username}; use keygo_api::endpoints::{ @@ -189,6 +190,12 @@ impl SyncClient { Ok(account) } + /// Signs in to an existing account. + /// + /// The server's copy of the ARK must open with the export key. If `ark` is locked, a successful + /// login unlocks it with that copy. If it is unlocked, it must already hold the same ARK; + /// otherwise the login fails with [`SyncError::AccountMismatch`] and the session the server + /// just issued is ended again. A failed login leaves any session this client held as it was. pub async fn login( &self, ark: &ArkSession, @@ -228,26 +235,22 @@ impl SyncClient { ) .await?; - let account = Account { - user_id: response.user_id, - username: response.username, - device_id: response.session.device_id, - }; - - // We dont catch the error early, because the server already created the session and the - // device. To revoke that session from the server, we adopt the session so logout is available. let unlocked = ark.unlock_with_server( &finish.export_key, &response.key_bundle.into_wrapped_ark(), response.user_id, ); - self.adopt_session(response.session, sent_at).await; - if let Err(error) = unlocked { - let _ = self.logout().await; + self.discard(&response.session, None).await; return Err(unlock_failure(error)); } + let account = Account { + user_id: response.user_id, + username: response.username, + device_id: response.session.device_id, + }; + self.adopt_session(response.session, sent_at).await; Ok(account) } @@ -262,6 +265,24 @@ impl SyncClient { self.adopt_session(session, sent_at).await; } + /// Ends a session the server issued but this client will not keep, with its own access token, + /// so the session this client holds is untouched. A device made for this login alone is + /// deleted, which ends its session too; a reattached one stays and is only logged out. + /// Best effort: if this fails, the session expires unused. + async fn discard(&self, session: &Session, claimed: Option) { + let token = Some(session.access.access_token.expose()); + let _ = if claimed == Some(session.device_id) { + self.send_singed(Logout::METHOD, &Logout.path(), token, None) + .await + } else { + let endpoint = DeleteDevice { + id: session.device_id, + }; + self.send_singed(DeleteDevice::METHOD, &endpoint.path(), token, None) + .await + }; + } + /// Always ends the session locally. Returns the server's result, unless the server was not told /// and the store could not be cleared: a token the server may still accept is then left on disk. pub async fn logout(&self) -> SyncResult<()> { From 061bd3cad0d58e2e89162df8ce65bfdf30594d93 Mon Sep 17 00:00:00 2001 From: Davis Date: Fri, 13 Nov 2026 13:09:27 +0100 Subject: [PATCH 42/52] fix(client): reclaim the device on login and end the old session Co-Authored-By: Claude Opus 5.5 --- rust/crates/keygo-client/src/sync/client.rs | 22 +++++++++++++++++---- 1 file changed, 18 insertions(+), 4 deletions(-) diff --git a/rust/crates/keygo-client/src/sync/client.rs b/rust/crates/keygo-client/src/sync/client.rs index 4204c4d55..db7b0d3fb 100644 --- a/rust/crates/keygo-client/src/sync/client.rs +++ b/rust/crates/keygo-client/src/sync/client.rs @@ -130,7 +130,6 @@ impl SyncClient { /// leaves it as it was. pub async fn register( &self, - ark: &ArkSession, user_id: UserId, username: String, @@ -196,6 +195,9 @@ impl SyncClient { /// login unlocks it with that copy. If it is unlocked, it must already hold the same ARK; /// otherwise the login fails with [`SyncError::AccountMismatch`] and the session the server /// just issued is ended again. A failed login leaves any session this client held as it was. + /// + /// The device this client was last signed in as is claimed again, so a re-login on the same + /// device replaces its session instead of adding a device. pub async fn login( &self, ark: &ArkSession, @@ -205,6 +207,7 @@ impl SyncClient { ) -> SyncResult { let (client, credential_request) = ClientLogin::start(password.as_bytes()).map_err(opaque_failure)?; + let claimed = self.current_device().await; let started = self .call( &LoginStart, @@ -227,7 +230,7 @@ impl SyncClient { login_id: started.login_id, credential_finalization: finish.finalization, device: DeviceClaim { - id: None, + id: claimed, info: device, }, dpop_binding, @@ -241,7 +244,7 @@ impl SyncClient { response.user_id, ); if let Err(error) = unlocked { - self.discard(&response.session, None).await; + self.discard(&response.session, claimed).await; return Err(unlock_failure(error)); } @@ -250,10 +253,21 @@ impl SyncClient { username: response.username, device_id: response.session.device_id, }; - self.adopt_session(response.session, sent_at).await; + self.replace_session(response.session, sent_at, claimed) + .await; Ok(account) } + /// The device of the session this client holds, if it can tell. + async fn current_device(&self) -> Option { + let state = self.auth.lock().await; + if let Some(unsaved) = &state.unsaved { + return Some(unsaved.device_id); + } + // A store that cannot be read only costs the reattach: the server then makes a new device. + self.tokens.load().await.ok().flatten().map(|s| s.device_id) + } + /// Adopts `session` in place of the one this client held. If the server reattached `claimed`, /// it already ended that device's old session. Otherwise the old one is logged out first, so /// its refresh token does not stay valid. That logout is best effort: the new session is live From 6d513bb32114ce106c8b1c650d8f8698f49f8cdb Mon Sep 17 00:00:00 2001 From: Davis Date: Fri, 13 Nov 2026 13:09:34 +0100 Subject: [PATCH 43/52] docs(uniffi): document register and login Co-Authored-By: Claude Opus 5.5 --- rust/crates/keygo-uniffi/src/sync.rs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/rust/crates/keygo-uniffi/src/sync.rs b/rust/crates/keygo-uniffi/src/sync.rs index d417d7044..aeb851bc0 100644 --- a/rust/crates/keygo-uniffi/src/sync.rs +++ b/rust/crates/keygo-uniffi/src/sync.rs @@ -370,6 +370,7 @@ impl SyncClient { detached(async move { self.inner.meta().await }).await } + /// `user_id` must be the local account's id; see the core `SyncClient::register`. pub async fn register( self: Arc, ark: Arc, @@ -390,6 +391,8 @@ impl SyncClient { Ok(account.into()) } + /// Unlocks a locked `ark` with the server's copy of the ARK; an unlocked one must hold the + /// same ARK, or this fails with `AccountMismatch`. See the core `SyncClient::login`. pub async fn login( self: Arc, ark: Arc, From b916a8d8171c0dd0746302ed77a9bb3e455d4ec5 Mon Sep 17 00:00:00 2001 From: Davis Date: Fri, 13 Nov 2026 13:09:34 +0100 Subject: [PATCH 44/52] test: cover sync login and the server-wrapped ARK Co-Authored-By: Claude Opus 5.5 --- rust/crates/keygo-client/src/ark_session.rs | 69 ++++ rust/crates/keygo-client/src/sync/client.rs | 348 +++++++++++++++++++ rust/crates/keygo-client/src/sync/testing.rs | 43 +++ rust/crates/keygo-e2e/tests/sync.rs | 113 +++++- 4 files changed, 572 insertions(+), 1 deletion(-) diff --git a/rust/crates/keygo-client/src/ark_session.rs b/rust/crates/keygo-client/src/ark_session.rs index a7bcc9332..5c579baee 100644 --- a/rust/crates/keygo-client/src/ark_session.rs +++ b/rust/crates/keygo-client/src/ark_session.rs @@ -258,6 +258,75 @@ mod tests { (session, new_account) } + fn export_key() -> ExportKey { + crate::sync::testing::FakeOpaqueAccount::register(PASSWORD).1 + } + + #[test] + fn server_wrapped_ark_unlocks_a_locked_session() { + let (session, account) = unlocked(); + let key = export_key(); + let wrapped = session.wrap_for_server(&key, account.user_id).unwrap(); + let ark = session.export_ark().unwrap(); + session.end(); + + session + .unlock_with_server(&key, &wrapped, account.user_id) + .unwrap(); + + assert_eq!(session.export_ark().unwrap(), ark); + } + + #[test] + fn server_wrapped_ark_matching_the_live_one_is_accepted() { + let (session, account) = unlocked(); + let key = export_key(); + let wrapped = session.wrap_for_server(&key, account.user_id).unwrap(); + + session + .unlock_with_server(&key, &wrapped, account.user_id) + .unwrap(); + } + + #[test] + fn server_wrapped_ark_of_another_account_is_a_mismatch() { + let (session, account) = unlocked(); + let ark = session.export_ark().unwrap(); + let (other, _) = unlocked(); + let key = export_key(); + let wrapped = other.wrap_for_server(&key, account.user_id).unwrap(); + + let result = session.unlock_with_server(&key, &wrapped, account.user_id); + + assert!(matches!(result, Err(ArkSessionError::AccountMismatch))); + assert_eq!(session.export_ark().unwrap(), ark, "the live ARK stays"); + } + + #[test] + fn server_wrapped_ark_is_bound_to_its_user() { + let (session, account) = unlocked(); + let key = export_key(); + let wrapped = session.wrap_for_server(&key, account.user_id).unwrap(); + session.end(); + + let result = session.unlock_with_server(&key, &wrapped, UserId::random()); + + assert!(matches!( + result, + Err(ArkSessionError::KeyWrap(CryptoError::KeyUnwrapFailed)), + )); + assert!(!session.is_active()); + } + + #[test] + fn wrap_for_server_needs_a_live_ark() { + let session = ArkSession::new(); + + let result = session.wrap_for_server(&export_key(), UserId::random()); + + assert!(matches!(result, Err(ArkSessionError::Locked))); + } + #[test] fn create_account_leaves_session_unlocked() { let (session, _) = unlocked(); diff --git a/rust/crates/keygo-client/src/sync/client.rs b/rust/crates/keygo-client/src/sync/client.rs index db7b0d3fb..9b5e0e20a 100644 --- a/rust/crates/keygo-client/src/sync/client.rs +++ b/rust/crates/keygo-client/src/sync/client.rs @@ -682,6 +682,354 @@ mod tests { .collect() } + mod login { + use super::super::super::testing::{ + FakeOpaqueAccount, FakeSigner, FakeTokenStore, FakeTransport, client_with_store, header, + }; + use super::super::super::transport::HttpRequest; + use super::super::{SyncClient, SyncError}; + use super::{OLD_DEVICE, OLD_REFRESH, old_session_reply, paths, previous_session}; + use crate::ark_session::ArkSession; + use keygo_api::Method; + use keygo_api::domain::DeviceInfo; + use keygo_core::UserId; + use keygo_opaque::{CredentialRequest, ExportKey}; + use serde_json::{Value, json}; + use std::sync::Arc; + + const PASSWORD: &str = "pw"; + const LOGIN_ID: &str = "CQkJCQkJCQkJCQkJCQkJCQ"; + const REFRESH: &str = "kgr_AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"; + const ACCESS: &str = "new.access.token"; + const NEW_DEVICE: &str = "00000000-0000-0000-0000-00000000000e"; + + /// A server account whose key bundle wraps the ARK `ark` holds. + struct Server { + opaque: FakeOpaqueAccount, + user_id: UserId, + wrapped_ark: Value, + } + + impl Server { + fn holding(ark: &ArkSession) -> Self { + let (opaque, export_key) = FakeOpaqueAccount::register(PASSWORD); + Self::with_key(opaque, &export_key, ark) + } + + fn with_key( + opaque: FakeOpaqueAccount, + export_key: &ExportKey, + ark: &ArkSession, + ) -> Self { + let user_id = UserId::random(); + let wrapped: keygo_api::domain::SealedBlob = + ark.wrap_for_server(export_key, user_id).unwrap().into(); + Self { + opaque, + user_id, + wrapped_ark: serde_json::to_value(wrapped).unwrap(), + } + } + + fn answer_start(&self, transport: &FakeTransport) { + let opaque = self.opaque.clone(); + transport.push_with(200, move |request| { + start_body(opaque.credential_response(credential_request(request))) + }); + } + + fn answer_finish(&self, transport: &FakeTransport, device_id: &str) { + let body = json!({ + "user_id": self.user_id, + "username": "ada", + "key_bundle": { "wrapped_ark": self.wrapped_ark }, + "session": { + "device_id": device_id, + "access_token": ACCESS, + "access_expires_in": 600, + "refresh_token": REFRESH, + "refresh_expires_in": 86400, + }, + }); + transport.push(200, &[], &serde_json::to_vec(&body).unwrap()); + } + } + + fn credential_request(request: &HttpRequest) -> CredentialRequest { + let body: Value = serde_json::from_slice(&request.body).unwrap(); + serde_json::from_value(body["credential_request"].clone()).unwrap() + } + + fn start_body(response: keygo_opaque::CredentialResponse) -> Vec { + serde_json::to_vec(&json!({ + "login_id": LOGIN_ID, + "credential_response": response, + "expires_in": 60, + })) + .unwrap() + } + + fn unlocked() -> ArkSession { + let ark = ArkSession::new(); + ark.create_account("local password").unwrap(); + ark + } + + fn device() -> DeviceInfo { + serde_json::from_value(json!({ + "name": "Pixel 9", + "platform": "android", + "app_version": "2.3.0", + })) + .unwrap() + } + + fn client() -> (SyncClient, Arc, Arc) { + client_with_store("https://kg.example", Arc::new(FakeSigner::new())) + } + + fn claimed_device(request: &HttpRequest) -> Value { + let body: Value = serde_json::from_slice(&request.body).unwrap(); + body["device"]["device_id"].clone() + } + + #[tokio::test] + async fn signs_in_and_keeps_the_session() { + let (client, transport, store) = client(); + let ark = unlocked(); + let server = Server::holding(&ark); + server.answer_start(&transport); + server.answer_finish(&transport, NEW_DEVICE); + + let account = client + .login(&ark, "Ada".into(), PASSWORD, device()) + .await + .unwrap(); + + assert_eq!(account.user_id, server.user_id); + assert_eq!(account.device_id.as_uuid().to_string(), NEW_DEVICE); + assert_eq!(store.current_refresh_token().as_deref(), Some(REFRESH)); + + let requests = transport.requests(); + assert_eq!(requests.len(), 2, "a signed-out client sends no logout"); + assert_eq!(header(&requests[0], "dpop"), None); + assert!(header(&requests[1], "dpop").is_some()); + assert_eq!(claimed_device(&requests[1]), Value::Null); + } + + #[tokio::test] + async fn unlocks_a_locked_session_with_the_server_copy() { + let (client, transport, _) = client(); + let ark = unlocked(); + let server = Server::holding(&ark); + let local = ark.export_ark().unwrap(); + ark.end(); + server.answer_start(&transport); + server.answer_finish(&transport, NEW_DEVICE); + + client + .login(&ark, "ada".into(), PASSWORD, device()) + .await + .unwrap(); + + assert_eq!(ark.export_ark().unwrap(), local); + } + + #[tokio::test] + async fn wrong_password_sends_no_finish() { + let (client, transport, store) = client(); + store.seed(previous_session()); + let ark = unlocked(); + Server::holding(&ark).answer_start(&transport); + + let error = client + .login(&ark, "ada".into(), "wrong", device()) + .await + .unwrap_err(); + + assert_eq!(error, SyncError::InvalidCredentials); + assert_eq!(transport.requests().len(), 1); + assert_eq!(store.current_refresh_token().as_deref(), Some(OLD_REFRESH)); + } + + #[tokio::test] + async fn unknown_username_fails_like_a_wrong_password() { + let (client, transport, _) = client(); + transport.push_with(200, |request| { + start_body(FakeOpaqueAccount::unknown_user_response( + credential_request(request), + )) + }); + + let error = client + .login(&unlocked(), "nobody".into(), PASSWORD, device()) + .await + .unwrap_err(); + + assert_eq!(error, SyncError::InvalidCredentials); + assert_eq!(transport.requests().len(), 1); + } + + #[tokio::test] + async fn empty_password_sends_nothing() { + let (client, transport, _) = client(); + + let error = client + .login(&unlocked(), "ada".into(), "", device()) + .await + .unwrap_err(); + + assert_eq!(error, SyncError::InvalidCredentials); + assert!(transport.requests().is_empty()); + } + + /// The server reattached the device and ended its old session, so there is nothing to + /// log out. + #[tokio::test] + async fn reclaims_the_device_it_was_signed_in_as() { + let (client, transport, store) = client(); + store.seed(previous_session()); + let ark = unlocked(); + let server = Server::holding(&ark); + server.answer_start(&transport); + server.answer_finish(&transport, OLD_DEVICE); + + client + .login(&ark, "ada".into(), PASSWORD, device()) + .await + .unwrap(); + + let requests = transport.requests(); + assert_eq!(requests.len(), 2); + assert_eq!(claimed_device(&requests[1]), OLD_DEVICE); + assert_eq!(store.current_refresh_token().as_deref(), Some(REFRESH)); + } + + /// The claim went to another account's device, so the server made a new one and the old + /// session would otherwise stay valid. + #[tokio::test] + async fn logs_the_previous_session_out_on_a_new_device() { + let (client, transport, store) = client(); + store.seed(previous_session()); + let ark = unlocked(); + let server = Server::holding(&ark); + server.answer_start(&transport); + server.answer_finish(&transport, NEW_DEVICE); + transport.push(200, &[], &old_session_reply()); + transport.push(204, &[], b""); + + client + .login(&ark, "ada".into(), PASSWORD, device()) + .await + .unwrap(); + + let requests = transport.requests(); + assert_eq!( + paths(&requests), + [ + "/api/v1/auth/login/start", + "/api/v1/auth/login/finish", + "/api/v1/auth/token", + "/api/v1/auth/logout", + ], + ); + assert_eq!( + header(&requests[3], "authorization"), + Some("DPoP old.access.token"), + ); + assert_eq!(store.current_refresh_token().as_deref(), Some(REFRESH)); + } + + #[tokio::test] + async fn mismatch_keeps_the_previous_session_and_deletes_the_new_device() { + let (client, transport, store) = client(); + store.seed(previous_session()); + let ark = unlocked(); + let local = ark.export_ark().unwrap(); + let server = Server::holding(&unlocked()); + server.answer_start(&transport); + server.answer_finish(&transport, NEW_DEVICE); + transport.push(204, &[], b""); + + let error = client + .login(&ark, "ada".into(), PASSWORD, device()) + .await + .unwrap_err(); + + assert_eq!(error, SyncError::AccountMismatch); + assert_eq!(store.current_refresh_token().as_deref(), Some(OLD_REFRESH)); + assert_eq!(ark.export_ark().unwrap(), local); + + let requests = transport.requests(); + assert_eq!(requests.len(), 3); + assert_eq!(requests[2].method, Method::Delete); + assert_eq!( + requests[2].url, + format!("https://kg.example/api/v1/devices/{NEW_DEVICE}"), + ); + assert_eq!( + header(&requests[2], "authorization"), + Some(format!("DPoP {ACCESS}").as_str()), + ); + } + + /// A reattached device was this client's before the login, so it stays; only the session + /// the login made is ended. + #[tokio::test] + async fn mismatch_on_a_reattached_device_only_logs_out() { + let (client, transport, _) = client(); + client_seed(&client).await; + let server = Server::holding(&unlocked()); + server.answer_start(&transport); + server.answer_finish(&transport, OLD_DEVICE); + transport.push(204, &[], b""); + + let error = client + .login(&unlocked(), "ada".into(), PASSWORD, device()) + .await + .unwrap_err(); + + assert_eq!(error, SyncError::AccountMismatch); + let requests = transport.requests(); + assert_eq!(requests.len(), 3); + assert_eq!(requests[2].url, "https://kg.example/api/v1/auth/logout",); + assert_eq!( + header(&requests[2], "authorization"), + Some(format!("DPoP {ACCESS}").as_str()), + ); + } + + /// OPAQUE proved the password, so a bundle that does not open is the server's fault. + #[tokio::test] + async fn bundle_that_does_not_open_is_an_invalid_response() { + let (client, transport, _) = client(); + let ark = unlocked(); + let (opaque, _) = FakeOpaqueAccount::register(PASSWORD); + let (_, other_key) = FakeOpaqueAccount::register(PASSWORD); + let server = Server::with_key(opaque, &other_key, &ark); + ark.end(); + server.answer_start(&transport); + server.answer_finish(&transport, NEW_DEVICE); + transport.push(204, &[], b""); + + let error = client + .login(&ark, "ada".into(), PASSWORD, device()) + .await + .unwrap_err(); + + assert!( + matches!(&error, SyncError::Server { code, .. } if code == "invalid_response"), + "{error:?}", + ); + assert!(!ark.is_active()); + assert_eq!(transport.requests().len(), 3, "the new device is deleted"); + } + + async fn client_seed(client: &SyncClient) { + client.tokens.save(&previous_session()).await.unwrap(); + } + } + #[tokio::test] async fn transport_failure_is_network() { let (client, transport) = fake_client(); diff --git a/rust/crates/keygo-client/src/sync/testing.rs b/rust/crates/keygo-client/src/sync/testing.rs index fa2597f55..afbfaa588 100644 --- a/rust/crates/keygo-client/src/sync/testing.rs +++ b/rust/crates/keygo-client/src/sync/testing.rs @@ -6,6 +6,9 @@ use super::transport::{Header, HttpRequest, HttpResponse, Transport, TransportEr use async_trait::async_trait; use keygo_dpop::testing::TestSigner; use keygo_dpop::{DpopSigner, Signature, VerifyingKey}; +use keygo_opaque::client::ClientRegistration; +use keygo_opaque::server::{self, ServerLogin, ServerSetup}; +use keygo_opaque::{CredentialRequest, CredentialResponse, ExportKey, PasswordFile}; use std::collections::VecDeque; use std::sync::atomic::{AtomicBool, AtomicU64, Ordering}; use std::sync::{Arc, Mutex}; @@ -255,3 +258,43 @@ impl Clock for FixedClock { self.0.load(Ordering::SeqCst) } } + +/// One account on a real OPAQUE server, so a test can answer `login/start` with a response the +/// client really finishes. +#[derive(Clone)] +pub struct FakeOpaqueAccount { + setup: ServerSetup, + password_file: Arc>>, +} + +impl FakeOpaqueAccount { + /// Registers `password` and returns the export key the client derives from it. + pub fn register(password: &str) -> (Self, ExportKey) { + let setup = ServerSetup::generate(); + let (client, request) = ClientRegistration::start(password.as_bytes()).unwrap(); + let response = server::registration_start(&setup, request, CREDENTIAL_ID).unwrap(); + let finish = client.finish(password.as_bytes(), response).unwrap(); + let password_file = server::registration_finish(finish.upload).to_bytes(); + let account = Self { + setup, + password_file: Arc::new(password_file), + }; + (account, finish.export_key) + } + + pub fn credential_response(&self, request: CredentialRequest) -> CredentialResponse { + let file = PasswordFile::from_bytes(&self.password_file).unwrap(); + ServerLogin::start(&self.setup, Some(file), request, CREDENTIAL_ID) + .unwrap() + .1 + } + + /// What the server answers for a username it does not know. + pub fn unknown_user_response(request: CredentialRequest) -> CredentialResponse { + ServerLogin::start(&ServerSetup::generate(), None, request, CREDENTIAL_ID) + .unwrap() + .1 + } +} + +const CREDENTIAL_ID: &[u8] = b"u"; diff --git a/rust/crates/keygo-e2e/tests/sync.rs b/rust/crates/keygo-e2e/tests/sync.rs index b3998e785..44e45c82b 100644 --- a/rust/crates/keygo-e2e/tests/sync.rs +++ b/rust/crates/keygo-e2e/tests/sync.rs @@ -115,6 +115,12 @@ async fn harness(db: &PgPool) -> Harness { /// A client with nothing stored, against a server with no session for it. fn signed_out(db: &PgPool) -> (SyncClient, Arc, AppState) { let state = testing::app_state(db, &ServerSetup::generate()); + let (client, store) = client_of(&state); + (client, store, state) +} + +/// Another install with nothing stored, against the same server. +fn client_of(state: &AppState) -> (SyncClient, Arc) { let store = Arc::new(FakeTokenStore::new()); let client = SyncClient::new( Url::parse(testing::ISS).unwrap(), @@ -123,7 +129,15 @@ fn signed_out(db: &PgPool) -> (SyncClient, Arc, AppState) { store.clone(), ) .unwrap(); - (client, store, state) + (client, store) +} + +async fn device_count(db: &PgPool, user_id: UserId) -> i64 { + sqlx::query_scalar("select count(*) from devices where user_id = $1") + .bind(user_id.as_uuid()) + .fetch_one(db) + .await + .unwrap() } fn local_account() -> (ArkSession, UserId) { @@ -365,3 +379,100 @@ async fn refused_save_does_not_trip_reuse_detection(db: PgPool) { assert_eq!(h.store.current_refresh_token().unwrap(), h.seed_token); } + +#[sqlx::test(migrations = "../keygo-server/migrations")] +async fn login_on_a_fresh_install_unlocks_the_vault(db: PgPool) { + let (client, _, state) = signed_out(&db); + let (ark, user_id) = local_account(); + register(&client, &ark, user_id, "ada").await; + + let (fresh, store) = client_of(&state); + let locked = ArkSession::new(); + let account = fresh + .login(&locked, "ada".into(), password(), testing::device_info()) + .await + .unwrap(); + + assert_eq!(account.user_id, user_id); + assert_eq!(locked.export_ark().unwrap(), ark.export_ark().unwrap()); + assert!(store.current_refresh_token().is_some()); + assert_eq!(fresh.devices().await.unwrap().len(), 2); +} + +#[sqlx::test(migrations = "../keygo-server/migrations")] +async fn logging_in_again_reuses_the_device(db: PgPool) { + let (client, _, _) = signed_out(&db); + let (ark, user_id) = local_account(); + register(&client, &ark, user_id, "ada").await; + let registered = client.devices().await.unwrap()[0].id; + + let account = client + .login(&ark, "ada".into(), password(), testing::device_info()) + .await + .unwrap(); + + assert_eq!(account.device_id, registered); + assert_eq!(device_count(&db, user_id).await, 1); + client.devices().await.unwrap(); +} + +#[sqlx::test(migrations = "../keygo-server/migrations")] +async fn login_into_another_vault_leaves_nothing_behind(db: PgPool) { + let (client, _, state) = signed_out(&db); + let (ark, user_id) = local_account(); + register(&client, &ark, user_id, "ada").await; + + let (other, store) = client_of(&state); + let (other_ark, _) = local_account(); + let error = other + .login(&other_ark, "ada".into(), password(), testing::device_info()) + .await + .unwrap_err(); + + assert_eq!(error, SyncError::AccountMismatch); + assert_eq!(store.current_refresh_token(), None); + assert_eq!( + device_count(&db, user_id).await, + 1, + "the new device is deleted" + ); +} + +#[sqlx::test(migrations = "../keygo-server/migrations")] +async fn failed_login_keeps_the_previous_session(db: PgPool) { + let h = harness(&db).await; + h.client.devices().await.unwrap(); + let before = h.store.current_refresh_token().unwrap(); + + let error = h + .client + .login( + &ArkSession::new(), + "ada".into(), + "wrong", + testing::device_info(), + ) + .await + .unwrap_err(); + + assert_eq!(error, SyncError::InvalidCredentials); + assert_eq!(h.store.current_refresh_token().unwrap(), before); + h.client.devices().await.unwrap(); +} + +#[sqlx::test(migrations = "../keygo-server/migrations")] +async fn unknown_username_is_invalid_credentials(db: PgPool) { + let (client, _, _) = signed_out(&db); + + let error = client + .login( + &ArkSession::new(), + "nobody".into(), + password(), + testing::device_info(), + ) + .await + .unwrap_err(); + + assert_eq!(error, SyncError::InvalidCredentials); +} From 486eaf3b2b106b763077331e363c4188485cd518 Mon Sep 17 00:00:00 2001 From: Davis Wolfermann Date: Sat, 14 Nov 2026 10:44:38 +0100 Subject: [PATCH 45/52] refactor: reintroduce glob import --- rust/crates/keygo-core/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rust/crates/keygo-core/src/lib.rs b/rust/crates/keygo-core/src/lib.rs index a7356bda9..bbcbfd012 100644 --- a/rust/crates/keygo-core/src/lib.rs +++ b/rust/crates/keygo-core/src/lib.rs @@ -16,5 +16,5 @@ mod sealed; pub use crypto::*; pub use error::{CryptoError, CryptoResult}; pub use ids::{DeviceId, ItemId, NamespaceId, SessionId, UserId, VaultId}; -pub use keys::{AccountRootKey, BackupKey, ItemKey, NamespaceKey, OpaqueKek, RootKek, VaultKey}; +pub use keys::*; pub use sealed::{KEY_LEN, NONCE_LEN, Sealed, TAG_LEN}; From 810b6e6e2c9a7d78d8038d7a1b1403cfcf90b32f Mon Sep 17 00:00:00 2001 From: Davis Wolfermann Date: Sat, 14 Nov 2026 11:18:14 +0100 Subject: [PATCH 46/52] refactor: drop Sealed<[u8]> --- .../crates/keygo-api/src/domain/key_bundle.rs | 10 +------- rust/crates/keygo-api/src/domain/mod.rs | 2 +- .../keygo-api/src/domain/sealed_blob.rs | 12 ++++------ rust/crates/keygo-client/src/sync/client.rs | 8 +++---- rust/crates/keygo-core/src/sealed.rs | 23 ------------------- .../crates/keygo-server/src/db/key_bundles.rs | 8 ++++--- rust/crates/keygo-server/src/domain/mod.rs | 2 +- .../src/service/registration/finish.rs | 5 ++-- rust/crates/keygo-server/src/testing.rs | 5 ++-- 9 files changed, 22 insertions(+), 53 deletions(-) diff --git a/rust/crates/keygo-api/src/domain/key_bundle.rs b/rust/crates/keygo-api/src/domain/key_bundle.rs index 863f49dbb..d7c8c0d9d 100644 --- a/rust/crates/keygo-api/src/domain/key_bundle.rs +++ b/rust/crates/keygo-api/src/domain/key_bundle.rs @@ -1,15 +1,7 @@ -use crate::domain::SealedBlob; use keygo_core::{AccountRootKey, Sealed}; use serde::{Deserialize, Serialize}; #[derive(Serialize, Deserialize)] pub struct KeyBundle { - pub wrapped_ark: SealedBlob, -} - -impl KeyBundle { - /// The protocol fixes this field as the ARK wrapped under the account's OPAQUE KEK. - pub fn into_wrapped_ark(self) -> Sealed { - self.wrapped_ark.assume() - } + pub wrapped_ark: Sealed, } diff --git a/rust/crates/keygo-api/src/domain/mod.rs b/rust/crates/keygo-api/src/domain/mod.rs index c4bafa1a7..65cb28d17 100644 --- a/rust/crates/keygo-api/src/domain/mod.rs +++ b/rust/crates/keygo-api/src/domain/mod.rs @@ -14,7 +14,7 @@ pub use device::{ }; pub use ids::{InvalidId, LoginId, RegistrationId}; pub use key_bundle::KeyBundle; -pub use sealed_blob::{InvalidBlob, SealedBlob, check_wrapped_ark}; +pub use sealed_blob::{InvalidBlob, check_wrapped_ark}; pub use session::{ParseRefreshTokenError, RefreshToken, RevokeReason}; pub use string_enum::UnknownVariant; pub use username::{Username, UsernameError}; diff --git a/rust/crates/keygo-api/src/domain/sealed_blob.rs b/rust/crates/keygo-api/src/domain/sealed_blob.rs index 36050a8d0..2657f10e3 100644 --- a/rust/crates/keygo-api/src/domain/sealed_blob.rs +++ b/rust/crates/keygo-api/src/domain/sealed_blob.rs @@ -1,19 +1,17 @@ -use keygo_core::{KEY_LEN, NONCE_LEN, Sealed, TAG_LEN}; +use keygo_core::{AccountRootKey, KEY_LEN, NONCE_LEN, Sealed, TAG_LEN}; use thiserror::Error; -pub type SealedBlob = Sealed<[u8]>; - const WRAPPED_ARK_LEN: usize = NONCE_LEN + KEY_LEN + TAG_LEN; #[derive(Debug, Clone, Copy, PartialEq, Eq, Error)] #[error("wrapped key has the wrong length")] pub struct InvalidBlob; -fn len(blob: &SealedBlob) -> usize { +fn len(blob: &Sealed) -> usize { NONCE_LEN + blob.ciphertext().len() } -pub fn check_wrapped_ark(blob: &SealedBlob) -> Result<(), InvalidBlob> { +pub fn check_wrapped_ark(blob: &Sealed) -> Result<(), InvalidBlob> { if len(blob) == WRAPPED_ARK_LEN { Ok(()) } else { @@ -25,8 +23,8 @@ pub fn check_wrapped_ark(blob: &SealedBlob) -> Result<(), InvalidBlob> { mod tests { use super::*; - fn blob(len: usize) -> SealedBlob { - SealedBlob::from_bytes(&vec![7; len]).unwrap() + fn blob(len: usize) -> Sealed { + Sealed::::from_bytes(&vec![7; len]).unwrap() } /// Clients and stored rows depend on these sizes, so a change to the constants must fail here. diff --git a/rust/crates/keygo-client/src/sync/client.rs b/rust/crates/keygo-client/src/sync/client.rs index 9b5e0e20a..21a8bddfd 100644 --- a/rust/crates/keygo-client/src/sync/client.rs +++ b/rust/crates/keygo-client/src/sync/client.rs @@ -163,8 +163,7 @@ impl SyncClient { .map_err(|error| match error { ArkSessionError::Locked => SyncError::VaultLocked, other => client_failure(other), - })? - .into(); + })?; let key_bundle = KeyBundle { wrapped_ark }; let sent_at = self.clock.now_secs(); @@ -240,7 +239,7 @@ impl SyncClient { let unlocked = ark.unlock_with_server( &finish.export_key, - &response.key_bundle.into_wrapped_ark(), + &response.key_bundle.wrapped_ark, response.user_id, ); if let Err(error) = unlocked { @@ -722,8 +721,7 @@ mod tests { ark: &ArkSession, ) -> Self { let user_id = UserId::random(); - let wrapped: keygo_api::domain::SealedBlob = - ark.wrap_for_server(export_key, user_id).unwrap().into(); + let wrapped = ark.wrap_for_server(export_key, user_id).unwrap(); Self { opaque, user_id, diff --git a/rust/crates/keygo-core/src/sealed.rs b/rust/crates/keygo-core/src/sealed.rs index 645cb196d..782472901 100644 --- a/rust/crates/keygo-core/src/sealed.rs +++ b/rust/crates/keygo-core/src/sealed.rs @@ -14,29 +14,6 @@ pub struct Sealed { pub(crate) content: PhantomData Box>, } -impl From> for Sealed<[u8]> { - fn from(value: Sealed) -> Self { - Self { - nonce: value.nonce, - ciphertext: value.ciphertext, - content: PhantomData, - } - } -} - -impl Sealed<[u8]> { - /// Claims an untyped blob holds a `T`. Only for a wire field whose kind the protocol fixes: - /// nothing checks the claim before the unwrap, so it is not a `From`, which any blob could - /// reach by accident. The AAD still rejects a blob of another kind at unwrap time. - pub fn assume(self) -> Sealed { - Sealed { - nonce: self.nonce, - ciphertext: self.ciphertext, - content: PhantomData, - } - } -} - impl Sealed { pub fn from_parts(nonce: &[u8], ciphertext: Vec) -> CryptoResult { let nonce = nonce diff --git a/rust/crates/keygo-server/src/db/key_bundles.rs b/rust/crates/keygo-server/src/db/key_bundles.rs index 6319d77d0..f55e1adf2 100644 --- a/rust/crates/keygo-server/src/db/key_bundles.rs +++ b/rust/crates/keygo-server/src/db/key_bundles.rs @@ -1,5 +1,6 @@ use super::corrupt; -use crate::domain::{KeyBundle, SealedBlob, UserId, check_wrapped_ark}; +use crate::domain::{KeyBundle, UserId, check_wrapped_ark}; +use keygo_core::Sealed; use sqlx::PgConnection; pub async fn insert( @@ -29,7 +30,7 @@ pub async fn find(conn: &mut PgConnection, user_id: UserId) -> sqlx::Result UserId { @@ -77,7 +79,7 @@ mod tests { .await .unwrap(); - let blob = SealedBlob::from_bytes(&stored).unwrap(); + let blob = Sealed::::from_bytes(&stored).unwrap(); assert_eq!(blob.nonce(), &WRAPPED_ARK[..12]); assert_eq!(blob.ciphertext(), &WRAPPED_ARK[12..]); } diff --git a/rust/crates/keygo-server/src/domain/mod.rs b/rust/crates/keygo-server/src/domain/mod.rs index 99b60eaa0..702585eef 100644 --- a/rust/crates/keygo-server/src/domain/mod.rs +++ b/rust/crates/keygo-server/src/domain/mod.rs @@ -15,7 +15,7 @@ pub use invite_hash::InviteHash; pub use invite_id::InviteId; pub use keygo_api::domain::{ AccessToken, Device, DeviceClaim, DeviceInfo, InvalidBlob, KeyBundle, LoginId, RefreshToken, - RegistrationId, RevokeReason, SealedBlob, Username, UsernameError, check_wrapped_ark, + RegistrationId, RevokeReason, Username, UsernameError, check_wrapped_ark, }; pub use keygo_core::{DeviceId, SessionId, UserId}; pub use session::{REFRESH_TTL, SESSION_LIFETIME, SESSION_RETENTION}; diff --git a/rust/crates/keygo-server/src/service/registration/finish.rs b/rust/crates/keygo-server/src/service/registration/finish.rs index 8b4ab13c8..5f0f9d2b7 100644 --- a/rust/crates/keygo-server/src/service/registration/finish.rs +++ b/rust/crates/keygo-server/src/service/registration/finish.rs @@ -80,12 +80,13 @@ pub async fn finish( #[cfg(test)] mod tests { use super::*; - use crate::domain::{SealedBlob, UserId}; + use crate::domain::UserId; use crate::service::registration::{self, Signup, StartRegistration, Started}; use crate::testing::{ JKT, PASSWORD, WRAPPED_ARK, count, create_invite, device_info, expire, invite_only, key_bundle, token_issuer, username, }; + use keygo_core::Sealed; use keygo_opaque::client::ClientRegistration; use keygo_opaque::server::ServerSetup; use uuid::Uuid; @@ -190,7 +191,7 @@ mod tests { let input = started_with(&db, &invite_only(), Some(&code), UserId::random(), "ada").await; let input = FinishRegistration { key_bundle: KeyBundle { - wrapped_ark: SealedBlob::from_bytes(&[7; 59]).unwrap(), + wrapped_ark: Sealed::from_bytes(&[7; 59]).unwrap(), }, ..input }; diff --git a/rust/crates/keygo-server/src/testing.rs b/rust/crates/keygo-server/src/testing.rs index 95f10ed6f..86dd242b8 100644 --- a/rust/crates/keygo-server/src/testing.rs +++ b/rust/crates/keygo-server/src/testing.rs @@ -3,7 +3,7 @@ use crate::cache::{LoginStates, StepUpStates}; use crate::db::{devices, invites, sessions, users}; use crate::domain::{ AccessTokenKey, DeviceClaim, DeviceId, DeviceInfo, InviteHash, InvitePepper, KeyBundle, - SealedBlob, SessionId, TokenIssuer, UserId, Username, + SessionId, TokenIssuer, UserId, Username, }; use crate::service::login::{self, FinishLogin, StartLogin}; use crate::service::registration::{self, FinishRegistration, Signup, StartRegistration}; @@ -13,6 +13,7 @@ use axum::body::Body; use axum::http::header::AUTHORIZATION; use axum::http::{HeaderMap, Request, StatusCode}; use http_body_util::BodyExt; +use keygo_core::{AccountRootKey, Sealed}; use keygo_dpop::DpopVerifier; use keygo_dpop::testing::TestSigner; use keygo_dpop::{DpopProver, Htm, ProofRequest}; @@ -51,7 +52,7 @@ pub fn device_claim(id: Option) -> DeviceClaim { } pub fn key_bundle_json() -> Value { - json!({ "wrapped_ark": SealedBlob::from_bytes(&WRAPPED_ARK).unwrap() }) + json!({ "wrapped_ark": Sealed::::from_bytes(&WRAPPED_ARK).unwrap() }) } pub fn key_bundle() -> KeyBundle { serde_json::from_value(key_bundle_json()).unwrap() From 880238a2b3a017915eca886c4f6746dc3e5f6e56 Mon Sep 17 00:00:00 2001 From: Davis Wolfermann Date: Sat, 14 Nov 2026 12:46:16 +0100 Subject: [PATCH 47/52] fix(client): rename send_singed to send_signed --- rust/crates/keygo-client/src/sync/client.rs | 4 ++-- rust/crates/keygo-client/src/sync/pipeline.rs | 8 ++++---- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/rust/crates/keygo-client/src/sync/client.rs b/rust/crates/keygo-client/src/sync/client.rs index 21a8bddfd..639c8d3b3 100644 --- a/rust/crates/keygo-client/src/sync/client.rs +++ b/rust/crates/keygo-client/src/sync/client.rs @@ -285,13 +285,13 @@ impl SyncClient { async fn discard(&self, session: &Session, claimed: Option) { let token = Some(session.access.access_token.expose()); let _ = if claimed == Some(session.device_id) { - self.send_singed(Logout::METHOD, &Logout.path(), token, None) + self.send_signed(Logout::METHOD, &Logout.path(), token, None) .await } else { let endpoint = DeleteDevice { id: session.device_id, }; - self.send_singed(DeleteDevice::METHOD, &endpoint.path(), token, None) + self.send_signed(DeleteDevice::METHOD, &endpoint.path(), token, None) .await }; } diff --git a/rust/crates/keygo-client/src/sync/pipeline.rs b/rust/crates/keygo-client/src/sync/pipeline.rs index 69f7b9130..a1cfb3d4b 100644 --- a/rust/crates/keygo-client/src/sync/pipeline.rs +++ b/rust/crates/keygo-client/src/sync/pipeline.rs @@ -167,7 +167,7 @@ impl SyncClient { /// Signs and sends one request, and re-signs once if the server answers with a nonce challenge /// that carries a nonce. /// Every `DPoP-Nonce` header the server sends replaces the stored nonce. - pub(super) async fn send_singed( + pub(super) async fn send_signed( &self, method: Method, path: &str, @@ -225,7 +225,7 @@ impl SyncClient { let sent_at = self.clock.now_secs(); let response = self - .send_singed(Token::METHOD, &Token.path(), None, Some(body.as_slice())) + .send_signed(Token::METHOD, &Token.path(), None, Some(body.as_slice())) .await?; if !response.is_success() { @@ -291,7 +291,7 @@ impl SyncClient { let (token, generation) = self.access_token(rejected).await?; let response = self - .send_singed(method, path, Some(token.as_str()), body) + .send_signed(method, path, Some(token.as_str()), body) .await?; if rejected.is_some() || !response.is_invalid_token() { @@ -320,7 +320,7 @@ impl SyncClient { .await? } Auth::Proof => { - self.send_singed(E::METHOD, &path, None, body.as_deref()) + self.send_signed(E::METHOD, &path, None, body.as_deref()) .await? } Auth::AccessToken => { From 7834268bbcec9630654334fbff0fcd5dc2d69377 Mon Sep 17 00:00:00 2001 From: Davis Wolfermann Date: Sat, 14 Nov 2026 12:46:17 +0100 Subject: [PATCH 48/52] docs(client): shorten the sync client docs --- rust/crates/keygo-client/src/sync/client.rs | 56 +++++++++------------ 1 file changed, 25 insertions(+), 31 deletions(-) diff --git a/rust/crates/keygo-client/src/sync/client.rs b/rust/crates/keygo-client/src/sync/client.rs index 639c8d3b3..a2cc0ea93 100644 --- a/rust/crates/keygo-client/src/sync/client.rs +++ b/rust/crates/keygo-client/src/sync/client.rs @@ -36,7 +36,7 @@ pub struct SyncClient { pub(super) tokens: Arc, pub(super) clock: Arc, pub(super) auth: Mutex, - /// Outside `auth` because a refresh holds that lock across the network, and it signs too. + /// Not inside `auth`: a refresh holds that lock across the network and signs with the nonce. pub(super) nonce: std::sync::Mutex>, } @@ -91,7 +91,7 @@ impl SyncClient { self.call(&DeleteDevice { id }, &()).await } - /// Proves the password again. Replaces only the access token: the refresh token stays as it is. + /// Proves the password again for a fresh access token. The refresh token is kept. pub async fn step_up(&self, password: &str) -> SyncResult<()> { let (login, credential_request) = ClientLogin::start(password.as_bytes()).map_err(opaque_failure)?; @@ -122,12 +122,10 @@ impl SyncClient { Ok(()) } - /// Creates an account whose server copy of the ARK is the one `ark` holds, and signs in. + /// Creates an account holding a server-wrapped copy of `ark`'s ARK, and signs in. /// - /// `user_id` must be the local account's id: the server-wrapped ARK is bound to it, and the - /// server stores it as the account's id. `ark` cannot check this, since it holds no user id. - /// Any session this client held is logged out once the new one exists; a failed registration - /// leaves it as it was. + /// `user_id` must be the local account's id: the wrapped ARK is bound to it, and `ark` holds no + /// id to check it against. The previous session is logged out only once the new one exists. pub async fn register( &self, ark: &ArkSession, @@ -188,15 +186,11 @@ impl SyncClient { Ok(account) } - /// Signs in to an existing account. + /// Signs in and unlocks `ark` with the server's copy of the ARK. An `ark` that is already + /// unlocked must hold that same ARK, or the login fails with [`SyncError::AccountMismatch`]. /// - /// The server's copy of the ARK must open with the export key. If `ark` is locked, a successful - /// login unlocks it with that copy. If it is unlocked, it must already hold the same ARK; - /// otherwise the login fails with [`SyncError::AccountMismatch`] and the session the server - /// just issued is ended again. A failed login leaves any session this client held as it was. - /// - /// The device this client was last signed in as is claimed again, so a re-login on the same - /// device replaces its session instead of adding a device. + /// Claims the device this client last signed in as, so a re-login replaces its session instead + /// of adding a device. pub async fn login( &self, ark: &ArkSession, @@ -257,37 +251,34 @@ impl SyncClient { Ok(account) } - /// The device of the session this client holds, if it can tell. async fn current_device(&self) -> Option { let state = self.auth.lock().await; if let Some(unsaved) = &state.unsaved { return Some(unsaved.device_id); } - // A store that cannot be read only costs the reattach: the server then makes a new device. + // An unreadable store only costs the reattach: the server makes a new device instead. self.tokens.load().await.ok().flatten().map(|s| s.device_id) } - /// Adopts `session` in place of the one this client held. If the server reattached `claimed`, - /// it already ended that device's old session. Otherwise the old one is logged out first, so - /// its refresh token does not stay valid. That logout is best effort: the new session is live - /// on the server either way, and dropping it would only leave a second token nobody holds. async fn replace_session(&self, session: Session, sent_at: u64, claimed: Option) { - if claimed != Some(session.device_id) { + // The server already revoked a reattached device's old session. The logout is best effort: + // the new session is live on the server either way. + if !is_reattached(&session, claimed) { let _ = self.logout().await; } self.adopt_session(session, sent_at).await; } - /// Ends a session the server issued but this client will not keep, with its own access token, - /// so the session this client holds is untouched. A device made for this login alone is - /// deleted, which ends its session too; a reattached one stays and is only logged out. - /// Best effort: if this fails, the session expires unused. + /// Ends a session this client will not keep, signing with that session's own token. Best + /// effort: one left behind expires unused. async fn discard(&self, session: &Session, claimed: Option) { let token = Some(session.access.access_token.expose()); - let _ = if claimed == Some(session.device_id) { + let _ = if is_reattached(session, claimed) { + // The device was this client's before the login, so it stays. self.send_signed(Logout::METHOD, &Logout.path(), token, None) .await } else { + // The device exists only for this login. Deleting it ends its session too. let endpoint = DeleteDevice { id: session.device_id, }; @@ -296,8 +287,8 @@ impl SyncClient { }; } - /// Always ends the session locally. Returns the server's result, unless the server was not told - /// and the store could not be cleared: a token the server may still accept is then left on disk. + /// Always ends the session locally and returns the server's result. If the server was not told + /// and the token is still on disk, the store error is returned instead. pub async fn logout(&self) -> SyncResult<()> { let sent = self.call(&Logout, &()).await; let mut state = self.auth.lock().await; @@ -309,14 +300,17 @@ impl SyncClient { } } +fn is_reattached(session: &Session, claimed: Option) -> bool { + claimed == Some(session.device_id) +} + fn client_failure(error: impl std::fmt::Display) -> SyncError { SyncError::Client { message: error.to_string(), } } -/// The server's copy of the ARK not opening is the server's fault: OPAQUE already proved the -/// password, and the export key follows from it. +/// OPAQUE already proved the password, so a key bundle that does not open is the server's fault. fn unlock_failure(error: ArkSessionError) -> SyncError { match error { ArkSessionError::AccountMismatch => SyncError::AccountMismatch, From 2f5bb8e626de2999ffe43753d4bf166a67dd91c8 Mon Sep 17 00:00:00 2001 From: Davis Wolfermann Date: Sat, 14 Nov 2026 12:57:54 +0100 Subject: [PATCH 49/52] refactor: rename ark_session --- .../de/davis/keygo/rust/FakeSyncClient.kt | 4 +- rust/crates/keygo-client/src/sync/client.rs | 121 +++++++++--------- rust/crates/keygo-e2e/tests/sync.rs | 51 +++++--- rust/crates/keygo-uniffi/src/sync.rs | 19 ++- 4 files changed, 109 insertions(+), 86 deletions(-) diff --git a/core/rust/src/testFixtures/kotlin/de/davis/keygo/rust/FakeSyncClient.kt b/core/rust/src/testFixtures/kotlin/de/davis/keygo/rust/FakeSyncClient.kt index 910409f1c..62dc8a99a 100644 --- a/core/rust/src/testFixtures/kotlin/de/davis/keygo/rust/FakeSyncClient.kt +++ b/core/rust/src/testFixtures/kotlin/de/davis/keygo/rust/FakeSyncClient.kt @@ -24,7 +24,7 @@ class FakeSyncClient : SyncClientInterface { override suspend fun devices(): List = devicesResult.getOrThrow() override suspend fun login( - ark: ArkSession, + arkSession: ArkSession, username: String, password: String, device: DeviceDetails, @@ -36,7 +36,7 @@ class FakeSyncClient : SyncClientInterface { checkNotNull(metaResult) { "metaResult not set" }.getOrThrow() override suspend fun register( - ark: ArkSession, + arkSession: ArkSession, userId: UserId, username: String, password: String, diff --git a/rust/crates/keygo-client/src/sync/client.rs b/rust/crates/keygo-client/src/sync/client.rs index a2cc0ea93..12bb0357e 100644 --- a/rust/crates/keygo-client/src/sync/client.rs +++ b/rust/crates/keygo-client/src/sync/client.rs @@ -122,20 +122,21 @@ impl SyncClient { Ok(()) } - /// Creates an account holding a server-wrapped copy of `ark`'s ARK, and signs in. + /// Creates an account holding a server-wrapped copy of `ark_session`'s ARK, and signs in. /// - /// `user_id` must be the local account's id: the wrapped ARK is bound to it, and `ark` holds no - /// id to check it against. The previous session is logged out only once the new one exists. + /// `user_id` must be the local account's id: the wrapped ARK is bound to it, and `ark_session` + /// holds no id to check it against. The previous session is logged out only once the new one + /// exists. pub async fn register( &self, - ark: &ArkSession, + ark_session: &ArkSession, user_id: UserId, username: String, password: &str, invite: Option, device: DeviceInfo, ) -> SyncResult { - if !ark.is_active() { + if !ark_session.is_active() { return Err(SyncError::VaultLocked); } let (client, registration_request) = @@ -156,7 +157,7 @@ impl SyncClient { .finish(password.as_bytes(), started.registration_response) .map_err(|error| SyncError::invalid_response(error.to_string()))?; - let wrapped_ark = ark + let wrapped_ark = ark_session .wrap_for_server(&finish.export_key, user_id) .map_err(|error| match error { ArkSessionError::Locked => SyncError::VaultLocked, @@ -186,14 +187,15 @@ impl SyncClient { Ok(account) } - /// Signs in and unlocks `ark` with the server's copy of the ARK. An `ark` that is already - /// unlocked must hold that same ARK, or the login fails with [`SyncError::AccountMismatch`]. + /// Signs in and unlocks `ark_session` with the server's copy of the ARK. An `ark_session` that + /// is already unlocked must hold that same ARK, or the login fails with + /// [`SyncError::AccountMismatch`]. /// /// Claims the device this client last signed in as, so a re-login replaces its session instead /// of adding a device. pub async fn login( &self, - ark: &ArkSession, + ark_session: &ArkSession, username: String, password: &str, device: DeviceInfo, @@ -231,7 +233,7 @@ impl SyncClient { ) .await?; - let unlocked = ark.unlock_with_server( + let unlocked = ark_session.unlock_with_server( &finish.export_key, &response.key_bundle.wrapped_ark, response.user_id, @@ -451,9 +453,12 @@ mod tests { const REFRESH: &str = "kgr_AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"; fn unlocked() -> (ArkSession, UserId) { - let ark = ArkSession::new(); - let user_id = ark.create_account("local password").unwrap().user_id; - (ark, user_id) + let ark_session = ArkSession::new(); + let user_id = ark_session + .create_account("local password") + .unwrap() + .user_id; + (ark_session, user_id) } fn device() -> DeviceInfo { @@ -504,10 +509,10 @@ mod tests { client_with_store("https://kg.example", Arc::new(FakeSigner::new())); transport.push_with(200, start_reply); transport.push(200, &[], &finish_reply()); - let (ark, user_id) = unlocked(); + let (ark_session, user_id) = unlocked(); let account = client - .register(&ark, user_id, "Ada".into(), "pw", None, device()) + .register(&ark_session, user_id, "Ada".into(), "pw", None, device()) .await .unwrap(); @@ -553,10 +558,10 @@ mod tests { async fn empty_password_sends_nothing() { let (client, transport, _) = client_with_store("https://kg.example", Arc::new(FakeSigner::new())); - let (ark, user_id) = unlocked(); + let (ark_session, user_id) = unlocked(); let error = client - .register(&ark, user_id, "ada".into(), "", None, device()) + .register(&ark_session, user_id, "ada".into(), "", None, device()) .await .unwrap_err(); @@ -582,10 +587,10 @@ mod tests { })) .unwrap() }); - let (ark, user_id) = unlocked(); + let (ark_session, user_id) = unlocked(); let error = client - .register(&ark, user_id, "ada".into(), "pw", None, device()) + .register(&ark_session, user_id, "ada".into(), "pw", None, device()) .await .unwrap_err(); @@ -602,10 +607,10 @@ mod tests { client_with_store("https://kg.example", Arc::new(FakeSigner::new())); store.seed(previous_session()); transport.push(409, &[], &error_body("username_taken")); - let (ark, user_id) = unlocked(); + let (ark_session, user_id) = unlocked(); let error = client - .register(&ark, user_id, "ada".into(), "pw", None, device()) + .register(&ark_session, user_id, "ada".into(), "pw", None, device()) .await .unwrap_err(); @@ -623,10 +628,10 @@ mod tests { transport.push(200, &[], &finish_reply()); transport.push(200, &[], &old_session_reply()); transport.push(204, &[], b""); - let (ark, user_id) = unlocked(); + let (ark_session, user_id) = unlocked(); client - .register(&ark, user_id, "ada".into(), "pw", None, device()) + .register(&ark_session, user_id, "ada".into(), "pw", None, device()) .await .unwrap(); @@ -696,7 +701,7 @@ mod tests { const ACCESS: &str = "new.access.token"; const NEW_DEVICE: &str = "00000000-0000-0000-0000-00000000000e"; - /// A server account whose key bundle wraps the ARK `ark` holds. + /// A server account whose key bundle wraps the ARK `ark_session` holds. struct Server { opaque: FakeOpaqueAccount, user_id: UserId, @@ -704,18 +709,18 @@ mod tests { } impl Server { - fn holding(ark: &ArkSession) -> Self { + fn holding(ark_session: &ArkSession) -> Self { let (opaque, export_key) = FakeOpaqueAccount::register(PASSWORD); - Self::with_key(opaque, &export_key, ark) + Self::with_key(opaque, &export_key, ark_session) } fn with_key( opaque: FakeOpaqueAccount, export_key: &ExportKey, - ark: &ArkSession, + ark_session: &ArkSession, ) -> Self { let user_id = UserId::random(); - let wrapped = ark.wrap_for_server(export_key, user_id).unwrap(); + let wrapped = ark_session.wrap_for_server(export_key, user_id).unwrap(); Self { opaque, user_id, @@ -762,9 +767,9 @@ mod tests { } fn unlocked() -> ArkSession { - let ark = ArkSession::new(); - ark.create_account("local password").unwrap(); - ark + let ark_session = ArkSession::new(); + ark_session.create_account("local password").unwrap(); + ark_session } fn device() -> DeviceInfo { @@ -788,13 +793,13 @@ mod tests { #[tokio::test] async fn signs_in_and_keeps_the_session() { let (client, transport, store) = client(); - let ark = unlocked(); - let server = Server::holding(&ark); + let ark_session = unlocked(); + let server = Server::holding(&ark_session); server.answer_start(&transport); server.answer_finish(&transport, NEW_DEVICE); let account = client - .login(&ark, "Ada".into(), PASSWORD, device()) + .login(&ark_session, "Ada".into(), PASSWORD, device()) .await .unwrap(); @@ -812,30 +817,30 @@ mod tests { #[tokio::test] async fn unlocks_a_locked_session_with_the_server_copy() { let (client, transport, _) = client(); - let ark = unlocked(); - let server = Server::holding(&ark); - let local = ark.export_ark().unwrap(); - ark.end(); + let ark_session = unlocked(); + let server = Server::holding(&ark_session); + let local = ark_session.export_ark().unwrap(); + ark_session.end(); server.answer_start(&transport); server.answer_finish(&transport, NEW_DEVICE); client - .login(&ark, "ada".into(), PASSWORD, device()) + .login(&ark_session, "ada".into(), PASSWORD, device()) .await .unwrap(); - assert_eq!(ark.export_ark().unwrap(), local); + assert_eq!(ark_session.export_ark().unwrap(), local); } #[tokio::test] async fn wrong_password_sends_no_finish() { let (client, transport, store) = client(); store.seed(previous_session()); - let ark = unlocked(); - Server::holding(&ark).answer_start(&transport); + let ark_session = unlocked(); + Server::holding(&ark_session).answer_start(&transport); let error = client - .login(&ark, "ada".into(), "wrong", device()) + .login(&ark_session, "ada".into(), "wrong", device()) .await .unwrap_err(); @@ -881,13 +886,13 @@ mod tests { async fn reclaims_the_device_it_was_signed_in_as() { let (client, transport, store) = client(); store.seed(previous_session()); - let ark = unlocked(); - let server = Server::holding(&ark); + let ark_session = unlocked(); + let server = Server::holding(&ark_session); server.answer_start(&transport); server.answer_finish(&transport, OLD_DEVICE); client - .login(&ark, "ada".into(), PASSWORD, device()) + .login(&ark_session, "ada".into(), PASSWORD, device()) .await .unwrap(); @@ -903,15 +908,15 @@ mod tests { async fn logs_the_previous_session_out_on_a_new_device() { let (client, transport, store) = client(); store.seed(previous_session()); - let ark = unlocked(); - let server = Server::holding(&ark); + let ark_session = unlocked(); + let server = Server::holding(&ark_session); server.answer_start(&transport); server.answer_finish(&transport, NEW_DEVICE); transport.push(200, &[], &old_session_reply()); transport.push(204, &[], b""); client - .login(&ark, "ada".into(), PASSWORD, device()) + .login(&ark_session, "ada".into(), PASSWORD, device()) .await .unwrap(); @@ -936,21 +941,21 @@ mod tests { async fn mismatch_keeps_the_previous_session_and_deletes_the_new_device() { let (client, transport, store) = client(); store.seed(previous_session()); - let ark = unlocked(); - let local = ark.export_ark().unwrap(); + let ark_session = unlocked(); + let local = ark_session.export_ark().unwrap(); let server = Server::holding(&unlocked()); server.answer_start(&transport); server.answer_finish(&transport, NEW_DEVICE); transport.push(204, &[], b""); let error = client - .login(&ark, "ada".into(), PASSWORD, device()) + .login(&ark_session, "ada".into(), PASSWORD, device()) .await .unwrap_err(); assert_eq!(error, SyncError::AccountMismatch); assert_eq!(store.current_refresh_token().as_deref(), Some(OLD_REFRESH)); - assert_eq!(ark.export_ark().unwrap(), local); + assert_eq!(ark_session.export_ark().unwrap(), local); let requests = transport.requests(); assert_eq!(requests.len(), 3); @@ -995,17 +1000,17 @@ mod tests { #[tokio::test] async fn bundle_that_does_not_open_is_an_invalid_response() { let (client, transport, _) = client(); - let ark = unlocked(); + let ark_session = unlocked(); let (opaque, _) = FakeOpaqueAccount::register(PASSWORD); let (_, other_key) = FakeOpaqueAccount::register(PASSWORD); - let server = Server::with_key(opaque, &other_key, &ark); - ark.end(); + let server = Server::with_key(opaque, &other_key, &ark_session); + ark_session.end(); server.answer_start(&transport); server.answer_finish(&transport, NEW_DEVICE); transport.push(204, &[], b""); let error = client - .login(&ark, "ada".into(), PASSWORD, device()) + .login(&ark_session, "ada".into(), PASSWORD, device()) .await .unwrap_err(); @@ -1013,7 +1018,7 @@ mod tests { matches!(&error, SyncError::Server { code, .. } if code == "invalid_response"), "{error:?}", ); - assert!(!ark.is_active()); + assert!(!ark_session.is_active()); assert_eq!(transport.requests().len(), 3, "the new device is deleted"); } diff --git a/rust/crates/keygo-e2e/tests/sync.rs b/rust/crates/keygo-e2e/tests/sync.rs index 44e45c82b..514761609 100644 --- a/rust/crates/keygo-e2e/tests/sync.rs +++ b/rust/crates/keygo-e2e/tests/sync.rs @@ -141,15 +141,15 @@ async fn device_count(db: &PgPool, user_id: UserId) -> i64 { } fn local_account() -> (ArkSession, UserId) { - let ark = ArkSession::new(); - let user_id = ark.create_account(password()).unwrap().user_id; - (ark, user_id) + let ark_session = ArkSession::new(); + let user_id = ark_session.create_account(password()).unwrap().user_id; + (ark_session, user_id) } -async fn register(client: &SyncClient, ark: &ArkSession, user_id: UserId, name: &str) { +async fn register(client: &SyncClient, ark_session: &ArkSession, user_id: UserId, name: &str) { client .register( - ark, + ark_session, user_id, name.into(), password(), @@ -297,11 +297,11 @@ async fn client_logout_ends_the_session_on_the_server(db: PgPool) { #[sqlx::test(migrations = "../keygo-server/migrations")] async fn register_signs_the_device_in(db: PgPool) { let (client, store, _) = signed_out(&db); - let (ark, user_id) = local_account(); + let (ark_session, user_id) = local_account(); let account = client .register( - &ark, + &ark_session, user_id, "Ada".into(), password(), @@ -322,8 +322,8 @@ async fn register_signs_the_device_in(db: PgPool) { #[sqlx::test(migrations = "../keygo-server/migrations")] async fn server_wrapped_ark_opens_after_sign_in(db: PgPool) { let (client, _, state) = signed_out(&db); - let (ark, user_id) = local_account(); - register(&client, &ark, user_id, "ada").await; + let (ark_session, user_id) = local_account(); + register(&client, &ark_session, user_id, "ada").await; let (login, started) = testing::start_login(&db, &state.login_states, &state.opaque_state, "ada").await; @@ -346,15 +346,18 @@ async fn server_wrapped_ark_opens_after_sign_in(db: PgPool) { ) .unwrap(); - assert_eq!(opened.as_bytes(), ark.export_ark().unwrap().as_slice()); + assert_eq!( + opened.as_bytes(), + ark_session.export_ark().unwrap().as_slice() + ); } #[sqlx::test(migrations = "../keygo-server/migrations")] async fn registering_while_signed_in_ends_the_old_session(db: PgPool) { let h = harness(&db).await; - let (ark, user_id) = local_account(); + let (ark_session, user_id) = local_account(); - register(&h.client, &ark, user_id, "bob").await; + register(&h.client, &ark_session, user_id, "bob").await; let (status, _) = testing::post_with_token( &h.state, @@ -383,8 +386,8 @@ async fn refused_save_does_not_trip_reuse_detection(db: PgPool) { #[sqlx::test(migrations = "../keygo-server/migrations")] async fn login_on_a_fresh_install_unlocks_the_vault(db: PgPool) { let (client, _, state) = signed_out(&db); - let (ark, user_id) = local_account(); - register(&client, &ark, user_id, "ada").await; + let (ark_session, user_id) = local_account(); + register(&client, &ark_session, user_id, "ada").await; let (fresh, store) = client_of(&state); let locked = ArkSession::new(); @@ -394,7 +397,10 @@ async fn login_on_a_fresh_install_unlocks_the_vault(db: PgPool) { .unwrap(); assert_eq!(account.user_id, user_id); - assert_eq!(locked.export_ark().unwrap(), ark.export_ark().unwrap()); + assert_eq!( + locked.export_ark().unwrap(), + ark_session.export_ark().unwrap() + ); assert!(store.current_refresh_token().is_some()); assert_eq!(fresh.devices().await.unwrap().len(), 2); } @@ -402,12 +408,17 @@ async fn login_on_a_fresh_install_unlocks_the_vault(db: PgPool) { #[sqlx::test(migrations = "../keygo-server/migrations")] async fn logging_in_again_reuses_the_device(db: PgPool) { let (client, _, _) = signed_out(&db); - let (ark, user_id) = local_account(); - register(&client, &ark, user_id, "ada").await; + let (ark_session, user_id) = local_account(); + register(&client, &ark_session, user_id, "ada").await; let registered = client.devices().await.unwrap()[0].id; let account = client - .login(&ark, "ada".into(), password(), testing::device_info()) + .login( + &ark_session, + "ada".into(), + password(), + testing::device_info(), + ) .await .unwrap(); @@ -419,8 +430,8 @@ async fn logging_in_again_reuses_the_device(db: PgPool) { #[sqlx::test(migrations = "../keygo-server/migrations")] async fn login_into_another_vault_leaves_nothing_behind(db: PgPool) { let (client, _, state) = signed_out(&db); - let (ark, user_id) = local_account(); - register(&client, &ark, user_id, "ada").await; + let (ark_session, user_id) = local_account(); + register(&client, &ark_session, user_id, "ada").await; let (other, store) = client_of(&state); let (other_ark, _) = local_account(); diff --git a/rust/crates/keygo-uniffi/src/sync.rs b/rust/crates/keygo-uniffi/src/sync.rs index aeb851bc0..27ddcc10d 100644 --- a/rust/crates/keygo-uniffi/src/sync.rs +++ b/rust/crates/keygo-uniffi/src/sync.rs @@ -373,7 +373,7 @@ impl SyncClient { /// `user_id` must be the local account's id; see the core `SyncClient::register`. pub async fn register( self: Arc, - ark: Arc, + ark_session: Arc, user_id: UserId, username: String, password: String, @@ -384,18 +384,25 @@ impl SyncClient { let device = device.into_core()?; let account = detached(async move { self.inner - .register(&ark.session, user_id, username, &password, invite, device) + .register( + &ark_session.session, + user_id, + username, + &password, + invite, + device, + ) .await }) .await?; Ok(account.into()) } - /// Unlocks a locked `ark` with the server's copy of the ARK; an unlocked one must hold the - /// same ARK, or this fails with `AccountMismatch`. See the core `SyncClient::login`. + /// Unlocks a locked `ark_session` with the server's copy of the ARK; an unlocked one must hold + /// the same ARK, or this fails with `AccountMismatch`. See the core `SyncClient::login`. pub async fn login( self: Arc, - ark: Arc, + ark_session: Arc, username: String, password: String, device: DeviceDetails, @@ -404,7 +411,7 @@ impl SyncClient { let device = device.into_core()?; let account = detached(async move { self.inner - .login(&ark.session, username, &password, device) + .login(&ark_session.session, username, &password, device) .await }) .await?; From 51b98a221f6796ec0fb2c49be16857af265c942a Mon Sep 17 00:00:00 2001 From: Davis Wolfermann Date: Sat, 14 Nov 2026 13:29:02 +0100 Subject: [PATCH 50/52] refactor: rename message to reason --- rust/crates/keygo-uniffi/src/sync.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/rust/crates/keygo-uniffi/src/sync.rs b/rust/crates/keygo-uniffi/src/sync.rs index 27ddcc10d..1c9984a92 100644 --- a/rust/crates/keygo-uniffi/src/sync.rs +++ b/rust/crates/keygo-uniffi/src/sync.rs @@ -46,8 +46,8 @@ pub enum SyncError { Server { code: String, reason: String }, #[error("client error: {reason}")] Client { reason: String }, - #[error("{message}")] - InvalidUrl { message: String }, + #[error("{reason}")] + InvalidUrl { reason: String }, } impl From for SyncError { @@ -72,7 +72,7 @@ impl From for SyncError { }, CoreSyncError::Client { message } => Self::Client { reason: message }, CoreSyncError::InvalidUrl(e) => Self::InvalidUrl { - message: e.to_string(), + reason: e.to_string(), }, } } From d8a620a07aa3cd7fbaba66b921deb71c3a612d0f Mon Sep 17 00:00:00 2001 From: Davis Wolfermann Date: Sat, 14 Nov 2026 13:32:22 +0100 Subject: [PATCH 51/52] chore: fix formatting --- rust/crates/keygo-api/src/endpoint.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rust/crates/keygo-api/src/endpoint.rs b/rust/crates/keygo-api/src/endpoint.rs index 340bef45d..fdc674807 100644 --- a/rust/crates/keygo-api/src/endpoint.rs +++ b/rust/crates/keygo-api/src/endpoint.rs @@ -1,5 +1,5 @@ -use serde::de::DeserializeOwned; use serde::Serialize; +use serde::de::DeserializeOwned; use std::borrow::Cow; /// What a request must carry for the server to accept it. From b6b114f5c21156d66b35320204164d2e45cfd4de Mon Sep 17 00:00:00 2001 From: Davis Wolfermann Date: Sat, 14 Nov 2026 14:36:11 +0100 Subject: [PATCH 52/52] fix(security): map AccountMismatch session error --- .../core/security/data/crypto/AccountRecordSealerImpl.kt | 6 +++++- .../security/data/crypto/CryptographicScopeProviderImpl.kt | 6 +++++- .../kotlin/de/davis/keygo/core/security/domain/Session.kt | 1 + .../de/davis/keygo/core/security/domain/SessionError.kt | 1 + 4 files changed, 12 insertions(+), 2 deletions(-) diff --git a/core/security/src/main/kotlin/de/davis/keygo/core/security/data/crypto/AccountRecordSealerImpl.kt b/core/security/src/main/kotlin/de/davis/keygo/core/security/data/crypto/AccountRecordSealerImpl.kt index 02676976f..25b388083 100644 --- a/core/security/src/main/kotlin/de/davis/keygo/core/security/data/crypto/AccountRecordSealerImpl.kt +++ b/core/security/src/main/kotlin/de/davis/keygo/core/security/data/crypto/AccountRecordSealerImpl.kt @@ -46,7 +46,11 @@ internal class AccountRecordSealerImpl( private fun SessionError.toAccountRecordError(): AccountRecordError = when (this) { SessionError.Locked -> AccountRecordError.NoActiveSession SessionError.DecryptionFailed -> AccountRecordError.Corrupted - SessionError.WrongPassword, is SessionError.Derivation, is SessionError.KeyWrap -> + SessionError.AccountMismatch, + SessionError.WrongPassword, + is SessionError.Derivation, + is SessionError.KeyWrap, + -> AccountRecordError.KeyUnwrapFailed } diff --git a/core/security/src/main/kotlin/de/davis/keygo/core/security/data/crypto/CryptographicScopeProviderImpl.kt b/core/security/src/main/kotlin/de/davis/keygo/core/security/data/crypto/CryptographicScopeProviderImpl.kt index b194c61e8..747d75017 100644 --- a/core/security/src/main/kotlin/de/davis/keygo/core/security/data/crypto/CryptographicScopeProviderImpl.kt +++ b/core/security/src/main/kotlin/de/davis/keygo/core/security/data/crypto/CryptographicScopeProviderImpl.kt @@ -122,7 +122,11 @@ internal class CryptographicScopeProviderImpl( private fun SessionError.toCryptoScopeError(): CryptoScopeError = when (this) { SessionError.Locked -> CryptoScopeError.NoActiveSession is SessionError.KeyWrap -> CryptoScopeError.KeyWrapError(cause) - SessionError.WrongPassword, is SessionError.Derivation, SessionError.DecryptionFailed -> + SessionError.AccountMismatch, + SessionError.WrongPassword, + is SessionError.Derivation, + SessionError.DecryptionFailed, + -> CryptoScopeError.KeyWrapError(KeyWrapException.UnwrapFailed()) } diff --git a/core/security/src/main/kotlin/de/davis/keygo/core/security/domain/Session.kt b/core/security/src/main/kotlin/de/davis/keygo/core/security/domain/Session.kt index 19278db5a..30a1385e8 100644 --- a/core/security/src/main/kotlin/de/davis/keygo/core/security/domain/Session.kt +++ b/core/security/src/main/kotlin/de/davis/keygo/core/security/domain/Session.kt @@ -103,6 +103,7 @@ inline fun Session.useArk(block: (ByteArray) -> T): Result @PublishedApi internal fun ArkSessionException.toSessionError(): SessionError = when (this) { is ArkSessionException.Locked -> SessionError.Locked + is ArkSessionException.AccountMismatch -> SessionError.AccountMismatch is ArkSessionException.WrongPassword -> SessionError.WrongPassword is ArkSessionException.Derivation -> SessionError.Derivation(v1) is ArkSessionException.DecryptionFailed -> SessionError.DecryptionFailed diff --git a/core/security/src/main/kotlin/de/davis/keygo/core/security/domain/SessionError.kt b/core/security/src/main/kotlin/de/davis/keygo/core/security/domain/SessionError.kt index 067c80d27..20a3764bf 100644 --- a/core/security/src/main/kotlin/de/davis/keygo/core/security/domain/SessionError.kt +++ b/core/security/src/main/kotlin/de/davis/keygo/core/security/domain/SessionError.kt @@ -5,6 +5,7 @@ import de.davisalessandro.keygo.rust.KeyWrapException sealed interface SessionError { data object Locked : SessionError + data object AccountMismatch : SessionError data object WrongPassword : SessionError data class Derivation(val message: String) : SessionError data object DecryptionFailed : SessionError