Grant the passkey permissions to existing roles on upgrade #483

Merged
jcoffey-dev merged 1 commits from fix/478-passkey-upgrade-grants into main 2026-11-19 17:05:59 +00:00
2 changed files with 246 additions and 5 deletions

No files matched your search

@@ -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<Permission> {
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));
}
}
+141 -3
View File
@@ -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::<Authentication>(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>(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<String, Value> = admin
.registry_get::<Role>(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(
"[email protected]",
"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(
"[email protected]",
"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<String, Value> = admin
.registry_get::<Role>(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("[email protected]").await;
test.insert_account(admin);
self::test(&mut test).await;
let admin = test.account("[email protected]");
upgraded_install(&test, admin).await;
if test.is_reset() {
test.temp_dir.delete();
}