CRYPTO - Cryptography Accelerator#

CRYPTO_ModulusId_TypeDef#

CRYPTO_ModulusId_TypeDef

CRYPTO modulus identifiers.

CRYPTO_MulOperandWidth_TypeDef#

CRYPTO_MulOperandWidth_TypeDef

CRYPTO multiplication widths for wide arithmetic operations.

CRYPTO_ResultWidth_TypeDef#

CRYPTO_ResultWidth_TypeDef

CRYPTO result widths for MUL operations.

CRYPTO_IncWidth_TypeDef#

CRYPTO_IncWidth_TypeDef

CRYPTO result widths for MUL operations.

CRYPTO_KeyWidth_TypeDef#

CRYPTO_KeyWidth_TypeDef

CRYPTO key width.

CRYPTO_Data_TypeDef#

typedef uint32_t CRYPTO_Data_TypeDef[CRYPTO_DATA_SIZE_IN_32BIT_WORDS] [CRYPTO_DATA_SIZE_IN_32BIT_WORDS]

CRYPTO data types used for data load functions.

This data type is capable of storing a 128 bits value as used in the crypto DATA registers.

CRYPTO_DData_TypeDef#

typedef uint32_t CRYPTO_DData_TypeDef[CRYPTO_DDATA_SIZE_IN_32BIT_WORDS] [CRYPTO_DDATA_SIZE_IN_32BIT_WORDS]

CRYPTO data type used for data load functions.

This data type is capable of storing a 256 bits value as used in the crypto DDATA registers.

CRYPTO_QData_TypeDef#

typedef uint32_t CRYPTO_QData_TypeDef[CRYPTO_QDATA_SIZE_IN_32BIT_WORDS] [CRYPTO_QDATA_SIZE_IN_32BIT_WORDS]

CRYPTO data type used for data load functions.

This data type is capable of storing a 512 bits value as used in the crypto QDATA registers.

CRYPTO_Data260_TypeDef#

typedef uint32_t CRYPTO_Data260_TypeDef[CRYPTO_DATA260_SIZE_IN_32BIT_WORDS] [CRYPTO_DATA260_SIZE_IN_32BIT_WORDS]

CRYPTO data type used for data load functions.

This data type is capable of storing a 260 bits value as used by the CRYPTO_DData0Write260 function.

Note that this data type is multiple of 32 bit words, so the actual storage used by this type is 32x9=288 bits.

CRYPTO_KeyBuf_TypeDef#

typedef uint32_t CRYPTO_KeyBuf_TypeDef[CRYPTO_KEYBUF_SIZE_IN_32BIT_WORDS] [CRYPTO_KEYBUF_SIZE_IN_32BIT_WORDS]

CRYPTO data type used for data load functions.

This data type is capable of storing 256 bits as used in the crypto KEYBUF register.

CRYPTO_DataReg_TypeDef#

typedef volatile uint32_t* CRYPTO_DataReg_TypeDef

CRYPTO 128 bit Data register pointer type.

The 128 bit registers are used to load 128 bit values as input and output data for cryptographic and big integer arithmetic functions of the CRYPTO module.

CRYPTO_DDataReg_TypeDef#

typedef volatile uint32_t* CRYPTO_DDataReg_TypeDef

CRYPTO 256 bit DData (Double Data) register pointer type.

The 256 bit registers are used to load 256 bit values as input and output data for cryptographic and big integer arithmetic functions of the CRYPTO module.

CRYPTO_QDataReg_TypeDef#

typedef volatile uint32_t* CRYPTO_QDataReg_TypeDef

CRYPTO 512 bit QData (Quad data) register pointer type.

The 512 bit registers are used to load 512 bit values as input and output data for cryptographic and big integer arithmetic functions of the CRYPTO module.

CRYPTO_InstructionSequence_TypeDef#

typedef uint8_t CRYPTO_InstructionSequence_TypeDef[CRYPTO_MAX_SEQUENCE_INSTRUCTIONS] [CRYPTO_MAX_SEQUENCE_INSTRUCTIONS]

Instruction sequence type.

Fill in the desired operations from step1, step2, and so on. The CRYPTO_CMD_INSTR_END marks the end of the sequence. Bit fields are used to format the memory layout of the struct equal to the sequence registers in the CRYPTO module.

CRYPTO_SHA1_Digest_TypeDef#

typedef uint8_t CRYPTO_SHA1_Digest_TypeDef[CRYPTO_SHA1_DIGEST_SIZE_IN_BYTES] [CRYPTO_SHA1_DIGEST_SIZE_IN_BYTES]

