32 #define TRACE_LEVEL CRYPTO_TRACE_LEVEL
35 #include "stm32h5xx.h"
36 #include "stm32h5xx_hal.h"
46 #if (STM32H5XX_CRYPTO_CIPHER_SUPPORT == ENABLED && AES_SUPPORT == ENABLED)
57 __HAL_RCC_AES_CLK_ENABLE();
74 temp = AES->CR & ~AES_CR_KEYSIZE;
83 AES->KEYR3 = context->
ek[0];
84 AES->KEYR2 = context->
ek[1];
85 AES->KEYR1 = context->
ek[2];
86 AES->KEYR0 = context->
ek[3];
94 AES->KEYR7 = context->
ek[0];
95 AES->KEYR6 = context->
ek[1];
96 AES->KEYR5 = context->
ek[2];
97 AES->KEYR4 = context->
ek[3];
98 AES->KEYR3 = context->
ek[4];
99 AES->KEYR2 = context->
ek[5];
100 AES->KEYR1 = context->
ek[6];
101 AES->KEYR0 = context->
ek[7];
117 uint8_t *output,
size_t length, uint32_t mode)
129 AES->ICR = AES_ICR_CCF;
138 temp = AES->CR & ~AES_CR_CHMOD;
142 AES->CR |= AES_CR_EN;
145 while((AES->SR & AES_SR_CCF) == 0)
150 AES->ICR = AES_ICR_CCF;
154 temp = AES->CR & ~(AES_CR_CHMOD | AES_CR_MODE);
155 AES->CR = temp | mode;
158 temp = AES->CR & ~AES_CR_DATATYPE;
172 AES->CR |= AES_CR_EN;
178 AES->DINR = __UNALIGNED_UINT32_READ(input);
179 AES->DINR = __UNALIGNED_UINT32_READ(input + 4);
180 AES->DINR = __UNALIGNED_UINT32_READ(input + 8);
181 AES->DINR = __UNALIGNED_UINT32_READ(input + 12);
184 while((AES->SR & AES_SR_CCF) == 0)
190 __UNALIGNED_UINT32_WRITE(output, temp);
192 __UNALIGNED_UINT32_WRITE(output + 4, temp);
194 __UNALIGNED_UINT32_WRITE(output + 8, temp);
196 __UNALIGNED_UINT32_WRITE(output + 12, temp);
199 AES->ICR = AES_ICR_CCF;
217 AES->DINR = buffer[0];
218 AES->DINR = buffer[1];
219 AES->DINR = buffer[2];
220 AES->DINR = buffer[3];
223 while((AES->SR & AES_SR_CCF) == 0)
228 buffer[0] = AES->DOUTR;
229 buffer[1] = AES->DOUTR;
230 buffer[2] = AES->DOUTR;
231 buffer[3] = AES->DOUTR;
234 AES->ICR = AES_ICR_CCF;
275 if(context == NULL || key == NULL)
284 else if(keyLen == 32)
299 for(i = 0; i < keyLen; i++)
339 #if (ECB_SUPPORT == ENABLED)
352 const uint8_t *
p, uint8_t *
c,
size_t length)
416 const uint8_t *
c, uint8_t *
p,
size_t length)
469 #if (CBC_SUPPORT == ENABLED)
483 uint8_t *
iv,
const uint8_t *
p, uint8_t *
c,
size_t length)
560 uint8_t *
iv,
const uint8_t *
c, uint8_t *
p,
size_t length)
628 #if (CTR_SUPPORT == ENABLED)
643 uint8_t *
t,
const uint8_t *
p, uint8_t *
c,
size_t length)
698 for(i = 0; i <
n; i++)
704 for(temp = 1, i = 1; i <=
m; i++)
730 #if (GCM_SUPPORT == ENABLED)
746 const uint8_t *
a,
size_t aLen,
const uint8_t *input, uint8_t *output,
747 size_t length, uint8_t *
t, uint32_t mode)
762 AES->ICR = AES_ICR_CCF;
766 temp = AES->CR & ~AES_CR_CHMOD;
770 temp = AES->CR & ~AES_CR_DATATYPE;
775 temp = AES->CR & ~AES_CR_GCMPH;
779 temp = AES->CR & ~AES_CR_MODE;
780 AES->CR = temp | mode;
793 AES->CR |= AES_CR_EN;
797 while((AES->SR & AES_SR_CCF) == 0)
803 AES->ICR = AES_ICR_CCF;
806 temp = AES->CR & ~AES_CR_DATATYPE;
811 temp = AES->CR & ~AES_CR_GCMPH;
815 AES->CR |= AES_CR_EN;
821 AES->DINR = __UNALIGNED_UINT32_READ(
a);
822 AES->DINR = __UNALIGNED_UINT32_READ(
a + 4);
823 AES->DINR = __UNALIGNED_UINT32_READ(
a + 8);
824 AES->DINR = __UNALIGNED_UINT32_READ(
a + 12);
827 while((AES->SR & AES_SR_CCF) == 0)
832 AES->ICR = AES_ICR_CCF;
847 AES->DINR = buffer[0];
848 AES->DINR = buffer[1];
849 AES->DINR = buffer[2];
850 AES->DINR = buffer[3];
853 while((AES->SR & AES_SR_CCF) == 0)
858 AES->ICR = AES_ICR_CCF;
863 temp = AES->CR & ~AES_CR_GCMPH;
870 AES->DINR = __UNALIGNED_UINT32_READ(input);
871 AES->DINR = __UNALIGNED_UINT32_READ(input + 4);
872 AES->DINR = __UNALIGNED_UINT32_READ(input + 8);
873 AES->DINR = __UNALIGNED_UINT32_READ(input + 12);
876 while((AES->SR & AES_SR_CCF) == 0)
882 __UNALIGNED_UINT32_WRITE(output, temp);
884 __UNALIGNED_UINT32_WRITE(output + 4, temp);
886 __UNALIGNED_UINT32_WRITE(output + 8, temp);
888 __UNALIGNED_UINT32_WRITE(output + 12, temp);
891 AES->ICR = AES_ICR_CCF;
908 temp = AES->CR & ~AES_CR_NPBLB;
912 AES->DINR = buffer[0];
913 AES->DINR = buffer[1];
914 AES->DINR = buffer[2];
915 AES->DINR = buffer[3];
918 while((AES->SR & AES_SR_CCF) == 0)
923 buffer[0] = AES->DOUTR;
924 buffer[1] = AES->DOUTR;
925 buffer[2] = AES->DOUTR;
926 buffer[3] = AES->DOUTR;
929 AES->ICR = AES_ICR_CCF;
938 temp = AES->CR & ~AES_CR_GCMPH;
943 temp = AES->CR & ~AES_CR_MODE;
957 while((AES->SR & AES_SR_CCF) == 0)
964 __UNALIGNED_UINT32_WRITE(
t, temp);
966 __UNALIGNED_UINT32_WRITE(
t + 4, temp);
968 __UNALIGNED_UINT32_WRITE(
t + 8, temp);
970 __UNALIGNED_UINT32_WRITE(
t + 12, temp);
973 AES->ICR = AES_ICR_CCF;
995 if(context == NULL || cipherContext == NULL)
1027 size_t ivLen,
const uint8_t *
a,
size_t aLen,
const uint8_t *
p,
1028 uint8_t *
c,
size_t length, uint8_t *
t,
size_t tLen)
1030 uint8_t authTag[16];
1041 if(tLen < 4 || tLen > 16)
1072 size_t ivLen,
const uint8_t *
a,
size_t aLen,
const uint8_t *
c,
1073 uint8_t *
p,
size_t length,
const uint8_t *
t,
size_t tLen)
1077 uint8_t authTag[16];
1088 if(tLen < 4 || tLen > 16)
1096 for(
mask = 0, i = 0; i < tLen; i++)
1098 mask |= authTag[i] ^
t[i];
1106 #if (CCM_SUPPORT == ENABLED)
1122 size_t aLen,
const uint8_t *input, uint8_t *output,
size_t length,
1123 uint8_t *
t, uint32_t mode)
1137 AES->ICR = AES_ICR_CCF;
1141 temp = AES->CR & ~AES_CR_CHMOD;
1145 temp = AES->CR & ~AES_CR_DATATYPE;
1150 temp = AES->CR & ~AES_CR_GCMPH;
1156 temp = AES->CR & ~AES_CR_MODE;
1157 AES->CR = temp | mode;
1170 AES->CR |= AES_CR_EN;
1174 while((AES->SR & AES_SR_CCF) == 0)
1180 AES->ICR = AES_ICR_CCF;
1184 temp = AES->CR & ~AES_CR_GCMPH;
1188 AES->CR |= AES_CR_EN;
1204 n =
MIN(aLen, 16 - 2);
1218 n =
MIN(aLen, 16 - 6);
1230 while((AES->SR & AES_SR_CCF) == 0)
1235 AES->ICR = AES_ICR_CCF;
1246 AES->DINR = __UNALIGNED_UINT32_READ(
a);
1247 AES->DINR = __UNALIGNED_UINT32_READ(
a + 4);
1248 AES->DINR = __UNALIGNED_UINT32_READ(
a + 8);
1249 AES->DINR = __UNALIGNED_UINT32_READ(
a + 12);
1252 while((AES->SR & AES_SR_CCF) == 0)
1257 AES->ICR = AES_ICR_CCF;
1273 AES->DINR = __UNALIGNED_UINT32_READ(buffer);
1274 AES->DINR = __UNALIGNED_UINT32_READ(buffer + 4);
1275 AES->DINR = __UNALIGNED_UINT32_READ(buffer + 8);
1276 AES->DINR = __UNALIGNED_UINT32_READ(buffer + 12);
1279 while((AES->SR & AES_SR_CCF) == 0)
1284 AES->ICR = AES_ICR_CCF;
1289 temp = AES->CR & ~AES_CR_GCMPH;
1296 AES->DINR = __UNALIGNED_UINT32_READ(input);
1297 AES->DINR = __UNALIGNED_UINT32_READ(input + 4);
1298 AES->DINR = __UNALIGNED_UINT32_READ(input + 8);
1299 AES->DINR = __UNALIGNED_UINT32_READ(input + 12);
1302 while((AES->SR & AES_SR_CCF) == 0)
1308 __UNALIGNED_UINT32_WRITE(output, temp);
1310 __UNALIGNED_UINT32_WRITE(output + 4, temp);
1312 __UNALIGNED_UINT32_WRITE(output + 8, temp);
1314 __UNALIGNED_UINT32_WRITE(output + 12, temp);
1317 AES->ICR = AES_ICR_CCF;
1338 temp = AES->CR & ~AES_CR_NPBLB;
1343 AES->DINR = __UNALIGNED_UINT32_READ(buffer);
1344 AES->DINR = __UNALIGNED_UINT32_READ(buffer + 4);
1345 AES->DINR = __UNALIGNED_UINT32_READ(buffer + 8);
1346 AES->DINR = __UNALIGNED_UINT32_READ(buffer + 12);
1349 while((AES->SR & AES_SR_CCF) == 0)
1355 __UNALIGNED_UINT32_WRITE(buffer, temp);
1357 __UNALIGNED_UINT32_WRITE(buffer + 4, temp);
1359 __UNALIGNED_UINT32_WRITE(buffer + 8, temp);
1361 __UNALIGNED_UINT32_WRITE(buffer + 12, temp);
1364 AES->ICR = AES_ICR_CCF;
1373 temp = AES->CR & ~AES_CR_GCMPH;
1378 while((AES->SR & AES_SR_CCF) == 0)
1385 __UNALIGNED_UINT32_WRITE(
t, temp);
1387 __UNALIGNED_UINT32_WRITE(
t + 4, temp);
1389 __UNALIGNED_UINT32_WRITE(
t + 8, temp);
1391 __UNALIGNED_UINT32_WRITE(
t + 12, temp);
1394 AES->ICR = AES_ICR_CCF;
1421 size_t nLen,
const uint8_t *
a,
size_t aLen,
const uint8_t *
p, uint8_t *
c,
1422 size_t length, uint8_t *
t,
size_t tLen)
1426 uint8_t authTag[16];
1471 size_t nLen,
const uint8_t *
a,
size_t aLen,
const uint8_t *
c, uint8_t *
p,
1472 size_t length,
const uint8_t *
t,
size_t tLen)
1478 uint8_t authTag[16];
1499 for(
mask = 0, i = 0; i < tLen; i++)
1501 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 AES_CR_MODE_ENCRYPTION
#define AES_CR_DATATYPE_8B
#define AES_CR_DATATYPE_32B
#define AES_CR_GCMPH_PAYLOAD
#define AES_CR_GCMPH_INIT
#define AES_CR_GCMPH_FINAL
#define AES_CR_GCMPH_HEADER
#define AES_CR_MODE_DECRYPTION
#define AES_CR_KEYSIZE_128B
#define AES_CR_MODE_KEY_DERIVATION
#define AES_CR_KEYSIZE_256B
#define AES_CR_CHMOD_GCM_GMAC
OsMutex stm32h5xxCryptoMutex
STM32H5 hardware cryptographic accelerator.
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.
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 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.
error_t ecbEncrypt(const CipherAlgo *cipher, void *context, const uint8_t *p, uint8_t *c, size_t length)
ECB encryption.
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 ecbDecrypt(const CipherAlgo *cipher, void *context, const uint8_t *c, uint8_t *p, size_t length)
ECB decryption.
STM32H5 cipher hardware accelerator.
Common interface for encryption algorithms.
CipherAlgoEncryptBlock encryptBlock
CipherAlgoDecryptBlock decryptBlock
const CipherAlgo * cipherAlgo
Cipher algorithm.
void * cipherContext
Cipher algorithm context.