32 #define TRACE_LEVEL CRYPTO_TRACE_LEVEL
35 #include "stm32f4xx.h"
36 #include "stm32f4xx_hal.h"
46 #if (STM32F4XX_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 && defined(CRYP_CR_ALGOMODE_AES_GCM))
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)
1299 temp = CRYP->CR & ~CRYP_CR_ALGOMODE;
1300 CRYP->CR = temp | CRYP_CR_ALGOMODE_AES_GCM;
1303 temp = CRYP->CR & ~CRYP_CR_GCM_CCMPH;
1316 CRYP->CR |= CRYP_CR_CRYPEN;
1320 while((CRYP->CR & CRYP_CR_CRYPEN) != 0)
1325 temp = CRYP->CR & ~CRYP_CR_GCM_CCMPH;
1329 CRYP->CR |= CRYP_CR_FFLUSH;
1331 CRYP->CR |= CRYP_CR_CRYPEN;
1337 while((CRYP->SR & CRYP_SR_IFNF) == 0)
1342 CRYP->DIN = __UNALIGNED_UINT32_READ(
a);
1343 CRYP->DIN = __UNALIGNED_UINT32_READ(
a + 4);
1344 CRYP->DIN = __UNALIGNED_UINT32_READ(
a + 8);
1345 CRYP->DIN = __UNALIGNED_UINT32_READ(
a + 12);
1359 while((CRYP->SR & CRYP_SR_IFNF) == 0)
1364 CRYP->DIN = buffer[0];
1365 CRYP->DIN = buffer[1];
1366 CRYP->DIN = buffer[2];
1367 CRYP->DIN = buffer[3];
1372 while((CRYP->SR & CRYP_SR_BUSY) != 0)
1377 CRYP->CR &= ~CRYP_CR_CRYPEN;
1380 temp = CRYP->CR & ~CRYP_CR_GCM_CCMPH;
1384 temp = CRYP->CR & ~CRYP_CR_ALGODIR;
1388 CRYP->CR |= CRYP_CR_CRYPEN;
1394 while((CRYP->SR & CRYP_SR_IFNF) == 0)
1399 CRYP->DIN = __UNALIGNED_UINT32_READ(input);
1400 CRYP->DIN = __UNALIGNED_UINT32_READ(input + 4);
1401 CRYP->DIN = __UNALIGNED_UINT32_READ(input + 8);
1402 CRYP->DIN = __UNALIGNED_UINT32_READ(input + 12);
1405 while((CRYP->SR & CRYP_SR_OFNE) == 0)
1411 __UNALIGNED_UINT32_WRITE(output, temp);
1413 __UNALIGNED_UINT32_WRITE(output + 4, temp);
1415 __UNALIGNED_UINT32_WRITE(output + 8, temp);
1417 __UNALIGNED_UINT32_WRITE(output + 12, temp);
1432 if((mode & CRYP_CR_ALGODIR) == 0)
1435 while((CRYP->SR & CRYP_SR_BUSY) != 0)
1440 h[0] = CRYP->CSGCM0R;
1441 h[1] = CRYP->CSGCM1R;
1442 h[2] = CRYP->CSGCM2R;
1443 h[3] = CRYP->CSGCM3R;
1447 while((CRYP->SR & CRYP_SR_IFNF) == 0)
1452 CRYP->DIN = buffer[0];
1453 CRYP->DIN = buffer[1];
1454 CRYP->DIN = buffer[2];
1455 CRYP->DIN = buffer[3];
1458 while((CRYP->SR & CRYP_SR_OFNE) == 0)
1463 buffer[0] = CRYP->DOUT;
1464 buffer[1] = CRYP->DOUT;
1465 buffer[2] = CRYP->DOUT;
1466 buffer[3] = CRYP->DOUT;
1472 if((mode & CRYP_CR_ALGODIR) == 0)
1478 while((CRYP->SR & CRYP_SR_BUSY) != 0)
1483 CRYP->CR |= CRYP_CR_ALGODIR;
1486 CRYP->CSGCM0R =
h[0];
1487 CRYP->CSGCM1R =
h[1];
1488 CRYP->CSGCM2R =
h[2];
1489 CRYP->CSGCM3R =
h[3];
1492 while((CRYP->SR & CRYP_SR_IFNF) == 0)
1497 CRYP->DIN = buffer[0];
1498 CRYP->DIN = buffer[1];
1499 CRYP->DIN = buffer[2];
1500 CRYP->DIN = buffer[3];
1503 while((CRYP->SR & CRYP_SR_OFNE) == 0)
1508 buffer[0] = CRYP->DOUT;
1509 buffer[1] = CRYP->DOUT;
1510 buffer[2] = CRYP->DOUT;
1511 buffer[3] = CRYP->DOUT;
1517 while((CRYP->SR & CRYP_SR_BUSY) != 0)
1522 temp = CRYP->CR & ~CRYP_CR_GCM_CCMPH;
1536 while((CRYP->SR & CRYP_SR_OFNE) == 0)
1543 __UNALIGNED_UINT32_WRITE(
t, temp);
1545 __UNALIGNED_UINT32_WRITE(
t + 4, temp);
1547 __UNALIGNED_UINT32_WRITE(
t + 8, temp);
1549 __UNALIGNED_UINT32_WRITE(
t + 12, temp);
1568 void *cipherContext)
1571 if(context == NULL || cipherContext == NULL)
1603 size_t ivLen,
const uint8_t *
a,
size_t aLen,
const uint8_t *
p,
1604 uint8_t *
c,
size_t length, uint8_t *
t,
size_t tLen)
1606 uint8_t authTag[16];
1617 if(tLen < 4 || tLen > 16)
1648 size_t ivLen,
const uint8_t *
a,
size_t aLen,
const uint8_t *
c,
1649 uint8_t *
p,
size_t length,
const uint8_t *
t,
size_t tLen)
1653 uint8_t authTag[16];
1664 if(tLen < 4 || tLen > 16)
1669 authTag, CRYP_CR_ALGODIR);
1672 for(
mask = 0, i = 0; i < tLen; i++)
1674 mask |= authTag[i] ^
t[i];
1682 #if (CCM_SUPPORT == ENABLED && AES_SUPPORT == ENABLED && defined(CRYP_CR_ALGOMODE_AES_CCM))
1698 size_t aLen,
const uint8_t *input, uint8_t *output,
size_t length,
1699 uint8_t *
t, uint32_t mode)
1714 temp = CRYP->CR & ~CRYP_CR_ALGOMODE;
1715 CRYP->CR = temp | CRYP_CR_ALGOMODE_AES_CCM;
1718 temp = CRYP->CR & ~CRYP_CR_GCM_CCMPH;
1725 qLen = (b0[0] & 0x07) + 1;
1729 osMemset(buffer + 16 - qLen, 0, qLen);
1732 buffer[0] = (uint8_t) (qLen - 1);
1738 CRYP->IV0RR =
LOAD32BE(buffer + 4);
1739 CRYP->IV1LR =
LOAD32BE(buffer + 8);
1740 CRYP->IV1RR =
LOAD32BE(buffer + 12);
1743 CRYP->CR |= CRYP_CR_CRYPEN;
1746 CRYP->DIN = __UNALIGNED_UINT32_READ(b0);
1747 CRYP->DIN = __UNALIGNED_UINT32_READ(b0 + 4);
1748 CRYP->DIN = __UNALIGNED_UINT32_READ(b0 + 8);
1749 CRYP->DIN = __UNALIGNED_UINT32_READ(b0 + 12);
1753 while((CRYP->CR & CRYP_CR_CRYPEN) != 0)
1758 temp = CRYP->CR & ~CRYP_CR_GCM_CCMPH;
1762 CRYP->CR |= CRYP_CR_FFLUSH;
1764 CRYP->CR |= CRYP_CR_CRYPEN;
1780 n =
MIN(aLen, 16 - 2);
1794 n =
MIN(aLen, 16 - 6);
1800 while((CRYP->SR & CRYP_SR_IFNF) == 0)
1805 CRYP->DIN = __UNALIGNED_UINT32_READ(buffer);
1806 CRYP->DIN = __UNALIGNED_UINT32_READ(buffer + 4);
1807 CRYP->DIN = __UNALIGNED_UINT32_READ(buffer + 8);
1808 CRYP->DIN = __UNALIGNED_UINT32_READ(buffer + 12);
1819 while((CRYP->SR & CRYP_SR_IFNF) == 0)
1824 CRYP->DIN = __UNALIGNED_UINT32_READ(
a);
1825 CRYP->DIN = __UNALIGNED_UINT32_READ(
a + 4);
1826 CRYP->DIN = __UNALIGNED_UINT32_READ(
a + 8);
1827 CRYP->DIN = __UNALIGNED_UINT32_READ(
a + 12);
1843 while((CRYP->SR & CRYP_SR_IFNF) == 0)
1848 CRYP->DIN = __UNALIGNED_UINT32_READ(buffer);
1849 CRYP->DIN = __UNALIGNED_UINT32_READ(buffer + 4);
1850 CRYP->DIN = __UNALIGNED_UINT32_READ(buffer + 8);
1851 CRYP->DIN = __UNALIGNED_UINT32_READ(buffer + 12);
1856 while((CRYP->SR & CRYP_SR_BUSY) != 0)
1861 CRYP->CR &= ~CRYP_CR_CRYPEN;
1864 temp = CRYP->CR & ~CRYP_CR_GCM_CCMPH;
1868 temp = CRYP->CR & ~CRYP_CR_ALGODIR;
1872 CRYP->CR |= CRYP_CR_CRYPEN;
1878 while((CRYP->SR & CRYP_SR_IFNF) == 0)
1883 CRYP->DIN = __UNALIGNED_UINT32_READ(input);
1884 CRYP->DIN = __UNALIGNED_UINT32_READ(input + 4);
1885 CRYP->DIN = __UNALIGNED_UINT32_READ(input + 8);
1886 CRYP->DIN = __UNALIGNED_UINT32_READ(input + 12);
1889 while((CRYP->SR & CRYP_SR_OFNE) == 0)
1895 __UNALIGNED_UINT32_WRITE(output, temp);
1897 __UNALIGNED_UINT32_WRITE(output + 4, temp);
1899 __UNALIGNED_UINT32_WRITE(output + 8, temp);
1901 __UNALIGNED_UINT32_WRITE(output + 12, temp);
1919 if((mode & CRYP_CR_ALGODIR) != 0)
1922 while((CRYP->SR & CRYP_SR_BUSY) != 0)
1927 y[0] = CRYP->CSGCMCCM0R;
1928 y[1] = CRYP->CSGCMCCM1R;
1929 y[2] = CRYP->CSGCMCCM2R;
1930 y[3] = CRYP->CSGCMCCM3R;
1934 while((CRYP->SR & CRYP_SR_IFNF) == 0)
1939 CRYP->DIN = __UNALIGNED_UINT32_READ(buffer);
1940 CRYP->DIN = __UNALIGNED_UINT32_READ(buffer + 4);
1941 CRYP->DIN = __UNALIGNED_UINT32_READ(buffer + 8);
1942 CRYP->DIN = __UNALIGNED_UINT32_READ(buffer + 12);
1945 while((CRYP->SR & CRYP_SR_OFNE) == 0)
1951 __UNALIGNED_UINT32_WRITE(buffer, temp);
1953 __UNALIGNED_UINT32_WRITE(buffer + 4, temp);
1955 __UNALIGNED_UINT32_WRITE(buffer + 8, temp);
1957 __UNALIGNED_UINT32_WRITE(buffer + 12, temp);
1964 if((mode & CRYP_CR_ALGODIR) != 0)
1970 while((CRYP->SR & CRYP_SR_BUSY) != 0)
1975 CRYP->CR &= ~CRYP_CR_ALGODIR;
1978 CRYP->CSGCMCCM0R = y[0];
1979 CRYP->CSGCMCCM1R = y[1];
1980 CRYP->CSGCMCCM2R = y[2];
1981 CRYP->CSGCMCCM3R = y[3];
1984 while((CRYP->SR & CRYP_SR_IFNF) == 0)
1989 CRYP->DIN = __UNALIGNED_UINT32_READ(buffer);
1990 CRYP->DIN = __UNALIGNED_UINT32_READ(buffer + 4);
1991 CRYP->DIN = __UNALIGNED_UINT32_READ(buffer + 8);
1992 CRYP->DIN = __UNALIGNED_UINT32_READ(buffer + 12);
1995 while((CRYP->SR & CRYP_SR_OFNE) == 0)
2009 while((CRYP->SR & CRYP_SR_BUSY) != 0)
2015 temp = CRYP->CR & ~(CRYP_CR_GCM_CCMPH | CRYP_CR_ALGODIR);
2020 osMemset(buffer + 16 - qLen, 0, qLen);
2023 buffer[0] = (uint8_t) (qLen - 1);
2026 CRYP->DIN = __UNALIGNED_UINT32_READ(buffer);
2027 CRYP->DIN = __UNALIGNED_UINT32_READ(buffer + 4);
2028 CRYP->DIN = __UNALIGNED_UINT32_READ(buffer + 8);
2029 CRYP->DIN = __UNALIGNED_UINT32_READ(buffer + 12);
2032 while((CRYP->SR & CRYP_SR_OFNE) == 0)
2039 __UNALIGNED_UINT32_WRITE(
t, temp);
2041 __UNALIGNED_UINT32_WRITE(
t + 4, temp);
2043 __UNALIGNED_UINT32_WRITE(
t + 8, temp);
2045 __UNALIGNED_UINT32_WRITE(
t + 12, temp);
2072 size_t nLen,
const uint8_t *
a,
size_t aLen,
const uint8_t *
p, uint8_t *
c,
2073 size_t length, uint8_t *
t,
size_t tLen)
2077 uint8_t authTag[16];
2121 size_t nLen,
const uint8_t *
a,
size_t aLen,
const uint8_t *
c, uint8_t *
p,
2122 size_t length,
const uint8_t *
t,
size_t tLen)
2128 uint8_t authTag[16];
2148 for(
mask = 0, i = 0; i < tLen; i++)
2150 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)
__weak_func 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.
__weak_func 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.
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.
__weak_func error_t gcmInit(GcmContext *context, const CipherAlgo *cipherAlgo, void *cipherContext)
Initialize GCM context.
__weak_func 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.
__weak_func 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 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.
#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
OsMutex stm32f4xxCryptoMutex
STM32F4 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.
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 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.
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.
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 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.
STM32F4 cipher hardware accelerator.
#define CRYP_CR_GCM_CCMPH_FINAL
#define CRYP_CR_GCM_CCMPH_INIT
#define CRYP_CR_GCM_CCMPH_PAYLOAD
#define CRYP_CR_GCM_CCMPH_HEADER
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.
Common interface for encryption algorithms.
CipherAlgoEncryptBlock encryptBlock
CipherAlgoDecryptBlock decryptBlock
Triple DES algorithm context.
const CipherAlgo * cipherAlgo
Cipher algorithm.
void * cipherContext
Cipher algorithm context.