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 OpensslBnFree(src);
195 }
196
197 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest020, TestSize.Level0)
198 {
199 BIGNUM *src = OpensslBnNew();
200 HcfBigInteger dest = { .data = nullptr, .len = 0 };
201 HcfResult ret = BigNumToBigInteger(src, &dest);
202 EXPECT_NE(ret, HCF_SUCCESS);
203 EXPECT_EQ(dest.data, nullptr);
204 OpensslBnFree(src);
205 }
206
207 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest021, TestSize.Level0)
208 {
209 RSA *rsa = OpensslRsaNew();
210 HcfResult ret = DuplicateRsa(rsa, true, nullptr);
211 EXPECT_NE(ret, HCF_SUCCESS);
212 OpensslRsaFree(rsa);
213 }
214
215 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest022, TestSize.Level0)
216 {
217 HcfResult ret = DuplicateRsa(nullptr, true, nullptr);
218 EXPECT_NE(ret, HCF_SUCCESS);
219 }
220
221 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest023, TestSize.Level0)
222 {
223 EVP_PKEY *pKey = NewEvpPkeyByRsa(nullptr, true);
224 EXPECT_EQ(pKey, nullptr);
225 }
226 // openssl fail need mock
227
228 // common
229 // parcel
230 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest101, TestSize.Level0)
231 {
232 HcParcel tmp = CreateParcel(0, 0);
233 EXPECT_EQ(tmp.data, nullptr);
234
235 DeleteParcel(&tmp);
236 }
237
238 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest102, TestSize.Level0)
239 {
240 HcParcel *tmp = nullptr;
241 DeleteParcel(tmp);
242 EXPECT_EQ(tmp, nullptr);
243 }
244
245 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest103, TestSize.Level0)
246 {
247 uint32_t ret = GetParcelDataSize(nullptr);
248 EXPECT_EQ(ret, 0);
249 }
250
251 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest104, TestSize.Level0)
252 {
253 HcParcel tmp = CreateParcel(0, 0);
254 tmp.beginPos = BEGIN_POS;
255 uint32_t ret = GetParcelDataSize(&tmp);
256
257 EXPECT_EQ(ret, 0);
258 DeleteParcel(&tmp);
259 }
260
261 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest105, TestSize.Level0)
262 {
263 const char *ret = GetParcelData(nullptr);
264 EXPECT_EQ(ret, nullptr);
265 }
266
267 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest106, TestSize.Level0)
268 {
269 bool ret = ParcelWrite(nullptr, nullptr, 0);
270 EXPECT_EQ(ret, false);
271 }
272
273 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest107, TestSize.Level0)
274 {
275 HcParcel tmp = CreateParcel(0, 0);
276 bool ret = ParcelWrite(&tmp, nullptr, 0);
277 EXPECT_EQ(ret, false);
278
279 DeleteParcel(&tmp);
280 }
281
282 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest108, TestSize.Level0)
283 {
284 HcParcel tmp = CreateParcel(0, 0);
285 int32_t src = 0;
286 bool ret = ParcelWrite(&tmp, &src, 0);
287 EXPECT_EQ(ret, false);
288
289 DeleteParcel(&tmp);
290 }
291
292 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest109, TestSize.Level0)
293 {
294 HcParcel tmp = CreateParcel(0, 0);
295 tmp.endPos = PARCEL_UINT_MAX;
296 int32_t src = 0;
297 bool ret = ParcelWrite(&tmp, &src, PARCEL_LENGTH);
298 EXPECT_EQ(ret, false);
299
300 DeleteParcel(&tmp);
301 }
302
303 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest110, TestSize.Level0)
304 {
305 HcParcel tmp = CreateParcel(PARCEL_DEFAULT_SIZE, PARCEL_DEFAULT_SIZE);
306 tmp.endPos = PARCEL_DEFAULT_SIZE;
307 bool ret = ParcelPopBack(&tmp, PARCEL_LENGTH);
308 EXPECT_EQ(ret, true);
309 EXPECT_EQ(tmp.endPos, PARCEL_DEFAULT_SIZE - PARCEL_LENGTH);
310
311 DeleteParcel(&tmp);
312 }
313
314 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest111, TestSize.Level0)
315 {
316 HcParcel tmp = CreateParcel(PARCEL_DEFAULT_SIZE, PARCEL_DEFAULT_SIZE);
317 tmp.endPos = PARCEL_DEFAULT_SIZE;
318 uint8_t src = 0;
319 tmp.allocUnit = 0;
320 bool ret = ParcelWrite(&tmp, &src, PARCEL_LENGTH);
321 EXPECT_EQ(ret, false);
322
323 DeleteParcel(&tmp);
324 }
325
326 // params.parser
327 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest112, TestSize.Level0)
328 {
329 HcfResult ret = ParseAndSetParameter(nullptr, nullptr, nullptr);
330 EXPECT_NE(ret, HCF_SUCCESS);
331 }
332
333 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest113, TestSize.Level0)
334 {
335 const char *tmp = g_paramStr;
336 HcfResult ret = ParseAndSetParameter(tmp, nullptr, nullptr);
337 EXPECT_NE(ret, HCF_SUCCESS);
338 }
339
340 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest114, TestSize.Level0)
341 {
342 HcfResult ret = ParseAlgNameToParams(nullptr, nullptr);
343 EXPECT_NE(ret, HCF_SUCCESS);
344 }
345
346 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest115, TestSize.Level0)
347 {
348 const char *tmp = g_paramStr;
349 HcfResult ret = ParseAlgNameToParams(tmp, nullptr);
350 EXPECT_NE(ret, HCF_SUCCESS);
351 }
352
353 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest116, TestSize.Level0)
354 {
355 const char *tmp = g_paramStr;
356 HcfAsyKeyGenParams parma = {};
357 HcfResult ret = ParseAlgNameToParams(tmp, &parma);
358 EXPECT_NE(ret, HCF_SUCCESS);
359 }
360
361 // hcf string
362 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest117, TestSize.Level0)
363 {
364 HcString tmp = CreateString();
365 bool ret = StringAppendPointer(&tmp, nullptr);
366 EXPECT_EQ(ret, false);
367 DeleteString(&tmp);
368 }
369
370 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest118, TestSize.Level0)
371 {
372 bool ret = StringAppendPointer(nullptr, nullptr);
373 EXPECT_EQ(ret, false);
374 }
375
376 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest119, TestSize.Level0)
377 {
378 bool ret = StringSetPointer(nullptr, nullptr);
379 EXPECT_EQ(ret, false);
380 }
381
382 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest120, TestSize.Level0)
383 {
384 bool ret = StringSetPointerWithLength(nullptr, nullptr, 0);
385 EXPECT_EQ(ret, false);
386 }
387
388 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest121, TestSize.Level0)
389 {
390 HcString tmp = CreateString();
391 bool ret = StringSetPointerWithLength(&tmp, nullptr, 0);
392 EXPECT_EQ(ret, false);
393 DeleteString(&tmp);
394 }
395
396 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest122, TestSize.Level0)
397 {
398 HcString tmp = CreateString();
399 uint32_t len = strlen(g_paramStr) + 1;
400 bool ret = StringSetPointerWithLength(&tmp, g_paramStr, len);
401 EXPECT_EQ(ret, false);
402 DeleteString(&tmp);
403 }
404
405 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest123, TestSize.Level0)
406 {
407 bool ret = StringGet(nullptr);
408 EXPECT_EQ(ret, false);
409 }
410
411 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest124, TestSize.Level0)
412 {
413 uint32_t ret = StringLength(nullptr);
414 EXPECT_EQ(ret, 0);
415 }
416
417 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest125, TestSize.Level0)
418 {
419 uint32_t ret = StringFind(nullptr, 0, 0);
420 EXPECT_EQ(ret, -1);
421 }
422
423 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest126, TestSize.Level0)
424 {
425 HcString tmp = CreateString();
426 bool ret = StringSubString(&tmp, 0, 0, nullptr);
427 EXPECT_EQ(ret, false);
428 DeleteString(&tmp);
429 }
430
431 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest127, TestSize.Level0)
432 {
433 HcString tmp = CreateString();
434 HcString sub = CreateString();
435 bool ret = StringSubString(&tmp, PARCEL_UINT_MAX, 0, nullptr);
436 EXPECT_EQ(ret, false);
437 DeleteString(&tmp);
438 DeleteString(&sub);
439 }
440
441 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest128, TestSize.Level0)
442 {
443 HcString tmp = CreateString();
444 int ret = StringCompare(&tmp, nullptr);
445 EXPECT_EQ(ret, 0);
446 DeleteString(&tmp);
447 }
448
449 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest129, TestSize.Level0)
450 {
451 int ret = StringCompare(nullptr, nullptr);
452 EXPECT_EQ(ret, 0);
453 }
454
455 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest130, TestSize.Level0)
456 {
457 HcString tmp = CreateString();
458 int ret = StringCompare(&tmp, g_paramStr);
459 EXPECT_EQ(ret, -1);
460 DeleteString(&tmp);
461 }
462
463 // asy parmas free
464 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest131, TestSize.Level0)
465 {
466 HcfDsaCommParamsSpec *spec = nullptr;
467 FreeDsaCommParamsSpec(spec);
468 EXPECT_EQ(spec, nullptr);
469 }
470
471 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest132, TestSize.Level0)
472 {
473 HcfDsaPubKeyParamsSpec *spec = nullptr;
474 DestroyDsaPubKeySpec(spec);
475 EXPECT_EQ(spec, nullptr);
476 }
477
478 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest133, TestSize.Level0)
479 {
480 HcfDsaKeyPairParamsSpec *spec = nullptr;
481 DestroyDsaKeyPairSpec(spec);
482 EXPECT_EQ(spec, nullptr);
483 }
484
485 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest134, TestSize.Level0)
486 {
487 HcfEccCommParamsSpec *spec = nullptr;
488 FreeEccCommParamsSpec(spec);
489 EXPECT_EQ(spec, nullptr);
490 }
491
492 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest135, TestSize.Level0)
493 {
494 HcfEccPubKeyParamsSpec *spec = nullptr;
495 DestroyEccPubKeySpec(spec);
496 EXPECT_EQ(spec, nullptr);
497 }
498
499 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest136, TestSize.Level0)
500 {
501 HcfEccPriKeyParamsSpec *spec = nullptr;
502 DestroyEccPriKeySpec(spec);
503 EXPECT_EQ(spec, nullptr);
504 }
505
506 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest137, TestSize.Level0)
507 {
508 HcfEccKeyPairParamsSpec *spec = nullptr;
509 DestroyEccKeyPairSpec(spec);
510 EXPECT_EQ(spec, nullptr);
511 }
512
513 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest138, TestSize.Level0)
514 {
515 HcfRsaCommParamsSpec *spec = nullptr;
516 FreeRsaCommParamsSpec(spec);
517 EXPECT_EQ(spec, nullptr);
518 }
519
520 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest139, TestSize.Level0)
521 {
522 HcfRsaPubKeyParamsSpec *spec = nullptr;
523 DestroyRsaPubKeySpec(spec);
524 EXPECT_EQ(spec, nullptr);
525 }
526
527 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest140, TestSize.Level0)
528 {
529 HcfRsaKeyPairParamsSpec *spec = nullptr;
530 DestroyRsaKeyPairSpec(spec);
531 EXPECT_EQ(spec, nullptr);
532 }
533
534 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest141, TestSize.Level0)
535 {
536 HcfBlob *blob = nullptr;
537 HcfBlobDataFree(blob);
538 EXPECT_EQ(blob, nullptr);
539 }
540
541 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest142, TestSize.Level0)
542 {
543 HcfBlob *blob = nullptr;
544 HcfBlobDataClearAndFree(blob);
545 EXPECT_EQ(blob, nullptr);
546 }
547
548 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest143, TestSize.Level0)
549 {
550 bool ret = HcfIsClassMatch(nullptr, nullptr);
551 EXPECT_EQ(ret, false);
552 }
553
554 HWTEST_F(CryptoCommonCovTest, CryptoCommonTest144, TestSize.Level0)
555 {
556 HcfObjectBase base = { .getClass = GetTestClass, .destroy = DestroyTest };
557 bool ret = HcfIsClassMatch(&base, nullptr);
558 EXPECT_EQ(ret, false);
559 }
560 }
561