Struct lpc55_hal::drivers::aes::Aes

pub struct Aes<'a, Size: KeySize> { /* fields omitted */ }

Implementations

impl<'a, Size: KeySize> Aes<'a, Size>

pub fn new(
    hashcrypt: &'a mut Hashcrypt<Enabled>,
    key: Key<Size>,
    mode: Mode
) -> Self

New AES struct implementing block-cipher.

pub fn new_decrypt(
    hashcrypt: &'a mut Hashcrypt<Enabled>,
    key: Key<Size>
) -> Self

New AES starting in decryption mode

pub fn new_encrypt(
    hashcrypt: &'a mut Hashcrypt<Enabled>,
    key: Key<Size>
) -> Self

New AES starting in encryption mode

pub fn prime_for_decryption(&self)

Optionally, configure peripheral for decryption ahead of time.

pub fn prime_for_encryption(&self)

Optionally, configure peripheral for encryption ahead of time.

Methods from Deref<Target = Hashcrypt<Enabled>>

pub fn sha1<'a>(&'a mut self) -> Sha1<'a>

SHA-1, as in RustCrypto digest trait

pub fn sha256<'a>(&'a mut self) -> Sha256<'a>

SHA-256, as in RustCrypto digest trait

pub fn aes128<'a>(&'a mut self, key: &[u8; 16]) -> Aes128<'a>

AES-128 “ECB”, as in RustCrypto block-cipher trait

pub fn aes192<'a>(&'a mut self, key: &[u8; 24]) -> Aes192<'a>

AES-192 “ECB”, as in RustCrypto block-cipher trait

pub fn aes256<'a>(&'a mut self, key: &[u8; 32]) -> Aes256<'a>

AES-256 “ECB”, as in RustCrypto block-cipher trait

pub fn puf_aes<'a>(&'a mut self) -> Aes256<'a>

AES “ECB” with PUF key, for use as in RustCrypto block-cipher trait

DOES NOT PROPERLY CHECK IF PUF AES KEY IS SETUP YET! TODO: have user pass in some token signaling PUF AES key is setup

Trait Implementations

impl<'a, Size: KeySize> BlockCipher for Aes<'a, Size>

type BlockSize = U16

Size of the block in bytes

type ParBlocks = U1

Number of blocks which can be processed in parallel by cipher implementation

impl<'a, Size: KeySize> BlockDecrypt for Aes<'a, Size>

fn decrypt_block(&self, block: &mut Block<Self>)

Decrypt block in-place

pub fn decrypt_par_blocks(
    &self,
    blocks: &mut GenericArray<GenericArray<u8, Self::BlockSize>, Self::ParBlocks>
)

Decrypt several blocks in parallel using instruction level parallelism if possible.

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

Decrypt a slice of blocks, leveraging parallelism when available.

impl<'a, Size: KeySize> BlockEncrypt for Aes<'a, Size>

fn encrypt_block(&self, block: &mut Block<Self>)

Encrypt block in-place

pub fn encrypt_par_blocks(
    &self,
    blocks: &mut GenericArray<GenericArray<u8, Self::BlockSize>, Self::ParBlocks>
)

Encrypt several blocks in parallel using instruction level parallelism if possible.

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

Encrypt a slice of blocks, leveraging parallelism when available.

impl<Size: KeySize> Deref for Aes<'_, Size>

type Target = Hashcrypt<Enabled>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<Size: KeySize> DerefMut for Aes<'_, Size>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.