Struct Symmetric 

pub struct Symmetric<'d, M: Mode> { /* private fields */ }

Driver for the symmetric crypto engines: AES, hash and ChaCha.

See the module documentation.

use embassy_nrf::crypto::symmetric::{Sha256, Symmetric};

let mut crypto = Symmetric::new_blocking(p.CRYPTO_SYMMETRIC);
let mut ctx = crypto.hash_start::<Sha256>();
crypto.hash_blocking_update(&mut ctx, b"hello");
let digest = crypto.hash_blocking_finish(ctx);

Implementations

impl<'d, M: Mode> Symmetric<'d, M>

pub fn aes_start<C: Cipher>( &mut self, cipher: C, dir: Direction, ) -> AesContext<C>

Starts a cipher operation.

The returned context holds all the state of the operation. Pass it to the other aes_blocking_* methods.

pub fn aes_blocking_aad<C: AuthenticatedCipher>( &mut self, ctx: &mut AesContext<C>, aad: &[u8], last: bool, ) -> Result<(), Error>

Feeds additional authenticated data (AAD).

• Call it before feeding any payload.
• Chunks may have any size.
• last marks the final chunk. It is optional. The AAD phase also ends when the first payload chunk is fed, or when the operation is finished.

Errors: AadAfterPayload, InvalidLength for CCM if the total does not match aad_len.

pub fn aes_blocking_payload<C: Cipher>( &mut self, ctx: &mut AesContext<C>, input: &[u8], output: &mut [u8], last: bool, ) -> Result<(), Error>

Processes payload data from input into output.

• input and output must have the same length. For AesCmac, output is ignored and may be empty.
• last marks the final chunk.
• ECB and CBC: every chunk must be a multiple of the block length.
• GCM: every chunk except the last must be a multiple of the block length.
• CTR, CMAC and CCM: chunks may have any length.

Errors: InvalidLength.

pub fn aes_blocking_payload_in_place<C: Cipher>( &mut self, ctx: &mut AesContext<C>, data: &mut [u8], last: bool, ) -> Result<(), Error>

Processes payload data in place. See Self::aes_blocking_payload.

pub fn aes_blocking_finish<C: Cipher>( &mut self, ctx: AesContext<C>, ) -> Result<Option<[u8; 16]>, Error>

Finishes the operation.

For CMAC, CCM and GCM this returns the authentication tag. For CCM only the first tag_len bytes of it are valid. For the other modes it returns None.

When decrypting with an authenticated mode, compare the returned tag with the received one in constant time before using the plaintext.

Errors: InvalidLength for CCM if the totals do not match aad_len and payload_len.

impl<'d, M: Mode> Symmetric<'d, M>

pub fn chacha_start( &mut self, variant: ChaChaVariant, key: &[u8; 32], nonce: &[u8; 12], counter: u32, ) -> ChaChaContext

Starts a ChaCha keystream with the given key, nonce and initial block counter.

The (key, nonce) pair must never be reused.

pub fn chacha_blocking_apply_keystream( &mut self, ctx: &mut ChaChaContext, input: &[u8], output: &mut [u8], ) -> Result<(), Error>

XORs the next bytes of the keystream into input, writing the result to output.

Encryption and decryption are the same operation. Data may have any length.

Errors: InvalidLength if input and output have different lengths.

pub fn chacha_blocking_apply_keystream_in_place( &mut self, ctx: &mut ChaChaContext, data: &mut [u8], )

XORs the next bytes of the keystream into data in place.

impl<'d, M: Mode> Symmetric<'d, M>

pub fn chachapoly_start( &mut self, variant: ChaChaVariant, key: &[u8; 32], nonce: &[u8; 12], dir: Direction, ) -> ChaChaPolyContext

Starts a ChaCha-Poly1305 authenticated encryption or decryption. With ChaChaVariant::ChaCha20 this is RFC 8439 ChaCha20-Poly1305.

The (key, nonce) pair must never be reused. The returned context holds all the state of the operation. Pass it to the other chachapoly_blocking_* methods.

pub fn chachapoly_blocking_aad( &mut self, ctx: &mut ChaChaPolyContext, aad: &[u8], last: bool, ) -> Result<(), Error>

Feeds additional authenticated data (AAD).

• Call it before feeding any payload.
• Chunks may have any size.
• last marks the final chunk. It is optional. The AAD phase also ends when the first payload chunk is fed, or when the operation is finished.

Errors: AadAfterPayload.

pub fn chachapoly_blocking_payload( &mut self, ctx: &mut ChaChaPolyContext, input: &[u8], output: &mut [u8], last: bool, ) -> Result<(), Error>

Processes payload data from input into output.

• input and output must have the same length.
• last marks the final chunk.
• Every chunk except the last must be a multiple of the block length, 64 bytes.

Errors: InvalidLength.

pub fn chachapoly_blocking_payload_in_place( &mut self, ctx: &mut ChaChaPolyContext, data: &mut [u8], last: bool, ) -> Result<(), Error>

Processes payload data in place. See Self::chachapoly_blocking_payload.

pub fn chachapoly_blocking_finish( &mut self, ctx: ChaChaPolyContext, ) -> Result<[u8; 16], Error>

Finishes the operation and returns the 16-byte Poly1305 tag.

When decrypting, compare the returned tag with the received one in constant time before using the plaintext.

impl<'d, M: Mode> Symmetric<'d, M>

pub fn hash_start<A: HashAlgorithm>(&mut self) -> HashContext<A>

Starts a hash computation with algorithm A.

pub fn hmac_start<A: HashAlgorithm>(&mut self, key: &[u8]) -> HmacContext<A>

Starts an HMAC computation with algorithm A and the given key.

The key may have any length.

pub fn hash_blocking_update<H: DigestContext>( &mut self, ctx: &mut H, data: &[u8], )

Feeds message data into a hash or HMAC context.

Data may be fed in chunks of any size.

pub fn hash_blocking_finish<H: DigestContext>( &mut self, ctx: H, ) -> <H::Algorithm as HashAlgorithm>::Digest

Finishes a hash or HMAC context and returns the digest.

impl<'d> Symmetric<'d, Blocking>

pub fn new_blocking(_peri: Peri<'d, CRYPTO_SYMMETRIC>) -> Self

Creates a new blocking driver for the symmetric engines.