Struct InMemoryMasterKey 

pub struct InMemoryMasterKey(/* private fields */);

In-memory master key for development and testing.

Stores the master key material directly in memory. Suitable for:

• Development and testing
• Single-node deployments with disk encryption
• Environments without HSM access

Security

The key material is zeroed on drop via ZeroizeOnDrop. However, for production deployments handling sensitive data, prefer an HSM-backed implementation.

Example

use kimberlite_crypto::encryption::{InMemoryMasterKey, MasterKeyProvider, KeyEncryptionKey};

let master = InMemoryMasterKey::generate();
let (kek, wrapped_kek) = KeyEncryptionKey::generate_and_wrap(&master);

// Store wrapped_kek.to_bytes() on disk...

Implementations

impl InMemoryMasterKey

pub fn from_bytes(bytes: &[u8; 32]) -> Self

Restores a master key from its 32-byte representation.

Security

Only use bytes from a previously generated key or secure backup. The bytes should come from encrypted-at-rest storage.

pub fn to_bytes(&self) -> [u8; 32]

Returns the raw 32-byte key material for backup.

Security

Handle with extreme care. This is the root secret of the entire key hierarchy. Only use this for:

• Secure backup to encrypted storage
• Key escrow with proper controls

Never log, transmit unencrypted, or store in plaintext.

pub fn generate() -> Self

Generates a new random master key using the OS CSPRNG.

This is the imperative shell - it handles IO (randomness) and delegates to a pure internal constructor for the actual construction.

Panics

Panics if the OS CSPRNG fails (catastrophic system error).

Trait Implementations

impl Drop for InMemoryMasterKey

fn drop(&mut self)

Executes the destructor for this type.

impl MasterKeyProvider for InMemoryMasterKey

fn wrap_kek(&self, kek_bytes: &[u8; 32]) -> WrappedKey

Wraps a Key Encryption Key for secure storage.

fn unwrap_kek(&self, wrapped: &WrappedKey) -> Result<[u8; 32], CryptoError>

Unwraps a Key Encryption Key from storage.

impl Zeroize for InMemoryMasterKey

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.