SHA-1 Digest type.

CRYPTO_SHA256_Digest_TypeDef#

typedef uint8_t CRYPTO_SHA256_Digest_TypeDef[CRYPTO_SHA256_DIGEST_SIZE_IN_BYTES] [CRYPTO_SHA256_DIGEST_SIZE_IN_BYTES]

SHA-256 Digest type.

CRYPTO_AES_CtrFuncPtr_TypeDef#

typedef void(* CRYPTO_AES_CtrFuncPtr_TypeDef) (uint8_t *ctr) )(uint8_t *ctr)

AES counter modification function pointer.

Note

• This is defined for backwards compatibility with EFM32 em_aes.h. The CRYPTO implementation of counter mode does not support counter update callbacks.

CRYPTO_ModulusSet#

void CRYPTO_ModulusSet (CRYPTO_TypeDef * crypto, CRYPTO_ModulusId_TypeDef modulusId)

Set the modulus type used for wide arithmetic operations.

This function sets the modulus type to be used by the modulus instructions of the CRYPTO module.

CRYPTO_MulOperandWidthSet#

void CRYPTO_MulOperandWidthSet (CRYPTO_TypeDef * crypto, CRYPTO_MulOperandWidth_TypeDef mulOperandWidth)

Set the number of bits in the operands of the MUL instruction.

This function sets the number of bits to be used in the operands of the MUL instruction.

CRYPTO_ResultWidthSet#

void CRYPTO_ResultWidthSet (CRYPTO_TypeDef * crypto, CRYPTO_ResultWidth_TypeDef resultWidth)

Set the width of the results of the non-modulus instructions.

This function sets the result width of the non-modulus instructions.

CRYPTO_IncWidthSet#

void CRYPTO_IncWidthSet (CRYPTO_TypeDef * crypto, CRYPTO_IncWidth_TypeDef incWidth)

Set the width of the DATA1 increment instruction DATA1INC.

This function sets the width of the DATA1 increment instruction CRYPTO_CMD_INSTR_DATA1INC.

CRYPTO_BurstToCrypto#

void CRYPTO_BurstToCrypto (volatile uint32_t * reg, const uint32_t * val)

Write a 128 bit value into a crypto register.

Note

• This function provides a low-level API for writing to the multi-word registers in the crypto peripheral. Applications should use CRYPTO_DataWrite, CRYPTO_DDataWrite or CRYPTO_QDataWrite for writing to DATA, DDATA, and QDATA registers.

CRYPTO_BurstFromCrypto#

void CRYPTO_BurstFromCrypto (volatile uint32_t * reg, uint32_t * val)

Read a 128 bit value from a crypto register.

Note

• This function provides a low-level API for reading one of the multi-word registers in the crypto peripheral. Applications should use CRYPTO_DataRead, CRYPTO_DDataRead or CRYPTO_QDataRead for reading the value of DATA, DDATA, and QDATA registers.

CRYPTO_DataWrite#

void CRYPTO_DataWrite (CRYPTO_DataReg_TypeDef dataReg, const CRYPTO_Data_TypeDef val)

Write 128 bits of data to a DATAX register in the CRYPTO module.

Write 128 bits of data to a DATAX register in the crypto module. The data value is typically input to a big integer operation (see crypto instructions).

CRYPTO_DataWriteUnaligned#

void CRYPTO_DataWriteUnaligned (volatile uint32_t * reg, const uint8_t * val)

Write 128 bits of unaligned data to a DATAX register in the CRYPTO module.

Write 128 bits of unaligned data to a DATAX register in the CRYPTO module. The data pointer does not have to be word-aligned, but an unaligned pointer might incur a performance hit.

CRYPTO_DataRead#

void CRYPTO_DataRead (CRYPTO_DataReg_TypeDef dataReg, CRYPTO_Data_TypeDef val)

Read 128 bits of data from a DATAX register in the CRYPTO module.

Read 128 bits of data from a DATAX register in the crypto module. The data value is typically output from a big integer operation (see crypto instructions)

CRYPTO_DataReadUnaligned#

void CRYPTO_DataReadUnaligned (volatile uint32_t * reg, uint8_t * val)

Read 128 bits of data from a DATAX register in the CRYPTO module to an unaligned pointer.

Write 128 bits of unaligned data to a DATAX register in the CRYPTO module to an unaligned pointer. The output pointer does not have to be word-aligned, but an unaligned pointer might incur a performance penalty.

CRYPTO_DDataWrite#

void CRYPTO_DDataWrite (CRYPTO_DDataReg_TypeDef ddataReg, const CRYPTO_DData_TypeDef val)

