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