From 7c61af44ab0c00fe55d47e9918dbd7709a6e4871 Mon Sep 17 00:00:00 2001 From: Davis Date: Wed, 4 Nov 2026 13:40:28 +0100 Subject: [PATCH 1/5] feat(server/db): add key bundle table --- .../keygo-server/migrations/20261014141017_init.sql | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/rust/crates/keygo-server/migrations/20261014141017_init.sql b/rust/crates/keygo-server/migrations/20261014141017_init.sql index c51ba50f8..5f66fb88d 100644 --- a/rust/crates/keygo-server/migrations/20261014141017_init.sql +++ b/rust/crates/keygo-server/migrations/20261014141017_init.sql @@ -5,6 +5,14 @@ create table users created_at timestamptz not null default now() ); +create table key_bundles +( + user_id uuid primary key references users on delete cascade, + wrapped_ark bytea, -- nonce ‖ ct, 60 B + updated_at timestamptz not null default now() +); +create index key_bundles_user_id_idx on key_bundles (user_id); + create table devices ( id uuid primary key, From 8406b94177e6754553668f763cc075ab321f16f8 Mon Sep 17 00:00:00 2001 From: Davis Date: Wed, 4 Nov 2026 15:38:13 +0100 Subject: [PATCH 2/5] feat(rust-core): allow Sealed to be serialized --- rust/Cargo.lock | 1 + rust/crates/keygo-core/Cargo.toml | 3 +- rust/crates/keygo-core/src/crypto/cipher.rs | 3 +- rust/crates/keygo-core/src/lib.rs | 2 +- rust/crates/keygo-core/src/sealed.rs | 126 ++++++++++++++++++ .../migrations/20261014141017_init.sql | 2 +- rust/crates/keygo-server/src/api/error.rs | 16 ++- rust/crates/keygo-server/src/domain/mod.rs | 4 + .../keygo-server/src/domain/sealed_blob.rs | 86 ++++++++++++ 9 files changed, 238 insertions(+), 5 deletions(-) create mode 100644 rust/crates/keygo-server/src/domain/sealed_blob.rs diff --git a/rust/Cargo.lock b/rust/Cargo.lock index 2fd11922e..b3709f88e 100644 --- a/rust/Cargo.lock +++ b/rust/Cargo.lock @@ -1629,6 +1629,7 @@ dependencies = [ "bcs", "hkdf 0.13.0", "serde", + "serde_json", "sha2 0.11.1", "thiserror", "uuid", diff --git a/rust/crates/keygo-core/Cargo.toml b/rust/crates/keygo-core/Cargo.toml index 97609a516..91b58a440 100644 --- a/rust/crates/keygo-core/Cargo.toml +++ b/rust/crates/keygo-core/Cargo.toml @@ -20,6 +20,7 @@ crypto = [ serde = { workspace = true, features = ["derive"] } thiserror.workspace = true uuid.workspace = true +base64.workspace = true aead = { version = "0.6.0", optional = true } aes-gcm-siv = { version = "0.12.1", optional = true } @@ -30,4 +31,4 @@ sha2 = { workspace = true, optional = true } zeroize = { workspace = true, features = ["derive"], optional = true } [dev-dependencies] -base64.workspace = true +serde_json.workspace = true diff --git a/rust/crates/keygo-core/src/crypto/cipher.rs b/rust/crates/keygo-core/src/crypto/cipher.rs index aef365b5c..f1002ce2b 100644 --- a/rust/crates/keygo-core/src/crypto/cipher.rs +++ b/rust/crates/keygo-core/src/crypto/cipher.rs @@ -1,4 +1,4 @@ -use crate::{KEY_LEN, NONCE_LEN, Sealed}; +use crate::{KEY_LEN, NONCE_LEN, Sealed, TAG_LEN}; use aead::array::typenum::Unsigned; use aead::{Aead, AeadCore, Generate, KeyInit, KeySizeUser, Nonce, Payload}; use aes_gcm_siv::Aes256GcmSiv; @@ -10,6 +10,7 @@ pub type CipherKey = aead::Key; // `sealed.rs` is compiled without the cipher, so it cannot ask it for these. const _: () = assert!(KEY_LEN == <::KeySize as Unsigned>::USIZE); const _: () = assert!(NONCE_LEN == <::NonceSize as Unsigned>::USIZE); +const _: () = assert!(TAG_LEN == <::TagSize as Unsigned>::USIZE); impl Sealed { pub(crate) fn seal(key: &CipherKey, plaintext: &[u8], aad: &[u8]) -> Result { diff --git a/rust/crates/keygo-core/src/lib.rs b/rust/crates/keygo-core/src/lib.rs index 9317035de..0e95c46e0 100644 --- a/rust/crates/keygo-core/src/lib.rs +++ b/rust/crates/keygo-core/src/lib.rs @@ -17,4 +17,4 @@ pub use crypto::*; pub use error::{CryptoError, CryptoResult}; pub use ids::{ItemId, NamespaceId, UserId, VaultId}; pub use keys::{AccountRootKey, BackupKey, ItemKey, NamespaceKey, RootKek, VaultKey}; -pub use sealed::{KEY_LEN, NONCE_LEN, Sealed}; +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 3aae70315..782472901 100644 --- a/rust/crates/keygo-core/src/sealed.rs +++ b/rust/crates/keygo-core/src/sealed.rs @@ -1,8 +1,12 @@ use crate::error::{CryptoError, CryptoResult}; +use base64::Engine; +use base64::engine::general_purpose::URL_SAFE_NO_PAD; +use serde::{Deserialize, Deserializer, Serialize, Serializer}; use std::marker::PhantomData; pub const KEY_LEN: usize = 32; pub const NONCE_LEN: usize = 12; +pub const TAG_LEN: usize = 16; pub struct Sealed { pub(crate) nonce: [u8; NONCE_LEN], @@ -38,6 +42,53 @@ impl Sealed { pub fn into_parts(self) -> (Vec, Vec) { (self.nonce.to_vec(), self.ciphertext) } + + pub fn to_bytes(&self) -> Vec { + let mut out = Vec::with_capacity(NONCE_LEN + self.ciphertext.len()); + out.extend_from_slice(&self.nonce); + out.extend_from_slice(&self.ciphertext); + out + } + + pub fn from_bytes(bytes: &[u8]) -> CryptoResult { + let (nonce, ciphertext) = + bytes + .split_first_chunk::() + .ok_or(CryptoError::InvalidNonceLength { + expected: NONCE_LEN, + got: bytes.len(), + })?; + + Ok(Self { + nonce: *nonce, + ciphertext: ciphertext.to_vec(), + content: PhantomData, + }) + } +} + +impl Serialize for Sealed { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + URL_SAFE_NO_PAD + .encode(self.to_bytes()) + .serialize(serializer) + } +} + +impl<'de, T: ?Sized> Deserialize<'de> for Sealed { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let data = String::deserialize(deserializer)?; + let data = URL_SAFE_NO_PAD + .decode(data) + .map_err(serde::de::Error::custom)?; + Self::from_bytes(&data).map_err(serde::de::Error::custom) + } } #[cfg(test)] @@ -68,4 +119,79 @@ mod tests { assert_eq!(wrapped.nonce(), [7; NONCE_LEN]); assert_eq!(wrapped.ciphertext(), [1, 2, 3]); } + + fn json(value: &str) -> String { + format!(r#""{value}""#) + } + + fn parse(value: &str) -> serde_json::Result> { + serde_json::from_str(&json(value)) + } + + #[test] + fn bytes_are_the_nonce_then_the_ciphertext() { + let sealed = Sealed::<[u8]>::from_parts(&[7; NONCE_LEN], vec![1, 2, 3]).unwrap(); + assert_eq!( + sealed.to_bytes(), + [[7; NONCE_LEN].as_slice(), &[1, 2, 3]].concat() + ); + } + + #[test] + fn bytes_round_trip() { + let bytes = [[7; NONCE_LEN].as_slice(), &[1, 2, 3]].concat(); + let sealed = Sealed::<[u8]>::from_bytes(&bytes).unwrap(); + + assert_eq!(sealed.nonce(), [7; NONCE_LEN]); + assert_eq!(sealed.ciphertext(), [1, 2, 3]); + assert_eq!(sealed.to_bytes(), bytes); + } + + #[test] + fn from_bytes_rejects_a_blob_too_short_for_a_nonce() { + assert!(matches!( + Sealed::<[u8]>::from_bytes(&[7; NONCE_LEN - 1]), + Err(CryptoError::InvalidNonceLength { + expected: NONCE_LEN, + got: 11, + }) + )); + } + + /// The wire form is API identity: changing this string breaks every client and stored blob. + #[test] + fn json_form_is_pinned() { + let sealed = Sealed::<[u8]>::from_parts(&[7; NONCE_LEN], vec![1, 2, 3]).unwrap(); + assert_eq!( + serde_json::to_string(&sealed).unwrap(), + json("BwcHBwcHBwcHBwcHAQID"), + ); + } + + #[test] + fn json_round_trip() { + let parsed = parse("BwcHBwcHBwcHBwcHAQID").unwrap(); + assert_eq!(parsed.into_parts(), (vec![7; NONCE_LEN], vec![1, 2, 3])); + } + + #[test] + fn json_uses_the_url_safe_alphabet() { + let parsed = parse("BwcHBwcHBwcHBwcH-w").unwrap(); + assert_eq!(parsed.ciphertext(), [0xfb]); + } + + #[test] + fn json_rejects_the_standard_alphabet() { + assert!(parse("BwcHBwcHBwcHBwcH+w").is_err()); + } + + #[test] + fn json_rejects_padding() { + assert!(parse("BwcHBwcHBwcHBwcH-w==").is_err()); + } + + #[test] + fn json_rejects_a_blob_too_short_for_a_nonce() { + assert!(parse("BwcHBwcHBwcHBwc").is_err()); + } } diff --git a/rust/crates/keygo-server/migrations/20261014141017_init.sql b/rust/crates/keygo-server/migrations/20261014141017_init.sql index 5f66fb88d..122b1017c 100644 --- a/rust/crates/keygo-server/migrations/20261014141017_init.sql +++ b/rust/crates/keygo-server/migrations/20261014141017_init.sql @@ -8,7 +8,7 @@ create table users create table key_bundles ( user_id uuid primary key references users on delete cascade, - wrapped_ark bytea, -- nonce ‖ ct, 60 B + wrapped_ark bytea, updated_at timestamptz not null default now() ); create index key_bundles_user_id_idx on key_bundles (user_id); diff --git a/rust/crates/keygo-server/src/api/error.rs b/rust/crates/keygo-server/src/api/error.rs index 36a05ca7d..06f6b3aaa 100644 --- a/rust/crates/keygo-server/src/api/error.rs +++ b/rust/crates/keygo-server/src/api/error.rs @@ -1,4 +1,4 @@ -use crate::domain::UsernameError; +use crate::domain::{InvalidBlob, UsernameError}; use axum::extract::rejection::JsonRejection; use axum::http::{HeaderMap, StatusCode}; use axum::response::{IntoResponse, Response}; @@ -137,6 +137,12 @@ impl HttpError for JsonRejection { } } +impl HttpError for InvalidBlob { + fn code(&self) -> ErrorCode { + ErrorCode::InvalidRequest + } +} + impl HttpError for UsernameError { fn code(&self) -> ErrorCode { ErrorCode::InvalidUsername @@ -195,6 +201,14 @@ mod tests { assert_eq!(body["code"], "invalid_request"); } + #[tokio::test] + async fn invalid_blobs_are_invalid_requests() { + let (status, body) = render(InvalidBlob).await; + + assert_eq!(status, StatusCode::BAD_REQUEST); + assert_eq!(body["code"], "invalid_request"); + } + #[tokio::test] async fn invalid_usernames_are_bad_requests() { let (status, body) = render(UsernameError::TooShort).await; diff --git a/rust/crates/keygo-server/src/domain/mod.rs b/rust/crates/keygo-server/src/domain/mod.rs index 3290d9314..66f6d6568 100644 --- a/rust/crates/keygo-server/src/domain/mod.rs +++ b/rust/crates/keygo-server/src/domain/mod.rs @@ -4,6 +4,7 @@ mod ids; mod invite_code; mod invite_hash; mod invite_id; +mod sealed_blob; mod session; mod string_enum; mod time; @@ -17,6 +18,9 @@ pub use ids::{DeviceId, LoginId, RegistrationId, SessionId, UserId, opaque_ident pub use invite_code::{InviteCode, InvitePepper}; pub use invite_hash::InviteHash; pub use invite_id::InviteId; +pub use sealed_blob::InvalidBlob; +#[allow(unused_imports)] +pub use sealed_blob::{SealedBlob, check_wrapped_ark, check_wrapped_private_keys}; pub use session::{REFRESH_TTL, RefreshToken, RevokeReason, SESSION_LIFETIME, SESSION_RETENTION}; pub use time::unix_now; pub use username::{Username, UsernameError}; diff --git a/rust/crates/keygo-server/src/domain/sealed_blob.rs b/rust/crates/keygo-server/src/domain/sealed_blob.rs new file mode 100644 index 000000000..fd8998222 --- /dev/null +++ b/rust/crates/keygo-server/src/domain/sealed_blob.rs @@ -0,0 +1,86 @@ +use keygo_core::{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; +// The plaintext's layout belongs to the client, so only the nonce and the tag are a known minimum. +const MIN_WRAPPED_PRIVATE_KEYS_LEN: usize = NONCE_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 { + NONCE_LEN + blob.ciphertext().len() +} + +pub fn check_wrapped_ark(blob: &SealedBlob) -> Result<(), InvalidBlob> { + if len(blob) == WRAPPED_ARK_LEN { + Ok(()) + } else { + Err(InvalidBlob) + } +} + +pub fn check_wrapped_private_keys(blob: &SealedBlob) -> Result<(), InvalidBlob> { + if len(blob) >= MIN_WRAPPED_PRIVATE_KEYS_LEN { + Ok(()) + } else { + Err(InvalidBlob) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn blob(len: usize) -> SealedBlob { + SealedBlob::from_bytes(&vec![7; len]).unwrap() + } + + /// Clients and stored rows depend on these sizes, so a change to the constants must fail here. + #[test] + fn blob_sizes_are_pinned() { + assert_eq!(WRAPPED_ARK_LEN, 60); + assert_eq!(MIN_WRAPPED_PRIVATE_KEYS_LEN, 28); + } + + #[test] + fn a_wrapped_ark_has_one_exact_length() { + assert_eq!(check_wrapped_ark(&blob(WRAPPED_ARK_LEN)), Ok(())); + assert_eq!( + check_wrapped_ark(&blob(WRAPPED_ARK_LEN - 1)), + Err(InvalidBlob), + ); + assert_eq!( + check_wrapped_ark(&blob(WRAPPED_ARK_LEN + 1)), + Err(InvalidBlob), + ); + } + + #[test] + fn a_wrapped_ark_cannot_be_only_a_nonce() { + assert_eq!(check_wrapped_ark(&blob(NONCE_LEN)), Err(InvalidBlob)); + } + + #[test] + fn wrapped_private_keys_need_at_least_a_nonce_and_a_tag() { + assert_eq!( + check_wrapped_private_keys(&blob(MIN_WRAPPED_PRIVATE_KEYS_LEN)), + Ok(()), + ); + assert_eq!( + check_wrapped_private_keys(&blob(MIN_WRAPPED_PRIVATE_KEYS_LEN - 1)), + Err(InvalidBlob), + ); + } + + #[test] + fn wrapped_private_keys_have_no_fixed_length() { + assert_eq!( + check_wrapped_private_keys(&blob(MIN_WRAPPED_PRIVATE_KEYS_LEN + 2 * KEY_LEN)), + Ok(()), + ); + } +} From 011c7e4e4dabdf3d7d6331faa567a857a34b1414 Mon Sep 17 00:00:00 2001 From: Davis Date: Thu, 5 Nov 2026 10:50:50 +0100 Subject: [PATCH 3/5] feat(server): add key bundle to registration --- ...ef5a6d3556ea91ceb8974b2b5219c1463f30f.json | 15 ++ .../migrations/20261014141017_init.sql | 2 +- .../src/api/routes/auth/register.rs | 150 +++++++++++++++++- .../crates/keygo-server/src/db/key_bundles.rs | 133 ++++++++++++++++ rust/crates/keygo-server/src/db/mod.rs | 1 + .../keygo-server/src/domain/key_bundle.rs | 7 + rust/crates/keygo-server/src/domain/mod.rs | 5 +- .../keygo-server/src/domain/sealed_blob.rs | 31 ---- .../src/service/registration/finish.rs | 83 +++++++++- rust/crates/keygo-server/src/testing.rs | 14 +- 10 files changed, 396 insertions(+), 45 deletions(-) create mode 100644 rust/crates/keygo-server/.sqlx/query-afec0fb1d3468cc2db852ddb984ef5a6d3556ea91ceb8974b2b5219c1463f30f.json create mode 100644 rust/crates/keygo-server/src/db/key_bundles.rs create mode 100644 rust/crates/keygo-server/src/domain/key_bundle.rs diff --git a/rust/crates/keygo-server/.sqlx/query-afec0fb1d3468cc2db852ddb984ef5a6d3556ea91ceb8974b2b5219c1463f30f.json b/rust/crates/keygo-server/.sqlx/query-afec0fb1d3468cc2db852ddb984ef5a6d3556ea91ceb8974b2b5219c1463f30f.json new file mode 100644 index 000000000..a1b9c4658 --- /dev/null +++ b/rust/crates/keygo-server/.sqlx/query-afec0fb1d3468cc2db852ddb984ef5a6d3556ea91ceb8974b2b5219c1463f30f.json @@ -0,0 +1,15 @@ +{ + "db_name": "PostgreSQL", + "query": "insert into key_bundles (user_id, wrapped_ark) values ($1, $2)", + "describe": { + "columns": [], + "parameters": { + "Left": [ + "Uuid", + "Bytea" + ] + }, + "nullable": [] + }, + "hash": "afec0fb1d3468cc2db852ddb984ef5a6d3556ea91ceb8974b2b5219c1463f30f" +} diff --git a/rust/crates/keygo-server/migrations/20261014141017_init.sql b/rust/crates/keygo-server/migrations/20261014141017_init.sql index 122b1017c..4f11c4ac5 100644 --- a/rust/crates/keygo-server/migrations/20261014141017_init.sql +++ b/rust/crates/keygo-server/migrations/20261014141017_init.sql @@ -8,7 +8,7 @@ create table users create table key_bundles ( user_id uuid primary key references users on delete cascade, - wrapped_ark bytea, + wrapped_ark bytea not null, -- nonce ‖ ct, 60 B updated_at timestamptz not null default now() ); create index key_bundles_user_id_idx on key_bundles (user_id); 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 803f13572..f604a36de 100644 --- a/rust/crates/keygo-server/src/api/routes/auth/register.rs +++ b/rust/crates/keygo-server/src/api/routes/auth/register.rs @@ -1,7 +1,7 @@ use crate::api::dpop::SingleUseDpopProof; use crate::api::routes::auth::session::Session; use crate::api::{AppState, ErrorCode, HttpError, Json, ServerResult}; -use crate::domain::{DeviceInfo, RegistrationId, UserId, Username}; +use crate::domain::{DeviceInfo, KeyBundle, RegistrationId, UserId, Username}; use crate::service::registration::{self, FinishRegistration, StartRegistration}; use axum::Router; use axum::extract::State; @@ -71,6 +71,7 @@ async fn start( struct FinishRequest { registration_id: RegistrationId, registration_upload: RegistrationUpload, + key_bundle: KeyBundle, device: DeviceInfo, } @@ -85,6 +86,7 @@ impl HttpError for registration::FinishError { match self { Self::Expired => ErrorCode::RegistrationExpired, Self::InviteInvalid => ErrorCode::InviteInvalid, + Self::InvalidKeyBundle(_) => ErrorCode::InvalidRequest, Self::Db(_) => ErrorCode::Internal, } } @@ -100,6 +102,7 @@ async fn finish( registration_upload: request.registration_upload, device_info: request.device, jkt: proof.jkt, + key_bundle: request.key_bundle, }; let finished = registration::finish(&state.db, &state.token_issuer, input).await?; @@ -118,9 +121,11 @@ mod tests { use super::*; use crate::api::error::render; use crate::testing::{ - app_state, count, create_invite, device_json, invite_only, post, post_to, post_with_proof, - proof_post, prover, register, replayable_post, send, + 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::client::ClientRegistration; use keygo_opaque::server::ServerSetup; use serde_json::{Value, json}; @@ -151,10 +156,149 @@ mod tests { json!({ "registration_id": started["registration_id"], "registration_upload": upload.to_base64(), + "key_bundle": key_bundle_json(), "device": device_json(), }) } + async fn stored_bundle(db: &PgPool, user_id: UserId) -> Option> { + sqlx::query_scalar("select wrapped_ark from key_bundles where user_id = $1") + .bind(user_id.as_uuid()) + .fetch_optional(db) + .await + .unwrap() + } + + #[sqlx::test] + async fn finish_stores_the_key_bundle_byte_for_byte(db: PgPool) { + let state = app_state(&db, &ServerSetup::generate()); + let user_id = UserId::random(); + let (client, body) = start_body("ada", user_id); + let (_, started) = post_to(state.clone(), START, body).await; + + let (status, _) = + post_with_proof(&state, &prover(), FINISH, finish_body(client, &started)).await; + + assert_eq!(status, StatusCode::CREATED); + assert_eq!( + stored_bundle(&db, user_id).await, + Some(WRAPPED_ARK.to_vec()), + ); + } + + #[sqlx::test] + async fn finish_without_a_key_bundle_keeps_the_registration(db: PgPool) { + let state = app_state(&db, &ServerSetup::generate()); + let (client, body) = start_body("ada", UserId::random()); + let (_, started) = post_to(state.clone(), START, body).await; + let mut body = finish_body(client, &started); + body.as_object_mut().unwrap().remove("key_bundle"); + + let (status, body) = post_with_proof(&state, &prover(), FINISH, body).await; + + assert_eq!(status, StatusCode::BAD_REQUEST); + assert_eq!(body["code"], "invalid_request"); + assert_eq!(count(&db, "users").await, 0); + assert_eq!(count(&db, "pending_registrations").await, 1); + } + + #[sqlx::test] + async fn finish_rejects_a_wrapped_ark_that_is_not_a_blob(db: PgPool) { + let state = app_state(&db, &ServerSetup::generate()); + let (client, body) = start_body("ada", UserId::random()); + let (_, started) = post_to(state.clone(), START, body).await; + let valid = finish_body(client, &started); + + let not_base64url = "+".repeat(80); + let too_short_for_a_nonce = URL_SAFE_NO_PAD.encode([7; 11]); + for bad in [not_base64url.as_str(), too_short_for_a_nonce.as_str()] { + let mut body = valid.clone(); + body["key_bundle"]["wrapped_ark"] = bad.into(); + + let (status, body) = post_with_proof(&state, &prover(), FINISH, body).await; + + assert_eq!(status, StatusCode::BAD_REQUEST, "{bad}"); + assert_eq!(body["code"], "invalid_request", "{bad}"); + } + assert_eq!(count(&db, "users").await, 0); + assert_eq!(count(&db, "pending_registrations").await, 1); + } + + /// Spec §4: a wrapped ARK is exactly 60 B, so a bad upload fails now and not at a later sign-in. + #[sqlx::test] + async fn finish_rejects_a_wrapped_ark_of_the_wrong_length(db: PgPool) { + let state = app_state(&db, &ServerSetup::generate()); + let (client, body) = start_body("ada", UserId::random()); + let (_, started) = post_to(state.clone(), START, body).await; + let valid = finish_body(client, &started); + + for len in [12, 59, 61] { + let mut body = valid.clone(); + body["key_bundle"]["wrapped_ark"] = URL_SAFE_NO_PAD.encode(vec![7; len]).into(); + + let (status, body) = post_with_proof(&state, &prover(), FINISH, body).await; + + assert_eq!(status, StatusCode::BAD_REQUEST, "{len} B"); + assert_eq!(body["code"], "invalid_request", "{len} B"); + assert_eq!(count(&db, "key_bundles").await, 0, "{len} B"); + assert_eq!(count(&db, "users").await, 0, "{len} B"); + } + assert_eq!(count(&db, "pending_registrations").await, 1); + } + + /// Spec §14: the server takes `user_id` from the registration state, not from this body. + #[sqlx::test] + async fn the_bundle_belongs_to_the_registered_user_whatever_the_body_says(db: PgPool) { + let state = app_state(&db, &ServerSetup::generate()); + let user_id = UserId::random(); + let (client, body) = start_body("ada", user_id); + let (_, started) = post_to(state.clone(), START, body).await; + let mut body = finish_body(client, &started); + body["key_bundle"]["user_id"] = json!(UserId::random()); + + let (status, _) = post_with_proof(&state, &prover(), FINISH, body).await; + + assert_eq!(status, StatusCode::CREATED); + assert_eq!( + stored_bundle(&db, user_id).await, + Some(WRAPPED_ARK.to_vec()), + ); + } + + #[sqlx::test] + async fn finish_cannot_plant_a_bundle_on_an_account_without_one(db: PgPool) { + let victim = UserId::random(); + let mut conn = db.acquire().await.unwrap(); + crate::db::users::insert(&mut conn, victim, &crate::testing::username("victim")) + .await + .unwrap(); + let state = app_state(&db, &ServerSetup::generate()); + let (client, body) = start_body("mallory", UserId::random()); + let (_, started) = post_to(state.clone(), START, body).await; + let mut body = finish_body(client, &started); + body["key_bundle"]["user_id"] = json!(victim); + + post_with_proof(&state, &prover(), FINISH, body).await; + + assert_eq!(stored_bundle(&db, victim).await, None); + } + + #[sqlx::test] + async fn finish_cannot_overwrite_another_users_bundle(db: PgPool) { + let setup = ServerSetup::generate(); + let victim = register(&db, &setup, "victim").await; + let state = app_state(&db, &setup); + let (client, body) = start_body("mallory", UserId::random()); + let (_, started) = post_to(state.clone(), START, body).await; + let mut body = finish_body(client, &started); + body["key_bundle"]["user_id"] = json!(victim); + body["key_bundle"]["wrapped_ark"] = URL_SAFE_NO_PAD.encode([9; 60]).into(); + + post_with_proof(&state, &prover(), FINISH, body).await; + + assert_eq!(stored_bundle(&db, victim).await, Some(WRAPPED_ARK.to_vec())); + } + #[tokio::test] async fn expired_registrations_are_bad_requests() { let (status, body) = render(registration::FinishError::Expired).await; diff --git a/rust/crates/keygo-server/src/db/key_bundles.rs b/rust/crates/keygo-server/src/db/key_bundles.rs new file mode 100644 index 000000000..47658461d --- /dev/null +++ b/rust/crates/keygo-server/src/db/key_bundles.rs @@ -0,0 +1,133 @@ +use crate::domain::{KeyBundle, UserId}; +use sqlx::PgConnection; + +pub async fn insert( + conn: &mut PgConnection, + user_id: UserId, + key_bundle: &KeyBundle, +) -> sqlx::Result<()> { + sqlx::query!( + "insert into key_bundles (user_id, wrapped_ark) values ($1, $2)", + user_id.as_uuid(), + key_bundle.wrapped_ark.to_bytes(), + ) + .execute(conn) + .await?; + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::db::users; + use crate::domain::SealedBlob; + use crate::testing::{WRAPPED_ARK, count, key_bundle, username}; + use sqlx::PgPool; + + async fn insert_user(db: &PgPool, name: &str) -> UserId { + let user_id = UserId::random(); + let mut conn = db.acquire().await.unwrap(); + users::insert(&mut conn, user_id, &username(name)) + .await + .unwrap(); + user_id + } + + #[sqlx::test] + async fn blob_is_stored_byte_for_byte(db: PgPool) { + let user_id = insert_user(&db, "ada").await; + let mut conn = db.acquire().await.unwrap(); + + insert(&mut conn, user_id, &key_bundle()).await.unwrap(); + + let stored: (uuid::Uuid, Vec) = + sqlx::query_as("select user_id, wrapped_ark from key_bundles") + .fetch_one(&db) + .await + .unwrap(); + assert_eq!(stored, (user_id.as_uuid(), WRAPPED_ARK.to_vec())); + } + + #[sqlx::test] + async fn stored_blob_decodes_to_the_same_parts(db: PgPool) { + let user_id = insert_user(&db, "ada").await; + let mut conn = db.acquire().await.unwrap(); + insert(&mut conn, user_id, &key_bundle()).await.unwrap(); + + let stored: Vec = sqlx::query_scalar("select wrapped_ark from key_bundles") + .fetch_one(&db) + .await + .unwrap(); + + let blob = SealedBlob::from_bytes(&stored).unwrap(); + assert_eq!(blob.nonce(), &WRAPPED_ARK[..12]); + assert_eq!(blob.ciphertext(), &WRAPPED_ARK[12..]); + } + + #[sqlx::test] + async fn updated_at_comes_from_the_database(db: PgPool) { + let user_id = insert_user(&db, "ada").await; + let mut conn = db.acquire().await.unwrap(); + + insert(&mut conn, user_id, &key_bundle()).await.unwrap(); + + let age: f64 = sqlx::query_scalar( + "select extract(epoch from now() - updated_at)::float8 from key_bundles", + ) + .fetch_one(&db) + .await + .unwrap(); + assert!((0.0..5.0).contains(&age), "{age}"); + } + + #[sqlx::test] + async fn a_bundle_must_hold_a_wrapped_ark(db: PgPool) { + let user_id = insert_user(&db, "ada").await; + + let err = sqlx::query("insert into key_bundles (user_id) values ($1)") + .bind(user_id.as_uuid()) + .execute(&db) + .await + .unwrap_err(); + + assert_eq!(err.as_database_error().unwrap().code().unwrap(), "23502"); + } + + #[sqlx::test] + async fn bundle_requires_a_user(db: PgPool) { + let mut conn = db.acquire().await.unwrap(); + + let err = insert(&mut conn, UserId::random(), &key_bundle()) + .await + .unwrap_err(); + + assert!(err.as_database_error().unwrap().is_foreign_key_violation()); + } + + #[sqlx::test] + async fn a_user_has_one_bundle(db: PgPool) { + let user_id = insert_user(&db, "ada").await; + let mut conn = db.acquire().await.unwrap(); + insert(&mut conn, user_id, &key_bundle()).await.unwrap(); + + let err = insert(&mut conn, user_id, &key_bundle()).await.unwrap_err(); + + assert!(err.as_database_error().unwrap().is_unique_violation()); + assert_eq!(count(&db, "key_bundles").await, 1); + } + + #[sqlx::test] + async fn bundle_is_deleted_with_its_user(db: PgPool) { + let user_id = insert_user(&db, "ada").await; + let mut conn = db.acquire().await.unwrap(); + insert(&mut conn, user_id, &key_bundle()).await.unwrap(); + + sqlx::query("delete from users where id = $1") + .bind(user_id.as_uuid()) + .execute(&db) + .await + .unwrap(); + + assert_eq!(count(&db, "key_bundles").await, 0); + } +} diff --git a/rust/crates/keygo-server/src/db/mod.rs b/rust/crates/keygo-server/src/db/mod.rs index 472be40a7..6596aa9b4 100644 --- a/rust/crates/keygo-server/src/db/mod.rs +++ b/rust/crates/keygo-server/src/db/mod.rs @@ -1,5 +1,6 @@ pub mod devices; pub mod invites; +pub mod key_bundles; pub mod opaque_records; pub mod refresh_tokens; pub mod registrations; diff --git a/rust/crates/keygo-server/src/domain/key_bundle.rs b/rust/crates/keygo-server/src/domain/key_bundle.rs new file mode 100644 index 000000000..54a734608 --- /dev/null +++ b/rust/crates/keygo-server/src/domain/key_bundle.rs @@ -0,0 +1,7 @@ +use crate::domain::SealedBlob; +use serde::Deserialize; + +#[derive(Deserialize)] +pub struct KeyBundle { + pub wrapped_ark: SealedBlob, +} diff --git a/rust/crates/keygo-server/src/domain/mod.rs b/rust/crates/keygo-server/src/domain/mod.rs index 66f6d6568..1d77121e3 100644 --- a/rust/crates/keygo-server/src/domain/mod.rs +++ b/rust/crates/keygo-server/src/domain/mod.rs @@ -4,6 +4,7 @@ mod ids; mod invite_code; mod invite_hash; mod invite_id; +mod key_bundle; mod sealed_blob; mod session; mod string_enum; @@ -18,9 +19,9 @@ pub use ids::{DeviceId, LoginId, RegistrationId, SessionId, UserId, opaque_ident pub use invite_code::{InviteCode, InvitePepper}; pub use invite_hash::InviteHash; pub use invite_id::InviteId; +pub use key_bundle::KeyBundle; pub use sealed_blob::InvalidBlob; -#[allow(unused_imports)] -pub use sealed_blob::{SealedBlob, check_wrapped_ark, check_wrapped_private_keys}; +pub use sealed_blob::{SealedBlob, check_wrapped_ark}; pub use session::{REFRESH_TTL, RefreshToken, RevokeReason, SESSION_LIFETIME, SESSION_RETENTION}; pub use time::unix_now; pub use username::{Username, UsernameError}; diff --git a/rust/crates/keygo-server/src/domain/sealed_blob.rs b/rust/crates/keygo-server/src/domain/sealed_blob.rs index fd8998222..36050a8d0 100644 --- a/rust/crates/keygo-server/src/domain/sealed_blob.rs +++ b/rust/crates/keygo-server/src/domain/sealed_blob.rs @@ -4,8 +4,6 @@ use thiserror::Error; pub type SealedBlob = Sealed<[u8]>; const WRAPPED_ARK_LEN: usize = NONCE_LEN + KEY_LEN + TAG_LEN; -// The plaintext's layout belongs to the client, so only the nonce and the tag are a known minimum. -const MIN_WRAPPED_PRIVATE_KEYS_LEN: usize = NONCE_LEN + TAG_LEN; #[derive(Debug, Clone, Copy, PartialEq, Eq, Error)] #[error("wrapped key has the wrong length")] @@ -23,14 +21,6 @@ pub fn check_wrapped_ark(blob: &SealedBlob) -> Result<(), InvalidBlob> { } } -pub fn check_wrapped_private_keys(blob: &SealedBlob) -> Result<(), InvalidBlob> { - if len(blob) >= MIN_WRAPPED_PRIVATE_KEYS_LEN { - Ok(()) - } else { - Err(InvalidBlob) - } -} - #[cfg(test)] mod tests { use super::*; @@ -43,7 +33,6 @@ mod tests { #[test] fn blob_sizes_are_pinned() { assert_eq!(WRAPPED_ARK_LEN, 60); - assert_eq!(MIN_WRAPPED_PRIVATE_KEYS_LEN, 28); } #[test] @@ -63,24 +52,4 @@ mod tests { fn a_wrapped_ark_cannot_be_only_a_nonce() { assert_eq!(check_wrapped_ark(&blob(NONCE_LEN)), Err(InvalidBlob)); } - - #[test] - fn wrapped_private_keys_need_at_least_a_nonce_and_a_tag() { - assert_eq!( - check_wrapped_private_keys(&blob(MIN_WRAPPED_PRIVATE_KEYS_LEN)), - Ok(()), - ); - assert_eq!( - check_wrapped_private_keys(&blob(MIN_WRAPPED_PRIVATE_KEYS_LEN - 1)), - Err(InvalidBlob), - ); - } - - #[test] - fn wrapped_private_keys_have_no_fixed_length() { - assert_eq!( - check_wrapped_private_keys(&blob(MIN_WRAPPED_PRIVATE_KEYS_LEN + 2 * KEY_LEN)), - Ok(()), - ); - } } diff --git a/rust/crates/keygo-server/src/service/registration/finish.rs b/rust/crates/keygo-server/src/service/registration/finish.rs index 28e0ece9f..8b4ab13c8 100644 --- a/rust/crates/keygo-server/src/service/registration/finish.rs +++ b/rust/crates/keygo-server/src/service/registration/finish.rs @@ -1,5 +1,7 @@ -use crate::db::{invites, opaque_records, registrations, users}; -use crate::domain::{DeviceInfo, RegistrationId, TokenIssuer, Username}; +use crate::db::{invites, key_bundles, opaque_records, registrations, users}; +use crate::domain::{ + DeviceInfo, InvalidBlob, KeyBundle, RegistrationId, TokenIssuer, Username, check_wrapped_ark, +}; use crate::service; use crate::service::session::Issued; use keygo_opaque::{RegistrationUpload, server}; @@ -12,6 +14,8 @@ pub enum FinishError { Expired, #[error("invite is not valid or has expired")] InviteInvalid, + #[error(transparent)] + InvalidKeyBundle(#[from] InvalidBlob), #[error("database error")] Db(#[from] sqlx::Error), } @@ -21,7 +25,7 @@ pub struct FinishRegistration { pub registration_upload: RegistrationUpload, pub device_info: DeviceInfo, pub jkt: [u8; 32], - // TODO: key bundle + pub key_bundle: KeyBundle, } pub struct Finished { @@ -39,8 +43,11 @@ pub async fn finish( registration_upload, device_info, jkt, + key_bundle, } = input; + check_wrapped_ark(&key_bundle.wrapped_ark)?; + // Pure computation, so it runs before the transaction to keep the reservation's lock short. let password_file = server::registration_finish(registration_upload); @@ -56,6 +63,7 @@ pub async fn finish( users::insert(&mut tx, pending.user_id, &pending.username).await?; opaque_records::insert(&mut tx, pending.user_id, &password_file).await?; + key_bundles::insert(&mut tx, pending.user_id, &key_bundle).await?; let device_id = service::device::create(&mut tx, pending.user_id, &device_info).await?; @@ -72,11 +80,11 @@ pub async fn finish( #[cfg(test)] mod tests { use super::*; - use crate::domain::UserId; + use crate::domain::{SealedBlob, UserId}; use crate::service::registration::{self, Signup, StartRegistration, Started}; use crate::testing::{ - JKT, PASSWORD, count, create_invite, device_info, expire, invite_only, token_issuer, - username, + JKT, PASSWORD, WRAPPED_ARK, count, create_invite, device_info, expire, invite_only, + key_bundle, token_issuer, username, }; use keygo_opaque::client::ClientRegistration; use keygo_opaque::server::ServerSetup; @@ -114,9 +122,20 @@ mod tests { registration_upload: finish.upload, device_info: device_info(), jkt: JKT, + key_bundle: key_bundle(), } } + /// Makes every bundle write fail, after the user and the OPAQUE record went in. + async fn reject_bundle_writes(db: &PgPool) { + sqlx::query( + "alter table key_bundles add constraint test_no_writes check (false) not valid", + ) + .execute(db) + .await + .unwrap(); + } + async fn user_count(db: &PgPool) -> (i64, i64, i64, i64) { ( count(db, "users").await, @@ -150,6 +169,56 @@ mod tests { assert_eq!(device.0, user_id.as_uuid()); } + #[sqlx::test] + async fn finish_stores_the_key_bundle(db: PgPool) { + let user_id = UserId::random(); + let input = started(&db, user_id, "ada").await; + + finish(&db, &token_issuer(), input).await.unwrap(); + + let stored: (Uuid, Vec) = + sqlx::query_as("select user_id, wrapped_ark from key_bundles") + .fetch_one(&db) + .await + .unwrap(); + assert_eq!(stored, (user_id.as_uuid(), WRAPPED_ARK.to_vec())); + } + + #[sqlx::test] + async fn malformed_bundle_creates_nothing_and_keeps_the_invite(db: PgPool) { + let code = create_invite(&db).await; + 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(), + }, + ..input + }; + + let err = finish(&db, &token_issuer(), input).await.err().unwrap(); + + assert!(matches!(err, FinishError::InvalidKeyBundle(_)), "{err:?}"); + assert_eq!(user_count(&db).await, (0, 0, 0, 1)); + assert_eq!(count(&db, "key_bundles").await, 0); + assert_eq!(count(&db, "invites").await, 1); + } + + /// Spec §14: "If any step fails, nothing commits and the invite stays open." + #[sqlx::test] + async fn failed_bundle_write_commits_nothing(db: PgPool) { + let code = create_invite(&db).await; + let input = started_with(&db, &invite_only(), Some(&code), UserId::random(), "ada").await; + reject_bundle_writes(&db).await; + + let err = finish(&db, &token_issuer(), input).await.err().unwrap(); + + assert!(matches!(err, FinishError::Db(_)), "{err:?}"); + assert_eq!(user_count(&db).await, (0, 0, 0, 1)); + assert_eq!(count(&db, "key_bundles").await, 0); + assert_eq!(count(&db, "sessions").await, 0); + assert_eq!(count(&db, "invites").await, 1); + } + #[sqlx::test] async fn finish_issues_a_session_for_the_new_device(db: PgPool) { let user_id = UserId::random(); @@ -188,6 +257,7 @@ mod tests { .unwrap(), device_info: device_info(), jkt: JKT, + key_bundle: key_bundle(), }; finish(&db, &token_issuer(), input).await.unwrap(); @@ -196,6 +266,7 @@ mod tests { assert!(matches!(err, FinishError::Expired), "{err:?}"); assert_eq!(user_count(&db).await, (1, 1, 1, 0)); assert_eq!(count(&db, "sessions").await, 1); + assert_eq!(count(&db, "key_bundles").await, 1); } #[sqlx::test] diff --git a/rust/crates/keygo-server/src/testing.rs b/rust/crates/keygo-server/src/testing.rs index f7ff52114..95f10ed6f 100644 --- a/rust/crates/keygo-server/src/testing.rs +++ b/rust/crates/keygo-server/src/testing.rs @@ -2,8 +2,8 @@ use crate::api::{AppState, router}; use crate::cache::{LoginStates, StepUpStates}; use crate::db::{devices, invites, sessions, users}; use crate::domain::{ - AccessTokenKey, DeviceClaim, DeviceId, DeviceInfo, InviteHash, InvitePepper, SessionId, - TokenIssuer, UserId, Username, + AccessTokenKey, DeviceClaim, DeviceId, DeviceInfo, InviteHash, InvitePepper, KeyBundle, + SealedBlob, SessionId, TokenIssuer, UserId, Username, }; use crate::service::login::{self, FinishLogin, StartLogin}; use crate::service::registration::{self, FinishRegistration, Signup, StartRegistration}; @@ -27,6 +27,8 @@ use tower::ServiceExt; pub const PASSWORD: &[u8] = b"correct horse battery staple"; pub const JKT: [u8; 32] = [7; 32]; pub const ISS: &str = "http://localhost"; +/// A well-formed wrapped ARK: nonce ‖ 32 B key ‖ tag. Only its length means anything to the server. +pub const WRAPPED_ARK: [u8; 60] = [7; 60]; pub fn token_issuer() -> TokenIssuer { TokenIssuer::new(AccessTokenKey::new(&[0; 32]), ISS) @@ -48,6 +50,13 @@ pub fn device_claim(id: Option) -> DeviceClaim { } } +pub fn key_bundle_json() -> Value { + json!({ "wrapped_ark": SealedBlob::from_bytes(&WRAPPED_ARK).unwrap() }) +} +pub fn key_bundle() -> KeyBundle { + serde_json::from_value(key_bundle_json()).unwrap() +} + pub async fn register(db: &PgPool, setup: &ServerSetup, name: &str) -> UserId { let user_id = UserId::random(); let (client, registration_request) = ClientRegistration::start(PASSWORD).unwrap(); @@ -70,6 +79,7 @@ pub async fn register(db: &PgPool, setup: &ServerSetup, name: &str) -> UserId { registration_upload: finish.upload, device_info: device_info(), jkt: JKT, + key_bundle: key_bundle(), }; registration::finish(db, &token_issuer(), input) .await From a02260ffdc46247f7a79078fc2fba3bdba041c09 Mon Sep 17 00:00:00 2001 From: Davis Date: Fri, 6 Nov 2026 15:32:09 +0100 Subject: [PATCH 4/5] feat(server): add key bundle to login --- ...c717390ea9728c96ba57cb519f253b222784c.json | 35 +++++++++ .../migrations/20261014141017_init.sql | 2 +- .../keygo-server/src/api/routes/auth/login.rs | 13 +++- .../crates/keygo-server/src/db/key_bundles.rs | 75 ++++++++++++++++++- .../keygo-server/src/domain/key_bundle.rs | 36 ++++++++- rust/crates/keygo-server/src/domain/mod.rs | 2 +- .../keygo-server/src/service/login/finish.rs | 47 +++++++++++- 7 files changed, 197 insertions(+), 13 deletions(-) create mode 100644 rust/crates/keygo-server/.sqlx/query-cadd2d220c1c0f56901e070f40bc717390ea9728c96ba57cb519f253b222784c.json diff --git a/rust/crates/keygo-server/.sqlx/query-cadd2d220c1c0f56901e070f40bc717390ea9728c96ba57cb519f253b222784c.json b/rust/crates/keygo-server/.sqlx/query-cadd2d220c1c0f56901e070f40bc717390ea9728c96ba57cb519f253b222784c.json new file mode 100644 index 000000000..aa06d83eb --- /dev/null +++ b/rust/crates/keygo-server/.sqlx/query-cadd2d220c1c0f56901e070f40bc717390ea9728c96ba57cb519f253b222784c.json @@ -0,0 +1,35 @@ +{ + "db_name": "PostgreSQL", + "query": "select wrapped_ark, extract(epoch from updated_at)::int8 as \"updated_at!\"\n from key_bundles\n where user_id = $1", + "describe": { + "columns": [ + { + "ordinal": 0, + "name": "wrapped_ark", + "type_info": "Bytea", + "origin": { + "Table": { + "table": "key_bundles", + "name": "wrapped_ark" + } + } + }, + { + "ordinal": 1, + "name": "updated_at!", + "type_info": "Int8", + "origin": "Expression" + } + ], + "parameters": { + "Left": [ + "Uuid" + ] + }, + "nullable": [ + false, + null + ] + }, + "hash": "cadd2d220c1c0f56901e070f40bc717390ea9728c96ba57cb519f253b222784c" +} diff --git a/rust/crates/keygo-server/migrations/20261014141017_init.sql b/rust/crates/keygo-server/migrations/20261014141017_init.sql index 4f11c4ac5..2a5cb2dc5 100644 --- a/rust/crates/keygo-server/migrations/20261014141017_init.sql +++ b/rust/crates/keygo-server/migrations/20261014141017_init.sql @@ -11,7 +11,7 @@ create table key_bundles wrapped_ark bytea not null, -- nonce ‖ ct, 60 B updated_at timestamptz not null default now() ); -create index key_bundles_user_id_idx on key_bundles (user_id); + create table devices ( 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 841c6c37f..37a5b9c1a 100644 --- a/rust/crates/keygo-server/src/api/routes/auth/login.rs +++ b/rust/crates/keygo-server/src/api/routes/auth/login.rs @@ -2,7 +2,7 @@ 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, LoginId, UserId, Username}; +use crate::domain::{DeviceClaim, LoginId, StoredKeyBundle, UserId, Username}; use crate::service::login::{self, FinishLogin, StartLogin}; use axum::Router; use axum::extract::State; @@ -49,6 +49,7 @@ struct FinishRequest { struct FinishResponse { user_id: UserId, username: Username, + key_bundle: StoredKeyBundle, session: Session, } @@ -71,6 +72,7 @@ async fn finish( Ok(Json(FinishResponse { user_id: finished.user_id, username: finished.username, + key_bundle: finished.key_bundle, session: finished.session.into(), })) } @@ -79,8 +81,8 @@ async fn finish( mod tests { use super::*; use crate::testing::{ - PASSWORD, app_state, count, device_json, post_to, post_with_proof, proof_post, prover, - register, replayable_post, send, + PASSWORD, app_state, count, device_json, key_bundle_json, post_to, post_with_proof, + proof_post, prover, register, replayable_post, send, }; use axum::http::StatusCode; use keygo_opaque::CredentialResponse; @@ -135,6 +137,11 @@ mod tests { assert_eq!(status, StatusCode::OK); assert_eq!(finished["user_id"], user_id.as_uuid().to_string()); assert_eq!(finished["username"], "ada"); + assert_eq!( + finished["key_bundle"]["wrapped_ark"], + key_bundle_json()["wrapped_ark"] + ); + assert!(finished["key_bundle"]["updated_at"].is_u64()); assert_eq!(state.login_states.count(), 0); } diff --git a/rust/crates/keygo-server/src/db/key_bundles.rs b/rust/crates/keygo-server/src/db/key_bundles.rs index 47658461d..3e709010c 100644 --- a/rust/crates/keygo-server/src/db/key_bundles.rs +++ b/rust/crates/keygo-server/src/db/key_bundles.rs @@ -1,4 +1,5 @@ -use crate::domain::{KeyBundle, UserId}; +use super::corrupt; +use crate::domain::{KeyBundle, SealedBlob, StoredKeyBundle, UserId, check_wrapped_ark}; use sqlx::PgConnection; pub async fn insert( @@ -16,11 +17,36 @@ pub async fn insert( Ok(()) } +pub async fn find( + conn: &mut PgConnection, + user_id: UserId, +) -> sqlx::Result> { + let Some(row) = sqlx::query!( + r#"select wrapped_ark, extract(epoch from updated_at)::int8 as "updated_at!" + from key_bundles + where user_id = $1"#, + user_id.as_uuid(), + ) + .fetch_optional(conn) + .await? + else { + return Ok(None); + }; + + // Registration admits only a well-sized wrap, so any other length is a corrupted row. + let wrapped_ark = SealedBlob::from_bytes(&row.wrapped_ark).map_err(corrupt)?; + check_wrapped_ark(&wrapped_ark).map_err(corrupt)?; + + Ok(Some(StoredKeyBundle { + bundle: KeyBundle { wrapped_ark }, + updated_at: u64::try_from(row.updated_at).map_err(corrupt)?, + })) +} + #[cfg(test)] mod tests { use super::*; use crate::db::users; - use crate::domain::SealedBlob; use crate::testing::{WRAPPED_ARK, count, key_bundle, username}; use sqlx::PgPool; @@ -130,4 +156,49 @@ mod tests { assert_eq!(count(&db, "key_bundles").await, 0); } + + #[sqlx::test] + async fn find_returns_the_stored_bundle(db: PgPool) { + let user_id = insert_user(&db, "ada").await; + let mut conn = db.acquire().await.unwrap(); + insert(&mut conn, user_id, &key_bundle()).await.unwrap(); + sqlx::query("update key_bundles set updated_at = to_timestamp(1700000000)") + .execute(&db) + .await + .unwrap(); + + let found = find(&mut conn, user_id).await.unwrap().unwrap(); + + assert_eq!(found.bundle.wrapped_ark.to_bytes(), WRAPPED_ARK); + assert_eq!(found.updated_at, 1_700_000_000); + } + + #[sqlx::test] + async fn find_ignores_other_users_bundles(db: PgPool) { + let ada = insert_user(&db, "ada").await; + let bob = insert_user(&db, "bob").await; + let mut conn = db.acquire().await.unwrap(); + insert(&mut conn, ada, &key_bundle()).await.unwrap(); + + assert!(find(&mut conn, bob).await.unwrap().is_none()); + } + + #[sqlx::test] + async fn missized_bundle_is_corrupt(db: PgPool) { + // 11 B is too short for a nonce, 59 B and 61 B are a sealed blob but not a wrapped ARK. + for len in [11, 59, 61] { + let user_id = insert_user(&db, &format!("ada{len}")).await; + sqlx::query("insert into key_bundles (user_id, wrapped_ark) values ($1, $2)") + .bind(user_id.as_uuid()) + .bind(vec![7u8; len]) + .execute(&db) + .await + .unwrap(); + let mut conn = db.acquire().await.unwrap(); + + let err = find(&mut conn, user_id).await.err().unwrap(); + + assert!(matches!(err, sqlx::Error::Decode(_)), "{len} B"); + } + } } diff --git a/rust/crates/keygo-server/src/domain/key_bundle.rs b/rust/crates/keygo-server/src/domain/key_bundle.rs index 54a734608..7dbdda956 100644 --- a/rust/crates/keygo-server/src/domain/key_bundle.rs +++ b/rust/crates/keygo-server/src/domain/key_bundle.rs @@ -1,7 +1,39 @@ use crate::domain::SealedBlob; -use serde::Deserialize; +use serde::{Deserialize, Serialize}; -#[derive(Deserialize)] +#[derive(Serialize, Deserialize)] pub struct KeyBundle { pub wrapped_ark: SealedBlob, } + +#[derive(Serialize)] +pub struct StoredKeyBundle { + #[serde(flatten)] + pub bundle: KeyBundle, + pub updated_at: u64, +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::testing::{WRAPPED_ARK, key_bundle_json}; + use serde_json::json; + + #[test] + fn stored_bundle_serializes_flat() { + let stored = StoredKeyBundle { + bundle: KeyBundle { + wrapped_ark: SealedBlob::from_bytes(&WRAPPED_ARK).unwrap(), + }, + updated_at: 1_700_000_000, + }; + + assert_eq!( + serde_json::to_value(&stored).unwrap(), + json!({ + "wrapped_ark": key_bundle_json()["wrapped_ark"], + "updated_at": 1_700_000_000, + }), + ); + } +} diff --git a/rust/crates/keygo-server/src/domain/mod.rs b/rust/crates/keygo-server/src/domain/mod.rs index 1d77121e3..856a79e3f 100644 --- a/rust/crates/keygo-server/src/domain/mod.rs +++ b/rust/crates/keygo-server/src/domain/mod.rs @@ -19,7 +19,7 @@ pub use ids::{DeviceId, LoginId, RegistrationId, SessionId, UserId, opaque_ident pub use invite_code::{InviteCode, InvitePepper}; pub use invite_hash::InviteHash; pub use invite_id::InviteId; -pub use key_bundle::KeyBundle; +pub use key_bundle::{KeyBundle, StoredKeyBundle}; pub use sealed_blob::InvalidBlob; pub use sealed_blob::{SealedBlob, check_wrapped_ark}; pub use session::{REFRESH_TTL, RefreshToken, RevokeReason, SESSION_LIFETIME, SESSION_RETENTION}; diff --git a/rust/crates/keygo-server/src/service/login/finish.rs b/rust/crates/keygo-server/src/service/login/finish.rs index 6863f5ec8..3a9abfc2e 100644 --- a/rust/crates/keygo-server/src/service/login/finish.rs +++ b/rust/crates/keygo-server/src/service/login/finish.rs @@ -1,6 +1,6 @@ use crate::cache::LoginStates; -use crate::db::users; -use crate::domain::{DeviceClaim, LoginId, TokenIssuer, UserId, Username}; +use crate::db::{key_bundles, users}; +use crate::domain::{DeviceClaim, LoginId, StoredKeyBundle, TokenIssuer, UserId, Username}; use crate::service; use crate::service::handshake::{self, Error}; use crate::service::session::Issued; @@ -18,6 +18,7 @@ pub struct FinishLogin { pub struct Finished { pub user_id: UserId, pub username: Username, + pub key_bundle: StoredKeyBundle, pub session: Issued, } @@ -51,6 +52,11 @@ pub async fn finish( let username = users::find_username(&mut tx, user_id) .await? .ok_or(OpaqueError::InvalidLogin)?; + // Registration stores the bundle together with the user, so a missing one is a broken account. + // The caller has proven the password, so it must not answer like a wrong one. + let key_bundle = key_bundles::find(&mut tx, user_id) + .await? + .ok_or(sqlx::Error::RowNotFound)?; let device_id = service::device::attach_or_create(&mut tx, user_id, device).await?; let issued = service::session::issue(&mut tx, token_issuer, user_id, device_id, &jkt).await?; @@ -60,6 +66,7 @@ pub async fn finish( Ok(Finished { user_id, username, + key_bundle, session: issued, }) } @@ -67,9 +74,10 @@ pub async fn finish( #[cfg(test)] mod tests { use super::*; - use crate::domain::DeviceId; + use crate::domain::{DeviceId, unix_now}; use crate::testing::{ - PASSWORD, device_claim, finish_login, register, start_login, token_issuer, username, + PASSWORD, WRAPPED_ARK, count, device_claim, finish_login, register, start_login, + token_issuer, username, }; use keygo_opaque::server::ServerSetup; use std::time::Duration; @@ -106,9 +114,40 @@ mod tests { assert_eq!(finished.user_id, user_id); assert_eq!(finished.username, username("ada")); + assert_eq!( + finished.key_bundle.bundle.wrapped_ark.to_bytes(), + WRAPPED_ARK + ); + assert!(unix_now().abs_diff(finished.key_bundle.updated_at) < 60); assert_eq!(login_states.count(), 0); } + #[sqlx::test] + async fn missing_bundle_fails_without_issuing_a_session(db: PgPool) { + let login_states = LoginStates::new(); + let setup = ServerSetup::generate(); + register(&db, &setup, "ada").await; + let (client, started) = start_login(&db, &login_states, &setup, "ada").await; + let sessions = count(&db, "sessions").await; + sqlx::query("delete from key_bundles") + .execute(&db) + .await + .unwrap(); + + let err = finish( + &db, + &token_issuer(), + &login_states, + finish_login(client, started, None), + ) + .await + .err() + .unwrap(); + + assert!(matches!(err, Error::Db(_)), "{err:?}"); + assert_eq!(count(&db, "sessions").await, sessions); + } + #[sqlx::test] async fn login_cannot_be_finished_twice(db: PgPool) { let login_states = LoginStates::new(); From 141c401925eaa3c9876e1ed68997c1cf6d33b9c5 Mon Sep 17 00:00:00 2001 From: Davis Wolfermann Date: Sat, 7 Nov 2026 22:54:18 +0100 Subject: [PATCH 5/5] refactor(server): drop key bundle updated_at and allow base64 in keygo-core --- .github/workflows/ci.yaml | 2 +- ...550fb4a7e12b595ce97fff4f18c677558c84.json} | 13 ++------ .../migrations/20261014141017_init.sql | 1 - .../keygo-server/src/api/routes/auth/login.rs | 10 ++---- .../crates/keygo-server/src/db/key_bundles.rs | 27 ++++------------ .../keygo-server/src/domain/key_bundle.rs | 32 ------------------- rust/crates/keygo-server/src/domain/mod.rs | 2 +- .../keygo-server/src/service/login/finish.rs | 12 +++---- 8 files changed, 19 insertions(+), 80 deletions(-) rename rust/crates/keygo-server/.sqlx/{query-cadd2d220c1c0f56901e070f40bc717390ea9728c96ba57cb519f253b222784c.json => query-91bfcc5d036046303c4782274896550fb4a7e12b595ce97fff4f18c677558c84.json} (51%) diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml index bd6cad2e1..f1e7007e3 100644 --- a/.github/workflows/ci.yaml +++ b/.github/workflows/ci.yaml @@ -64,7 +64,7 @@ jobs: run: | cargo clippy -p keygo-core --all-targets -- -D warnings deps=$(cargo tree -p keygo-core -e normal --depth 1 --prefix none | tail -n +2 | cut -d' ' -f1 | sort | xargs) - [ "$deps" = "serde thiserror uuid" ] || { echo "unexpected keygo-core deps: $deps" >&2; exit 1; } + [ "$deps" = "base64 serde thiserror uuid" ] || { echo "unexpected keygo-core deps: $deps" >&2; exit 1; } - name: keygo-server holds no crypto or client code run: | # Proves the pattern below still matches, so renaming the feature can't silently disable it. diff --git a/rust/crates/keygo-server/.sqlx/query-cadd2d220c1c0f56901e070f40bc717390ea9728c96ba57cb519f253b222784c.json b/rust/crates/keygo-server/.sqlx/query-91bfcc5d036046303c4782274896550fb4a7e12b595ce97fff4f18c677558c84.json similarity index 51% rename from rust/crates/keygo-server/.sqlx/query-cadd2d220c1c0f56901e070f40bc717390ea9728c96ba57cb519f253b222784c.json rename to rust/crates/keygo-server/.sqlx/query-91bfcc5d036046303c4782274896550fb4a7e12b595ce97fff4f18c677558c84.json index aa06d83eb..2afb6d3b0 100644 --- a/rust/crates/keygo-server/.sqlx/query-cadd2d220c1c0f56901e070f40bc717390ea9728c96ba57cb519f253b222784c.json +++ b/rust/crates/keygo-server/.sqlx/query-91bfcc5d036046303c4782274896550fb4a7e12b595ce97fff4f18c677558c84.json @@ -1,6 +1,6 @@ { "db_name": "PostgreSQL", - "query": "select wrapped_ark, extract(epoch from updated_at)::int8 as \"updated_at!\"\n from key_bundles\n where user_id = $1", + "query": "select wrapped_ark from key_bundles where user_id = $1", "describe": { "columns": [ { @@ -13,12 +13,6 @@ "name": "wrapped_ark" } } - }, - { - "ordinal": 1, - "name": "updated_at!", - "type_info": "Int8", - "origin": "Expression" } ], "parameters": { @@ -27,9 +21,8 @@ ] }, "nullable": [ - false, - null + false ] }, - "hash": "cadd2d220c1c0f56901e070f40bc717390ea9728c96ba57cb519f253b222784c" + "hash": "91bfcc5d036046303c4782274896550fb4a7e12b595ce97fff4f18c677558c84" } diff --git a/rust/crates/keygo-server/migrations/20261014141017_init.sql b/rust/crates/keygo-server/migrations/20261014141017_init.sql index 2a5cb2dc5..a29a50192 100644 --- a/rust/crates/keygo-server/migrations/20261014141017_init.sql +++ b/rust/crates/keygo-server/migrations/20261014141017_init.sql @@ -12,7 +12,6 @@ create table key_bundles updated_at timestamptz not null default now() ); - create table devices ( id uuid primary key, 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 37a5b9c1a..5e82007d3 100644 --- a/rust/crates/keygo-server/src/api/routes/auth/login.rs +++ b/rust/crates/keygo-server/src/api/routes/auth/login.rs @@ -2,7 +2,7 @@ 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, LoginId, StoredKeyBundle, UserId, Username}; +use crate::domain::{DeviceClaim, KeyBundle, LoginId, UserId, Username}; use crate::service::login::{self, FinishLogin, StartLogin}; use axum::Router; use axum::extract::State; @@ -49,7 +49,7 @@ struct FinishRequest { struct FinishResponse { user_id: UserId, username: Username, - key_bundle: StoredKeyBundle, + key_bundle: KeyBundle, session: Session, } @@ -137,11 +137,7 @@ mod tests { assert_eq!(status, StatusCode::OK); assert_eq!(finished["user_id"], user_id.as_uuid().to_string()); assert_eq!(finished["username"], "ada"); - assert_eq!( - finished["key_bundle"]["wrapped_ark"], - key_bundle_json()["wrapped_ark"] - ); - assert!(finished["key_bundle"]["updated_at"].is_u64()); + assert_eq!(finished["key_bundle"], key_bundle_json()); assert_eq!(state.login_states.count(), 0); } diff --git a/rust/crates/keygo-server/src/db/key_bundles.rs b/rust/crates/keygo-server/src/db/key_bundles.rs index 3e709010c..6319d77d0 100644 --- a/rust/crates/keygo-server/src/db/key_bundles.rs +++ b/rust/crates/keygo-server/src/db/key_bundles.rs @@ -1,5 +1,5 @@ use super::corrupt; -use crate::domain::{KeyBundle, SealedBlob, StoredKeyBundle, UserId, check_wrapped_ark}; +use crate::domain::{KeyBundle, SealedBlob, UserId, check_wrapped_ark}; use sqlx::PgConnection; pub async fn insert( @@ -17,14 +17,9 @@ pub async fn insert( Ok(()) } -pub async fn find( - conn: &mut PgConnection, - user_id: UserId, -) -> sqlx::Result> { - let Some(row) = sqlx::query!( - r#"select wrapped_ark, extract(epoch from updated_at)::int8 as "updated_at!" - from key_bundles - where user_id = $1"#, +pub async fn find(conn: &mut PgConnection, user_id: UserId) -> sqlx::Result> { + let Some(stored) = sqlx::query_scalar!( + "select wrapped_ark from key_bundles where user_id = $1", user_id.as_uuid(), ) .fetch_optional(conn) @@ -34,13 +29,10 @@ pub async fn find( }; // Registration admits only a well-sized wrap, so any other length is a corrupted row. - let wrapped_ark = SealedBlob::from_bytes(&row.wrapped_ark).map_err(corrupt)?; + let wrapped_ark = SealedBlob::from_bytes(&stored).map_err(corrupt)?; check_wrapped_ark(&wrapped_ark).map_err(corrupt)?; - Ok(Some(StoredKeyBundle { - bundle: KeyBundle { wrapped_ark }, - updated_at: u64::try_from(row.updated_at).map_err(corrupt)?, - })) + Ok(Some(KeyBundle { wrapped_ark })) } #[cfg(test)] @@ -162,15 +154,10 @@ mod tests { let user_id = insert_user(&db, "ada").await; let mut conn = db.acquire().await.unwrap(); insert(&mut conn, user_id, &key_bundle()).await.unwrap(); - sqlx::query("update key_bundles set updated_at = to_timestamp(1700000000)") - .execute(&db) - .await - .unwrap(); let found = find(&mut conn, user_id).await.unwrap().unwrap(); - assert_eq!(found.bundle.wrapped_ark.to_bytes(), WRAPPED_ARK); - assert_eq!(found.updated_at, 1_700_000_000); + assert_eq!(found.wrapped_ark.to_bytes(), WRAPPED_ARK); } #[sqlx::test] diff --git a/rust/crates/keygo-server/src/domain/key_bundle.rs b/rust/crates/keygo-server/src/domain/key_bundle.rs index 7dbdda956..a248d05c0 100644 --- a/rust/crates/keygo-server/src/domain/key_bundle.rs +++ b/rust/crates/keygo-server/src/domain/key_bundle.rs @@ -5,35 +5,3 @@ use serde::{Deserialize, Serialize}; pub struct KeyBundle { pub wrapped_ark: SealedBlob, } - -#[derive(Serialize)] -pub struct StoredKeyBundle { - #[serde(flatten)] - pub bundle: KeyBundle, - pub updated_at: u64, -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::testing::{WRAPPED_ARK, key_bundle_json}; - use serde_json::json; - - #[test] - fn stored_bundle_serializes_flat() { - let stored = StoredKeyBundle { - bundle: KeyBundle { - wrapped_ark: SealedBlob::from_bytes(&WRAPPED_ARK).unwrap(), - }, - updated_at: 1_700_000_000, - }; - - assert_eq!( - serde_json::to_value(&stored).unwrap(), - json!({ - "wrapped_ark": key_bundle_json()["wrapped_ark"], - "updated_at": 1_700_000_000, - }), - ); - } -} diff --git a/rust/crates/keygo-server/src/domain/mod.rs b/rust/crates/keygo-server/src/domain/mod.rs index 856a79e3f..1d77121e3 100644 --- a/rust/crates/keygo-server/src/domain/mod.rs +++ b/rust/crates/keygo-server/src/domain/mod.rs @@ -19,7 +19,7 @@ pub use ids::{DeviceId, LoginId, RegistrationId, SessionId, UserId, opaque_ident pub use invite_code::{InviteCode, InvitePepper}; pub use invite_hash::InviteHash; pub use invite_id::InviteId; -pub use key_bundle::{KeyBundle, StoredKeyBundle}; +pub use key_bundle::KeyBundle; pub use sealed_blob::InvalidBlob; pub use sealed_blob::{SealedBlob, check_wrapped_ark}; pub use session::{REFRESH_TTL, RefreshToken, RevokeReason, SESSION_LIFETIME, SESSION_RETENTION}; diff --git a/rust/crates/keygo-server/src/service/login/finish.rs b/rust/crates/keygo-server/src/service/login/finish.rs index 3a9abfc2e..5cb446d74 100644 --- a/rust/crates/keygo-server/src/service/login/finish.rs +++ b/rust/crates/keygo-server/src/service/login/finish.rs @@ -1,6 +1,6 @@ use crate::cache::LoginStates; use crate::db::{key_bundles, users}; -use crate::domain::{DeviceClaim, LoginId, StoredKeyBundle, TokenIssuer, UserId, Username}; +use crate::domain::{DeviceClaim, KeyBundle, LoginId, TokenIssuer, UserId, Username}; use crate::service; use crate::service::handshake::{self, Error}; use crate::service::session::Issued; @@ -18,7 +18,7 @@ pub struct FinishLogin { pub struct Finished { pub user_id: UserId, pub username: Username, - pub key_bundle: StoredKeyBundle, + pub key_bundle: KeyBundle, pub session: Issued, } @@ -74,7 +74,7 @@ pub async fn finish( #[cfg(test)] mod tests { use super::*; - use crate::domain::{DeviceId, unix_now}; + use crate::domain::DeviceId; use crate::testing::{ PASSWORD, WRAPPED_ARK, count, device_claim, finish_login, register, start_login, token_issuer, username, @@ -114,11 +114,7 @@ mod tests { assert_eq!(finished.user_id, user_id); assert_eq!(finished.username, username("ada")); - assert_eq!( - finished.key_bundle.bundle.wrapped_ark.to_bytes(), - WRAPPED_ARK - ); - assert!(unix_now().abs_diff(finished.key_bundle.updated_at) < 60); + assert_eq!(finished.key_bundle.wrapped_ark.to_bytes(), WRAPPED_ARK); assert_eq!(login_states.count(), 0); }