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(); }