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/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/.sqlx/query-91bfcc5d036046303c4782274896550fb4a7e12b595ce97fff4f18c677558c84.json b/rust/crates/keygo-server/.sqlx/query-91bfcc5d036046303c4782274896550fb4a7e12b595ce97fff4f18c677558c84.json new file mode 100644 index 000000000..2afb6d3b0 --- /dev/null +++ b/rust/crates/keygo-server/.sqlx/query-91bfcc5d036046303c4782274896550fb4a7e12b595ce97fff4f18c677558c84.json @@ -0,0 +1,28 @@ +{ + "db_name": "PostgreSQL", + "query": "select wrapped_ark from key_bundles where user_id = $1", + "describe": { + "columns": [ + { + "ordinal": 0, + "name": "wrapped_ark", + "type_info": "Bytea", + "origin": { + "Table": { + "table": "key_bundles", + "name": "wrapped_ark" + } + } + } + ], + "parameters": { + "Left": [ + "Uuid" + ] + }, + "nullable": [ + false + ] + }, + "hash": "91bfcc5d036046303c4782274896550fb4a7e12b595ce97fff4f18c677558c84" +} 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 c51ba50f8..a29a50192 100644 --- a/rust/crates/keygo-server/migrations/20261014141017_init.sql +++ b/rust/crates/keygo-server/migrations/20261014141017_init.sql @@ -5,6 +5,13 @@ 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 not null, -- nonce ‖ ct, 60 B + updated_at timestamptz not null default now() +); + create table devices ( id uuid primary key, 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/api/routes/auth/login.rs b/rust/crates/keygo-server/src/api/routes/auth/login.rs index 841c6c37f..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, 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,6 +49,7 @@ struct FinishRequest { struct FinishResponse { user_id: UserId, username: Username, + key_bundle: KeyBundle, 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,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"], key_bundle_json()); assert_eq!(state.login_states.count(), 0); } 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..6319d77d0 --- /dev/null +++ b/rust/crates/keygo-server/src/db/key_bundles.rs @@ -0,0 +1,191 @@ +use super::corrupt; +use crate::domain::{KeyBundle, SealedBlob, UserId, check_wrapped_ark}; +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(()) +} + +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) + .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(&stored).map_err(corrupt)?; + check_wrapped_ark(&wrapped_ark).map_err(corrupt)?; + + Ok(Some(KeyBundle { wrapped_ark })) +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::db::users; + 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); + } + + #[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(); + + let found = find(&mut conn, user_id).await.unwrap().unwrap(); + + assert_eq!(found.wrapped_ark.to_bytes(), WRAPPED_ARK); + } + + #[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/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..a248d05c0 --- /dev/null +++ b/rust/crates/keygo-server/src/domain/key_bundle.rs @@ -0,0 +1,7 @@ +use crate::domain::SealedBlob; +use serde::{Deserialize, Serialize}; + +#[derive(Serialize, 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 3290d9314..1d77121e3 100644 --- a/rust/crates/keygo-server/src/domain/mod.rs +++ b/rust/crates/keygo-server/src/domain/mod.rs @@ -4,6 +4,8 @@ mod ids; mod invite_code; mod invite_hash; mod invite_id; +mod key_bundle; +mod sealed_blob; mod session; mod string_enum; mod time; @@ -17,6 +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; +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 new file mode 100644 index 000000000..36050a8d0 --- /dev/null +++ b/rust/crates/keygo-server/src/domain/sealed_blob.rs @@ -0,0 +1,55 @@ +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; + +#[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) + } +} + +#[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); + } + + #[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)); + } +} diff --git a/rust/crates/keygo-server/src/service/login/finish.rs b/rust/crates/keygo-server/src/service/login/finish.rs index 6863f5ec8..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::users; -use crate::domain::{DeviceClaim, LoginId, TokenIssuer, UserId, Username}; +use crate::db::{key_bundles, users}; +use crate::domain::{DeviceClaim, KeyBundle, LoginId, 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: KeyBundle, 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, }) } @@ -69,7 +76,8 @@ mod tests { use super::*; use crate::domain::DeviceId; 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,36 @@ mod tests { assert_eq!(finished.user_id, user_id); assert_eq!(finished.username, username("ada")); + assert_eq!(finished.key_bundle.wrapped_ark.to_bytes(), WRAPPED_ARK); 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(); 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