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)
211 static inline void CRYPTO_AES_ProcessLoop(uint32_t len,
212 CRYPTO_DataReg_TypeDef inReg,
214 CRYPTO_DataReg_TypeDef outReg,
217 static void CRYPTO_AES_CBCx(uint8_t * out,
223 CRYPTO_KeyWidth_TypeDef keyWidth);
225 static void CRYPTO_AES_CFBx(uint8_t * out,
231 CRYPTO_KeyWidth_TypeDef keyWidth);
233 static void CRYPTO_AES_CTRx(uint8_t * out,
238 CRYPTO_AES_CtrFuncPtr_TypeDef ctrFunc,
239 CRYPTO_KeyWidth_TypeDef keyWidth);
241 static void CRYPTO_AES_ECBx(uint8_t * out,
246 CRYPTO_KeyWidth_TypeDef keyWidth);
248 static void CRYPTO_AES_OFBx(uint8_t * out,
253 CRYPTO_KeyWidth_TypeDef keyWidth);
255 #ifdef USE_VARIABLE_SIZED_DATA_LOADS
269 void CRYPTO_DataWriteVariableSize(CRYPTO_DataReg_TypeDef dataReg,
270 const CRYPTO_Data_TypeDef val,
274 volatile uint32_t * reg = (
volatile uint32_t *) dataReg;
279 for (i = 0; i < valSize; i++)
286 CRYPTO_BurstToCrypto(reg, &val[0]);
307 void CRYPTO_ModulusSet(CRYPTO_ModulusType_TypeDef modType)
309 uint32_t temp = CRYPTO->WAC & (~(_CRYPTO_WAC_MODULUS_MASK | _CRYPTO_WAC_MODOP_MASK));
313 case cryptoModulusBin256:
314 case cryptoModulusBin128:
315 case cryptoModulusGcmBin128:
316 case cryptoModulusEccB233:
317 case cryptoModulusEccB163:
318 #ifdef _CRYPTO_WAC_MODULUS_ECCBIN233N
319 case cryptoModulusEccB233Order:
320 case cryptoModulusEccB233KOrder:
321 case cryptoModulusEccB163Order:
322 case cryptoModulusEccB163KOrder:
324 CRYPTO->WAC = temp | modType | CRYPTO_WAC_MODOP_BINARY;
327 case cryptoModulusEccP256:
328 case cryptoModulusEccP224:
329 case cryptoModulusEccP192:
330 #ifdef _CRYPTO_WAC_MODULUS_ECCPRIME256P
331 case cryptoModulusEccP256Order:
332 case cryptoModulusEccP224Order:
333 case cryptoModulusEccP192Order:
335 CRYPTO->WAC = temp | modType | CRYPTO_WAC_MODOP_REGULAR;
354 void CRYPTO_KeyRead(CRYPTO_KeyBuf_TypeDef val,
355 CRYPTO_KeyWidth_TypeDef keyWidth)
359 CRYPTO_BurstFromCrypto(&CRYPTO->KEY, &val[0]);
360 if (keyWidth == cryptoKey256Bits)
362 CRYPTO_BurstFromCrypto(&CRYPTO->KEY, &val[4]);
378 void CRYPTO_SHA_1(
const uint8_t * msg,
380 CRYPTO_SHA1_Digest_TypeDef msgDigest)
385 uint32_t shaBlock[CRYPTO_SHA1_BLOCK_SIZE_IN_32BIT_WORDS]=
388 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0
390 uint8_t * p8ShaBlock = (uint8_t *) shaBlock;
393 CRYPTO->CTRL = CRYPTO_CTRL_SHA_SHA1;
395 CRYPTO->SEQCTRLB = 0;
398 CRYPTO_ResultWidthSet(cryptoResult256Bits);
401 CRYPTO_DDataWrite(cryptoRegDDATA1, shaBlock);
404 CRYPTO_EXECUTE_2(CRYPTO_CMD_INSTR_DDATA1TODDATA0,
405 CRYPTO_CMD_INSTR_SELDDATA0DDATA1);
409 while (len >= CRYPTO_SHA1_BLOCK_SIZE_IN_BYTES)
412 CRYPTO_QDataWrite(cryptoRegQDATA1BIG, (uint32_t *) msg);
415 CRYPTO_EXECUTE_3(CRYPTO_CMD_INSTR_SHA,
416 CRYPTO_CMD_INSTR_MADD32,
417 CRYPTO_CMD_INSTR_DDATA0TODDATA1);
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;
442 CRYPTO_QDataWrite(cryptoRegQDATA1BIG, shaBlock);
445 CRYPTO_EXECUTE_3(CRYPTO_CMD_INSTR_SHA,
446 CRYPTO_CMD_INSTR_MADD32,
447 CRYPTO_CMD_INSTR_DDATA0TODDATA1);
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);
465 CRYPTO_QDataWrite(cryptoRegQDATA1BIG, shaBlock);
468 CRYPTO_EXECUTE_3(CRYPTO_CMD_INSTR_SHA,
469 CRYPTO_CMD_INSTR_MADD32,
470 CRYPTO_CMD_INSTR_DDATA0TODDATA1);
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;
478 temp = CRYPTO->DDATA0BIG;
479 temp = CRYPTO->DDATA0BIG;
480 temp = CRYPTO->DDATA0BIG;
495 void CRYPTO_SHA_256(
const uint8_t * msg,
497 CRYPTO_SHA256_Digest_TypeDef msgDigest)
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;
511 CRYPTO->CTRL = CRYPTO_CTRL_SHA_SHA2;
513 CRYPTO->SEQCTRLB = 0;
516 CRYPTO_ResultWidthSet(cryptoResult256Bits);
519 CRYPTO_DDataWrite(cryptoRegDDATA1, shaBlock);
522 CRYPTO_EXECUTE_2(CRYPTO_CMD_INSTR_DDATA1TODDATA0,
523 CRYPTO_CMD_INSTR_SELDDATA0DDATA1);
526 while (len >= CRYPTO_SHA256_BLOCK_SIZE_IN_BYTES)
529 CRYPTO_QDataWrite(cryptoRegQDATA1BIG, (uint32_t *) msg);
532 CRYPTO_EXECUTE_3(CRYPTO_CMD_INSTR_SHA,
533 CRYPTO_CMD_INSTR_MADD32,
534 CRYPTO_CMD_INSTR_DDATA0TODDATA1);
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;
559 CRYPTO_QDataWrite(cryptoRegQDATA1BIG, shaBlock);
562 CRYPTO_EXECUTE_3(CRYPTO_CMD_INSTR_SHA,
563 CRYPTO_CMD_INSTR_MADD32,
564 CRYPTO_CMD_INSTR_DDATA0TODDATA1);
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);
582 CRYPTO_QDataWrite(cryptoRegQDATA1BIG, shaBlock);
585 CRYPTO_EXECUTE_3(CRYPTO_CMD_INSTR_SHA,
586 CRYPTO_CMD_INSTR_MADD32,
587 CRYPTO_CMD_INSTR_DDATA0TODDATA1);
590 CRYPTO_DDataRead(cryptoRegDDATA0BIG, (uint32_t *)msgDigest);
600 __STATIC_INLINE
void cryptoBigintZeroize(uint32_t * words32bits,
603 while (num32bitWords--)
614 __STATIC_INLINE
void cryptoBigintIncrement(uint32_t * words32bits,
618 for (i=0; i<num32bitWords; i++)
619 if (++words32bits[i] != 0)
641 void CRYPTO_Mul(uint32_t * A,
int aSize,
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);
672 cryptoBigintZeroize(R, rSize >> 5);
675 CRYPTO->WAC = CRYPTO_WAC_MULWIDTH_MUL128 | CRYPTO_WAC_RESULTWIDTH_256BIT;
682 CRYPTO_CTRL_DMA0RSEL_DATA0 | CRYPTO_CTRL_DMA0MODE_FULL |
683 CRYPTO_CTRL_DMA1RSEL_DATA1 | CRYPTO_CTRL_DMA1MODE_FULL;
686 CRYPTO_CMD_INSTR_CCLR,
687 CRYPTO_CMD_INSTR_CLR,
689 CRYPTO_CMD_INSTR_DDATA0TODDATA2,
690 CRYPTO_CMD_INSTR_SELDDATA1DDATA3);
702 CRYPTO_CMD_INSTR_DMA0TODATA,
704 CRYPTO_CMD_INSTR_DDATA2TODDATA1,
707 CRYPTO_CMD_INSTR_DATA1TODATA0,
710 CRYPTO_CMD_INSTR_DMA1TODATA,
713 CRYPTO_CMD_INSTR_MULO,
718 CRYPTO_CMD_INSTR_SELDDATA0DDATA2,
719 CRYPTO_CMD_INSTR_ADDIC,
722 CRYPTO_CMD_INSTR_DDATA0TODDATA2,
723 CRYPTO_CMD_INSTR_DATATODMA0,
725 CRYPTO_CMD_INSTR_SELDDATA2DDATA3
730 for(i=0; i<numPartialOperandsA; i++)
733 #ifdef USE_VARIABLE_SIZED_DATA_LOADS
734 if ( (numWordsLastOperandA != 0) && ( i == numPartialOperandsA-1 ) )
735 CRYPTO_DataWriteVariableSize(cryptoRegDATA2,
736 &A[i*PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS],
737 numWordsLastOperandA);
739 CRYPTO_DataWrite(cryptoRegDATA2, &A[i*PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS]);
741 CRYPTO_DataWrite(cryptoRegDATA2, &A[i*PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS]);
745 #ifdef USE_VARIABLE_SIZED_DATA_LOADS
746 if ( (numWordsLastOperandR != 0) && ( i == numPartialOperandsR-1 ) )
747 CRYPTO_DataWriteVariableSize(cryptoRegDATA1,
748 &R[i*PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS],
749 numWordsLastOperandR);
751 CRYPTO_DataWrite(cryptoRegDATA1, &R[i*PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS]);
753 CRYPTO_DataWrite(cryptoRegDATA1, &R[i*PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS]);
757 CRYPTO->CMD = CRYPTO_CMD_INSTR_CCLR;
760 CRYPTO->SEQCTRL = CRYPTO_SEQCTRL_BLOCKSIZE_16BYTES
761 | (PARTIAL_OPERAND_WIDTH_IN_BYTES * numPartialOperandsB);
764 CRYPTO_InstructionSequenceExecute();
766 for (j=0; j<numPartialOperandsB; j++)
770 #ifdef USE_VARIABLE_SIZED_DATA_LOADS
771 if ( (numWordsLastOperandB != 0) && ( j == numPartialOperandsB-1 ) )
772 CRYPTO_DataWriteVariableSize(cryptoRegDATA0,
773 &B[j*PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS],
774 numWordsLastOperandB);
776 CRYPTO_DataWrite(cryptoRegDATA0,
777 &B[j*PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS]);
779 CRYPTO_DataWrite(cryptoRegDATA0,
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 ) )
787 CRYPTO_DataWriteVariableSize(cryptoRegDATA1,
788 &R[(i+j+1)*PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS],
789 numWordsLastOperandR);
791 CRYPTO_DataWrite(cryptoRegDATA1,
792 &R[(i+j+1)*PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS]);
794 CRYPTO_DataWrite(cryptoRegDATA1,
795 &R[(i+j+1)*PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS]);
798 CRYPTO_DataRead(cryptoRegDATA0,
799 &R[(i+j)*PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS]);
804 if (CRYPTO_CarryIsSet())
805 cryptoBigintIncrement(&R[(i+numPartialOperandsB+1)
806 *PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS],
807 (numPartialOperandsA-i-1)
808 *PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS);
810 CRYPTO_DataRead(cryptoRegDATA1,
811 &R[(i+numPartialOperandsB)
812 * PARTIAL_OPERAND_WIDTH_IN_32BIT_WORDS]);
879 void CRYPTO_AES_CBC128(uint8_t * out,
886 CRYPTO->CTRL = CRYPTO_CTRL_AES_AES128;
887 CRYPTO_AES_CBCx(out, in, len, key, iv, encrypt, cryptoKey128Bits);
921 void CRYPTO_AES_CBC256(uint8_t * out,
928 CRYPTO->CTRL = CRYPTO_CTRL_AES_AES256;
929 CRYPTO_AES_CBCx(out, in, len, key, iv, encrypt, cryptoKey256Bits);
990 void CRYPTO_AES_CFB128(uint8_t * out,
997 CRYPTO->CTRL = CRYPTO_CTRL_AES_AES128;
998 CRYPTO_AES_CFBx(out, in, len, key, iv, encrypt, cryptoKey128Bits);
1029 void CRYPTO_AES_CFB256(uint8_t * out,
1032 const uint8_t * key,
1036 CRYPTO->CTRL = CRYPTO_CTRL_AES_AES256;
1037 CRYPTO_AES_CFBx(out, in, len, key, iv, encrypt, cryptoKey256Bits);
1101 void CRYPTO_AES_CTR128(uint8_t * out,
1104 const uint8_t * key,
1106 CRYPTO_AES_CtrFuncPtr_TypeDef ctrFunc)
1108 CRYPTO->CTRL = CRYPTO_CTRL_AES_AES128;
1109 CRYPTO_AES_CTRx(out, in, len, key, ctr, ctrFunc, cryptoKey128Bits);
1143 void CRYPTO_AES_CTR256(uint8_t * out,
1146 const uint8_t * key,
1148 CRYPTO_AES_CtrFuncPtr_TypeDef ctrFunc)
1150 CRYPTO->CTRL = CRYPTO_CTRL_AES_AES256;
1151 CRYPTO_AES_CTRx(out, in, len, key, ctr, ctrFunc, cryptoKey256Bits);
1168 void CRYPTO_AES_CTRUpdate32Bit(uint8_t * ctr)
1170 uint32_t * _ctr = (uint32_t *) ctr;
1172 _ctr[3] = __REV(__REV(_ctr[3]) + 1);
1190 void CRYPTO_AES_DecryptKey128(uint8_t * out,
const uint8_t * in)
1192 uint32_t * _out = (uint32_t *) out;
1193 const uint32_t * _in = (
const uint32_t *) in;
1196 CRYPTO_BurstToCrypto(&CRYPTO->KEYBUF, &_in[0]);
1199 CRYPTO->CTRL = CRYPTO_CTRL_AES_AES128;
1200 CRYPTO_IntClear(CRYPTO_IF_INSTRDONE);
1201 CRYPTO->CMD = CRYPTO_CMD_INSTR_AESENC;
1204 CRYPTO_BurstFromCrypto(&CRYPTO->KEY, &_out[0]);
1222 void CRYPTO_AES_DecryptKey256(uint8_t * out,
const uint8_t * in)
1224 uint32_t * _out = (uint32_t *) out;
1225 const uint32_t * _in = (
const uint32_t *) in;
1228 CRYPTO_BurstToCrypto(&CRYPTO->KEYBUF, &_in[0]);
1229 CRYPTO_BurstToCrypto(&CRYPTO->KEYBUF, &_in[4]);
1232 CRYPTO->CTRL = CRYPTO_CTRL_AES_AES256;
1233 CRYPTO->CMD = CRYPTO_CMD_INSTR_AESENC;
1236 CRYPTO_BurstFromCrypto(&CRYPTO->KEY, &_out[0]);
1237 CRYPTO_BurstFromCrypto(&CRYPTO->KEY, &_out[4]);
1292 void CRYPTO_AES_ECB128(uint8_t * out,
1295 const uint8_t * key,
1298 CRYPTO->CTRL = CRYPTO_CTRL_AES_AES128;
1299 CRYPTO_AES_ECBx(out, in, len, key, encrypt, cryptoKey128Bits);
1330 void CRYPTO_AES_ECB256(uint8_t * out,
1333 const uint8_t * key,
1336 CRYPTO->CTRL = CRYPTO_CTRL_AES_AES256;
1337 CRYPTO_AES_ECBx(out, in, len, key, encrypt, cryptoKey256Bits);
1397 void CRYPTO_AES_OFB128(uint8_t * out,
1400 const uint8_t * key,
1403 CRYPTO->CTRL = CRYPTO_CTRL_AES_AES128;
1404 CRYPTO_AES_OFBx(out, in, len, key, iv, cryptoKey128Bits);
1432 void CRYPTO_AES_OFB256(uint8_t * out,
1435 const uint8_t * key,
1438 CRYPTO->CTRL = CRYPTO_CTRL_AES_AES256;
1439 CRYPTO_AES_OFBx(out, in, len, key, iv, cryptoKey256Bits);
1479 static void CRYPTO_AES_CBCx(uint8_t * out,
1482 const uint8_t * key,
1485 CRYPTO_KeyWidth_TypeDef keyWidth)
1487 EFM_ASSERT(!(len % CRYPTO_AES_BLOCKSIZE));
1492 CRYPTO_KeyBufWrite((uint32_t *)key, keyWidth);
1496 CRYPTO_DataWrite(cryptoRegDATA0, (uint32_t *)iv);
1499 CRYPTO_CMD_INSTR_DATA1TODATA0XOR << _CRYPTO_SEQ0_INSTR0_SHIFT |
1500 CRYPTO_CMD_INSTR_AESENC << _CRYPTO_SEQ0_INSTR1_SHIFT;
1502 CRYPTO_AES_ProcessLoop(len,
1503 cryptoRegDATA1, (uint32_t *) in,
1504 cryptoRegDATA0, (uint32_t *) out);
1508 CRYPTO_DataWrite(cryptoRegDATA2, (uint32_t *) iv);
1511 CRYPTO_CMD_INSTR_DATA1TODATA0 << _CRYPTO_SEQ0_INSTR0_SHIFT |
1512 CRYPTO_CMD_INSTR_AESDEC << _CRYPTO_SEQ0_INSTR1_SHIFT |
1513 CRYPTO_CMD_INSTR_DATA2TODATA0XOR << _CRYPTO_SEQ0_INSTR2_SHIFT |
1514 CRYPTO_CMD_INSTR_DATA1TODATA2 << _CRYPTO_SEQ0_INSTR3_SHIFT;
1522 CRYPTO_AES_ProcessLoop(len,
1523 cryptoRegDATA1, (uint32_t *) in,
1524 cryptoRegDATA0, (uint32_t *) out);
1559 static void CRYPTO_AES_CFBx(uint8_t * out,
1562 const uint8_t * key,
1565 CRYPTO_KeyWidth_TypeDef keyWidth)
1567 EFM_ASSERT(!(len % CRYPTO_AES_BLOCKSIZE));
1573 CRYPTO_KeyBufWrite((uint32_t *)key, keyWidth);
1579 CRYPTO_DataWrite(cryptoRegDATA0, (uint32_t *)iv);
1582 CRYPTO_CMD_INSTR_AESENC << _CRYPTO_SEQ0_INSTR0_SHIFT |
1583 CRYPTO_CMD_INSTR_DATA1TODATA0XOR << _CRYPTO_SEQ0_INSTR1_SHIFT;
1585 CRYPTO_AES_ProcessLoop(len,
1586 cryptoRegDATA1, (uint32_t *)in,
1587 cryptoRegDATA0, (uint32_t *)out
1593 CRYPTO_DataWrite(cryptoRegDATA2, (uint32_t *)iv);
1596 CRYPTO_CMD_INSTR_DATA2TODATA0 << _CRYPTO_SEQ0_INSTR0_SHIFT |
1597 CRYPTO_CMD_INSTR_AESENC << _CRYPTO_SEQ0_INSTR1_SHIFT |
1598 CRYPTO_CMD_INSTR_DATA1TODATA0XOR << _CRYPTO_SEQ0_INSTR2_SHIFT |
1599 CRYPTO_CMD_INSTR_DATA1TODATA2 << _CRYPTO_SEQ0_INSTR3_SHIFT;
1602 CRYPTO_AES_ProcessLoop(len,
1603 cryptoRegDATA1, (uint32_t *)in,
1604 cryptoRegDATA0, (uint32_t *)out
1643 static void CRYPTO_AES_CTRx(uint8_t * out,
1646 const uint8_t * key,
1648 CRYPTO_AES_CtrFuncPtr_TypeDef ctrFunc,
1649 CRYPTO_KeyWidth_TypeDef keyWidth)
1653 EFM_ASSERT(!(len % CRYPTO_AES_BLOCKSIZE));
1656 CRYPTO->CTRL |= CRYPTO_CTRL_INCWIDTH_INCWIDTH4;
1659 CRYPTO_KeyBufWrite((uint32_t *)key, keyWidth);
1661 CRYPTO_DataWrite(cryptoRegDATA1, (uint32_t *) ctr);
1663 CRYPTO->SEQ0 = CRYPTO_CMD_INSTR_DATA1TODATA0 << _CRYPTO_SEQ0_INSTR0_SHIFT |
1664 CRYPTO_CMD_INSTR_AESENC << _CRYPTO_SEQ0_INSTR1_SHIFT |
1665 CRYPTO_CMD_INSTR_DATA0TODATA3 << _CRYPTO_SEQ0_INSTR2_SHIFT |
1666 CRYPTO_CMD_INSTR_DATA1INC << _CRYPTO_SEQ0_INSTR3_SHIFT;
1668 CRYPTO->SEQ1 = CRYPTO_CMD_INSTR_DATA2TODATA0XOR << _CRYPTO_SEQ1_INSTR4_SHIFT;
1670 CRYPTO_AES_ProcessLoop(len,
1671 cryptoRegDATA2, (uint32_t *) in,
1672 cryptoRegDATA0, (uint32_t *) out);
1674 CRYPTO_DataRead(cryptoRegDATA1, (uint32_t *) ctr);
1707 static void CRYPTO_AES_ECBx(uint8_t * out,
1710 const uint8_t * key,
1712 CRYPTO_KeyWidth_TypeDef keyWidth)
1714 EFM_ASSERT(!(len % CRYPTO_AES_BLOCKSIZE));
1718 CRYPTO_KeyBufWrite((uint32_t *)key, keyWidth);
1723 (CRYPTO_CMD_INSTR_AESENC << _CRYPTO_SEQ0_INSTR0_SHIFT |
1724 CRYPTO_CMD_INSTR_DATA0TODATA1 << _CRYPTO_SEQ0_INSTR1_SHIFT);
1729 (CRYPTO_CMD_INSTR_AESDEC << _CRYPTO_SEQ0_INSTR0_SHIFT |
1730 CRYPTO_CMD_INSTR_DATA0TODATA1 << _CRYPTO_SEQ0_INSTR1_SHIFT);
1733 CRYPTO_AES_ProcessLoop(len,
1734 cryptoRegDATA0, (uint32_t *) in,
1735 cryptoRegDATA1, (uint32_t *) out);
1766 static void CRYPTO_AES_OFBx(uint8_t * out,
1769 const uint8_t * key,
1771 CRYPTO_KeyWidth_TypeDef keyWidth)
1773 EFM_ASSERT(!(len % CRYPTO_AES_BLOCKSIZE));
1777 CRYPTO_KeyBufWrite((uint32_t *)key, keyWidth);
1779 CRYPTO_DataWrite(cryptoRegDATA2, (uint32_t *)iv);
1782 CRYPTO_CMD_INSTR_DATA0TODATA1 << _CRYPTO_SEQ0_INSTR0_SHIFT |
1783 CRYPTO_CMD_INSTR_DATA2TODATA0 << _CRYPTO_SEQ0_INSTR1_SHIFT |
1784 CRYPTO_CMD_INSTR_AESENC << _CRYPTO_SEQ0_INSTR2_SHIFT |
1785 CRYPTO_CMD_INSTR_DATA0TODATA2 << _CRYPTO_SEQ0_INSTR3_SHIFT;
1787 CRYPTO_CMD_INSTR_DATA1TODATA0XOR << _CRYPTO_SEQ1_INSTR4_SHIFT |
1788 CRYPTO_CMD_INSTR_DATA0TODATA1 << _CRYPTO_SEQ1_INSTR5_SHIFT;
1790 CRYPTO_AES_ProcessLoop(len,
1791 cryptoRegDATA0, (uint32_t *) in,
1792 cryptoRegDATA1, (uint32_t *) out);
1820 static inline void CRYPTO_AES_ProcessLoop(uint32_t len,
1821 CRYPTO_DataReg_TypeDef inReg,
1823 CRYPTO_DataReg_TypeDef outReg,
1826 len /= CRYPTO_AES_BLOCKSIZE;
1827 CRYPTO->SEQCTRL = 16 << _CRYPTO_SEQCTRL_LENGTHA_SHIFT;
1832 CRYPTO_DataWrite(inReg, (uint32_t *)in);
1834 CRYPTO->CMD = CRYPTO_CMD_SEQSTART;
1837 CRYPTO_DataRead(outReg, (uint32_t *)out);
Emlib peripheral API "assert" implementation.
CMSIS Cortex-M Peripheral Access Layer for Silicon Laboratories microcontroller devices.
Cryptography accelerator peripheral API.