32 #define TRACE_LEVEL CRYPTO_TRACE_LEVEL
35 #include "stm32h7xx.h"
36 #include "stm32h7xx_hal.h"
46 #if (STM32H7XX_CRYPTO_CIPHER_SUPPORT == ENABLED)
57 __HAL_RCC_CRYP_CLK_ENABLE();
64 #if (DES_SUPPORT == ENABLED)
77 uint8_t *output,
size_t length, uint32_t mode)
90 CRYP->K1LR = context->
ks[0];
91 CRYP->K1RR = context->
ks[1];
102 CRYP->CR |= CRYP_CR_FFLUSH;
104 CRYP->CR |= CRYP_CR_CRYPEN;
110 while((CRYP->SR & CRYP_SR_IFNF) == 0)
115 CRYP->DIN = __UNALIGNED_UINT32_READ(input);
116 CRYP->DIN = __UNALIGNED_UINT32_READ(input + 4);
119 while((CRYP->SR & CRYP_SR_OFNE) == 0)
125 __UNALIGNED_UINT32_WRITE(output, temp);
127 __UNALIGNED_UINT32_WRITE(output + 4, temp);
164 if(context == NULL || key == NULL)
191 CRYP_CR_ALGOMODE_DES_ECB);
206 CRYP_CR_ALGOMODE_DES_ECB | CRYP_CR_ALGODIR);
210 #if (DES3_SUPPORT == ENABLED)
223 uint8_t *output,
size_t length, uint32_t mode)
236 CRYP->K1LR = context->
k1.
ks[0];
237 CRYP->K1RR = context->
k1.
ks[1];
238 CRYP->K2LR = context->
k2.
ks[0];
239 CRYP->K2RR = context->
k2.
ks[1];
240 CRYP->K3LR = context->
k3.
ks[0];
241 CRYP->K3RR = context->
k3.
ks[1];
252 CRYP->CR |= CRYP_CR_FFLUSH;
254 CRYP->CR |= CRYP_CR_CRYPEN;
260 while((CRYP->SR & CRYP_SR_IFNF) == 0)
265 CRYP->DIN = __UNALIGNED_UINT32_READ(input);
266 CRYP->DIN = __UNALIGNED_UINT32_READ(input + 4);
269 while((CRYP->SR & CRYP_SR_OFNE) == 0)
275 __UNALIGNED_UINT32_WRITE(output, temp);
277 __UNALIGNED_UINT32_WRITE(output + 4, temp);
314 if(context == NULL || key == NULL)
329 else if(keyLen == 16)
341 else if(keyLen == 24)
374 CRYP_CR_ALGOMODE_TDES_ECB);
389 CRYP_CR_ALGOMODE_TDES_ECB | CRYP_CR_ALGODIR);
393 #if (AES_SUPPORT == ENABLED)
405 temp = CRYP->CR & ~CRYP_CR_KEYSIZE;
408 if(context->
nr == 10)
414 CRYP->K2LR = context->
ek[0];
415 CRYP->K2RR = context->
ek[1];
416 CRYP->K3LR = context->
ek[2];
417 CRYP->K3RR = context->
ek[3];
419 else if(context->
nr == 12)
425 CRYP->K1LR = context->
ek[0];
426 CRYP->K1RR = context->
ek[1];
427 CRYP->K2LR = context->
ek[2];
428 CRYP->K2RR = context->
ek[3];
429 CRYP->K3LR = context->
ek[4];
430 CRYP->K3RR = context->
ek[5];
438 CRYP->K0LR = context->
ek[0];
439 CRYP->K0RR = context->
ek[1];
440 CRYP->K1LR = context->
ek[2];
441 CRYP->K1RR = context->
ek[3];
442 CRYP->K2LR = context->
ek[4];
443 CRYP->K2RR = context->
ek[5];
444 CRYP->K3LR = context->
ek[6];
445 CRYP->K3RR = context->
ek[7];
461 uint8_t *output,
size_t length, uint32_t mode)
472 if((mode & CRYP_CR_ALGODIR) != 0)
475 CRYP->CR |= CRYP_CR_ALGOMODE_AES_KEY;
479 CRYP->CR |= CRYP_CR_CRYPEN;
482 while((CRYP->SR & CRYP_SR_BUSY) != 0)
487 temp = CRYP->CR & ~CRYP_CR_ALGOMODE;
488 CRYP->CR = temp | mode;
509 CRYP->CR |= CRYP_CR_FFLUSH;
511 CRYP->CR |= CRYP_CR_CRYPEN;
517 while((CRYP->SR & CRYP_SR_IFNF) == 0)
522 CRYP->DIN = __UNALIGNED_UINT32_READ(input);
523 CRYP->DIN = __UNALIGNED_UINT32_READ(input + 4);
524 CRYP->DIN = __UNALIGNED_UINT32_READ(input + 8);
525 CRYP->DIN = __UNALIGNED_UINT32_READ(input + 12);
528 while((CRYP->SR & CRYP_SR_OFNE) == 0)
534 __UNALIGNED_UINT32_WRITE(output, temp);
536 __UNALIGNED_UINT32_WRITE(output + 4, temp);
538 __UNALIGNED_UINT32_WRITE(output + 8, temp);
540 __UNALIGNED_UINT32_WRITE(output + 12, temp);
558 while((CRYP->SR & CRYP_SR_IFNF) == 0)
563 CRYP->DIN = buffer[0];
564 CRYP->DIN = buffer[1];
565 CRYP->DIN = buffer[2];
566 CRYP->DIN = buffer[3];
569 while((CRYP->SR & CRYP_SR_OFNE) == 0)
574 buffer[0] = CRYP->DOUT;
575 buffer[1] = CRYP->DOUT;
576 buffer[2] = CRYP->DOUT;
577 buffer[3] = CRYP->DOUT;
618 if(context == NULL || key == NULL)
627 else if(keyLen == 24)
632 else if(keyLen == 32)
647 for(i = 0; i < keyLen; i++)
668 CRYP_CR_ALGOMODE_AES_ECB);
683 CRYP_CR_ALGOMODE_AES_ECB | CRYP_CR_ALGODIR);
687 #if (ECB_SUPPORT == ENABLED)
700 const uint8_t *
p, uint8_t *
c,
size_t length)
707 #if (DES_SUPPORT == ENABLED)
729 #if (DES3_SUPPORT == ENABLED)
751 #if (AES_SUPPORT == ENABLED)
810 const uint8_t *
c, uint8_t *
p,
size_t length)
817 #if (DES_SUPPORT == ENABLED)
840 #if (DES3_SUPPORT == ENABLED)
863 #if (AES_SUPPORT == ENABLED)
912 #if (CBC_SUPPORT == ENABLED)
926 uint8_t *
iv,
const uint8_t *
p, uint8_t *
c,
size_t length)
933 #if (DES_SUPPORT == ENABLED)
955 #if (DES3_SUPPORT == ENABLED)
977 #if (AES_SUPPORT == ENABLED)
1009 c[i] =
p[i] ^
iv[i];
1049 uint8_t *
iv,
const uint8_t *
c, uint8_t *
p,
size_t length)
1056 #if (DES_SUPPORT == ENABLED)
1079 #if (DES3_SUPPORT == ENABLED)
1102 #if (AES_SUPPORT == ENABLED)
1166 #if (CTR_SUPPORT == ENABLED && AES_SUPPORT == ENABLED)
1181 uint8_t *
t,
const uint8_t *
p, uint8_t *
c,
size_t length)
1235 for(i = 0; i <
n; i++)
1241 for(temp = 1, i = 1; i <=
m; i++)
1267 #if (GCM_SUPPORT == ENABLED && AES_SUPPORT == ENABLED)
1283 const uint8_t *
a,
size_t aLen,
const uint8_t *input, uint8_t *output,
1284 size_t length, uint8_t *
t, uint32_t mode)
1290 #if !defined (CRYP_VER_2_2)
1301 temp = CRYP->CR & ~CRYP_CR_ALGOMODE;
1302 CRYP->CR = temp | CRYP_CR_ALGOMODE_AES_GCM;
1305 temp = CRYP->CR & ~CRYP_CR_GCM_CCMPH;
1318 CRYP->CR |= CRYP_CR_CRYPEN;
1322 while((CRYP->CR & CRYP_CR_CRYPEN) != 0)
1327 temp = CRYP->CR & ~CRYP_CR_GCM_CCMPH;
1331 CRYP->CR |= CRYP_CR_FFLUSH;
1333 CRYP->CR |= CRYP_CR_CRYPEN;
1339 while((CRYP->SR & CRYP_SR_IFNF) == 0)
1344 CRYP->DIN = __UNALIGNED_UINT32_READ(
a);
1345 CRYP->DIN = __UNALIGNED_UINT32_READ(
a + 4);
1346 CRYP->DIN = __UNALIGNED_UINT32_READ(
a + 8);
1347 CRYP->DIN = __UNALIGNED_UINT32_READ(
a + 12);
1361 while((CRYP->SR & CRYP_SR_IFNF) == 0)
1366 CRYP->DIN = buffer[0];
1367 CRYP->DIN = buffer[1];
1368 CRYP->DIN = buffer[2];
1369 CRYP->DIN = buffer[3];
1374 while((CRYP->SR & CRYP_SR_BUSY) != 0)
1379 CRYP->CR &= ~CRYP_CR_CRYPEN;
1382 temp = CRYP->CR & ~CRYP_CR_GCM_CCMPH;
1386 temp = CRYP->CR & ~CRYP_CR_ALGODIR;
1390 CRYP->CR |= CRYP_CR_CRYPEN;
1396 while((CRYP->SR & CRYP_SR_IFNF) == 0)
1401 CRYP->DIN = __UNALIGNED_UINT32_READ(input);
1402 CRYP->DIN = __UNALIGNED_UINT32_READ(input + 4);
1403 CRYP->DIN = __UNALIGNED_UINT32_READ(input + 8);
1404 CRYP->DIN = __UNALIGNED_UINT32_READ(input + 12);
1407 while((CRYP->SR & CRYP_SR_OFNE) == 0)
1413 __UNALIGNED_UINT32_WRITE(output, temp);
1415 __UNALIGNED_UINT32_WRITE(output + 4, temp);
1417 __UNALIGNED_UINT32_WRITE(output + 8, temp);
1419 __UNALIGNED_UINT32_WRITE(output + 12, temp);
1433 #if !defined (CRYP_VER_2_2)
1435 if(HAL_GetREVID() < REV_ID_B)
1438 if((mode & CRYP_CR_ALGODIR) == 0)
1441 while((CRYP->SR & CRYP_SR_BUSY) != 0)
1446 h[0] = CRYP->CSGCM0R;
1447 h[1] = CRYP->CSGCM1R;
1448 h[2] = CRYP->CSGCM2R;
1449 h[3] = CRYP->CSGCM3R;
1456 temp = CRYP->CR & ~CRYP_CR_NPBLB;
1461 while((CRYP->SR & CRYP_SR_IFNF) == 0)
1466 CRYP->DIN = buffer[0];
1467 CRYP->DIN = buffer[1];
1468 CRYP->DIN = buffer[2];
1469 CRYP->DIN = buffer[3];
1472 while((CRYP->SR & CRYP_SR_OFNE) == 0)
1477 buffer[0] = CRYP->DOUT;
1478 buffer[1] = CRYP->DOUT;
1479 buffer[2] = CRYP->DOUT;
1480 buffer[3] = CRYP->DOUT;
1485 #if !defined (CRYP_VER_2_2)
1487 if(HAL_GetREVID() < REV_ID_B)
1490 if((mode & CRYP_CR_ALGODIR) == 0)
1496 while((CRYP->SR & CRYP_SR_BUSY) != 0)
1501 CRYP->CR |= CRYP_CR_ALGODIR;
1504 CRYP->CSGCM0R =
h[0];
1505 CRYP->CSGCM1R =
h[1];
1506 CRYP->CSGCM2R =
h[2];
1507 CRYP->CSGCM3R =
h[3];
1510 while((CRYP->SR & CRYP_SR_IFNF) == 0)
1515 CRYP->DIN = buffer[0];
1516 CRYP->DIN = buffer[1];
1517 CRYP->DIN = buffer[2];
1518 CRYP->DIN = buffer[3];
1521 while((CRYP->SR & CRYP_SR_OFNE) == 0)
1526 buffer[0] = CRYP->DOUT;
1527 buffer[1] = CRYP->DOUT;
1528 buffer[2] = CRYP->DOUT;
1529 buffer[3] = CRYP->DOUT;
1537 while((CRYP->SR & CRYP_SR_BUSY) != 0)
1542 temp = CRYP->CR & ~CRYP_CR_GCM_CCMPH;
1545 #if !defined (CRYP_VER_2_2)
1547 if(HAL_GetREVID() < REV_ID_B)
1572 while((CRYP->SR & CRYP_SR_OFNE) == 0)
1579 __UNALIGNED_UINT32_WRITE(
t, temp);
1581 __UNALIGNED_UINT32_WRITE(
t + 4, temp);
1583 __UNALIGNED_UINT32_WRITE(
t + 8, temp);
1585 __UNALIGNED_UINT32_WRITE(
t + 12, temp);
1604 void *cipherContext)
1607 if(context == NULL || cipherContext == NULL)
1639 size_t ivLen,
const uint8_t *
a,
size_t aLen,
const uint8_t *
p,
1640 uint8_t *
c,
size_t length, uint8_t *
t,
size_t tLen)
1642 uint8_t authTag[16];
1653 if(tLen < 4 || tLen > 16)
1684 size_t ivLen,
const uint8_t *
a,
size_t aLen,
const uint8_t *
c,
1685 uint8_t *
p,
size_t length,
const uint8_t *
t,
size_t tLen)
1689 uint8_t authTag[16];
1700 if(tLen < 4 || tLen > 16)
1705 authTag, CRYP_CR_ALGODIR);
1708 for(
mask = 0, i = 0; i < tLen; i++)
1710 mask |= authTag[i] ^
t[i];
1718 #if (CCM_SUPPORT == ENABLED && AES_SUPPORT == ENABLED)
1734 size_t aLen,
const uint8_t *input, uint8_t *output,
size_t length,
1735 uint8_t *
t, uint32_t mode)
1741 #if !defined (CRYP_VER_2_2)
1752 temp = CRYP->CR & ~CRYP_CR_ALGOMODE;
1753 CRYP->CR = temp | CRYP_CR_ALGOMODE_AES_CCM;
1756 temp = CRYP->CR & ~CRYP_CR_GCM_CCMPH;
1763 qLen = (b0[0] & 0x07) + 1;
1767 osMemset(buffer + 16 - qLen, 0, qLen);
1770 buffer[0] = (uint8_t) (qLen - 1);
1776 CRYP->IV0RR =
LOAD32BE(buffer + 4);
1777 CRYP->IV1LR =
LOAD32BE(buffer + 8);
1778 CRYP->IV1RR =
LOAD32BE(buffer + 12);
1781 CRYP->CR |= CRYP_CR_CRYPEN;
1783 #if !defined (CRYP_VER_2_2)
1785 if(HAL_GetREVID() < REV_ID_B)
1805 while((CRYP->CR & CRYP_CR_CRYPEN) != 0)
1810 temp = CRYP->CR & ~CRYP_CR_GCM_CCMPH;
1814 CRYP->CR |= CRYP_CR_FFLUSH;
1816 CRYP->CR |= CRYP_CR_CRYPEN;
1832 n =
MIN(aLen, 16 - 2);
1846 n =
MIN(aLen, 16 - 6);
1852 while((CRYP->SR & CRYP_SR_IFNF) == 0)
1857 CRYP->DIN = __UNALIGNED_UINT32_READ(buffer);
1858 CRYP->DIN = __UNALIGNED_UINT32_READ(buffer + 4);
1859 CRYP->DIN = __UNALIGNED_UINT32_READ(buffer + 8);
1860 CRYP->DIN = __UNALIGNED_UINT32_READ(buffer + 12);
1871 while((CRYP->SR & CRYP_SR_IFNF) == 0)
1876 CRYP->DIN = __UNALIGNED_UINT32_READ(
a);
1877 CRYP->DIN = __UNALIGNED_UINT32_READ(
a + 4);
1878 CRYP->DIN = __UNALIGNED_UINT32_READ(
a + 8);
1879 CRYP->DIN = __UNALIGNED_UINT32_READ(
a + 12);
1895 while((CRYP->SR & CRYP_SR_IFNF) == 0)
1900 CRYP->DIN = __UNALIGNED_UINT32_READ(buffer);
1901 CRYP->DIN = __UNALIGNED_UINT32_READ(buffer + 4);
1902 CRYP->DIN = __UNALIGNED_UINT32_READ(buffer + 8);
1903 CRYP->DIN = __UNALIGNED_UINT32_READ(buffer + 12);
1908 while((CRYP->SR & CRYP_SR_BUSY) != 0)
1913 CRYP->CR &= ~CRYP_CR_CRYPEN;
1916 temp = CRYP->CR & ~CRYP_CR_GCM_CCMPH;
1920 temp = CRYP->CR & ~CRYP_CR_ALGODIR;
1924 CRYP->CR |= CRYP_CR_CRYPEN;
1930 while((CRYP->SR & CRYP_SR_IFNF) == 0)
1935 CRYP->DIN = __UNALIGNED_UINT32_READ(input);
1936 CRYP->DIN = __UNALIGNED_UINT32_READ(input + 4);
1937 CRYP->DIN = __UNALIGNED_UINT32_READ(input + 8);
1938 CRYP->DIN = __UNALIGNED_UINT32_READ(input + 12);
1941 while((CRYP->SR & CRYP_SR_OFNE) == 0)
1947 __UNALIGNED_UINT32_WRITE(output, temp);
1949 __UNALIGNED_UINT32_WRITE(output + 4, temp);
1951 __UNALIGNED_UINT32_WRITE(output + 8, temp);
1953 __UNALIGNED_UINT32_WRITE(output + 12, temp);
1970 #if !defined (CRYP_VER_2_2)
1972 if(HAL_GetREVID() < REV_ID_B)
1975 if((mode & CRYP_CR_ALGODIR) != 0)
1978 while((CRYP->SR & CRYP_SR_BUSY) != 0)
1983 y[0] = CRYP->CSGCMCCM0R;
1984 y[1] = CRYP->CSGCMCCM1R;
1985 y[2] = CRYP->CSGCMCCM2R;
1986 y[3] = CRYP->CSGCMCCM3R;
1993 temp = CRYP->CR & ~CRYP_CR_NPBLB;
1998 while((CRYP->SR & CRYP_SR_IFNF) == 0)
2003 CRYP->DIN = __UNALIGNED_UINT32_READ(buffer);
2004 CRYP->DIN = __UNALIGNED_UINT32_READ(buffer + 4);
2005 CRYP->DIN = __UNALIGNED_UINT32_READ(buffer + 8);
2006 CRYP->DIN = __UNALIGNED_UINT32_READ(buffer + 12);
2009 while((CRYP->SR & CRYP_SR_OFNE) == 0)
2015 __UNALIGNED_UINT32_WRITE(buffer, temp);
2017 __UNALIGNED_UINT32_WRITE(buffer + 4, temp);
2019 __UNALIGNED_UINT32_WRITE(buffer + 8, temp);
2021 __UNALIGNED_UINT32_WRITE(buffer + 12, temp);
2027 #if !defined (CRYP_VER_2_2)
2029 if(HAL_GetREVID() < REV_ID_B)
2032 if((mode & CRYP_CR_ALGODIR) != 0)
2038 while((CRYP->SR & CRYP_SR_BUSY) != 0)
2043 CRYP->CR &= ~CRYP_CR_ALGODIR;
2046 CRYP->CSGCMCCM0R = y[0];
2047 CRYP->CSGCMCCM1R = y[1];
2048 CRYP->CSGCMCCM2R = y[2];
2049 CRYP->CSGCMCCM3R = y[3];
2052 while((CRYP->SR & CRYP_SR_IFNF) == 0)
2057 CRYP->DIN = __UNALIGNED_UINT32_READ(buffer);
2058 CRYP->DIN = __UNALIGNED_UINT32_READ(buffer + 4);
2059 CRYP->DIN = __UNALIGNED_UINT32_READ(buffer + 8);
2060 CRYP->DIN = __UNALIGNED_UINT32_READ(buffer + 12);
2063 while((CRYP->SR & CRYP_SR_OFNE) == 0)
2079 while((CRYP->SR & CRYP_SR_BUSY) != 0)
2085 temp = CRYP->CR & ~(CRYP_CR_GCM_CCMPH | CRYP_CR_ALGODIR);
2090 osMemset(buffer + 16 - qLen, 0, qLen);
2093 buffer[0] = (uint8_t) (qLen - 1);
2095 #if !defined (CRYP_VER_2_2)
2097 if(HAL_GetREVID() < REV_ID_B)
2116 while((CRYP->SR & CRYP_SR_OFNE) == 0)
2123 __UNALIGNED_UINT32_WRITE(
t, temp);
2125 __UNALIGNED_UINT32_WRITE(
t + 4, temp);
2127 __UNALIGNED_UINT32_WRITE(
t + 8, temp);
2129 __UNALIGNED_UINT32_WRITE(
t + 12, temp);
2156 size_t nLen,
const uint8_t *
a,
size_t aLen,
const uint8_t *
p, uint8_t *
c,
2157 size_t length, uint8_t *
t,
size_t tLen)
2161 uint8_t authTag[16];
2205 size_t nLen,
const uint8_t *
a,
size_t aLen,
const uint8_t *
c, uint8_t *
p,
2206 size_t length,
const uint8_t *
t,
size_t tLen)
2212 uint8_t authTag[16];
2232 for(
mask = 0, i = 0; i < tLen; i++)
2234 mask |= authTag[i] ^
t[i];
error_t ccmFormatBlock0(size_t q, const uint8_t *n, size_t nLen, size_t aLen, size_t tLen, uint8_t *b)
Format first block B(0)
Collection of AEAD algorithms.
Block cipher modes of operation.
General definitions for cryptographic algorithms.
@ ERROR_INVALID_KEY_LENGTH
@ ERROR_FAILURE
Generic error code.
@ ERROR_INVALID_PARAMETER
Invalid parameter.
#define osMemset(p, value, length)
#define osMemcpy(dest, src, length)
void osAcquireMutex(OsMutex *mutex)
Acquire ownership of the specified mutex object.
void osReleaseMutex(OsMutex *mutex)
Release ownership of the specified mutex object.
#define CRYP_CR_KEYSIZE_192B
#define CRYP_CR_KEYSIZE_128B
#define CRYP_CR_DATATYPE_8B
#define CRYP_CR_KEYSIZE_256B
#define CRYP_CR_GCM_CCMPH_FINAL
#define CRYP_CR_GCM_CCMPH_INIT
#define CRYP_CR_GCM_CCMPH_PAYLOAD
#define CRYP_CR_GCM_CCMPH_HEADER
OsMutex stm32h7xxCryptoMutex
STM32H7 hardware cryptographic accelerator.
void des3ProcessData(Des3Context *context, uint8_t *iv, const uint8_t *input, uint8_t *output, size_t length, uint32_t mode)
Perform Triple DES encryption or decryption.
void des3DecryptBlock(Des3Context *context, const uint8_t *input, uint8_t *output)
Decrypt a 8-byte block using Triple DES algorithm.
error_t aesInit(AesContext *context, const uint8_t *key, size_t keyLen)
Key expansion.
error_t ccmDecrypt(const CipherAlgo *cipher, void *context, const uint8_t *n, size_t nLen, const uint8_t *a, size_t aLen, const uint8_t *c, uint8_t *p, size_t length, const uint8_t *t, size_t tLen)
Authenticated decryption using CCM.
error_t gcmEncrypt(GcmContext *context, const uint8_t *iv, size_t ivLen, const uint8_t *a, size_t aLen, const uint8_t *p, uint8_t *c, size_t length, uint8_t *t, size_t tLen)
Authenticated encryption using GCM.
void aesLoadKey(AesContext *context)
Load AES key.
void desDecryptBlock(DesContext *context, const uint8_t *input, uint8_t *output)
Decrypt a 8-byte block using DES algorithm.
error_t ccmEncrypt(const CipherAlgo *cipher, void *context, const uint8_t *n, size_t nLen, const uint8_t *a, size_t aLen, const uint8_t *p, uint8_t *c, size_t length, uint8_t *t, size_t tLen)
Authenticated encryption using CCM.
error_t ctrEncrypt(const CipherAlgo *cipher, void *context, uint_t m, uint8_t *t, const uint8_t *p, uint8_t *c, size_t length)
CTR encryption.
void aesProcessData(AesContext *context, uint8_t *iv, const uint8_t *input, uint8_t *output, size_t length, uint32_t mode)
Perform AES encryption or decryption.
void gcmProcessData(AesContext *context, const uint8_t *iv, const uint8_t *a, size_t aLen, const uint8_t *input, uint8_t *output, size_t length, uint8_t *t, uint32_t mode)
Perform AES-GCM encryption or decryption.
error_t cbcEncrypt(const CipherAlgo *cipher, void *context, uint8_t *iv, const uint8_t *p, uint8_t *c, size_t length)
CBC encryption.
error_t des3Init(Des3Context *context, const uint8_t *key, size_t keyLen)
Initialize a Triple DES context using the supplied key.
void des3EncryptBlock(Des3Context *context, const uint8_t *input, uint8_t *output)
Encrypt a 8-byte block using Triple DES algorithm.
error_t crypInit(void)
CRYP module initialization.
error_t cbcDecrypt(const CipherAlgo *cipher, void *context, uint8_t *iv, const uint8_t *c, uint8_t *p, size_t length)
CBC decryption.
void aesDecryptBlock(AesContext *context, const uint8_t *input, uint8_t *output)
Decrypt a 16-byte block using AES algorithm.
void aesEncryptBlock(AesContext *context, const uint8_t *input, uint8_t *output)
Encrypt a 16-byte block using AES algorithm.
error_t gcmDecrypt(GcmContext *context, const uint8_t *iv, size_t ivLen, const uint8_t *a, size_t aLen, const uint8_t *c, uint8_t *p, size_t length, const uint8_t *t, size_t tLen)
Authenticated decryption using GCM.
void desEncryptBlock(DesContext *context, const uint8_t *input, uint8_t *output)
Encrypt a 8-byte block using DES algorithm.
error_t ecbEncrypt(const CipherAlgo *cipher, void *context, const uint8_t *p, uint8_t *c, size_t length)
ECB encryption.
void desProcessData(DesContext *context, uint8_t *iv, const uint8_t *input, uint8_t *output, size_t length, uint32_t mode)
Perform DES encryption or decryption.
error_t gcmInit(GcmContext *context, const CipherAlgo *cipherAlgo, void *cipherContext)
Initialize GCM context.
void ccmProcessData(AesContext *context, const uint8_t *b0, const uint8_t *a, size_t aLen, const uint8_t *input, uint8_t *output, size_t length, uint8_t *t, uint32_t mode)
Perform AES-CCM encryption or decryption.
error_t desInit(DesContext *context, const uint8_t *key, size_t keyLen)
Initialize a DES context using the supplied key.
error_t ecbDecrypt(const CipherAlgo *cipher, void *context, const uint8_t *c, uint8_t *p, size_t length)
ECB decryption.
STM32H7 cipher hardware accelerator.
Common interface for encryption algorithms.
CipherAlgoEncryptBlock encryptBlock
CipherAlgoDecryptBlock decryptBlock
Triple DES algorithm context.
const CipherAlgo * cipherAlgo
Cipher algorithm.
void * cipherContext
Cipher algorithm context.