Struct dryoc::dryocbox::DryocBox

pub struct DryocBox<EphemeralPublicKey: ByteArray<CRYPTO_BOX_PUBLICKEYBYTES> + Zeroize, Mac: ByteArray<CRYPTO_BOX_MACBYTES> + Zeroize, Data: Bytes + Zeroize> { /* private fields */ }

A libsodium public-key authenticated encrypted box.

Refer to crate::dryocbox for sample usage.

Implementations

impl<EphemeralPublicKey: ByteArray<CRYPTO_BOX_PUBLICKEYBYTES> + Zeroize, Mac: NewByteArray<CRYPTO_BOX_MACBYTES> + Zeroize, Data: NewBytes + ResizableBytes + Zeroize> DryocBox<EphemeralPublicKey, Mac, Data>

pub fn encrypt<Message: Bytes + ?Sized, Nonce: ByteArray<CRYPTO_BOX_NONCEBYTES>, RecipientPublicKey: ByteArray<CRYPTO_BOX_PUBLICKEYBYTES>, SenderSecretKey: ByteArray<CRYPTO_BOX_SECRETKEYBYTES>>( message: &Message, nonce: &Nonce, recipient_public_key: &RecipientPublicKey, sender_secret_key: &SenderSecretKey ) -> Result<Self, Error>

Encrypts a message using sender_secret_key for recipient_public_key, and returns a new DryocBox with ciphertext and tag.

impl<EphemeralPublicKey: NewByteArray<CRYPTO_BOX_PUBLICKEYBYTES> + Zeroize, Mac: NewByteArray<CRYPTO_BOX_MACBYTES> + Zeroize, Data: NewBytes + ResizableBytes + Zeroize> DryocBox<EphemeralPublicKey, Mac, Data>

pub fn seal<Message: Bytes + ?Sized, RecipientPublicKey: ByteArray<CRYPTO_BOX_PUBLICKEYBYTES>>( message: &Message, recipient_public_key: &RecipientPublicKey ) -> Result<Self, Error>

Encrypts a message for recipient_public_key, using an ephemeral secret key and nonce. Returns a new DryocBox with ciphertext, tag, and ephemeral public key.

impl<'a, EphemeralPublicKey: ByteArray<CRYPTO_BOX_PUBLICKEYBYTES> + TryFrom<&'a [u8]> + Zeroize, Mac: ByteArray<CRYPTO_BOX_MACBYTES> + TryFrom<&'a [u8]> + Zeroize, Data: Bytes + From<&'a [u8]> + Zeroize> DryocBox<EphemeralPublicKey, Mac, Data>

