Trait Cipher

pub trait Cipher<'c> {
    const BLOCK_SIZE: usize;
    const REQUIRES_PADDING: bool = false;

    // Required methods
    fn key(&self) -> &[u8];
    fn iv(&self) -> &[u8];
    fn set_algomode(&self, p: Cryp);

    // Provided methods
    fn prepare_key(&self, _p: Cryp) { ... }
    fn init_phase_blocking<T: Instance, DmaIn, DmaOut>(
        &self,
        _p: Cryp,
        _cryp: &Cryp<'_, T, DmaIn, DmaOut>,
    ) { ... }
    async fn init_phase<T: Instance, DmaIn, DmaOut>(
        &self,
        _p: Cryp,
        _cryp: &mut Cryp<'_, T, DmaIn, DmaOut>,
    )
       where DmaIn: DmaIn<T>,
             DmaOut: DmaOut<T> { ... }
    fn pre_final(
        &self,
        _p: Cryp,
        _dir: Direction,
        _padding_len: usize,
    ) -> [u32; 4] { ... }
    fn post_final_blocking<T: Instance, DmaIn, DmaOut>(
        &self,
        _p: Cryp,
        _cryp: &Cryp<'_, T, DmaIn, DmaOut>,
        _dir: Direction,
        _int_data: &mut [u8; 16],
        _temp1: [u32; 4],
        _padding_mask: [u8; 16],
    ) { ... }
    async fn post_final<T: Instance, DmaIn, DmaOut>(
        &self,
        _p: Cryp,
        _cryp: &mut Cryp<'_, T, DmaIn, DmaOut>,
        _dir: Direction,
        _int_data: &mut [u8; 16],
        _temp1: [u32; 4],
        _padding_mask: [u8; 16],
    )
       where DmaIn: DmaIn<T>,
             DmaOut: DmaOut<T> { ... }
    fn get_header_block(&self) -> &[u8] { ... }
}

This trait encapsulates all cipher-specific behavior/

Required Associated Constants

const BLOCK_SIZE: usize

Processing block size. Determined by the processor and the algorithm.

Provided Associated Constants

const REQUIRES_PADDING: bool = false

Indicates whether the cipher requires the application to provide padding. If true, no partial blocks will be accepted (a panic will occur).

Required Methods

fn key(&self) -> &[u8]

Returns the symmetric key.

fn iv(&self) -> &[u8]

Returns the initialization vector.

fn set_algomode(&self, p: Cryp)

Sets the processor algorithm mode according to the associated cipher.

Provided Methods

fn prepare_key(&self, _p: Cryp)

Performs any key preparation within the processor, if necessary.

fn init_phase_blocking<T: Instance, DmaIn, DmaOut>( &self, _p: Cryp, _cryp: &Cryp<'_, T, DmaIn, DmaOut>, )

Performs any cipher-specific initialization.

async fn init_phase<T: Instance, DmaIn, DmaOut>( &self, _p: Cryp, _cryp: &mut Cryp<'_, T, DmaIn, DmaOut>, )

where DmaIn: DmaIn<T>, DmaOut: DmaOut<T>,

Performs any cipher-specific initialization.

fn pre_final(&self, _p: Cryp, _dir: Direction, _padding_len: usize) -> [u32; 4]

Called prior to processing the last data block for cipher-specific operations.

fn post_final_blocking<T: Instance, DmaIn, DmaOut>( &self, _p: Cryp, _cryp: &Cryp<'_, T, DmaIn, DmaOut>, _dir: Direction, _int_data: &mut [u8; 16], _temp1: [u32; 4], _padding_mask: [u8; 16], )

Called after processing the last data block for cipher-specific operations.

async fn post_final<T: Instance, DmaIn, DmaOut>( &self, _p: Cryp, _cryp: &mut Cryp<'_, T, DmaIn, DmaOut>, _dir: Direction, _int_data: &mut [u8; 16], _temp1: [u32; 4], _padding_mask: [u8; 16], )

where DmaIn: DmaIn<T>, DmaOut: DmaOut<T>,

Called after processing the last data block for cipher-specific operations.

fn get_header_block(&self) -> &[u8]

Returns the AAD header block as required by the cipher.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<'c, const KEY_SIZE: usize> Cipher<'c> for AesCbc<'c, KEY_SIZE>

const BLOCK_SIZE: usize = 16usize

const REQUIRES_PADDING: bool = true

impl<'c, const KEY_SIZE: usize> Cipher<'c> for AesCtr<'c, KEY_SIZE>

const BLOCK_SIZE: usize = 16usize

impl<'c, const KEY_SIZE: usize> Cipher<'c> for AesEcb<'c, KEY_SIZE>

const BLOCK_SIZE: usize = 16usize

const REQUIRES_PADDING: bool = true

impl<'c, const KEY_SIZE: usize> Cipher<'c> for AesGcm<'c, KEY_SIZE>

const BLOCK_SIZE: usize = 16usize

impl<'c, const KEY_SIZE: usize> Cipher<'c> for AesGmac<'c, KEY_SIZE>

const BLOCK_SIZE: usize = 16usize

impl<'c, const KEY_SIZE: usize> Cipher<'c> for DesCbc<'c, KEY_SIZE>

const BLOCK_SIZE: usize = 8usize

const REQUIRES_PADDING: bool = true

impl<'c, const KEY_SIZE: usize> Cipher<'c> for DesEcb<'c, KEY_SIZE>

const BLOCK_SIZE: usize = 8usize

const REQUIRES_PADDING: bool = true

impl<'c, const KEY_SIZE: usize> Cipher<'c> for TdesCbc<'c, KEY_SIZE>

const BLOCK_SIZE: usize = 8usize

const REQUIRES_PADDING: bool = true

impl<'c, const KEY_SIZE: usize> Cipher<'c> for TdesEcb<'c, KEY_SIZE>

const BLOCK_SIZE: usize = 8usize

const REQUIRES_PADDING: bool = true

impl<'c, const KEY_SIZE: usize, const TAG_SIZE: usize, const IV_SIZE: usize> Cipher<'c> for AesCcm<'c, KEY_SIZE, TAG_SIZE, IV_SIZE>

const BLOCK_SIZE: usize = 16usize