Struct RegistryVerifierResolver 

pub struct RegistryVerifierResolver { /* private fields */ }

A set of verification keys that can be registered and revoked while the server runs: the resolver for devices or peers that enrol after start-up (the immutable StaticVerifierResolver is fixed at construction). Holds every key type the verifier accepts: Ed25519, ESP256 and the two HMAC algorithms.

Share it as an Arc: hand a clone to the envelope (an Arc<dyn CoseVerifierResolver>) and keep one for register and revoke.

use std::sync::Arc;
use cratestack_cose::{
    CoseAlg, CoseVerifierResolver, Ed25519Signer, RegistryVerifierResolver,
};

let registry = Arc::new(RegistryVerifierResolver::new());
let for_envelope: Arc<dyn CoseVerifierResolver> = registry.clone();

let key = Ed25519Signer::from_seed(&[7; 32]).verify_key();
assert!(for_envelope.resolve(&key.kid(), CoseAlg::Ed25519).await?.is_empty());

let kid = registry.register(key.clone())?; // a device enrols
assert_eq!(kid, key.kid());
assert_eq!(for_envelope.resolve(&kid, CoseAlg::Ed25519).await?, vec![key]);

assert_eq!(registry.revoke(&kid), 1); // and is cut off
assert!(for_envelope.resolve(&kid, CoseAlg::Ed25519).await?.is_empty());

The kid is the first 8 bytes of the key’s RFC 9679 thumbprint, computed from the key (so it cannot be filed under another). Keys with the same kid (an 8-byte collision, or one HMAC secret registered for both HMAC algorithms) are all kept, and all returned for it.

Concurrency. Every call takes one short lock and none is held across an .await. A register or revoke is atomic: a concurrent resolve sees the registry wholly before it or wholly after. A request whose resolve already returned the key still finishes verifying with it, so a revocation takes effect for requests that resolve after it returns, not for ones already in flight. A register that returned is visible to every later resolve.

Unknown kids resolve to Ok(vec![]), never Err, as the trait requires. State is per process: replicas each need the same registrations.

Implementations

impl RegistryVerifierResolver

pub fn new() -> RegistryVerifierResolver

An empty registry with no bound on its size.

pub fn with_max_keys(max_keys: usize) -> RegistryVerifierResolver

An empty registry holding at most max_keys keys. A server that registers keys on behalf of callers uses this to bound memory.

use cratestack_cose::{Ed25519Signer, RegistryVerifierResolver};

let registry = RegistryVerifierResolver::with_max_keys(1);
registry.register(Ed25519Signer::from_seed(&[1; 32]).verify_key())?;
assert!(registry
    .register(Ed25519Signer::from_seed(&[2; 32]).verify_key())
    .is_err());

pub fn register(&self, key: CoseVerifyKey) -> Result<[u8; 8], CratestackError>

Register key and return its kid. Registering a key that is already present changes nothing and succeeds, even when the registry is full. Fails with CratestackError::Conflict when a new key would exceed the bound; the registry is then unchanged.

pub fn revoke(&self, kid: &[u8]) -> usize

Remove every key filed under kid and return how many there were (0 for an unknown or malformed kid: revoking twice is harmless). One HMAC secret registered for both algorithms goes with it, and so does any other key whose 8-byte kid collides (an unrelated device). To revoke one device, use revoke_key.

pub fn revoke_key(&self, key: &CoseVerifyKey) -> bool

Remove exactly key and nothing else that shares its kid. true if it was registered.

pub fn len(&self) -> usize

The number of registered keys.

pub fn is_empty(&self) -> bool

Whether no key is registered.

Trait Implementations

impl CoseVerifierResolver for RegistryVerifierResolver

fn resolve<'life0, 'life1, 'async_trait>( &'life0 self, kid: &'life1 [u8], alg: CoseAlg, ) -> Pin<Box<dyn Future<Output = Result<Vec<CoseVerifyKey>, CratestackError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, RegistryVerifierResolver: 'async_trait,

Every key whose kid is kid and which verifies alg; Ok(vec![]) if there is none. Err only for a backend failure.

impl Debug for RegistryVerifierResolver

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for RegistryVerifierResolver

fn default() -> RegistryVerifierResolver

Returns the “default value” for a type.