Struct MemoryKeyRing 

pub struct MemoryKeyRing { /* private fields */ }

A key ring in this process. For tests.

It holds the wrapping keys beside the data they protect, so it protects that data from nobody: anyone who can read the ciphertext can read the keys. What it does model faithfully is the shape a real service has — a named wrapping key per scope, a fresh data key per call, and erasure by destroying the wrapping key rather than by refusing to look.

Implementations

impl MemoryKeyRing

pub fn new() -> Self

pub fn rotate(&self)

Move to a new wrapping key.

The next mint draws a fresh KEK under the new generation; prior generations keep their keys, so envelopes sealed before the rotation still open. That is the property sealed-byte immutability rests on — rotation adds a version, it does not invalidate one — and it is what makes rotation something other than an outage.

pub fn retire_below(&self, generation: u64)

Refuse to decrypt below generation, as a KMS version floor does.

Vault’s min_decryption_version and its equivalents elsewhere. Modelled here because it is the one operator action that makes un-erased history unreadable, and a ring that could not express it would leave KeyError::Retired unreachable in every test — an error variant no test can produce is a classification nothing proves the runtime honours.

pub fn current_key_id(&self) -> KeyId

The current wrapping key’s id.

Trait Implementations

impl Debug for MemoryKeyRing

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

Formats the value using the given formatter.

impl Default for MemoryKeyRing

fn default() -> Self

Returns the “default value” for a type.

impl KeyRing for MemoryKeyRing

fn data_key<'life0, 'life1, 'async_trait>( &'life0 self, scope: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(DataKey, WrappedKey), KeyError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Mint a fresh data key, wrapped under the scope’s key.

fn open<'life0, 'life1, 'async_trait>( &'life0 self, wrapped: &'life1 WrappedKey, ) -> Pin<Box<dyn Future<Output = Result<DataKey, KeyError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Open a wrapped data key.

fn destroy<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, scope: &'life1 str, at: Timestamp, reason: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<(), KeyError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Destroy a scope’s data key. This is the erasure.