Struct LocalKms 

pub struct LocalKms { /* private fields */ }

File-based KEK store for dev / on-prem deployments.

Layout

<dir>/
  alpha.kek         # 32 raw bytes — KEK for key_id "alpha"
  beta.kek          # 32 raw bytes — KEK for key_id "beta"

Files are loaded eagerly at LocalKms::open time; subsequent adds/removals require a restart. KEK files MUST be exactly 32 bytes (other formats — hex / base64 — are intentionally not accepted here, unlike crate::sse::SseKey, because operators generating KEKs for KMS use should produce raw randomness from /dev/urandom rather than human-edited files).

Wrap algorithm

LocalKms wraps DEKs with AES-256-GCM using the KEK as the cipher key. The wrapped form is nonce(12) || ciphertext(32) || tag(16) = 60 bytes for a 32-byte DEK. The nonce is fresh per wrap, drawn from OsRng; the AAD is the UTF-8 key_id so a wrap under one id can’t be replayed under another.

Implementations

impl LocalKms

pub fn open(dir: PathBuf) -> Result<Self, KmsError>

Open a KEK directory. Reads every *.kek file; each must be exactly 32 raw bytes. The basename (sans .kek) becomes the key_id used in KmsBackend::generate_dek / WrappedDek.

An empty directory is a valid (but useless) state — callers that haven’t loaded any KEKs will still see all generate_dek calls return KmsError::KeyNotFound.

pub fn from_keks(dir: PathBuf, keks: HashMap<String, [u8; 32]>) -> Self

Construct a LocalKms directly from in-memory KEKs. Useful for tests and for callers that load KEKs out of band (e.g. from a sealed config blob). Production deployments should prefer LocalKms::open.

pub fn key_ids(&self) -> Vec<String>

Sorted list of key ids present in this backend. Used by the CLI --list-kms-keys flag (orchestrator wires that) and by readiness probes that want to assert a specific key is loaded.

Trait Implementations

impl Debug for LocalKms

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

Formats the value using the given formatter.

impl KmsBackend for LocalKms

fn generate_dek<'life0, 'life1, 'async_trait>( &'life0 self, key_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(Vec<u8>, WrappedDek), KmsError>> + Send + 'async_trait>>

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

Generate a fresh 32-byte DEK and return both the plaintext (used immediately for AES-GCM encryption of the object body) and the wrapped form (persisted in the S4E4 frame).

fn decrypt_dek<'life0, 'life1, 'async_trait>( &'life0 self, wrapped: &'life1 WrappedDek, ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, KmsError>> + Send + 'async_trait>>

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

Unwrap a stored DEK ciphertext back to plaintext for the decrypt path. The 32-byte plaintext must be zeroed by the caller after use (callers in this crate hold it in a stack [u8; 32] for the duration of one GET).