Write 256 bits of data to a DDATAX register in the CRYPTO module.

Write 256 bits of data into a DDATAX (Double Data) register in the crypto module. The data value is typically input to a big integer operation (see crypto instructions).

CRYPTO_DDataRead#

void CRYPTO_DDataRead (CRYPTO_DDataReg_TypeDef ddataReg, CRYPTO_DData_TypeDef val)

Read 256 bits of data from a DDATAX register in the CRYPTO module.

Read 256 bits of data from a DDATAX (Double Data) register in the crypto module. The data value is typically output from a big integer operation (see crypto instructions).

CRYPTO_DDataReadUnaligned#

void CRYPTO_DDataReadUnaligned (CRYPTO_DDataReg_TypeDef ddataReg, uint8_t * val)

Read 256 bits of data from a DDATAX register in the CRYPTO module to an unaligned pointer.

Read 256 bits from a DDATAX register in the CRYPTO module. The output buffer pointer does not have to be word-aligned, but an unaligned pointer might incur a performance penalty.

CRYPTO_QDataWrite#

void CRYPTO_QDataWrite (CRYPTO_QDataReg_TypeDef qdataReg, const CRYPTO_QData_TypeDef val)

Write 512 bits of data to a QDATAX register in the CRYPTO module.

Write 512 bits of data into a QDATAX (Quad Data) register in the crypto module The data value is typically input to a big integer operation (see crypto instructions).

CRYPTO_QDataWriteUnaligned#

void CRYPTO_QDataWriteUnaligned (CRYPTO_QDataReg_TypeDef qdataReg, const uint8_t * val)

Write 512 bits of unaligned data to a QDATAX register in the CRYPTO module.

Write 512 bits of unaligned data to a QDATAX register in the CRYPTO module. The data pointer does not have to be word-aligned, but an unaligned pointer might incur a performance hit.

CRYPTO_QDataRead#

void CRYPTO_QDataRead (CRYPTO_QDataReg_TypeDef qdataReg, CRYPTO_QData_TypeDef val)

Read 512 bits of data from a QDATAX register in the CRYPTO module.

Read 512 bits of data from a QDATAX register in the crypto module. The data value is typically input to a big integer operation (see crypto instructions).

CRYPTO_KeyBufWrite#

void CRYPTO_KeyBufWrite (CRYPTO_TypeDef * crypto, CRYPTO_KeyBuf_TypeDef val, CRYPTO_KeyWidth_TypeDef keyWidth)

Set the key value to be used by the CRYPTO module.

Write 128 or 256 bit key to the KEYBUF register in the crypto module.

CRYPTO_KeyBufWriteUnaligned#

void CRYPTO_KeyBufWriteUnaligned (CRYPTO_TypeDef * crypto, const uint8_t * val, CRYPTO_KeyWidth_TypeDef keyWidth)

Set the key value to be used by the CRYPTO module.

Write 128 or 256 bit key to the KEYBUF register in the crypto module. The input key buffer does not have to be word-aligned, but an unaligned value might incur a performance penalty.

CRYPTO_KeyRead#

void CRYPTO_KeyRead (CRYPTO_TypeDef * crypto, CRYPTO_KeyBuf_TypeDef val, CRYPTO_KeyWidth_TypeDef keyWidth)

Read the key value currently used by the CRYPTO module.

Read 128 bits or 256 bits from the KEY register in the CRYPTO module.

CRYPTO_KeyReadUnaligned#

void CRYPTO_KeyReadUnaligned (CRYPTO_TypeDef * crypto, uint8_t * val, CRYPTO_KeyWidth_TypeDef keyWidth)

Read the key value currently used by the CRYPTO module.

Read 128 bits or 256 bits from the KEY register in the CRYPTO module. The destination pointer does not have to be word-aligned, but an unaligned pointer might incur a performance penalty.

CRYPTO_KeyBuf128Write#

void CRYPTO_KeyBuf128Write (CRYPTO_TypeDef * crypto, const uint32_t * val)

Quick write 128 bit key to the CRYPTO module.

Quick write 128 bit key to the KEYBUF register in the CRYPTO module.

CRYPTO_CarryIsSet#

bool CRYPTO_CarryIsSet (CRYPTO_TypeDef * crypto)

Quick read access of the carry bit from arithmetic operations.

This function reads the carry bit of the CRYPTO ALU.

Returns

• Returns 'true' if carry is 1, and 'false' if carry is 0.

CRYPTO_DData0_4LSBitsRead#

uint8_t CRYPTO_DData0_4LSBitsRead (CRYPTO_TypeDef * crypto)

