Struct Encryptor

pub struct Encryptor<C>
where
    C: BlockEncryptMut + BlockCipher,
{ /* private fields */ }

CBC mode encryptor.

Trait Implementations

impl<C> AlgorithmName for Encryptor<C>

where C: BlockEncryptMut + BlockCipher + AlgorithmName,

fn write_alg_name(f: &mut Formatter<'_>) -> Result

Write algorithm name into f.

impl<C> BlockEncryptMut for Encryptor<C>

where C: BlockEncryptMut + BlockCipher,

fn encrypt_with_backend_mut( &mut self, f: impl BlockClosure<BlockSize = Self::BlockSize>, )

Encrypt data using backend provided to the rank-2 closure.

fn encrypt_block_inout_mut( &mut self, block: InOut<'_, '_, GenericArray<u8, Self::BlockSize>>, )

Encrypt single inout block.

fn encrypt_blocks_inout_mut( &mut self, blocks: InOutBuf<'_, '_, GenericArray<u8, Self::BlockSize>>, )

Encrypt inout blocks.

fn encrypt_block_mut(&mut self, block: &mut GenericArray<u8, Self::BlockSize>)

Encrypt single block in-place.

fn encrypt_block_b2b_mut( &mut self, in_block: &GenericArray<u8, Self::BlockSize>, out_block: &mut GenericArray<u8, Self::BlockSize>, )

Encrypt in_block and write result to out_block.

fn encrypt_blocks_mut( &mut self, blocks: &mut [GenericArray<u8, Self::BlockSize>], )

Encrypt blocks in-place.

fn encrypt_blocks_b2b_mut( &mut self, in_blocks: &[GenericArray<u8, Self::BlockSize>], out_blocks: &mut [GenericArray<u8, Self::BlockSize>], ) -> Result<(), NotEqualError>

Encrypt blocks buffer-to-buffer.

impl<C> BlockSizeUser for Encryptor<C>

where C: BlockEncryptMut + BlockCipher,

type BlockSize = <C as BlockSizeUser>::BlockSize

Size of the block in bytes.

fn block_size() -> usize

Return block size in bytes.

impl<C> Clone for Encryptor<C>

where C: BlockEncryptMut + BlockCipher + Clone,

fn clone(&self) -> Encryptor<C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C> Debug for Encryptor<C>

where C: BlockEncryptMut + BlockCipher + AlgorithmName,

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

Formats the value using the given formatter.

impl<C> InnerIvInit for Encryptor<C>

where C: BlockEncryptMut + BlockCipher,

fn inner_iv_init(cipher: C, iv: &Iv<Self>) -> Self

Initialize value using inner and iv array.

fn inner_iv_slice_init( inner: Self::Inner, iv: &[u8], ) -> Result<Self, InvalidLength>

Initialize value using inner and iv slice.

impl<C> InnerUser for Encryptor<C>

where C: BlockEncryptMut + BlockCipher,

type Inner = C

Inner type.

impl<C> IvSizeUser for Encryptor<C>

where C: BlockEncryptMut + BlockCipher,

type IvSize = <C as BlockSizeUser>::BlockSize

Initialization vector size in bytes.

fn iv_size() -> usize

Return IV size in bytes.

impl<C> IvState for Encryptor<C>

where C: BlockEncryptMut + BlockCipher,

fn iv_state(&self) -> Iv<Self>

Returns current IV state.

impl<C: BlockCipher + BlockEncryptMut + BlockDecrypt + BlockSizeUser> UnalignedBytesEncryptMut for Encryptor<C>

fn proc_tail( &self, blocks: &mut InOutBuf<'_, '_, Block<Self>>, tail: &mut InOutBuf<'_, '_, u8>, ) -> Result<(), TailError>

In many cases, plaintext and ciphertext input is not divisible by the block size, and padding is often used. In practical use, however, this is not always done, and the termination may be handled by, for example, XOR. This trait and fn [proc_tail] divides the input into aligned blocks and an unaligned part([tail]), and then applies appropriate user-specified processing to the [tail].

fn encrypt_bytes_inout_mut<'inp, 'out>( &mut self, data: InOutBuf<'inp, 'out, u8>, ) -> Result<&'out [u8], TailError>

Encrypt inout bytes slice.

fn encrypt_bytes_mut<'a>( &mut self, buf: &'a mut [u8], ) -> Result<&'a [u8], TailError>

Unaligned bytes input and encrypt in-place. Returns resulting plaintext slice.

fn encrypt_bytes_b2b_mut<'a>( &mut self, msg: &[u8], out_buf: &'a mut [u8], ) -> Result<&'a [u8], TailError>

Unaligned bytes input and encrypt buffer-to-buffer. Returns resulting plaintext slice.