1 /*
2 * Copyright (C) 2023 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 "securec.h"
18
19 #include "blob.h"
20 #include "detailed_rsa_key_params.h"
21 #include "detailed_dsa_key_params.h"
22 #include "detailed_ecc_key_params.h"
23 #include "hcf_parcel.h"
24 #include "hcf_string.h"
25 #include "memory.h"
26 #include "object_base.h"
27 #include "openssl_adapter.h"
28 #include "openssl_common.h"
29 #include "params_parser.h"
30 #include "rsa_openssl_common.h"
31 #include "utils.h"
32
33 using namespace std;
34 using namespace testing::ext;
35
36
37 namespace {
38 class CryptoCommonCovTest : public testing::Test {
39 public:
40 static void SetUpTestCase();
41 static void TearDownTestCase();
42 void SetUp();
43 void TearDown();
44 };
45
SetUpTestCase()46 void CryptoCommonCovTest::SetUpTestCase() {}
47
TearDownTestCase()48 void CryptoCommonCovTest::TearDownTestCase() {}
49
SetUp()50 void CryptoCommonCovTest::SetUp() {}
51
TearDown()52 void CryptoCommonCovTest::TearDown() {}
53
54 constexpr uint32_t PRIMES_2 = 2;
55 constexpr uint32_t PRIMES_3 = 3;
56 constexpr uint32_t PRIMES_4 = 4;
57 constexpr uint32_t PRIMES_5 = 5;
58 constexpr uint32_t BEGIN_POS = 1;
59 constexpr uint32_t PARCEL_LENGTH = 1;
60 constexpr uint32_t PARCEL_UINT_MAX = 0xffffffffU;
61 constexpr uint32_t PARCEL_DEFAULT_SIZE = 16;
62 static const char *g_paramStr = "NULL";
63
GetTestClass()64 static const char *GetTestClass()
65 {
66 return g_paramStr;
67 }
68
DestroyTest(HcfObjectBase * self)69 static void DestroyTest(HcfObjectBase *self)
70 {
71 (void)self;
72 return;
73 }
74 // plugin common
75 // invalid digest alg
76 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest001, TestSize.Level0)
77 {
78 HcfResult ret = GetOpensslDigestAlg(0, nullptr);
79 EXPECT_NE(ret, HCF_SUCCESS);
80 }
81
82 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest002, TestSize.Level0)
83 {
84 EVP_MD *tmp = nullptr;
85 HcfResult ret = GetOpensslDigestAlg(HCF_OPENSSL_DIGEST_NONE, &tmp);
86 EXPECT_EQ(ret, HCF_SUCCESS);
87 EXPECT_EQ(tmp, nullptr);
88 }
89
90 // Get Rsa Spec String Md
91 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest003, TestSize.Level0)
92 {
93 HcfAlgParaValue md = HCF_OPENSSL_DIGEST_MD5;
94 HcfResult ret = GetRsaSpecStringMd(md, nullptr);
95 EXPECT_NE(ret, HCF_SUCCESS);
96 }
97
98 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest004, TestSize.Level0)
99 {
100 HcfAlgParaValue md = HCF_OPENSSL_DIGEST_MD5;
101 char *retStr = nullptr;
102 HcfResult ret = GetRsaSpecStringMd(md, &retStr);
103 EXPECT_EQ(ret, HCF_SUCCESS);
104 EXPECT_NE(retStr, nullptr);
105
106 HcfFree(retStr);
107 }
108
109 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest005, TestSize.Level0)
110 {
111 HcfAlgParaValue md = HCF_OPENSSL_DIGEST_SHA1;
112 char *retStr = nullptr;
113 HcfResult ret = GetRsaSpecStringMd(md, &retStr);
114 EXPECT_EQ(ret, HCF_SUCCESS);
115 EXPECT_NE(retStr, nullptr);
116
117 HcfFree(retStr);
118 }
119
120 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest006, TestSize.Level0)
121 {
122 HcfAlgParaValue md = HCF_OPENSSL_DIGEST_SHA224;
123 char *retStr = nullptr;
124 HcfResult ret = GetRsaSpecStringMd(md, &retStr);
125 EXPECT_EQ(ret, HCF_SUCCESS);
126 EXPECT_NE(retStr, nullptr);
127
128 HcfFree(retStr);
129 }
130
131 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest007, TestSize.Level0)
132 {
133 HcfAlgParaValue md = HCF_OPENSSL_DIGEST_SHA384;
134 char *retStr = nullptr;
135 HcfResult ret = GetRsaSpecStringMd(md, &retStr);
136 EXPECT_EQ(ret, HCF_SUCCESS);
137 EXPECT_NE(retStr, nullptr);
138
139 HcfFree(retStr);
140 }
141
142 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest008, TestSize.Level0)
143 {
144 HcfAlgParaValue md = HCF_OPENSSL_DIGEST_SHA512;
145 char *retStr = nullptr;
146 HcfResult ret = GetRsaSpecStringMd(md, &retStr);
147 EXPECT_EQ(ret, HCF_SUCCESS);
148 EXPECT_NE(retStr, nullptr);
149
150 HcfFree(retStr);
151 }
152
153 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest009, TestSize.Level0)
154 {
155 HcfAlgParaValue md = HCF_OPENSSL_DIGEST_NONE;
156 char *retStr = nullptr;
157 HcfResult ret = GetRsaSpecStringMd(md, &retStr);
158 EXPECT_NE(ret, HCF_SUCCESS);
159 EXPECT_EQ(retStr, nullptr);
160 }
161
162 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest010, TestSize.Level0)
163 {
164 HcfResult ret = GetRsaSpecStringMGF(nullptr);
165 EXPECT_NE(ret, HCF_SUCCESS);
166 }
167
168 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest011, TestSize.Level0)
169 {
170 HcfResult ret = GetOpensslPadding(0, nullptr);
171 EXPECT_NE(ret, HCF_SUCCESS);
172 }
173
174 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest012, TestSize.Level0)
175 {
176 int32_t ret = GetRealPrimes(HCF_OPENSSL_PRIMES_2);
177 EXPECT_EQ(ret, PRIMES_2);
178 }
179
180 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest013, TestSize.Level0)
181 {
182 int32_t ret = GetRealPrimes(HCF_OPENSSL_PRIMES_3);
183 EXPECT_EQ(ret, PRIMES_3);
184 }
185
186 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest014, TestSize.Level0)
187 {
188 int32_t ret = GetRealPrimes(HCF_OPENSSL_PRIMES_4);
189 EXPECT_EQ(ret, PRIMES_4);
190 }
191
192 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest015, TestSize.Level0)
193 {
194 int32_t ret = GetRealPrimes(HCF_OPENSSL_PRIMES_5);
195 EXPECT_EQ(ret, PRIMES_5);
196 }
197
198 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest016, TestSize.Level0)
199 {
200 HcfResult ret = BigIntegerToBigNum(nullptr, nullptr);
201 EXPECT_NE(ret, HCF_SUCCESS);
202 }
203
204 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest017, TestSize.Level0)
205 {
206 HcfBigInteger tmp = { .data = nullptr, .len = 0 };
207 HcfResult ret = BigIntegerToBigNum(&tmp, nullptr);
208 EXPECT_NE(ret, HCF_SUCCESS);
209 }
210
211 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest018, TestSize.Level0)
212 {
213 HcfResult ret = BigNumToBigInteger(nullptr, nullptr);
214 EXPECT_NE(ret, HCF_SUCCESS);
215 }
216
217 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest019, TestSize.Level0)
218 {
219 BIGNUM *src = Openssl_BN_new();
220 HcfResult ret = BigNumToBigInteger(src, nullptr);
221 EXPECT_NE(ret, HCF_SUCCESS);
222 }
223
224 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest020, TestSize.Level0)
225 {
226 BIGNUM *src = Openssl_BN_new();
227 HcfBigInteger dest = { .data = nullptr, .len = 0 };
228 HcfResult ret = BigNumToBigInteger(src, &dest);
229 EXPECT_NE(ret, HCF_SUCCESS);
230 EXPECT_EQ(dest.data, nullptr);
231 }
232
233 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest021, TestSize.Level0)
234 {
235 RSA *rsa = Openssl_RSA_new();
236 HcfResult ret = DuplicateRsa(rsa, true, nullptr);
237 EXPECT_NE(ret, HCF_SUCCESS);
238 Openssl_RSA_free(rsa);
239 }
240
241 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest022, TestSize.Level0)
242 {
243 HcfResult ret = DuplicateRsa(nullptr, true, nullptr);
244 EXPECT_NE(ret, HCF_SUCCESS);
245 }
246
247 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest023, TestSize.Level0)
248 {
249 EVP_PKEY *pKey = NewEvpPkeyByRsa(nullptr, true);
250 EXPECT_EQ(pKey, nullptr);
251 }
252 // openssl fail need mock
253
254 // common
255 // parcel
256 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest101, TestSize.Level0)
257 {
258 HcParcel tmp = CreateParcel(0, 0);
259 EXPECT_EQ(tmp.data, nullptr);
260
261 DeleteParcel(&tmp);
262 }
263
264 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest102, TestSize.Level0)
265 {
266 HcParcel *tmp = nullptr;
267 DeleteParcel(tmp);
268 EXPECT_EQ(tmp, nullptr);
269 }
270
271 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest103, TestSize.Level0)
272 {
273 uint32_t ret = GetParcelDataSize(nullptr);
274 EXPECT_EQ(ret, 0);
275 }
276
277 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest104, TestSize.Level0)
278 {
279 HcParcel tmp = CreateParcel(0, 0);
280 tmp.beginPos = BEGIN_POS;
281 uint32_t ret = GetParcelDataSize(&tmp);
282
283 EXPECT_EQ(ret, 0);
284 DeleteParcel(&tmp);
285 }
286
287 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest105, TestSize.Level0)
288 {
289 const char *ret = GetParcelData(nullptr);
290 EXPECT_EQ(ret, nullptr);
291 }
292
293 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest106, TestSize.Level0)
294 {
295 bool ret = ParcelWrite(nullptr, nullptr, 0);
296 EXPECT_EQ(ret, false);
297 }
298
299 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest107, TestSize.Level0)
300 {
301 HcParcel tmp = CreateParcel(0, 0);
302 bool ret = ParcelWrite(&tmp, nullptr, 0);
303 EXPECT_EQ(ret, false);
304
305 DeleteParcel(&tmp);
306 }
307
308 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest108, TestSize.Level0)
309 {
310 HcParcel tmp = CreateParcel(0, 0);
311 int32_t src = 0;
312 bool ret = ParcelWrite(&tmp, &src, 0);
313 EXPECT_EQ(ret, false);
314
315 DeleteParcel(&tmp);
316 }
317
318 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest109, TestSize.Level0)
319 {
320 HcParcel tmp = CreateParcel(0, 0);
321 tmp.endPos = PARCEL_UINT_MAX;
322 int32_t src = 0;
323 bool ret = ParcelWrite(&tmp, &src, PARCEL_LENGTH);
324 EXPECT_EQ(ret, false);
325
326 DeleteParcel(&tmp);
327 }
328
329 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest110, TestSize.Level0)
330 {
331 HcParcel tmp = CreateParcel(PARCEL_DEFAULT_SIZE, PARCEL_DEFAULT_SIZE);
332 tmp.endPos = PARCEL_DEFAULT_SIZE;
333 bool ret = ParcelPopBack(&tmp, PARCEL_LENGTH);
334 EXPECT_EQ(ret, true);
335 EXPECT_EQ(tmp.endPos, PARCEL_DEFAULT_SIZE - PARCEL_LENGTH);
336
337 DeleteParcel(&tmp);
338 }
339
340 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest111, TestSize.Level0)
341 {
342 HcParcel tmp = CreateParcel(PARCEL_DEFAULT_SIZE, PARCEL_DEFAULT_SIZE);
343 tmp.endPos = PARCEL_DEFAULT_SIZE;
344 uint8_t src = 0;
345 tmp.allocUnit = 0;
346 bool ret = ParcelWrite(&tmp, &src, PARCEL_LENGTH);
347 EXPECT_EQ(ret, false);
348
349 DeleteParcel(&tmp);
350 }
351
352 // params.parser
353 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest112, TestSize.Level0)
354 {
355 HcfResult ret = ParseAndSetParameter(nullptr, nullptr, nullptr);
356 EXPECT_NE(ret, HCF_SUCCESS);
357 }
358
359 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest113, TestSize.Level0)
360 {
361 const char *tmp = g_paramStr;
362 HcfResult ret = ParseAndSetParameter(tmp, nullptr, nullptr);
363 EXPECT_NE(ret, HCF_SUCCESS);
364 }
365
366 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest114, TestSize.Level0)
367 {
368 HcfResult ret = ParseAlgNameToParams(nullptr, nullptr);
369 EXPECT_NE(ret, HCF_SUCCESS);
370 }
371
372 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest115, TestSize.Level0)
373 {
374 const char *tmp = g_paramStr;
375 HcfResult ret = ParseAlgNameToParams(tmp, nullptr);
376 EXPECT_NE(ret, HCF_SUCCESS);
377 }
378
379 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest116, TestSize.Level0)
380 {
381 const char *tmp = g_paramStr;
382 HcfAsyKeyGenParams parma = {};
383 HcfResult ret = ParseAlgNameToParams(tmp, &parma);
384 EXPECT_NE(ret, HCF_SUCCESS);
385 }
386
387 // hcf string
388 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest117, TestSize.Level0)
389 {
390 HcString tmp = CreateString();
391 bool ret = StringAppendPointer(&tmp, nullptr);
392 EXPECT_EQ(ret, false);
393 DeleteString(&tmp);
394 }
395
396 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest118, TestSize.Level0)
397 {
398 bool ret = StringAppendPointer(nullptr, nullptr);
399 EXPECT_EQ(ret, false);
400 }
401
402 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest119, TestSize.Level0)
403 {
404 bool ret = StringSetPointer(nullptr, nullptr);
405 EXPECT_EQ(ret, false);
406 }
407
408 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest120, TestSize.Level0)
409 {
410 bool ret = StringSetPointerWithLength(nullptr, nullptr, 0);
411 EXPECT_EQ(ret, false);
412 }
413
414 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest121, TestSize.Level0)
415 {
416 HcString tmp = CreateString();
417 bool ret = StringSetPointerWithLength(&tmp, nullptr, 0);
418 EXPECT_EQ(ret, false);
419 DeleteString(&tmp);
420 }
421
422 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest122, TestSize.Level0)
423 {
424 HcString tmp = CreateString();
425 uint32_t len = strlen(g_paramStr) + 1;
426 bool ret = StringSetPointerWithLength(&tmp, g_paramStr, len);
427 EXPECT_EQ(ret, false);
428 DeleteString(&tmp);
429 }
430
431 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest123, TestSize.Level0)
432 {
433 bool ret = StringGet(nullptr);
434 EXPECT_EQ(ret, false);
435 }
436
437 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest124, TestSize.Level0)
438 {
439 uint32_t ret = StringLength(nullptr);
440 EXPECT_EQ(ret, 0);
441 }
442
443 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest125, TestSize.Level0)
444 {
445 uint32_t ret = StringFind(nullptr, 0, 0);
446 EXPECT_EQ(ret, -1);
447 }
448
449 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest126, TestSize.Level0)
450 {
451 HcString tmp = CreateString();
452 bool ret = StringSubString(&tmp, 0, 0, nullptr);
453 EXPECT_EQ(ret, false);
454 DeleteString(&tmp);
455 }
456
457 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest127, TestSize.Level0)
458 {
459 HcString tmp = CreateString();
460 HcString sub = CreateString();
461 bool ret = StringSubString(&tmp, PARCEL_UINT_MAX, 0, nullptr);
462 EXPECT_EQ(ret, false);
463 DeleteString(&tmp);
464 DeleteString(&sub);
465 }
466
467 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest128, TestSize.Level0)
468 {
469 HcString tmp = CreateString();
470 int ret = StringCompare(&tmp, nullptr);
471 EXPECT_EQ(ret, 0);
472 DeleteString(&tmp);
473 }
474
475 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest129, TestSize.Level0)
476 {
477 int ret = StringCompare(nullptr, nullptr);
478 EXPECT_EQ(ret, 0);
479 }
480
481 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest130, TestSize.Level0)
482 {
483 HcString tmp = CreateString();
484 int ret = StringCompare(&tmp, g_paramStr);
485 EXPECT_EQ(ret, -1);
486 DeleteString(&tmp);
487 }
488
489 // asy parmas free
490 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest131, TestSize.Level0)
491 {
492 HcfDsaCommParamsSpec *spec = nullptr;
493 FreeDsaCommParamsSpec(spec);
494 EXPECT_EQ(spec, nullptr);
495 }
496
497 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest132, TestSize.Level0)
498 {
499 HcfDsaPubKeyParamsSpec *spec = nullptr;
500 DestroyDsaPubKeySpec(spec);
501 EXPECT_EQ(spec, nullptr);
502 }
503
504 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest133, TestSize.Level0)
505 {
506 HcfDsaKeyPairParamsSpec *spec = nullptr;
507 DestroyDsaKeyPairSpec(spec);
508 EXPECT_EQ(spec, nullptr);
509 }
510
511 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest134, TestSize.Level0)
512 {
513 HcfEccCommParamsSpec *spec = nullptr;
514 FreeEccCommParamsSpec(spec);
515 EXPECT_EQ(spec, nullptr);
516 }
517
518 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest135, TestSize.Level0)
519 {
520 HcfEccPubKeyParamsSpec *spec = nullptr;
521 DestroyEccPubKeySpec(spec);
522 EXPECT_EQ(spec, nullptr);
523 }
524
525 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest136, TestSize.Level0)
526 {
527 HcfEccPriKeyParamsSpec *spec = nullptr;
528 DestroyEccPriKeySpec(spec);
529 EXPECT_EQ(spec, nullptr);
530 }
531
532 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest137, TestSize.Level0)
533 {
534 HcfEccKeyPairParamsSpec *spec = nullptr;
535 DestroyEccKeyPairSpec(spec);
536 EXPECT_EQ(spec, nullptr);
537 }
538
539 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest138, TestSize.Level0)
540 {
541 HcfRsaCommParamsSpec *spec = nullptr;
542 FreeRsaCommParamsSpec(spec);
543 EXPECT_EQ(spec, nullptr);
544 }
545
546 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest139, TestSize.Level0)
547 {
548 HcfRsaPubKeyParamsSpec *spec = nullptr;
549 DestroyRsaPubKeySpec(spec);
550 EXPECT_EQ(spec, nullptr);
551 }
552
553 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest140, TestSize.Level0)
554 {
555 HcfRsaKeyPairParamsSpec *spec = nullptr;
556 DestroyRsaKeyPairSpec(spec);
557 EXPECT_EQ(spec, nullptr);
558 }
559
560 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest141, TestSize.Level0)
561 {
562 HcfBlob *blob = nullptr;
563 HcfBlobDataFree(blob);
564 EXPECT_EQ(blob, nullptr);
565 }
566
567 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest142, TestSize.Level0)
568 {
569 HcfBlob *blob = nullptr;
570 HcfBlobDataClearAndFree(blob);
571 EXPECT_EQ(blob, nullptr);
572 }
573
574 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest143, TestSize.Level0)
575 {
576 bool ret = IsClassMatch(nullptr, nullptr);
577 EXPECT_EQ(ret, false);
578 }
579
580 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest144, TestSize.Level0)
581 {
582 HcfObjectBase base = { .getClass = GetTestClass, .destroy = DestroyTest };
583 bool ret = IsClassMatch(&base, nullptr);
584 EXPECT_EQ(ret, false);
585 }
586 }
587