From dd2e605e888afddf51d49e651f4d89effc51fa0e Mon Sep 17 00:00:00 2001 From: John Coffey Date: Wed, 18 Nov 2026 19:57:46 -0700 Subject: [PATCH] Passkeys: storage and inbuxa:Passkey management (#334) First part of passkeys (docs/spec/features/passkeys.md). An account's passkeys are kept in the fork's own data under N, apart from the account's credentials, so a server that doesn't know passkeys still reads every account. inbuxa:Passkey/get lists an account's passkeys; the request's accountId names the account. /set create starts a registration: a pending passkey and the registration page's URL, with a ticket good for 10 minutes and returned once. An account has at most 10, pending ones included. Update changes the name only. Destroy removes one; removing a registered one moves the account's credential version, so every session ends, as after a password change. Deleting an account removes its passkeys. People manage their own with the new sysPasskeyGet, sysPasskeyCreate, sysPasskeyUpdate and sysPasskeyDestroy permissions, granted to users, tenant administrators and server administrators by default. Reaching another account's passkeys also takes sysAccountUpdate, an account in reach, and no permission on it the caller lacks. Every change is in the audit log, named by the passkey's name. The registration page (PK-6), sign-in and the settings follow in their own PRs. The spec now has the page ask for the password or an existing passkey before it registers a new one (PK-8), and notes that the console needs its own passkeys panel. --- crates/common/src/auth/access_token.rs | 9 + crates/common/src/auth/permissions.rs | 6 + crates/features/src/lib.rs | 1 + crates/features/src/passkey/mod.rs | 515 ++++++++++++++++++ .../jmap-proto/src/object/inbuxa_passkey.rs | 183 +++++++ crates/jmap-proto/src/object/mod.rs | 1 + crates/jmap-proto/src/references/eval.rs | 3 + crates/jmap-proto/src/references/resolve.rs | 2 + crates/jmap-proto/src/request/method.rs | 8 + crates/jmap-proto/src/request/mod.rs | 4 + crates/jmap-proto/src/request/parser.rs | 15 + crates/jmap-proto/src/response/mod.rs | 17 + crates/jmap/src/api/auth.rs | 11 + crates/jmap/src/api/request.rs | 26 + crates/jmap/src/changes/get.rs | 1 + crates/jmap/src/inbuxa/audit.rs | 14 + crates/jmap/src/inbuxa/mod.rs | 1 + crates/jmap/src/inbuxa/passkey.rs | 423 ++++++++++++++ crates/migration/src/fork_subspaces.rs | 2 + crates/registry/src/schema/enums.rs | 5 + crates/registry/src/schema/enums_impl.rs | 14 +- .../src/task_manager/destroy_account.rs | 3 + docs/spec/features/passkeys.md | 43 +- resources/privacy/catalog.toml | 15 + resources/schema/schema.json.gz | Bin 155903 -> 155947 bytes resources/schema/schema.json.sha256 | 2 +- tests/src/system/mod.rs | 1 + tests/src/system/passkeys.rs | 251 +++++++++ 28 files changed, 1560 insertions(+), 16 deletions(-) create mode 100644 crates/features/src/passkey/mod.rs create mode 100644 crates/jmap-proto/src/object/inbuxa_passkey.rs create mode 100644 crates/jmap/src/inbuxa/passkey.rs create mode 100644 tests/src/system/passkeys.rs diff --git a/crates/common/src/auth/access_token.rs b/crates/common/src/auth/access_token.rs index 04ec9168..b18b3283 100644 --- a/crates/common/src/auth/access_token.rs +++ b/crates/common/src/auth/access_token.rs @@ -309,6 +309,15 @@ impl Server { } } + // inbuxa: passkeys spec, PK-15: removing a passkey moves the + // credential version, as a password change does + let credential_version = inbuxa_features::passkey::credential_version( + credential_version, + inbuxa_features::passkey::epoch(self.store(), account_id) + .await + .caused_by(trc::location!())?, + ); + Ok(AccessTokenInner { concurrent_imap_requests: self .core diff --git a/crates/common/src/auth/permissions.rs b/crates/common/src/auth/permissions.rs index 60e60d63..2c7a3db9 100644 --- a/crates/common/src/auth/permissions.rs +++ b/crates/common/src/auth/permissions.rs @@ -445,6 +445,12 @@ impl Default for DefaultPermissions { { default.user.push(permission); default.superuser.push(permission); + } else if name.starts_with("sysPasskey") { + // inbuxa: passkeys spec: people manage their own, + // and administrators remove them for recovery (PK-16) + default.user.push(permission); + default.tenant.push(permission); + default.superuser.push(permission); } else if name.starts_with("sysDomain") || name.starts_with("sysDkimSignature") || name.starts_with("sysAcmeProvider") diff --git a/crates/features/src/lib.rs b/crates/features/src/lib.rs index 4916a5b7..77171371 100644 --- a/crates/features/src/lib.rs +++ b/crates/features/src/lib.rs @@ -29,6 +29,7 @@ pub mod lock; pub mod mailflow; pub mod masked_email; pub mod migration; // inbuxa: migrations into this server (not a rebuild) +pub mod passkey; // inbuxa: passkeys (not a rebuild) pub mod privacy; pub mod relay; // inbuxa: the downstream side of inbuxa Relay (not a rebuild) pub mod scheduled_reports; // inbuxa: scheduled reports and the weekly digest (not a rebuild) diff --git a/crates/features/src/passkey/mod.rs b/crates/features/src/passkey/mod.rs new file mode 100644 index 00000000..5011b704 --- /dev/null +++ b/crates/features/src/passkey/mod.rs @@ -0,0 +1,515 @@ +/* + * SPDX-FileCopyrightText: 2026 Coffey Labs LLC + * + * SPDX-License-Identifier: AGPL-3.0-only + */ + +//! Passkeys (passkeys spec, inbuxa-server #334): what the server keeps for +//! each one, in the fork's subspace (`store::SUBSPACE_INBUXA`). Every key +//! starts with `N`, then one byte names the kind: +//! +//! - `p` + account id + number: the passkey's `Passkey` record. +//! - `c` + credential id: the account and number it belongs to, so sign-in +//! finds a passkey without loading accounts. +//! - `h` + account id: the account's user handle, 32 random bytes the +//! authenticator keeps as the user id. +//! - `u` + user handle: the account it belongs to. +//! - `t` + SHA-256 of a registration ticket: the pending passkey it opens +//! (PK-6). +//! - `e` + account id: how many times the account's passkeys were removed. +//! It's part of the account's credential version, so a removal ends every +//! session (PK-15). +//! +//! Kept apart from the account's credentials, so a server that doesn't know +//! passkeys still reads every account. + +use serde::{Deserialize as SerdeDeserialize, Serialize as SerdeSerialize}; +use sha2::{Digest, Sha256}; +use store::{ + Deserialize, IterateParams, SUBSPACE_INBUXA, Store, ValueKey, + write::{AnyClass, BatchBuilder, ValueClass, assert::AssertValue}, +}; +use trc::AddContext; + +const FEATURE: u8 = b'N'; +const KIND_PASSKEY: u8 = b'p'; +const KIND_CREDENTIAL: u8 = b'c'; +const KIND_HANDLE: u8 = b'h'; +const KIND_HANDLE_ACCOUNT: u8 = b'u'; +const KIND_TICKET: u8 = b't'; +const KIND_EPOCH: u8 = b'e'; + +/// Passkeys per account, pending ones included (PK-5). +pub const MAX_PASSKEYS: usize = 10; +/// How long a registration ticket stays good (PK-6). +pub const TICKET_SECONDS: u64 = 600; +/// The longest name (PK-5). +pub const MAX_NAME: usize = 64; +/// The length of a user handle. +pub const HANDLE_LEN: usize = 32; +const CREATE_ATTEMPTS: usize = 5; + +#[derive(Debug, Clone, Copy, PartialEq, Eq, SerdeSerialize, SerdeDeserialize)] +#[serde(rename_all = "camelCase")] +pub enum State { + /// Made, waiting for the browser part of registration. + Pending, + /// Registered and usable for sign-in. + Active, +} + +impl State { + pub fn as_str(&self) -> &'static str { + match self { + State::Pending => "pending", + State::Active => "active", + } + } +} + +/// One passkey. +#[derive(Debug, Clone, PartialEq, Eq, SerdeSerialize, SerdeDeserialize)] +#[serde(rename_all = "camelCase")] +pub struct Passkey { + pub account_id: u32, + /// Unique within the account. + pub number: u32, + pub name: String, + pub state: State, + /// For a pending passkey, when its ticket runs out. + #[serde(default)] + pub ticket_expires: u64, + /// The relying-party id it was registered for (PK-3, PK-4). + #[serde(default)] + pub rp_id: String, + /// The authenticator's credential id. + #[serde(default)] + pub credential_id: Vec, + /// The public key, as COSE. + #[serde(default)] + pub public_key: Vec, + #[serde(default)] + pub sign_count: u32, + #[serde(default)] + pub transports: Vec, + /// The authenticator said the key is synced. + #[serde(default)] + pub backed_up: bool, + #[serde(default)] + pub aaguid: Vec, + /// When it was made: for a pending one, when registration started. + pub created_at: u64, + #[serde(default)] + pub last_used_at: Option, +} + +impl Passkey { + /// The JMAP id: the account id over the number. + pub fn id(&self) -> u64 { + passkey_id(self.account_id, self.number) + } + + pub fn is_expired(&self, now: u64) -> bool { + self.state == State::Pending && self.ticket_expires <= now + } +} + +/// A passkey's JMAP id. +pub fn passkey_id(account_id: u32, number: u32) -> u64 { + ((account_id as u64) << 32) | number as u64 +} + +/// The account id and number in a JMAP id. +pub fn split_id(id: u64) -> (u32, u32) { + ((id >> 32) as u32, id as u32) +} + +/// A name as a person typed it, trimmed, or why it can't be used. +pub fn clean_name(name: &str) -> Result { + let name = name.trim(); + if name.is_empty() { + Err("Give the passkey a name, such as the device it's on.") + } else if name.chars().count() > MAX_NAME { + Err("At most 64 characters.") + } else if name.chars().any(char::is_control) { + Err("A name can't hold control characters.") + } else { + Ok(name.to_string()) + } +} + +/// What a ticket is stored under. +pub fn ticket_hash(ticket: &str) -> [u8; 32] { + Sha256::digest(ticket.as_bytes()).into() +} + +struct Json(T); + +impl Deserialize for Json { + fn deserialize(bytes: &[u8]) -> trc::Result { + serde_json::from_slice(bytes).map(Json).map_err(|err| { + trc::StoreEvent::DataCorruption + .into_err() + .details("Invalid passkey") + .reason(err) + }) + } +} + +fn to_json(passkey: &Passkey) -> trc::Result> { + serde_json::to_vec(passkey).map_err(|err| { + trc::StoreEvent::UnexpectedError + .into_err() + .details("Failed to serialize a passkey") + .reason(err) + }) +} + +struct Raw(Vec); + +impl Deserialize for Raw { + fn deserialize(bytes: &[u8]) -> trc::Result { + Ok(Raw(bytes.to_vec())) + } +} + +fn class(kind: u8, rest: &[u8]) -> ValueClass { + let mut key = Vec::with_capacity(2 + rest.len()); + key.push(FEATURE); + key.push(kind); + key.extend_from_slice(rest); + ValueClass::Any(AnyClass { + subspace: SUBSPACE_INBUXA, + key, + }) +} + +fn key(kind: u8, rest: &[u8]) -> ValueKey { + ValueKey::from(class(kind, rest)) +} + +fn pair(account_id: u32, number: u32) -> [u8; 8] { + let mut out = [0u8; 8]; + out[..4].copy_from_slice(&account_id.to_be_bytes()); + out[4..].copy_from_slice(&number.to_be_bytes()); + out +} + +fn unpair(bytes: &[u8]) -> Option<(u32, u32)> { + let account = u32::from_be_bytes(bytes.get(..4)?.try_into().ok()?); + let number = u32::from_be_bytes(bytes.get(4..8)?.try_into().ok()?); + Some((account, number)) +} + +/// One passkey, expired pending ones included. +pub async fn get(data: &Store, account_id: u32, number: u32) -> trc::Result> { + Ok(data + .get_value::>(key(KIND_PASSKEY, &pair(account_id, number))) + .await + .caused_by(trc::location!())? + .map(|Json(passkey)| passkey)) +} + +/// Every passkey of the account, expired pending ones included, by number. +pub async fn all(data: &Store, account_id: u32) -> trc::Result> { + let mut out = Vec::new(); + data.iterate( + IterateParams::new( + key(KIND_PASSKEY, &pair(account_id, 0)), + key(KIND_PASSKEY, &pair(account_id, u32::MAX)), + ), + |_, value| { + if let Ok(Json(passkey)) = Json::::deserialize(value) { + out.push(passkey); + } + Ok(true) + }, + ) + .await + .caused_by(trc::location!())?; + out.sort_by_key(|p| p.number); + Ok(out) +} + +/// Every passkey of the account a person can see: active ones, and pending +/// ones whose ticket is still good. Expired pending ones are removed. +pub async fn list(data: &Store, account_id: u32, now: u64) -> trc::Result> { + let mut out = Vec::new(); + for passkey in all(data, account_id).await? { + if passkey.is_expired(now) { + remove(data, &passkey).await?; + } else { + out.push(passkey); + } + } + Ok(out) +} + +pub enum Created { + Pending(Passkey), + Full, +} + +/// Starts registering a passkey (PK-5): a pending record opened by `ticket`. +pub async fn create_pending( + data: &Store, + account_id: u32, + name: String, + ticket: &str, + now: u64, +) -> trc::Result { + for attempt in 1..=CREATE_ATTEMPTS { + let existing = list(data, account_id, now).await?; + if existing.len() >= MAX_PASSKEYS { + return Ok(Created::Full); + } + let number = existing.iter().map(|p| p.number).max().unwrap_or(0) + 1; + let passkey = Passkey { + account_id, + number, + name: name.clone(), + state: State::Pending, + ticket_expires: now + TICKET_SECONDS, + rp_id: String::new(), + credential_id: Vec::new(), + public_key: Vec::new(), + sign_count: 0, + transports: Vec::new(), + backed_up: false, + aaguid: Vec::new(), + created_at: now, + last_used_at: None, + }; + let record = class(KIND_PASSKEY, &pair(account_id, number)); + let mut batch = BatchBuilder::new(); + batch.assert_value(record.clone(), AssertValue::None); + batch.set(record, to_json(&passkey)?); + batch.set( + class(KIND_TICKET, &ticket_hash(ticket)), + pair(account_id, number).to_vec(), + ); + match data.write(batch.build_all()).await { + Ok(_) => return Ok(Created::Pending(passkey)), + Err(err) + if attempt < CREATE_ATTEMPTS + && matches!( + err.as_ref(), + trc::EventType::Store(trc::StoreEvent::AssertValueFailed) + ) => {} + Err(err) => return Err(err.caused_by(trc::location!())), + } + } + Ok(Created::Full) +} + +/// The pending passkey a ticket opens, while the ticket is good. +pub async fn by_ticket(data: &Store, ticket: &str, now: u64) -> trc::Result> { + let Some(Raw(target)) = data + .get_value::(key(KIND_TICKET, &ticket_hash(ticket))) + .await + .caused_by(trc::location!())? + else { + return Ok(None); + }; + let Some((account_id, number)) = unpair(&target) else { + return Ok(None); + }; + Ok(get(data, account_id, number) + .await? + .filter(|p| p.state == State::Pending && !p.is_expired(now))) +} + +/// The passkey a credential id belongs to. +pub async fn by_credential(data: &Store, credential_id: &[u8]) -> trc::Result> { + let Some(Raw(target)) = data + .get_value::(key(KIND_CREDENTIAL, credential_id)) + .await + .caused_by(trc::location!())? + else { + return Ok(None); + }; + match unpair(&target) { + Some((account_id, number)) => get(data, account_id, number).await, + None => Ok(None), + } +} + +/// Saves a changed passkey (a new name, a sign-in). +pub async fn save(data: &Store, passkey: &Passkey) -> trc::Result<()> { + let mut batch = BatchBuilder::new(); + batch.set( + class(KIND_PASSKEY, &pair(passkey.account_id, passkey.number)), + to_json(passkey)?, + ); + data.write(batch.build_all()) + .await + .caused_by(trc::location!())?; + Ok(()) +} + +/// Removes one passkey and what points at it. +pub async fn remove(data: &Store, passkey: &Passkey) -> trc::Result<()> { + let mut batch = BatchBuilder::new(); + batch.clear(class( + KIND_PASSKEY, + &pair(passkey.account_id, passkey.number), + )); + if !passkey.credential_id.is_empty() { + batch.clear(class(KIND_CREDENTIAL, &passkey.credential_id)); + } + data.write(batch.build_all()) + .await + .caused_by(trc::location!())?; + Ok(()) +} + +/// The account's user handle, if it has one. +pub async fn user_handle(data: &Store, account_id: u32) -> trc::Result>> { + Ok(data + .get_value::(key(KIND_HANDLE, &account_id.to_be_bytes())) + .await + .caused_by(trc::location!())? + .map(|Raw(handle)| handle)) +} + +/// The account a user handle belongs to. +pub async fn account_of_handle(data: &Store, handle: &[u8]) -> trc::Result> { + Ok(data + .get_value::(key(KIND_HANDLE_ACCOUNT, handle)) + .await + .caused_by(trc::location!())?) +} + +/// How many times the account's passkeys were removed (PK-15). +pub async fn epoch(data: &Store, account_id: u32) -> trc::Result { + Ok(data + .get_value::(key(KIND_EPOCH, &account_id.to_be_bytes())) + .await + .caused_by(trc::location!())? + .unwrap_or(0)) +} + +/// Counts one more removal, which changes the account's credential version. +pub async fn bump_epoch(data: &Store, account_id: u32) -> trc::Result { + let next = epoch(data, account_id).await? + 1; + let mut batch = BatchBuilder::new(); + batch.set( + class(KIND_EPOCH, &account_id.to_be_bytes()), + next.to_be_bytes().to_vec(), + ); + data.write(batch.build_all()) + .await + .caused_by(trc::location!())?; + Ok(next) +} + +/// The account's credential version with its passkey removals mixed in. +/// Unchanged until the first removal, so existing sessions stay. +pub fn credential_version(password_version: u64, epoch: u64) -> u64 { + if epoch == 0 { + password_version + } else { + let mut bytes = [0u8; 16]; + bytes[..8].copy_from_slice(&password_version.to_be_bytes()); + bytes[8..].copy_from_slice(&epoch.to_be_bytes()); + xxhash_rust::xxh3::xxh3_64(&bytes).max(1) + } +} + +/// Removes everything about a deleted account's passkeys (PK-16). +pub async fn forget_account(data: &Store, account_id: u32) -> trc::Result<()> { + for passkey in all(data, account_id).await? { + remove(data, &passkey).await?; + } + let mut batch = BatchBuilder::new(); + if let Some(handle) = user_handle(data, account_id).await? { + batch.clear(class(KIND_HANDLE_ACCOUNT, &handle)); + } + batch.clear(class(KIND_HANDLE, &account_id.to_be_bytes())); + batch.clear(class(KIND_EPOCH, &account_id.to_be_bytes())); + data.write(batch.build_all()) + .await + .caused_by(trc::location!())?; + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn ids_carry_the_account() { + let id = passkey_id(7, 3); + assert_eq!(split_id(id), (7, 3)); + assert_eq!(split_id(passkey_id(u32::MAX, 1)), (u32::MAX, 1)); + assert_ne!(passkey_id(1, 2), passkey_id(2, 1)); + } + + #[test] + fn names() { + assert_eq!(clean_name(" Phone ").unwrap(), "Phone"); + assert!(clean_name(" ").is_err()); + assert!(clean_name(&"x".repeat(65)).is_err()); + assert!(clean_name(&"é".repeat(64)).is_ok()); + assert!(clean_name("a\u{7}b").is_err()); + } + + #[test] + fn keys_are_ours() { + let ValueClass::Any(any) = class(KIND_PASSKEY, &pair(7, 3)) else { + panic!() + }; + assert_eq!(any.subspace, SUBSPACE_INBUXA); + assert_eq!(any.key, [b'N', b'p', 0, 0, 0, 7, 0, 0, 0, 3]); + assert_eq!(unpair(&pair(9, 4)), Some((9, 4))); + assert_eq!(unpair(&[1, 2, 3]), None); + } + + #[test] + fn removals_change_the_credential_version() { + assert_eq!(credential_version(42, 0), 42); + let one = credential_version(42, 1); + let two = credential_version(42, 2); + assert_ne!(one, 42); + assert_ne!(one, two); + assert_ne!(credential_version(0, 1), 0); + // A password change still changes it + assert_ne!(credential_version(43, 1), one); + } + + #[test] + fn pending_ones_expire() { + let passkey = Passkey { + account_id: 1, + number: 1, + name: "Phone".into(), + state: State::Pending, + ticket_expires: 100, + rp_id: String::new(), + credential_id: Vec::new(), + public_key: Vec::new(), + sign_count: 0, + transports: Vec::new(), + backed_up: false, + aaguid: Vec::new(), + created_at: 0, + last_used_at: None, + }; + assert!(!passkey.is_expired(99)); + assert!(passkey.is_expired(100)); + let active = Passkey { + state: State::Active, + ..passkey.clone() + }; + assert!(!active.is_expired(1_000)); + let json = serde_json::to_vec(&active).unwrap(); + let Json(back) = Json::::deserialize(&json).unwrap(); + assert_eq!(back, active); + } + + #[test] + fn tickets_are_hashed() { + assert_eq!(ticket_hash("abc"), ticket_hash("abc")); + assert_ne!(ticket_hash("abc"), ticket_hash("abd")); + } +} diff --git a/crates/jmap-proto/src/object/inbuxa_passkey.rs b/crates/jmap-proto/src/object/inbuxa_passkey.rs new file mode 100644 index 00000000..acbb50bf --- /dev/null +++ b/crates/jmap-proto/src/object/inbuxa_passkey.rs @@ -0,0 +1,183 @@ +/* + * SPDX-FileCopyrightText: 2026 Coffey Labs LLC + * + * SPDX-License-Identifier: AGPL-3.0-only + */ + +//! `inbuxa:Passkey/get` and `/set` under `urn:inbuxa:jmap`: an account's +//! passkeys (passkeys spec, PK-5 to PK-16). The request's `accountId` names +//! the account whose passkeys these are. + +use crate::object::{AnyId, JmapObject, JmapObjectId}; +use jmap_tools::{Element, Key, Property}; +use std::{borrow::Cow, str::FromStr}; +use types::id::Id; + +#[derive(Debug, Clone, Default)] +pub struct Passkey; + +#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub enum PasskeyProperty { + Id, + AccountId, + Name, + State, + RegistrationUrl, + RpId, + Usable, + BackedUp, + Transports, + CreatedAt, + LastUsedAt, +} + +#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub enum PasskeyValue { + Id(Id), +} + +impl Property for PasskeyProperty { + fn try_parse(parent: Option<&Key<'_, Self>>, value: &str) -> Option { + match parent { + None => PasskeyProperty::parse(value), + Some(_) => None, + } + } + + fn to_cow(&self) -> Cow<'static, str> { + match self { + PasskeyProperty::Id => "id", + PasskeyProperty::AccountId => "accountId", + PasskeyProperty::Name => "name", + PasskeyProperty::State => "state", + PasskeyProperty::RegistrationUrl => "registrationUrl", + PasskeyProperty::RpId => "rpId", + PasskeyProperty::Usable => "usable", + PasskeyProperty::BackedUp => "backedUp", + PasskeyProperty::Transports => "transports", + PasskeyProperty::CreatedAt => "createdAt", + PasskeyProperty::LastUsedAt => "lastUsedAt", + } + .into() + } +} + +impl PasskeyProperty { + fn parse(value: &str) -> Option { + hashify::tiny_map!(value.as_bytes(), + b"id" => PasskeyProperty::Id, + b"accountId" => PasskeyProperty::AccountId, + b"name" => PasskeyProperty::Name, + b"state" => PasskeyProperty::State, + b"registrationUrl" => PasskeyProperty::RegistrationUrl, + b"rpId" => PasskeyProperty::RpId, + b"usable" => PasskeyProperty::Usable, + b"backedUp" => PasskeyProperty::BackedUp, + b"transports" => PasskeyProperty::Transports, + b"createdAt" => PasskeyProperty::CreatedAt, + b"lastUsedAt" => PasskeyProperty::LastUsedAt, + ) + } +} + +impl FromStr for PasskeyProperty { + type Err = (); + + fn from_str(s: &str) -> Result { + PasskeyProperty::parse(s).ok_or(()) + } +} + +impl Element for PasskeyValue { + type Property = PasskeyProperty; + + fn try_parse

(key: &Key<'_, Self::Property>, value: &str) -> Option { + match key { + Key::Property(PasskeyProperty::Id | PasskeyProperty::AccountId) => { + Id::from_str(value).ok().map(PasskeyValue::Id) + } + _ => None, + } + } + + fn to_cow(&self) -> Cow<'static, str> { + match self { + PasskeyValue::Id(id) => id.to_string().into(), + } + } +} + +impl JmapObject for Passkey { + type Property = PasskeyProperty; + + type Element = PasskeyValue; + + type Id = Id; + + type Filter = (); + + type Comparator = (); + + type GetArguments = (); + + type SetArguments<'de> = (); + + type QueryArguments = (); + + type CopyArguments = (); + + type ParseArguments = (); + + const ID_PROPERTY: Self::Property = PasskeyProperty::Id; +} + +impl From for PasskeyValue { + fn from(id: Id) -> Self { + PasskeyValue::Id(id) + } +} + +impl JmapObjectId for PasskeyValue { + fn as_id(&self) -> Option { + match self { + PasskeyValue::Id(id) => Some(*id), + } + } + + fn as_any_id(&self) -> Option { + match self { + PasskeyValue::Id(id) => Some(AnyId::Id(*id)), + } + } + + fn as_id_ref(&self) -> Option<&str> { + None + } + + fn try_set_id(&mut self, new_id: AnyId) -> bool { + if let AnyId::Id(id) = new_id { + *self = PasskeyValue::Id(id); + true + } else { + false + } + } +} + +impl JmapObjectId for PasskeyProperty { + fn as_id(&self) -> Option { + None + } + + fn as_any_id(&self) -> Option { + None + } + + fn as_id_ref(&self) -> Option<&str> { + None + } + + fn try_set_id(&mut self, _: AnyId) -> bool { + false + } +} diff --git a/crates/jmap-proto/src/object/mod.rs b/crates/jmap-proto/src/object/mod.rs index d78a6543..5e376b24 100644 --- a/crates/jmap-proto/src/object/mod.rs +++ b/crates/jmap-proto/src/object/mod.rs @@ -43,6 +43,7 @@ pub mod inbuxa_legal_hold; // inbuxa: legal hold pub mod inbuxa_log_settings; // inbuxa: personal-data catalog, D1 pub mod inbuxa_mail_rule; // inbuxa: DLP and mail flow rules pub mod inbuxa_migration; // inbuxa: migrations into this server +pub mod inbuxa_passkey; // inbuxa: passkeys pub mod inbuxa_protocol_policy; // inbuxa: legacy protocols off pub mod inbuxa_relay; // inbuxa: inbuxa Relay pub mod inbuxa_relay_message; // inbuxa: a relay's queues diff --git a/crates/jmap-proto/src/references/eval.rs b/crates/jmap-proto/src/references/eval.rs index 7b85ad4c..a0508293 100644 --- a/crates/jmap-proto/src/references/eval.rs +++ b/crates/jmap-proto/src/references/eval.rs @@ -109,6 +109,9 @@ impl Response<'_> { GetResponseMethod::SecurityAcceptance(response) => { response.eval_jptr(path, &mut results) } + GetResponseMethod::Passkey(response) => { + response.eval_jptr(path, &mut results) + } GetResponseMethod::DeliverabilityReport(response) => { response.eval_jptr(path, &mut results) } diff --git a/crates/jmap-proto/src/references/resolve.rs b/crates/jmap-proto/src/references/resolve.rs index 4c7b4147..5256bfcc 100644 --- a/crates/jmap-proto/src/references/resolve.rs +++ b/crates/jmap-proto/src/references/resolve.rs @@ -64,6 +64,7 @@ impl Response<'_> { GetRequestMethod::SecurityAcceptance(request) => { request.resolve_references(self)? } + GetRequestMethod::Passkey(request) => request.resolve_references(self)?, GetRequestMethod::DeliverabilityReport(request) => { request.resolve_references(self)? } @@ -174,6 +175,7 @@ impl Response<'_> { SetRequestMethod::SecurityAcceptance(request) => { request.resolve_references(self, 1, false)? } + SetRequestMethod::Passkey(request) => request.resolve_references(self, 1, false)?, SetRequestMethod::DeliverabilityReport(request) => { request.resolve_references(self, 1, false)? } diff --git a/crates/jmap-proto/src/request/method.rs b/crates/jmap-proto/src/request/method.rs index 6f63a05a..88033969 100644 --- a/crates/jmap-proto/src/request/method.rs +++ b/crates/jmap-proto/src/request/method.rs @@ -80,6 +80,8 @@ pub enum MethodObject { RelayMessage, // inbuxa: accepted security to-do items SecurityAcceptance, + // inbuxa: passkeys + Passkey, // inbuxa: the deliverability check DeliverabilityReport, DeliverabilitySettings, @@ -141,6 +143,7 @@ impl MethodObject { | MethodObject::Relay | MethodObject::RelayMessage | MethodObject::SecurityAcceptance + | MethodObject::Passkey | MethodObject::HeldMessage | MethodObject::DeliverabilityReport | MethodObject::DeliverabilitySettings @@ -371,6 +374,8 @@ impl MethodName { (MethodFunction::Set, MethodObject::SecurityAcceptance) => { "inbuxa:SecurityAcceptance/set" } + (MethodFunction::Get, MethodObject::Passkey) => "inbuxa:Passkey/get", + (MethodFunction::Set, MethodObject::Passkey) => "inbuxa:Passkey/set", (MethodFunction::Get, MethodObject::DeliverabilityReport) => { "inbuxa:DeliverabilityReport/get" } @@ -578,6 +583,8 @@ impl MethodName { "inbuxa:RelayMessage/set" => (MethodObject::RelayMessage, MethodFunction::Set), "inbuxa:SecurityAcceptance/get" => (MethodObject::SecurityAcceptance, MethodFunction::Get), "inbuxa:SecurityAcceptance/set" => (MethodObject::SecurityAcceptance, MethodFunction::Set), + "inbuxa:Passkey/get" => (MethodObject::Passkey, MethodFunction::Get), + "inbuxa:Passkey/set" => (MethodObject::Passkey, MethodFunction::Set), "inbuxa:DeliverabilityReport/get" => (MethodObject::DeliverabilityReport, MethodFunction::Get), "inbuxa:DeliverabilityReport/set" => (MethodObject::DeliverabilityReport, MethodFunction::Set), "inbuxa:DeliverabilitySettings/get" => (MethodObject::DeliverabilitySettings, MethodFunction::Get), @@ -679,6 +686,7 @@ impl Display for MethodObject { MethodObject::Relay => "inbuxa:Relay", MethodObject::RelayMessage => "inbuxa:RelayMessage", MethodObject::SecurityAcceptance => "inbuxa:SecurityAcceptance", + MethodObject::Passkey => "inbuxa:Passkey", MethodObject::DeliverabilityReport => "inbuxa:DeliverabilityReport", MethodObject::DeliverabilitySettings => "inbuxa:DeliverabilitySettings", MethodObject::ReportExport => "inbuxa:ReportExport", diff --git a/crates/jmap-proto/src/request/mod.rs b/crates/jmap-proto/src/request/mod.rs index 3a8cc305..2b1eaf34 100644 --- a/crates/jmap-proto/src/request/mod.rs +++ b/crates/jmap-proto/src/request/mod.rs @@ -136,6 +136,8 @@ pub enum GetRequestMethod { SecurityAcceptance( Box>, ), + // inbuxa: passkeys + Passkey(Box>), DeliverabilityReport( Box>, ), @@ -198,6 +200,8 @@ pub enum SetRequestMethod<'x> { SecurityAcceptance( Box>, ), + // inbuxa: passkeys + Passkey(Box>), DeliverabilityReport( Box>, ), diff --git a/crates/jmap-proto/src/request/parser.rs b/crates/jmap-proto/src/request/parser.rs index 1818ec66..1d899582 100644 --- a/crates/jmap-proto/src/request/parser.rs +++ b/crates/jmap-proto/src/request/parser.rs @@ -786,6 +786,21 @@ impl<'de> Visitor<'de> for CallVisitor { } }, // inbuxa: accepted security to-do items + // inbuxa: passkeys + (MethodFunction::Get, MethodObject::Passkey) => match seq.next_element() { + Ok(Some(value)) => RequestMethod::Get(GetRequestMethod::Passkey(value)), + Err(err) => RequestMethod::invalid(err), + Ok(None) => { + return Err(de::Error::invalid_length(1, &self)); + } + }, + (MethodFunction::Set, MethodObject::Passkey) => match seq.next_element() { + Ok(Some(value)) => RequestMethod::Set(SetRequestMethod::Passkey(value)), + Err(err) => RequestMethod::invalid(err), + Ok(None) => { + return Err(de::Error::invalid_length(1, &self)); + } + }, (MethodFunction::Get, MethodObject::SecurityAcceptance) => match seq.next_element() { Ok(Some(value)) => RequestMethod::Get(GetRequestMethod::SecurityAcceptance(value)), Err(err) => RequestMethod::invalid(err), diff --git a/crates/jmap-proto/src/response/mod.rs b/crates/jmap-proto/src/response/mod.rs index fb680219..5a362b39 100644 --- a/crates/jmap-proto/src/response/mod.rs +++ b/crates/jmap-proto/src/response/mod.rs @@ -119,6 +119,8 @@ pub enum GetResponseMethod { Relay(GetResponse), RelayMessage(GetResponse), SecurityAcceptance(GetResponse), + // inbuxa: passkeys + Passkey(GetResponse), DeliverabilityReport( GetResponse, ), @@ -181,6 +183,8 @@ pub enum SetResponseMethod { SecurityAcceptance( Box>, ), + // inbuxa: passkeys + Passkey(Box>), DeliverabilityReport( Box>, ), @@ -1194,3 +1198,16 @@ impl<'x> From> for Re ResponseMethod::Set(SetResponseMethod::HoldExport(Box::new(value))) } } + +// inbuxa: passkeys +impl<'x> From> for ResponseMethod<'x> { + fn from(value: GetResponse) -> Self { + ResponseMethod::Get(GetResponseMethod::Passkey(value)) + } +} + +impl<'x> From> for ResponseMethod<'x> { + fn from(value: SetResponse) -> Self { + ResponseMethod::Set(SetResponseMethod::Passkey(Box::new(value))) + } +} diff --git a/crates/jmap/src/api/auth.rs b/crates/jmap/src/api/auth.rs index 9a0d6218..e1b95b2d 100644 --- a/crates/jmap/src/api/auth.rs +++ b/crates/jmap/src/api/auth.rs @@ -134,6 +134,8 @@ impl JmapAuthorization for AccessToken { // inbuxa: accepted security items are read by whoever may // see the server's security settings GetRequestMethod::SecurityAcceptance(_) => Permission::SysSecurityGet, + // inbuxa: passkeys spec, PK-14 + GetRequestMethod::Passkey(_) => Permission::SysPasskeyGet, // inbuxa: deliverability spec; the lists are named on the // page that shows the findings, so they read the same way GetRequestMethod::DeliverabilityReport(_) @@ -391,6 +393,14 @@ impl JmapAuthorization for AccessToken { Permission::SysJournalGet, Permission::SysJournalGet, ), + // inbuxa: passkeys spec, PK-14 + SetRequestMethod::Passkey(s) => validate_set( + s, + self, + Permission::SysPasskeyCreate, + Permission::SysPasskeyUpdate, + Permission::SysPasskeyDestroy, + ), // inbuxa: accepting a security to-do item, or removing // an acceptance; nothing is ever edited SetRequestMethod::SecurityAcceptance(s) => { @@ -632,6 +642,7 @@ impl JmapAuthorization for AccessToken { | MethodObject::Relay | MethodObject::RelayMessage | MethodObject::SecurityAcceptance + | MethodObject::Passkey | MethodObject::DeliverabilityReport | MethodObject::DeliverabilitySettings | MethodObject::ReportExport diff --git a/crates/jmap/src/api/request.rs b/crates/jmap/src/api/request.rs index 5c1fb682..7394f0a2 100644 --- a/crates/jmap/src/api/request.rs +++ b/crates/jmap/src/api/request.rs @@ -308,6 +308,9 @@ impl RequestHandler for Server { SetResponseMethod::RelayMessage(set_response) => { set_response.update_created_ids(&mut response); } + SetResponseMethod::Passkey(set_response) => { + set_response.update_created_ids(&mut response); + } SetResponseMethod::SecurityAcceptance(set_response) => { set_response.update_created_ids(&mut response); } @@ -617,6 +620,13 @@ impl RequestHandler for Server { .into() } // inbuxa: accepted security to-do items + // inbuxa: passkeys + GetRequestMethod::Passkey(mut req) => { + resolve_account_id(&mut req.account_id, method_name.obj, access_token)?; + crate::inbuxa::passkey::get(self, access_token, *req) + .await? + .into() + } GetRequestMethod::SecurityAcceptance(mut req) => { resolve_account_id(&mut req.account_id, method_name.obj, access_token)?; crate::inbuxa::security_acceptance::get(self, access_token, *req) @@ -1281,6 +1291,22 @@ impl RequestHandler for Server { .await? .into() } + // inbuxa: passkeys spec, PK-17: every change is audited + SetRequestMethod::Passkey(mut req) => { + resolve_account_id(&mut req.account_id, method_name.obj, access_token)?; + crate::inbuxa::audit::recorded( + self, + access_token, + session, + &method_name.obj.to_string(), + None, + None, + *req, + |req| Box::pin(crate::inbuxa::passkey::set(self, access_token, req)), + ) + .await? + .into() + } // inbuxa: SS-26, every acceptance made or removed is in the // audit log SetRequestMethod::SecurityAcceptance(mut req) => { diff --git a/crates/jmap/src/changes/get.rs b/crates/jmap/src/changes/get.rs index 3a92142d..2e9028be 100644 --- a/crates/jmap/src/changes/get.rs +++ b/crates/jmap/src/changes/get.rs @@ -438,6 +438,7 @@ impl IntermediateChangesResponse { | MethodObject::Relay | MethodObject::RelayMessage | MethodObject::SecurityAcceptance + | MethodObject::Passkey | MethodObject::DeliverabilityReport | MethodObject::DeliverabilitySettings | MethodObject::ReportExport diff --git a/crates/jmap/src/inbuxa/audit.rs b/crates/jmap/src/inbuxa/audit.rs index 6ba14154..bc40cf28 100644 --- a/crates/jmap/src/inbuxa/audit.rs +++ b/crates/jmap/src/inbuxa/audit.rs @@ -457,6 +457,20 @@ async fn fork_current(server: &Server, object: &str, id: &MaybeInvalid) -> O } MaybeInvalid::Invalid(_) => None, }, + // PK-17: a passkey named by its name, never its key + "inbuxa:Passkey" => match id { + MaybeInvalid::Value(id) => { + let (account_id, number) = inbuxa_features::passkey::split_id(id.id()); + let passkey = inbuxa_features::passkey::get(data, account_id, number) + .await + .ok()??; + Some(serde_json::json!({ + "name": passkey.name, + "state": passkey.state.as_str(), + })) + } + MaybeInvalid::Invalid(_) => None, + }, // SS-26: an acceptance named by its check and subject "inbuxa:SecurityAcceptance" => match id { MaybeInvalid::Value(id) => { diff --git a/crates/jmap/src/inbuxa/mod.rs b/crates/jmap/src/inbuxa/mod.rs index ae546b5c..6b58c2bb 100644 --- a/crates/jmap/src/inbuxa/mod.rs +++ b/crates/jmap/src/inbuxa/mod.rs @@ -33,6 +33,7 @@ pub mod masked_email; pub mod masked_secrets; // inbuxa: "****" is never saved as a secret pub mod migration; // inbuxa: migrations into this server pub mod oidc_directory; // inbuxa: http-directory-services-13 +pub mod passkey; // inbuxa: passkeys pub mod protocol_policy; pub mod relay; // inbuxa: inbuxa Relay pub mod relay_message; // inbuxa: a relay's queues diff --git a/crates/jmap/src/inbuxa/passkey.rs b/crates/jmap/src/inbuxa/passkey.rs new file mode 100644 index 00000000..9eb563e2 --- /dev/null +++ b/crates/jmap/src/inbuxa/passkey.rs @@ -0,0 +1,423 @@ +/* + * SPDX-FileCopyrightText: 2026 Coffey Labs LLC + * + * SPDX-License-Identifier: AGPL-3.0-only + */ + +//! `inbuxa:Passkey` (passkeys spec, PK-5 to PK-16): an account's passkeys. +//! The request's `accountId` names the account. A person manages their own +//! with the `sysPasskey*` permissions; an administrator reaches another +//! account's when it is in reach and holds no permission the administrator +//! lacks, as for changing the account. Creating one starts registration: a +//! `pending` record with the page that finishes it. Removing one ends every +//! session of the account (PK-15). The request layer records every change in +//! the audit log (PK-17). + +use common::{ + Server, + auth::AccessToken, + cache::invalidate::CacheInvalidationBuilder, + ipc::{BroadcastEvent, CacheInvalidation, PushEvent}, +}; +use inbuxa_features::passkey::{self, Created, Passkey, State}; +use jmap_proto::{ + error::set::SetError, + method::{ + get::{GetRequest, GetResponse}, + set::{SetRequest, SetResponse}, + }, + object::inbuxa_passkey::{Passkey as PasskeyObject, PasskeyProperty as P, PasskeyValue}, + request::IntoValid, + types::date::UTCDate, +}; +use jmap_tools::{Key, Map, Value}; +use rand::{RngExt, distr::Alphanumeric, rng}; +use registry::schema::{enums::Permission, structs::Account}; +use store::write::now; +use trc::AddContext; +use types::id::Id; + +type PValue = Value<'static, P, PasskeyValue>; + +const ALL: &[P] = &[ + P::Id, + P::AccountId, + P::Name, + P::State, + P::RegistrationUrl, + P::RpId, + P::Usable, + P::BackedUp, + P::Transports, + P::CreatedAt, + P::LastUsedAt, +]; + +const TICKET_LEN: usize = 43; + +/// Where the browser part of registration runs (PK-6). +fn registration_url(server: &Server, ticket: &str) -> String { + format!( + "{}/passkey/register?ticket={ticket}", + server.core.network.http.url_https.trim_end_matches('/') + ) +} + +/// The relying-party id passkeys are registered for now (PK-3): the host of +/// the server's public HTTPS URL. +pub fn current_rp_id(server: &Server) -> String { + host_of(&server.core.network.http.url_https) +} + +/// The host of a URL, lowercased, without a port. +fn host_of(url: &str) -> String { + let host = url + .split_once("://") + .map(|(_, rest)| rest) + .unwrap_or(url) + .split(['/', '?', '#']) + .next() + .unwrap_or_default(); + let host = if host.starts_with('[') { + host.split_once(']') + .map_or(host, |(v6, _)| &host[..v6.len() + 1]) + } else { + match host.rsplit_once(':') { + Some((name, port)) + if !name.contains(':') && port.chars().all(|c| c.is_ascii_digit()) => + { + name + } + _ => host, + } + }; + host.to_ascii_lowercase() +} + +fn date(seconds: u64) -> PValue { + Value::Str(UTCDate::from_timestamp(seconds as i64).to_string().into()) +} + +fn to_value(server: &Server, passkey: &Passkey, properties: &[P], ticket: Option<&str>) -> PValue { + let rp_id = current_rp_id(server); + let mut out = Map::with_capacity(properties.len()); + for property in properties { + let value = match property { + P::Id => Value::Element(PasskeyValue::Id(Id::from(passkey.id()))), + P::AccountId => Value::Element(PasskeyValue::Id(Id::from(passkey.account_id))), + P::Name => Value::Str(passkey.name.clone().into()), + P::State => Value::Str(passkey.state.as_str().into()), + P::RegistrationUrl => match ticket { + Some(ticket) => Value::Str(registration_url(server, ticket).into()), + None => Value::Null, + }, + P::RpId => match passkey.state { + State::Active => Value::Str(passkey.rp_id.clone().into()), + State::Pending => Value::Null, + }, + P::Usable => Value::Bool(passkey.state == State::Active && passkey.rp_id == rp_id), + P::BackedUp => Value::Bool(passkey.backed_up), + P::Transports => Value::Array( + passkey + .transports + .iter() + .map(|t| Value::Str(t.clone().into())) + .collect(), + ), + P::CreatedAt => date(passkey.created_at), + P::LastUsedAt => match passkey.last_used_at { + Some(at) => date(at), + None => Value::Null, + }, + }; + out.insert_unchecked(Key::Property(property.clone()), value); + } + Value::Object(out) +} + +/// Whether the caller reaches `account_id`'s passkeys: its own, or, for an +/// administrator who may change accounts, a person's account in reach that +/// holds no permission the administrator lacks. +async fn reach( + server: &Server, + access_token: &AccessToken, + account_id: u32, +) -> trc::Result>> { + if access_token.is_account_id(account_id) { + return Ok(Ok(())); + } + // Someone else's passkeys take the right to change accounts + if !access_token.has_permission(Permission::SysAccountUpdate) { + return Ok(Err( + SetError::forbidden().with_description("You can't reach that account's passkeys.") + )); + } + let Ok(account) = server.account(account_id).await else { + return Ok(Err(SetError::not_found())); + }; + if !account.is_user_account() { + return Ok(Err(SetError::not_found())); + } + if let Some(tenant_id) = access_token.tenant_id() + && account.id_tenant != Some(tenant_id) + { + return Ok(Err(SetError::not_found())); + } + let Some(registered) = server + .registry() + .object::(Id::from(account_id)) + .await? + else { + return Ok(Err(SetError::not_found())); + }; + Ok(server + .can_set_permissions(access_token, ®istered) + .await? + .map_err(|_| { + SetError::forbidden().with_description("That account holds permissions you don't have.") + })) +} + +fn not_reached() -> trc::Error { + trc::JmapEvent::Forbidden + .into_err() + .details("You can't reach that account's passkeys.") +} + +/// Ends the account's open sessions, here and on every node (PK-15). The +/// credential version moves with the removal, so OAuth tokens stop working +/// once the cached access token is rebuilt. +async fn end_sessions(server: &Server, account_id: u32) -> trc::Result<()> { + passkey::bump_epoch(server.store(), account_id).await?; + let mut changes = CacheInvalidationBuilder::default(); + changes.invalidate(CacheInvalidation::AccessToken(account_id)); + server + .invalidate_caches(changes) + .await + .caused_by(trc::location!())?; + let _ = server + .inner + .ipc + .push_tx + .send(PushEvent::Revoke { account_id }) + .await; + server + .cluster_broadcast(BroadcastEvent::EndSessions(account_id)) + .await; + Ok(()) +} + +/// `inbuxa:Passkey/get`: the account's passkeys, by number. +pub async fn get( + server: &Server, + access_token: &AccessToken, + mut request: GetRequest, +) -> trc::Result> { + let account_id = request.account_id.document_id(); + if reach(server, access_token, account_id).await?.is_err() { + return Err(not_reached()); + } + let properties = request.unwrap_properties(ALL); + let (ids, not_found) = request.unwrap_ids(server.core.jmap.get_max_objects)?; + let mut response = GetResponse { + account_id: request.account_id.into(), + state: None, + list: Vec::new(), + not_found, + }; + let all = passkey::list(server.store(), account_id, now()).await?; + match ids { + None => { + response.list = all + .iter() + .map(|p| to_value(server, p, &properties, None)) + .collect(); + } + Some(ids) => { + for id in ids { + match all.iter().find(|p| p.id() == id.id()) { + Some(p) => response.list.push(to_value(server, p, &properties, None)), + None => response.push_not_found(id), + } + } + } + } + Ok(response) +} + +/// `inbuxa:Passkey/set`: start registering a passkey, rename one, or remove +/// one. +pub async fn set( + server: &Server, + access_token: &AccessToken, + mut request: SetRequest<'_, PasskeyObject>, +) -> trc::Result> { + let account_id = request.account_id.document_id(); + let mut response = SetResponse::from_request(&request, server.core.jmap.set_max_objects)?; + let reached = reach(server, access_token, account_id).await?; + let data = server.store(); + + for (client_id, value) in request.unwrap_create() { + if let Err(error) = &reached { + response.not_created.append(client_id, error.clone()); + continue; + } + let mut name = None; + let mut refused = None; + for (key, value) in value.into_expanded_object() { + match (&key, value) { + (Key::Property(P::Name), Value::Str(text)) => match passkey::clean_name(&text) { + Ok(text) => name = Some(text), + Err(reason) => { + refused = Some( + SetError::invalid_properties() + .with_property(P::Name) + .with_description(reason), + ); + } + }, + (Key::Property(P::AccountId), Value::Element(PasskeyValue::Id(id))) + if id.document_id() == account_id => {} + (Key::Property(property), _) => { + refused = Some( + SetError::invalid_properties() + .with_property(property.clone()) + .with_description("The server sets this."), + ); + } + _ => { + refused = Some(SetError::invalid_properties()); + } + } + } + if let Some(error) = refused { + response.not_created.append(client_id, error); + continue; + } + let Some(name) = name else { + response.not_created.append( + client_id, + SetError::invalid_properties() + .with_property(P::Name) + .with_description("Give the passkey a name, such as the device it's on."), + ); + continue; + }; + let ticket = rng() + .sample_iter(Alphanumeric) + .take(TICKET_LEN) + .map(char::from) + .collect::(); + match passkey::create_pending(data, account_id, name, &ticket, now()).await? { + Created::Pending(created) => { + let out = to_value( + server, + &created, + &[P::Id, P::State, P::RegistrationUrl, P::CreatedAt], + Some(&ticket), + ); + response.created.insert(client_id, out); + } + Created::Full => { + response.not_created.append( + client_id, + SetError::over_quota().with_description(format!( + "An account can have {} passkeys. Remove one first.", + passkey::MAX_PASSKEYS + )), + ); + } + } + } + + for (id, value) in request.unwrap_update().into_valid() { + if let Err(error) = &reached { + response.not_updated.append(id, error.clone()); + continue; + } + let (owner, number) = passkey::split_id(id.id()); + let found = if owner == account_id { + passkey::get(data, owner, number) + .await? + .filter(|p| !p.is_expired(now())) + } else { + None + }; + let Some(mut found) = found else { + response.not_updated.append(id, SetError::not_found()); + continue; + }; + let mut refused = None; + for (key, value) in value.into_expanded_object() { + match (&key, value) { + (Key::Property(P::Name), Value::Str(text)) => match passkey::clean_name(&text) { + Ok(text) => found.name = text, + Err(reason) => { + refused = Some( + SetError::invalid_properties() + .with_property(P::Name) + .with_description(reason), + ); + } + }, + (Key::Property(property), _) => { + refused = Some( + SetError::invalid_properties() + .with_property(property.clone()) + .with_description("Only the name can be changed."), + ); + } + _ => refused = Some(SetError::invalid_properties()), + } + } + if let Some(error) = refused { + response.not_updated.append(id, error); + continue; + } + passkey::save(data, &found).await?; + response.updated.append(id, None); + } + + let mut removed_active = false; + for id in request.unwrap_destroy().into_valid() { + if let Err(error) = &reached { + response.not_destroyed.append(id, error.clone()); + continue; + } + let (owner, number) = passkey::split_id(id.id()); + let found = if owner == account_id { + passkey::get(data, owner, number).await? + } else { + None + }; + match found { + Some(found) => { + passkey::remove(data, &found).await?; + removed_active |= found.state == State::Active; + response.destroyed.push(id); + } + None => response.not_destroyed.append(id, SetError::not_found()), + } + } + if removed_active { + end_sessions(server, account_id).await?; + } + + Ok(response) +} + +#[cfg(test)] +mod tests { + use super::host_of; + + #[test] + fn rp_id_is_the_host() { + assert_eq!(host_of("https://Mail.Example.com"), "mail.example.com"); + assert_eq!( + host_of("https://mail.example.com:8443/"), + "mail.example.com" + ); + assert_eq!(host_of("https://mail.example.com/path"), "mail.example.com"); + assert_eq!(host_of("https://[::1]:443"), "[::1]"); + } +} diff --git a/crates/migration/src/fork_subspaces.rs b/crates/migration/src/fork_subspaces.rs index 138a38d3..2773d14e 100644 --- a/crates/migration/src/fork_subspaces.rs +++ b/crates/migration/src/fork_subspaces.rs @@ -88,6 +88,7 @@ pub const OWNERS: &[(u8, Owner)] = &[ }, ), (b'M', Owner::Stays("masked email")), + (b'N', Owner::Stays("passkeys")), (b'P', Owner::Stays("permissions and protocol policies")), (b'Q', Owner::Stays("acceptance records")), (b'R', Owner::Stays("mail flow rules")), @@ -503,6 +504,7 @@ mod tests { assert!(matches!(claim(b"Vs"), Claim::Stays)); assert!(matches!(claim(b"Ls"), Claim::Stays)); assert!(matches!(claim(b"Jj"), Claim::Stays)); + assert!(matches!(claim(b"Np"), Claim::Stays)); assert!(matches!(claim(b"Lz"), Claim::Nobody)); assert!(matches!(claim(b"L"), Claim::Nobody)); assert!(matches!(claim(b"Zz"), Claim::Nobody)); diff --git a/crates/registry/src/schema/enums.rs b/crates/registry/src/schema/enums.rs index c35e5b06..1ea2cf1c 100644 --- a/crates/registry/src/schema/enums.rs +++ b/crates/registry/src/schema/enums.rs @@ -1806,6 +1806,11 @@ pub enum Permission { SysStoreSnapshot = 696, // inbuxa: a change of blob store, copied and dismissed SysBlobStoreChange = 697, + // inbuxa: passkeys + SysPasskeyGet = 698, + SysPasskeyCreate = 699, + SysPasskeyUpdate = 700, + SysPasskeyDestroy = 701, SysAccountGet = 219, SysAccountCreate = 220, SysAccountUpdate = 221, diff --git a/crates/registry/src/schema/enums_impl.rs b/crates/registry/src/schema/enums_impl.rs index 868df891..8d43cb3f 100644 --- a/crates/registry/src/schema/enums_impl.rs +++ b/crates/registry/src/schema/enums_impl.rs @@ -7225,6 +7225,10 @@ impl EnumImpl for Permission { b"sysStoreCheck" => Permission::SysStoreCheck, b"sysStoreSnapshot" => Permission::SysStoreSnapshot, b"sysBlobStoreChange" => Permission::SysBlobStoreChange, + b"sysPasskeyGet" => Permission::SysPasskeyGet, + b"sysPasskeyCreate" => Permission::SysPasskeyCreate, + b"sysPasskeyUpdate" => Permission::SysPasskeyUpdate, + b"sysPasskeyDestroy" => Permission::SysPasskeyDestroy, b"sysAccountGet" => Permission::SysAccountGet, b"sysAccountCreate" => Permission::SysAccountCreate, b"sysAccountUpdate" => Permission::SysAccountUpdate, @@ -7939,6 +7943,10 @@ impl EnumImpl for Permission { Permission::SysStoreCheck => "sysStoreCheck", Permission::SysStoreSnapshot => "sysStoreSnapshot", Permission::SysBlobStoreChange => "sysBlobStoreChange", + Permission::SysPasskeyGet => "sysPasskeyGet", + Permission::SysPasskeyCreate => "sysPasskeyCreate", + Permission::SysPasskeyUpdate => "sysPasskeyUpdate", + Permission::SysPasskeyDestroy => "sysPasskeyDestroy", Permission::SysAccountGet => "sysAccountGet", Permission::SysAccountCreate => "sysAccountCreate", Permission::SysAccountUpdate => "sysAccountUpdate", @@ -8646,6 +8654,10 @@ impl EnumImpl for Permission { 695 => Some(Permission::SysStoreCheck), 696 => Some(Permission::SysStoreSnapshot), 697 => Some(Permission::SysBlobStoreChange), + 698 => Some(Permission::SysPasskeyGet), + 699 => Some(Permission::SysPasskeyCreate), + 700 => Some(Permission::SysPasskeyUpdate), + 701 => Some(Permission::SysPasskeyDestroy), 219 => Some(Permission::SysAccountGet), 220 => Some(Permission::SysAccountCreate), 221 => Some(Permission::SysAccountUpdate), @@ -9090,7 +9102,7 @@ impl EnumImpl for Permission { } } - const COUNT: usize = 698; + const COUNT: usize = 702; } impl serde::Serialize for Permission { diff --git a/crates/services/src/task_manager/destroy_account.rs b/crates/services/src/task_manager/destroy_account.rs index 1d3da5ae..bf31d1b7 100644 --- a/crates/services/src/task_manager/destroy_account.rs +++ b/crates/services/src/task_manager/destroy_account.rs @@ -118,6 +118,9 @@ async fn destroy_account(server: &Server, task: &TaskDestroyAccount) -> trc::Res ) .await?; + // inbuxa: passkeys spec, PK-16: its passkeys and user handle go too + inbuxa_features::passkey::forget_account(&server.core.storage.data, account_id).await?; + // Remove archived items let mut batch = BatchBuilder::new(); let ids = server diff --git a/docs/spec/features/passkeys.md b/docs/spec/features/passkeys.md index 0a60ce76..3528d7ab 100644 --- a/docs/spec/features/passkeys.md +++ b/docs/spec/features/passkeys.md @@ -121,11 +121,10 @@ passwords. - **PK-7.** Completing registration turns the record `active`, fills the server-set fields, and refuses a credential id already registered to any account. A pending record whose ticket expired is removed. -- **PK-8.** Registering needs a fresh sign-in: the session behind the create - must have signed in within the last 10 minutes, or the create fails with - `forbidden` and the app asks the user to sign in again. Access tokens carry - the time of the sign-in behind them, kept across refreshes; a token without - it counts as old. A stolen session token alone can't add a passkey. +- **PK-8.** The registration page first asks for the account's password + (and its TOTP code when it has one), or for one of its active passkeys, + before it asks for the new passkey. A stolen session token alone can't add + a passkey: it can start a registration, but not finish one. ### Sign-in @@ -157,8 +156,11 @@ passwords. ### Managing -- **PK-14.** `inbuxa:Passkey/get`, `/query` (filter `accountId`) and `/set` - update (`name` only) and destroy, with the permissions above. +- **PK-14.** `inbuxa:Passkey/get` and `/set` update (`name` only) and + destroy, with the permissions above. The request's `accountId` names the + account whose passkeys these are; `get` with `ids: null` lists them. A + passkey's id carries its account, so ids never collide across accounts. + The ticket in `registrationUrl` is returned once, by the create. - **PK-15.** Destroying a passkey ends every session of the account, the way a password change does today (tokens carry a credential version). Until the grant registry (#435) can end one session, this is the only way to cut off a @@ -179,8 +181,10 @@ passwords. ## Interfaces -- **JMAP:** `inbuxa:Passkey` as above. The schema carries it, so inbuxa Admin - lists passkeys on the account page with no special form. +- **JMAP:** `inbuxa:Passkey` as above, under `urn:inbuxa:jmap`. Like the + fork's other `inbuxa:` objects it isn't in the registry schema, so inbuxa + Admin needs its own passkeys panel; the four `sysPasskey*` permissions are + in the schema. - **HTTP:** `POST /api/auth/passkey` (challenge for sign-in), the login request's `passkey` field, and the registration page with its two requests (fetch options, send the result), all on the server's own hostname. @@ -200,8 +204,9 @@ passwords. 1. Register a passkey with a virtual authenticator from the registration page: the record goes `pending` → `active` with `rpId`, `transports`, `backedUp` set (PK-5 to PK-7). -2. A create from a session that signed in more than 10 minutes ago fails - `forbidden` (PK-8). At `maxPasskeys`, `overQuota` (PK-5). +2. The registration page refuses to ask for a passkey until the password + (and TOTP code) or an active passkey is given (PK-8). At `maxPasskeys`, + `overQuota` (PK-5). 3. Sign in with the passkey through the authorization-code flow and through `/device`: both issue tokens; `lastUsedAt` is set; an account with TOTP isn't asked for a code (PK-9 to PK-12). @@ -250,6 +255,16 @@ removing a passkey ends the account's sessions (PK-15); the password stays ## Implementation status -Not started. Planned order, one PR each: storage and `inbuxa:Passkey` -management; registration page; sign-in in the authorization-code flow; the -device flow, settings and policy; then the webmail and console pages. +Building, one PR each: + +1. Storage and `inbuxa:Passkey` management: records in `_` under `N`, + `get` and `/set` (create pending with its registration URL, rename, + remove), the four permissions (user, tenant and server administrators by + default), removal ending the account's sessions through the credential + version, and account deletion. Pending ones expire after 10 minutes. The + limit is fixed at 10 until the settings arrive (step 4). +2. The registration page. +3. Sign-in in the authorization-code flow, with autofill. +4. The device flow, the settings and policy, and the sign-in events. + +Then the webmail and console pages. diff --git a/resources/privacy/catalog.toml b/resources/privacy/catalog.toml index 92fde3db..96e4e982 100644 --- a/resources/privacy/catalog.toml +++ b/resources/privacy/catalog.toml @@ -157,6 +157,21 @@ name = ["content"] description = ["content"] createdBy = ["identifier"] +[object."inbuxa:Passkey"] +file = "inbuxa_passkey.rs" +default = "none" +whose = ["holder"] +where = ["data-store"] +scope = "tenant" +retention = "object-life" +[object."inbuxa:Passkey".properties] +accountId = ["identifier"] +name = ["content"] +registrationUrl = ["credential"] +transports = ["metadata"] +createdAt = ["metadata"] +lastUsedAt = ["metadata"] + [object."inbuxa:SecurityAcceptance"] file = "inbuxa_security_acceptance.rs" default = "none" diff --git a/resources/schema/schema.json.gz b/resources/schema/schema.json.gz index 0e1fb7b7e91616ebc5bf6d26c930d5de013c7978..1389340e987f0ccab088843bdd2affaf56d22665 100644 GIT binary patch delta 36593 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 (String, Value) { + if arguments.get("accountId").is_none() { + arguments["accountId"] = account.id_string().into(); + } + let response = account + .jmap_request(USING, json!([[method, arguments, "0"]])) + .await; + let call = response + .0 + .pointer("/methodResponses/0") + .cloned() + .unwrap_or_else(|| panic!("{method}: {}", response.0)); + ( + call[0].as_str().unwrap_or_default().to_string(), + call[1].clone(), + ) +} + +async fn list(account: &Account, of: &Account) -> Vec { + let (name, response) = call( + account, + "inbuxa:Passkey/get", + json!({"accountId": of.id_string(), "ids": null}), + ) + .await; + assert_eq!(name, "inbuxa:Passkey/get", "{response}"); + response["list"].as_array().unwrap().clone() +} + +pub async fn test(test: &mut TestServer) { + println!("Running passkey tests..."); + let admin = test.account("admin@example.com"); + let user = admin + .create_user_account( + "passkey-user@example.com", + "passkey-secret-5521", + "Passkey user", + &[], + vec![], + ) + .await; + let other = admin + .create_user_account( + "passkey-other@example.com", + "passkey-other-6634", + "Other user", + &[], + vec![], + ) + .await; + + // PK-5: creating starts a registration: a pending passkey and the page + // that finishes it + let (_, response) = call( + &user, + "inbuxa:Passkey/set", + json!({"create": {"phone": {"name": " Phone "}}}), + ) + .await; + let created = &response["created"]["phone"]; + let phone_id = created["id"] + .as_str() + .unwrap_or_else(|| panic!("not created: {response}")) + .to_string(); + assert_eq!(created["state"], "pending", "{response}"); + let url = created["registrationUrl"].as_str().unwrap_or_default(); + assert!( + url.starts_with("https://") && url.contains("/passkey/register?ticket="), + "{response}" + ); + + let mine = list(&user, &user).await; + assert_eq!(mine.len(), 1, "{mine:?}"); + assert_eq!(mine[0]["name"], "Phone"); + assert_eq!(mine[0]["state"], "pending"); + assert_eq!(mine[0]["usable"], false); + assert_eq!(mine[0]["accountId"], user.id_string()); + // The ticket is shown once, when the registration starts + assert_eq!(mine[0]["registrationUrl"], Value::Null, "{mine:?}"); + + // A name is required, and what the server sets can't be sent + let (_, response) = call( + &user, + "inbuxa:Passkey/set", + json!({"create": { + "blank": {"name": " "}, + "none": {}, + "state": {"name": "Key", "state": "active"} + }}), + ) + .await; + assert_eq!( + response["notCreated"]["blank"]["properties"][0], "name", + "{response}" + ); + assert_eq!( + response["notCreated"]["none"]["properties"][0], "name", + "{response}" + ); + assert_eq!( + response["notCreated"]["state"]["properties"][0], "state", + "{response}" + ); + + // PK-14: only the name changes + let (_, response) = call( + &user, + "inbuxa:Passkey/set", + json!({"update": { + phone_id.as_str(): {"name": "Work phone"} + }}), + ) + .await; + assert!( + response["updated"].get(phone_id.as_str()).is_some(), + "{response}" + ); + let (_, response) = call( + &user, + "inbuxa:Passkey/set", + json!({"update": {phone_id.as_str(): {"rpId": "example.com"}}}), + ) + .await; + assert_eq!( + response["notUpdated"][phone_id.as_str()]["properties"][0], + "rpId", + "{response}" + ); + assert_eq!(list(&user, &user).await[0]["name"], "Work phone"); + + // PK-5: ten per account, pending ones included + let mut create = serde_json::Map::new(); + for n in 0..10 { + create.insert(format!("k{n}"), json!({"name": format!("Key {n}")})); + } + let (_, response) = call(&user, "inbuxa:Passkey/set", json!({"create": create})).await; + let made = response["created"].as_object().map_or(0, |m| m.len()); + assert_eq!(made, 9, "{response}"); + let over = response["notCreated"] + .as_object() + .unwrap() + .values() + .next() + .unwrap(); + assert_eq!(over["type"], "overQuota", "{response}"); + assert_eq!(list(&user, &user).await.len(), 10); + + // Someone else's passkeys are out of reach for an ordinary account + let (name, response) = call( + &other, + "inbuxa:Passkey/get", + json!({"accountId": user.id_string(), "ids": null}), + ) + .await; + assert_eq!(name, "error", "another user read passkeys: {response}"); + let (_, response) = call( + &other, + "inbuxa:Passkey/set", + json!({"accountId": user.id_string(), "destroy": [phone_id]}), + ) + .await; + assert!( + response["destroyed"] + .as_array() + .is_none_or(|d| d.is_empty()), + "another user removed a passkey: {response}" + ); + assert!(list(&other, &other).await.is_empty()); + + // PK-16: an administrator sees and removes them + let seen = list(&admin, &user).await; + assert_eq!(seen.len(), 10, "{seen:?}"); + let all_ids = seen + .iter() + .map(|p| p["id"].as_str().unwrap().to_string()) + .collect::>(); + let (_, response) = call( + &admin, + "inbuxa:Passkey/set", + json!({"accountId": user.id_string(), "destroy": all_ids}), + ) + .await; + assert_eq!( + response["destroyed"].as_array().map_or(0, |d| d.len()), + 10, + "{response}" + ); + assert!(list(&user, &user).await.is_empty()); + + // PK-17: made and removed are in the audit log, by name + let (_, response) = call( + &admin, + "inbuxa:AuditEvent/query", + json!({"filter": {"targetKind": "inbuxa:Passkey"}}), + ) + .await; + let ids = response["ids"].clone(); + let (_, response) = call(&admin, "inbuxa:AuditEvent/get", json!({"ids": ids})).await; + let events = response["list"].as_array().unwrap(); + assert!( + events + .iter() + .any(|e| e["action"] == "create" && e["outcome"]["status"] == "success"), + "{response}" + ); + assert!( + events + .iter() + .any(|e| e["action"] == "destroy" && e["target"]["name"] == "Work phone"), + "no removal recorded by name: {response}" + ); +} + +#[ignore] +#[tokio::test(flavor = "multi_thread")] +pub async fn passkey_tests() { + let mut test = TestServerBuilder::new("passkey_tests") + .await + .with_default_listeners() + .await + .build() + .await; + let admin = test.create_admin_account("admin@example.com").await; + test.insert_account(admin); + self::test(&mut test).await; + if test.is_reset() { + test.temp_dir.delete(); + } +} -- 2.54.0