Quick read access of the 4 LSbits of the DDATA0 register.

This function quickly retrieves the 4 least significant bits of the DDATA0 register via the DDATA0LSBS bit field in the DSTATUS register.

Returns

• Returns the 4 LSbits of DDATA0.

CRYPTO_DData0Read260#

void CRYPTO_DData0Read260 (CRYPTO_TypeDef * crypto, CRYPTO_Data260_TypeDef val)

Read 260 bits from the DDATA0 register.

This functions reads 260 bits from the DDATA0 register in the CRYPTO module. The data value is typically output from a big integer operation (see crypto instructions) when the result width is set to 260 bits by calling CRYPTO_ResultWidthSet(cryptoResult260Bits);

CRYPTO_DData0Write260#

void CRYPTO_DData0Write260 (CRYPTO_TypeDef * crypto, const CRYPTO_Data260_TypeDef val)

Write 260 bits to the DDATA0 register.

This functions writes 260 bits to the DDATA0 register in the CRYPTO module. The data value is typically input to a big integer operation (see crypto instructions) when the result width is set to 260 bits by calling CRYPTO_ResultWidthSet(cryptoResult260Bits);

CRYPTO_DData1_MSBitRead#

bool CRYPTO_DData1_MSBitRead (CRYPTO_TypeDef * crypto)

Quick read the MSbit of the DDATA1 register.

This function reads the most significant bit (bit 255) of the DDATA1 register via the DDATA1MSB bit field in the DSTATUS register. This can be used to quickly check the signedness of a big integer resident in the CRYPTO module.

Returns

• Returns 'true' if MSbit is 1, and 'false' if MSbit is 0.

CRYPTO_InstructionSequenceLoad#

CRYPTO_WARNINGS_NO_CAST_ALIGN void CRYPTO_InstructionSequenceLoad (CRYPTO_TypeDef * crypto, const CRYPTO_InstructionSequence_TypeDef instructionSequence)

Load a sequence of instructions to be executed on the current values in the data registers.

This function loads a sequence of instructions to the crypto module. The instructions will be executed when the CRYPTO_InstructionSequenceExecute function is called. The first END marks the end of the sequence.

CRYPTO_InstructionSequenceExecute#

CRYPTO_WARNINGS_RESET void CRYPTO_InstructionSequenceExecute (CRYPTO_TypeDef * crypto)

Execute the current programmed instruction sequence.

This function starts the execution of the current instruction sequence in the CRYPTO module.

CRYPTO_InstructionSequenceDone#

bool CRYPTO_InstructionSequenceDone (CRYPTO_TypeDef * crypto)

Check whether the execution of an instruction sequence has completed.

This function checks whether an instruction sequence has completed.

Returns

• Returns 'true' if the instruction sequence is done, and 'false' if not.

CRYPTO_InstructionSequenceWait#

void CRYPTO_InstructionSequenceWait (CRYPTO_TypeDef * crypto)

Wait for completion of the current sequence of instructions.

This function "busy"-waits until the execution of the ongoing instruction sequence has completed.

CRYPTO_InstructionWait#

void CRYPTO_InstructionWait (CRYPTO_TypeDef * crypto)

Wait for completion of the current command.

This function "busy"-waits until the execution of the ongoing instruction has completed.

CRYPTO_SHA_1#

void CRYPTO_SHA_1 (CRYPTO_TypeDef * crypto, const uint8_t * msg, uint64_t msgLen, CRYPTO_SHA1_Digest_TypeDef msgDigest)

Perform a SHA-1 hash operation on a message.

This function performs a SHA-1 hash operation on the message specified by msg with length msgLen and returns the message digest in msgDigest.

CRYPTO_SHA_256#

void CRYPTO_SHA_256 (CRYPTO_TypeDef * crypto, const uint8_t * msg, uint64_t msgLen, CRYPTO_SHA256_Digest_TypeDef msgDigest)

Perform a SHA-256 hash operation on a message.

This function performs a SHA-256 hash operation on the message specified by msg with length msgLen and returns the message digest in msgDigest.

CRYPTO_Mul#

void CRYPTO_Mul (CRYPTO_TypeDef * crypto, uint32_t * A, int aSize, uint32_t * B, int bSize, uint32_t * R, int rSize)

Multiply two big integers.

This function uses the CRYPTO unit to multiply two big integer operands. If USE_VARIABLE_SIZED_DATA_LOADS is defined, the sizes of the operands may be any multiple of 32 bits. If USE_VARIABLE_SIZED_DATA_LOADS is not defined, the sizes of the operands must be a multiple of 128 bits.

