Struct Ocb3 

pub struct Ocb3<Cipher, NonceSize = U12, TagSize = U16>
where
    NonceSize: NonceSizes,
    TagSize: TagSizes,
{
    pub(crate) cipher: Cipher,
    pub(crate) nonce_size: PhantomData<NonceSize>,
    pub(crate) tag_size: PhantomData<TagSize>,
    pub(crate) ll_star: GenericArray<u8, U16>,
    pub(crate) ll_dollar: GenericArray<u8, U16>,
    pub(crate) ll: [GenericArray<u8, U16>; 32],
}

OCB3: generic over a block cipher implementation, nonce size, and tag size.

• NonceSize: max of 15-bytes, default and recommended size of 12-bytes (96-bits). We further restrict the minimum nonce size to 6-bytes to prevent an attack described in the following paper: https://eprint.iacr.org/2023/326.pdf.
• TagSize: non-zero, max of 16-bytes, default and recommended size of 16-bytes.

Compilation will fail if the size conditions are not satisfied:

// Invalid nonce size equal to 5 bytes
let cipher = Ocb3::<Aes128, U5>::new(&key);

// Invalid nonce size equal to 16 bytes
let cipher = Ocb3::<Aes128, U16>::new(&key);

// Invalid tag size equal to 0 bytes
let cipher = Ocb3::<Aes128, U12, U0>::new(&key);

// Invalid tag size equal to 20 bytes
let cipher = Ocb3::<Aes128, U12, U20>::new(&key);

Fields

cipher: Cipher

nonce_size: PhantomData<NonceSize>

tag_size: PhantomData<TagSize>

ll_star: GenericArray<u8, U16>

ll_dollar: GenericArray<u8, U16>

ll: [GenericArray<u8, U16>; 32]

Implementations

impl<Cipher, NonceSize, TagSize> Ocb3<Cipher, NonceSize, TagSize>

where Cipher: BlockSizeUser<BlockSize = U16> + BlockEncrypt + BlockDecrypt, NonceSize: NonceSizes, TagSize: TagSizes,

pub(crate) fn decrypt_in_place_return_tag( &self, nonce: &Nonce<NonceSize>, associated_data: &[u8], buffer: &mut [u8], ) -> Tag<Self>

Decrypts in place and returns expected tag.

pub(crate) fn wide_encrypt( &self, nonce: &Nonce<NonceSize>, buffer: &mut [u8], ) -> (usize, GenericArray<u8, U16>, GenericArray<u8, U16>)

Encrypts plaintext in groups of two.

Adapted from https://www.cs.ucdavis.edu/~rogaway/ocb/news/code/ocb.c

pub(crate) fn wide_decrypt( &self, nonce: &Nonce<NonceSize>, buffer: &mut [u8], ) -> (usize, GenericArray<u8, U16>, GenericArray<u8, U16>)

Decrypts plaintext in groups of two.

Adapted from https://www.cs.ucdavis.edu/~rogaway/ocb/news/code/ocb.c

impl<Cipher, NonceSize, TagSize> Ocb3<Cipher, NonceSize, TagSize>

where Cipher: BlockSizeUser<BlockSize = U16> + BlockEncrypt, NonceSize: NonceSizes, TagSize: TagSizes,

pub(crate) fn hash(&self, associated_data: &[u8]) -> GenericArray<u8, U16>

Computes HASH function defined in https://www.rfc-editor.org/rfc/rfc7253.html#section-4.1

pub(crate) fn compute_tag( &self, associated_data: &[u8], checksum_m: &mut GenericArray<u8, U16>, offset_m: &GenericArray<u8, U16>, ) -> Tag<TagSize>

Trait Implementations

impl<Cipher, NonceSize, TagSize> AeadCore for Ocb3<Cipher, NonceSize, TagSize>

where NonceSize: NonceSizes, TagSize: TagSizes,

type NonceSize = NonceSize

The length of a nonce.

type TagSize = TagSize

The maximum length of the nonce.

type CiphertextOverhead = UTerm

The upper bound amount of additional space required to support a ciphertext vs. a plaintext.

fn generate_nonce( rng: impl CryptoRng + RngCore, ) -> GenericArray<u8, Self::NonceSize>

where GenericArray<u8, Self::NonceSize>: Default,

Generate a random nonce for this AEAD algorithm.

impl<Cipher, NonceSize, TagSize> AeadInPlace for Ocb3<Cipher, NonceSize, TagSize>

where Cipher: BlockSizeUser<BlockSize = U16> + BlockEncrypt + BlockDecrypt, NonceSize: NonceSizes, TagSize: TagSizes,

fn encrypt_in_place_detached( &self, nonce: &Nonce<NonceSize>, associated_data: &[u8], buffer: &mut [u8], ) -> Result<Tag<Self>>

Encrypt the data in-place, returning the authentication tag

fn decrypt_in_place_detached( &self, nonce: &Nonce<NonceSize>, associated_data: &[u8], buffer: &mut [u8], tag: &Tag<Self>, ) -> Result<()>

Decrypt the message in-place, returning an error in the event the provided authentication tag does not match the given ciphertext (i.e. ciphertext is modified/unauthentic)

fn encrypt_in_place( &self, nonce: &GenericArray<u8, Self::NonceSize>, associated_data: &[u8], buffer: &mut dyn Buffer, ) -> Result<(), Error>

Encrypt the given buffer containing a plaintext message in-place.

fn decrypt_in_place( &self, nonce: &GenericArray<u8, Self::NonceSize>, associated_data: &[u8], buffer: &mut dyn Buffer, ) -> Result<(), Error>

Decrypt the message in-place, returning an error in the event the provided authentication tag does not match the given ciphertext.

impl<Cipher: Clone, NonceSize, TagSize> Clone for Ocb3<Cipher, NonceSize, TagSize>

where NonceSize: NonceSizes + Clone, TagSize: TagSizes + Clone,

fn clone(&self) -> Ocb3<Cipher, NonceSize, TagSize>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Cipher, NonceSize, TagSize> From<Cipher> for Ocb3<Cipher, NonceSize, TagSize>

where Cipher: BlockSizeUser<BlockSize = U16> + BlockEncrypt + BlockDecrypt, NonceSize: NonceSizes, TagSize: TagSizes,

fn from(cipher: Cipher) -> Self

Converts to this type from the input type.

impl<Cipher, NonceSize, TagSize> KeyInit for Ocb3<Cipher, NonceSize, TagSize>

where Cipher: BlockSizeUser<BlockSize = U16> + BlockEncrypt + KeyInit + BlockDecrypt, NonceSize: NonceSizes, TagSize: TagSizes,

fn new(key: &Key<Self>) -> Self

Create new value from fixed size key.

fn new_from_slice(key: &[u8]) -> Result<Self, InvalidLength>

Create new value from variable size key.

fn generate_key( rng: impl CryptoRng + RngCore, ) -> GenericArray<u8, Self::KeySize>

Generate random key using the provided CryptoRng.

impl<Cipher, NonceSize, TagSize> KeySizeUser for Ocb3<Cipher, NonceSize, TagSize>

where Cipher: KeySizeUser, NonceSize: NonceSizes, TagSize: TagSizes,

type KeySize = <Cipher as KeySizeUser>::KeySize

Key size in bytes.

fn key_size() -> usize

Return key size in bytes.