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