CRYPTO_AES_CBC128#

void CRYPTO_AES_CBC128 (CRYPTO_TypeDef * crypto, uint8_t * out, const uint8_t * in, unsigned int len, const uint8_t * key, const uint8_t * iv, bool encrypt)

AES Cipher-block chaining (CBC) cipher mode encryption/decryption, 128 bit key.

Encryption:

*           Plaintext                  Plaintext
*               |                          |
*               V                          V
* InitVector ->XOR        +-------------->XOR
*               |         |                |
*               V         |                V
*       +--------------+  |        +--------------+
* Key ->| Block cipher |  |  Key ->| Block cipher |
*       |  encryption  |  |        |  encryption  |
*       +--------------+  |        +--------------+
*               |---------+                |
*               V                          V
*           Ciphertext                 Ciphertext
* 

Decryption:

*         Ciphertext                 Ciphertext
*              |----------+                |
*              V          |                V
*       +--------------+  |        +--------------+
* Key ->| Block cipher |  |  Key ->| Block cipher |
*       |  decryption  |  |        |  decryption  |
*       +--------------+  |        +--------------+
*               |         |                |
*               V         |                V
* InitVector ->XOR        +-------------->XOR
*               |                          |
*               V                          V
*           Plaintext                  Plaintext
* 

See general comments on layout and byte ordering of parameters.

CRYPTO_AES_CBC256#

void CRYPTO_AES_CBC256 (CRYPTO_TypeDef * crypto, uint8_t * out, const uint8_t * in, unsigned int len, const uint8_t * key, const uint8_t * iv, bool encrypt)

AES Cipher-block chaining (CBC) cipher mode encryption/decryption, 256 bit key.

See CRYPTO_AES_CBC128() for the CBC figure.

See general comments on layout and byte ordering of parameters.

CRYPTO_AES_PCBC128#

void CRYPTO_AES_PCBC128 (CRYPTO_TypeDef * crypto, uint8_t * out, const uint8_t * in, unsigned int len, const uint8_t * key, const uint8_t * iv, bool encrypt)

AES Propagating Cipher-block chaining (PCBC) cipher mode encryption/decryption, 128 bit key.

Encryption:

*           Plaintext                  Plaintext
*               |--------------+           |
*               V              V           V
* InitVector ->XOR        +-->XOR-------->XOR
*               |         |                |
*               V         |                V
*       +--------------+  |        +--------------+
* Key ->| Block cipher |  |  Key ->| Block cipher |
*       |  encryption  |  |        |  encryption  |
*       +--------------+  |        +--------------+
*               |---------+                |
*               V                          V
*           Ciphertext                 Ciphertext
* 

Decryption:

*         Ciphertext                 Ciphertext
*              |----------+                |
*              V          |                V
*       +--------------+  |        +--------------+
* Key ->| Block cipher |  |  Key ->| Block cipher |
*       |  decryption  |  |        |  decryption  |
*       +--------------+  |        +--------------+
*               |         |               |
*               V         V               V
* InitVector ->XOR  +--->XOR------------>XOR
*               |---+                     |
*               V                         V
*           Plaintext                  Plaintext
* 

See general comments on layout and byte ordering of parameters.

CRYPTO_AES_PCBC256#

void CRYPTO_AES_PCBC256 (CRYPTO_TypeDef * crypto, uint8_t * out, const uint8_t * in, unsigned int len, const uint8_t * key, const uint8_t * iv, bool encrypt)

AES Propagating Cipher-block chaining (PCBC) cipher mode encryption/decryption, 256 bit key.

See CRYPTO_AES_PCBC128() for the PCBC figure.

See general comments on layout and byte ordering of parameters.

CRYPTO_AES_CFB128#

void CRYPTO_AES_CFB128 (CRYPTO_TypeDef * crypto, uint8_t * out, const uint8_t * in, unsigned int len, const uint8_t * key, const uint8_t * iv, bool encrypt)

AES Cipher feedback (CFB) cipher mode encryption/decryption, 128 bit key.

Encryption:

*           InitVector    +----------------+
*               |         |                |
*               V         |                V
*       +--------------+  |        +--------------+
* Key ->| Block cipher |  |  Key ->| Block cipher |
*       |  encryption  |  |        |  encryption  |
*       +--------------+  |        +--------------+
*               |         |                |
*               V         |                V
*  Plaintext ->XOR        |   Plaintext ->XOR
*               |---------+                |
*               V                          V
*           Ciphertext                 Ciphertext
* 

Decryption:

