34 #if defined(CRYPTO_COUNT) && (CRYPTO_COUNT > 0)
182 #define CRYPTO_INSTRUCTIONS_PER_REG (4)
183 #define CRYPTO_INSTRUCTIONS_MAX (12)
184 #define CRYPTO_INSTRUCTION_REGS (CRYPTO_INSTRUCTIONS_MAX/CRYPTO_INSTRUCTIONS_PER_REG)
186 #define CRYPTO_SHA1_BLOCK_SIZE_IN_BITS (512)
187 #define CRYPTO_SHA1_BLOCK_SIZE_IN_BYTES (CRYPTO_SHA1_BLOCK_SIZE_IN_BITS/8)
188 #define CRYPTO_SHA1_BLOCK_SIZE_IN_32BIT_WORDS (CRYPTO_SHA1_BLOCK_SIZE_IN_BYTES/sizeof(uint32_t))
189 #define CRYPTO_SHA1_DIGEST_SIZE_IN_32BIT_WORDS (CRYPTO_SHA1_DIGEST_SIZE_IN_BYTES/sizeof(uint32_t))
191 #define CRYPTO_SHA256_BLOCK_SIZE_IN_BITS (512)
192 #define CRYPTO_SHA256_BLOCK_SIZE_IN_BYTES (CRYPTO_SHA256_BLOCK_SIZE_IN_BITS/8)
193 #define CRYPTO_SHA256_BLOCK_SIZE_IN_32BIT_WORDS (CRYPTO_SHA256_BLOCK_SIZE_IN_BYTES/sizeof(uint32_t))
195 #define CRYPTO_SHA256_DIGEST_SIZE_IN_32BIT_WORDS (CRYPTO_SHA256_DIGEST_SIZE_IN_BYTES/sizeof(uint32_t))
197 #define PARTIAL_OPERAND_WIDTH_LOG2 (7)
198 #define PARTIAL_OPERAND_WIDTH (1<<PARTIAL_OPERAND_WIDTH_LOG2)
199 #define PARTIAL_OPERAND_WIDTH_MASK (PARTIAL_OPERAND_WIDTH-1)
200 #define PARTIAL_OPERAND_WIDTH_IN_BYTES (PARTIAL_OPERAND_WIDTH/8)
201 #define PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS (PARTIAL_OPERAND_WIDTH_IN_BYTES/sizeof(uint32_t))
203 #define SWAP32(x) (__REV(x))
205 #define CRYPTO_AES_BLOCKSIZE (16)
255 #ifdef USE_VARIABLE_SIZED_DATA_LOADS
274 volatile uint32_t * reg = (
volatile uint32_t *) dataReg;
279 for (i = 0; i < valSize; i++)
318 #ifdef _CRYPTO_WAC_MODULUS_ECCBIN233N
330 #ifdef _CRYPTO_WAC_MODULUS_ECCPRIME256P
385 uint32_t shaBlock[CRYPTO_SHA1_BLOCK_SIZE_IN_32BIT_WORDS]=
388 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0
390 uint8_t * p8ShaBlock = (uint8_t *) shaBlock;
409 while (len >= CRYPTO_SHA1_BLOCK_SIZE_IN_BYTES)
419 len -= CRYPTO_SHA1_BLOCK_SIZE_IN_BYTES;
420 msg += CRYPTO_SHA1_BLOCK_SIZE_IN_BYTES;
427 p8ShaBlock[blockLen++] = *msg++;
430 p8ShaBlock[blockLen++] = 0x80;
438 while (blockLen < 64)
439 p8ShaBlock[blockLen++] = 0;
452 while (blockLen < 56)
453 p8ShaBlock[blockLen++] = 0;
457 uint64_t msgLenInBits = msgLen << 3;
458 temp = msgLenInBits >> 32;
459 *(uint32_t*)&p8ShaBlock[56] = SWAP32(temp);
460 temp = msgLenInBits & 0xFFFFFFFF;
461 *(uint32_t*)&p8ShaBlock[60] = SWAP32(temp);
473 ((uint32_t*)msgDigest)[0] =
CRYPTO->DDATA0BIG;
474 ((uint32_t*)msgDigest)[1] =
CRYPTO->DDATA0BIG;
475 ((uint32_t*)msgDigest)[2] =
CRYPTO->DDATA0BIG;
476 ((uint32_t*)msgDigest)[3] =
CRYPTO->DDATA0BIG;
477 ((uint32_t*)msgDigest)[4] =
CRYPTO->DDATA0BIG;
502 uint32_t shaBlock[CRYPTO_SHA256_BLOCK_SIZE_IN_32BIT_WORDS]=
505 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
506 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
508 uint8_t * p8ShaBlock = (uint8_t *) shaBlock;
526 while (len >= CRYPTO_SHA256_BLOCK_SIZE_IN_BYTES)
536 len -= CRYPTO_SHA256_BLOCK_SIZE_IN_BYTES;
537 msg += CRYPTO_SHA256_BLOCK_SIZE_IN_BYTES;
544 p8ShaBlock[blockLen++] = *msg++;
547 p8ShaBlock[blockLen++] = 0x80;
555 while (blockLen < 64)
556 p8ShaBlock[blockLen++] = 0;
569 while (blockLen < 56)
570 p8ShaBlock[blockLen++] = 0;
574 uint64_t msgLenInBits = msgLen << 3;
575 temp = msgLenInBits >> 32;
576 *(uint32_t *)&p8ShaBlock[56] = SWAP32(temp);
577 temp = msgLenInBits & 0xFFFFFFFF;
578 *(uint32_t *)&p8ShaBlock[60] = SWAP32(temp);
603 while (num32bitWords--)
618 for (i=0; i<num32bitWords; i++)
619 if (++words32bits[i] != 0)
642 uint32_t * B,
int bSize,
643 uint32_t * R,
int rSize)
649 #ifdef USE_VARIABLE_SIZED_DATA_LOADS
650 int numWordsLastOperandA = (aSize&PARTIAL_OPERAND_WIDTH_MASK)>>5;
651 int numPartialOperandsA = numWordsLastOperandA ?
652 (aSize >> PARTIAL_OPERAND_WIDTH_LOG2) + 1 :
653 aSize >> PARTIAL_OPERAND_WIDTH_LOG2;
654 int numWordsLastOperandB = (bSize&PARTIAL_OPERAND_WIDTH_MASK)>>5;
655 int numPartialOperandsB = numWordsLastOperandB ?
656 (bSize >> PARTIAL_OPERAND_WIDTH_LOG2) + 1 :
657 bSize >> PARTIAL_OPERAND_WIDTH_LOG2;
658 int numWordsLastOperandR = (rSize&PARTIAL_OPERAND_WIDTH_MASK)>>5;
659 int numPartialOperandsR = numWordsLastOperandR ?
660 (rSize >> PARTIAL_OPERAND_WIDTH_LOG2) + 1 :
661 rSize >> PARTIAL_OPERAND_WIDTH_LOG2;
662 EFM_ASSERT(numPartialOperandsA + numPartialOperandsB <= numPartialOperandsR);
664 int numPartialOperandsA = aSize >> PARTIAL_OPERAND_WIDTH_LOG2;
665 int numPartialOperandsB = bSize >> PARTIAL_OPERAND_WIDTH_LOG2;
666 EFM_ASSERT((aSize & PARTIAL_OPERAND_WIDTH_MASK) == 0);
667 EFM_ASSERT((bSize & PARTIAL_OPERAND_WIDTH_MASK) == 0);
669 EFM_ASSERT(aSize + bSize <= rSize);
730 for(i=0; i<numPartialOperandsA; i++)
733 #ifdef USE_VARIABLE_SIZED_DATA_LOADS
734 if ( (numWordsLastOperandA != 0) && ( i == numPartialOperandsA-1 ) )
736 &A[i*PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS],
737 numWordsLastOperandA);
745 #ifdef USE_VARIABLE_SIZED_DATA_LOADS
746 if ( (numWordsLastOperandR != 0) && ( i == numPartialOperandsR-1 ) )
748 &R[i*PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS],
749 numWordsLastOperandR);
761 | (PARTIAL_OPERAND_WIDTH_IN_BYTES * numPartialOperandsB);
766 for (j=0; j<numPartialOperandsB; j++)
770 #ifdef USE_VARIABLE_SIZED_DATA_LOADS
771 if ( (numWordsLastOperandB != 0) && ( j == numPartialOperandsB-1 ) )
773 &B[j*PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS],
774 numWordsLastOperandB);
777 &B[j*PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS]);
780 &B[j*PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS]);
785 #ifdef USE_VARIABLE_SIZED_DATA_LOADS
786 if ( (numWordsLastOperandR != 0) && ( (i+j+1) == numPartialOperandsR-1 ) )
788 &R[(i+j+1)*PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS],
789 numWordsLastOperandR);
792 &R[(i+j+1)*PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS]);
795 &R[(i+j+1)*PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS]);
799 &R[(i+j)*PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS]);
806 *PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS],
807 (numPartialOperandsA-i-1)
808 *PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS);
811 &R[(i+numPartialOperandsB)
812 * PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS]);
1032 const uint8_t * key,
1104 const uint8_t * key,
1146 const uint8_t * key,
1170 uint32_t * _ctr = (uint32_t *) ctr;
1172 _ctr[3] = __REV(__REV(_ctr[3]) + 1);
1192 uint32_t * _out = (uint32_t *) out;
1193 const uint32_t * _in = (
const uint32_t *) in;
1224 uint32_t * _out = (uint32_t *) out;
1225 const uint32_t * _in = (
const uint32_t *) in;
1295 const uint8_t * key,
1333 const uint8_t * key,
1400 const uint8_t * key,
1435 const uint8_t * key,
1482 const uint8_t * key,
1487 EFM_ASSERT(!(len % CRYPTO_AES_BLOCKSIZE));
1562 const uint8_t * key,
1567 EFM_ASSERT(!(len % CRYPTO_AES_BLOCKSIZE));
1646 const uint8_t * key,
1653 EFM_ASSERT(!(len % CRYPTO_AES_BLOCKSIZE));
1710 const uint8_t * key,
1714 EFM_ASSERT(!(len % CRYPTO_AES_BLOCKSIZE));
1769 const uint8_t * key,
1773 EFM_ASSERT(!(len % CRYPTO_AES_BLOCKSIZE));
1826 len /= CRYPTO_AES_BLOCKSIZE;
#define CRYPTO_CMD_INSTR_DATA0TODATA3
#define CRYPTO_CMD_INSTR_DATA1TODATA0
#define CRYPTO_WAC_RESULTWIDTH_256BIT
#define CRYPTO_CMD_INSTR_AESENC
#define _CRYPTO_SEQ1_INSTR5_SHIFT
void CRYPTO_AES_CFB128(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.
void CRYPTO_AES_CBC128(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.
#define CRYPTO_CMD_INSTR_DATA0TODATA1
Emlib peripheral API "assert" implementation.
#define CRYPTO_CMD_INSTR_DATA0TODATA2
__STATIC_INLINE void CRYPTO_DataRead(CRYPTO_DataReg_TypeDef dataReg, CRYPTO_Data_TypeDef val)
Read 128 bits of data from a DATAX register in the CRYPTO module.
#define CRYPTO_CTRL_SHA_SHA1
void CRYPTO_AES_CTRUpdate32Bit(uint8_t *ctr)
Update last 32 bits of 128 bit counter, by incrementing with 1.
#define CRYPTO_CTRL_AES_AES256
#define _CRYPTO_SEQ0_INSTR1_SHIFT
#define CRYPTO_CMD_INSTR_DATATODMA0
#define _CRYPTO_SEQ0_INSTR3_SHIFT
__STATIC_INLINE void cryptoBigintIncrement(uint32_t *words32bits, int num32bitWords)
Increment value of 32bit word array by one.
#define _CRYPTO_SEQCTRL_LENGTHA_SHIFT
static void CRYPTO_AES_OFBx(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.
#define _CRYPTO_WAC_MODULUS_MASK
#define CRYPTO_CMD_INSTR_DDATA0TODDATA2
#define CRYPTO_CMD_INSTR_DDATA2TODDATA1
uint32_t CRYPTO_Data_TypeDef[CRYPTO_DATA_SIZE_IN_32BIT_WORDS]
CMSIS Cortex-M Peripheral Access Layer for Silicon Laboratories microcontroller devices.
#define CRYPTO_CMD_SEQSTART
#define _CRYPTO_SEQ0_INSTR2_SHIFT
void CRYPTO_ModulusSet(CRYPTO_ModulusType_TypeDef modType)
Set the modulus type used for wide arithmetic operations.
void CRYPTO_KeyRead(CRYPTO_KeyBuf_TypeDef val, CRYPTO_KeyWidth_TypeDef keyWidth)
Read the key value currently used by the CRYPTO module.
#define CRYPTO_IF_INSTRDONE
void CRYPTO_AES_OFB128(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.
static void CRYPTO_AES_CTRx(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.
__STATIC_INLINE void CRYPTO_QDataWrite(CRYPTO_QDataReg_TypeDef qdataReg, CRYPTO_QData_TypeDef val)
Write 512 bits of data to a QDATAX register in the CRYPTO module.
static void CRYPTO_AES_CBCx(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.
static void CRYPTO_AES_ProcessLoop(uint32_t len, CRYPTO_DataReg_TypeDef inReg, uint32_t *in, CRYPTO_DataReg_TypeDef outReg, uint32_t *out)
Function performs generic AES loop.
#define CRYPTO_CMD_INSTR_ADDIC
CRYPTO_ModulusType_TypeDef
#define CRYPTO_WAC_MODOP_BINARY
__STATIC_INLINE void CRYPTO_IntClear(uint32_t flags)
Clear one or more pending CRYPTO interrupts.
void CRYPTO_AES_ECB128(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.
#define CRYPTO_CMD_INSTR_SELDDATA2DDATA3
#define CRYPTO_CTRL_DMA1RSEL_DATA1
__STATIC_INLINE void CRYPTO_BurstFromCrypto(volatile uint32_t *reg, uint32_t *val)
Read a 128 bit value from a crypto register.
__STATIC_INLINE void CRYPTO_DDataRead(CRYPTO_DDataReg_TypeDef ddataReg, CRYPTO_DData_TypeDef val)
Read 256 bits of data from a DDATAX register in the CRYPTO module.
#define CRYPTO_CTRL_DMA0MODE_FULL
#define CRYPTO_CMD_INSTR_DDATA0TODDATA1
void CRYPTO_SHA_256(const uint8_t *msg, uint64_t msgLen, CRYPTO_SHA256_Digest_TypeDef digest)
Perform a SHA-256 hash operation on a message.
void CRYPTO_AES_DecryptKey256(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 ...
#define CRYPTO_CMD_INSTR_SHA
#define CRYPTO_CMD_INSTR_DATA1INC
__STATIC_INLINE 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.
uint8_t CRYPTO_SHA1_Digest_TypeDef[CRYPTO_SHA1_DIGEST_SIZE_IN_BYTES]
#define CRYPTO_CMD_INSTR_DATA1TODATA0XOR
#define CRYPTO_CMD_INSTR_SELDDATA1DDATA3
#define CRYPTO_CMD_INSTR_DMA0TODATA
static void CRYPTO_AES_CFBx(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.
#define CRYPTO_CTRL_AES_AES128
#define CRYPTO_CTRL_SHA_SHA2
#define CRYPTO_CMD_INSTR_DATA2TODATA0XOR
Cryptography accelerator peripheral API.
void CRYPTO_AES_CFB256(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.
#define CRYPTO_CMD_INSTR_DDATA1TODDATA0
__STATIC_INLINE void CRYPTO_KeyBufWrite(CRYPTO_KeyBuf_TypeDef val, CRYPTO_KeyWidth_TypeDef keyWidth)
Set the key value to be used by the CRYPTO module.
void(* CRYPTO_AES_CtrFuncPtr_TypeDef)(uint8_t *ctr)
AES counter modification function pointer.
__STATIC_INLINE void CRYPTO_BurstToCrypto(volatile uint32_t *reg, const uint32_t *val)
Write a 128 bit value into a crypto register.
void CRYPTO_SHA_1(const uint8_t *msg, uint64_t msgLen, CRYPTO_SHA1_Digest_TypeDef digest)
Perform a SHA-1 hash operation on a message.
#define CRYPTO_WAC_MULWIDTH_MUL128
#define CRYPTO_CTRL_DMA0RSEL_DATA0
uint32_t CRYPTO_KeyBuf_TypeDef[CRYPTO_KEYBUF_SIZE_IN_32BIT_WORDS]
void CRYPTO_Mul(uint32_t *A, int aSize, uint32_t *B, int bSize, uint32_t *R, int rSize)
Multiply two big integers.
__STATIC_INLINE void CRYPTO_ResultWidthSet(CRYPTO_ResultWidth_TypeDef resultWidth)
Set the width of the results of the non-modulus instructions.
#define CRYPTO_CMD_INSTR_CCLR
void CRYPTO_AES_ECB256(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.
#define CRYPTO_CMD_INSTR_AESDEC
__STATIC_INLINE 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.
__STATIC_INLINE bool CRYPTO_CarryIsSet(void)
Quick read access of the Carry bit from arithmetic operations.
void CRYPTO_AES_CTR128(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.
#define _CRYPTO_SEQ1_INSTR4_SHIFT
#define CRYPTO_CMD_INSTR_MULO
#define CRYPTO_SEQCTRL_BLOCKSIZE_16BYTES
#define CRYPTO_CMD_INSTR_CLR
#define _CRYPTO_WAC_MODOP_MASK
void CRYPTO_AES_CBC256(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.
#define CRYPTO_CMD_INSTR_MADD32
#define CRYPTO_CMD_INSTR_SELDDATA0DDATA2
void CRYPTO_AES_OFB256(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.
#define CRYPTO_CTRL_DMA1MODE_FULL
static void CRYPTO_AES_ECBx(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.
__STATIC_INLINE void CRYPTO_InstructionSequenceExecute(void)
Execute the current programmed instruction sequence.
uint8_t CRYPTO_SHA256_Digest_TypeDef[CRYPTO_SHA256_DIGEST_SIZE_IN_BYTES]
#define _CRYPTO_SEQ0_INSTR0_SHIFT
void CRYPTO_AES_DecryptKey128(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 ...
__STATIC_INLINE void cryptoBigintZeroize(uint32_t *words32bits, int num32bitWords)
Set 32bit word array to zero.
#define CRYPTO_CMD_INSTR_DATA2TODATA0
#define CRYPTO_WAC_MODOP_REGULAR
#define CRYPTO_CMD_INSTR_DATA1TODATA2
#define CRYPTO_CMD_INSTR_DMA1TODATA
#define CRYPTO_CTRL_INCWIDTH_INCWIDTH4
#define CRYPTO_CMD_INSTR_SELDDATA0DDATA1
void CRYPTO_AES_CTR256(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.