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

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

Encrypt block in-place

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

Decrypt block in-place

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

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

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

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

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.