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 #include "hks_log.h"
26
27 using namespace testing::ext;
28 namespace OHOS {
29 namespace Security {
30 namespace Huks {
31 namespace UnitTest {
32 const uint32_t KEY_LEN_256 = 256;
33 constexpr uint32_t DSA_KEY_LEN_512 = 512;
34 class HksCryptoHalApiOpenssl : public HksCryptoHalCommon, public testing::Test {
35 public:
36 static void SetUpTestCase(void);
37 static void TearDownTestCase(void);
38 void SetUp();
39 void TearDown();
40 };
41
SetUpTestCase(void)42 void HksCryptoHalApiOpenssl::SetUpTestCase(void)
43 {
44 }
45
TearDownTestCase(void)46 void HksCryptoHalApiOpenssl::TearDownTestCase(void)
47 {
48 }
49
SetUp()50 void HksCryptoHalApiOpenssl::SetUp()
51 {
52 EXPECT_EQ(HksCryptoAbilityInit(), 0);
53 }
54
TearDown()55 void HksCryptoHalApiOpenssl::TearDown()
56 {
57 }
58
59 /**
60 * @tc.number : HksCryptoHalApiOpenssl_001
61 * @tc.name : HksCryptoHalApiOpenssl_001
62 * @tc.desc : Using HksCryptoHalGenerateKey Generate key -- key is NULL.
63 */
64 HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_001, Function | SmallTest | Level0)
65 {
66 int32_t ret;
67
68 HksKeySpec spec = {
69 .algType = HKS_ALG_AES,
70 .keyLen = HKS_AES_KEY_SIZE_128,
71 };
72
73 ret = HksCryptoHalGenerateKey(&spec, NULL);
74 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
75 }
76
77 /**
78 * @tc.number : HksCryptoHalApiOpenssl_002
79 * @tc.name : HksCryptoHalApiOpenssl_002
80 * @tc.desc : Using HksCryptoHalGenerateKey Generate key -- algType is invalid.
81 */
82 HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_002, Function | SmallTest | Level0)
83 {
84 int32_t ret;
85
86 HksKeySpec spec = {
87 .algType = 0xffff,
88 .keyLen = 0,
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 : HksCryptoHalApiOpenssl_003
99 * @tc.name : HksCryptoHalApiOpenssl_003
100 * @tc.desc : Using HksCryptoHalGenerateKey Generate key -- keyLen is invalid.
101 */
102 HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_003, Function | SmallTest | Level0)
103 {
104 int32_t ret;
105
106 HksKeySpec spec = {
107 .algType = HKS_ALG_AES,
108 .keyLen = 1,
109 };
110
111 HksBlob key = {};
112
113 ret = HksCryptoHalGenerateKey(&spec, &key);
114 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
115
116 spec.algType = HKS_ALG_RSA;
117 ret = HksCryptoHalGenerateKey(&spec, &key);
118 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
119
120 spec.algType = HKS_ALG_ECC;
121 ret = HksCryptoHalGenerateKey(&spec, &key);
122 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
123
124 spec.algType = HKS_ALG_DSA;
125 ret = HksCryptoHalGenerateKey(&spec, &key);
126 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
127
128 spec.algType = HKS_ALG_HMAC;
129 ret = HksCryptoHalGenerateKey(&spec, &key);
130 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
131
132 #ifdef HKS_SUPPORT_DH_C
133 spec.algType = HKS_ALG_DH;
134 ret = HksCryptoHalGenerateKey(&spec, &key);
135 ASSERT_EQ(HKS_ERROR_INVALID_KEY_SIZE, ret);
136 #endif
137 }
138
139 /**
140 * @tc.number : HksCryptoHalApiOpenssl_004
141 * @tc.name : HksCryptoHalApiOpenssl_004
142 * @tc.desc : Using HksCryptoHalEncrypt -- parameter is invalid.
143 */
144 HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_004, Function | SmallTest | Level0)
145 {
146 int32_t ret;
147
148 HksBlob key = { .size = 0, .data = nullptr };
149 HksUsageSpec spec = { .algType = 0xffff };
150 HksBlob message = { .size = 0, .data = nullptr };
151 HksBlob cipherText = { .size = 0, .data = nullptr };
152 HksBlob tagAead = { .size = 0, .data = nullptr };
153 uint8_t buff[1] = {0};
154
155 ret = HksCryptoHalEncrypt(&key, nullptr, &message, &cipherText, &tagAead);
156 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
157
158 key = { .size = 1, .data = buff };
159 ret = HksCryptoHalEncrypt(&key, nullptr, &message, &cipherText, &tagAead);
160 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
161
162 message = { .size = 1, .data = buff };
163 ret = HksCryptoHalEncrypt(&key, nullptr, &message, &cipherText, &tagAead);
164 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
165
166 cipherText = { .size = 1, .data = buff };
167 ret = HksCryptoHalEncrypt(&key, nullptr, &message, &cipherText, &tagAead);
168 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
169
170 ret = HksCryptoHalEncrypt(&key, &spec, &message, &cipherText, &tagAead);
171 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
172 }
173
174 /**
175 * @tc.number : HksCryptoHalApiOpenssl_005
176 * @tc.name : HksCryptoHalApiOpenssl_005
177 * @tc.desc : Using HksCryptoHalDecrypt -- parameter is invalid.
178 */
179 HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_005, Function | SmallTest | Level0)
180 {
181 int32_t ret;
182
183 HksBlob key = { .size = 0, .data = nullptr };
184 HksUsageSpec spec = { .algType = 0xffff };
185 HksBlob message = { .size = 0, .data = nullptr };
186 HksBlob cipherText = { .size = 0, .data = nullptr };
187 uint8_t buff[1] = {0};
188
189 ret = HksCryptoHalDecrypt(&key, nullptr, &message, &cipherText);
190 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
191
192 key = { .size = 1, .data = buff };
193 ret = HksCryptoHalDecrypt(&key, nullptr, &message, &cipherText);
194 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
195
196 message = { .size = 1, .data = buff };
197 ret = HksCryptoHalDecrypt(&key, nullptr, &message, &cipherText);
198 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
199
200 cipherText = { .size = 1, .data = buff };
201 ret = HksCryptoHalDecrypt(&key, nullptr, &message, &cipherText);
202 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
203
204 ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText);
205 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
206 }
207
208 /**
209 * @tc.number : HksCryptoHalApiOpenssl_006
210 * @tc.name : HksCryptoHalApiOpenssl_006
211 * @tc.desc : Using HksCryptoHalEncrypt -- AES encrypt parameter is invalid.
212 */
213 HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_006, Function | SmallTest | Level0)
214 {
215 int32_t ret;
216
217 uint8_t buff[HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128)] = {0};
218 HksBlob key = { .size = 1, .data = buff };
219 HksUsageSpec spec = { .algType = HKS_ALG_AES, .mode = 0xffff };
220 HksBlob message = { .size = 1, .data = buff };
221 HksBlob cipherText = { .size = 1, .data = buff };
222 HksBlob tagAead = { .size = 1, .data = buff };
223
224 ret = HksCryptoHalEncrypt(&key, &spec, &message, &cipherText, &tagAead);
225 EXPECT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
226
227 spec.mode = HKS_MODE_CBC;
228 ret = HksCryptoHalEncrypt(&key, &spec, &message, &cipherText, &tagAead);
229 EXPECT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
230
231 spec.mode = HKS_MODE_CTR;
232 ret = HksCryptoHalEncrypt(&key, &spec, &message, &cipherText, &tagAead);
233 EXPECT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
234
235 spec.mode = HKS_MODE_ECB;
236 ret = HksCryptoHalEncrypt(&key, &spec, &message, &cipherText, &tagAead);
237 EXPECT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
238
239 spec.mode = HKS_MODE_GCM;
240 ret = HksCryptoHalEncrypt(&key, &spec, &message, &cipherText, &tagAead);
241 EXPECT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
242 }
243
244 /**
245 * @tc.number : HksCryptoHalApiOpenssl_007
246 * @tc.name : HksCryptoHalApiOpenssl_007
247 * @tc.desc : Using HksCryptoHalDecrypt -- AES decrypt parameter is invalid.
248 */
249 HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_007, Function | SmallTest | Level0)
250 {
251 int32_t ret;
252
253 uint8_t buff[HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128)] = {0};
254 HksBlob key = { .size = 1, .data = buff };
255 HksUsageSpec spec = { .algType = HKS_ALG_AES, .mode = 0xffff };
256 HksBlob message = { .size = 1, .data = buff };
257 HksBlob cipherText = { .size = 1, .data = buff };
258
259 ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText);
260 EXPECT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
261
262 key.size = sizeof(buff);
263 ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText);
264 EXPECT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
265
266 spec.mode = HKS_MODE_GCM;
267 key.size = 1;
268 ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText);
269 EXPECT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
270 }
271
272 /**
273 * @tc.number : HksCryptoHalApiOpenssl_008
274 * @tc.name : HksCryptoHalApiOpenssl_008
275 * @tc.desc : Using HksCryptoHalDecrypt -- decrypt padding is invalid.
276 */
277 HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_008, Function | SmallTest | Level0)
278 {
279 int32_t ret;
280
281 uint8_t buff[HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128)] = {0};
282 HksBlob key = { .size = sizeof(buff), .data = buff };
283 HksUsageSpec spec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, .padding = HKS_PADDING_PSS };
284 HksBlob message = { .size = 1, .data = buff };
285 HksBlob cipherText = { .size = 1, .data = buff };
286
287 ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText);
288 EXPECT_EQ(HKS_ERROR_CRYPTO_ENGINE_ERROR, ret);
289
290 spec.mode = HKS_MODE_ECB;
291 ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText);
292 EXPECT_EQ(HKS_ERROR_CRYPTO_ENGINE_ERROR, ret);
293
294 spec.algType = HKS_ALG_RSA;
295 ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText);
296 EXPECT_EQ(HKS_ERROR_CRYPTO_ENGINE_ERROR, ret);
297 }
298
299 /**
300 * @tc.number : HksCryptoHalApiOpenssl_009
301 * @tc.name : HksCryptoHalApiOpenssl_009
302 * @tc.desc : Using HksCryptoHalSign -- parameter is invalid.
303 */
304 HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_009, Function | SmallTest | Level0)
305 {
306 HksBlob key = { .size = 0, .data = nullptr };
307 HksUsageSpec spec = { .algType = 0xffff };
308 HksBlob message = { .size = 0, .data = nullptr };
309 HksBlob signature = { .size = 0, .data = nullptr };
310 uint8_t buff[1] = {0};
311
312 EXPECT_EQ(HksCryptoHalSign(&key, nullptr, &message, &signature), HKS_ERROR_INVALID_ARGUMENT);
313
314 key = { .size = 1, .data = buff };
315 EXPECT_EQ(HksCryptoHalSign(&key, nullptr, &message, &signature), HKS_ERROR_INVALID_ARGUMENT);
316
317 message = { .size = 1, .data = buff };
318 EXPECT_EQ(HksCryptoHalSign(&key, nullptr, &message, &signature), HKS_ERROR_INVALID_ARGUMENT);
319
320 signature = { .size = 1, .data = buff };
321 EXPECT_EQ(HksCryptoHalSign(&key, nullptr, &message, &signature), HKS_ERROR_INVALID_ARGUMENT);
322
323 EXPECT_EQ(HksCryptoHalSign(&key, &spec, &message, &signature), HKS_ERROR_INVALID_ARGUMENT);
324 }
325
326 /**
327 * @tc.number : HksCryptoHalApiOpenssl_010
328 * @tc.name : HksCryptoHalApiOpenssl_010
329 * @tc.desc : Using HksCryptoHalVerify -- parameter is invalid.
330 */
331 HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_010, Function | SmallTest | Level0)
332 {
333 HksBlob key = { .size = 0, .data = nullptr };
334 HksUsageSpec spec = { .algType = 0xffff };
335 HksBlob message = { .size = 0, .data = nullptr };
336 HksBlob signature = { .size = 0, .data = nullptr };
337 uint8_t buff[1] = {0};
338
339 EXPECT_EQ(HksCryptoHalVerify(&key, nullptr, &message, &signature), HKS_ERROR_INVALID_ARGUMENT);
340
341 key = { .size = 1, .data = buff };
342 EXPECT_EQ(HksCryptoHalVerify(&key, nullptr, &message, &signature), HKS_ERROR_INVALID_ARGUMENT);
343
344 message = { .size = 1, .data = buff };
345 EXPECT_EQ(HksCryptoHalVerify(&key, nullptr, &message, &signature), HKS_ERROR_INVALID_ARGUMENT);
346
347 signature = { .size = 1, .data = buff };
348 EXPECT_EQ(HksCryptoHalVerify(&key, nullptr, &message, &signature), HKS_ERROR_INVALID_ARGUMENT);
349
350 EXPECT_EQ(HksCryptoHalVerify(&key, &spec, &message, &signature), HKS_ERROR_INVALID_ARGUMENT);
351 }
352
353 /**
354 * @tc.number : HksCryptoHalApiOpenssl_011
355 * @tc.name : HksCryptoHalApiOpenssl_011
356 * @tc.desc : RSA Using HksCryptoHalSign -- parameter is invalid.
357 */
358 HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_011, Function | SmallTest | Level0)
359 {
360 HksKeySpec spec = {
361 .algType = HKS_ALG_RSA,
362 .keyLen = HKS_RSA_KEY_SIZE_512,
363 };
364
365 uint8_t buff[HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_512)] = {0};
366 HksBlob key = { .size = sizeof(buff), .data = buff };
367 HksUsageSpec signSpec = { .algType = HKS_ALG_RSA, .padding = HKS_PADDING_PKCS1_V1_5 };
368 HksBlob message = { .size = 1, .data = buff };
369 HksBlob signature = { .size = 1, .data = buff };
370
371 EXPECT_EQ(HksCryptoHalSign(&key, &signSpec, &message, &signature), HKS_ERROR_INVALID_KEY_INFO);
372
373 signSpec.padding = HKS_PADDING_PSS;
374 EXPECT_EQ(HksCryptoHalSign(&key, &signSpec, &message, &signature), HKS_ERROR_INVALID_KEY_INFO);
375
376 HksCryptoHalGenerateKey(&spec, &key);
377 EXPECT_NE(HksCryptoHalSign(&key, &signSpec, &message, &signature), HKS_SUCCESS);
378 HKS_FREE_BLOB(key);
379 }
380
381 /**
382 * @tc.number : HksCryptoHalApiOpenssl_012
383 * @tc.name : HksCryptoHalApiOpenssl_012
384 * @tc.desc : RSA Using HksCryptoHalVerify -- parameter is invalid.
385 */
386 HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_012, Function | SmallTest | Level0)
387 {
388 uint8_t buff[HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_512)] = {0};
389 HksBlob key = { .size = sizeof(buff), .data = buff };
390 HksUsageSpec signSpec = { .algType = HKS_ALG_RSA };
391 HksBlob message = { .size = 1, .data = buff };
392 HksBlob signature = { .size = 1, .data = buff };
393
394 EXPECT_EQ(HksCryptoHalVerify(&key, &signSpec, &message, &signature), HKS_ERROR_INVALID_KEY_INFO);
395
396 signSpec.padding = HKS_PADDING_PSS;
397 EXPECT_EQ(HksCryptoHalVerify(&key, &signSpec, &message, &signature), HKS_ERROR_INVALID_KEY_INFO);
398 }
399
400 /**
401 * @tc.number : HksCryptoHalApiOpenssl_013
402 * @tc.name : HksCryptoHalApiOpenssl_013
403 * @tc.desc : DSA Using HksCryptoHalSign -- parameter is invalid.
404 */
405 HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_013, Function | SmallTest | Level0)
406 {
407 HksKeySpec spec = {
408 .algType = HKS_ALG_DSA,
409 .keyLen = DSA_KEY_LEN_512,
410 };
411
412 uint8_t buff[HKS_KEY_BYTES(DSA_KEY_LEN_512)] = {0};
413 HksBlob key = { .size = sizeof(buff), .data = buff };
414 HksUsageSpec signSpec = { .algType = HKS_ALG_DSA };
415 HksBlob message = { .size = 1, .data = buff };
416 HksBlob signature = { .size = 1, .data = buff };
417
418 EXPECT_EQ(HksCryptoHalSign(&key, &signSpec, &message, &signature), HKS_ERROR_INVALID_KEY_INFO);
419
420 HksCryptoHalGenerateKey(&spec, &key);
421 EXPECT_NE(HksCryptoHalSign(&key, &signSpec, &message, &signature), HKS_SUCCESS);
422 HKS_FREE_BLOB(key);
423 }
424
425 /**
426 * @tc.number : HksCryptoHalApiOpenssl_014
427 * @tc.name : HksCryptoHalApiOpenssl_014
428 * @tc.desc : DSA Using HksCryptoHalVerify -- parameter is invalid.
429 */
430 HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_014, Function | SmallTest | Level0)
431 {
432 uint8_t buff[HKS_KEY_BYTES(DSA_KEY_LEN_512)] = {0};
433 HksBlob key = { .size = sizeof(buff), .data = buff };
434 HksUsageSpec signSpec = { .algType = HKS_ALG_DSA };
435 HksBlob message = { .size = 1, .data = buff };
436 HksBlob signature = { .size = 1, .data = buff };
437
438 EXPECT_EQ(HksCryptoHalVerify(&key, &signSpec, &message, &signature), HKS_ERROR_INVALID_KEY_INFO);
439 }
440
441 /**
442 * @tc.number : HksCryptoHalApiOpenssl_015
443 * @tc.name : HksCryptoHalApiOpenssl_015
444 * @tc.desc : ECDSA Using HksCryptoHalSign -- parameter is invalid.
445 */
446 HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_015, Function | SmallTest | Level0)
447 {
448 HKS_LOG_E("Enter HksCryptoHalApiOpenssl_015");
449 uint8_t buff[HKS_KEY_BYTES(HKS_ECC_KEY_SIZE_256)] = {0};
450 HksBlob key = { .size = sizeof(buff), .data = buff };
451 HksUsageSpec signSpec = { .algType = HKS_ALG_ECC };
452 HksBlob message = { .size = 1, .data = buff };
453 HksBlob signature = { .size = 1, .data = buff };
454
455 EXPECT_EQ(HksCryptoHalSign(&key, &signSpec, &message, &signature), HKS_ERROR_INVALID_KEY_INFO);
456 }
457
458 /**
459 * @tc.number : HksCryptoHalApiOpenssl_016
460 * @tc.name : HksCryptoHalApiOpenssl_016
461 * @tc.desc : ECDSA Using HksCryptoHalVerify -- parameter is invalid.
462 */
463 HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_016, Function | SmallTest | Level0)
464 {
465 HKS_LOG_E("Enter HksCryptoHalApiOpenssl_016");
466 HksKeySpec spec = {
467 .algType = HKS_ALG_ECC,
468 .keyLen = HKS_ECC_KEY_SIZE_256,
469 };
470
471 uint8_t buff[HKS_KEY_BYTES(KEY_LEN_256)] = {0};
472 HksBlob key = { .size = sizeof(buff), .data = buff };
473 HksUsageSpec signSpec = { .algType = HKS_ALG_ECC };
474 HksBlob message = { .size = 1, .data = buff };
475 HksBlob signature = { .size = 1, .data = buff };
476
477 EXPECT_EQ(HksCryptoHalVerify(&key, &signSpec, &message, &signature), HKS_ERROR_INVALID_KEY_INFO);
478
479 HksCryptoHalGenerateKey(&spec, &key);
480 EXPECT_NE(HksCryptoHalVerify(&key, &signSpec, &message, &signature), HKS_SUCCESS);
481 HKS_FREE_BLOB(key);
482 }
483
484 /**
485 * @tc.number : HksCryptoHalApiOpenssl_017
486 * @tc.name : HksCryptoHalApiOpenssl_017
487 * @tc.desc : Using HksCryptoHalAgreeKey -- parameter is invalid.
488 */
489 HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_017, Function | SmallTest | Level0)
490 {
491 HksBlob key = { .size = 0, .data = nullptr };
492 HksBlob pubKey = { .size = 0, .data = nullptr };
493 HksKeySpec spec = { .algType = 0xffff };
494 HksBlob agreeKey = { .size = 0, .data = nullptr };
495 uint8_t buff[1] = {0};
496
497 EXPECT_EQ(HksCryptoHalAgreeKey(&key, &pubKey, nullptr, &agreeKey), HKS_ERROR_INVALID_ARGUMENT);
498
499 key = { .size = 1, .data = buff };
500 EXPECT_EQ(HksCryptoHalAgreeKey(&key, &pubKey, nullptr, &agreeKey), HKS_ERROR_INVALID_ARGUMENT);
501
502 pubKey = { .size = 1, .data = buff };
503 EXPECT_EQ(HksCryptoHalAgreeKey(&key, &pubKey, nullptr, &agreeKey), HKS_ERROR_INVALID_ARGUMENT);
504
505 EXPECT_EQ(HksCryptoHalAgreeKey(&key, &pubKey, &spec, &agreeKey), HKS_ERROR_INVALID_ARGUMENT);
506
507 agreeKey = { .size = 1, .data = buff };
508 EXPECT_EQ(HksCryptoHalAgreeKey(&key, &pubKey, &spec, &agreeKey), HKS_ERROR_INVALID_ARGUMENT);
509 }
510
511 /**
512 * @tc.number : HksCryptoHalApiOpenssl_018
513 * @tc.name : HksCryptoHalApiOpenssl_018
514 * @tc.desc : ECDH Using HksCryptoHalAgreeKey -- parameter is invalid.
515 */
516 HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_018, Function | SmallTest | Level0)
517 {
518 HksKeySpec keySpec = {
519 .algType = HKS_ALG_ECC,
520 .keyLen = HKS_ECC_KEY_SIZE_256,
521 };
522
523 uint8_t buff[HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_512)] = {0};
524 HksBlob key = { .size = sizeof(buff), .data = buff };
525 HksBlob pubKey = { .size = sizeof(buff), .data = buff };
526 HksKeySpec spec = { .algType = HKS_ALG_ECDH };
527 HksBlob agreeKey = { .size = sizeof(buff), .data = buff };
528
529 EXPECT_EQ(HksCryptoHalAgreeKey(&key, &pubKey, &spec, &agreeKey), HKS_ERROR_INVALID_ARGUMENT);
530
531 spec.keyLen = HKS_ECC_KEY_SIZE_256;
532 EXPECT_EQ(HksCryptoHalAgreeKey(&key, &pubKey, &spec, &agreeKey), HKS_ERROR_CRYPTO_ENGINE_ERROR);
533
534 HksCryptoHalGenerateKey(&keySpec, &key);
535 EXPECT_EQ(HksCryptoHalAgreeKey(&key, &pubKey, &spec, &agreeKey), HKS_ERROR_CRYPTO_ENGINE_ERROR);
536 HKS_FREE_BLOB(key);
537 }
538
539 #ifdef HKS_SUPPORT_DH_C
540 /**
541 * @tc.number : HksCryptoHalApiOpenssl_019
542 * @tc.name : HksCryptoHalApiOpenssl_019
543 * @tc.desc : DH Using HksCryptoHalAgreeKey -- parameter is invalid.
544 */
545 HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_019, Function | SmallTest | Level0)
546 {
547 HksKeySpec keySpec = {
548 .algType = HKS_ALG_DH,
549 .keyLen = HKS_DH_KEY_SIZE_2048,
550 };
551
552 uint8_t buff[HKS_KEY_BYTES(HKS_DH_KEY_SIZE_2048)] = {0};
553 HksBlob key = { .size = sizeof(buff), .data = buff };
554 HksBlob pubKey = { .size = sizeof(buff), .data = buff };
555 HksKeySpec spec = { .algType = HKS_ALG_DH, .keyLen = HKS_DH_KEY_SIZE_4096 };
556 HksBlob agreeKey = { .size = sizeof(buff), .data = buff };
557
558 EXPECT_EQ(HksCryptoHalAgreeKey(&key, &pubKey, &spec, &agreeKey), HKS_ERROR_INVALID_KEY_SIZE);
559
560 spec.keyLen = 0;
561 EXPECT_EQ(HksCryptoHalAgreeKey(&key, &pubKey, &spec, &agreeKey), HKS_ERROR_CRYPTO_ENGINE_ERROR);
562
563 HksCryptoHalGenerateKey(&keySpec, &key);
564 EXPECT_EQ(HksCryptoHalAgreeKey(&key, &pubKey, &spec, &agreeKey), HKS_ERROR_CRYPTO_ENGINE_ERROR);
565
566 HKS_FREE_BLOB(key);
567 }
568 #endif
569
570 /**
571 * @tc.number : HksCryptoHalApiOpenssl_020
572 * @tc.name : HksCryptoHalApiOpenssl_020
573 * @tc.desc : Using HksCryptoHalAgreeKey -- parameter is invalid.
574 */
575 HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_020, Function | SmallTest | Level0)
576 {
577 HksBlob key = { .size = 0, .data = nullptr };
578 HksBlob message = { .size = 0, .data = nullptr };
579 HksBlob signature = { .size = 0, .data = nullptr };
580 uint8_t buff[1] = {0};
581
582 EXPECT_EQ(HksCryptoHalHmac(&key, 0, &message, &signature), HKS_ERROR_INVALID_ARGUMENT);
583
584 key = { .size = 1, .data = buff };
585 EXPECT_EQ(HksCryptoHalHmac(&key, 0, &message, &signature), HKS_ERROR_INVALID_ARGUMENT);
586
587 message = { .size = 1, .data = buff };
588 EXPECT_EQ(HksCryptoHalHmac(&key, 0, &message, &signature), HKS_ERROR_INVALID_ARGUMENT);
589
590 signature = { .size = 1, .data = buff };
591 EXPECT_EQ(HksCryptoHalHmac(&key, 0, &message, &signature), HKS_ERROR_INVALID_ARGUMENT);
592
593 EXPECT_EQ(HksCryptoHalHmac(&key, HKS_DIGEST_SHA512, &message, &signature), HKS_ERROR_INVALID_ARGUMENT);
594 }
595
596 /**
597 * @tc.number : HksCryptoHalApiOpenssl_021
598 * @tc.name : HksCryptoHalApiOpenssl_021
599 * @tc.desc : Using HksCryptoHalHmacInit -- parameter is invalid.
600 */
601 HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_021, Function | SmallTest | Level0)
602 {
603 HksBlob key = { .size = 0, .data = nullptr };
604 uint8_t buff[1] = {0};
605 void *hmactestctx = HksMalloc(HKS_CONTEXT_DATA_MAX);
606 ASSERT_NE(hmactestctx, nullptr);
607
608 EXPECT_EQ(HksCryptoHalHmacInit(&key, 0, &hmactestctx), HKS_ERROR_INVALID_ARGUMENT);
609
610 key = { .size = 1, .data = buff };
611 EXPECT_EQ(HksCryptoHalHmacInit(&key, 0, &hmactestctx), HKS_ERROR_INVALID_ARGUMENT);
612
613 EXPECT_EQ(HksCryptoHalHmacInit(&key, HKS_DIGEST_NONE, &hmactestctx), HKS_ERROR_INVALID_ARGUMENT);
614
615 HKS_FREE(hmactestctx);
616 hmactestctx = nullptr;
617 EXPECT_EQ(HksCryptoHalHmacInit(&key, HKS_DIGEST_SHA512, NULL), HKS_ERROR_INVALID_ARGUMENT);
618 }
619
620 /**
621 * @tc.number : HksCryptoHalApiOpenssl_022
622 * @tc.name : HksCryptoHalApiOpenssl_022
623 * @tc.desc : Using HksCryptoHalHmacUpdate -- parameter is invalid.
624 */
625 HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_022, Function | SmallTest | Level0)
626 {
627 HksBlob key = { .size = 0, .data = nullptr };
628 HksBlob message = { .size = 0, .data = nullptr };
629 uint8_t buff[1] = {0};
630 void *hmactestctx = HksMalloc(HKS_CONTEXT_DATA_MAX);
631 ASSERT_NE(hmactestctx, nullptr);
632
633 EXPECT_EQ(HksCryptoHalHmacUpdate(&message, hmactestctx), HKS_ERROR_INVALID_ARGUMENT);
634 HKS_FREE(hmactestctx);
635
636 key = { .size = 0, .data = nullptr };
637 HksKeySpec spec = {.algType = HKS_ALG_HMAC, .keyLen = KEY_LEN_256, .algParam = nullptr};
638 EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS);
639
640 hmactestctx = HksMalloc(HKS_CONTEXT_DATA_MAX);
641 ASSERT_NE(hmactestctx, nullptr);
642 EXPECT_EQ(HksCryptoHalHmacInit(&key, HKS_DIGEST_SHA512, &hmactestctx), HKS_SUCCESS);
643 EXPECT_EQ(HksCryptoHalHmacUpdate(&message, hmactestctx), HKS_ERROR_INVALID_ARGUMENT);
644 HKS_FREE(hmactestctx);
645
646 message = { .size = 1, .data = buff };
647 EXPECT_EQ(HksCryptoHalHmacUpdate(&message, NULL), HKS_ERROR_INVALID_ARGUMENT);
648 }
649
650
651 /**
652 * @tc.number : HksCryptoHalApiOpenssl_024
653 * @tc.name : HksCryptoHalApiOpenssl_024
654 * @tc.desc : Using HksCryptoHalEncryptInit -- parameter is invalid.
655 */
656 HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_024, Function | SmallTest | Level0)
657 {
658 int32_t ret;
659
660 HksBlob key = { .size = 0, .data = nullptr };
661 HksUsageSpec spec = { .algType = 0xffff };
662 uint8_t buff[1] = {0};
663
664 ret = HksCryptoHalEncryptInit(&key, nullptr, nullptr);
665 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
666
667 key = { .size = 1, .data = buff };
668 ret = HksCryptoHalEncryptInit(&key, nullptr, nullptr);
669 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
670
671 spec = { .algType = HKS_ALG_AES, .mode = 0xffff };
672
673 ret = HksCryptoHalEncryptInit(&key, &spec, nullptr);
674 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
675
676 void *ctx = (void *)HksMalloc(HKS_CONTEXT_DATA_MAX);
677 ASSERT_NE(ctx, nullptr);
678
679 ret = HksCryptoHalEncryptInit(&key, &spec, &ctx);
680 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
681 HKS_FREE(ctx);
682 ctx = nullptr;
683 }
684
685 /**
686 * @tc.number : HksCryptoHalApiOpenssl_025
687 * @tc.name : HksCryptoHalApiOpenssl_025
688 * @tc.desc : Using HksCryptoHalEncryptUpdate -- parameter is invalid.
689 */
690 HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_025, Function | SmallTest | Level0)
691 {
692 int32_t ret;
693
694 HksUsageSpec spec = { .algType = 0xffff };
695 HksBlob message = { .size = 0, .data = nullptr };
696 uint8_t buff[HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128)] = {0};
697 HksBlob out = { .size = 0, .data = nullptr };
698
699 ret = HksCryptoHalEncryptUpdate(&message, nullptr, &out, spec.algType);
700 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
701
702 message = { .size = 1, .data = buff };
703 ret = HksCryptoHalEncryptUpdate(&message, nullptr, &out, spec.algType);
704 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
705
706 void *ctx = (void *)HksMalloc(HKS_CONTEXT_DATA_MAX);
707 ASSERT_NE(ctx, nullptr);
708 ret = HksCryptoHalEncryptUpdate(&message, ctx, &out, spec.algType);
709 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
710
711 out = { .size = 1, .data = buff };
712 ret = HksCryptoHalEncryptUpdate(&message, ctx, &out, spec.algType);
713 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
714
715 spec = { .algType = HKS_ALG_AES, .mode = 0xffff };
716 ret = HksCryptoHalEncryptUpdate(&message, ctx, &out, spec.algType);
717 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
718 HKS_FREE(ctx);
719 ctx = nullptr;
720 }
721
722 /**
723 * @tc.number : HksCryptoHalApiOpenssl_026
724 * @tc.name : HksCryptoHalApiOpenssl_026
725 * @tc.desc : Using HksCryptoHalEncryptFinal -- parameter is invalid.
726 */
727 HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_026, Function | SmallTest | Level0)
728 {
729 int32_t ret;
730
731 HksUsageSpec spec = { .algType = 0xffff };
732 HksBlob cipherText = { .size = 0, .data = nullptr };
733 HksBlob tagAead = { .size = 0, .data = nullptr };
734 uint8_t buff[HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128)] = {0};
735 HksBlob messageLast = { .size = 0, .data = nullptr };
736
737 ret = HksCryptoHalEncryptFinal(&messageLast, nullptr, &cipherText, &tagAead, spec.algType);
738 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
739
740 messageLast = { .size = 1, .data = buff };
741 ret = HksCryptoHalEncryptFinal(&messageLast, nullptr, &cipherText, &tagAead, spec.algType);
742 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
743
744 void *ctx = (void *)HksMalloc(HKS_CONTEXT_DATA_MAX);
745 ASSERT_NE(ctx, nullptr);
746 ret = HksCryptoHalEncryptFinal(&messageLast, &ctx, &cipherText, &tagAead, spec.algType);
747 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
748
749 cipherText = { .size = 1, .data = buff };
750 ret = HksCryptoHalEncryptFinal(&messageLast, nullptr, &cipherText, &tagAead, spec.algType);
751 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
752
753 tagAead = { .size = 1, .data = buff };
754 ret = HksCryptoHalEncryptFinal(&messageLast, nullptr, &cipherText, &tagAead, spec.algType);
755 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
756
757 spec = { .algType = HKS_ALG_AES, .mode = 0xffff };
758 ret = HksCryptoHalEncryptFinal(&messageLast, nullptr, &cipherText, &tagAead, spec.algType);
759 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
760 }
761
762 /**
763 * @tc.number : HksCryptoHalApiOpenssl_027
764 * @tc.name : HksCryptoHalApiOpenssl_027
765 * @tc.desc : Using HksCryptoHalDecryptInit -- parameter is invalid.
766 */
767 HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_027, Function | SmallTest | Level0)
768 {
769 int32_t ret;
770
771 HksBlob key = { .size = 0, .data = nullptr };
772 HksUsageSpec spec = { .algType = 0xffff };
773 uint8_t buff[1] = {0};
774
775 ret = HksCryptoHalDecryptInit(&key, nullptr, nullptr);
776 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
777
778 key = { .size = 1, .data = buff };
779 ret = HksCryptoHalDecryptInit(&key, nullptr, nullptr);
780 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
781
782 spec = { .algType = HKS_ALG_AES, .mode = 0xffff };
783
784 ret = HksCryptoHalDecryptInit(&key, &spec, nullptr);
785 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
786
787 void *ctx = (void *)HksMalloc(HKS_CONTEXT_DATA_MAX);
788 ASSERT_NE(ctx, nullptr);
789
790 ret = HksCryptoHalDecryptInit(&key, &spec, &ctx);
791 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
792 HKS_FREE(ctx);
793 ctx = nullptr;
794 }
795
796 /**
797 * @tc.number : HksCryptoHalApiOpenssl_028
798 * @tc.name : HksCryptoHalApiOpenssl_028
799 * @tc.desc : Using HksCryptoHalDecryptUpdate -- parameter is invalid.
800 */
801 HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_028, Function | SmallTest | Level0)
802 {
803 int32_t ret;
804
805 HksUsageSpec spec = { .algType = 0xffff };
806 HksBlob message = { .size = 0, .data = nullptr };
807 uint8_t buff[HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128)] = {0};
808 HksBlob out = { .size = 0, .data = nullptr };
809
810 ret = HksCryptoHalDecryptUpdate(&message, nullptr, &out, spec.algType);
811 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
812
813 message = { .size = 1, .data = buff };
814 ret = HksCryptoHalDecryptUpdate(&message, nullptr, &out, spec.algType);
815 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
816
817 void *ctx = (void *)HksMalloc(HKS_CONTEXT_DATA_MAX);
818 ASSERT_NE(ctx, nullptr);
819 ret = HksCryptoHalDecryptUpdate(&message, ctx, &out, spec.algType);
820 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
821
822 out = { .size = 1, .data = buff };
823 ret = HksCryptoHalDecryptUpdate(&message, ctx, &out, spec.algType);
824 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
825
826 spec = { .algType = HKS_ALG_AES, .mode = 0xffff };
827 ret = HksCryptoHalDecryptUpdate(&message, ctx, &out, spec.algType);
828 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
829 HKS_FREE(ctx);
830 ctx = nullptr;
831 }
832
833 /**
834 * @tc.number : HksCryptoHalApiOpenssl_029
835 * @tc.name : HksCryptoHalApiOpenssl_029
836 * @tc.desc : Using HksCryptoHalDecryptFinal -- parameter is invalid.
837 */
838 HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_029, Function | SmallTest | Level0)
839 {
840 int32_t ret;
841
842 HksUsageSpec spec = { .algType = 0xffff };
843 HksBlob cipherText = { .size = 0, .data = nullptr };
844 HksBlob tagAead = { .size = 0, .data = nullptr };
845 uint8_t buff[HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128)] = {0};
846 HksBlob messageLast = { .size = 0, .data = nullptr };
847
848 ret = HksCryptoHalDecryptFinal(&messageLast, nullptr, &cipherText, &tagAead, spec.algType);
849 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
850
851 messageLast = { .size = 1, .data = buff };
852 ret = HksCryptoHalDecryptFinal(&messageLast, nullptr, &cipherText, &tagAead, spec.algType);
853 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
854
855 void *ctx = (void *)HksMalloc(HKS_CONTEXT_DATA_MAX);
856 ASSERT_NE(ctx, nullptr);
857 ret = HksCryptoHalDecryptFinal(&messageLast, &ctx, &cipherText, &tagAead, spec.algType);
858 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
859
860 cipherText = { .size = 1, .data = buff };
861 ret = HksCryptoHalDecryptFinal(&messageLast, nullptr, &cipherText, &tagAead, spec.algType);
862 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
863
864 tagAead = { .size = 1, .data = buff };
865 ret = HksCryptoHalDecryptFinal(&messageLast, nullptr, &cipherText, &tagAead, spec.algType);
866 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
867
868 spec = { .algType = HKS_ALG_AES, .mode = 0xffff };
869 ret = HksCryptoHalDecryptFinal(&messageLast, nullptr, &cipherText, &tagAead, spec.algType);
870 ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret);
871 HKS_FREE(ctx);
872 ctx = nullptr;
873 }
874 } // namespace UnitTest
875 } // namespace Huks
876 } // namespace Security
877 } // namespace OHOS