1 /*
2 * Copyright (c) 2020-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #ifdef HKS_CONFIG_FILE
17 #include HKS_CONFIG_FILE
18 #else
19 #include "hks_config.h"
20 #endif
21
22 #ifdef HKS_SUPPORT_AES_C
23
24 #include "hks_mbedtls_aes.h"
25
26 #include <mbedtls/aes.h>
27 #include <mbedtls/ccm.h>
28 #include <mbedtls/cipher.h>
29 #include <mbedtls/ctr_drbg.h>
30 #include <mbedtls/entropy.h>
31 #include <mbedtls/gcm.h>
32
33 #include "hks_log.h"
34 #include "hks_mbedtls_common.h"
35 #include "hks_mem.h"
36 #include "hks_template.h"
37
38 #define HKS_AES_CBC_NOPADDING_IV_SIZE 16
39 #define HKS_AES_CBC_DATA_BLOB_SIZE 16
40 #define HKS_AES_CCM_DATA_SIZE_MAX (1 * 1024 * 1024) // 1M
41
42 struct HksMbedtlsAesCtx {
43 uint32_t algType;
44 uint32_t mode;
45 uint32_t padding;
46 uint8_t *append;
47 uint8_t iv[HKS_AES_CBC_NOPADDING_IV_SIZE];
48 uint8_t *nonce;
49 uint32_t nonceSize;
50 uint8_t *aad;
51 uint32_t aadSize;
52 } HksMbedtlsAesCtx;
53
54 #ifdef HKS_SUPPORT_AES_GENERATE_KEY
HksMbedtlsAesGenerateKey(const struct HksKeySpec * spec,struct HksBlob * key)55 int32_t HksMbedtlsAesGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key)
56 {
57 if (spec->keyLen != HKS_AES_KEY_SIZE_128 && spec->keyLen != HKS_AES_KEY_SIZE_192 &&
58 spec->keyLen != HKS_AES_KEY_SIZE_256) {
59 return HKS_ERROR_INVALID_ARGUMENT;
60 }
61
62 const uint32_t keyByteLen = spec->keyLen / HKS_BITS_PER_BYTE;
63
64 uint8_t *outKey = (uint8_t *)HksMalloc(keyByteLen);
65 HKS_IF_NULL_RETURN(outKey, HKS_ERROR_MALLOC_FAIL)
66
67 mbedtls_entropy_context entropy;
68 mbedtls_ctr_drbg_context ctrDrbg;
69 (void)memset_s(&entropy, sizeof(mbedtls_entropy_context), 0, sizeof(mbedtls_entropy_context));
70 (void)memset_s(&ctrDrbg, sizeof(mbedtls_ctr_drbg_context), 0, sizeof(mbedtls_ctr_drbg_context));
71 int32_t ret = HksCtrDrbgSeed(&ctrDrbg, &entropy);
72 if (ret != HKS_SUCCESS) {
73 HKS_FREE_PTR(outKey);
74 return ret;
75 }
76
77 do {
78 ret = mbedtls_ctr_drbg_random(&ctrDrbg, outKey, keyByteLen);
79 if (ret != HKS_MBEDTLS_SUCCESS) {
80 HKS_LOG_E("Mbedtls ctr drbg random failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
81 (void)memset_s(outKey, keyByteLen, 0, keyByteLen);
82 HKS_FREE_PTR(outKey);
83 break;
84 }
85
86 key->data = outKey;
87 key->size = keyByteLen;
88 } while (0);
89
90 mbedtls_ctr_drbg_free(&ctrDrbg);
91 mbedtls_entropy_free(&entropy);
92 return ret;
93 }
94 #endif /* HKS_SUPPORT_AES_GENERATE_KEY */
95
96 #ifdef HKS_SUPPORT_AES_CBC_NOPADDING
AesCbcNoPaddingCrypt(const struct HksBlob * key,const struct HksCipherParam * cipherParam,const struct HksBlob * message,const bool encrypt,struct HksBlob * cipherText)97 static int32_t AesCbcNoPaddingCrypt(const struct HksBlob *key, const struct HksCipherParam *cipherParam,
98 const struct HksBlob *message, const bool encrypt, struct HksBlob *cipherText)
99 {
100 mbedtls_aes_context ctx;
101 mbedtls_aes_init(&ctx);
102
103 int32_t ret;
104 do {
105 if (encrypt) {
106 ret = mbedtls_aes_setkey_enc(&ctx, key->data, key->size * HKS_BITS_PER_BYTE);
107 } else {
108 ret = mbedtls_aes_setkey_dec(&ctx, key->data, key->size * HKS_BITS_PER_BYTE);
109 }
110 if (ret != HKS_MBEDTLS_SUCCESS) {
111 HKS_LOG_E("Mbedtls aes set key failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
112 break;
113 }
114
115 /* mbedtls_aes_crypt_cbc will refresh iv, so need a temp iv */
116 uint8_t tmpIv[HKS_AES_CBC_NOPADDING_IV_SIZE];
117 if (memcpy_s(tmpIv, HKS_AES_CBC_NOPADDING_IV_SIZE, cipherParam->iv.data, cipherParam->iv.size) != EOK) {
118 HKS_LOG_E("Memcpy temp iv failed!");
119 ret = HKS_ERROR_INVALID_IV;
120 break;
121 }
122
123 ret = mbedtls_aes_crypt_cbc(&ctx,
124 (encrypt ? MBEDTLS_AES_ENCRYPT : MBEDTLS_AES_DECRYPT),
125 message->size,
126 tmpIv,
127 message->data,
128 cipherText->data);
129 if (ret != HKS_MBEDTLS_SUCCESS) {
130 HKS_LOG_E("Mbedtks aes cbc crypt failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
131 (void)memset_s(cipherText->data, cipherText->size, 0, cipherText->size);
132 break;
133 }
134 cipherText->size = message->size;
135 } while (0);
136
137 mbedtls_aes_free(&ctx);
138 return ret;
139 }
140
AesCbcNoPaddingCryptInit(void ** cryptoCtx,const struct HksBlob * key,const struct HksUsageSpec * usageSpec,const bool encrypt)141 static int32_t AesCbcNoPaddingCryptInit(void **cryptoCtx, const struct HksBlob *key,
142 const struct HksUsageSpec *usageSpec, const bool encrypt)
143 {
144 mbedtls_aes_context *ctx = (mbedtls_aes_context *)HksMalloc(sizeof(mbedtls_aes_context));
145 HKS_IF_NULL_LOGE_RETURN(ctx, HKS_ERROR_MALLOC_FAIL, "initialize ctx fail")
146 mbedtls_aes_init(ctx);
147
148 int32_t ret;
149 if (encrypt) {
150 ret = mbedtls_aes_setkey_enc(ctx, key->data, key->size * HKS_BITS_PER_BYTE);
151 } else {
152 ret = mbedtls_aes_setkey_dec(ctx, key->data, key->size * HKS_BITS_PER_BYTE);
153 }
154 if (ret != HKS_MBEDTLS_SUCCESS) {
155 HKS_LOG_E("Mbedtls aes set key failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
156 mbedtls_aes_free(ctx);
157 HKS_FREE_PTR(ctx);
158 return ret;
159 }
160
161 struct HksMbedtlsAesCtx *outCtx = (struct HksMbedtlsAesCtx *)HksMalloc(sizeof(HksMbedtlsAesCtx));
162 if (outCtx == NULL) {
163 HKS_LOG_E("initialize outCtx fail");
164 mbedtls_aes_free(ctx);
165 HKS_FREE_PTR(ctx);
166 return HKS_ERROR_MALLOC_FAIL;
167 }
168
169 outCtx->append = (void *)ctx;
170 outCtx->mode = usageSpec->mode;
171 outCtx->padding = usageSpec->padding;
172 struct HksCipherParam *iv = (struct HksCipherParam *)(usageSpec->algParam);
173 (void)memcpy_s(outCtx->iv, HKS_AES_CBC_NOPADDING_IV_SIZE, iv->iv.data, HKS_AES_CBC_NOPADDING_IV_SIZE);
174
175 *cryptoCtx = (void *)outCtx;
176
177 return ret;
178 }
179
AesCbcNoPaddingCryptUpdate(void * cryptoCtx,const struct HksBlob * message,const bool encrypt,struct HksBlob * cipherText)180 static int32_t AesCbcNoPaddingCryptUpdate(void *cryptoCtx,
181 const struct HksBlob *message, const bool encrypt, struct HksBlob *cipherText)
182 {
183 struct HksMbedtlsAesCtx *aesCtx = (struct HksMbedtlsAesCtx *)cryptoCtx;
184 HKS_IF_NULL_RETURN(aesCtx, HKS_ERROR_NULL_POINTER)
185
186 mbedtls_aes_context *cbcNoPaddingCtx = (mbedtls_aes_context *)aesCtx->append;
187
188 HKS_IF_NULL_RETURN(cbcNoPaddingCtx, HKS_ERROR_NULL_POINTER)
189
190 int32_t ret;
191 do {
192 if (message->size % HKS_AES_CBC_DATA_BLOB_SIZE != 0) {
193 HKS_LOG_E("AesCbcNoPaddingCryptUpdate data size invalid!");
194 ret = HKS_ERROR_INVALID_ARGUMENT;
195 break;
196 }
197
198 /* mbedtls_aes_crypt_cbc will refresh iv, so need a temp iv */
199 uint8_t tmpIv[HKS_AES_CBC_NOPADDING_IV_SIZE];
200 if (memcpy_s(tmpIv, HKS_AES_CBC_NOPADDING_IV_SIZE, aesCtx->iv, HKS_AES_CBC_NOPADDING_IV_SIZE) != EOK) {
201 HKS_LOG_E("Memcpy temp iv failed!");
202 ret = HKS_ERROR_INVALID_IV;
203 break;
204 }
205
206 ret = mbedtls_aes_crypt_cbc(cbcNoPaddingCtx,
207 (encrypt ? MBEDTLS_AES_ENCRYPT : MBEDTLS_AES_DECRYPT),
208 message->size,
209 tmpIv,
210 message->data,
211 cipherText->data);
212 if (ret != HKS_MBEDTLS_SUCCESS) {
213 HKS_LOG_E("Mbedtks aes cbc nopadding crypt failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
214 (void)memset_s(cipherText->data, cipherText->size, 0, cipherText->size);
215 ret = HKS_ERROR_CRYPTO_ENGINE_ERROR;
216 break;
217 }
218
219 cipherText->size = message->size;
220 (void)memcpy_s(aesCtx->iv, HKS_AES_CBC_NOPADDING_IV_SIZE, tmpIv, HKS_AES_CBC_NOPADDING_IV_SIZE);
221 } while (0);
222
223 return ret;
224 }
225
AesCbcNoPaddingCryptFinal(void ** cryptoCtx,const struct HksBlob * message,const bool encrypt,struct HksBlob * cipherText)226 static int32_t AesCbcNoPaddingCryptFinal(void **cryptoCtx,
227 const struct HksBlob *message, const bool encrypt, struct HksBlob *cipherText)
228 {
229 struct HksMbedtlsAesCtx *aesCtx = (struct HksMbedtlsAesCtx *)*cryptoCtx;
230 mbedtls_aes_context *cbcNoPaddingCtx = (mbedtls_aes_context *)aesCtx->append;
231
232 if (cbcNoPaddingCtx == NULL) {
233 HKS_FREE_PTR(*cryptoCtx);
234 return HKS_ERROR_NULL_POINTER;
235 }
236
237 int32_t ret = HKS_SUCCESS;
238 do {
239 if (message->size % HKS_AES_CBC_DATA_BLOB_SIZE != 0) {
240 HKS_LOG_E("AesCbcNoPaddingCryptFinal data size invalid!");
241 ret = HKS_ERROR_INVALID_ARGUMENT;
242 break;
243 }
244
245 if (message->size != 0) {
246 /* mbedtls_aes_crypt_cbc will refresh iv, so need a temp iv */
247 uint8_t tmpIv[HKS_AES_CBC_NOPADDING_IV_SIZE];
248 if (memcpy_s(tmpIv, HKS_AES_CBC_NOPADDING_IV_SIZE, aesCtx->iv, HKS_AES_CBC_NOPADDING_IV_SIZE) != EOK) {
249 HKS_LOG_E("Memcpy temp iv failed!");
250 ret = HKS_ERROR_INVALID_IV;
251 break;
252 }
253 ret = mbedtls_aes_crypt_cbc(cbcNoPaddingCtx,
254 (encrypt ? MBEDTLS_AES_ENCRYPT : MBEDTLS_AES_DECRYPT),
255 message->size,
256 tmpIv,
257 message->data,
258 cipherText->data);
259 if (ret != HKS_MBEDTLS_SUCCESS) {
260 HKS_LOG_E("Mbedtls aes gcm encryot failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
261 (void)memset_s(cipherText->data, cipherText->size, 0, cipherText->size);
262 ret = HKS_ERROR_CRYPTO_ENGINE_ERROR;
263 break;
264 }
265 }
266 cipherText->size = message->size;
267 } while (0);
268
269 mbedtls_aes_free(cbcNoPaddingCtx);
270 HKS_FREE_PTR(aesCtx->append);
271 HKS_FREE_PTR(*cryptoCtx);
272
273 return ret;
274 }
275 #endif /* HKS_SUPPORT_AES_CBC_NOPADDING */
276
277 #ifdef HKS_SUPPORT_AES_CBC_PKCS7
AesCbcPkcs7Crypt(const struct HksBlob * key,const struct HksCipherParam * cipherParam,const struct HksBlob * message,const bool encrypt,struct HksBlob * cipherText)278 static int32_t AesCbcPkcs7Crypt(const struct HksBlob *key, const struct HksCipherParam *cipherParam,
279 const struct HksBlob *message, const bool encrypt, struct HksBlob *cipherText)
280 {
281 const uint32_t keyBitLen = key->size * HKS_BITS_PER_BYTE;
282 const mbedtls_cipher_info_t *info =
283 mbedtls_cipher_info_from_values(MBEDTLS_CIPHER_ID_AES, keyBitLen, MBEDTLS_MODE_CBC);
284
285 mbedtls_cipher_context_t ctx;
286 mbedtls_cipher_init(&ctx);
287
288 int32_t ret;
289 do {
290 ret = mbedtls_cipher_setup(&ctx, info);
291 if (ret != HKS_MBEDTLS_SUCCESS) {
292 HKS_LOG_E("Mbedtls cbc pkcs7 setup ctx failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
293 break;
294 }
295
296 ret = mbedtls_cipher_setkey(&ctx, key->data, keyBitLen, (encrypt ? MBEDTLS_ENCRYPT : MBEDTLS_DECRYPT));
297 if (ret != HKS_MBEDTLS_SUCCESS) {
298 HKS_LOG_E("Mbedtls cbc pkcs7 set key failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
299 break;
300 }
301 size_t keyLen = cipherText->size;
302 ret = mbedtls_cipher_crypt(&ctx,
303 cipherParam->iv.data,
304 cipherParam->iv.size,
305 message->data,
306 message->size,
307 cipherText->data,
308 &keyLen);
309 cipherText->size = (uint32_t)keyLen;
310 if (ret != HKS_MBEDTLS_SUCCESS) {
311 HKS_LOG_E("Mbedtls cbc pkcs7 crypt failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
312 (void)memset_s(cipherText->data, cipherText->size, 0, cipherText->size);
313 }
314 } while (0);
315
316 mbedtls_cipher_free(&ctx);
317 return ret;
318 }
319
AesCbcPkcs7CryptInitParam(const struct HksBlob * key,mbedtls_cipher_context_t * cbcPkcs7ctx,const bool encrypt)320 static int32_t AesCbcPkcs7CryptInitParam(const struct HksBlob *key, mbedtls_cipher_context_t *cbcPkcs7ctx,
321 const bool encrypt)
322 {
323 const uint32_t keyBitLen = key->size * HKS_BITS_PER_BYTE;
324 const mbedtls_cipher_info_t *info =
325 mbedtls_cipher_info_from_values(MBEDTLS_CIPHER_ID_AES, keyBitLen, MBEDTLS_MODE_CBC);
326
327 int32_t ret = mbedtls_cipher_setup(cbcPkcs7ctx, info);
328 if (ret != HKS_MBEDTLS_SUCCESS) {
329 HKS_LOG_E("Mbedtls cbc pkcs7 setup ctx failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
330 return ret;
331 }
332
333 ret = mbedtls_cipher_setkey(cbcPkcs7ctx, key->data, keyBitLen, (encrypt ? MBEDTLS_ENCRYPT : MBEDTLS_DECRYPT));
334 if (ret != HKS_MBEDTLS_SUCCESS) {
335 HKS_LOG_E("Mbedtls cbc pkcs7 set key failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
336 return ret;
337 }
338 return HKS_SUCCESS;
339 }
340
AesCbcPkcs7CryptInit(void ** cryptoCtx,const struct HksBlob * key,const struct HksUsageSpec * usageSpec,const bool encrypt)341 static int32_t AesCbcPkcs7CryptInit(void **cryptoCtx, const struct HksBlob *key,
342 const struct HksUsageSpec *usageSpec, const bool encrypt)
343 {
344 mbedtls_cipher_context_t *cbcPkcs7ctx = (mbedtls_cipher_context_t *)HksMalloc(sizeof(mbedtls_cipher_context_t));
345 HKS_IF_NULL_LOGE_RETURN(cbcPkcs7ctx, HKS_ERROR_MALLOC_FAIL, "malloc cbcPkcs7ctx fail")
346 mbedtls_cipher_init(cbcPkcs7ctx);
347
348 int32_t ret = AesCbcPkcs7CryptInitParam(key, cbcPkcs7ctx, encrypt);
349 if (ret != HKS_SUCCESS) {
350 HKS_LOG_E("AesCbcPkcs7CryptInitParam fail %" LOG_PUBLIC "d", ret);
351 mbedtls_cipher_free(cbcPkcs7ctx);
352 HKS_FREE_PTR(cbcPkcs7ctx);
353 return ret;
354 }
355
356 const struct HksCipherParam *cipherParam = (struct HksCipherParam *)(usageSpec->algParam);
357 ret = mbedtls_cipher_set_iv(cbcPkcs7ctx, cipherParam->iv.data, cipherParam->iv.size);
358 if (ret != HKS_MBEDTLS_SUCCESS) {
359 HKS_LOG_E("Mbedtls cbc pkcs7 set iv failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
360 mbedtls_cipher_free(cbcPkcs7ctx);
361 HKS_FREE_PTR(cbcPkcs7ctx);
362 return ret;
363 }
364 ret = mbedtls_cipher_reset(cbcPkcs7ctx);
365 if (ret != HKS_MBEDTLS_SUCCESS) {
366 HKS_LOG_E("Mbedtls cbc pkcs7 reset failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
367 mbedtls_cipher_free(cbcPkcs7ctx);
368 HKS_FREE_PTR(cbcPkcs7ctx);
369 return ret;
370 }
371
372 struct HksMbedtlsAesCtx *outCtx = (struct HksMbedtlsAesCtx *)HksMalloc(sizeof(HksMbedtlsAesCtx));
373 if (outCtx == NULL) {
374 HKS_LOG_E("malloc outCtx fail");
375 mbedtls_cipher_free(cbcPkcs7ctx);
376 HKS_FREE_PTR(cbcPkcs7ctx);
377 return HKS_ERROR_MALLOC_FAIL;
378 }
379
380 outCtx->mode = usageSpec->mode;
381 outCtx->padding = usageSpec->padding;
382 outCtx->append = (void *)cbcPkcs7ctx;
383
384 *cryptoCtx = (void *)outCtx;
385
386 return ret;
387 }
388
AesCbcPkcs7CryptUpdate(void * cryptoCtx,const struct HksBlob * message,struct HksBlob * cipherText)389 static int32_t AesCbcPkcs7CryptUpdate(void *cryptoCtx, const struct HksBlob *message, struct HksBlob *cipherText)
390 {
391 struct HksMbedtlsAesCtx *aesCtx = (struct HksMbedtlsAesCtx *)cryptoCtx;
392 mbedtls_cipher_context_t *cbcPkcs7ctx = (mbedtls_cipher_context_t *)aesCtx->append;
393
394 HKS_IF_NULL_RETURN(cbcPkcs7ctx, HKS_ERROR_NULL_POINTER)
395 size_t keyLen = cipherText->size;
396 int32_t ret = mbedtls_cipher_update(cbcPkcs7ctx, message->data, message->size, cipherText->data,
397 &keyLen);
398 cipherText->size = (uint32_t)keyLen;
399 if (ret != HKS_MBEDTLS_SUCCESS) {
400 HKS_LOG_E("Mbedtls cbc pkcs7 crypt update failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
401 (void)memset_s(cipherText->data, cipherText->size, 0, cipherText->size);
402 }
403 return ret;
404 }
405
AesCbcPkcs7CryptFinal(void ** cryptoCtx,const struct HksBlob * message,struct HksBlob * cipherText)406 static int32_t AesCbcPkcs7CryptFinal(void **cryptoCtx, const struct HksBlob *message,
407 struct HksBlob *cipherText)
408 {
409 struct HksMbedtlsAesCtx *aesCtx = (struct HksMbedtlsAesCtx *)*cryptoCtx;
410 mbedtls_cipher_context_t *cbcPkcs7ctx = (mbedtls_cipher_context_t *)aesCtx->append;
411
412 if (cbcPkcs7ctx == NULL) {
413 HKS_FREE_PTR(*cryptoCtx);
414 return HKS_ERROR_NULL_POINTER;
415 }
416
417 size_t finish_olen;
418 int32_t ret;
419 do {
420 cipherText->size = 0;
421 if (message->size != 0) {
422 size_t keyLen = cipherText->size;
423 ret = mbedtls_cipher_update(cbcPkcs7ctx, message->data, message->size, cipherText->data,
424 &keyLen);
425 cipherText->size = (uint32_t)keyLen;
426 if (ret != HKS_MBEDTLS_SUCCESS) {
427 HKS_LOG_E("Mbedtls cbc pkcs7 crypt update failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
428 (void)memset_s(cipherText->data, cipherText->size, 0, cipherText->size);
429 break;
430 }
431 }
432
433 size_t olen = (size_t)cipherText->size;
434 ret = mbedtls_cipher_finish(cbcPkcs7ctx, cipherText->data + olen, &finish_olen);
435 if (ret != HKS_MBEDTLS_SUCCESS) {
436 HKS_LOG_E("Mbedtls cbc pkcs7 crypt update failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
437 (void)memset_s(cipherText->data, cipherText->size, 0, cipherText->size);
438 break;
439 }
440 cipherText->size = olen + finish_olen;
441 } while (0);
442
443 mbedtls_cipher_free(cbcPkcs7ctx);
444 HKS_FREE_PTR(aesCtx->append);
445 HKS_FREE_PTR(*cryptoCtx);
446
447 return ret;
448 }
449 #endif /* HKS_SUPPORT_AES_CBC_PKCS7 */
450
451 #if defined(HKS_SUPPORT_AES_CBC_NOPADDING) || defined(HKS_SUPPORT_AES_CBC_PKCS7)
AesCbcCrypt(const struct HksBlob * key,const struct HksUsageSpec * usageSpec,const struct HksBlob * message,const bool encrypt,struct HksBlob * cipherText)452 static int32_t AesCbcCrypt(const struct HksBlob *key, const struct HksUsageSpec *usageSpec,
453 const struct HksBlob *message, const bool encrypt, struct HksBlob *cipherText)
454 {
455 const struct HksCipherParam *cipherParam = (struct HksCipherParam *)(usageSpec->algParam);
456
457 switch (usageSpec->padding) {
458 #ifdef HKS_SUPPORT_AES_CBC_NOPADDING
459 case HKS_PADDING_NONE:
460 return AesCbcNoPaddingCrypt(key, cipherParam, message, encrypt, cipherText);
461 #endif
462 #ifdef HKS_SUPPORT_AES_CBC_PKCS7
463 case HKS_PADDING_PKCS7:
464 return AesCbcPkcs7Crypt(key, cipherParam, message, encrypt, cipherText);
465 #endif
466 default:
467 HKS_LOG_E("Unsupport padding! mode = 0x%" LOG_PUBLIC "X", usageSpec->padding);
468 return HKS_ERROR_INVALID_PADDING;
469 }
470 }
471
AesCbcCryptInit(void ** cryptoCtx,const struct HksBlob * key,const struct HksUsageSpec * usageSpec,const bool encrypt)472 static int32_t AesCbcCryptInit(void **cryptoCtx, const struct HksBlob *key,
473 const struct HksUsageSpec *usageSpec, const bool encrypt)
474 {
475 switch (usageSpec->padding) {
476 #ifdef HKS_SUPPORT_AES_CBC_NOPADDING
477 case HKS_PADDING_NONE:
478 return AesCbcNoPaddingCryptInit(cryptoCtx, key, usageSpec, encrypt);
479 #endif
480 #ifdef HKS_SUPPORT_AES_CBC_PKCS7
481 case HKS_PADDING_PKCS7:
482 return AesCbcPkcs7CryptInit(cryptoCtx, key, usageSpec, encrypt);
483 #endif
484 default:
485 HKS_LOG_E("Unsupport padding! mode = 0x%" LOG_PUBLIC "X", usageSpec->padding);
486 return HKS_ERROR_INVALID_PADDING;
487 }
488 }
489
AesCbcCryptUpdate(void * cryptoCtx,const uint8_t padding,const struct HksBlob * message,const bool encrypt,struct HksBlob * cipherText)490 static int32_t AesCbcCryptUpdate(void *cryptoCtx, const uint8_t padding,
491 const struct HksBlob *message, const bool encrypt, struct HksBlob *cipherText)
492 {
493 switch (padding) {
494 #ifdef HKS_SUPPORT_AES_CBC_NOPADDING
495 case HKS_PADDING_NONE:
496 return AesCbcNoPaddingCryptUpdate(cryptoCtx, message, encrypt, cipherText);
497 #endif
498 #ifdef HKS_SUPPORT_AES_CBC_PKCS7
499 case HKS_PADDING_PKCS7:
500 return AesCbcPkcs7CryptUpdate(cryptoCtx, message, cipherText);
501 #endif
502 default:
503 HKS_LOG_E("Unsupport padding! mode = 0x%" LOG_PUBLIC "X", padding);
504 return HKS_ERROR_INVALID_PADDING;
505 }
506 }
507
AesCbcCryptFinal(void ** cryptoCtx,const uint8_t padding,const struct HksBlob * message,const bool encrypt,struct HksBlob * cipherText)508 static int32_t AesCbcCryptFinal(void **cryptoCtx, const uint8_t padding,
509 const struct HksBlob *message, const bool encrypt, struct HksBlob *cipherText)
510 {
511 switch (padding) {
512 #ifdef HKS_SUPPORT_AES_CBC_NOPADDING
513 case HKS_PADDING_NONE:
514 return AesCbcNoPaddingCryptFinal(cryptoCtx, message, encrypt, cipherText);
515 #endif
516 #ifdef HKS_SUPPORT_AES_CBC_PKCS7
517 case HKS_PADDING_PKCS7:
518 return AesCbcPkcs7CryptFinal(cryptoCtx, message, cipherText);
519 #endif
520 default:
521 HKS_LOG_E("Unsupport padding! mode = 0x%" LOG_PUBLIC "X", padding);
522 return HKS_ERROR_INVALID_PADDING;
523 }
524 }
525 #endif /* HKS_SUPPORT_AES_CBC_NOPADDING or HKS_SUPPORT_AES_CBC_PKCS7 */
526
527 #ifdef HKS_SUPPORT_AES_GCM
AesEncryptGcm(const struct HksBlob * key,const struct HksUsageSpec * usageSpec,const struct HksBlob * message,struct HksBlob * cipherText,struct HksBlob * tagAead)528 static int32_t AesEncryptGcm(const struct HksBlob *key, const struct HksUsageSpec *usageSpec,
529 const struct HksBlob *message, struct HksBlob *cipherText, struct HksBlob *tagAead)
530 {
531 mbedtls_gcm_context ctx;
532 mbedtls_gcm_init(&ctx);
533
534 int32_t ret;
535 do {
536 ret = mbedtls_gcm_setkey(&ctx, MBEDTLS_CIPHER_ID_AES, key->data, key->size * HKS_BITS_PER_BYTE);
537 if (ret != HKS_MBEDTLS_SUCCESS) {
538 HKS_LOG_E("Mbedtls aes gcm set key failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
539 break;
540 }
541
542 const struct HksAeadParam *aeadParam = (struct HksAeadParam *)(usageSpec->algParam);
543 ret = mbedtls_gcm_crypt_and_tag(&ctx,
544 MBEDTLS_GCM_ENCRYPT,
545 message->size,
546 aeadParam->nonce.data,
547 aeadParam->nonce.size,
548 aeadParam->aad.data,
549 aeadParam->aad.size,
550 message->data,
551 cipherText->data,
552 tagAead->size,
553 tagAead->data);
554 if (ret != HKS_MBEDTLS_SUCCESS) {
555 HKS_LOG_E("Mbedtls aes gcm encryot failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
556 (void)memset_s(cipherText->data, cipherText->size, 0, cipherText->size);
557 (void)memset_s(tagAead->data, tagAead->size, 0, tagAead->size);
558 break;
559 }
560 cipherText->size = message->size;
561 } while (0);
562
563 mbedtls_gcm_free(&ctx);
564 return ret;
565 }
566
AesEncryptGcmInit(void ** cryptoCtx,const struct HksUsageSpec * usageSpec,const struct HksBlob * key)567 static int32_t AesEncryptGcmInit(void **cryptoCtx, const struct HksUsageSpec *usageSpec, const struct HksBlob *key)
568 {
569 mbedtls_gcm_context *gcmCtx = (mbedtls_gcm_context *)HksMalloc(sizeof(mbedtls_gcm_context));
570 HKS_IF_NULL_LOGE_RETURN(gcmCtx, HKS_ERROR_MALLOC_FAIL, "Gcm gcmCtx malloc fail")
571
572 mbedtls_gcm_init(gcmCtx);
573
574 int32_t ret = mbedtls_gcm_setkey(gcmCtx, MBEDTLS_CIPHER_ID_AES, key->data, key->size * HKS_BITS_PER_BYTE);
575 if (ret != HKS_MBEDTLS_SUCCESS) {
576 HKS_LOG_E("Mbedtls aes gcm set key failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
577 mbedtls_gcm_free(gcmCtx);
578 HKS_FREE_PTR(gcmCtx);
579 return ret;
580 }
581
582 const struct HksAeadParam *aeadParam = (struct HksAeadParam *)(usageSpec->algParam);
583 ret = mbedtls_gcm_starts(gcmCtx, MBEDTLS_GCM_ENCRYPT, aeadParam->nonce.data,
584 aeadParam->nonce.size);
585 if (ret != HKS_MBEDTLS_SUCCESS) {
586 HKS_LOG_E("Mbedtls aes gcm start failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
587 mbedtls_gcm_free(gcmCtx);
588 HKS_FREE_PTR(gcmCtx);
589 return ret;
590 }
591
592 struct HksMbedtlsAesCtx *outCtx = (struct HksMbedtlsAesCtx *)HksMalloc(sizeof(struct HksMbedtlsAesCtx));
593 if (outCtx == NULL) {
594 HKS_LOG_E("initialize outCtx fail");
595 mbedtls_gcm_free(gcmCtx);
596 HKS_FREE_PTR(gcmCtx);
597 return HKS_ERROR_MALLOC_FAIL;
598 }
599
600 outCtx->mode = usageSpec->mode;
601 outCtx->append = (void *)gcmCtx;
602 *cryptoCtx = (void *)outCtx;
603
604 return ret;
605 }
606
AesEncryptGcmUpdate(void * cryptoCtx,const uint8_t padding,const struct HksBlob * message,struct HksBlob * cipherText)607 static int32_t AesEncryptGcmUpdate(void *cryptoCtx, const uint8_t padding, const struct HksBlob *message,
608 struct HksBlob *cipherText)
609 {
610 (void)padding;
611
612 struct HksMbedtlsAesCtx *aesCtx = (struct HksMbedtlsAesCtx *)cryptoCtx;
613 mbedtls_gcm_context *gcmCtx = (mbedtls_gcm_context *)aesCtx->append;
614 HKS_IF_NULL_LOGE_RETURN(gcmCtx, HKS_ERROR_NULL_POINTER, "GcmUpdate gcmCtx is null")
615
616 size_t size = 0;
617 int32_t ret = mbedtls_gcm_update(gcmCtx, message->data, message->size, cipherText->data, cipherText->size, &size);
618 if (ret != HKS_MBEDTLS_SUCCESS) {
619 HKS_LOG_E("Mbedtls aes gcm encryot update failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
620 (void)memset_s(cipherText->data, cipherText->size, 0, cipherText->size);
621 } else {
622 cipherText->size = message->size;
623 }
624
625 return ret;
626 }
627
AesEncryptGcmFinal(void ** cryptoCtx,const struct HksBlob * message,struct HksBlob * cipherText,struct HksBlob * tagAead)628 static int32_t AesEncryptGcmFinal(void **cryptoCtx, const struct HksBlob *message, struct HksBlob *cipherText,
629 struct HksBlob *tagAead)
630 {
631 struct HksMbedtlsAesCtx *aesCtx = (struct HksMbedtlsAesCtx *)*cryptoCtx;
632 mbedtls_gcm_context *gcmCtx = (mbedtls_gcm_context *)aesCtx->append;
633 if (gcmCtx == NULL) {
634 HKS_LOG_E("GcmFinal gcmCtx is null");
635 HKS_FREE_PTR(*cryptoCtx);
636 return HKS_ERROR_NULL_POINTER;
637 }
638
639 int32_t ret;
640 do {
641 if (message->size != 0) {
642 size_t size = 0;
643 ret = mbedtls_gcm_update(gcmCtx, message->data, message->size, cipherText->data, cipherText->size, &size);
644 if (ret != HKS_MBEDTLS_SUCCESS) {
645 HKS_LOG_E("Mbedtls aes gcm encryot failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
646 (void)memset_s(cipherText->data, cipherText->size, 0, cipherText->size);
647 break;
648 }
649 }
650 cipherText->size = message->size;
651
652 size_t size = 0;
653 ret = mbedtls_gcm_finish(gcmCtx, tagAead->data, tagAead->size, &size, tagAead->data, tagAead->size);
654 if (ret != HKS_MBEDTLS_SUCCESS) {
655 HKS_LOG_E("Mbedtls aes gcm encryot failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
656 (void)memset_s(tagAead->data, tagAead->size, 0, tagAead->size);
657 break;
658 }
659 } while (0);
660
661 mbedtls_gcm_free(gcmCtx);
662 HKS_FREE_PTR(aesCtx->append);
663 HKS_FREE_PTR(*cryptoCtx);
664 return ret;
665 }
666
AesDecryptGcm(const struct HksBlob * key,const struct HksUsageSpec * usageSpec,const struct HksBlob * message,struct HksBlob * cipherText)667 static int32_t AesDecryptGcm(const struct HksBlob *key, const struct HksUsageSpec *usageSpec,
668 const struct HksBlob *message, struct HksBlob *cipherText)
669 {
670 mbedtls_gcm_context ctx;
671 (void)memset_s(&ctx, sizeof(mbedtls_gcm_context), 0, sizeof(mbedtls_gcm_context));
672 mbedtls_gcm_init(&ctx);
673
674 int32_t ret;
675 do {
676 ret = mbedtls_gcm_setkey(&ctx, MBEDTLS_CIPHER_ID_AES, key->data, key->size * HKS_BITS_PER_BYTE);
677 if (ret != HKS_MBEDTLS_SUCCESS) {
678 HKS_LOG_E("Mbedtls aes gcm set key failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
679 break;
680 }
681
682 const struct HksAeadParam *aeadParam = (struct HksAeadParam *)(usageSpec->algParam);
683 ret = mbedtls_gcm_auth_decrypt(&ctx,
684 message->size,
685 aeadParam->nonce.data,
686 aeadParam->nonce.size,
687 aeadParam->aad.data,
688 aeadParam->aad.size,
689 aeadParam->tagDec.data,
690 aeadParam->tagDec.size,
691 message->data,
692 cipherText->data);
693 if (ret != HKS_MBEDTLS_SUCCESS) {
694 HKS_LOG_E("Mbedtls aes gcm decrypt failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
695 (void)memset_s(cipherText->data, cipherText->size, 0, cipherText->size);
696 break;
697 }
698 cipherText->size = message->size;
699 } while (0);
700
701 mbedtls_gcm_free(&ctx);
702 return ret;
703 }
704
AesDecryptGcmInit(void ** cryptoCtx,const struct HksBlob * key,const struct HksUsageSpec * usageSpec)705 static int32_t AesDecryptGcmInit(void **cryptoCtx, const struct HksBlob *key, const struct HksUsageSpec *usageSpec)
706 {
707 mbedtls_gcm_context *gcmCtx = (mbedtls_gcm_context*)HksMalloc(sizeof(mbedtls_gcm_context));
708 HKS_IF_NULL_LOGE_RETURN(gcmCtx, HKS_ERROR_MALLOC_FAIL, "Decrtyt Gcm gcmCtx malloc fail")
709
710 mbedtls_gcm_init(gcmCtx);
711
712 int32_t ret = mbedtls_gcm_setkey(gcmCtx, MBEDTLS_CIPHER_ID_AES, key->data, key->size * HKS_BITS_PER_BYTE);
713 if (ret != HKS_MBEDTLS_SUCCESS) {
714 HKS_LOG_E("Mbedtls aes gcm set key failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
715 mbedtls_gcm_free(gcmCtx);
716 HKS_FREE_PTR(gcmCtx);
717 return ret;
718 }
719
720 const struct HksAeadParam *aeadParam = (struct HksAeadParam *)(usageSpec->algParam);
721 ret = mbedtls_gcm_starts(gcmCtx, MBEDTLS_GCM_DECRYPT, aeadParam->nonce.data,
722 aeadParam->nonce.size);
723 if (ret != HKS_MBEDTLS_SUCCESS) {
724 HKS_LOG_E("Mbedtls aes gcm start failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
725 mbedtls_gcm_free(gcmCtx);
726 HKS_FREE_PTR(gcmCtx);
727 return ret;
728 }
729
730 struct HksMbedtlsAesCtx *outCtx = (struct HksMbedtlsAesCtx *)HksMalloc(sizeof(struct HksMbedtlsAesCtx));
731 if (outCtx == NULL) {
732 mbedtls_gcm_free(gcmCtx);
733 HKS_FREE_PTR(gcmCtx);
734 return HKS_ERROR_MALLOC_FAIL;
735 }
736
737 outCtx->mode = usageSpec->mode;
738 outCtx->append = (void *)gcmCtx;
739 *cryptoCtx = (void *)outCtx;
740
741 return ret;
742 }
743
AesDecryptGcmUpdate(void * cryptoCtx,const struct HksBlob * message,struct HksBlob * cipherText)744 static int32_t AesDecryptGcmUpdate(void *cryptoCtx,
745 const struct HksBlob *message, struct HksBlob *cipherText)
746 {
747 struct HksMbedtlsAesCtx *aesCtx = (struct HksMbedtlsAesCtx *)cryptoCtx;
748 mbedtls_gcm_context *gcmCtx = (mbedtls_gcm_context *)aesCtx->append;
749 HKS_IF_NULL_LOGE_RETURN(gcmCtx, HKS_FAILURE, "GcmUpdate gcmCtx is null")
750
751 size_t size = 0;
752 int32_t ret = mbedtls_gcm_update(gcmCtx, message->data, message->size, cipherText->data, cipherText->size, &size);
753 if (ret != HKS_MBEDTLS_SUCCESS) {
754 HKS_LOG_E("Mbedtls aes gcm decrypt update failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
755 (void)memset_s(cipherText->data, cipherText->size, 0, cipherText->size);
756 } else {
757 cipherText->size = message->size;
758 }
759 return ret;
760 }
761
AesDecryptGcmFinal(void ** cryptoCtx,const struct HksBlob * message,struct HksBlob * cipherText,struct HksBlob * tagAead)762 static int32_t AesDecryptGcmFinal(void **cryptoCtx, const struct HksBlob *message,
763 struct HksBlob *cipherText, struct HksBlob *tagAead)
764 {
765 struct HksMbedtlsAesCtx *aesCtx = (struct HksMbedtlsAesCtx *)*cryptoCtx;
766 mbedtls_gcm_context *gcmCtx = (mbedtls_gcm_context *)aesCtx->append;
767 if (gcmCtx == NULL) {
768 HKS_LOG_E("GcmFinal gcmCtx is null");
769 HKS_FREE_PTR(*cryptoCtx);
770 return HKS_FAILURE;
771 }
772
773 int32_t ret;
774 do {
775 if (message->size != 0) {
776 size_t size = 0;
777 ret = mbedtls_gcm_update(gcmCtx, message->data, message->size, cipherText->data, cipherText->size, &size);
778 if (ret != HKS_MBEDTLS_SUCCESS) {
779 HKS_LOG_E("Mbedtls aes gcm decrypt update failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
780 (void)memset_s(cipherText->data, cipherText->size, 0, cipherText->size);
781 break;
782 }
783 }
784 cipherText->size = message->size;
785
786 uint8_t check_tag[16];
787 size_t size = 0;
788 ret = mbedtls_gcm_finish(gcmCtx, check_tag, tagAead->size, &size, check_tag, tagAead->size);
789 if (ret != HKS_MBEDTLS_SUCCESS) {
790 HKS_LOG_E("Mbedtls aes gcm decrypt failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
791 (void)memset_s(cipherText->data, cipherText->size, 0, cipherText->size);
792 break;
793 }
794
795 uint8_t diff;
796 size_t i;
797 /* Check tag in "constant-time" */
798 for (diff = 0, i = 0; i < tagAead->size; i++) {
799 diff |= tagAead->data[i] ^ check_tag[i];
800 }
801
802 if (diff != 0) {
803 mbedtls_platform_zeroize(cipherText->data, message->size);
804 ret = MBEDTLS_ERR_GCM_AUTH_FAILED;
805 break;
806 }
807 } while (0);
808
809 mbedtls_gcm_free(gcmCtx);
810 HKS_FREE_PTR(aesCtx->append);
811 HKS_FREE_PTR(*cryptoCtx);
812
813 return ret;
814 }
815 #endif /* HKS_SUPPORT_AES_GCM */
816
817 #ifdef HKS_SUPPORT_AES_CCM
AesEncryptCcm(const struct HksBlob * key,const struct HksUsageSpec * usageSpec,const struct HksBlob * message,struct HksBlob * cipherText,struct HksBlob * tagAead)818 static int32_t AesEncryptCcm(const struct HksBlob *key, const struct HksUsageSpec *usageSpec,
819 const struct HksBlob *message, struct HksBlob *cipherText, struct HksBlob *tagAead)
820 {
821 mbedtls_ccm_context ctx;
822 (void)memset_s(&ctx, sizeof(mbedtls_ccm_context), 0, sizeof(mbedtls_ccm_context));
823 mbedtls_ccm_init(&ctx);
824
825 int32_t ret;
826 do {
827 ret = mbedtls_ccm_setkey(&ctx, MBEDTLS_CIPHER_ID_AES, key->data, key->size * HKS_BITS_PER_BYTE);
828 if (ret != HKS_MBEDTLS_SUCCESS) {
829 HKS_LOG_E("Mbedtls aes ccm set key failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
830 break;
831 }
832
833 const struct HksAeadParam *aeadParam = (struct HksAeadParam *)(usageSpec->algParam);
834 ret = mbedtls_ccm_encrypt_and_tag(&ctx,
835 message->size,
836 aeadParam->nonce.data,
837 aeadParam->nonce.size,
838 aeadParam->aad.data,
839 aeadParam->aad.size,
840 message->data,
841 cipherText->data,
842 tagAead->data,
843 tagAead->size);
844 if (ret != HKS_MBEDTLS_SUCCESS) {
845 HKS_LOG_E("Mbedtls aes ccm encrypt failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
846 (void)memset_s(cipherText->data, cipherText->size, 0, cipherText->size);
847 (void)memset_s(tagAead->data, tagAead->size, 0, tagAead->size);
848 break;
849 }
850 cipherText->size = message->size;
851 } while (0);
852
853 mbedtls_ccm_free(&ctx);
854 return ret;
855 }
856
AesDecryptCcm(const struct HksBlob * key,const struct HksUsageSpec * usageSpec,const struct HksBlob * message,struct HksBlob * cipherText)857 static int32_t AesDecryptCcm(const struct HksBlob *key, const struct HksUsageSpec *usageSpec,
858 const struct HksBlob *message, struct HksBlob *cipherText)
859 {
860 mbedtls_ccm_context ctx;
861 (void)memset_s(&ctx, sizeof(mbedtls_ccm_context), 0, sizeof(mbedtls_ccm_context));
862 mbedtls_ccm_init(&ctx);
863
864 int32_t ret;
865 do {
866 ret = mbedtls_ccm_setkey(&ctx, MBEDTLS_CIPHER_ID_AES, key->data, key->size * HKS_BITS_PER_BYTE);
867 if (ret != HKS_MBEDTLS_SUCCESS) {
868 HKS_LOG_E("Mbedtls aes ccm set key failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
869 break;
870 }
871
872 const struct HksAeadParam *aeadParam = (struct HksAeadParam *)(usageSpec->algParam);
873 ret = mbedtls_ccm_auth_decrypt(&ctx,
874 message->size,
875 aeadParam->nonce.data,
876 aeadParam->nonce.size,
877 aeadParam->aad.data,
878 aeadParam->aad.size,
879 message->data,
880 cipherText->data,
881 aeadParam->tagDec.data,
882 aeadParam->tagDec.size);
883 if (ret != HKS_MBEDTLS_SUCCESS) {
884 HKS_LOG_E("Mbedtls aes ccm decrypt failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
885 (void)memset_s(cipherText->data, cipherText->size, 0, cipherText->size);
886 break;
887 }
888 cipherText->size = message->size;
889 } while (0);
890
891 mbedtls_ccm_free(&ctx);
892 return ret;
893 }
894 #endif /* HKS_SUPPORT_AES_CCM */
895
896 #ifdef HKS_SUPPORT_AES_CTR_NOPADDING
AesCtrCrypt(const struct HksBlob * key,const struct HksUsageSpec * usageSpec,const struct HksBlob * message,const bool encrypt,struct HksBlob * cipherText)897 static int32_t AesCtrCrypt(const struct HksBlob *key, const struct HksUsageSpec *usageSpec,
898 const struct HksBlob *message, const bool encrypt, struct HksBlob *cipherText)
899 {
900 const struct HksCipherParam *cipherParam = (struct HksCipherParam *)(usageSpec->algParam);
901 mbedtls_cipher_context_t ctx;
902 (void)memset_s(&ctx, sizeof(mbedtls_cipher_context_t), 0, sizeof(mbedtls_cipher_context_t));
903 mbedtls_cipher_init(&ctx);
904
905 int32_t ret;
906 do {
907 const mbedtls_cipher_info_t *info =
908 mbedtls_cipher_info_from_values(MBEDTLS_CIPHER_ID_AES, key->size * HKS_BITS_PER_BYTE, MBEDTLS_MODE_CTR);
909
910 ret = mbedtls_cipher_setup(&ctx, info);
911 if (ret != HKS_MBEDTLS_SUCCESS) {
912 HKS_LOG_E("Mbedtls failed ret = %" LOG_PUBLIC "d", ret);
913 break;
914 }
915
916 ret = mbedtls_cipher_setkey(
917 &ctx, key->data, key->size * HKS_BITS_PER_BYTE, encrypt ? MBEDTLS_ENCRYPT : MBEDTLS_DECRYPT);
918 if (ret != HKS_MBEDTLS_SUCCESS) {
919 HKS_LOG_E("Mbedtls failed ret = %" LOG_PUBLIC "d", ret);
920 break;
921 }
922
923 size_t outLen;
924 ret = mbedtls_cipher_crypt(
925 &ctx, cipherParam->iv.data, cipherParam->iv.size, message->data, message->size, cipherText->data, &outLen);
926 if (ret != HKS_MBEDTLS_SUCCESS) {
927 HKS_LOG_E("Mbedtls failed ret = 0x%" LOG_PUBLIC "X", ret);
928 break;
929 }
930 cipherText->size = outLen;
931
932 mbedtls_cipher_free(&ctx);
933 return HKS_SUCCESS;
934 } while (0);
935
936 mbedtls_cipher_free(&ctx);
937 return HKS_ERROR_CRYPTO_ENGINE_ERROR;
938 }
939
AesCtrCryptInitParam(const struct HksBlob * key,mbedtls_cipher_context_t * ctrCtx,const bool encrypt)940 static int32_t AesCtrCryptInitParam(const struct HksBlob *key, mbedtls_cipher_context_t *ctrCtx,
941 const bool encrypt)
942 {
943 int32_t ret;
944 const mbedtls_cipher_info_t *info =
945 mbedtls_cipher_info_from_values(MBEDTLS_CIPHER_ID_AES, key->size * HKS_BITS_PER_BYTE, MBEDTLS_MODE_CTR);
946
947 ret = mbedtls_cipher_setup(ctrCtx, info);
948 if (ret != HKS_MBEDTLS_SUCCESS) {
949 HKS_LOG_E("Mbedtls failed ret = %" LOG_PUBLIC "d", ret);
950 return ret;
951 }
952
953 ret = mbedtls_cipher_setkey(
954 ctrCtx, key->data, key->size * HKS_BITS_PER_BYTE, encrypt ? MBEDTLS_ENCRYPT : MBEDTLS_DECRYPT);
955 if (ret != HKS_MBEDTLS_SUCCESS) {
956 HKS_LOG_E("Mbedtls failed ret = %" LOG_PUBLIC "d", ret);
957 return ret;
958 }
959 return HKS_SUCCESS;
960 }
961
AesCtrCryptInit(void ** cryptoCtx,const struct HksUsageSpec * usageSpec,const struct HksBlob * key,const bool encrypt)962 static int32_t AesCtrCryptInit(void **cryptoCtx, const struct HksUsageSpec *usageSpec,
963 const struct HksBlob *key, const bool encrypt)
964 {
965 mbedtls_cipher_context_t *ctrCtx = (mbedtls_cipher_context_t *)HksMalloc(sizeof(mbedtls_cipher_context_t));
966 HKS_IF_NULL_LOGE_RETURN(ctrCtx, HKS_ERROR_MALLOC_FAIL, "Ctr ctrCtx malloc fail")
967
968 mbedtls_cipher_init(ctrCtx);
969
970 int32_t ret;
971 ret = AesCtrCryptInitParam(key, ctrCtx, encrypt);
972 if (ret != HKS_SUCCESS) {
973 HKS_LOG_E("AesCtrCryptInitParam failed ret = 0x%" LOG_PUBLIC "X", ret);
974 mbedtls_cipher_free(ctrCtx);
975 HKS_FREE_PTR(ctrCtx);
976 return ret;
977 }
978
979 const struct HksCipherParam *cipherParam = (struct HksCipherParam *)(usageSpec->algParam);
980 if (cipherParam == NULL) {
981 HKS_LOG_E("Gcm cipherParam is null");
982 mbedtls_cipher_free(ctrCtx);
983 HKS_FREE_PTR(ctrCtx);
984 return HKS_FAILURE;
985 }
986
987 ret = mbedtls_cipher_set_iv(ctrCtx, cipherParam->iv.data, cipherParam->iv.size);
988 if (ret != HKS_SUCCESS) {
989 HKS_LOG_E("Mbedtls cbc pkcs7 set iv failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
990 mbedtls_cipher_free(ctrCtx);
991 HKS_FREE_PTR(ctrCtx);
992 return HKS_ERROR_CRYPTO_ENGINE_ERROR;
993 }
994 ret = mbedtls_cipher_reset(ctrCtx);
995 if (ret != HKS_SUCCESS) {
996 HKS_LOG_E("Mbedtls cbc pkcs7 reset failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
997 mbedtls_cipher_free(ctrCtx);
998 HKS_FREE_PTR(ctrCtx);
999 return HKS_ERROR_CRYPTO_ENGINE_ERROR;
1000 }
1001
1002 struct HksMbedtlsAesCtx *outCtx = (struct HksMbedtlsAesCtx *)HksMalloc(sizeof(HksMbedtlsAesCtx));
1003 if (outCtx == NULL) {
1004 mbedtls_cipher_free(ctrCtx);
1005 HKS_FREE_PTR(ctrCtx);
1006 return HKS_ERROR_MALLOC_FAIL;
1007 }
1008
1009 outCtx->mode = usageSpec->mode;
1010 outCtx->padding = usageSpec->padding;
1011 outCtx->append = (void *)ctrCtx;
1012
1013 *cryptoCtx = (void *)outCtx;
1014 return ret;
1015 }
1016
AesCtrCryptUpdate(void * cryptoCtx,const struct HksBlob * message,struct HksBlob * cipherText)1017 static int32_t AesCtrCryptUpdate(void *cryptoCtx,
1018 const struct HksBlob *message, struct HksBlob *cipherText)
1019 {
1020 struct HksMbedtlsAesCtx *aesCtx = (struct HksMbedtlsAesCtx *)cryptoCtx;
1021 mbedtls_cipher_context_t *ctrCtx = (mbedtls_cipher_context_t *)aesCtx->append;
1022 HKS_IF_NULL_LOGE_RETURN(ctrCtx, HKS_FAILURE, "CtrUpdate ctrCtx is null")
1023
1024 size_t olen;
1025 int32_t ret = mbedtls_cipher_update(ctrCtx, message->data, message->size, cipherText->data, &olen);
1026 if (ret != HKS_MBEDTLS_SUCCESS) {
1027 HKS_LOG_E("Mbedtls cipher update failed ret = 0x%" LOG_PUBLIC "X", ret);
1028 return HKS_ERROR_CRYPTO_ENGINE_ERROR;
1029 }
1030
1031 cipherText->size = olen;
1032 return ret;
1033 }
1034
AesCtrCryptFinal(void ** cryptoCtx,const struct HksBlob * message,struct HksBlob * cipherText)1035 static int32_t AesCtrCryptFinal(void **cryptoCtx, const struct HksBlob *message, struct HksBlob *cipherText)
1036 {
1037 struct HksMbedtlsAesCtx *aesCtx = (struct HksMbedtlsAesCtx *)*cryptoCtx;
1038 mbedtls_cipher_context_t *ctrCtx = (mbedtls_cipher_context_t *)aesCtx->append;
1039 if (ctrCtx == NULL) {
1040 HKS_LOG_E("CtrFinal ctrCtx is null");
1041 HKS_FREE_PTR(*cryptoCtx);
1042 return HKS_FAILURE;
1043 }
1044
1045 int32_t ret;
1046 do {
1047 size_t olen = (size_t)cipherText->size;
1048 if (message->size != 0) {
1049 ret = mbedtls_cipher_update(ctrCtx, message->data, message->size, cipherText->data, &olen);
1050 if (ret != HKS_MBEDTLS_SUCCESS) {
1051 HKS_LOG_E("Mbedtls cipher update failed ret = 0x%" LOG_PUBLIC "X", ret);
1052 ret = HKS_ERROR_CRYPTO_ENGINE_ERROR;
1053 break;
1054 }
1055 }
1056
1057 size_t finish_olen;
1058 ret = mbedtls_cipher_finish(ctrCtx, cipherText->data + olen, &finish_olen);
1059 if (ret != HKS_MBEDTLS_SUCCESS) {
1060 HKS_LOG_E("Mbedtls cipher update failed ret = 0x%" LOG_PUBLIC "X", ret);
1061 ret = HKS_ERROR_CRYPTO_ENGINE_ERROR;
1062 break;
1063 } else {
1064 cipherText->size = (uint32_t)(olen + finish_olen);
1065 }
1066 } while (0);
1067
1068 mbedtls_cipher_free(ctrCtx);
1069 HKS_FREE_PTR(aesCtx->append);
1070 HKS_FREE_PTR(*cryptoCtx);
1071 return ret;
1072 }
1073 #endif
1074
1075 #ifdef HKS_SUPPORT_AES_ECB_NOPADDING
AesEcbNoPaddingCrypt(const struct HksBlob * key,const struct HksUsageSpec * usageSpec,const struct HksBlob * message,const bool encrypt,struct HksBlob * cipherText)1076 static int32_t AesEcbNoPaddingCrypt(const struct HksBlob *key, const struct HksUsageSpec *usageSpec,
1077 const struct HksBlob *message, const bool encrypt, struct HksBlob *cipherText)
1078 {
1079 (void)usageSpec;
1080 mbedtls_cipher_context_t ctx;
1081 (void)memset_s(&ctx, sizeof(mbedtls_cipher_context_t), 0, sizeof(mbedtls_cipher_context_t));
1082 mbedtls_cipher_init(&ctx);
1083
1084 int32_t ret;
1085 do {
1086 const mbedtls_cipher_info_t *info =
1087 mbedtls_cipher_info_from_values(MBEDTLS_CIPHER_ID_AES, key->size * HKS_BITS_PER_BYTE, MBEDTLS_MODE_ECB);
1088
1089 ret = mbedtls_cipher_setup(&ctx, info);
1090 if (ret != HKS_MBEDTLS_SUCCESS) {
1091 HKS_LOG_E("Mbedtls failed ret = %" LOG_PUBLIC "d", ret);
1092 break;
1093 }
1094
1095 ret = mbedtls_cipher_setkey(
1096 &ctx, key->data, key->size * HKS_BITS_PER_BYTE, encrypt ? MBEDTLS_ENCRYPT : MBEDTLS_DECRYPT);
1097 if (ret != HKS_MBEDTLS_SUCCESS) {
1098 HKS_LOG_E("Mbedtls failed ret = %" LOG_PUBLIC "d", ret);
1099 break;
1100 }
1101
1102 size_t outLen;
1103 ret = mbedtls_cipher_crypt(&ctx, NULL, 0, message->data, message->size, cipherText->data, &outLen);
1104 if (ret != HKS_MBEDTLS_SUCCESS) {
1105 HKS_LOG_E("Mbedtls failed ret = 0x%" LOG_PUBLIC "X", ret);
1106 break;
1107 }
1108 cipherText->size = outLen;
1109
1110 mbedtls_cipher_free(&ctx);
1111 return HKS_SUCCESS;
1112 } while (0);
1113
1114 mbedtls_cipher_free(&ctx);
1115 return HKS_ERROR_CRYPTO_ENGINE_ERROR;
1116 }
1117
AesEcbNoPaddingCryptInitParam(const struct HksBlob * key,mbedtls_cipher_context_t * ecbCtx,const bool encrypt)1118 static int32_t AesEcbNoPaddingCryptInitParam(const struct HksBlob *key, mbedtls_cipher_context_t *ecbCtx,
1119 const bool encrypt)
1120 {
1121 const mbedtls_cipher_info_t *info =
1122 mbedtls_cipher_info_from_values(MBEDTLS_CIPHER_ID_AES, key->size * HKS_BITS_PER_BYTE, MBEDTLS_MODE_ECB);
1123
1124 int32_t ret = mbedtls_cipher_setup(ecbCtx, info);
1125 if (ret != HKS_MBEDTLS_SUCCESS) {
1126 HKS_LOG_E("Mbedtls cipher setup failed ret = %" LOG_PUBLIC "d", ret);
1127 return ret;
1128 }
1129
1130 ret = mbedtls_cipher_setkey(
1131 ecbCtx, key->data, key->size * HKS_BITS_PER_BYTE, encrypt ? MBEDTLS_ENCRYPT : MBEDTLS_DECRYPT);
1132 if (ret != HKS_MBEDTLS_SUCCESS) {
1133 HKS_LOG_E("Mbedtls setkey failed ret = %" LOG_PUBLIC "d", ret);
1134 return ret;
1135 }
1136
1137 ret = mbedtls_cipher_set_iv(ecbCtx, NULL, 0);
1138 if (ret != HKS_MBEDTLS_SUCCESS) {
1139 HKS_LOG_E("Mbedtls set iv failed ret = %" LOG_PUBLIC "d", ret);
1140 return ret;
1141 }
1142 return HKS_SUCCESS;
1143 }
1144
AesEcbNoPaddingCryptInit(void ** cryptoCtx,const struct HksUsageSpec * usageSpec,const struct HksBlob * key,const bool encrypt)1145 static int32_t AesEcbNoPaddingCryptInit(void **cryptoCtx, const struct HksUsageSpec *usageSpec,
1146 const struct HksBlob *key, const bool encrypt)
1147 {
1148 mbedtls_cipher_context_t *ecbCtx = (mbedtls_cipher_context_t *)HksMalloc(sizeof(mbedtls_cipher_context_t));
1149 HKS_IF_NULL_LOGE_RETURN(ecbCtx, HKS_ERROR_MALLOC_FAIL, "Ecb ecbCtx malloc fail")
1150
1151 mbedtls_cipher_init(ecbCtx);
1152
1153 int32_t ret = AesEcbNoPaddingCryptInitParam(key, ecbCtx, encrypt);
1154 if (ret != HKS_SUCCESS) {
1155 HKS_LOG_E("AesEcbNoPaddingCryptInitParam failed ret = %" LOG_PUBLIC "d", ret);
1156 mbedtls_cipher_free(ecbCtx);
1157 HKS_FREE_PTR(ecbCtx);
1158 return ret;
1159 }
1160
1161 ret = mbedtls_cipher_reset(ecbCtx);
1162 if (ret != HKS_MBEDTLS_SUCCESS) {
1163 HKS_LOG_E("Mbedtls reset failed ret = %" LOG_PUBLIC "d", ret);
1164 mbedtls_cipher_free(ecbCtx);
1165 HKS_FREE_PTR(ecbCtx);
1166 return ret;
1167 }
1168
1169 struct HksMbedtlsAesCtx *outCtx = (struct HksMbedtlsAesCtx *)HksMalloc(sizeof(HksMbedtlsAesCtx));
1170 if (outCtx == NULL) {
1171 HKS_LOG_E("initialize outCtx fail");
1172 mbedtls_cipher_free(ecbCtx);
1173 HKS_FREE_PTR(ecbCtx);
1174 return HKS_ERROR_MALLOC_FAIL;
1175 }
1176
1177 outCtx->algType = usageSpec->algType;
1178 outCtx->mode = usageSpec->mode;
1179 outCtx->padding = usageSpec->padding;
1180 outCtx->append = (void *)ecbCtx;
1181 *cryptoCtx = (void *)outCtx;
1182
1183 return ret;
1184 }
1185
AesEcbNoPaddingData(mbedtls_cipher_context_t * ecbNoPadingctx,size_t blockSize,const struct HksBlob * message,struct HksBlob * cipherText,size_t * olenTotal)1186 static int32_t AesEcbNoPaddingData(mbedtls_cipher_context_t *ecbNoPadingctx, size_t blockSize,
1187 const struct HksBlob *message, struct HksBlob *cipherText, size_t *olenTotal)
1188 {
1189 int32_t ret;
1190
1191 uint8_t *tmpMessage = (uint8_t *)HksMalloc(blockSize);
1192 HKS_IF_NULL_LOGE_RETURN(tmpMessage, HKS_ERROR_INSUFFICIENT_MEMORY, "EcbNoPaddingUpdate tmpMessage is null")
1193
1194 if (message->size <= blockSize) {
1195 (void)memset_s(tmpMessage, blockSize, 0, blockSize);
1196 (void)memcpy_s(tmpMessage, message->size, message->data, message->size);
1197 ret = mbedtls_cipher_update(ecbNoPadingctx, tmpMessage, blockSize, cipherText->data, olenTotal);
1198 if (ret != HKS_MBEDTLS_SUCCESS) {
1199 HKS_LOG_E("Mbedtls ecb no padding update failed ret = 0x%" LOG_PUBLIC "X", ret);
1200 HksFree(tmpMessage);
1201 return HKS_ERROR_CRYPTO_ENGINE_ERROR;
1202 }
1203 } else {
1204 uint32_t point = 0;
1205 while (point < message->size) {
1206 (void)memset_s(tmpMessage, blockSize, 0, blockSize);
1207 uint32_t tmpSize = (message->size - point) >= blockSize ? blockSize : (message->size - point);
1208 if (memcpy_s(tmpMessage, blockSize, message->data + point, tmpSize)) {
1209 HKS_LOG_E("copy data failed");
1210 HksFree(tmpMessage);
1211 return HKS_ERROR_INSUFFICIENT_MEMORY;
1212 }
1213 size_t olen;
1214 ret = mbedtls_cipher_update(ecbNoPadingctx, tmpMessage, tmpSize, cipherText->data + point, &olen);
1215 if (ret != HKS_MBEDTLS_SUCCESS) {
1216 HKS_LOG_E("Mbedtls ecb no padding update failed ret = 0x%" LOG_PUBLIC "X", ret);
1217 HksFree(tmpMessage);
1218 return HKS_ERROR_CRYPTO_ENGINE_ERROR;
1219 }
1220 *olenTotal += olen;
1221 point += blockSize;
1222 }
1223 }
1224 HksFree(tmpMessage);
1225 return HKS_SUCCESS;
1226 }
1227
GetAesEcbNoPaddingCtx(void * cryptoCtx,const struct HksBlob * message,struct HksBlob * cipherText,size_t * olenTotal)1228 static mbedtls_cipher_context_t *GetAesEcbNoPaddingCtx(void *cryptoCtx, const struct HksBlob *message,
1229 struct HksBlob *cipherText, size_t *olenTotal)
1230 {
1231 struct HksMbedtlsAesCtx *aesCtx = (struct HksMbedtlsAesCtx *)cryptoCtx;
1232 mbedtls_cipher_context_t *ecbNoPadingctx = (mbedtls_cipher_context_t *)aesCtx->append;
1233 HKS_IF_NULL_LOGE_RETURN(ecbNoPadingctx, NULL, "EcbNoPaddingUpdate ecbNoPadingctx is null")
1234
1235 int32_t ret = HKS_SUCCESS;
1236 do {
1237 if (message == NULL) {
1238 HKS_LOG_E("The message is null.");
1239 ret = HKS_FAILURE;
1240 break;
1241 }
1242
1243 if (message->size != 0) {
1244 size_t blockSize = mbedtls_cipher_get_block_size(ecbNoPadingctx);
1245 HKS_LOG_E("Ecb No padding update!message.size[%" LOG_PUBLIC "d] blockSize[%" LOG_PUBLIC "d]",
1246 message->size, blockSize);
1247 if (blockSize == 0 || (message->size % blockSize != 0)) {
1248 HKS_LOG_E("The size of message is invalid.");
1249 ret = HKS_ERROR_INVALID_ARGUMENT;
1250 break;
1251 }
1252
1253 ret = AesEcbNoPaddingData(ecbNoPadingctx, blockSize, message, cipherText, olenTotal);
1254 HKS_IF_NOT_SUCC_LOGE_BREAK(ret, "AesEcbNoPaddingData failed")
1255 }
1256 } while (0);
1257
1258 HKS_IF_NOT_SUCC_RETURN(ret, NULL)
1259
1260 return ecbNoPadingctx;
1261 }
1262
AesEcbNoPaddingCryptUpdate(void * cryptoCtx,const struct HksBlob * message,struct HksBlob * cipherText)1263 static int32_t AesEcbNoPaddingCryptUpdate(void *cryptoCtx, const struct HksBlob *message,
1264 struct HksBlob *cipherText)
1265 {
1266 size_t olenTotal = 0;
1267 HKS_IF_NULL_RETURN(GetAesEcbNoPaddingCtx(cryptoCtx, message, cipherText, &olenTotal), HKS_ERROR_NULL_POINTER)
1268
1269 cipherText->size = olenTotal;
1270 return HKS_SUCCESS;
1271 }
1272
AesEcbNoPaddingCryptFinal(void ** cryptoCtx,const struct HksBlob * message,struct HksBlob * cipherText)1273 static int32_t AesEcbNoPaddingCryptFinal(void **cryptoCtx, const struct HksBlob *message,
1274 struct HksBlob *cipherText)
1275 {
1276 size_t olenTotal = 0;
1277 mbedtls_cipher_context_t *ecbNoPadingctx = GetAesEcbNoPaddingCtx(*cryptoCtx, message, cipherText, &olenTotal);
1278 if (ecbNoPadingctx == NULL) {
1279 HKS_FREE_PTR(*cryptoCtx);
1280 return HKS_ERROR_NULL_POINTER;
1281 }
1282
1283 struct HksMbedtlsAesCtx *aesCtx = (struct HksMbedtlsAesCtx *)*cryptoCtx;
1284 size_t finish_olen;
1285 size_t olen = olenTotal;
1286 int32_t ret = mbedtls_cipher_finish(ecbNoPadingctx, cipherText->data + olen, &finish_olen);
1287 if (ret != HKS_MBEDTLS_SUCCESS) {
1288 HKS_LOG_E("Mbedtls ecb nopadding crypt update failed! mbedtls ret = 0x%" LOG_PUBLIC "X", ret);
1289 (void)memset_s(cipherText->data, cipherText->size, 0, cipherText->size);
1290 } else {
1291 cipherText->size = olen + finish_olen;
1292 }
1293
1294 mbedtls_cipher_free(ecbNoPadingctx);
1295 HKS_FREE_PTR(aesCtx->append);
1296 HKS_FREE_PTR(*cryptoCtx);
1297
1298 return ret;
1299 }
1300 #endif
1301
1302 #if defined(HKS_SUPPORT_AES_ECB_NOPADDING) || defined(HKS_SUPPORT_AES_ECB_PKCS7PADDING)
AesEcbCrypt(const struct HksBlob * key,const struct HksUsageSpec * usageSpec,const struct HksBlob * message,const bool encrypt,struct HksBlob * cipherText)1303 static int32_t AesEcbCrypt(const struct HksBlob *key, const struct HksUsageSpec *usageSpec,
1304 const struct HksBlob *message, const bool encrypt, struct HksBlob *cipherText)
1305 {
1306 switch (usageSpec->padding) {
1307 #ifdef HKS_SUPPORT_AES_ECB_NOPADDING
1308 case HKS_PADDING_NONE:
1309 return AesEcbNoPaddingCrypt(key, usageSpec, message, encrypt, cipherText);
1310 #endif
1311 case HKS_PADDING_PKCS7:
1312 return HKS_ERROR_NOT_SUPPORTED;
1313 default:
1314 HKS_LOG_E("Unsupport padding! mode = 0x%" LOG_PUBLIC "X", usageSpec->padding);
1315 return HKS_ERROR_INVALID_PADDING;
1316 }
1317 }
1318
AesEcbCryptInit(void ** cryptoCtx,const struct HksUsageSpec * usageSpec,const struct HksBlob * key,const bool encrypt)1319 static int32_t AesEcbCryptInit(void **cryptoCtx, const struct HksUsageSpec *usageSpec,
1320 const struct HksBlob *key, const bool encrypt)
1321 {
1322 switch (usageSpec->padding) {
1323 #ifdef HKS_SUPPORT_AES_ECB_NOPADDING
1324 case HKS_PADDING_NONE:
1325 return AesEcbNoPaddingCryptInit(cryptoCtx, usageSpec, key, encrypt);
1326 #endif
1327 case HKS_PADDING_PKCS7:
1328 return HKS_ERROR_NOT_SUPPORTED;
1329 default:
1330 HKS_LOG_E("Unsupport padding! mode = 0x%" LOG_PUBLIC "X", usageSpec->padding);
1331 return HKS_ERROR_INVALID_PADDING;
1332 }
1333 }
1334
AesEcbCryptUpdate(void * cryptoCtx,const uint8_t padding,const struct HksBlob * message,struct HksBlob * cipherText)1335 static int32_t AesEcbCryptUpdate(void *cryptoCtx, const uint8_t padding, const struct HksBlob *message,
1336 struct HksBlob *cipherText)
1337 {
1338 switch (padding) {
1339 #ifdef HKS_SUPPORT_AES_ECB_NOPADDING
1340 case HKS_PADDING_NONE:
1341 return AesEcbNoPaddingCryptUpdate(cryptoCtx, message, cipherText);
1342 #endif
1343 case HKS_PADDING_PKCS7:
1344 return HKS_ERROR_NOT_SUPPORTED;
1345 default:
1346 HKS_LOG_E("Unsupport padding! mode = 0x%" LOG_PUBLIC "X", padding);
1347 return HKS_ERROR_INVALID_PADDING;
1348 }
1349 }
1350
AesEcbCryptFinal(void ** cryptoCtx,const uint8_t padding,const struct HksBlob * message,struct HksBlob * cipherText)1351 static int32_t AesEcbCryptFinal(void **cryptoCtx, const uint8_t padding, const struct HksBlob *message,
1352 struct HksBlob *cipherText)
1353 {
1354 switch (padding) {
1355 #ifdef HKS_SUPPORT_AES_ECB_NOPADDING
1356 case HKS_PADDING_NONE:
1357 return AesEcbNoPaddingCryptFinal(cryptoCtx, message, cipherText);
1358 #endif
1359 case HKS_PADDING_PKCS7:
1360 return HKS_ERROR_NOT_SUPPORTED;
1361 default:
1362 HKS_LOG_E("Unsupport padding! mode = 0x%" LOG_PUBLIC "X", padding);
1363 return HKS_ERROR_INVALID_PADDING;
1364 }
1365 }
1366 #endif
1367
CheckKeySize(const struct HksBlob * key)1368 static int32_t CheckKeySize(const struct HksBlob *key)
1369 {
1370 if ((key->size != HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128)) && (key->size != HKS_KEY_BYTES(HKS_AES_KEY_SIZE_192)) &&
1371 (key->size != HKS_KEY_BYTES(HKS_AES_KEY_SIZE_256))) {
1372 return HKS_ERROR_INVALID_KEY_SIZE;
1373 }
1374
1375 return HKS_SUCCESS;
1376 }
1377
HksMbedtlsAesEncrypt(const struct HksBlob * key,const struct HksUsageSpec * usageSpec,const struct HksBlob * message,struct HksBlob * cipherText,struct HksBlob * tagAead)1378 int32_t HksMbedtlsAesEncrypt(const struct HksBlob *key, const struct HksUsageSpec *usageSpec,
1379 const struct HksBlob *message, struct HksBlob *cipherText, struct HksBlob *tagAead)
1380 {
1381 HKS_IF_NOT_SUCC_LOGE_RETURN(CheckKeySize(key), HKS_ERROR_INVALID_KEY_SIZE,
1382 "Invalid aes keySiz = 0x%" LOG_PUBLIC "X", key->size)
1383
1384 switch (usageSpec->mode) {
1385 #if defined(HKS_SUPPORT_AES_CBC_NOPADDING) || defined(HKS_SUPPORT_AES_CBC_PKCS7)
1386 case HKS_MODE_CBC:
1387 return AesCbcCrypt(key, usageSpec, message, true, cipherText);
1388 #endif
1389 #ifdef HKS_SUPPORT_AES_GCM
1390 case HKS_MODE_GCM:
1391 return AesEncryptGcm(key, usageSpec, message, cipherText, tagAead);
1392 #endif
1393 #ifdef HKS_SUPPORT_AES_CCM
1394 case HKS_MODE_CCM:
1395 return AesEncryptCcm(key, usageSpec, message, cipherText, tagAead);
1396 #endif
1397 #ifdef HKS_SUPPORT_AES_CTR_NOPADDING
1398 case HKS_MODE_CTR:
1399 return AesCtrCrypt(key, usageSpec, message, true, cipherText);
1400 #endif
1401 #if defined(HKS_SUPPORT_AES_ECB_NOPADDING) || defined(HKS_SUPPORT_AES_ECB_PKCS7PADDING)
1402 case HKS_MODE_ECB:
1403 return AesEcbCrypt(key, usageSpec, message, true, cipherText);
1404 #endif
1405 default:
1406 HKS_LOG_E("Unsupport key alg! mode = 0x%" LOG_PUBLIC "X", usageSpec->mode);
1407 return HKS_ERROR_INVALID_ARGUMENT;
1408 }
1409 }
1410
HksMbedtlsAesEncryptInit(void ** cryptoCtx,const struct HksBlob * key,const struct HksUsageSpec * usageSpec)1411 int32_t HksMbedtlsAesEncryptInit(void** cryptoCtx, const struct HksBlob *key, const struct HksUsageSpec *usageSpec)
1412 {
1413 if (CheckKeySize(key) != HKS_SUCCESS || cryptoCtx == NULL || usageSpec == NULL) {
1414 HKS_LOG_E("Invalid aes keySiz = 0x%" LOG_PUBLIC "X", key->size);
1415 return HKS_ERROR_INVALID_ARGUMENT;
1416 }
1417
1418 switch (usageSpec->mode) {
1419 #if defined(HKS_SUPPORT_AES_CBC_NOPADDING) || defined(HKS_SUPPORT_AES_CBC_PKCS7)
1420 case HKS_MODE_CBC:
1421 return AesCbcCryptInit(cryptoCtx, key, usageSpec, true);
1422 #endif
1423 #ifdef HKS_SUPPORT_AES_GCM
1424 case HKS_MODE_GCM:
1425 return AesEncryptGcmInit(cryptoCtx, usageSpec, key);
1426 #endif
1427 #ifdef HKS_SUPPORT_AES_CCM
1428 case HKS_MODE_CCM:
1429 return HKS_ERROR_INVALID_ARGUMENT;
1430 #endif
1431 #ifdef HKS_SUPPORT_AES_CTR_NOPADDING
1432 case HKS_MODE_CTR:
1433 return AesCtrCryptInit(cryptoCtx, usageSpec, key, true);
1434 #endif
1435 #if defined(HKS_SUPPORT_AES_ECB_NOPADDING) || defined(HKS_SUPPORT_AES_ECB_PKCS7PADDING)
1436 case HKS_MODE_ECB:
1437 return AesEcbCryptInit(cryptoCtx, usageSpec, key, true);
1438 #endif
1439 default:
1440 HKS_LOG_E("Unsupport key alg! mode = 0x%" LOG_PUBLIC "X", usageSpec->mode);
1441 return HKS_ERROR_INVALID_ARGUMENT;
1442 }
1443 }
1444
HksMbedtlsAesEncryptUpdate(void * cryptoCtx,const struct HksBlob * message,struct HksBlob * cipherText)1445 int32_t HksMbedtlsAesEncryptUpdate(void *cryptoCtx, const struct HksBlob *message, struct HksBlob *cipherText)
1446 {
1447 HKS_IF_NULL_LOGE_RETURN(cryptoCtx, HKS_ERROR_INVALID_ARGUMENT, "Mbedtls AES encrypt update param is null")
1448
1449 struct HksMbedtlsAesCtx *aesEncryptCtx = (struct HksMbedtlsAesCtx *)cryptoCtx;
1450
1451 switch (aesEncryptCtx->mode) {
1452 #if defined(HKS_SUPPORT_AES_CBC_NOPADDING) || defined(HKS_SUPPORT_AES_CBC_PKCS7)
1453 case HKS_MODE_CBC:
1454 return AesCbcCryptUpdate(cryptoCtx, aesEncryptCtx->padding, message, true, cipherText);
1455 #endif
1456 #ifdef HKS_SUPPORT_AES_GCM
1457 case HKS_MODE_GCM:
1458 return AesEncryptGcmUpdate(cryptoCtx, aesEncryptCtx->padding, message, cipherText);
1459 #endif
1460 #ifdef HKS_SUPPORT_AES_CCM
1461 case HKS_MODE_CCM:
1462 return HKS_ERROR_INVALID_ARGUMENT;
1463 #endif
1464 #ifdef HKS_SUPPORT_AES_CTR_NOPADDING
1465 case HKS_MODE_CTR:
1466 return AesCtrCryptUpdate(cryptoCtx, message, cipherText);
1467 #endif
1468 #if defined(HKS_SUPPORT_AES_ECB_NOPADDING) || defined(HKS_SUPPORT_AES_ECB_PKCS7PADDING)
1469 case HKS_MODE_ECB:
1470 return AesEcbCryptUpdate(cryptoCtx, aesEncryptCtx->padding, message, cipherText);
1471 #endif
1472 default:
1473 HKS_LOG_E("Unsupport key alg! mode = 0x%" LOG_PUBLIC "X", aesEncryptCtx->mode);
1474 return HKS_ERROR_INVALID_ARGUMENT;
1475 }
1476 }
1477
HksMbedtlsAesEncryptFinal(void ** cryptoCtx,const struct HksBlob * message,struct HksBlob * cipherText,struct HksBlob * tagAead)1478 int32_t HksMbedtlsAesEncryptFinal(void** cryptoCtx, const struct HksBlob *message, struct HksBlob *cipherText,
1479 struct HksBlob *tagAead)
1480 {
1481 struct HksMbedtlsAesCtx *aesEncryptCtx = (struct HksMbedtlsAesCtx *)*cryptoCtx;
1482
1483 switch (aesEncryptCtx->mode) {
1484 #if defined(HKS_SUPPORT_AES_CBC_NOPADDING) || defined(HKS_SUPPORT_AES_CBC_PKCS7)
1485 case HKS_MODE_CBC:
1486 return AesCbcCryptFinal(cryptoCtx, aesEncryptCtx->padding, message, true, cipherText);
1487 #endif
1488 #ifdef HKS_SUPPORT_AES_GCM
1489 case HKS_MODE_GCM:
1490 return AesEncryptGcmFinal(cryptoCtx, message, cipherText, tagAead);
1491 #endif
1492 #ifdef HKS_SUPPORT_AES_CCM
1493 case HKS_MODE_CCM:
1494 return HKS_ERROR_INVALID_ARGUMENT;
1495 #endif
1496 #ifdef HKS_SUPPORT_AES_CTR_NOPADDING
1497 case HKS_MODE_CTR:
1498 return AesCtrCryptFinal(cryptoCtx, message, cipherText);
1499 #endif
1500 #if defined(HKS_SUPPORT_AES_ECB_NOPADDING) || defined(HKS_SUPPORT_AES_ECB_PKCS7PADDING)
1501 case HKS_MODE_ECB:
1502 return AesEcbCryptFinal(cryptoCtx, aesEncryptCtx->padding, message, cipherText);
1503 #endif
1504 default:
1505 HKS_LOG_E("Unsupport key alg! mode = 0x%" LOG_PUBLIC "X", aesEncryptCtx->mode);
1506 return HKS_ERROR_INVALID_ARGUMENT;
1507 }
1508 }
1509
HksMbedtlsAesDecrypt(const struct HksBlob * key,const struct HksUsageSpec * usageSpec,const struct HksBlob * message,struct HksBlob * cipherText)1510 int32_t HksMbedtlsAesDecrypt(const struct HksBlob *key, const struct HksUsageSpec *usageSpec,
1511 const struct HksBlob *message, struct HksBlob *cipherText)
1512 {
1513 HKS_IF_NOT_SUCC_LOGE_RETURN(CheckKeySize(key), HKS_ERROR_INVALID_KEY_SIZE,
1514 "Invalid aes keySize = 0x%" LOG_PUBLIC "X", key->size)
1515
1516 switch (usageSpec->mode) {
1517 #if defined(HKS_SUPPORT_AES_CBC_NOPADDING) || defined(HKS_SUPPORT_AES_CBC_PKCS7)
1518 case HKS_MODE_CBC:
1519 return AesCbcCrypt(key, usageSpec, message, false, cipherText);
1520 #endif
1521 #ifdef HKS_SUPPORT_AES_GCM
1522 case HKS_MODE_GCM:
1523 return AesDecryptGcm(key, usageSpec, message, cipherText);
1524 #endif
1525 #ifdef HKS_SUPPORT_AES_CCM
1526 case HKS_MODE_CCM:
1527 return AesDecryptCcm(key, usageSpec, message, cipherText);
1528 #endif
1529 #ifdef HKS_SUPPORT_AES_CTR_NOPADDING
1530 case HKS_MODE_CTR:
1531 return AesCtrCrypt(key, usageSpec, message, false, cipherText);
1532 #endif
1533 #if defined(HKS_SUPPORT_AES_ECB_NOPADDING) || defined(HKS_SUPPORT_AES_ECB_PKCS7PADDING)
1534 case HKS_MODE_ECB:
1535 return AesEcbCrypt(key, usageSpec, message, false, cipherText);
1536 #endif
1537 default:
1538 HKS_LOG_E("Unsupport key alg! mode = 0x%" LOG_PUBLIC "X", usageSpec->mode);
1539 return HKS_ERROR_INVALID_ARGUMENT;
1540 }
1541 }
1542
HksMbedtlsAesDecryptInit(void ** cryptoCtx,const struct HksBlob * key,const struct HksUsageSpec * usageSpec)1543 int32_t HksMbedtlsAesDecryptInit(void **cryptoCtx, const struct HksBlob *key, const struct HksUsageSpec *usageSpec)
1544 {
1545 HKS_IF_NOT_SUCC_LOGE_RETURN(CheckKeySize(key), HKS_ERROR_INVALID_ARGUMENT,
1546 "Invalid aes keySize = 0x%" LOG_PUBLIC "X", key->size)
1547
1548 switch (usageSpec->mode) {
1549 #if defined(HKS_SUPPORT_AES_CBC_NOPADDING) || defined(HKS_SUPPORT_AES_CBC_PKCS7)
1550 case HKS_MODE_CBC:
1551 return AesCbcCryptInit(cryptoCtx, key, usageSpec, false);
1552 #endif
1553 #ifdef HKS_SUPPORT_AES_GCM
1554 case HKS_MODE_GCM:
1555 return AesDecryptGcmInit(cryptoCtx, key, usageSpec);
1556 #endif
1557 #ifdef HKS_SUPPORT_AES_CCM
1558 case HKS_MODE_CCM:
1559 return HKS_ERROR_INVALID_ARGUMENT;
1560 #endif
1561 #ifdef HKS_SUPPORT_AES_CTR_NOPADDING
1562 case HKS_MODE_CTR:
1563 return AesCtrCryptInit(cryptoCtx, usageSpec, key, false);
1564 #endif
1565 #if defined(HKS_SUPPORT_AES_ECB_NOPADDING) || defined(HKS_SUPPORT_AES_ECB_PKCS7PADDING)
1566 case HKS_MODE_ECB:
1567 return AesEcbCryptInit(cryptoCtx, usageSpec, key, false);
1568 #endif
1569 default:
1570 HKS_LOG_E("Unsupport key alg! mode = 0x%" LOG_PUBLIC "X", usageSpec->mode);
1571 return HKS_ERROR_INVALID_ARGUMENT;
1572 }
1573 }
1574
HksMbedtlsAesDecryptUpdate(void * cryptoCtx,const struct HksBlob * message,struct HksBlob * cipherText)1575 int32_t HksMbedtlsAesDecryptUpdate(void *cryptoCtx, const struct HksBlob *message, struct HksBlob *cipherText)
1576 {
1577 struct HksMbedtlsAesCtx *aesDecryptCtx = (struct HksMbedtlsAesCtx *)cryptoCtx;
1578 switch (aesDecryptCtx->mode) {
1579 #if defined(HKS_SUPPORT_AES_CBC_NOPADDING) || defined(HKS_SUPPORT_AES_CBC_PKCS7)
1580 case HKS_MODE_CBC:
1581 return AesCbcCryptUpdate(cryptoCtx, aesDecryptCtx->padding, message, false, cipherText);
1582 #endif
1583 #ifdef HKS_SUPPORT_AES_GCM
1584 case HKS_MODE_GCM:
1585 return AesDecryptGcmUpdate(cryptoCtx, message, cipherText);
1586 #endif
1587 #ifdef HKS_SUPPORT_AES_CCM
1588 case HKS_MODE_CCM:
1589 return HKS_ERROR_INVALID_ARGUMENT;
1590 #endif
1591 #ifdef HKS_SUPPORT_AES_CTR_NOPADDING
1592 case HKS_MODE_CTR:
1593 return AesCtrCryptUpdate(cryptoCtx, message, cipherText);
1594 #endif
1595 #if defined(HKS_SUPPORT_AES_ECB_NOPADDING) || defined(HKS_SUPPORT_AES_ECB_PKCS7PADDING)
1596 case HKS_MODE_ECB:
1597 return AesEcbCryptUpdate(cryptoCtx, aesDecryptCtx->padding, message, cipherText);
1598 #endif
1599 default:
1600 HKS_LOG_E("Unsupport key alg! mode = 0x%" LOG_PUBLIC "X", aesDecryptCtx->mode);
1601 return HKS_ERROR_INVALID_ARGUMENT;
1602 }
1603 }
1604
HksMbedtlsAesDecryptFinal(void ** cryptoCtx,const struct HksBlob * message,struct HksBlob * cipherText,struct HksBlob * tagAead)1605 int32_t HksMbedtlsAesDecryptFinal(void **cryptoCtx, const struct HksBlob *message, struct HksBlob *cipherText,
1606 struct HksBlob *tagAead)
1607 {
1608 struct HksMbedtlsAesCtx *aesDecryptCtx = (struct HksMbedtlsAesCtx *)*cryptoCtx;
1609
1610 switch (aesDecryptCtx->mode) {
1611 #if defined(HKS_SUPPORT_AES_CBC_NOPADDING) || defined(HKS_SUPPORT_AES_CBC_PKCS7)
1612 case HKS_MODE_CBC:
1613 return AesCbcCryptFinal(cryptoCtx, aesDecryptCtx->padding, message, false, cipherText);
1614 #endif
1615 #ifdef HKS_SUPPORT_AES_GCM
1616 case HKS_MODE_GCM:
1617 return AesDecryptGcmFinal(cryptoCtx, message, cipherText, tagAead);
1618 #endif
1619 #ifdef HKS_SUPPORT_AES_CCM
1620 case HKS_MODE_CCM:
1621 return HKS_ERROR_INVALID_ARGUMENT;
1622 #endif
1623 #ifdef HKS_SUPPORT_AES_CTR_NOPADDING
1624 case HKS_MODE_CTR:
1625 return AesCtrCryptFinal(cryptoCtx, message, cipherText);
1626 #endif
1627 #if defined(HKS_SUPPORT_AES_ECB_NOPADDING) || defined(HKS_SUPPORT_AES_ECB_PKCS7PADDING)
1628 case HKS_MODE_ECB:
1629 return AesEcbCryptFinal(cryptoCtx, aesDecryptCtx->padding, message, cipherText);
1630 #endif
1631 default:
1632 HKS_LOG_E("Unsupport key alg! mode = 0x%" LOG_PUBLIC "X", aesDecryptCtx->mode);
1633 return HKS_ERROR_INVALID_ARGUMENT;
1634 }
1635 }
1636
HksMbedtlsAesCryptoInit(void ** cryptoCtx,const struct HksBlob * key,const struct HksUsageSpec * usageSpec,const bool encrypt)1637 int32_t HksMbedtlsAesCryptoInit(void **cryptoCtx, const struct HksBlob *key, const struct HksUsageSpec *usageSpec,
1638 const bool encrypt)
1639 {
1640 if (encrypt) {
1641 return HksMbedtlsAesEncryptInit(cryptoCtx, key, usageSpec);
1642 } else {
1643 return HksMbedtlsAesDecryptInit(cryptoCtx, key, usageSpec);
1644 }
1645 }
1646
HksMbedtlsAesCryptoUpdate(void * cryptoCtx,const struct HksBlob * message,struct HksBlob * cipherText,const bool encrypt)1647 int32_t HksMbedtlsAesCryptoUpdate(void *cryptoCtx, const struct HksBlob *message,
1648 struct HksBlob *cipherText, const bool encrypt)
1649 {
1650 if (encrypt) {
1651 return HksMbedtlsAesEncryptUpdate(cryptoCtx, message, cipherText);
1652 } else {
1653 return HksMbedtlsAesDecryptUpdate(cryptoCtx, message, cipherText);
1654 }
1655 }
1656
HksMbedtlsAesCryptoFinal(void ** cryptoCtx,const struct HksBlob * message,struct HksBlob * cipherText,struct HksBlob * tagAead,const bool encrypt)1657 int32_t HksMbedtlsAesCryptoFinal(void **cryptoCtx, const struct HksBlob *message,
1658 struct HksBlob *cipherText, struct HksBlob *tagAead, const bool encrypt)
1659 {
1660 if (encrypt) {
1661 return HksMbedtlsAesEncryptFinal(cryptoCtx, message, cipherText, tagAead);
1662 } else {
1663 return HksMbedtlsAesDecryptFinal(cryptoCtx, message, cipherText, tagAead);
1664 }
1665 }
1666
1667 #if defined(HKS_SUPPORT_AES_CBC_NOPADDING) || defined(HKS_SUPPORT_AES_CBC_PKCS7)
HksMbedtlsAesHalModecbcFreeCtx(void ** cryptCtx)1668 void HksMbedtlsAesHalModecbcFreeCtx(void **cryptCtx)
1669 {
1670 if (cryptCtx == NULL || *cryptCtx == NULL) {
1671 HKS_LOG_E("FreeCtx cryptCtx param is null");
1672 return;
1673 }
1674
1675 struct HksMbedtlsAesCtx *mbedtlsAesCtx = (struct HksMbedtlsAesCtx *)*cryptCtx;
1676 if (mbedtlsAesCtx->padding == HKS_PADDING_NONE) {
1677 if (mbedtlsAesCtx->append != NULL) {
1678 mbedtls_aes_free((mbedtls_aes_context *)(mbedtlsAesCtx->append));
1679 HKS_FREE_PTR(mbedtlsAesCtx->append);
1680 }
1681 } else if (mbedtlsAesCtx->padding == HKS_PADDING_PKCS7) {
1682 if (mbedtlsAesCtx->append != NULL) {
1683 mbedtls_cipher_free((mbedtls_cipher_context_t *)mbedtlsAesCtx->append);
1684 HKS_FREE_PTR(mbedtlsAesCtx->append);
1685 }
1686 }
1687 }
1688 #endif
1689 #ifdef HKS_SUPPORT_AES_GCM
HksMbedtlsAesHalModegcmFreeCtx(void ** cryptCtx)1690 void HksMbedtlsAesHalModegcmFreeCtx(void **cryptCtx)
1691 {
1692 if (cryptCtx == NULL || *cryptCtx == NULL) {
1693 HKS_LOG_E("FreeCtx cryptCtx param is null");
1694 return;
1695 }
1696
1697 struct HksMbedtlsAesCtx *mbedtlsAesCtx = (struct HksMbedtlsAesCtx *)*cryptCtx;
1698 if (mbedtlsAesCtx->append != NULL) {
1699 mbedtls_gcm_free((mbedtls_gcm_context *)mbedtlsAesCtx->append);
1700 HKS_FREE_PTR(mbedtlsAesCtx->append);
1701 }
1702 }
1703 #endif
1704
1705 #ifdef HKS_SUPPORT_AES_CTR_NOPADDING
HksMbedtlsAesHalModectrFreeCtx(void ** cryptCtx)1706 void HksMbedtlsAesHalModectrFreeCtx(void **cryptCtx)
1707 {
1708 if (cryptCtx == NULL || *cryptCtx == NULL) {
1709 HKS_LOG_E("FreeCtx cryptCtx param is null");
1710 return;
1711 }
1712
1713 struct HksMbedtlsAesCtx *mbedtlsAesCtx = (struct HksMbedtlsAesCtx *)*cryptCtx;
1714 if (mbedtlsAesCtx->append != NULL) {
1715 mbedtls_cipher_free((mbedtls_cipher_context_t *)mbedtlsAesCtx->append);
1716 HKS_FREE_PTR(mbedtlsAesCtx->append);
1717 }
1718 }
1719 #endif
1720
1721 #if defined(HKS_SUPPORT_AES_ECB_NOPADDING) || defined(HKS_SUPPORT_AES_ECB_PKCS7PADDING)
HksMbedtlsAesHalModeecbFreeCtx(void ** cryptCtx)1722 void HksMbedtlsAesHalModeecbFreeCtx(void **cryptCtx)
1723 {
1724 if (cryptCtx == NULL || *cryptCtx == NULL) {
1725 HKS_LOG_E("FreeCtx cryptCtx param is null");
1726 return;
1727 }
1728
1729 struct HksMbedtlsAesCtx *mbedtlsAesCtx = (struct HksMbedtlsAesCtx *)*cryptCtx;
1730 if (mbedtlsAesCtx->padding == HKS_PADDING_NONE) {
1731 if (mbedtlsAesCtx->append != NULL) {
1732 mbedtls_cipher_free((mbedtls_cipher_context_t *)mbedtlsAesCtx->append);
1733 HKS_FREE_PTR(mbedtlsAesCtx->append);
1734 }
1735 }
1736 }
1737 #endif
1738
HksMbedtlsAesHalFreeCtx(void ** cryptCtx)1739 void HksMbedtlsAesHalFreeCtx(void **cryptCtx)
1740 {
1741 if (cryptCtx == NULL || *cryptCtx == NULL) {
1742 HKS_LOG_E("FreeCtx param context null");
1743 return;
1744 }
1745
1746 struct HksMbedtlsAesCtx *mbedtlsAesCtx = (struct HksMbedtlsAesCtx *)*cryptCtx;
1747 switch (mbedtlsAesCtx->mode) {
1748 #if defined(HKS_SUPPORT_AES_CBC_NOPADDING) || defined(HKS_SUPPORT_AES_CBC_PKCS7)
1749 case HKS_MODE_CBC:
1750 HksMbedtlsAesHalModecbcFreeCtx(cryptCtx);
1751 break;
1752 #endif
1753 #ifdef HKS_SUPPORT_AES_GCM
1754 case HKS_MODE_GCM:
1755 HksMbedtlsAesHalModegcmFreeCtx(cryptCtx);
1756 break;
1757 #endif
1758 #ifdef HKS_SUPPORT_AES_CCM
1759 case HKS_MODE_CCM:
1760 break;
1761 #endif
1762 #ifdef HKS_SUPPORT_AES_CTR_NOPADDING
1763 case HKS_MODE_CTR:
1764 HksMbedtlsAesHalModectrFreeCtx(cryptCtx);
1765 break;
1766 #endif
1767 #if defined(HKS_SUPPORT_AES_ECB_NOPADDING) || defined(HKS_SUPPORT_AES_ECB_PKCS7PADDING)
1768 case HKS_MODE_ECB:
1769 HksMbedtlsAesHalModeecbFreeCtx(cryptCtx);
1770 break;
1771 #endif
1772 default:
1773 HKS_LOG_E("Unsupport key alg! mode = 0x%" LOG_PUBLIC "X", mbedtlsAesCtx->mode);
1774 break;
1775 }
1776
1777 HKS_FREE_PTR(*cryptCtx);
1778 }
1779 #endif /* HKS_SUPPORT_AES_C */
1780