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