*          InitVector     +----------------+
*               |         |                |
*               V         |                V
*       +--------------+  |        +--------------+
* Key ->| Block cipher |  |  Key ->| Block cipher |
*       |  encryption  |  |        |  encryption  |
*       +--------------+  |        +--------------+
*               |         |                |
*               V         |                V
*              XOR<- Ciphertext           XOR<- Ciphertext
*               |                          |
*               V                          V
*           Plaintext                  Plaintext
* 

See general comments on layout and byte ordering of parameters.

CRYPTO_AES_CFB256#

void CRYPTO_AES_CFB256 (CRYPTO_TypeDef * crypto, uint8_t * out, const uint8_t * in, unsigned int len, const uint8_t * key, const uint8_t * iv, bool encrypt)

AES Cipher feedback (CFB) cipher mode encryption/decryption, 256 bit key.

See CRYPTO_AES_CFB128() for the CFB figure.

See general comments on layout and byte ordering of parameters.

CRYPTO_AES_CTR128#

void CRYPTO_AES_CTR128 (CRYPTO_TypeDef * crypto, uint8_t * out, const uint8_t * in, unsigned int len, const uint8_t * key, uint8_t * ctr, CRYPTO_AES_CtrFuncPtr_TypeDef ctrFunc)

AES Counter (CTR) cipher mode encryption/decryption, 128 bit key.

Encryption:

*           Counter                    Counter
*              |                          |
*              V                          V
*       +--------------+           +--------------+
* Key ->| Block cipher |     Key ->| Block cipher |
*       |  encryption  |           |  encryption  |
*       +--------------+           +--------------+
*              |                          |
* Plaintext ->XOR            Plaintext ->XOR
*              |                          |
*              V                          V
*         Ciphertext                 Ciphertext
* 

Decryption:

*           Counter                    Counter
*              |                          |
*              V                          V
*       +--------------+           +--------------+
* Key ->| Block cipher |     Key ->| Block cipher |
*       |  encryption  |           |  encryption  |
*       +--------------+           +--------------+
*               |                          |
* Ciphertext ->XOR           Ciphertext ->XOR
*               |                          |
*               V                          V
*           Plaintext                  Plaintext
* 

See general comments on layout and byte ordering of parameters.

CRYPTO_AES_CTR256#

void CRYPTO_AES_CTR256 (CRYPTO_TypeDef * crypto, uint8_t * out, const uint8_t * in, unsigned int len, const uint8_t * key, uint8_t * ctr, CRYPTO_AES_CtrFuncPtr_TypeDef ctrFunc)

AES Counter (CTR) cipher mode encryption/decryption, 256 bit key.

See CRYPTO_AES_CTR128() for CTR figure.

See general comments on layout and byte ordering of parameters.

CRYPTO_AES_CTRUpdate32Bit#

void CRYPTO_AES_CTRUpdate32Bit (uint8_t * ctr)

Update the last 32 bits of 128 bit counter by incrementing with 1.

Notice that no special consideration is given to the possible wrap around. If 32 least significant bits are 0xFFFFFFFF, they will be updated to 0x00000000, ignoring overflow.

See general comments on layout and byte ordering of parameters.

CRYPTO_AES_DecryptKey128#

void CRYPTO_AES_DecryptKey128 (CRYPTO_TypeDef * crypto, uint8_t * out, const uint8_t * in)

Generate 128 bit AES decryption key from 128 bit encryption key.

The decryption key is used for some cipher modes when decrypting.

See general comments on layout and byte ordering of parameters.

CRYPTO_AES_DecryptKey256#

void CRYPTO_AES_DecryptKey256 (CRYPTO_TypeDef * crypto, uint8_t * out, const uint8_t * in)

Generate 256 bit AES decryption key from 256 bit encryption key.

The decryption key is used for some cipher modes when decrypting.

See general comments on layout and byte ordering of parameters.

CRYPTO_AES_ECB128#

void CRYPTO_AES_ECB128 (CRYPTO_TypeDef * crypto, uint8_t * out, const uint8_t * in, unsigned int len, const uint8_t * key, bool encrypt)

AES Electronic Codebook (ECB) cipher mode encryption/decryption, 128 bit key.

Encryption:

*          Plaintext                  Plaintext
*              |                          |
*              V                          V
*       +--------------+           +--------------+
* Key ->| Block cipher |     Key ->| Block cipher |
*       |  encryption  |           |  encryption  |
*       +--------------+           +--------------+
*              |                          |
*              V                          V
*         Ciphertext                 Ciphertext
* 

Decryption:

