Struct ockam_vault_sync_core::VaultSync

pub struct VaultSync(_);

Vault sync wrapper

Implementations

impl VaultSync

pub fn start_another(&self) -> Result<Self>

Start another Vault at the same address.

impl VaultSync

pub fn create_with_mutex<T: VaultTrait>(vault: T) -> Self

Create and start a new Vault using Mutex.

pub async fn create_with_worker(
    ctx: &Context,
    vault_worker_address: Address,
    error_domain: &'static str
) -> Result<Self>

Create and start a new Vault using Worker.

pub async fn create<T: VaultTrait>(ctx: &Context, vault: T) -> Result<Self>

Start a Vault.

Trait Implementations

impl AsymmetricVault for VaultSync

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 Clone for VaultSync

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Hasher for VaultSync

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 KeyIdVault for VaultSync

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 SecretVault for VaultSync

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 Signer for VaultSync

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

Generate a signature for given data using given secret key

impl SymmetricVault for VaultSync

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 Verifier for VaultSync

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 Zeroize for VaultSync

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.