From e844ce552561499db9e4e219bd67b4e9fc52fbd0 Mon Sep 17 00:00:00 2001 From: John Coffey Date: Thu, 19 Nov 2026 09:46:25 -0700 Subject: [PATCH] Grant the passkey permissions to existing roles on upgrade An install from before rc.32 stored its default roles without sysPasskeyGet/Create/Update/Destroy, and granted_permissions.rs never added them, so nobody on an upgraded install could list or add a passkey. An administrator couldn't fix it by hand either: you can't grant a permission you don't hold. - Add a User audience that grants to the default user role (not the group role), and grant the four passkey permissions to the user, tenant administrator and administrator roles, once, as for the other fork permissions. - fork_defaults_reach_upgraded_installs: fails when DefaultPermissions gives a fork-added permission (SysAiExplain and later) to the user, tenant or administrator role and the upgrade grants don't carry it. - passkey_tests: strips the permissions from the stored roles, checks a new account is refused, runs the start-up defaults, and checks every role has them back, a new account can list its passkeys, the group role gets none, and a removed one isn't granted twice. Fixes #478 --- .../common/src/manager/granted_permissions.rs | 107 ++++++++++++- tests/src/system/passkeys.rs | 144 +++++++++++++++++- 2 files changed, 246 insertions(+), 5 deletions(-) diff --git a/crates/common/src/manager/granted_permissions.rs b/crates/common/src/manager/granted_permissions.rs index efa757bb..63fe7e07 100644 --- a/crates/common/src/manager/granted_permissions.rs +++ b/crates/common/src/manager/granted_permissions.rs @@ -6,8 +6,11 @@ //! Permissions the fork adds after an install's roles were stored. A new //! install's roles take them from `DefaultPermissions`; an older install's -//! administrator roles were written once, before the permission existed, so -//! each is added to them here, once. An operator who takes one away later +//! default roles (user, tenant administrator and administrator) were +//! written once, before the permission existed, so each is added to them +//! here, once. Every permission the fork adds to one of those defaults must +//! be listed here too: the `fork_defaults_reach_upgraded_installs` test +//! fails otherwise (inbuxa-server #478). An operator who takes one away later //! keeps it away: the grant is recorded and never repeated. use registry::schema::{ @@ -74,6 +77,22 @@ const ADMIN_GRANTS: &[Permission] = &[ Permission::SysStoreCheck, Permission::SysStoreSnapshot, Permission::SysBlobStoreChange, + // passkeys spec, PK-16: administrators remove them for recovery + Permission::SysPasskeyGet, + Permission::SysPasskeyCreate, + Permission::SysPasskeyUpdate, + Permission::SysPasskeyDestroy, +]; + +/// Granted to the default user role: managing one's own passkeys (passkeys +/// spec, PK-14). Without this an upgraded install's users, administrators +/// included, can't list or add a passkey, and nobody can grant it by hand: +/// you can't grant a permission you don't hold (#478). +const USER_GRANTS: &[Permission] = &[ + Permission::SysPasskeyGet, + Permission::SysPasskeyCreate, + Permission::SysPasskeyUpdate, + Permission::SysPasskeyDestroy, ]; /// Granted to the server-level Compliance Officer role once it exists: @@ -104,10 +123,16 @@ const TENANT_GRANTS: &[Permission] = &[ Permission::SysDeliverabilityGet, Permission::SysScheduledReportGet, Permission::SysScheduledReportUpdate, + // passkeys spec, PK-16: the tenant's administrators remove them for recovery + Permission::SysPasskeyGet, + Permission::SysPasskeyCreate, + Permission::SysPasskeyUpdate, + Permission::SysPasskeyDestroy, ]; #[derive(Clone, Copy, PartialEq, Eq)] enum Audience { + User, Admin, Tenant, Officer, @@ -118,6 +143,7 @@ fn granted_key(permission: Permission, audience: Audience) -> ValueClass { // Admin grants keep the key they were first recorded under match audience { Audience::Admin => {} + Audience::User => key.extend_from_slice(b"user:"), Audience::Tenant => key.extend_from_slice(b"tenant:"), Audience::Officer => key.extend_from_slice(b"officer:"), } @@ -129,6 +155,7 @@ fn granted_key(permission: Permission, audience: Audience) -> ValueClass { } pub(crate) async fn grant_new_admin_permissions(bp: &mut Bootstrap) -> trc::Result<()> { + grant(bp, Audience::User, USER_GRANTS).await?; grant(bp, Audience::Admin, ADMIN_GRANTS).await?; grant(bp, Audience::Tenant, TENANT_GRANTS).await?; grant(bp, Audience::Officer, OFFICER_GRANTS).await @@ -165,6 +192,12 @@ async fn grant(bp: &mut Bootstrap, audience: Audience, grants: &[Permission]) -> .await? .map(|auth| { let (own, shared) = match audience { + // The user role is shared by every default: only the + // group role, which no person signs in with, is left out + Audience::User => ( + auth.default_user_role_ids.as_slice(), + auth.default_group_role_ids.as_slice().to_vec(), + ), Audience::Admin => ( auth.default_admin_role_ids.as_slice(), [ @@ -235,3 +268,73 @@ async fn grant(bp: &mut Bootstrap, audience: Audience, grants: &[Permission]) -> .caused_by(trc::location!()) .map(|_| ()) } + +#[cfg(test)] +mod tests { + use super::*; + use crate::auth::permissions::DefaultPermissions; + use registry::types::EnumImpl; + + /// The first permission the fork added after the last upstream import. + /// Older ones came with the upstream defaults every install stored. + const FIRST_FORK_PERMISSION: Permission = Permission::SysAiExplain; + + fn fork_added(permissions: &[Permission]) -> Vec { + permissions + .iter() + .copied() + .filter(|p| p.to_id() >= FIRST_FORK_PERMISSION.to_id()) + .collect() + } + + /// #478: a permission the fork gives a default role must reach that role + /// on an upgraded install too, or upgraded installs never get it. + #[test] + fn fork_defaults_reach_upgraded_installs() { + let defaults = DefaultPermissions::default(); + for (role, defaults, grants) in [ + ("user", &defaults.user, USER_GRANTS), + ("tenant administrator", &defaults.tenant, TENANT_GRANTS), + ("administrator", &defaults.superuser, ADMIN_GRANTS), + ] { + let missing: Vec<_> = fork_added(defaults) + .into_iter() + .filter(|p| !grants.contains(p)) + .map(|p| p.as_str()) + .collect(); + assert!( + missing.is_empty(), + "the default {role} role gets {missing:?} on a new install only: \ + add them to granted_permissions.rs" + ); + } + // The group role takes none: nobody signs in as a group + assert!(fork_added(&defaults.group).is_empty()); + } + + /// Nothing is granted on upgrade that a new install's role wouldn't hold. + #[test] + fn grants_match_the_defaults() { + let defaults = DefaultPermissions::default(); + for (grants, defaults) in [ + (USER_GRANTS, &defaults.user), + (TENANT_GRANTS, &defaults.tenant), + (ADMIN_GRANTS, &defaults.superuser), + ] { + for permission in grants { + assert!(defaults.contains(permission), "{}", permission.as_str()); + } + } + } + + #[test] + fn audiences_record_apart() { + let key = |a| match granted_key(Permission::SysPasskeyGet, a) { + ValueClass::Any(k) => k.key, + _ => panic!(), + }; + assert_eq!(key(Audience::Admin), b"PgsysPasskeyGet"); + assert_eq!(key(Audience::User), b"Pguser:sysPasskeyGet"); + assert_ne!(key(Audience::User), key(Audience::Tenant)); + } +} diff --git a/tests/src/system/passkeys.rs b/tests/src/system/passkeys.rs index 52845718..f6bc3823 100644 --- a/tests/src/system/passkeys.rs +++ b/tests/src/system/passkeys.rs @@ -16,9 +16,14 @@ use crate::utils::{ server::{TestServer, TestServerBuilder}, }; use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD}; -use registry::schema::{ - prelude::{ObjectType, Property}, - structs::Authentication, +use common::manager::defaults::BootstrapDefaults; +use registry::{ + schema::{ + enums::Permission, + prelude::{ObjectType, Property}, + structs::{Authentication, Role}, + }, + types::EnumImpl, }; use ring::{ rand::SystemRandom, @@ -26,6 +31,12 @@ use ring::{ }; use serde_json::{Value, json}; use sha2::{Digest, Sha256}; +use store::{ + SUBSPACE_INBUXA, + registry::bootstrap::Bootstrap, + write::{AnyClass, BatchBuilder, ValueClass}, +}; +use types::id::Id; /// The page's origin: the test server's public URL. const ORIGIN: &str = "https://localhost:8899"; @@ -832,6 +843,131 @@ async fn policy(admin: &Account, user: &Account, key: &SoftKey, client_id: &str) assert_eq!(response["type"], "authenticated", "{response}"); } +const PASSKEY_PERMISSIONS: [Permission; 4] = [ + Permission::SysPasskeyGet, + Permission::SysPasskeyCreate, + Permission::SysPasskeyUpdate, + Permission::SysPasskeyDestroy, +]; + +/// #478: an install from before passkeys stored its default roles without +/// the passkey permissions. Start-up adds them once to the user, tenant +/// administrator and administrator roles, and never to the group role. +async fn upgraded_install(test: &TestServer, admin: &Account) { + let auth = admin.registry_get::(Id::singleton()).await; + let roles = [ + ("user", auth.default_user_role_ids.as_slice()[0], "Pguser:"), + ( + "tenant", + auth.default_tenant_role_ids.as_slice()[0], + "Pgtenant:", + ), + ("admin", auth.default_admin_role_ids.as_slice()[0], "Pg"), + ]; + let group_role = auth.default_group_role_ids.as_slice()[0]; + let held = |role_id: Id| async move { + let role = admin.registry_get::(role_id).await; + PASSKEY_PERMISSIONS + .iter() + .filter(|p| role.enabled_permissions.as_slice().contains(p)) + .count() + }; + for (name, role_id, _) in roles { + assert_eq!( + held(role_id).await, + 4, + "a new install's {name} role has them" + ); + } + + // Back to how a pre-passkey install stored them + let mut batch = BatchBuilder::new(); + for (_, role_id, prefix) in roles { + let others: serde_json::Map = admin + .registry_get::(role_id) + .await + .enabled_permissions + .as_slice() + .iter() + .filter(|p| !PASSKEY_PERMISSIONS.contains(p)) + .map(|p| (p.as_str().to_string(), Value::Bool(true))) + .collect(); + admin + .registry_update_object( + ObjectType::Role, + role_id, + json!({Property::EnabledPermissions: others}), + ) + .await; + for permission in PASSKEY_PERMISSIONS { + batch.clear(ValueClass::Any(AnyClass { + subspace: SUBSPACE_INBUXA, + key: format!("{prefix}{}", permission.as_str()).into_bytes(), + })); + } + } + let mut bp = Bootstrap::new_uninitialized(test.server.registry().clone()); + bp.data_store.write(batch.build_all()).await.unwrap(); + for (name, role_id, _) in roles { + assert_eq!(held(role_id).await, 0, "{name} role stripped"); + } + let before = admin + .create_user_account( + "passkey-before@example.com", + "passkey-before-7712", + "Before the upgrade", + &[], + vec![], + ) + .await; + let (name, response) = call(&before, "inbuxa:Passkey/get", json!({"ids": null})).await; + assert_eq!(name, "error", "refused before the upgrade: {response}"); + + // The upgrade: start-up grants them once + bp.insert_safe_defaults().await; + assert!(bp.errors.is_empty(), "{:?}", bp.errors); + for (name, role_id, _) in roles { + assert_eq!(held(role_id).await, 4, "{name} role granted on upgrade"); + } + assert_eq!(held(group_role).await, 0, "never the group role"); + // Start-up grants before anything is cached; here the server is already + // running, so drop its caches as a restart would + test.server.invalidate_all_local_caches(); + let after = admin + .create_user_account( + "passkey-after@example.com", + "passkey-after-8823", + "After the upgrade", + &[], + vec![], + ) + .await; + assert!(list(&after, &after).await.is_empty()); + + // An operator who takes them away again keeps them away + let user_role = roles[0].1; + let others: serde_json::Map = admin + .registry_get::(user_role) + .await + .enabled_permissions + .as_slice() + .iter() + .filter(|p| **p != Permission::SysPasskeyCreate) + .map(|p| (p.as_str().to_string(), Value::Bool(true))) + .collect(); + admin + .registry_update_object( + ObjectType::Role, + user_role, + json!({Property::EnabledPermissions: others}), + ) + .await; + Bootstrap::new_uninitialized(test.server.registry().clone()) + .insert_safe_defaults() + .await; + assert_eq!(held(user_role).await, 3, "not granted twice"); +} + #[ignore] #[tokio::test(flavor = "multi_thread")] pub async fn passkey_tests() { @@ -845,6 +981,8 @@ pub async fn passkey_tests() { let admin = test.create_admin_account("admin@example.com").await; test.insert_account(admin); self::test(&mut test).await; + let admin = test.account("admin@example.com"); + upgraded_install(&test, admin).await; if test.is_reset() { test.temp_dir.delete(); } -- 2.54.0