pub fn from_bytes(bytes: &'a [u8]) -> Result<Self, Error>

Initializes a DryocBox from a slice. Expects the first CRYPTO_BOX_MACBYTES bytes to contain the message authentication tag, with the remaining bytes containing the encrypted message.

pub fn from_sealed_bytes(bytes: &'a [u8]) -> Result<Self, Error>

Initializes a sealed DryocBox from a slice. Expects the first CRYPTO_BOX_PUBLICKEYBYTES bytes to contain the ephemeral public key, the next CRYPTO_BOX_MACBYTES bytes to be the message authentication tag, with the remaining bytes containing the encrypted message.

impl<EphemeralPublicKey: ByteArray<CRYPTO_BOX_PUBLICKEYBYTES> + Zeroize, Mac: ByteArray<CRYPTO_BOX_MACBYTES> + Zeroize, Data: Bytes + Zeroize> DryocBox<EphemeralPublicKey, Mac, Data>

pub fn from_parts( tag: Mac, data: Data, ephemeral_pk: Option<EphemeralPublicKey> ) -> Self

Returns a new box with tag, data and (optional) ephemeral_pk, consuming each.

pub fn to_vec(&self) -> Vec<u8>

Copies self into a new Vec

pub fn into_parts(self) -> (Mac, Data, Option<EphemeralPublicKey>)

Moves the tag, data, and (optional) ephemeral public key out of this instance, returning them as a tuple.

pub fn decrypt<Nonce: ByteArray<CRYPTO_BOX_NONCEBYTES>, SenderPublicKey: ByteArray<CRYPTO_BOX_PUBLICKEYBYTES>, RecipientSecretKey: ByteArray<CRYPTO_BOX_SECRETKEYBYTES>, Output: ResizableBytes + NewBytes>( &self, nonce: &Nonce, sender_public_key: &SenderPublicKey, recipient_secret_key: &RecipientSecretKey ) -> Result<Output, Error>

Decrypts this box using nonce, recipient_secret_key, and sender_public_key, returning the decrypted message upon success.

pub fn unseal<RecipientPublicKey: ByteArray<CRYPTO_BOX_PUBLICKEYBYTES> + Zeroize, RecipientSecretKey: ByteArray<CRYPTO_BOX_SECRETKEYBYTES> + Zeroize, Output: ResizableBytes + NewBytes + Zeroize>( &self, recipient_keypair: &KeyPair<RecipientPublicKey, RecipientSecretKey> ) -> Result<Output, Error>

Decrypts this sealed box using recipient_secret_key, and returning the decrypted message upon success.

pub fn to_bytes<Bytes: NewBytes + ResizableBytes>(&self) -> Bytes

Copies self into the target. Can be used with protected memory.

impl DryocBox<PublicKey, Mac, Vec<u8>>

pub fn encrypt_to_vecbox<Message: Bytes + ?Sized, SecretKey: ByteArray<CRYPTO_BOX_SECRETKEYBYTES>>( message: &Message, nonce: &Nonce, recipient_public_key: &PublicKey, sender_secret_key: &SecretKey ) -> Result<Self, Error>

Encrypts a message using sender_secret_key for recipient_public_key, and returns a new DryocBox with ciphertext and tag.

pub fn seal_to_vecbox<Message: Bytes + ?Sized>( message: &Message, recipient_public_key: &PublicKey ) -> Result<Self, Error>

Encrypts a message for recipient_public_key, using an ephemeral secret key and nonce, and returns a new DryocBox with the ciphertext, ephemeral public key, and tag.

pub fn decrypt_to_vec<SecretKey: ByteArray<CRYPTO_BOX_SECRETKEYBYTES>>( &self, nonce: &Nonce, sender_public_key: &PublicKey, recipient_secret_key: &SecretKey ) -> Result<Vec<u8>, Error>

Decrypts this box using nonce, recipient_secret_key and sender_public_key, returning the decrypted message upon success.

pub fn unseal_to_vec<RecipientPublicKey: ByteArray<CRYPTO_BOX_PUBLICKEYBYTES> + Zeroize, RecipientSecretKey: ByteArray<CRYPTO_BOX_SECRETKEYBYTES> + Zeroize>( &self, recipient_keypair: &KeyPair<RecipientPublicKey, RecipientSecretKey> ) -> Result<Vec<u8>, Error>

Decrypts this sealed box using recipient_secret_key, returning the decrypted message upon success.

impl<'a, EphemeralPublicKey: ByteArray<CRYPTO_BOX_PUBLICKEYBYTES> + Zeroize, Mac: ByteArray<CRYPTO_BOX_MACBYTES> + Zeroize, Data: Bytes + ResizableBytes + From<&'a [u8]> + Zeroize> DryocBox<EphemeralPublicKey, Mac, Data>

pub fn new_with_data_and_mac(tag: Mac, input: &'a [u8]) -> Self

Returns a new box with data and tag, with data copied from input and tag consumed. The ephemeral public key is assumed not to be present.

pub fn new_with_epk_data_and_mac( ephemeral_pk: EphemeralPublicKey, tag: Mac, input: &'a [u8] ) -> Self

Returns a new sealed box with ephemeral_pk, data and tag, where data copied from input and ephemeral_pk & tag are consumed.

Trait Implementations

impl<EphemeralPublicKey: Clone + ByteArray<CRYPTO_BOX_PUBLICKEYBYTES> + Zeroize, Mac: Clone + ByteArray<CRYPTO_BOX_MACBYTES> + Zeroize, Data: Clone + Bytes + Zeroize> Clone for DryocBox<EphemeralPublicKey, Mac, Data>

fn clone(&self) -> DryocBox<EphemeralPublicKey, Mac, Data>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<EphemeralPublicKey: Debug + ByteArray<CRYPTO_BOX_PUBLICKEYBYTES> + Zeroize, Mac: Debug + ByteArray<CRYPTO_BOX_MACBYTES> + Zeroize, Data: Debug + Bytes + Zeroize> Debug for DryocBox<EphemeralPublicKey, Mac, Data>

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

Formats the value using the given formatter.

impl<'de, EphemeralPublicKey, Mac, Data> Deserialize<'de> for DryocBox<EphemeralPublicKey, Mac, Data>

where EphemeralPublicKey: Deserialize<'de> + ByteArray<CRYPTO_BOX_PUBLICKEYBYTES> + Zeroize, Mac: Deserialize<'de> + ByteArray<CRYPTO_BOX_MACBYTES> + Zeroize, Data: Deserialize<'de> + Bytes + Zeroize,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<EphemeralPublicKey: ByteArray<CRYPTO_BOX_PUBLICKEYBYTES> + Zeroize, Mac: ByteArray<CRYPTO_BOX_MACBYTES> + Zeroize, Data: Bytes + Zeroize> PartialEq for DryocBox<EphemeralPublicKey, Mac, Data>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<EphemeralPublicKey, Mac, Data> Serialize for DryocBox<EphemeralPublicKey, Mac, Data>

where EphemeralPublicKey: Serialize + ByteArray<CRYPTO_BOX_PUBLICKEYBYTES> + Zeroize, Mac: Serialize + ByteArray<CRYPTO_BOX_MACBYTES> + Zeroize, Data: Serialize + Bytes + Zeroize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<EphemeralPublicKey: ByteArray<CRYPTO_BOX_PUBLICKEYBYTES> + Zeroize, Mac, Data> Zeroize for DryocBox<EphemeralPublicKey, Mac, Data>

where Mac: Zeroize + ByteArray<CRYPTO_BOX_MACBYTES>, Data: Zeroize + Bytes,

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.