*         Ciphertext                 Ciphertext
*              |                          |
*              V                          V
*       +--------------+           +--------------+
* Key ->| Block cipher |     Key ->| Block cipher |
*       |  decryption  |           |  decryption  |
*       +--------------+           +--------------+
*              |                          |
*              V                          V
*          Plaintext                  Plaintext
* 

See general comments on layout and byte ordering of parameters.

CRYPTO_AES_ECB256#

void CRYPTO_AES_ECB256 (CRYPTO_TypeDef * crypto, uint8_t * out, const uint8_t * in, unsigned int len, const uint8_t * key, bool encrypt)

AES Electronic Codebook (ECB) cipher mode encryption/decryption, 256 bit key.

See CRYPTO_AES_ECB128() for ECB figure.

See general comments on layout and byte ordering of parameters.

CRYPTO_AES_OFB128#

void CRYPTO_AES_OFB128 (CRYPTO_TypeDef * crypto, uint8_t * out, const uint8_t * in, unsigned int len, const uint8_t * key, const uint8_t * iv)

AES Output feedback (OFB) cipher mode encryption/decryption, 128 bit key.

Encryption:

*          InitVector    +----------------+
*              |         |                |
*              V         |                V
*       +--------------+ |        +--------------+
* Key ->| Block cipher | |  Key ->| Block cipher |
*       |  encryption  | |        |  encryption  |
*       +--------------+ |        +--------------+
*              |         |                |
*              |---------+                |
*              V                          V
* Plaintext ->XOR            Plaintext ->XOR
*              |                          |
*              V                          V
*         Ciphertext                 Ciphertext
* 

Decryption:

*          InitVector    +----------------+
*              |         |                |
*              V         |                V
*       +--------------+ |        +--------------+
* Key ->| Block cipher | |  Key ->| Block cipher |
*       |  encryption  | |        |  encryption  |
*       +--------------+ |        +--------------+
*              |         |                |
*              |---------+                |
*              V                          V
* Ciphertext ->XOR           Ciphertext ->XOR
*              |                          |
*              V                          V
*          Plaintext                  Plaintext
* 

See general comments on layout and byte ordering of parameters.

CRYPTO_AES_OFB256#

void CRYPTO_AES_OFB256 (CRYPTO_TypeDef * crypto, uint8_t * out, const uint8_t * in, unsigned int len, const uint8_t * key, const uint8_t * iv)

AES Output feedback (OFB) cipher mode encryption/decryption, 256 bit key.

See CRYPTO_AES_OFB128() for OFB figure.

See general comments on layout and byte ordering of parameters.

CRYPTO_IntClear#

void CRYPTO_IntClear (CRYPTO_TypeDef * crypto, uint32_t flags)

Clear one or more pending CRYPTO interrupts.

CRYPTO_IntDisable#

void CRYPTO_IntDisable (CRYPTO_TypeDef * crypto, uint32_t flags)

Disable one or more CRYPTO interrupts.

CRYPTO_IntEnable#

void CRYPTO_IntEnable (CRYPTO_TypeDef * crypto, uint32_t flags)

Enable one or more CRYPTO interrupts.

Note

• Depending on the use, a pending interrupt may already be set prior to enabling the interrupt. Consider using CRYPTO_IntClear() prior to enabling if such a pending interrupt should be ignored.

CRYPTO_IntGet#

uint32_t CRYPTO_IntGet (CRYPTO_TypeDef * crypto)

Get pending CRYPTO interrupt flags.

Note

• The event bits are not cleared by the use of this function.

Returns

• CRYPTO interrupt sources pending. A bitwise logic OR combination of valid interrupt flags for the CRYPTO module (CRYPTO_IF_nnn).

CRYPTO_IntGetEnabled#

uint32_t CRYPTO_IntGetEnabled (CRYPTO_TypeDef * crypto)

Get enabled and pending CRYPTO interrupt flags.

Useful for handling more interrupt sources in the same interrupt handler.

Note

• Interrupt flags are not cleared by the use of this function.

Returns

• Pending and enabled CRYPTO interrupt sources The return value is the bitwise AND of

  • the enabled interrupt sources in CRYPTO_IEN and

  • the pending interrupt flags CRYPTO_IF

CRYPTO_IntSet#

void CRYPTO_IntSet (CRYPTO_TypeDef * crypto, uint32_t flags)

Set one or more pending CRYPTO interrupts from software.

cryptoBurstToCryptoAndZeroize#

void cryptoBurstToCryptoAndZeroize (volatile uint32_t * reg, const uint32_t * val)

cryptoBurstFromCryptoAndZeroize#

