1 /*
2 * Copyright (c) 2021-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 #include <gtest/gtest.h>
17 #include <iostream>
18
19 #include "hks_ability.h"
20 #include "hks_config.h"
21 #include "hks_crypto_hal.h"
22 #include "hks_crypto_hal_common.h"
23 #include "hks_mem.h"
24
25 using namespace testing::ext;
26 namespace OHOS {
27 namespace Security {
28 namespace Huks {
29 namespace UnitTest {
30 const uint32_t IV_SIZE = 20;
31 const uint32_t ERROR_KEY_SIZE = 2000;
32 class HksCryptoHalApiMbedtls : public HksCryptoHalCommon, public testing::Test {
33 public:
34 static void SetUpTestCase(void);
35 static void TearDownTestCase(void);
36 void SetUp();
37 void TearDown();
38 };
39
SetUpTestCase(void)40 void HksCryptoHalApiMbedtls::SetUpTestCase(void)
41 {
42 }
43
TearDownTestCase(void)44 void HksCryptoHalApiMbedtls::TearDownTestCase(void)
45 {
46 }
47
SetUp()48 void HksCryptoHalApiMbedtls::SetUp()
49 {
50 EXPECT_EQ(HksCryptoAbilityInit(), 0);
51 }
52
TearDown()53 void HksCryptoHalApiMbedtls::TearDown()
54 {
55 }
56
57 /**
58 * @tc.number : HksCryptoHalApiMbedtls_001
59 * @tc.name : HksCryptoHalApiMbedtls_001
60 * @tc.desc : Using HksCryptoHalGenerateKey Generate key -- key is NULL.
61 */
62 HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_001, Function | SmallTest | Level0)
63 {
64 int32_t ret;
65
66 HksKeySpec spec = {
67 .algType = HKS_ALG_AES,
68 .keyLen = HKS_AES_KEY_SIZE_128,
69 .algParam = nullptr,
70 };
71
72 ret = HksCryptoHalGenerateKey(&spec, NULL);
73 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
74 }
75
76 /**
77 * @tc.number : HksCryptoHalApiMbedtls_002
78 * @tc.name : HksCryptoHalApiMbedtls_002
79 * @tc.desc : Using HksCryptoHalGenerateKey Generate key -- algType is invalid.
80 */
81 HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_002, Function | SmallTest | Level0)
82 {
83 int32_t ret;
84
85 HksKeySpec spec = {
86 .algType = 0xffff,
87 .keyLen = 0,
88 .algParam = nullptr,
89 };
90
91 HksBlob key = {};
92
93 ret = HksCryptoHalGenerateKey(&spec, &key);
94 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
95 }
96
97 /**
98 * @tc.number : HksCryptoHalApiMbedtls_003
99 * @tc.name : HksCryptoHalApiMbedtls_003
100 * @tc.desc : Using HksCryptoHalGenerateKey Generate key -- algType is AES keyLen is invalid.
101 */
102 HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_003, Function | SmallTest | Level0)
103 {
104 int32_t ret;
105
106 HksKeySpec spec = {
107 .algType = HKS_ALG_AES,
108 .keyLen = 0,
109 .algParam = nullptr,
110 };
111
112 HksBlob key = {};
113
114 ret = HksCryptoHalGenerateKey(&spec, &key);
115 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
116 }
117
118 /**
119 * @tc.number : HksCryptoHalApiMbedtls_004
120 * @tc.name : HksCryptoHalApiMbedtls_004
121 * @tc.desc : Using HksCryptoHalEncrypt -- parameter is invalid.
122 */
123 HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_004, Function | SmallTest | Level0)
124 {
125 int32_t ret;
126
127 HksBlob key = { .size = 0, .data = nullptr };
128 HksUsageSpec spec = { .algType = 0xffff };
129 HksBlob message = { .size = 0, .data = nullptr };
130 HksBlob cipherText = { .size = 0, .data = nullptr };
131 HksBlob tagAead = { .size = 0, .data = nullptr };
132 uint8_t buff[1] = {0};
133
134 ret = HksCryptoHalEncrypt(&key, nullptr, &message, &cipherText, &tagAead);
135 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
136
137 key = { .size = 1, .data = buff };
138 ret = HksCryptoHalEncrypt(&key, nullptr, &message, &cipherText, &tagAead);
139 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
140
141 message = { .size = 1, .data = buff };
142 ret = HksCryptoHalEncrypt(&key, nullptr, &message, &cipherText, &tagAead);
143 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
144
145 cipherText = { .size = 1, .data = buff };
146 ret = HksCryptoHalEncrypt(&key, nullptr, &message, &cipherText, &tagAead);
147 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
148
149 ret = HksCryptoHalEncrypt(&key, &spec, &message, &cipherText, &tagAead);
150 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
151 }
152
153 /**
154 * @tc.number : HksCryptoHalApiMbedtls_005
155 * @tc.name : HksCryptoHalApiMbedtls_005
156 * @tc.desc : Using HksCryptoHalDecrypt -- parameter is invalid.
157 */
158 HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_005, Function | SmallTest | Level0)
159 {
160 int32_t ret;
161
162 HksBlob key = { .size = 0, .data = nullptr };
163 HksUsageSpec spec = { .algType = 0xffff };
164 HksBlob message = { .size = 0, .data = nullptr };
165 HksBlob cipherText = { .size = 0, .data = nullptr };
166 uint8_t buff[1] = {0};
167
168 ret = HksCryptoHalDecrypt(&key, nullptr, &message, &cipherText);
169 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
170
171 key = { .size = 1, .data = buff };
172 ret = HksCryptoHalDecrypt(&key, nullptr, &message, &cipherText);
173 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
174
175 message = { .size = 1, .data = buff };
176 ret = HksCryptoHalDecrypt(&key, nullptr, &message, &cipherText);
177 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
178
179 cipherText = { .size = 1, .data = buff };
180 ret = HksCryptoHalDecrypt(&key, nullptr, &message, &cipherText);
181 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
182
183 ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText);
184 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
185 }
186
187 /**
188 * @tc.number : HksCryptoHalApiMbedtls_006
189 * @tc.name : HksCryptoHalApiMbedtls_006
190 * @tc.desc : Using HksCryptoHalEncrypt -- AES encrypt parameter is invalid.
191 */
192 HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_006, Function | SmallTest | Level0)
193 {
194 int32_t ret;
195
196 uint8_t buff[HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128)] = {0};
197 HksBlob key = { .size = 1, .data = buff };
198 HksUsageSpec spec = { .algType = HKS_ALG_AES, .mode = 0xffff };
199 HksBlob message = { .size = 1, .data = buff };
200 HksBlob cipherText = { .size = 1, .data = buff };
201 HksBlob tagAead = { .size = 1, .data = buff };
202
203 ret = HksCryptoHalEncrypt(&key, &spec, &message, &cipherText, &tagAead);
204 EXPECT_EQ(HKS_ERROR_INVALID_KEY_SIZE, ret);
205
206 key.size = sizeof(buff);
207 ret = HksCryptoHalEncrypt(&key, &spec, &message, &cipherText, &tagAead);
208 EXPECT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
209 }
210
211 /**
212 * @tc.number : HksCryptoHalApiMbedtls_007
213 * @tc.name : HksCryptoHalApiMbedtls_007
214 * @tc.desc : Using HksCryptoHalDecrypt -- AES decrypt parameter is invalid.
215 */
216 HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_007, Function | SmallTest | Level0)
217 {
218 int32_t ret;
219
220 uint8_t buff[HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128)] = {0};
221 HksBlob key = { .size = 1, .data = buff };
222 HksUsageSpec spec = { .algType = HKS_ALG_AES, .mode = 0xffff };
223 HksBlob message = { .size = 1, .data = buff };
224 HksBlob cipherText = { .size = 1, .data = buff };
225
226 ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText);
227 EXPECT_EQ(HKS_ERROR_INVALID_KEY_SIZE, ret);
228
229 key.size = sizeof(buff);
230 ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText);
231 EXPECT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
232 }
233
234 /**
235 * @tc.number : HksCryptoHalApiMbedtls_008
236 * @tc.name : HksCryptoHalApiMbedtls_008
237 * @tc.desc : Using HksCryptoHalDecrypt -- AES decrypt padding is invalid.
238 */
239 HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_008, Function | SmallTest | Level0)
240 {
241 int32_t ret;
242
243 uint8_t buff[HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128)] = {0};
244 HksBlob key = { .size = sizeof(buff), .data = buff };
245 HksUsageSpec spec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, .padding = HKS_PADDING_PSS };
246 HksBlob message = { .size = 1, .data = buff };
247 HksBlob cipherText = { .size = 1, .data = buff };
248
249 ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText);
250 EXPECT_EQ(HKS_ERROR_INVALID_PADDING, ret);
251
252 spec.mode = HKS_MODE_ECB;
253 ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText);
254 EXPECT_EQ(HKS_ERROR_INVALID_PADDING, ret);
255 }
256
257 /**
258 * @tc.number : HksCryptoHalApiMbedtls_009
259 * @tc.name : HksCryptoHalApiMbedtls_009
260 * @tc.desc : Using HksCryptoHalDecrypt -- AES decrypt CBC mode nopadding with large iv.
261 */
262 HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_009, Function | SmallTest | Level0)
263 {
264 int32_t ret;
265
266 uint8_t buff[HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128)] = {0};
267 uint8_t iv[IV_SIZE] = {0};
268 HksBlob key = { .size = sizeof(buff), .data = buff };
269 HksCipherParam cipherParam = { .iv = { .size = sizeof(iv), .data = iv } };
270 HksUsageSpec spec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, .padding = HKS_PADDING_NONE };
271 HksBlob message = { .size = 1, .data = buff };
272 HksBlob cipherText = { .size = 1, .data = buff };
273
274 spec.algParam = &cipherParam;
275 ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText);
276 EXPECT_EQ(HKS_ERROR_INVALID_IV, ret);
277 }
278
279 /**
280 * @tc.number : HksCryptoHalApiMbedtls_010
281 * @tc.name : HksCryptoHalApiMbedtls_010
282 * @tc.desc : Using HksCryptoHalDecrypt -- RSA decrypt key is invalid.
283 */
284 HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_010, Function | SmallTest | Level0)
285 {
286 int32_t ret;
287
288 uint8_t buff[HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128)] = {0};
289 uint8_t iv[IV_SIZE] = {0};
290 HksBlob key;
291 HksCipherParam cipherParam = { .iv = { .size = sizeof(iv), .data = iv } };
292 HksUsageSpec spec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE };
293 HksBlob message = { .size = 1, .data = buff };
294 HksBlob cipherText = { .size = 1, .data = buff };
295 spec.algParam = &cipherParam;
296
297 uint32_t keyLen = sizeof(KeyMaterialRsa) + HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096) +
298 HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096) +
299 (HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096) + HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096));
300 key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) };
301 ASSERT_NE(key.data, nullptr);
302 KeyMaterialRsa *keyMaterial = (KeyMaterialRsa *)key.data;
303 keyMaterial->keyAlg = HKS_ALG_RSA;
304 keyMaterial->keySize = HKS_RSA_KEY_SIZE_4096;
305 keyMaterial->nSize = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096);
306 keyMaterial->eSize = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096);
307 keyMaterial->dSize = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096) + HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096);
308
309 ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText);
310 EXPECT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
311
312 key.size -= HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096);
313 keyMaterial->dSize = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096);
314 keyMaterial->keySize = ERROR_KEY_SIZE;
315 ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText);
316 EXPECT_EQ(HKS_ERROR_INVALID_KEY_SIZE, ret);
317
318 key.size = sizeof(KeyMaterialRsa);
319 keyMaterial->keySize = HKS_RSA_KEY_SIZE_4096;
320 ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText);
321 EXPECT_EQ(HKS_ERROR_INVALID_KEY_INFO, ret);
322 HKS_FREE_BLOB(key);
323 }
324
325 /**
326 * @tc.number : HksCryptoHalApiMbedtls_011
327 * @tc.name : HksCryptoHalApiMbedtls_011
328 * @tc.desc : Using HksMbedtlsGetRsaPubKey -- RSA in/out key is invalid.
329 */
330 HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_011, Function | SmallTest | Level0)
331 {
332 int32_t ret;
333
334 HksKeySpec spec = {
335 .algType = HKS_ALG_RSA,
336 .keyLen = HKS_RSA_KEY_SIZE_2048,
337 };
338 HksBlob key = { .size = 0, .data = NULL };
339
340 ret = HksCryptoHalGenerateKey(&spec, &key);
341 ASSERT_EQ(ret, HKS_SUCCESS);
342
343 KeyMaterialRsa *keyMaterial = (KeyMaterialRsa *)key.data;
344
345 uint32_t keyOutLen = sizeof(KeyMaterialRsa) + keyMaterial->nSize + keyMaterial->eSize;
346 HksBlob keyOut = { .size = sizeof(KeyMaterialRsa), .data = (uint8_t *)HksMalloc(keyOutLen) };
347 ASSERT_NE(keyOut.data, nullptr);
348
349 keyMaterial->keySize = ERROR_KEY_SIZE;
350 ret = HksCryptoHalGetPubKey(&key, &keyOut);
351 ASSERT_EQ(ret, HKS_ERROR_INVALID_KEY_SIZE);
352
353 keyMaterial->keySize = HKS_RSA_KEY_SIZE_2048;
354 ret = HksCryptoHalGetPubKey(&key, &keyOut);
355 ASSERT_EQ(ret, HKS_ERROR_BUFFER_TOO_SMALL);
356 HKS_FREE_BLOB(keyOut);
357 HKS_FREE_BLOB(key);
358 }
359
360 /**
361 * @tc.number : HksCryptoHalApiMbedtls_012
362 * @tc.name : HksCryptoHalApiMbedtls_012
363 * @tc.desc : Using HksMbedtlsEccGenerateKey -- key size is invalid.
364 */
365 HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_012, Function | SmallTest | Level0)
366 {
367 int32_t ret;
368
369 HksKeySpec spec = {
370 .algType = HKS_ALG_ECC,
371 .keyLen = HKS_ECC_KEY_SIZE_256,
372 };
373 HksBlob key = { .size = 0, .data = NULL };
374
375 spec.keyLen += 1;
376 ret = HksCryptoHalGenerateKey(&spec, &key);
377 ASSERT_EQ(ret, HKS_ERROR_INVALID_KEY_SIZE);
378 }
379
380 /**
381 * @tc.number : HksCryptoHalApiMbedtls_013
382 * @tc.name : HksCryptoHalApiMbedtls_013
383 * @tc.desc : Using HksMbedtlsGetEccPubKey -- Ecc in/out key is invalid.
384 */
385 HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_013, Function | SmallTest | Level0)
386 {
387 int32_t ret;
388
389 HksKeySpec spec = {
390 .algType = HKS_ALG_ECC,
391 .keyLen = HKS_ECC_KEY_SIZE_256,
392 };
393 HksBlob key = { .size = 0, .data = NULL };
394
395 ret = HksCryptoHalGenerateKey(&spec, &key);
396 ASSERT_EQ(ret, HKS_SUCCESS);
397
398 KeyMaterialEcc *keyMaterial = (KeyMaterialEcc *)key.data;
399
400 uint32_t keyOutLen = sizeof(KeyMaterialEcc) + keyMaterial->xSize + keyMaterial->ySize;
401 HksBlob keyOut = { .size = sizeof(KeyMaterialEcc), .data = (uint8_t *)HksMalloc(keyOutLen) };
402 ASSERT_NE(keyOut.data, nullptr);
403
404 ret = HksCryptoHalGetPubKey(&key, &keyOut);
405 ASSERT_EQ(ret, HKS_ERROR_BUFFER_TOO_SMALL);
406
407 key.size -= 1;
408 ret = HksCryptoHalGetPubKey(&key, &keyOut);
409 ASSERT_EQ(ret, HKS_ERROR_INVALID_KEY_INFO);
410 key.size += 1;
411
412 keyMaterial->zSize = 0xFFFF;
413 ret = HksCryptoHalGetPubKey(&key, &keyOut);
414 ASSERT_EQ(ret, HKS_ERROR_INVALID_ARGUMENT);
415
416 keyMaterial->keySize += 1;
417 ret = HksCryptoHalGetPubKey(&key, &keyOut);
418 ASSERT_EQ(ret, HKS_ERROR_INVALID_KEY_SIZE);
419
420 HKS_FREE_BLOB(keyOut);
421 HKS_FREE_BLOB(key);
422 }
423
424 #ifdef HKS_SUPPORT_DH_C
425 /**
426 * @tc.number : HksCryptoHalApiMbedtls_014
427 * @tc.name : HksCryptoHalApiMbedtls_014
428 * @tc.desc : Using HksMbedtlsDhGenerateKey -- key size is invalid.
429 */
430 HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_014, Function | SmallTest | Level0)
431 {
432 int32_t ret;
433
434 HksKeySpec spec = {
435 .algType = HKS_ALG_DH,
436 .keyLen = HKS_DH_KEY_SIZE_2048,
437 };
438 HksBlob key = { .size = 0, .data = NULL };
439
440 spec.keyLen += 1;
441 ret = HksCryptoHalGenerateKey(&spec, &key);
442 ASSERT_EQ(ret, HKS_ERROR_INVALID_KEY_SIZE);
443 }
444
445 /**
446 * @tc.number : HksCryptoHalApiMbedtls_015
447 * @tc.name : HksCryptoHalApiMbedtls_015
448 * @tc.desc : Using HksMbedtlsGetDhPubKey -- Ecc in/out key is invalid.
449 */
450 HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_015, Function | SmallTest | Level0)
451 {
452 int32_t ret;
453
454 HksKeySpec spec = {
455 .algType = HKS_ALG_DH,
456 .keyLen = HKS_DH_KEY_SIZE_2048,
457 };
458 HksBlob key = { .size = 0, .data = NULL };
459
460 ret = HksCryptoHalGenerateKey(&spec, &key);
461 ASSERT_EQ(ret, HKS_SUCCESS);
462
463 KeyMaterialDh *keyMaterial = (KeyMaterialDh *)key.data;
464
465 uint32_t keyOutLen = sizeof(KeyMaterialDh) + keyMaterial->pubKeySize;
466 HksBlob keyOut = { .size = sizeof(KeyMaterialDh), .data = (uint8_t *)HksMalloc(keyOutLen) };
467 ASSERT_NE(keyOut.data, nullptr);
468
469 ret = HksCryptoHalGetPubKey(&key, &keyOut);
470 ASSERT_EQ(ret, HKS_ERROR_BUFFER_TOO_SMALL);
471
472 key.size = keyOut.size;
473 ret = HksCryptoHalGetPubKey(&key, &keyOut);
474 ASSERT_EQ(ret, HKS_ERROR_INVALID_ARGUMENT);
475 HKS_FREE_BLOB(keyOut);
476 HKS_FREE_BLOB(key);
477 }
478
479 /**
480 * @tc.number : HksCryptoHalApiMbedtls_016
481 * @tc.name : HksCryptoHalApiMbedtls_016
482 * @tc.desc : Using HksMbedtlsDhAgreeKey -- Ecc in/out key is invalid.
483 */
484 HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_016, Function | SmallTest | Level0)
485 {
486 int32_t ret;
487
488 HksKeySpec spec = {
489 .algType = HKS_ALG_DH,
490 .keyLen = HKS_DH_KEY_SIZE_2048,
491 };
492 HksBlob key = { .size = 0, .data = NULL };
493
494 ret = HksCryptoHalGenerateKey(&spec, &key);
495 ASSERT_EQ(ret, HKS_SUCCESS);
496
497 KeyMaterialDh *keyMaterial = (KeyMaterialDh *)key.data;
498
499 uint32_t keyOutLen = HKS_KEY_BYTES(spec.keyLen);
500 HksBlob sharedKey = { .size = keyOutLen, .data = (uint8_t *)HksMalloc(keyOutLen) };
501 ASSERT_NE(sharedKey.data, nullptr);
502
503 keyMaterial->keySize -= 1;
504 ret = HksCryptoHalAgreeKey(&key, &key, &spec, &sharedKey);
505 ASSERT_EQ(ret, HKS_ERROR_INVALID_KEY_SIZE);
506
507 sharedKey.size -= 1;
508 ret = HksCryptoHalAgreeKey(&key, &key, &spec, &sharedKey);
509 ASSERT_EQ(ret, HKS_ERROR_BUFFER_TOO_SMALL);
510 HKS_FREE_BLOB(sharedKey);
511 HKS_FREE_BLOB(key);
512 }
513 #endif
514
515 /**
516 * @tc.number : HksCryptoHalApiMbedtls_017
517 * @tc.name : HksCryptoHalApiMbedtls_017
518 * @tc.desc : Using HksCryptoHalHmacInit -- parameter is invalid.
519 */
520 HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_017, Function | SmallTest | Level0)
521 {
522 HksBlob key = { .size = 0, .data = nullptr };
523 uint8_t buff[1] = {0};
524 void *hmactestctx = HksMalloc(HKS_CONTEXT_DATA_MAX);
525 ASSERT_NE(hmactestctx, nullptr);
526
527 ASSERT_EQ(HksCryptoHalHmacInit(&key, NULL, &hmactestctx), HKS_ERROR_INVALID_ARGUMENT);
528
529 key = { .size = 1, .data = buff };
530 ASSERT_EQ(HksCryptoHalHmacInit(&key, NULL, &hmactestctx), HKS_ERROR_INVALID_DIGEST);
531
532 HksFree(hmactestctx);
533 hmactestctx = nullptr;
534 ASSERT_EQ(HksCryptoHalHmacInit(&key, HKS_DIGEST_SHA512, NULL), HKS_ERROR_INVALID_ARGUMENT);
535 }
536
537 /**
538 * @tc.number : HksCryptoHalApiMbedtls_018
539 * @tc.name : HksCryptoHalApiMbedtls_018
540 * @tc.desc : Using HksCryptoHalHmacUpdate -- parameter is invalid.
541 */
542 HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_018, Function | SmallTest | Level0)
543 {
544 HksBlob key = { .size = 0, .data = nullptr };
545 HksBlob message = { .size = 0, .data = nullptr };
546 uint8_t buff[1] = {0};
547 void *hmactestctx = HksMalloc(HKS_CONTEXT_DATA_MAX);
548 ASSERT_NE(hmactestctx, nullptr);
549
550 ASSERT_EQ(HksCryptoHalHmacUpdate(&message, hmactestctx), HKS_ERROR_INVALID_ARGUMENT);
551 HksFree(hmactestctx);
552
553 key = { .size = 0, .data = nullptr };
554 HksKeySpec spec = {.algType = HKS_ALG_HMAC, .keyLen = 256, .algParam = nullptr};
555 ASSERT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS);
556
557 hmactestctx = HksMalloc(HKS_CONTEXT_DATA_MAX);
558 ASSERT_NE(hmactestctx, nullptr);
559 ASSERT_EQ(HksCryptoHalHmacInit(&key, HKS_DIGEST_SHA512, &hmactestctx), HKS_SUCCESS);
560 ASSERT_EQ(HksCryptoHalHmacUpdate(&message, hmactestctx), HKS_ERROR_INVALID_ARGUMENT);
561 HksFree(hmactestctx);
562
563 message = { .size = 1, .data = buff };
564 ASSERT_EQ(HksCryptoHalHmacUpdate(&message, NULL), HKS_ERROR_INVALID_ARGUMENT);
565 }
566
567 /**
568 * @tc.number : HksCryptoHalApiMbedtls_019
569 * @tc.name : HksCryptoHalApiMbedtls_019
570 * @tc.desc : Using HksCryptoHalHmacFinal -- parameter is invalid.
571 */
572 HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_019, Function | SmallTest | Level0)
573 {
574 HksBlob key = { .size = 0, .data = nullptr };
575 HksKeySpec spec = {.algType = HKS_ALG_HMAC, .keyLen = 256, .algParam = nullptr};
576 ASSERT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS);
577 const char *hexData = "00112233445566778899aabbccddeeff";
578 uint32_t dataLen = strlen(hexData) / HKS_COUNT_OF_HALF;
579
580 HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) };
581 ASSERT_NE(message.data, nullptr);
582 for (uint32_t ii = 0; ii < dataLen; ii++) {
583 message.data[ii] = ReadHex((const uint8_t *)&hexData[HKS_COUNT_OF_HALF * ii]);
584 }
585
586 uint8_t buff[1] = {0};
587 HksBlob signature = { .size = 1, .data = buff };
588 void *hmactestctx = HksMalloc(HKS_CONTEXT_DATA_MAX);
589 ASSERT_NE(hmactestctx, nullptr);
590 ASSERT_EQ(HksCryptoHalHmacInit(&key, HKS_DIGEST_SHA1, &hmactestctx), HKS_SUCCESS);
591 ASSERT_EQ(HksCryptoHalHmacUpdate(&message, hmactestctx), HKS_SUCCESS);
592 ASSERT_EQ(HksCryptoHalHmacFinal(NULL, &hmactestctx, &signature), HKS_ERROR_INVALID_ARGUMENT);
593
594 ASSERT_EQ(HksCryptoHalHmacFinal(&message, NULL, &signature), HKS_ERROR_INVALID_ARGUMENT);
595
596 signature = { .size = 0, .data = nullptr };
597 ASSERT_EQ(HksCryptoHalHmacFinal(&message, &hmactestctx, &signature), HKS_ERROR_INVALID_ARGUMENT);
598 HksFree(hmactestctx);
599 HksFree(message.data);
600 }
601
602 /**
603 * @tc.number : HksCryptoHalApiMbedtls_020
604 * @tc.name : HksCryptoHalApiMbedtls_020
605 * @tc.desc : Using HksCryptoHalHmac -- parameter is invalid.
606 */
607 HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_020, Function | SmallTest | Level0)
608 {
609 HksBlob key = { .size = 0, .data = nullptr };
610 HksBlob message = { .size = 0, .data = nullptr };
611 HksBlob signature = { .size = 0, .data = nullptr };
612 uint8_t buff[1] = {0};
613
614 ASSERT_EQ(HksCryptoHalHmac(&key, NULL, &message, &signature), HKS_ERROR_INVALID_ARGUMENT);
615
616 key = { .size = 1, .data = buff };
617 ASSERT_EQ(HksCryptoHalHmac(&key, NULL, &message, &signature), HKS_ERROR_INVALID_ARGUMENT);
618
619 message = { .size = 1, .data = buff };
620 ASSERT_EQ(HksCryptoHalHmac(&key, NULL, &message, &signature), HKS_ERROR_INVALID_ARGUMENT);
621
622 signature = { .size = 1, .data = buff };
623 ASSERT_EQ(HksCryptoHalHmac(&key, NULL, &message, &signature), HKS_ERROR_INVALID_DIGEST);
624 }
625 } // namespace UnitTest
626 } // namespace Huks
627 } // namespace Security
628 } // namespace OHOS