Struct ockam_vault_sync_core::VaultMutex

pub struct VaultMutex<V>(_);

Vault inside Arc Mutex

Implementations

impl<V> VaultMutex<V>

pub fn create(vault: V) -> Self

Create and start a new Vault using Mutex.

Trait Implementations

impl<V: AsymmetricVault + Send> AsymmetricVault for VaultMutex<V>

fn ec_diffie_hellman<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 mut self,
    context: &'life1 Secret,
    peer_public_key: &'life2 PublicKey
) -> Pin<Box<dyn Future<Output = Result<Secret>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

Compute Elliptic-Curve Diffie-Hellman using this secret key and the specified uncompressed public key

impl<V> Clone for VaultMutex<V>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<V: Hasher + Send> Hasher for VaultMutex<V>

fn sha256<'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    data: &'life1 [u8]
) -> Pin<Box<dyn Future<Output = Result<[u8; 32]>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Compute the SHA-256 digest given input data

fn hkdf_sha256<'life0, 'life1, 'life2, 'life3, 'async_trait>(
    &'life0 mut self,
    salt: &'life1 Secret,
    info: &'life2 [u8],
    ikm: Option<&'life3 Secret>,
    output_attributes: SmallBuffer<SecretAttributes>
) -> Pin<Box<dyn Future<Output = Result<SmallBuffer<Secret>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    Self: 'async_trait, 

Derive multiple output Secrets with given attributes using the HKDF-SHA256 using specified salt, input key material and info.

impl<V: KeyIdVault + Send> KeyIdVault for VaultMutex<V>

fn get_secret_by_key_id<'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    key_id: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<Secret>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Return Secret for given key id

fn compute_key_id_for_public_key<'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    public_key: &'life1 PublicKey
) -> Pin<Box<dyn Future<Output = Result<KeyId>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Return KeyId for given public key

impl<V: SecretVault + Send> SecretVault for VaultMutex<V>

fn secret_generate<'life0, 'async_trait>(
    &'life0 mut self,
    attributes: SecretAttributes
) -> Pin<Box<dyn Future<Output = Result<Secret>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Generate fresh secret with given attributes

fn secret_import<'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    secret: &'life1 [u8],
    attributes: SecretAttributes
) -> Pin<Box<dyn Future<Output = Result<Secret>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Import a secret with given attributes from binary form into the vault

fn secret_export<'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    context: &'life1 Secret
) -> Pin<Box<dyn Future<Output = Result<SecretKey>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Export a secret key to the binary form represented as SecretKey

fn secret_attributes_get<'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    context: &'life1 Secret
) -> Pin<Box<dyn Future<Output = Result<SecretAttributes>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Get the attributes for a secret

fn secret_public_key_get<'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    context: &'life1 Secret
) -> Pin<Box<dyn Future<Output = Result<PublicKey>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Return the associated public key given the secret key

fn secret_destroy<'life0, 'async_trait>(
    &'life0 mut self,
    context: Secret
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Remove a secret from the vault

impl<V: Signer + Send> Signer for VaultMutex<V>

fn sign<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 mut self,
    secret_key: &'life1 Secret,
    data: &'life2 [u8]
) -> Pin<Box<dyn Future<Output = Result<Signature>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

Generate a signature for given data using given secret key

impl<V: SymmetricVault + Send> SymmetricVault for VaultMutex<V>

fn aead_aes_gcm_encrypt<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
    &'life0 mut self,
    context: &'life1 Secret,
    plaintext: &'life2 [u8],
    nonce: &'life3 [u8],
    aad: &'life4 [u8]
) -> Pin<Box<dyn Future<Output = Result<Buffer<u8>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    'life4: 'async_trait,
    Self: 'async_trait, 

Encrypt a payload using AES-GCM

fn aead_aes_gcm_decrypt<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
    &'life0 mut self,
    context: &'life1 Secret,
    cipher_text: &'life2 [u8],
    nonce: &'life3 [u8],
    aad: &'life4 [u8]
) -> Pin<Box<dyn Future<Output = Result<Buffer<u8>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    'life4: 'async_trait,
    Self: 'async_trait, 

Decrypt a payload using AES-GCM

impl<V: Verifier + Send> Verifier for VaultMutex<V>

fn verify<'life0, 'life1, 'life2, 'life3, 'async_trait>(
    &'life0 mut self,
    signature: &'life1 Signature,
    public_key: &'life2 PublicKey,
    data: &'life3 [u8]
) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    Self: 'async_trait, 

Verify a signature for given data using given public key