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