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 <openssl/x509.h>
18
19 #include "asy_key_generator.h"
20 #include "certificate_openssl_class.h"
21 #include "cf_memory.h"
22 #include "cf_log.h"
23 #include "cipher.h"
24 #include "crypto_x509_test_common.h"
25 #include "key_pair.h"
26 #include "memory_mock.h"
27 #include "securec.h"
28 #include "x509_crl.h"
29 #include "x509_crl_entry_openssl.h"
30 #include "x509_crl_match_parameters.h"
31 #include "x509_crl_openssl.h"
32
33 using namespace std;
34 using namespace testing::ext;
35
36 namespace {
37 static uint8_t g_testSn[] = { 0x03, 0xe8 };
38 HcfX509Crl *g_x509Crl = nullptr;
39 HcfX509CrlEntry *g_crlEntry = nullptr;
40 HcfX509CrlSpi *g_crlSpiObj = nullptr;
41
42 class CryptoX509CrlTestPart2 : public testing::Test {
43 public:
44 static void SetUpTestCase();
45 static void TearDownTestCase();
46 void SetUp();
47 void TearDown();
48 };
49
SetUpTestCase()50 void CryptoX509CrlTestPart2::SetUpTestCase()
51 {
52 HcfX509Crl *x509Crl = nullptr;
53 CfResult ret = HcfX509CrlCreate(&g_crlDerInStream, &x509Crl);
54 ASSERT_EQ(ret, 0);
55 ASSERT_NE(x509Crl, nullptr);
56 g_x509Crl = x509Crl;
57
58 CfBlob testSnBlob = { 2, g_testSn };
59 ret = g_x509Crl->getRevokedCert(g_x509Crl, &testSnBlob, &g_crlEntry);
60 EXPECT_EQ(ret, CF_SUCCESS);
61 EXPECT_NE(g_crlEntry, nullptr);
62
63 ret = HcfCX509CrlSpiCreate(&g_crlDerInStream, &g_crlSpiObj);
64 EXPECT_EQ(ret, CF_SUCCESS);
65 EXPECT_NE(g_crlSpiObj, nullptr);
66 }
67
TearDownTestCase()68 void CryptoX509CrlTestPart2::TearDownTestCase()
69 {
70 if (g_x509Crl != nullptr) {
71 CfObjDestroy(g_x509Crl);
72 g_x509Crl = nullptr;
73 }
74
75 if (g_crlEntry != nullptr) {
76 CfObjDestroy(g_crlEntry);
77 g_crlEntry = nullptr;
78 }
79
80 if (g_crlSpiObj != nullptr) {
81 CfObjDestroy(g_crlSpiObj);
82 g_crlSpiObj = nullptr;
83 }
84 }
SetUp()85 void CryptoX509CrlTestPart2::SetUp() {}
TearDown()86 void CryptoX509CrlTestPart2::TearDown() {}
87
GetInvalidCrlClass(void)88 static const char *GetInvalidCrlClass(void)
89 {
90 return "INVALID_CRL_CLASS";
91 }
92
93 /* self point is nullptr */
94 HWTEST_F(CryptoX509CrlTestPart2, MatchX509CRLTest001, TestSize.Level0)
95 {
96 bool bResult = true;
97 HcfX509CrlMatchParams matchParams;
98 CfResult ret = g_x509Crl->match(nullptr, &matchParams, &bResult);
99 EXPECT_EQ(ret, CF_INVALID_PARAMS);
100 }
101
102 /* x509Cert point is nullptr */
103 HWTEST_F(CryptoX509CrlTestPart2, MatchX509CRLTest002, TestSize.Level0)
104 {
105 ASSERT_NE(g_x509Crl, nullptr);
106 bool bResult = true;
107 CfResult ret = g_x509Crl->match(g_x509Crl, nullptr, &bResult);
108 EXPECT_EQ(ret, CF_INVALID_PARAMS);
109 }
110
111 /* out point is nullptr */
112 HWTEST_F(CryptoX509CrlTestPart2, MatchX509CRLTest003, TestSize.Level0)
113 {
114 ASSERT_NE(g_x509Crl, nullptr);
115 HcfX509CrlMatchParams matchParams;
116 CfResult ret = g_x509Crl->match(g_x509Crl, &matchParams, nullptr);
117 EXPECT_EQ(ret, CF_INVALID_PARAMS);
118 }
119
120 /* Get Invalid Crl Class */
121 HWTEST_F(CryptoX509CrlTestPart2, MatchX509CRLTest004, TestSize.Level0)
122 {
123 ASSERT_NE(g_x509Crl, nullptr);
124 HcfX509CrlMatchParams matchParams;
125 HcfX509Crl invalidCrl;
126 invalidCrl.base.base.getClass = GetInvalidCrlClass;
127 bool bResult = true;
128 CfResult ret = g_x509Crl->match(&invalidCrl, &matchParams, &bResult);
129 EXPECT_EQ(ret, CF_INVALID_PARAMS);
130 }
131
132 /* x509Cert is nullptr */
133 HWTEST_F(CryptoX509CrlTestPart2, MatchX509CRLTest005, TestSize.Level0)
134 {
135 ASSERT_NE(g_x509Crl, nullptr);
136 HcfX509CrlMatchParams matchParams;
137 matchParams.x509Cert = nullptr;
138 bool bResult = true;
139 CfResult ret = g_x509Crl->match(g_x509Crl, &matchParams, &bResult);
140 EXPECT_EQ(ret, CF_SUCCESS);
141 }
142
143 /* self x509Cert is not equal to x509Crl */
144 HWTEST_F(CryptoX509CrlTestPart2, MatchX509CRLTest006, TestSize.Level0)
145 {
146 // Get cert
147 HcfX509Certificate *x509Cert = nullptr;
148 CfEncodingBlob inStreamCert = { nullptr, 0, CF_FORMAT_PEM };
149 inStreamCert.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_testErrorCert));
150 inStreamCert.encodingFormat = CF_FORMAT_PEM;
151 inStreamCert.len = strlen(g_testErrorCert) + 1;
152 CfResult ret = HcfX509CertificateCreate(&inStreamCert, &x509Cert);
153 EXPECT_EQ(ret, CF_SUCCESS);
154 EXPECT_NE(x509Cert, nullptr);
155
156 // Get crl
157 HcfX509Crl *x509Crl = nullptr;
158 ret = HcfX509CrlCreate(&g_inStreamCrl, &x509Crl);
159 EXPECT_EQ(ret, CF_SUCCESS);
160 EXPECT_NE(x509Crl, nullptr);
161
162 HcfX509CrlMatchParams matchParams;
163 matchParams.x509Cert = &(x509Cert->base);
164 bool bResult = true;
165 ret = x509Crl->match(x509Crl, &matchParams, &bResult);
166 EXPECT_EQ(ret, CF_SUCCESS);
167 EXPECT_EQ(bResult, false);
168 CfObjDestroy(x509Cert);
169 CfObjDestroy(x509Crl);
170 }
171
172 /* self x509Cert is equal to x509Crl */
173 HWTEST_F(CryptoX509CrlTestPart2, MatchX509CRLTest007, TestSize.Level0)
174 {
175 // Get cert
176 HcfX509Certificate *x509Cert = nullptr;
177 CfResult ret = HcfX509CertificateCreate(&g_inStreamCert, &x509Cert);
178 EXPECT_EQ(ret, CF_SUCCESS);
179 EXPECT_NE(x509Cert, nullptr);
180
181 HcfX509CrlMatchParams matchParams;
182 matchParams.x509Cert = &(x509Cert->base);
183 bool bResult = true;
184 ret = g_x509Crl->match(g_x509Crl, &matchParams, &bResult);
185 EXPECT_EQ(ret, CF_SUCCESS);
186 EXPECT_EQ(bResult, true);
187 CfObjDestroy(x509Cert);
188 }
189
190 /* issuer is nullptr */
191 HWTEST_F(CryptoX509CrlTestPart2, MatchX509CRLTest008, TestSize.Level0)
192 {
193 ASSERT_NE(g_x509Crl, nullptr);
194 HcfX509CrlMatchParams matchParams;
195 matchParams.issuer = nullptr;
196 bool bResult = true;
197 CfResult ret = g_x509Crl->match(g_x509Crl, &matchParams, &bResult);
198 EXPECT_EQ(ret, CF_SUCCESS);
199 }
200
201 /* self issuer is equal to x509Crl */
202 HWTEST_F(CryptoX509CrlTestPart2, MatchX509CRLTest009, TestSize.Level0)
203 {
204 // get issuer name
205 ASSERT_NE(g_x509Crl, nullptr);
206 CfBlob out1 = { 0, nullptr };
207 out1.data = (uint8_t *)(&g_testCrlSubAndIssNameDerData[0]);
208 out1.size = g_testCrlSubAndIssNameDerDataSize;
209
210 CfBlobArray cfBlobArr;
211 CfBlob cfb[2] = { out1, out1 };
212 cfBlobArr.data = cfb;
213 cfBlobArr.count = 2;
214
215 HcfX509CrlMatchParams matchParams;
216 matchParams.issuer = &cfBlobArr;
217 bool bResult = true;
218 CfResult ret = g_x509Crl->match(g_x509Crl, &matchParams, &bResult);
219 EXPECT_EQ(ret, CF_SUCCESS);
220 EXPECT_EQ(bResult, true);
221 }
222
223 /* self issuer is not equal to x509Crl */
224 HWTEST_F(CryptoX509CrlTestPart2, MatchX509CRLTest010, TestSize.Level0)
225 {
226 // get issuer name
227 ASSERT_NE(g_x509Crl, nullptr);
228 CfBlob out1 = { 0, nullptr };
229 CfResult ret = g_x509Crl->getIssuerName(g_x509Crl, &out1);
230 EXPECT_EQ(ret, CF_SUCCESS);
231 EXPECT_EQ((out1.size >= 2), true);
232 out1.data[1] = out1.data[1] + 1; // modify to a different value.
233
234 CfBlobArray cfBlobArr;
235 CfBlob cfb[2] = { out1, out1 };
236 cfBlobArr.data = cfb;
237 cfBlobArr.count = 2;
238
239 // Get crl
240 HcfX509Crl *x509Crl = nullptr;
241 ret = HcfX509CrlCreate(&g_crlDerInStream, &x509Crl);
242 EXPECT_EQ(ret, CF_SUCCESS);
243 EXPECT_NE(x509Crl, nullptr);
244
245 HcfX509CrlMatchParams matchParams;
246 matchParams.issuer = &cfBlobArr;
247 bool bResult = true;
248 ret = x509Crl->match(x509Crl, &matchParams, &bResult);
249 EXPECT_NE(ret, CF_SUCCESS);
250
251 CfFree(out1.data);
252 CfObjDestroy(x509Crl);
253 }
254
255 /* issuer->count is 0 and outTmpSelf.size is not 0 */
256 HWTEST_F(CryptoX509CrlTestPart2, MatchX509CRLTest011, TestSize.Level0)
257 {
258 // get issuer name
259 ASSERT_NE(g_x509Crl, nullptr);
260 CfBlob out1 = { 0, nullptr };
261 out1.data = (uint8_t *)(&g_testCrlSubAndIssNameDerData[0]);
262 out1.size = g_testCrlSubAndIssNameDerDataSize;
263
264 CfBlobArray cfBlobArr;
265 CfBlob cfb[2] = { out1, out1 };
266 cfBlobArr.data = cfb;
267 cfBlobArr.count = 0;
268
269 HcfX509CrlMatchParams matchParams;
270 matchParams.issuer = &cfBlobArr;
271 bool bResult = true;
272 CfResult ret = g_x509Crl->match(g_x509Crl, &matchParams, &bResult);
273 EXPECT_EQ(ret, CF_INVALID_PARAMS);
274 }
275
276 /* issuer->data[0].data is nullptr */
277 HWTEST_F(CryptoX509CrlTestPart2, MatchX509CRLTest012, TestSize.Level0)
278 {
279 // get issuer name
280 ASSERT_NE(g_x509Crl, nullptr);
281 CfBlob out1 = { 0, nullptr };
282 CfBlob out2 = { 0, nullptr };
283 out1.data = nullptr;
284 out1.size = g_testCrlSubAndIssNameDerDataSize;
285 out2.data = (uint8_t *)(&g_testCrlSubAndIssNameDerData[0]);
286 out2.size = g_testCrlSubAndIssNameDerDataSize;
287
288 CfBlobArray cfBlobArr;
289 CfBlob cfb[2] = { out1, out2 };
290 cfBlobArr.data = cfb;
291 cfBlobArr.count = 2;
292
293 HcfX509CrlMatchParams matchParams;
294 matchParams.issuer = &cfBlobArr;
295 bool bResult = true;
296 CfResult ret = g_x509Crl->match(g_x509Crl, &matchParams, &bResult);
297 EXPECT_EQ(ret, CF_INVALID_PARAMS);
298 }
299
300 /* i == issuer->count - 1 */
301 HWTEST_F(CryptoX509CrlTestPart2, MatchX509CRLTest013, TestSize.Level0)
302 {
303 // get issuer name
304 ASSERT_NE(g_x509Crl, nullptr);
305 CfBlob out1 = { 0, nullptr };
306 out1.data = (uint8_t *)(&g_testCrlSubAndIssNameDerData[0]);
307 out1.size = g_testCrlSubAndIssNameDerDataSize;
308
309 CfBlobArray cfBlobArr;
310 CfBlob cfb[2] = { out1, out1 };
311 cfBlobArr.data = cfb;
312 cfBlobArr.count = 2;
313
314 // Get crl
315 HcfX509Crl *x509Crl = nullptr;
316 CfResult ret = HcfX509CrlCreate(&g_crlWithoutExtPemInStream, &x509Crl);
317 EXPECT_EQ(ret, CF_SUCCESS);
318 EXPECT_NE(x509Crl, nullptr);
319
320 HcfX509CrlMatchParams matchParams;
321 matchParams.issuer = &cfBlobArr;
322 bool bResult = true;
323 ret = x509Crl->match(x509Crl, &matchParams, &bResult);
324 EXPECT_EQ(ret, CF_SUCCESS);
325 EXPECT_EQ(bResult, false);
326
327 CfObjDestroy(x509Crl);
328 }
329
330 /* match all params */
331 HWTEST_F(CryptoX509CrlTestPart2, MatchX509CRLTest014, TestSize.Level0)
332 {
333 // Get cert
334 HcfX509Certificate *x509Cert = nullptr;
335 CfResult ret = HcfX509CertificateCreate(&g_inStreamCert, &x509Cert);
336 EXPECT_EQ(ret, CF_SUCCESS);
337 EXPECT_NE(x509Cert, nullptr);
338
339 // get issuer name
340 ASSERT_NE(g_x509Crl, nullptr);
341 CfBlob out1 = { 0, nullptr };
342 out1.data = (uint8_t *)(&g_testCrlSubAndIssNameDerData[0]);
343 out1.size = g_testCrlSubAndIssNameDerDataSize;
344
345 CfBlobArray cfBlobArr;
346 CfBlob cfb[2] = { out1, out1 };
347 cfBlobArr.data = cfb;
348 cfBlobArr.count = 2;
349
350 HcfX509CrlMatchParams matchParams;
351 matchParams.x509Cert = &(x509Cert->base);
352 matchParams.issuer = &cfBlobArr;
353 bool bResult = true;
354 ret = g_x509Crl->match(g_x509Crl, &matchParams, &bResult);
355 EXPECT_EQ(ret, CF_SUCCESS);
356 EXPECT_EQ(bResult, true);
357 CfObjDestroy(x509Cert);
358 }
359
360 HWTEST_F(CryptoX509CrlTestPart2, CrlToStringTest001, TestSize.Level0)
361 {
362 CF_LOG_I("CrlToStringTest001");
363 ASSERT_NE(g_x509Crl, nullptr);
364
365 CfBlob blob = { 0, nullptr };
366 CfResult ret = g_x509Crl->toString(g_x509Crl, &blob);
367 EXPECT_EQ(ret, CF_SUCCESS);
368 CfBlobDataFree(&blob);
369
370 HcfX509Crl invalidCrl;
371 invalidCrl.base.base.getClass = GetInvalidCrlClass;
372
373 ret = g_x509Crl->toString(&invalidCrl, &blob);
374 EXPECT_EQ(ret, CF_INVALID_PARAMS);
375
376 ret = g_x509Crl->toString(NULL, &blob);
377 EXPECT_EQ(ret, CF_INVALID_PARAMS);
378
379 ret = g_x509Crl->toString(g_x509Crl, NULL);
380 EXPECT_EQ(ret, CF_INVALID_PARAMS);
381
382 ret = g_x509Crl->toString(NULL, NULL);
383 EXPECT_EQ(ret, CF_INVALID_PARAMS);
384 }
385
386 HWTEST_F(CryptoX509CrlTestPart2, CrlHashCodeTest001, TestSize.Level0)
387 {
388 CF_LOG_I("CrlHashCodeTest001");
389 ASSERT_NE(g_x509Crl, nullptr);
390
391 CfBlob blob = { 0, nullptr };
392 CfResult ret = g_x509Crl->hashCode(g_x509Crl, &blob);
393 EXPECT_EQ(ret, CF_SUCCESS);
394 CfBlobDataFree(&blob);
395
396 HcfX509Crl invalidCrl;
397 invalidCrl.base.base.getClass = GetInvalidCrlClass;
398
399 ret = g_x509Crl->hashCode(&invalidCrl, &blob);
400 EXPECT_EQ(ret, CF_INVALID_PARAMS);
401
402 ret = g_x509Crl->hashCode(NULL, &blob);
403 EXPECT_EQ(ret, CF_INVALID_PARAMS);
404
405 ret = g_x509Crl->hashCode(g_x509Crl, NULL);
406 EXPECT_EQ(ret, CF_INVALID_PARAMS);
407
408 ret = g_x509Crl->hashCode(NULL, NULL);
409 EXPECT_EQ(ret, CF_INVALID_PARAMS);
410 }
411
412 HWTEST_F(CryptoX509CrlTestPart2, CrlGetExtensionsObjectTest001, TestSize.Level0)
413 {
414 CF_LOG_I("CrlGetExtensionsObjectTest001");
415 ASSERT_NE(g_x509Crl, nullptr);
416
417 CfBlob blob = { 0, nullptr };
418 CfResult ret = g_x509Crl->getExtensionsObject(g_x509Crl, &blob);
419 EXPECT_EQ(ret, CF_SUCCESS);
420 CfBlobDataFree(&blob);
421
422 HcfX509Crl invalidCrl;
423 invalidCrl.base.base.getClass = GetInvalidCrlClass;
424
425 ret = g_x509Crl->getExtensionsObject(&invalidCrl, &blob);
426 EXPECT_EQ(ret, CF_INVALID_PARAMS);
427
428 ret = g_x509Crl->getExtensionsObject(NULL, &blob);
429 EXPECT_EQ(ret, CF_INVALID_PARAMS);
430
431 ret = g_x509Crl->getExtensionsObject(g_x509Crl, NULL);
432 EXPECT_EQ(ret, CF_INVALID_PARAMS);
433
434 ret = g_x509Crl->getExtensionsObject(NULL, NULL);
435 EXPECT_EQ(ret, CF_INVALID_PARAMS);
436 }
437
438 HWTEST_F(CryptoX509CrlTestPart2, CrlEntryToStringTest001, TestSize.Level0)
439 {
440 CF_LOG_I("CrlEntryToStringTest001");
441 ASSERT_NE(g_crlEntry, nullptr);
442
443 CfBlob blob = { 0, nullptr };
444 CfResult ret = g_crlEntry->toString(g_crlEntry, &blob);
445 EXPECT_EQ(ret, CF_SUCCESS);
446 CfBlobDataFree(&blob);
447
448 HcfX509CrlEntry invalidCrlEntry;
449 HcfX509CRLEntryOpensslImpl *imp = (HcfX509CRLEntryOpensslImpl*)&invalidCrlEntry;
450 imp->base.base.getClass = GetInvalidCrlClass;
451
452 ret = g_crlEntry->toString(&invalidCrlEntry, &blob);
453 EXPECT_EQ(ret, CF_INVALID_PARAMS);
454
455 ret = g_crlEntry->toString(NULL, &blob);
456 EXPECT_EQ(ret, CF_INVALID_PARAMS);
457
458 ret = g_crlEntry->toString(g_crlEntry, NULL);
459 EXPECT_EQ(ret, CF_INVALID_PARAMS);
460
461 ret = g_crlEntry->toString(NULL, NULL);
462 EXPECT_EQ(ret, CF_INVALID_PARAMS);
463 }
464
465 HWTEST_F(CryptoX509CrlTestPart2, CrlEntryHashCodeTest001, TestSize.Level0)
466 {
467 CF_LOG_I("CrlEntryHashCodeTest001");
468 ASSERT_NE(g_crlEntry, nullptr);
469
470 CfBlob blob = { 0, nullptr };
471 CfResult ret = g_crlEntry->hashCode(g_crlEntry, &blob);
472 EXPECT_EQ(ret, CF_SUCCESS);
473 CfBlobDataFree(&blob);
474
475 HcfX509CrlEntry invalidCrlEntry;
476 HcfX509CRLEntryOpensslImpl *imp = (HcfX509CRLEntryOpensslImpl*)&invalidCrlEntry;
477 imp->base.base.getClass = GetInvalidCrlClass;
478
479 ret = g_crlEntry->hashCode(&invalidCrlEntry, &blob);
480 EXPECT_EQ(ret, CF_INVALID_PARAMS);
481
482 ret = g_crlEntry->hashCode(NULL, &blob);
483 EXPECT_EQ(ret, CF_INVALID_PARAMS);
484
485 ret = g_crlEntry->hashCode(g_crlEntry, NULL);
486 EXPECT_EQ(ret, CF_INVALID_PARAMS);
487
488 ret = g_crlEntry->hashCode(NULL, NULL);
489 EXPECT_EQ(ret, CF_INVALID_PARAMS);
490 }
491
492 HWTEST_F(CryptoX509CrlTestPart2, CrlEntryGetExtensionsObjectTest001, TestSize.Level0)
493 {
494 CF_LOG_I("CrlEntryGetExtensionsObjectTest001");
495 ASSERT_NE(g_crlEntry, nullptr);
496
497 CfBlob blob = { 0, nullptr };
498 CfResult ret = g_crlEntry->getExtensionsObject(g_crlEntry, &blob);
499 EXPECT_EQ(ret, CF_SUCCESS);
500 CfBlobDataFree(&blob);
501
502 HcfX509CrlEntry invalidCrlEntry;
503 HcfX509CRLEntryOpensslImpl *imp = (HcfX509CRLEntryOpensslImpl*)&invalidCrlEntry;
504 imp->base.base.getClass = GetInvalidCrlClass;
505
506 ret = g_crlEntry->getExtensionsObject(&invalidCrlEntry, &blob);
507 EXPECT_EQ(ret, CF_INVALID_PARAMS);
508
509 ret = g_crlEntry->getExtensionsObject(NULL, &blob);
510 EXPECT_EQ(ret, CF_INVALID_PARAMS);
511
512 ret = g_crlEntry->getExtensionsObject(g_crlEntry, NULL);
513 EXPECT_EQ(ret, CF_INVALID_PARAMS);
514
515 ret = g_crlEntry->getExtensionsObject(NULL, NULL);
516 EXPECT_EQ(ret, CF_INVALID_PARAMS);
517 }
518
519 HWTEST_F(CryptoX509CrlTestPart2, HcfX509CrlSpiEngineToStringTest001, TestSize.Level0)
520 {
521 CF_LOG_I("HcfX509CrlSpiEngineToStringTest001");
522 ASSERT_NE(g_crlSpiObj, nullptr);
523
524 CfBlob blob = { 0, nullptr };
525 CfResult ret = g_crlSpiObj->engineToString(g_crlSpiObj, &blob);
526 EXPECT_EQ(ret, CF_SUCCESS);
527 CfBlobDataFree(&blob);
528
529 HcfX509CrlSpi invalidCrlSpi;
530 invalidCrlSpi.base.getClass = GetInvalidCrlClass;
531
532 ret = g_crlSpiObj->engineToString(&invalidCrlSpi, &blob);
533 EXPECT_EQ(ret, CF_INVALID_PARAMS);
534
535 ret = g_crlSpiObj->engineToString(NULL, &blob);
536 EXPECT_EQ(ret, CF_INVALID_PARAMS);
537
538 ret = g_crlSpiObj->engineToString(g_crlSpiObj, NULL);
539 EXPECT_EQ(ret, CF_INVALID_PARAMS);
540
541 ret = g_crlSpiObj->engineToString(NULL, NULL);
542 EXPECT_EQ(ret, CF_INVALID_PARAMS);
543 }
544
545 HWTEST_F(CryptoX509CrlTestPart2, HcfX509CrlSpiEngineHashCodeTest001, TestSize.Level0)
546 {
547 CF_LOG_I("HcfX509CrlSpiEngineHashCodeTest001");
548 ASSERT_NE(g_crlSpiObj, nullptr);
549
550 CfBlob blob = { 0, nullptr };
551 CfResult ret = g_crlSpiObj->engineHashCode(g_crlSpiObj, &blob);
552 EXPECT_EQ(ret, CF_SUCCESS);
553 CfBlobDataFree(&blob);
554
555 HcfX509CrlSpi invalidCrlSpi;
556 invalidCrlSpi.base.getClass = GetInvalidCrlClass;
557
558 ret = g_crlSpiObj->engineHashCode(&invalidCrlSpi, &blob);
559 EXPECT_EQ(ret, CF_INVALID_PARAMS);
560
561 ret = g_crlSpiObj->engineHashCode(NULL, &blob);
562 EXPECT_EQ(ret, CF_INVALID_PARAMS);
563
564 ret = g_crlSpiObj->engineHashCode(g_crlSpiObj, NULL);
565 EXPECT_EQ(ret, CF_INVALID_PARAMS);
566
567 ret = g_crlSpiObj->engineHashCode(NULL, NULL);
568 EXPECT_EQ(ret, CF_INVALID_PARAMS);
569 }
570
571 HWTEST_F(CryptoX509CrlTestPart2, HcfX509CrlSpiEngineGetExtensionsObjectTest001, TestSize.Level0)
572 {
573 CF_LOG_I("HcfX509CrlSpiEngineGetExtensionsObjectTest001");
574 ASSERT_NE(g_crlSpiObj, nullptr);
575
576 CfBlob blob = { 0, nullptr };
577 CfResult ret = g_crlSpiObj->engineGetExtensionsObject(g_crlSpiObj, &blob);
578 EXPECT_EQ(ret, CF_SUCCESS);
579 CfBlobDataFree(&blob);
580
581 HcfX509CrlSpi invalidCrlSpi;
582 invalidCrlSpi.base.getClass = GetInvalidCrlClass;
583
584 ret = g_crlSpiObj->engineGetExtensionsObject(&invalidCrlSpi, &blob);
585 EXPECT_EQ(ret, CF_INVALID_PARAMS);
586
587 ret = g_crlSpiObj->engineGetExtensionsObject(NULL, &blob);
588 EXPECT_EQ(ret, CF_INVALID_PARAMS);
589
590 ret = g_crlSpiObj->engineGetExtensionsObject(g_crlSpiObj, NULL);
591 EXPECT_EQ(ret, CF_INVALID_PARAMS);
592
593 ret = g_crlSpiObj->engineGetExtensionsObject(NULL, NULL);
594 EXPECT_EQ(ret, CF_INVALID_PARAMS);
595 }
596
597 } // namespace
598