void cryptoBurstFromCryptoAndZeroize (volatile uint32_t * reg, uint32_t * val)

cryptoBigintZeroize#

void cryptoBigintZeroize (uint32_t * words32bits, unsigned num32bitWords)

Set the 32 bit word array to zero.

cryptoBigintIncrement#

void cryptoBigintIncrement (uint32_t * words32bits, unsigned num32bitWords)

Increment value of 32bit word array by one.

CRYPTO_AES_CBCx#

static void CRYPTO_AES_CBCx (CRYPTO_TypeDef * crypto, uint8_t * out, const uint8_t * in, unsigned int len, const uint8_t * key, const uint8_t * iv, bool encrypt, CRYPTO_KeyWidth_TypeDef keyWidth)

Cipher-block chaining (CBC) cipher mode encryption/decryption, 128/256 bit key.

See CRYPTO_AES_CBC128() for CBC figure.

See general comments on layout and byte ordering of parameters.

CRYPTO_AES_PCBCx#

static void CRYPTO_AES_PCBCx (CRYPTO_TypeDef * crypto, uint8_t * out, const uint8_t * in, unsigned int len, const uint8_t * key, const uint8_t * iv, bool encrypt, CRYPTO_KeyWidth_TypeDef keyWidth)

Propagating cipher-block chaining (PCBC) cipher mode encryption/decryption, 128/256 bit key.

See CRYPTO_AES_PCBC128() for PCBC figure.

See general comments on layout and byte ordering of parameters.

CRYPTO_AES_CFBx#

static void CRYPTO_AES_CFBx (CRYPTO_TypeDef * crypto, uint8_t * out, const uint8_t * in, unsigned int len, const uint8_t * key, const uint8_t * iv, bool encrypt, CRYPTO_KeyWidth_TypeDef keyWidth)

Cipher feedback (CFB) cipher mode encryption/decryption, 128/256 bit key.

See CRYPTO_AES_CFB128() for CFB figure.

See general comments on layout and byte ordering of parameters.

CRYPTO_AES_CTRx#

static void CRYPTO_AES_CTRx (CRYPTO_TypeDef * crypto, uint8_t * out, const uint8_t * in, unsigned int len, const uint8_t * key, uint8_t * ctr, CRYPTO_AES_CtrFuncPtr_TypeDef ctrFunc, CRYPTO_KeyWidth_TypeDef keyWidth)

Counter (CTR) cipher mode encryption/decryption, 128/256 bit key.

See CRYPTO_AES_CTR128() for CTR figure.

See general comments on layout and byte ordering of parameters.

CRYPTO_AES_ECBx#

static void CRYPTO_AES_ECBx (CRYPTO_TypeDef * crypto, uint8_t * out, const uint8_t * in, unsigned int len, const uint8_t * key, bool encrypt, CRYPTO_KeyWidth_TypeDef keyWidth)

Electronic Codebook (ECB) cipher mode encryption/decryption, 128/256 bit key.

See CRYPTO_AES_ECB128() for ECB figure.

See general comments on layout and byte ordering of parameters.

CRYPTO_AES_OFBx#

static void CRYPTO_AES_OFBx (CRYPTO_TypeDef * crypto, uint8_t * out, const uint8_t * in, unsigned int len, const uint8_t * key, const uint8_t * iv, CRYPTO_KeyWidth_TypeDef keyWidth)

Output feedback (OFB) cipher mode encryption/decryption, 128/256 bit key.

See CRYPTO_AES_OFB128() for OFB figure.

See general comments on layout and byte ordering of parameters.

CRYPTO_AES_ProcessLoop#

void CRYPTO_AES_ProcessLoop (CRYPTO_TypeDef * crypto, unsigned int len, CRYPTO_DataReg_TypeDef inReg, const uint8_t * in, CRYPTO_DataReg_TypeDef outReg, uint8_t * out)

Perform generic AES loop.

Function loads given register with provided input data. Triggers CRYPTO to perform sequence of instructions and read specified output register to output buffer.

CRYPTO_MAX_SEQUENCE_INSTRUCTIONS#

#define CRYPTO_MAX_SEQUENCE_INSTRUCTIONS

(20)

The maximum number of crypto instructions in an instruction sequence.

CRYPTO_INSTRUCTIONSEQUENSE_DEFAULT#

#define CRYPTO_INSTRUCTIONSEQUENSE_DEFAULT

Default instruction sequence consisting of all ENDs.

The user can initialize the instruction sequence with this default value set and fill in the desired operations from step 1. The first END instruction marks the end of the sequence.