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