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> AsymmetricVault for VaultMutex<V>

fn ec_diffie_hellman(
    &mut self,
    context: &Secret,
    peer_public_key: &PublicKey
) -> Result<Secret>

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> Hasher for VaultMutex<V>

fn sha256(&mut self, data: &[u8]) -> Result<[u8; 32]>

Compute the SHA-256 digest given input data

fn hkdf_sha256(
    &mut self,
    salt: &Secret,
    info: &[u8],
    ikm: Option<&Secret>,
    output_attributes: SmallBuffer<SecretAttributes>
) -> Result<SmallBuffer<Secret>>

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

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

fn get_secret_by_key_id(&mut self, key_id: &str) -> Result<Secret>

Return Secret for given key id

fn compute_key_id_for_public_key(
    &mut self,
    public_key: &PublicKey
) -> Result<KeyId>

Return KeyId for given public key

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

fn secret_generate(&mut self, attributes: SecretAttributes) -> Result<Secret>

Generate fresh secret with given attributes

fn secret_import(
    &mut self,
    secret: &[u8],
    attributes: SecretAttributes
) -> Result<Secret>

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

fn secret_export(&mut self, context: &Secret) -> Result<SecretKey>

Export a secret key to the binary form represented as SecretKey

fn secret_attributes_get(
    &mut self,
    context: &Secret
) -> Result<SecretAttributes>

Get the attributes for a secret

fn secret_public_key_get(&mut self, context: &Secret) -> Result<PublicKey>

Return the associated public key given the secret key

fn secret_destroy(&mut self, context: Secret) -> Result<()>

Remove a secret from the vault

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

fn sign(&mut self, secret_key: &Secret, data: &[u8]) -> Result<[u8; 64]>

Generate a signature for given data using given secret key

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

fn aead_aes_gcm_encrypt(
    &mut self,
    context: &Secret,
    plaintext: &[u8],
    nonce: &[u8],
    aad: &[u8]
) -> Result<Buffer<u8>>

Encrypt a payload using AES-GCM

fn aead_aes_gcm_decrypt(
    &mut self,
    context: &Secret,
    cipher_text: &[u8],
    nonce: &[u8],
    aad: &[u8]
) -> Result<Buffer<u8>>

Decrypt a payload using AES-GCM

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

fn verify(
    &mut self,
    signature: &[u8; 64],
    public_key: &PublicKey,
    data: &[u8]
) -> Result<bool>

Verify a signature for given data using given public key

impl<V: Zeroize> Zeroize for VaultMutex<V>

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.