Struct dryoc::dryocbox::DryocBox

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

A libsodium public-key authenticated encrypted box.

Refer to crate::dryocbox for sample usage.

Implementations

impl<EphemeralPublicKey: ByteArray<CRYPTO_BOX_PUBLICKEYBYTES>, Mac: NewByteArray<CRYPTO_BOX_MACBYTES>, Data: NewBytes + ResizableBytes> 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>, Mac: NewByteArray<CRYPTO_BOX_MACBYTES>, Data: NewBytes + ResizableBytes> 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]>, Mac: ByteArray<CRYPTO_BOX_MACBYTES> + TryFrom<&'a [u8]>, Data: Bytes + From<&'a [u8]>> 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>, Mac: ByteArray<CRYPTO_BOX_MACBYTES>, Data: Bytes> 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>, RecipientSecretKey: ByteArray<CRYPTO_BOX_SECRETKEYBYTES>, Output: ResizableBytes + NewBytes>(
    &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>, RecipientSecretKey: ByteArray<CRYPTO_BOX_SECRETKEYBYTES>>(
    &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>, Mac: ByteArray<CRYPTO_BOX_MACBYTES>, Data: Bytes + ResizableBytes + From<&'a [u8]>> 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>, Mac: Clone + ByteArray<CRYPTO_BOX_MACBYTES>, Data: Clone + Bytes> 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>, Mac: Debug + ByteArray<CRYPTO_BOX_MACBYTES>, Data: Debug + Bytes> Debug for DryocBox<EphemeralPublicKey, Mac, Data>

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

Formats the value using the given formatter.

impl<'de, EphemeralPublicKey: ByteArray<CRYPTO_BOX_PUBLICKEYBYTES>, Mac: ByteArray<CRYPTO_BOX_MACBYTES>, Data: Bytes> Deserialize<'de> for DryocBox<EphemeralPublicKey, Mac, Data>where
    EphemeralPublicKey: Deserialize<'de>,
    Mac: Deserialize<'de>,
    Data: Deserialize<'de>,

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>, Mac: ByteArray<CRYPTO_BOX_MACBYTES>, Data: Bytes> PartialEq<DryocBox<EphemeralPublicKey, Mac, Data>> 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: ByteArray<CRYPTO_BOX_PUBLICKEYBYTES>, Mac: ByteArray<CRYPTO_BOX_MACBYTES>, Data: Bytes> Serialize for DryocBox<EphemeralPublicKey, Mac, Data>where
    EphemeralPublicKey: Serialize,
    Mac: Serialize,
    Data: Serialize,

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>, Mac: ByteArray<CRYPTO_BOX_MACBYTES>, Data: Bytes> Zeroize for DryocBox<EphemeralPublicKey, Mac, Data>where
    Option<EphemeralPublicKey>: Zeroize,
    EphemeralPublicKey: Zeroize,
    Mac: Zeroize,
    Data: Zeroize,

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.