32 #define TRACE_LEVEL CRYPTO_TRACE_LEVEL
35 #include "stm32wlxx.h"
36 #include "stm32wlxx_hal.h"
46 #if (STM32WLXX_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)
125 AES->CR = AES_CR_CCFC;
134 temp = AES->CR & ~AES_CR_CHMOD;
138 AES->CR |= AES_CR_EN;
141 while((AES->SR & AES_SR_CCF) == 0)
146 AES->CR |= AES_CR_CCFC;
150 temp = AES->CR & ~(AES_CR_CHMOD | AES_CR_MODE);
151 AES->CR = temp | mode;
154 temp = AES->CR & ~AES_CR_DATATYPE;
168 AES->CR |= AES_CR_EN;
174 AES->DINR = __UNALIGNED_UINT32_READ(input);
175 AES->DINR = __UNALIGNED_UINT32_READ(input + 4);
176 AES->DINR = __UNALIGNED_UINT32_READ(input + 8);
177 AES->DINR = __UNALIGNED_UINT32_READ(input + 12);
180 while((AES->SR & AES_SR_CCF) == 0)
186 __UNALIGNED_UINT32_WRITE(output, temp);
188 __UNALIGNED_UINT32_WRITE(output + 4, temp);
190 __UNALIGNED_UINT32_WRITE(output + 8, temp);
192 __UNALIGNED_UINT32_WRITE(output + 12, temp);
195 AES->CR |= AES_CR_CCFC;
213 AES->DINR = buffer[0];
214 AES->DINR = buffer[1];
215 AES->DINR = buffer[2];
216 AES->DINR = buffer[3];
219 while((AES->SR & AES_SR_CCF) == 0)
224 buffer[0] = AES->DOUTR;
225 buffer[1] = AES->DOUTR;
226 buffer[2] = AES->DOUTR;
227 buffer[3] = AES->DOUTR;
230 AES->CR |= AES_CR_CCFC;
271 if(context == NULL || key == NULL)
280 else if(keyLen == 32)
295 for(i = 0; i < keyLen; i++)
335 #if (ECB_SUPPORT == ENABLED)
348 const uint8_t *
p, uint8_t *
c,
size_t length)
412 const uint8_t *
c, uint8_t *
p,
size_t length)
465 #if (CBC_SUPPORT == ENABLED)
479 uint8_t *
iv,
const uint8_t *
p, uint8_t *
c,
size_t length)
556 uint8_t *
iv,
const uint8_t *
c, uint8_t *
p,
size_t length)
624 #if (CTR_SUPPORT == ENABLED)
639 uint8_t *
t,
const uint8_t *
p, uint8_t *
c,
size_t length)
694 for(i = 0; i <
n; i++)
700 for(temp = 1, i = 1; i <=
m; i++)
726 #if (GCM_SUPPORT == ENABLED)
742 const uint8_t *
a,
size_t aLen,
const uint8_t *input, uint8_t *output,
743 size_t length, uint8_t *
t, uint32_t mode)
754 AES->CR = AES_CR_CCFC;
758 temp = AES->CR & ~AES_CR_CHMOD;
762 temp = AES->CR & ~AES_CR_DATATYPE;
767 temp = AES->CR & ~AES_CR_GCMPH;
771 temp = AES->CR & ~AES_CR_MODE;
772 AES->CR = temp | mode;
785 AES->CR |= AES_CR_EN;
789 while((AES->SR & AES_SR_CCF) == 0)
795 AES->CR |= AES_CR_CCFC;
798 temp = AES->CR & ~AES_CR_DATATYPE;
803 temp = AES->CR & ~AES_CR_GCMPH;
807 AES->CR |= AES_CR_EN;
813 AES->DINR = __UNALIGNED_UINT32_READ(
a);
814 AES->DINR = __UNALIGNED_UINT32_READ(
a + 4);
815 AES->DINR = __UNALIGNED_UINT32_READ(
a + 8);
816 AES->DINR = __UNALIGNED_UINT32_READ(
a + 12);
819 while((AES->SR & AES_SR_CCF) == 0)
824 AES->CR |= AES_CR_CCFC;
839 AES->DINR = buffer[0];
840 AES->DINR = buffer[1];
841 AES->DINR = buffer[2];
842 AES->DINR = buffer[3];
845 while((AES->SR & AES_SR_CCF) == 0)
850 AES->CR |= AES_CR_CCFC;
855 temp = AES->CR & ~AES_CR_GCMPH;
862 AES->DINR = __UNALIGNED_UINT32_READ(input);
863 AES->DINR = __UNALIGNED_UINT32_READ(input + 4);
864 AES->DINR = __UNALIGNED_UINT32_READ(input + 8);
865 AES->DINR = __UNALIGNED_UINT32_READ(input + 12);
868 while((AES->SR & AES_SR_CCF) == 0)
874 __UNALIGNED_UINT32_WRITE(output, temp);
876 __UNALIGNED_UINT32_WRITE(output + 4, temp);
878 __UNALIGNED_UINT32_WRITE(output + 8, temp);
880 __UNALIGNED_UINT32_WRITE(output + 12, temp);
883 AES->CR |= AES_CR_CCFC;
900 temp = AES->CR & ~AES_CR_NPBLB;
904 AES->DINR = buffer[0];
905 AES->DINR = buffer[1];
906 AES->DINR = buffer[2];
907 AES->DINR = buffer[3];
910 while((AES->SR & AES_SR_CCF) == 0)
915 buffer[0] = AES->DOUTR;
916 buffer[1] = AES->DOUTR;
917 buffer[2] = AES->DOUTR;
918 buffer[3] = AES->DOUTR;
921 AES->CR |= AES_CR_CCFC;
930 temp = AES->CR & ~AES_CR_GCMPH;
935 temp = AES->CR & ~AES_CR_MODE;
949 while((AES->SR & AES_SR_CCF) == 0)
956 __UNALIGNED_UINT32_WRITE(
t, temp);
958 __UNALIGNED_UINT32_WRITE(
t + 4, temp);
960 __UNALIGNED_UINT32_WRITE(
t + 8, temp);
962 __UNALIGNED_UINT32_WRITE(
t + 12, temp);
965 AES->CR |= AES_CR_CCFC;
987 if(context == NULL || cipherContext == NULL)
1019 size_t ivLen,
const uint8_t *
a,
size_t aLen,
const uint8_t *
p,
1020 uint8_t *
c,
size_t length, uint8_t *
t,
size_t tLen)
1022 uint8_t authTag[16];
1033 if(tLen < 4 || tLen > 16)
1064 size_t ivLen,
const uint8_t *
a,
size_t aLen,
const uint8_t *
c,
1065 uint8_t *
p,
size_t length,
const uint8_t *
t,
size_t tLen)
1069 uint8_t authTag[16];
1080 if(tLen < 4 || tLen > 16)
1088 for(
mask = 0, i = 0; i < tLen; i++)
1090 mask |= authTag[i] ^
t[i];
1098 #if (CCM_SUPPORT == ENABLED)
1114 size_t aLen,
const uint8_t *input, uint8_t *output,
size_t length,
1115 uint8_t *
t, uint32_t mode)
1125 AES->CR = AES_CR_CCFC;
1129 temp = AES->CR & ~AES_CR_CHMOD;
1133 temp = AES->CR & ~AES_CR_DATATYPE;
1138 temp = AES->CR & ~AES_CR_GCMPH;
1144 temp = AES->CR & ~AES_CR_MODE;
1145 AES->CR = temp | mode;
1158 AES->CR |= AES_CR_EN;
1162 while((AES->SR & AES_SR_CCF) == 0)
1167 AES->CR |= AES_CR_CCFC;
1171 temp = AES->CR & ~AES_CR_GCMPH;
1175 AES->CR |= AES_CR_EN;
1191 n =
MIN(aLen, 16 - 2);
1205 n =
MIN(aLen, 16 - 6);
1217 while((AES->SR & AES_SR_CCF) == 0)
1222 AES->CR |= AES_CR_CCFC;
1233 AES->DINR = __UNALIGNED_UINT32_READ(
a);
1234 AES->DINR = __UNALIGNED_UINT32_READ(
a + 4);
1235 AES->DINR = __UNALIGNED_UINT32_READ(
a + 8);
1236 AES->DINR = __UNALIGNED_UINT32_READ(
a + 12);
1239 while((AES->SR & AES_SR_CCF) == 0)
1244 AES->CR |= AES_CR_CCFC;
1260 AES->DINR = __UNALIGNED_UINT32_READ(buffer);
1261 AES->DINR = __UNALIGNED_UINT32_READ(buffer + 4);
1262 AES->DINR = __UNALIGNED_UINT32_READ(buffer + 8);
1263 AES->DINR = __UNALIGNED_UINT32_READ(buffer + 12);
1266 while((AES->SR & AES_SR_CCF) == 0)
1271 AES->CR |= AES_CR_CCFC;
1276 temp = AES->CR & ~AES_CR_GCMPH;
1283 AES->DINR = __UNALIGNED_UINT32_READ(input);
1284 AES->DINR = __UNALIGNED_UINT32_READ(input + 4);
1285 AES->DINR = __UNALIGNED_UINT32_READ(input + 8);
1286 AES->DINR = __UNALIGNED_UINT32_READ(input + 12);
1289 while((AES->SR & AES_SR_CCF) == 0)
1295 __UNALIGNED_UINT32_WRITE(output, temp);
1297 __UNALIGNED_UINT32_WRITE(output + 4, temp);
1299 __UNALIGNED_UINT32_WRITE(output + 8, temp);
1301 __UNALIGNED_UINT32_WRITE(output + 12, temp);
1304 AES->CR |= AES_CR_CCFC;
1325 temp = AES->CR & ~AES_CR_NPBLB;
1330 AES->DINR = __UNALIGNED_UINT32_READ(buffer);
1331 AES->DINR = __UNALIGNED_UINT32_READ(buffer + 4);
1332 AES->DINR = __UNALIGNED_UINT32_READ(buffer + 8);
1333 AES->DINR = __UNALIGNED_UINT32_READ(buffer + 12);
1336 while((AES->SR & AES_SR_CCF) == 0)
1342 __UNALIGNED_UINT32_WRITE(buffer, temp);
1344 __UNALIGNED_UINT32_WRITE(buffer + 4, temp);
1346 __UNALIGNED_UINT32_WRITE(buffer + 8, temp);
1348 __UNALIGNED_UINT32_WRITE(buffer + 12, temp);
1351 AES->CR |= AES_CR_CCFC;
1360 temp = AES->CR & ~AES_CR_GCMPH;
1365 while((AES->SR & AES_SR_CCF) == 0)
1372 __UNALIGNED_UINT32_WRITE(
t, temp);
1374 __UNALIGNED_UINT32_WRITE(
t + 4, temp);
1376 __UNALIGNED_UINT32_WRITE(
t + 8, temp);
1378 __UNALIGNED_UINT32_WRITE(
t + 12, temp);
1381 AES->CR |= AES_CR_CCFC;
1408 size_t nLen,
const uint8_t *
a,
size_t aLen,
const uint8_t *
p, uint8_t *
c,
1409 size_t length, uint8_t *
t,
size_t tLen)
1413 uint8_t authTag[16];
1458 size_t nLen,
const uint8_t *
a,
size_t aLen,
const uint8_t *
c, uint8_t *
p,
1459 size_t length,
const uint8_t *
t,
size_t tLen)
1465 uint8_t authTag[16];
1486 for(
mask = 0, i = 0; i < tLen; i++)
1488 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 stm32wlxxCryptoMutex
STM32WL 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.
STM32WL cipher hardware accelerator.
Common interface for encryption algorithms.
CipherAlgoEncryptBlock encryptBlock
CipherAlgoDecryptBlock decryptBlock
const CipherAlgo * cipherAlgo
Cipher algorithm.
void * cipherContext
Cipher algorithm context.