1 /*
2  * Copyright (c) 2023-2024 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_log.h"
22 #include "cf_memory.h"
23 #include "cipher.h"
24 #include "crypto_x509_test_common.h"
25 #include "fwk_class.h"
26 #include "key_pair.h"
27 #include "memory_mock.h"
28 #include "securec.h"
29 #include "x509_crl.h"
30 #include "x509_crl_entry_openssl.h"
31 #include "x509_crl_openssl.h"
32 
33 using namespace std;
34 using namespace testing::ext;
35 
36 namespace {
37 HcfX509Crl *g_x509Crl = nullptr;
38 uint8_t g_testSn[] = { 0x03, 0xe8 };
39 
40 class CryptoX509CrlTest : public testing::Test {
41 public:
42     static void SetUpTestCase();
43     static void TearDownTestCase();
44     void SetUp();
45     void TearDown();
46 };
47 
SetUpTestCase()48 void CryptoX509CrlTest::SetUpTestCase()
49 {
50     HcfX509Crl *x509Crl = nullptr;
51     int32_t ret = HcfX509CrlCreate(&g_crlDerInStream, &x509Crl);
52     ASSERT_EQ(ret, 0);
53     ASSERT_NE(x509Crl, nullptr);
54     g_x509Crl = x509Crl;
55 }
56 
TearDownTestCase()57 void CryptoX509CrlTest::TearDownTestCase()
58 {
59     if (g_x509Crl != nullptr) {
60         CfObjDestroy(g_x509Crl);
61         g_x509Crl = nullptr;
62     }
63 }
SetUp()64 void CryptoX509CrlTest::SetUp() {}
TearDown()65 void CryptoX509CrlTest::TearDown() {}
66 
67 // Begin test crl create, test crl create PEM true
68 HWTEST_F(CryptoX509CrlTest, X509CrlTest001, TestSize.Level0)
69 {
70     HcfX509Crl *x509Crl = nullptr;
71     CfResult ret = HcfX509CrlCreate(&g_inStreamCrl, &x509Crl);
72     EXPECT_EQ(ret, CF_SUCCESS);
73     EXPECT_NE(x509Crl, nullptr);
74     CfObjDestroy(x509Crl);
75 }
76 
77 // Test crl create DER true
78 HWTEST_F(CryptoX509CrlTest, X509CrlTest002, TestSize.Level0)
79 {
80     HcfX509Crl *x509Crl = nullptr;
81     CfResult ret = HcfX509CrlCreate(&g_crlDerInStream, &x509Crl);
82     EXPECT_EQ(ret, CF_SUCCESS);
83     EXPECT_NE(x509Crl, nullptr);
84     CfObjDestroy(x509Crl);
85 }
86 
87 // Test crl create error | encodingFormat
88 HWTEST_F(CryptoX509CrlTest, X509CrlTest003, TestSize.Level0)
89 {
90     HcfX509Crl *x509Crl = nullptr;
91     CfEncodingBlob inStreamCrl = { nullptr, 0, CF_FORMAT_PEM };
92     inStreamCrl.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_testCrl));
93     inStreamCrl.encodingFormat = CF_FORMAT_DER;
94     inStreamCrl.len = strlen(g_testCrl) + 1;
95     CfResult ret = HcfX509CrlCreate(&inStreamCrl, &x509Crl);
96     EXPECT_NE(ret, CF_SUCCESS);
97     EXPECT_EQ(x509Crl, nullptr);
98 }
99 
100 // Test crl create error | Crl data
101 HWTEST_F(CryptoX509CrlTest, X509CrlTest004, TestSize.Level0)
102 {
103     HcfX509Crl *x509Crl = nullptr;
104     CfEncodingBlob inStreamCrl = { nullptr, 0, CF_FORMAT_PEM };
105     inStreamCrl.data = nullptr;
106     inStreamCrl.encodingFormat = CF_FORMAT_PEM;
107     inStreamCrl.len = strlen(g_testCrl) + 1;
108     CfResult ret = HcfX509CrlCreate(&inStreamCrl, &x509Crl);
109     EXPECT_NE(ret, CF_SUCCESS);
110     EXPECT_EQ(x509Crl, nullptr);
111 }
112 
113 // Test crl create error | Crl len
114 HWTEST_F(CryptoX509CrlTest, X509CrlTest005, TestSize.Level0)
115 {
116     HcfX509Crl *x509Crl = nullptr;
117     CfEncodingBlob inStreamCrl = { nullptr, 0, CF_FORMAT_PEM };
118     inStreamCrl.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_testCrl));
119     inStreamCrl.encodingFormat = CF_FORMAT_PEM;
120     inStreamCrl.len = 0;
121     CfResult ret = HcfX509CrlCreate(&inStreamCrl, &x509Crl);
122     EXPECT_NE(ret, CF_SUCCESS);
123     EXPECT_EQ(x509Crl, nullptr);
124 }
125 
126 // Test crl create error | Crl nullptr
127 HWTEST_F(CryptoX509CrlTest, X509CrlTest006, TestSize.Level0)
128 {
129     HcfX509Crl *x509Crl = nullptr;
130     CfEncodingBlob *inStreamCrl = nullptr;
131     CfResult ret = HcfX509CrlCreate(inStreamCrl, &x509Crl);
132     EXPECT_NE(ret, CF_SUCCESS);
133     EXPECT_EQ(x509Crl, nullptr);
134 }
135 
136 // Begin test crl isRevoked, test crl isRevoked true
137 HWTEST_F(CryptoX509CrlTest, X509CrlTest011, TestSize.Level0)
138 {
139     // Get cert
140     HcfX509Certificate *x509Cert = nullptr;
141     CfResult ret = HcfX509CertificateCreate(&g_inStreamCert, &x509Cert);
142     EXPECT_EQ(ret, CF_SUCCESS);
143     EXPECT_NE(x509Cert, nullptr);
144 
145     // Get crl
146     HcfX509Crl *x509Crl = nullptr;
147     ret = HcfX509CrlCreate(&g_inStreamCrl, &x509Crl);
148     EXPECT_EQ(ret, CF_SUCCESS);
149     EXPECT_NE(x509Crl, nullptr);
150 
151     bool resIsRevoked =
152         x509Crl->base.isRevoked(reinterpret_cast<HcfCrl *>(x509Crl), reinterpret_cast<HcfCertificate *>(x509Cert));
153     EXPECT_EQ(resIsRevoked, true);
154     CfObjDestroy(x509Crl);
155     CfObjDestroy(x509Cert);
156 }
157 
158 // Test crl isRevoked error | crl null
159 HWTEST_F(CryptoX509CrlTest, X509CrlTest012, TestSize.Level0)
160 {
161     ASSERT_NE(g_x509Crl, nullptr);
162     // Get cert
163     HcfX509Certificate *x509Cert = nullptr;
164     CfResult ret = HcfX509CertificateCreate(&g_inStreamCert, &x509Cert);
165     EXPECT_EQ(ret, CF_SUCCESS);
166     EXPECT_NE(x509Cert, nullptr);
167 
168     bool resIsRevoked = g_x509Crl->base.isRevoked(nullptr, reinterpret_cast<HcfCertificate *>(x509Cert));
169     EXPECT_EQ(resIsRevoked, false);
170     CfObjDestroy(x509Cert);
171 }
172 
173 // Test crl isRevoked error | x509Cert null
174 HWTEST_F(CryptoX509CrlTest, X509CrlTest013, TestSize.Level0)
175 {
176     // Get crl
177     HcfX509Crl *x509Crl = nullptr;
178     CfResult ret = HcfX509CrlCreate(&g_inStreamCrl, &x509Crl);
179     EXPECT_EQ(ret, CF_SUCCESS);
180     EXPECT_NE(x509Crl, nullptr);
181 
182     bool resIsRevoked = x509Crl->base.isRevoked(reinterpret_cast<HcfCrl *>(x509Crl), nullptr);
183     EXPECT_EQ(resIsRevoked, false);
184     CfObjDestroy(x509Crl);
185 }
186 
187 // Test crl isRevoked - der
188 HWTEST_F(CryptoX509CrlTest, X509CrlTest014, TestSize.Level0)
189 {
190     // Get cert
191     HcfX509Certificate *x509Cert = nullptr;
192     CfResult ret = HcfX509CertificateCreate(&g_inStreamCert, &x509Cert);
193     EXPECT_EQ(ret, CF_SUCCESS);
194     EXPECT_NE(x509Cert, nullptr);
195 
196     // Get crl
197     HcfX509Crl *x509Crl = nullptr;
198     ret = HcfX509CrlCreate(&g_crlDerInStream, &x509Crl);
199     EXPECT_EQ(ret, CF_SUCCESS);
200     EXPECT_NE(x509Crl, nullptr);
201 
202     bool resIsRevoked =
203         x509Crl->base.isRevoked(reinterpret_cast<HcfCrl *>(x509Crl), reinterpret_cast<HcfCertificate *>(x509Cert));
204     EXPECT_EQ(resIsRevoked, true);
205     CfObjDestroy(x509Cert);
206     CfObjDestroy(x509Crl);
207 }
208 
209 // Test crl isRevoked error | x509Crl error
210 HWTEST_F(CryptoX509CrlTest, X509CrlTest015, TestSize.Level0)
211 {
212     // Get cert
213     HcfX509Certificate *x509Cert = nullptr;
214     CfEncodingBlob inStreamCert = { nullptr, 0, CF_FORMAT_PEM };
215     inStreamCert.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_testErrorCert));
216     inStreamCert.encodingFormat = CF_FORMAT_PEM;
217     inStreamCert.len = strlen(g_testErrorCert) + 1;
218     CfResult ret = HcfX509CertificateCreate(&inStreamCert, &x509Cert);
219     EXPECT_EQ(ret, CF_SUCCESS);
220     EXPECT_NE(x509Cert, nullptr);
221 
222     // Get crl
223     HcfX509Crl *x509Crl = nullptr;
224     ret = HcfX509CrlCreate(&g_inStreamCrl, &x509Crl);
225     EXPECT_EQ(ret, CF_SUCCESS);
226     EXPECT_NE(x509Crl, nullptr);
227 
228     bool resIsRevoked =
229         x509Crl->base.isRevoked(reinterpret_cast<HcfCrl *>(x509Crl), reinterpret_cast<HcfCertificate *>(x509Cert));
230     EXPECT_EQ(resIsRevoked, false);
231     CfObjDestroy(x509Cert);
232     CfObjDestroy(x509Crl);
233 }
234 
235 // Test crl GetType true
236 HWTEST_F(CryptoX509CrlTest, X509CrlTest021, TestSize.Level0)
237 {
238     // Get crl
239     HcfX509Crl *x509Crl = nullptr;
240     CfResult ret = HcfX509CrlCreate(&g_inStreamCrl, &x509Crl);
241     EXPECT_EQ(ret, CF_SUCCESS);
242     EXPECT_NE(x509Crl, nullptr);
243 
244     const char *resStr = x509Crl->base.getType(reinterpret_cast<HcfCrl *>(x509Crl));
245     EXPECT_STREQ(resStr, "X509");
246     CfObjDestroy(x509Crl);
247 }
248 
249 // Test crl GetType error
250 HWTEST_F(CryptoX509CrlTest, X509CrlTest022, TestSize.Level0)
251 {
252     // Get crl
253     HcfX509Crl *x509Crl = nullptr;
254     CfResult ret = HcfX509CrlCreate(&g_inStreamCrl, &x509Crl);
255     EXPECT_EQ(ret, CF_SUCCESS);
256     EXPECT_NE(x509Crl, nullptr);
257 
258     const char *resStr = x509Crl->base.getType(nullptr);
259     EXPECT_EQ(resStr, nullptr);
260     CfObjDestroy(x509Crl);
261 }
262 
263 // Test crl getEncoded DER true
264 HWTEST_F(CryptoX509CrlTest, X509CrlTest031, TestSize.Level0)
265 {
266     ASSERT_NE(g_x509Crl, nullptr);
267     CfEncodingBlob inStreamInput = { nullptr, 0, CF_FORMAT_PEM };
268     CfResult ret = g_x509Crl->getEncoded(g_x509Crl, &inStreamInput);
269     EXPECT_EQ(ret, CF_SUCCESS);
270 
271     HcfX509Crl *crl2 = nullptr;
272     ret = HcfX509CrlCreate(&inStreamInput, &crl2);
273     EXPECT_EQ(ret, CF_SUCCESS);
274     EXPECT_NE(crl2, nullptr);
275     CfObjDestroy(crl2);
276     CfFree(inStreamInput.data);
277 }
278 
279 // Test crl getEncoded PEM true
280 HWTEST_F(CryptoX509CrlTest, X509CrlTest032, TestSize.Level0)
281 {
282     // Get crl
283     HcfX509Crl *x509Crl = nullptr;
284     CfResult ret = HcfX509CrlCreate(&g_inStreamCrl, &x509Crl);
285     EXPECT_EQ(ret, CF_SUCCESS);
286     EXPECT_NE(x509Crl, nullptr);
287 
288     CfEncodingBlob inStreamInput = { nullptr, 0, CF_FORMAT_PEM };
289     ret = x509Crl->getEncoded(x509Crl, &inStreamInput);
290     EXPECT_EQ(ret, CF_SUCCESS);
291 
292     HcfX509Crl *crl2 = nullptr;
293     ret = HcfX509CrlCreate(&inStreamInput, &crl2);
294     EXPECT_EQ(ret, CF_SUCCESS);
295     EXPECT_NE(crl2, nullptr);
296     CfFree(inStreamInput.data);
297     CfObjDestroy(crl2);
298     CfObjDestroy(x509Crl);
299 }
300 
301 // Test crl getEncoded error
302 HWTEST_F(CryptoX509CrlTest, X509CrlTest033, TestSize.Level0)
303 {
304     ASSERT_NE(g_x509Crl, nullptr);
305     CfResult ret = g_x509Crl->getEncoded(g_x509Crl, nullptr);
306     EXPECT_NE(ret, CF_SUCCESS);
307 }
308 
309 // Test crl getEncoded error
310 HWTEST_F(CryptoX509CrlTest, X509CrlTest034, TestSize.Level0)
311 {
312     ASSERT_NE(g_x509Crl, nullptr);
313     CfEncodingBlob inStreamInput = { nullptr, 0, CF_FORMAT_PEM };
314     CfResult ret = g_x509Crl->getEncoded(nullptr, &inStreamInput);
315     EXPECT_NE(ret, CF_SUCCESS);
316 }
317 
318 // Test crl getEncoded error
319 HWTEST_F(CryptoX509CrlTest, X509CrlTest035, TestSize.Level0)
320 {
321     ASSERT_NE(g_x509Crl, nullptr);
322     CfResult ret = g_x509Crl->getEncoded(nullptr, nullptr);
323     EXPECT_NE(ret, CF_SUCCESS);
324 }
325 
326 // Test crl verify true
327 HWTEST_F(CryptoX509CrlTest, X509CrlTest041, TestSize.Level0)
328 {
329     ASSERT_NE(g_x509Crl, nullptr);
330     HcfX509Certificate *x509CertObj = nullptr;
331     CfResult ret = HcfX509CertificateCreate(&g_inStreamIssuerCert, &x509CertObj);
332     ASSERT_EQ(ret, CF_SUCCESS);
333     ASSERT_NE(x509CertObj, nullptr);
334 
335     HcfPubKey *keyOut = nullptr;
336     ret = x509CertObj->base.getPublicKey((HcfCertificate *)x509CertObj, (void **)&keyOut);
337     ASSERT_EQ(ret, CF_SUCCESS);
338     ASSERT_NE(keyOut, nullptr);
339 
340     HcfBlob blob = { nullptr, 0 };
341     HcfResult hcfRet = keyOut->base.getEncoded(&(keyOut->base), &blob);
342     ASSERT_EQ(hcfRet, HCF_SUCCESS);
343 
344     HcfAsyKeyGenerator *generator = nullptr;
345     hcfRet = HcfAsyKeyGeneratorCreate("RSA2048", &generator);
346     ASSERT_EQ(hcfRet, HCF_SUCCESS);
347     ASSERT_NE(generator, nullptr);
348 
349     HcfKeyPair *dupKeyPair = nullptr;
350     hcfRet = generator->convertKey(generator, nullptr, &blob, nullptr, &dupKeyPair);
351     ASSERT_EQ(hcfRet, HCF_SUCCESS);
352     HcfPubKey *hcfPubkey = dupKeyPair->pubKey;
353 
354     ret = g_x509Crl->verify(g_x509Crl, hcfPubkey);
355     EXPECT_EQ(ret, CF_SUCCESS);
356 
357     free(blob.data);
358     HcfObjDestroy(dupKeyPair);
359     HcfObjDestroy(keyOut);
360     HcfObjDestroy(generator);
361     CfObjDestroy(x509CertObj);
362 }
363 
364 // Test crl verify false
365 HWTEST_F(CryptoX509CrlTest, X509CrlTest042, TestSize.Level0)
366 {
367     ASSERT_NE(g_x509Crl, nullptr);
368     HcfAsyKeyGenerator *generator = nullptr;
369     HcfResult ret = HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_3", &generator);
370     ASSERT_EQ(ret, 0);
371     ASSERT_NE(generator, nullptr);
372 
373     HcfKeyPair *keyPair = nullptr;
374     ret = generator->generateKeyPair(generator, nullptr, &keyPair);
375     ASSERT_EQ(ret, 0);
376     ASSERT_NE(keyPair, nullptr);
377 
378     CfResult ret1 = g_x509Crl->verify(g_x509Crl, keyPair->pubKey);
379     EXPECT_NE(ret1, CF_SUCCESS);
380     HcfObjDestroy(keyPair);
381     HcfObjDestroy(generator);
382 }
383 
384 // Test crl verify false
385 HWTEST_F(CryptoX509CrlTest, X509CrlTest043, TestSize.Level0)
386 {
387     ASSERT_NE(g_x509Crl, nullptr);
388     HcfAsyKeyGenerator *generator = nullptr;
389     HcfResult ret = HcfAsyKeyGeneratorCreate("RSA512|PRIMES_2", &generator);
390     ASSERT_EQ(ret, 0);
391     ASSERT_NE(generator, nullptr);
392 
393     HcfKeyPair *keyPair = nullptr;
394     ret = generator->generateKeyPair(generator, nullptr, &keyPair);
395     ASSERT_EQ(ret, 0);
396     ASSERT_NE(keyPair, nullptr);
397 
398     CfResult ret1 = g_x509Crl->verify(nullptr, keyPair->pubKey);
399     EXPECT_NE(ret1, CF_SUCCESS);
400     HcfObjDestroy(keyPair);
401     HcfObjDestroy(generator);
402 }
403 
404 // Test crl verify false
405 HWTEST_F(CryptoX509CrlTest, X509CrlTest044, TestSize.Level0)
406 {
407     ASSERT_NE(g_x509Crl, nullptr);
408     CfResult ret = g_x509Crl->verify(g_x509Crl, nullptr);
409     EXPECT_NE(ret, CF_SUCCESS);
410 }
411 
412 // Test crl verify false
413 HWTEST_F(CryptoX509CrlTest, X509CrlTest045, TestSize.Level0)
414 {
415     // Get crl
416     HcfX509Crl *x509Crl = nullptr;
417     CfResult ret = HcfX509CrlCreate(&g_inStreamCrl, &x509Crl);
418     EXPECT_EQ(ret, CF_SUCCESS);
419     EXPECT_NE(x509Crl, nullptr);
420 
421     ret = x509Crl->verify(x509Crl, nullptr);
422     EXPECT_NE(ret, CF_SUCCESS);
423     CfObjDestroy(x509Crl);
424 }
425 
426 // Test crl getVersion true
427 HWTEST_F(CryptoX509CrlTest, X509CrlTest051, TestSize.Level0)
428 {
429     ASSERT_NE(g_x509Crl, nullptr);
430     long version = g_x509Crl->getVersion(g_x509Crl);
431     EXPECT_EQ(version, 2);
432 }
433 
434 // Test crl getVersion false
435 HWTEST_F(CryptoX509CrlTest, X509CrlTest052, TestSize.Level0)
436 {
437     ASSERT_NE(g_x509Crl, nullptr);
438     long version = g_x509Crl->getVersion(nullptr);
439     EXPECT_EQ(version, -1);
440 }
441 
442 // Test crl getIssuerName true
443 HWTEST_F(CryptoX509CrlTest, X509CrlTest061, TestSize.Level0)
444 {
445     ASSERT_NE(g_x509Crl, nullptr);
446     CfBlob out = { 0, nullptr };
447     CfResult ret = g_x509Crl->getIssuerName(g_x509Crl, &out);
448     EXPECT_EQ(ret, CF_SUCCESS);
449     EXPECT_NE(out.data, nullptr);
450     EXPECT_STREQ("/C=CN/O=test/CN=subca", reinterpret_cast<char *>(out.data));
451     CfFree(out.data);
452 }
453 
454 // Test crl getIssuerName false
455 HWTEST_F(CryptoX509CrlTest, X509CrlTest062, TestSize.Level0)
456 {
457     ASSERT_NE(g_x509Crl, nullptr);
458     CfBlob out = { 0, nullptr };
459     CfResult ret = g_x509Crl->getIssuerName(nullptr, &out);
460     EXPECT_NE(ret, CF_SUCCESS);
461     EXPECT_EQ(out.data, nullptr);
462 }
463 
464 // Test crl getIssuerName false
465 HWTEST_F(CryptoX509CrlTest, X509CrlTest063, TestSize.Level0)
466 {
467     ASSERT_NE(g_x509Crl, nullptr);
468     CfResult ret = g_x509Crl->getIssuerName(g_x509Crl, nullptr);
469     EXPECT_NE(ret, CF_SUCCESS);
470 }
471 
472 // Test crl getIssuerName false
473 HWTEST_F(CryptoX509CrlTest, X509CrlTest064, TestSize.Level0)
474 {
475     ASSERT_NE(g_x509Crl, nullptr);
476     CfResult ret = g_x509Crl->getIssuerName(nullptr, nullptr);
477     EXPECT_NE(ret, CF_SUCCESS);
478 }
479 
480 // Test crl getLastUpdate true
481 HWTEST_F(CryptoX509CrlTest, X509CrlTest071, TestSize.Level0)
482 {
483     ASSERT_NE(g_x509Crl, nullptr);
484     CfBlob out = { 0, nullptr };
485     CfResult ret = g_x509Crl->getLastUpdate(g_x509Crl, &out);
486     EXPECT_EQ(ret, CF_SUCCESS);
487     EXPECT_NE(out.data, nullptr);
488     EXPECT_STREQ("230912064750Z", reinterpret_cast<char *>(out.data));
489     CfFree(out.data);
490 }
491 
492 // Test crl getLastUpdate false
493 HWTEST_F(CryptoX509CrlTest, X509CrlTest072, TestSize.Level0)
494 {
495     ASSERT_NE(g_x509Crl, nullptr);
496     CfBlob out = { 0, nullptr };
497     CfResult ret = g_x509Crl->getLastUpdate(nullptr, &out);
498     EXPECT_NE(ret, CF_SUCCESS);
499     EXPECT_EQ(out.data, nullptr);
500 }
501 
502 // Test crl getLastUpdate false
503 HWTEST_F(CryptoX509CrlTest, X509CrlTest073, TestSize.Level0)
504 {
505     ASSERT_NE(g_x509Crl, nullptr);
506     CfResult ret = g_x509Crl->getLastUpdate(g_x509Crl, nullptr);
507     EXPECT_NE(ret, CF_SUCCESS);
508 }
509 
510 // Test crl getLastUpdate false
511 HWTEST_F(CryptoX509CrlTest, X509CrlTest074, TestSize.Level0)
512 {
513     ASSERT_NE(g_x509Crl, nullptr);
514     CfResult ret = g_x509Crl->getLastUpdate(nullptr, nullptr);
515     EXPECT_NE(ret, CF_SUCCESS);
516 }
517 
518 // Test crl getNextUpdate true
519 HWTEST_F(CryptoX509CrlTest, X509CrlTest081, TestSize.Level0)
520 {
521     ASSERT_NE(g_x509Crl, nullptr);
522     CfBlob out = { 0, nullptr };
523     CfResult ret = g_x509Crl->getNextUpdate(g_x509Crl, &out);
524     EXPECT_EQ(ret, CF_SUCCESS);
525     EXPECT_NE(out.data, nullptr);
526     EXPECT_STREQ("231012064750Z", reinterpret_cast<char *>(out.data));
527     CfFree(out.data);
528 }
529 
530 // Test crl getNextUpdate false
531 HWTEST_F(CryptoX509CrlTest, X509CrlTest082, TestSize.Level0)
532 {
533     ASSERT_NE(g_x509Crl, nullptr);
534     CfBlob out = { 0, nullptr };
535     CfResult ret = g_x509Crl->getNextUpdate(nullptr, &out);
536     EXPECT_NE(ret, CF_SUCCESS);
537     EXPECT_EQ(out.data, nullptr);
538 }
539 
540 // Test crl getNextUpdate false
541 HWTEST_F(CryptoX509CrlTest, X509CrlTest083, TestSize.Level0)
542 {
543     ASSERT_NE(g_x509Crl, nullptr);
544     CfResult ret = g_x509Crl->getNextUpdate(g_x509Crl, nullptr);
545     EXPECT_NE(ret, CF_SUCCESS);
546 }
547 
548 // Test crl getNextUpdate false
549 HWTEST_F(CryptoX509CrlTest, X509CrlTest084, TestSize.Level0)
550 {
551     ASSERT_NE(g_x509Crl, nullptr);
552     CfResult ret = g_x509Crl->getNextUpdate(nullptr, nullptr);
553     EXPECT_NE(ret, CF_SUCCESS);
554 }
555 
556 // Test crl getRevokedCert true
557 HWTEST_F(CryptoX509CrlTest, X509CrlTest091, TestSize.Level0)
558 {
559     ASSERT_NE(g_x509Crl, nullptr);
560     HcfX509CrlEntry *crlEntry = nullptr;
561     CfBlob testSnBlob = { 2, g_testSn };
562     CfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, &testSnBlob, &crlEntry);
563     EXPECT_EQ(ret, CF_SUCCESS);
564     EXPECT_NE(crlEntry, nullptr);
565     CfObjDestroy(crlEntry);
566 }
567 
568 // Test crl getRevokedCert false
569 HWTEST_F(CryptoX509CrlTest, X509CrlTest092, TestSize.Level0)
570 {
571     ASSERT_NE(g_x509Crl, nullptr);
572     HcfX509CrlEntry *crlEntry = nullptr;
573     long long testSn = 9999;
574     CfBlob testSnBlob = { sizeof(testSn), (uint8_t *)&testSn };
575     CfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, &testSnBlob, &crlEntry);
576     EXPECT_NE(ret, CF_SUCCESS);
577 }
578 
579 // Test crl getRevokedCert false
580 HWTEST_F(CryptoX509CrlTest, X509CrlTest093, TestSize.Level0)
581 {
582     ASSERT_NE(g_x509Crl, nullptr);
583     CfBlob testSnBlob = { 2, g_testSn };
584     CfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, &testSnBlob, nullptr);
585     EXPECT_NE(ret, CF_SUCCESS);
586 }
587 
588 // Test crl getRevokedCert false
589 HWTEST_F(CryptoX509CrlTest, X509CrlTest094, TestSize.Level0)
590 {
591     ASSERT_NE(g_x509Crl, nullptr);
592     HcfX509CrlEntry *crlEntry = nullptr;
593     CfBlob testSnBlob = { 2, g_testSn };
594     CfResult ret = g_x509Crl->getRevokedCert(nullptr, &testSnBlob, &crlEntry);
595     EXPECT_NE(ret, CF_SUCCESS);
596 }
597 
598 // Test crl getRevokedCert false
599 HWTEST_F(CryptoX509CrlTest, X509CrlTest095, TestSize.Level0)
600 {
601     ASSERT_NE(g_x509Crl, nullptr);
602     CfBlob testSnBlob = { 2, g_testSn };
603     CfResult ret = g_x509Crl->getRevokedCert(nullptr, &testSnBlob, nullptr);
604     EXPECT_NE(ret, CF_SUCCESS);
605 }
606 
607 // Test crl entry getSerialNumber true
608 HWTEST_F(CryptoX509CrlTest, X509CrlTest101, TestSize.Level0)
609 {
610     ASSERT_NE(g_x509Crl, nullptr);
611     HcfX509CrlEntry *crlEntry = nullptr;
612     CfBlob testSnBlob = { 2, g_testSn };
613     CfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, &testSnBlob, &crlEntry);
614     EXPECT_EQ(ret, CF_SUCCESS);
615     EXPECT_NE(crlEntry, nullptr);
616     CfBlob out = { 0, nullptr };
617     ret = crlEntry->getSerialNumber(crlEntry, &out);
618     EXPECT_EQ(ret, CF_SUCCESS);
619     EXPECT_EQ(out.size, 2); /* out size: 2 bytes */
620     EXPECT_EQ(out.data[0], g_testSn[0]);
621     EXPECT_EQ(out.data[1], g_testSn[1]);
622     CfFree(out.data);
623     CfObjDestroy(crlEntry);
624 }
625 
626 // Test crl entry getSerialNumber false
627 HWTEST_F(CryptoX509CrlTest, X509CrlTest102, TestSize.Level0)
628 {
629     ASSERT_NE(g_x509Crl, nullptr);
630     HcfX509CrlEntry *crlEntry = nullptr;
631     CfBlob testSnBlob = { 2, g_testSn };
632     CfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, &testSnBlob, &crlEntry);
633     EXPECT_EQ(ret, CF_SUCCESS);
634     EXPECT_NE(crlEntry, nullptr);
635     ret = crlEntry->getSerialNumber(nullptr, nullptr);
636     EXPECT_NE(ret, CF_SUCCESS);
637     CfObjDestroy(crlEntry);
638 }
639 
640 // Test crl entry getSerialNumber false
641 HWTEST_F(CryptoX509CrlTest, X509CrlTest103, TestSize.Level0)
642 {
643     ASSERT_NE(g_x509Crl, nullptr);
644     HcfX509CrlEntry *crlEntry = nullptr;
645     CfBlob testSnBlob = { 2, g_testSn };
646     CfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, &testSnBlob, &crlEntry);
647     EXPECT_EQ(ret, CF_SUCCESS);
648     EXPECT_NE(crlEntry, nullptr);
649     ret = crlEntry->getSerialNumber(nullptr, nullptr);
650     EXPECT_NE(ret, CF_SUCCESS);
651     CfObjDestroy(crlEntry);
652 }
653 
654 // Test crl entry getEncoded true
655 HWTEST_F(CryptoX509CrlTest, X509CrlTest111, TestSize.Level0)
656 {
657     ASSERT_NE(g_x509Crl, nullptr);
658     HcfX509CrlEntry *crlEntry = nullptr;
659     CfBlob testSnBlob = { 2, g_testSn };
660     CfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, &testSnBlob, &crlEntry);
661     EXPECT_EQ(ret, CF_SUCCESS);
662     EXPECT_NE(crlEntry, nullptr);
663 
664     CfEncodingBlob encodingBlob = { nullptr, 0, CF_FORMAT_PEM };
665     ret = crlEntry->getEncoded(crlEntry, &encodingBlob);
666     EXPECT_EQ(ret, CF_SUCCESS);
667     EXPECT_NE(encodingBlob.data, nullptr);
668     CfObjDestroy(crlEntry);
669     CfFree(encodingBlob.data);
670 }
671 
672 // Test crl entry getEncoded false
673 HWTEST_F(CryptoX509CrlTest, X509CrlTest112, TestSize.Level0)
674 {
675     ASSERT_NE(g_x509Crl, nullptr);
676     HcfX509CrlEntry *crlEntry = nullptr;
677     CfBlob testSnBlob = { 2, g_testSn };
678     CfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, &testSnBlob, &crlEntry);
679     EXPECT_EQ(ret, CF_SUCCESS);
680     EXPECT_NE(crlEntry, nullptr);
681 
682     CfEncodingBlob encodingBlob = { nullptr, 0, CF_FORMAT_PEM };
683     ret = crlEntry->getEncoded(nullptr, &encodingBlob);
684     EXPECT_NE(ret, CF_SUCCESS);
685     EXPECT_EQ(encodingBlob.data, nullptr);
686     CfObjDestroy(crlEntry);
687 }
688 
689 // Test crl entry getEncoded false
690 HWTEST_F(CryptoX509CrlTest, X509CrlTest113, TestSize.Level0)
691 {
692     ASSERT_NE(g_x509Crl, nullptr);
693     HcfX509CrlEntry *crlEntry = nullptr;
694     CfBlob testSnBlob = { 2, g_testSn };
695     CfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, &testSnBlob, &crlEntry);
696     EXPECT_EQ(ret, CF_SUCCESS);
697     EXPECT_NE(crlEntry, nullptr);
698 
699     ret = crlEntry->getEncoded(crlEntry, nullptr);
700     EXPECT_NE(ret, CF_SUCCESS);
701     CfObjDestroy(crlEntry);
702 }
703 
704 // Test crl entry getEncoded false
705 HWTEST_F(CryptoX509CrlTest, X509CrlTest114, TestSize.Level0)
706 {
707     ASSERT_NE(g_x509Crl, nullptr);
708     HcfX509CrlEntry *crlEntry = nullptr;
709     CfBlob testSnBlob = { 2, g_testSn };
710     CfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, &testSnBlob, &crlEntry);
711     EXPECT_EQ(ret, CF_SUCCESS);
712     EXPECT_NE(crlEntry, nullptr);
713 
714     ret = crlEntry->getEncoded(nullptr, nullptr);
715     EXPECT_NE(ret, CF_SUCCESS);
716     CfObjDestroy(crlEntry);
717 }
718 
719 // Test crl entry getCertIssuer true
720 HWTEST_F(CryptoX509CrlTest, X509CrlTest121, TestSize.Level0)
721 {
722     ASSERT_NE(g_x509Crl, nullptr);
723     HcfX509CrlEntry *crlEntry = nullptr;
724     CfBlob testSnBlob = { 2, g_testSn };
725     CfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, &testSnBlob, &crlEntry);
726     EXPECT_EQ(ret, CF_SUCCESS);
727     EXPECT_NE(crlEntry, nullptr);
728 
729     CfBlob out = { 0, nullptr };
730     ret = crlEntry->getCertIssuer(crlEntry, &out);
731     EXPECT_EQ(ret, CF_SUCCESS);
732     EXPECT_NE(out.data, nullptr);
733     EXPECT_STREQ("/C=CN/O=test/CN=subca", reinterpret_cast<char *>(out.data));
734     CfObjDestroy(crlEntry);
735     CfFree(out.data);
736 }
737 
738 // Test crl entry getCertIssuer false
739 HWTEST_F(CryptoX509CrlTest, X509CrlTest122, TestSize.Level0)
740 {
741     ASSERT_NE(g_x509Crl, nullptr);
742     HcfX509CrlEntry *crlEntry = nullptr;
743     CfBlob testSnBlob = { 2, g_testSn };
744     CfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, &testSnBlob, &crlEntry);
745     EXPECT_EQ(ret, CF_SUCCESS);
746     EXPECT_NE(crlEntry, nullptr);
747 
748     CfBlob out = { 0, nullptr };
749     ret = crlEntry->getCertIssuer(nullptr, &out);
750     EXPECT_NE(ret, CF_SUCCESS);
751     EXPECT_EQ(out.data, nullptr);
752     CfObjDestroy(crlEntry);
753 }
754 
755 // Test crl entry getCertIssuer false
756 HWTEST_F(CryptoX509CrlTest, X509CrlTest123, TestSize.Level0)
757 {
758     ASSERT_NE(g_x509Crl, nullptr);
759     HcfX509CrlEntry *crlEntry = nullptr;
760     CfBlob testSnBlob = { 2, g_testSn };
761     CfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, &testSnBlob, &crlEntry);
762     EXPECT_EQ(ret, CF_SUCCESS);
763     EXPECT_NE(crlEntry, nullptr);
764 
765     ret = crlEntry->getCertIssuer(crlEntry, nullptr);
766     EXPECT_NE(ret, CF_SUCCESS);
767     CfObjDestroy(crlEntry);
768 }
769 
770 // Test crl entry getRevocationDate true
771 HWTEST_F(CryptoX509CrlTest, X509CrlTest131, TestSize.Level0)
772 {
773     ASSERT_NE(g_x509Crl, nullptr);
774     HcfX509CrlEntry *crlEntry = nullptr;
775     CfBlob testSnBlob = { 2, g_testSn };
776     CfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, &testSnBlob, &crlEntry);
777     EXPECT_EQ(ret, CF_SUCCESS);
778     EXPECT_NE(crlEntry, nullptr);
779 
780     CfBlob out = { 0, nullptr };
781     ret = crlEntry->getRevocationDate(crlEntry, &out);
782     EXPECT_EQ(ret, CF_SUCCESS);
783     EXPECT_NE(out.data, nullptr);
784     EXPECT_STREQ("230912064749Z", reinterpret_cast<char *>(out.data));
785     CfObjDestroy(crlEntry);
786     CfFree(out.data);
787 }
788 
789 // Test crl entry getRevocationDate false
790 HWTEST_F(CryptoX509CrlTest, X509CrlTest132, TestSize.Level0)
791 {
792     ASSERT_NE(g_x509Crl, nullptr);
793     HcfX509CrlEntry *crlEntry = nullptr;
794     CfBlob testSnBlob = { 2, g_testSn };
795     CfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, &testSnBlob, &crlEntry);
796     EXPECT_EQ(ret, CF_SUCCESS);
797     EXPECT_NE(crlEntry, nullptr);
798 
799     CfBlob out = { 0, nullptr };
800     ret = crlEntry->getRevocationDate(nullptr, &out);
801     EXPECT_NE(ret, CF_SUCCESS);
802     EXPECT_EQ(out.data, nullptr);
803     CfObjDestroy(crlEntry);
804 }
805 
806 // Test crl entry getRevocationDate false
807 HWTEST_F(CryptoX509CrlTest, X509CrlTest133, TestSize.Level0)
808 {
809     ASSERT_NE(g_x509Crl, nullptr);
810     HcfX509CrlEntry *crlEntry = nullptr;
811     CfBlob testSnBlob = { 2, g_testSn };
812     CfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, &testSnBlob, &crlEntry);
813     EXPECT_EQ(ret, CF_SUCCESS);
814     EXPECT_NE(crlEntry, nullptr);
815 
816     ret = crlEntry->getRevocationDate(crlEntry, nullptr);
817     EXPECT_NE(ret, CF_SUCCESS);
818     CfObjDestroy(crlEntry);
819 }
820 
821 // Test crl getRevokedCertWithCert true
822 HWTEST_F(CryptoX509CrlTest, X509CrlTest141, TestSize.Level0)
823 {
824     // Get cert
825     HcfX509Certificate *x509Cert = nullptr;
826     CfResult ret = HcfX509CertificateCreate(&g_inStreamCert, &x509Cert);
827     EXPECT_EQ(ret, CF_SUCCESS);
828     EXPECT_NE(x509Cert, nullptr);
829 
830     // Get crl
831     HcfX509Crl *x509Crl = nullptr;
832     ret = HcfX509CrlCreate(&g_inStreamCrl, &x509Crl);
833     EXPECT_EQ(ret, CF_SUCCESS);
834     EXPECT_NE(x509Crl, nullptr);
835 
836     HcfX509CrlEntry *crlEntry = nullptr;
837     ret = x509Crl->getRevokedCertWithCert(x509Crl, x509Cert, &crlEntry);
838     EXPECT_EQ(ret, CF_SUCCESS);
839     EXPECT_NE(crlEntry, nullptr);
840 
841     CfBlob out = { 0, nullptr };
842     ret = crlEntry->getRevocationDate(crlEntry, &out);
843     EXPECT_EQ(ret, CF_SUCCESS);
844     EXPECT_NE(out.data, nullptr);
845     EXPECT_STREQ("230912064749Z", (char *)out.data);
846 
847     CfObjDestroy(x509Cert);
848     CfObjDestroy(x509Crl);
849     CfObjDestroy(crlEntry);
850     CfFree(out.data);
851 }
852 
853 // Test crl getRevokedCertWithCert true
854 HWTEST_F(CryptoX509CrlTest, X509CrlTest142, TestSize.Level0)
855 {
856     // Get cert
857     HcfX509Certificate *x509CertT142 = nullptr;
858     CfResult ret = HcfX509CertificateCreate(&g_inStreamCert, &x509CertT142);
859     EXPECT_EQ(ret, CF_SUCCESS);
860     EXPECT_NE(x509CertT142, nullptr);
861 
862     // Get crl
863     HcfX509Crl *x509Crl = nullptr;
864     ret = HcfX509CrlCreate(&g_inStreamCrl, &x509Crl);
865     EXPECT_EQ(ret, CF_SUCCESS);
866     EXPECT_NE(x509Crl, nullptr);
867 
868     HcfX509CrlEntry *crlEntry = nullptr;
869     ret = x509Crl->getRevokedCertWithCert(x509Crl, x509CertT142, &crlEntry);
870     EXPECT_EQ(ret, CF_SUCCESS);
871     EXPECT_NE(crlEntry, nullptr);
872 
873     CfBlob out = { 0, nullptr };
874     ret = crlEntry->getCertIssuer(crlEntry, &out);
875     EXPECT_EQ(ret, CF_SUCCESS);
876     EXPECT_NE(out.data, nullptr);
877     EXPECT_STREQ("/C=CN/O=test/CN=subca", (char *)out.data);
878 
879     CfObjDestroy(x509CertT142);
880     CfObjDestroy(x509Crl);
881     CfObjDestroy(crlEntry);
882     CfFree(out.data);
883 }
884 
885 // Test crl getRevokedCertWithCert true
886 HWTEST_F(CryptoX509CrlTest, X509CrlTest143, TestSize.Level0)
887 {
888     // Get cert
889     HcfX509Certificate *x509CertT143 = nullptr;
890     CfResult ret = HcfX509CertificateCreate(&g_inStreamCert, &x509CertT143);
891     EXPECT_EQ(ret, CF_SUCCESS);
892     EXPECT_NE(x509CertT143, nullptr);
893 
894     // Get crl
895     HcfX509Crl *x509Crl = nullptr;
896     ret = HcfX509CrlCreate(&g_inStreamCrl, &x509Crl);
897     EXPECT_EQ(ret, CF_SUCCESS);
898     EXPECT_NE(x509Crl, nullptr);
899 
900     HcfX509CrlEntry *crlEntry = nullptr;
901     ret = x509Crl->getRevokedCertWithCert(x509Crl, x509CertT143, &crlEntry);
902     EXPECT_EQ(ret, CF_SUCCESS);
903     EXPECT_NE(crlEntry, nullptr);
904 
905     CfEncodingBlob encodingBlob = { nullptr, 0, CF_FORMAT_PEM };
906     ret = crlEntry->getEncoded(crlEntry, &encodingBlob);
907     EXPECT_EQ(ret, CF_SUCCESS);
908     EXPECT_NE(encodingBlob.data, nullptr);
909 
910     CfFree(encodingBlob.data);
911     CfObjDestroy(x509CertT143);
912     CfObjDestroy(x509Crl);
913     CfObjDestroy(crlEntry);
914 }
915 
916 // Test crl getRevokedCertWithCert false
917 HWTEST_F(CryptoX509CrlTest, X509CrlTest144, TestSize.Level0)
918 {
919     // Get crl
920     HcfX509Crl *x509Crl = nullptr;
921     CfResult ret = HcfX509CrlCreate(&g_inStreamCrl, &x509Crl);
922     EXPECT_EQ(ret, CF_SUCCESS);
923     EXPECT_NE(x509Crl, nullptr);
924 
925     HcfX509CrlEntry *crlEntry = nullptr;
926     ret = x509Crl->getRevokedCertWithCert(x509Crl, nullptr, &crlEntry);
927     EXPECT_NE(ret, CF_SUCCESS);
928     EXPECT_EQ(crlEntry, nullptr);
929 
930     CfObjDestroy(x509Crl);
931 }
932 
933 // Test crl getRevokedCertWithCert false
934 HWTEST_F(CryptoX509CrlTest, X509CrlTest145, TestSize.Level0)
935 {
936     // Get cert
937     HcfX509Certificate *x509Cert = nullptr;
938     CfResult ret = HcfX509CertificateCreate(&g_inStreamCert, &x509Cert);
939     EXPECT_EQ(ret, CF_SUCCESS);
940     EXPECT_NE(x509Cert, nullptr);
941 
942     // Get crl
943     HcfX509Crl *x509Crl = nullptr;
944     ret = HcfX509CrlCreate(&g_inStreamCrl, &x509Crl);
945     EXPECT_EQ(ret, CF_SUCCESS);
946     EXPECT_NE(x509Crl, nullptr);
947 
948     HcfX509CrlEntry *crlEntry = nullptr;
949     ret = x509Crl->getRevokedCertWithCert(nullptr, x509Cert, &crlEntry);
950     EXPECT_NE(ret, CF_SUCCESS);
951     EXPECT_EQ(crlEntry, nullptr);
952 
953     CfObjDestroy(x509Cert);
954     CfObjDestroy(x509Crl);
955 }
956 
957 // Test crl getRevokedCertWithCert false
958 HWTEST_F(CryptoX509CrlTest, X509CrlTest146, TestSize.Level0)
959 {
960     // Get cert
961     HcfX509Certificate *x509CertT146 = nullptr;
962     CfResult ret = HcfX509CertificateCreate(&g_inStreamCert, &x509CertT146);
963     EXPECT_EQ(ret, CF_SUCCESS);
964     EXPECT_NE(x509CertT146, nullptr);
965 
966     // Get crl
967     HcfX509Crl *x509Crl = nullptr;
968     ret = HcfX509CrlCreate(&g_inStreamCrl, &x509Crl);
969     EXPECT_EQ(ret, CF_SUCCESS);
970     EXPECT_NE(x509Crl, nullptr);
971 
972     ret = x509Crl->getRevokedCertWithCert(x509Crl, x509CertT146, nullptr);
973     EXPECT_NE(ret, CF_SUCCESS);
974 
975     CfObjDestroy(x509CertT146);
976     CfObjDestroy(x509Crl);
977 }
978 
979 // Test crl getRevokedCertWithCert false
980 HWTEST_F(CryptoX509CrlTest, X509CrlTest147, TestSize.Level0)
981 {
982     // Get cert
983     HcfX509Certificate *x509CertT147 = nullptr;
984     CfResult ret = HcfX509CertificateCreate(&g_inStreamCert, &x509CertT147);
985     EXPECT_EQ(ret, CF_SUCCESS);
986     EXPECT_NE(x509CertT147, nullptr);
987 
988     // Get crl
989     HcfX509Crl *x509Crl = nullptr;
990     ret = HcfX509CrlCreate(&g_inStreamCrl, &x509Crl);
991     EXPECT_EQ(ret, CF_SUCCESS);
992     EXPECT_NE(x509Crl, nullptr);
993 
994     HcfX509CrlEntry *crlEntry = nullptr;
995     ret = x509Crl->getRevokedCertWithCert(x509Crl, x509CertT147, &crlEntry);
996     EXPECT_EQ(ret, CF_SUCCESS);
997     EXPECT_NE(crlEntry, nullptr);
998 
999     CfBlob out = { 0, nullptr };
1000     ret = crlEntry->getRevocationDate(nullptr, &out);
1001     EXPECT_NE(ret, CF_SUCCESS);
1002     EXPECT_EQ(out.data, nullptr);
1003 
1004     CfObjDestroy(x509CertT147);
1005     CfObjDestroy(x509Crl);
1006     CfObjDestroy(crlEntry);
1007 }
1008 
1009 // Test crl entry getRevokedCerts true
1010 HWTEST_F(CryptoX509CrlTest, X509CrlTest151, TestSize.Level0)
1011 {
1012     ASSERT_NE(g_x509Crl, nullptr);
1013     CfArray entrysOut = { nullptr, CF_FORMAT_PEM, 0 };
1014     CfResult ret = g_x509Crl->getRevokedCerts(g_x509Crl, &entrysOut);
1015     EXPECT_EQ(ret, CF_SUCCESS);
1016     EXPECT_NE(entrysOut.data, nullptr);
1017     EXPECT_EQ(entrysOut.count, 2);
1018 
1019     HcfX509CrlEntry *crlEntry = reinterpret_cast<HcfX509CrlEntry *>(entrysOut.data[0].data);
1020     CfBlob out = { 0, nullptr };
1021     ret = crlEntry->getRevocationDate(crlEntry, &out);
1022     EXPECT_EQ(ret, CF_SUCCESS);
1023     EXPECT_NE(out.data, nullptr);
1024     EXPECT_STREQ("230912064749Z", reinterpret_cast<char *>(out.data));
1025 
1026     CfFree(out.data);
1027     CfObjDestroy(entrysOut.data[0].data);
1028     CfObjDestroy(entrysOut.data[1].data);
1029     CfFree(entrysOut.data);
1030 }
1031 
1032 // Test crl entry getRevokedCerts false
1033 HWTEST_F(CryptoX509CrlTest, X509CrlTest152, TestSize.Level0)
1034 {
1035     ASSERT_NE(g_x509Crl, nullptr);
1036     CfResult ret = g_x509Crl->getRevokedCerts(g_x509Crl, nullptr);
1037     EXPECT_NE(ret, CF_SUCCESS);
1038 }
1039 
1040 // Test crl entry getRevokedCerts false
1041 HWTEST_F(CryptoX509CrlTest, X509CrlTest153, TestSize.Level0)
1042 {
1043     ASSERT_NE(g_x509Crl, nullptr);
1044     CfArray entrysOut = { nullptr, CF_FORMAT_PEM, 0 };
1045     CfResult ret = g_x509Crl->getRevokedCerts(nullptr, &entrysOut);
1046     EXPECT_NE(ret, CF_SUCCESS);
1047     EXPECT_EQ(entrysOut.data, nullptr);
1048 }
1049 
1050 // Test crl entry getRevokedCerts false
1051 HWTEST_F(CryptoX509CrlTest, X509CrlTest154, TestSize.Level0)
1052 {
1053     ASSERT_NE(g_x509Crl, nullptr);
1054     CfResult ret = g_x509Crl->getRevokedCerts(nullptr, nullptr);
1055     EXPECT_NE(ret, CF_SUCCESS);
1056 }
1057 
1058 // Test crl getTbsInfo true
1059 HWTEST_F(CryptoX509CrlTest, X509CrlTest161, TestSize.Level0)
1060 {
1061     ASSERT_NE(g_x509Crl, nullptr);
1062     CfBlob tbsCertListOut = { 0, nullptr };
1063     CfResult ret = g_x509Crl->getTbsInfo(g_x509Crl, &tbsCertListOut);
1064     EXPECT_EQ(ret, CF_SUCCESS);
1065     EXPECT_NE(tbsCertListOut.data, nullptr);
1066     CfFree(tbsCertListOut.data);
1067 }
1068 
1069 // Test crl getTbsInfo false
1070 HWTEST_F(CryptoX509CrlTest, X509CrlTest162, TestSize.Level0)
1071 {
1072     ASSERT_NE(g_x509Crl, nullptr);
1073     CfBlob tbsCertListOut = { 0, nullptr };
1074     CfResult ret = g_x509Crl->getTbsInfo(nullptr, &tbsCertListOut);
1075     EXPECT_NE(ret, CF_SUCCESS);
1076     EXPECT_EQ(tbsCertListOut.data, nullptr);
1077 }
1078 
1079 // Test crl  getTbsInfo false
1080 HWTEST_F(CryptoX509CrlTest, X509CrlTest163, TestSize.Level0)
1081 {
1082     ASSERT_NE(g_x509Crl, nullptr);
1083     CfResult ret = g_x509Crl->getTbsInfo(g_x509Crl, nullptr);
1084     EXPECT_NE(ret, CF_SUCCESS);
1085 }
1086 
1087 // Test crl getTbsInfo false
1088 HWTEST_F(CryptoX509CrlTest, X509CrlTest164, TestSize.Level0)
1089 {
1090     ASSERT_NE(g_x509Crl, nullptr);
1091     CfResult ret = g_x509Crl->getTbsInfo(nullptr, nullptr);
1092     EXPECT_NE(ret, CF_SUCCESS);
1093 }
1094 
1095 // Test crl getSignature true
1096 HWTEST_F(CryptoX509CrlTest, X509CrlTest171, TestSize.Level0)
1097 {
1098     ASSERT_NE(g_x509Crl, nullptr);
1099     CfBlob signature = { 0, nullptr };
1100     CfResult ret = g_x509Crl->getSignature(g_x509Crl, &signature);
1101     EXPECT_EQ(ret, CF_SUCCESS);
1102     EXPECT_NE(signature.data, nullptr);
1103     CfFree(signature.data);
1104 }
1105 
1106 // Test crl getSignature false
1107 HWTEST_F(CryptoX509CrlTest, X509CrlTest172, TestSize.Level0)
1108 {
1109     ASSERT_NE(g_x509Crl, nullptr);
1110     CfBlob signature = { 0, nullptr };
1111     CfResult ret = g_x509Crl->getSignature(nullptr, &signature);
1112     EXPECT_NE(ret, CF_SUCCESS);
1113     EXPECT_EQ(signature.data, nullptr);
1114 }
1115 
1116 // Test crl getSignature false
1117 HWTEST_F(CryptoX509CrlTest, X509CrlTest173, TestSize.Level0)
1118 {
1119     ASSERT_NE(g_x509Crl, nullptr);
1120     CfResult ret = g_x509Crl->getSignature(g_x509Crl, nullptr);
1121     EXPECT_NE(ret, CF_SUCCESS);
1122 }
1123 
1124 // Test crl getSignature false
1125 HWTEST_F(CryptoX509CrlTest, X509CrlTest174, TestSize.Level0)
1126 {
1127     ASSERT_NE(g_x509Crl, nullptr);
1128     CfResult ret = g_x509Crl->getSignature(nullptr, nullptr);
1129     EXPECT_NE(ret, CF_SUCCESS);
1130 }
1131 
1132 // Test crl getSignatureAlgName true
1133 HWTEST_F(CryptoX509CrlTest, X509CrlTest181, TestSize.Level0)
1134 {
1135     ASSERT_NE(g_x509Crl, nullptr);
1136     CfBlob out = { 0, nullptr };
1137     CfResult ret = g_x509Crl->getSignatureAlgName(g_x509Crl, &out);
1138     EXPECT_EQ(ret, CF_SUCCESS);
1139     EXPECT_NE(out.data, nullptr);
1140     EXPECT_STREQ("SHA256withRSA", reinterpret_cast<char *>(out.data));
1141     CfFree(out.data);
1142 }
1143 
1144 // Test crl getSignatureAlgName false
1145 HWTEST_F(CryptoX509CrlTest, X509CrlTest182, TestSize.Level0)
1146 {
1147     ASSERT_NE(g_x509Crl, nullptr);
1148     CfBlob out = { 0, nullptr };
1149     CfResult ret = g_x509Crl->getSignatureAlgName(nullptr, &out);
1150     EXPECT_NE(ret, CF_SUCCESS);
1151     EXPECT_EQ(out.data, nullptr);
1152 }
1153 
1154 // Test crl getSignatureAlgName false
1155 HWTEST_F(CryptoX509CrlTest, X509CrlTest183, TestSize.Level0)
1156 {
1157     ASSERT_NE(g_x509Crl, nullptr);
1158     CfResult ret = g_x509Crl->getSignatureAlgName(g_x509Crl, nullptr);
1159     EXPECT_NE(ret, CF_SUCCESS);
1160 }
1161 
1162 // Test crl getSignatureAlgName false
1163 HWTEST_F(CryptoX509CrlTest, X509CrlTest184, TestSize.Level0)
1164 {
1165     ASSERT_NE(g_x509Crl, nullptr);
1166     CfResult ret = g_x509Crl->getSignatureAlgName(nullptr, nullptr);
1167     EXPECT_NE(ret, CF_SUCCESS);
1168 }
1169 
1170 // Test crl getSignatureAlgOid true
1171 HWTEST_F(CryptoX509CrlTest, X509CrlTest191, TestSize.Level0)
1172 {
1173     ASSERT_NE(g_x509Crl, nullptr);
1174     CfBlob out = { 0, nullptr };
1175     CfResult ret = g_x509Crl->getSignatureAlgOid(g_x509Crl, &out);
1176     EXPECT_EQ(ret, CF_SUCCESS);
1177     EXPECT_NE(out.data, nullptr);
1178     EXPECT_STREQ("1.2.840.113549.1.1.11", reinterpret_cast<char *>(out.data));
1179     CfFree(out.data);
1180 }
1181 
1182 // Test crl getSignatureAlgOid false
1183 HWTEST_F(CryptoX509CrlTest, X509CrlTest192, TestSize.Level0)
1184 {
1185     ASSERT_NE(g_x509Crl, nullptr);
1186     CfBlob out = { 0, nullptr };
1187     CfResult ret = g_x509Crl->getSignatureAlgOid(nullptr, &out);
1188     EXPECT_NE(ret, CF_SUCCESS);
1189     EXPECT_EQ(out.data, nullptr);
1190 }
1191 
1192 // Test crl getSignatureAlgOid false
1193 HWTEST_F(CryptoX509CrlTest, X509CrlTest193, TestSize.Level0)
1194 {
1195     ASSERT_NE(g_x509Crl, nullptr);
1196     CfResult ret = g_x509Crl->getSignatureAlgOid(g_x509Crl, nullptr);
1197     EXPECT_NE(ret, CF_SUCCESS);
1198 }
1199 
1200 // Test crl getSignatureAlgOid false
1201 HWTEST_F(CryptoX509CrlTest, X509CrlTest194, TestSize.Level0)
1202 {
1203     ASSERT_NE(g_x509Crl, nullptr);
1204     CfResult ret = g_x509Crl->getSignatureAlgOid(nullptr, nullptr);
1205     EXPECT_NE(ret, CF_SUCCESS);
1206 }
1207 
1208 // Test crl getSignatureAlgParams true
1209 HWTEST_F(CryptoX509CrlTest, X509CrlTest201, TestSize.Level0)
1210 {
1211     ASSERT_NE(g_x509Crl, nullptr);
1212     CfBlob sigAlgParamOut = { 0, nullptr };
1213     CfResult ret = g_x509Crl->getSignatureAlgParams(g_x509Crl, &sigAlgParamOut);
1214     EXPECT_EQ(ret, CF_SUCCESS);
1215     EXPECT_NE(sigAlgParamOut.data, nullptr);
1216     CfFree(sigAlgParamOut.data);
1217 }
1218 
1219 // Test crl getSignatureAlgParams false
1220 HWTEST_F(CryptoX509CrlTest, X509CrlTest202, TestSize.Level0)
1221 {
1222     ASSERT_NE(g_x509Crl, nullptr);
1223     CfBlob sigAlgParamOut = { 0, nullptr };
1224     CfResult ret = g_x509Crl->getSignatureAlgParams(nullptr, &sigAlgParamOut);
1225     EXPECT_NE(ret, CF_SUCCESS);
1226     EXPECT_EQ(sigAlgParamOut.data, nullptr);
1227 }
1228 
1229 // Test crl getSignatureAlgParams false
1230 HWTEST_F(CryptoX509CrlTest, X509CrlTest203, TestSize.Level0)
1231 {
1232     ASSERT_NE(g_x509Crl, nullptr);
1233     CfResult ret = g_x509Crl->getSignatureAlgParams(g_x509Crl, nullptr);
1234     EXPECT_NE(ret, CF_SUCCESS);
1235 }
1236 
1237 // Test crl getSignatureAlgParams false
1238 HWTEST_F(CryptoX509CrlTest, X509CrlTest204, TestSize.Level0)
1239 {
1240     ASSERT_NE(g_x509Crl, nullptr);
1241     CfResult ret = g_x509Crl->getSignatureAlgParams(nullptr, nullptr);
1242     EXPECT_NE(ret, CF_SUCCESS);
1243 }
1244 
1245 // Test crl getExtensions return CF_INVALID_PARAMS
1246 HWTEST_F(CryptoX509CrlTest, X509CrlTest205, TestSize.Level0)
1247 {
1248     ASSERT_NE(g_x509Crl, nullptr);
1249     CfBlob blobOut = { 0, nullptr };
1250     CfResult ret = g_x509Crl->getExtensions(nullptr, &blobOut);
1251     EXPECT_EQ(ret, CF_INVALID_PARAMS);
1252     EXPECT_EQ(blobOut.data, nullptr);
1253 }
1254 
1255 // Test crl getExtensions return CF_INVALID_PARAMS
1256 HWTEST_F(CryptoX509CrlTest, X509CrlTest206, TestSize.Level0)
1257 {
1258     ASSERT_NE(g_x509Crl, nullptr);
1259     CfResult ret = g_x509Crl->getExtensions(g_x509Crl, nullptr);
1260     EXPECT_EQ(ret, CF_INVALID_PARAMS);
1261 }
1262 
1263 // Test crl getExtensions while there is no extension in the crl, return CF_SUCCESS
1264 HWTEST_F(CryptoX509CrlTest, X509CrlTest207, TestSize.Level0)
1265 {
1266     HcfX509Crl *x509Crl = nullptr;
1267     int32_t nRet = HcfX509CrlCreate(&g_crlWithoutExtPemInStream, &x509Crl);
1268     ASSERT_EQ(nRet, 0);
1269 
1270     CfBlob blobOut = { 0, nullptr };
1271     CfResult cfRet = x509Crl->getExtensions(x509Crl, &blobOut);
1272     EXPECT_EQ(cfRet, CF_SUCCESS);
1273     EXPECT_EQ(blobOut.data, nullptr);
1274     CfFree(blobOut.data);
1275     CfObjDestroy(x509Crl);
1276 }
1277 
1278 // Test crl getExtensions while there are extensions in the crl, return CF_SUCCESS
1279 HWTEST_F(CryptoX509CrlTest, X509CrlTest208, TestSize.Level0)
1280 {
1281     ASSERT_NE(g_x509Crl, nullptr);
1282     CfBlob blobOut = { 0, nullptr };
1283     CfResult ret = g_x509Crl->getExtensions(g_x509Crl, &blobOut);
1284     EXPECT_EQ(ret, CF_SUCCESS);
1285     EXPECT_NE(blobOut.data, nullptr);
1286     CfFree(blobOut.data);
1287 }
1288 
1289 // Test crlEntry hasExtensions return false
1290 HWTEST_F(CryptoX509CrlTest, X509CrlTest209, TestSize.Level0)
1291 {
1292     ASSERT_NE(g_x509Crl, nullptr);
1293     HcfX509CrlEntry *crlEntry = nullptr;
1294     CfBlob testSnBlob = { 2, g_testSn };
1295     CfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, &testSnBlob, &crlEntry);
1296     EXPECT_EQ(ret, CF_SUCCESS);
1297     EXPECT_NE(crlEntry, nullptr);
1298 
1299     bool boolResult = true;
1300     CfResult result = crlEntry->hasExtensions(nullptr, &boolResult);
1301     EXPECT_EQ(result, CF_INVALID_PARAMS);
1302 
1303     CfObjDestroy(crlEntry);
1304 }
1305 
1306 // Test crlEntry hasExtensions  while there is no extension in the crlEntry,return CF_SUCCESS
1307 HWTEST_F(CryptoX509CrlTest, X509CrlTest210, TestSize.Level0)
1308 {
1309     ASSERT_NE(g_x509Crl, nullptr);
1310     HcfX509CrlEntry *crlEntry = nullptr;
1311     CfBlob testSnBlob = { 2, g_testSn };
1312     CfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, &testSnBlob, &crlEntry);
1313     EXPECT_EQ(ret, CF_SUCCESS);
1314     EXPECT_NE(crlEntry, nullptr);
1315 
1316     bool boolResult = false;
1317     CfResult result = crlEntry->hasExtensions(crlEntry, &boolResult);
1318     EXPECT_EQ(result, CF_SUCCESS);
1319     EXPECT_EQ(boolResult, false);
1320 
1321     CfObjDestroy(crlEntry);
1322 }
1323 
1324 // Test crlEntry hasExtensions  while there are extensions in the crlEntry,return CF_SUCCESS
1325 HWTEST_F(CryptoX509CrlTest, X509CrlTest211, TestSize.Level0)
1326 {
1327     HcfX509Crl *x509Crl = nullptr;
1328     int32_t nRet = HcfX509CrlCreate(&g_crlWhichEntryWithExtInStream, &x509Crl);
1329     ASSERT_EQ(nRet, 0);
1330 
1331     HcfX509CrlEntry *crlEntry = nullptr;
1332     uint8_t testSN[] = { 0xAB, 0xCD };
1333     CfBlob testSnBlob = { 2, testSN };
1334     CfResult ret = x509Crl->getRevokedCert(x509Crl, &testSnBlob, &crlEntry);
1335     EXPECT_EQ(ret, CF_SUCCESS);
1336     EXPECT_NE(crlEntry, nullptr);
1337 
1338     bool boolResult = false;
1339     CfResult result = crlEntry->hasExtensions(crlEntry, &boolResult);
1340     EXPECT_EQ(result, CF_SUCCESS);
1341     EXPECT_EQ(boolResult, true);
1342 
1343     CfObjDestroy(crlEntry);
1344     CfObjDestroy(x509Crl);
1345 }
1346 
1347 // Test crlEntry getExtensions,return CF_INVALID_PARAMS
1348 HWTEST_F(CryptoX509CrlTest, X509CrlTest212, TestSize.Level0)
1349 {
1350     ASSERT_NE(g_x509Crl, nullptr);
1351     HcfX509CrlEntry *crlEntry = nullptr;
1352     CfBlob testSnBlob = { 2, g_testSn };
1353     CfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, &testSnBlob, &crlEntry);
1354     EXPECT_EQ(ret, CF_SUCCESS);
1355     EXPECT_NE(crlEntry, nullptr);
1356 
1357     CfBlob blob = { 0, nullptr };
1358     ret = crlEntry->getExtensions(nullptr, &blob);
1359     EXPECT_EQ(ret, CF_INVALID_PARAMS);
1360     EXPECT_EQ(blob.data, nullptr);
1361 
1362     CfObjDestroy(crlEntry);
1363 }
1364 
1365 // Test crlEntry getExtensions,return CF_INVALID_PARAMS
1366 HWTEST_F(CryptoX509CrlTest, X509CrlTest213, TestSize.Level0)
1367 {
1368     ASSERT_NE(g_x509Crl, nullptr);
1369     HcfX509CrlEntry *crlEntry = nullptr;
1370     CfBlob testSnBlob = { 2, g_testSn };
1371     CfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, &testSnBlob, &crlEntry);
1372     EXPECT_EQ(ret, CF_SUCCESS);
1373     EXPECT_NE(crlEntry, nullptr);
1374 
1375     ret = crlEntry->getExtensions(crlEntry, nullptr);
1376     EXPECT_EQ(ret, CF_INVALID_PARAMS);
1377 
1378     CfObjDestroy(crlEntry);
1379 }
1380 
1381 // Test crlEntry getExtensions while there is no extension in crlEntry,return CF_SUCCESS
1382 HWTEST_F(CryptoX509CrlTest, X509CrlTest214, TestSize.Level0)
1383 {
1384     ASSERT_NE(g_x509Crl, nullptr);
1385     HcfX509CrlEntry *crlEntry = nullptr;
1386     CfBlob testSnBlob = { 2, g_testSn };
1387     CfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, &testSnBlob, &crlEntry);
1388     EXPECT_EQ(ret, CF_SUCCESS);
1389     EXPECT_NE(crlEntry, nullptr);
1390 
1391     CfBlob blob = { 0, nullptr };
1392     ret = crlEntry->getExtensions(crlEntry, &blob);
1393     EXPECT_EQ(ret, CF_SUCCESS);
1394     EXPECT_EQ(blob.size, 0);
1395     EXPECT_EQ(blob.data, nullptr);
1396 
1397     CfObjDestroy(crlEntry);
1398 }
1399 
1400 // Test crlEntry getExtensions while there is one extension in crlEntry,return CF_SUCCESS
1401 HWTEST_F(CryptoX509CrlTest, X509CrlTest215, TestSize.Level0)
1402 {
1403     HcfX509Crl *x509Crl = nullptr;
1404     int32_t nRet = HcfX509CrlCreate(&g_crlWhichEntryWithExtInStream, &x509Crl);
1405     ASSERT_EQ(nRet, 0);
1406 
1407     HcfX509CrlEntry *crlEntry = nullptr;
1408     uint8_t testSN[] = { 0xAB, 0xCD };
1409     CfBlob testSnBlob = { 2, testSN };
1410     CfResult ret = x509Crl->getRevokedCert(x509Crl, &testSnBlob, &crlEntry);
1411     EXPECT_EQ(ret, CF_SUCCESS);
1412     EXPECT_NE(crlEntry, nullptr);
1413 
1414     CfBlob blob = { 0, nullptr };
1415     ret = crlEntry->getExtensions(crlEntry, &blob);
1416     EXPECT_EQ(ret, CF_SUCCESS);
1417     EXPECT_NE(blob.size, 0);
1418     EXPECT_NE(blob.data, nullptr);
1419 
1420     CfObjDestroy(crlEntry);
1421     CfFree(blob.data);
1422     CfObjDestroy(x509Crl);
1423 }
1424 
1425 // Test crlEntry getExtensions while there are more than one extensions in crlEntry,return CF_SUCCESS
1426 HWTEST_F(CryptoX509CrlTest, X509CrlTest216, TestSize.Level0)
1427 {
1428     ASSERT_NE(g_x509Crl, nullptr);
1429     HcfX509CrlEntry *crlEntry = nullptr;
1430     CfBlob testSnBlob = { 2, g_testSn };
1431     CfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, &testSnBlob, &crlEntry);
1432     EXPECT_EQ(ret, CF_SUCCESS);
1433     EXPECT_NE(crlEntry, nullptr);
1434 
1435     CfBlob blob = { 0, nullptr };
1436     ret = crlEntry->getExtensions(crlEntry, &blob);
1437     EXPECT_EQ(ret, CF_SUCCESS);
1438 
1439     CfObjDestroy(crlEntry);
1440     CfFree(blob.data);
1441 }
1442 
1443 // Test crlEntry getRevokedCert while there is a big num serialNumber,return CF_SUCCESS
1444 HWTEST_F(CryptoX509CrlTest, X509CrlTest217, TestSize.Level0)
1445 {
1446     HcfX509Crl *x509Crl = nullptr;
1447     int32_t nRet = HcfX509CrlCreate(&g_crlWithBignumSerialInStream, &x509Crl);
1448     ASSERT_EQ(nRet, 0);
1449     ASSERT_NE(x509Crl, nullptr);
1450 
1451     HcfX509CrlEntry *crlEntry = nullptr;
1452     // Serial Number: FF01FF01FF01FF01FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF01
1453     uint8_t testSn[] = { 0xFF, 0x01, 0xFF, 0x01, 0xFF, 0x01, 0xFF, 0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1454         0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01 };
1455     CfBlob testSnBlob = { sizeof(testSn) / sizeof(testSn[0]), testSn };
1456     CfResult cfRet = x509Crl->getRevokedCert(x509Crl, &testSnBlob, &crlEntry);
1457     EXPECT_EQ(cfRet, CF_SUCCESS);
1458     EXPECT_NE(crlEntry, nullptr);
1459 
1460     CfObjDestroy(crlEntry);
1461     CfObjDestroy(x509Crl);
1462 }
1463 
1464 // Test crlEntry hasExtensions return false
1465 HWTEST_F(CryptoX509CrlTest, X509CrlTest218, TestSize.Level0)
1466 {
1467     ASSERT_NE(g_x509Crl, nullptr);
1468     HcfX509CrlEntry *crlEntry = nullptr;
1469     CfBlob testSnBlob = { 2, g_testSn };
1470     CfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, &testSnBlob, &crlEntry);
1471     EXPECT_EQ(ret, CF_SUCCESS);
1472     EXPECT_NE(crlEntry, nullptr);
1473 
1474     bool boolResult = true;
1475     CfObjectBase obj = { GetInvalidCrlClass, nullptr };
1476     CfResult result = crlEntry->hasExtensions((HcfX509CrlEntry *)&obj, &boolResult);
1477     EXPECT_EQ(result, CF_INVALID_PARAMS);
1478 
1479     CfObjDestroy(crlEntry);
1480 }
1481 
1482 // Test crlEntry getExtensions return false
1483 HWTEST_F(CryptoX509CrlTest, X509CrlTest219, TestSize.Level0)
1484 {
1485     ASSERT_NE(g_x509Crl, nullptr);
1486     HcfX509CrlEntry *crlEntry = nullptr;
1487     CfBlob testSnBlob = { 2, g_testSn };
1488     CfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, &testSnBlob, &crlEntry);
1489     EXPECT_EQ(ret, CF_SUCCESS);
1490     EXPECT_NE(crlEntry, nullptr);
1491 
1492     CfBlob blob = { 0, nullptr };
1493     CfObjectBase obj = { GetInvalidCrlClass, nullptr };
1494     CfResult result = crlEntry->getExtensions((HcfX509CrlEntry *)&obj, &blob);
1495     EXPECT_EQ(result, CF_INVALID_PARAMS);
1496 
1497     CfObjDestroy(crlEntry);
1498 }
1499 
1500 HWTEST_F(CryptoX509CrlTest, NullSpi, TestSize.Level0)
1501 {
1502     HcfX509CrlSpi *spiObj = nullptr;
1503     CfBlob serialBlob = { 0, nullptr };
1504     SetMockFlag(true);
1505     (void)HcfCX509CrlSpiCreate(&g_crlDerInStream, &spiObj);
1506     SetMockFlag(false);
1507     (void)HcfCX509CrlSpiCreate(nullptr, &spiObj);
1508     CfEncodingBlob blob = { nullptr, 0, CF_FORMAT_DER };
1509     (void)HcfCX509CrlSpiCreate(&blob, &spiObj);
1510     (void)HcfCX509CrlSpiCreate(&g_crlDerInStream, nullptr);
1511 
1512     CfResult ret = HcfCX509CrlSpiCreate(&g_crlDerInStream, &spiObj);
1513     EXPECT_EQ(ret, CF_SUCCESS);
1514     EXPECT_NE(spiObj, nullptr);
1515 
1516     (void)spiObj->base.destroy(nullptr);
1517     const char *tmp = spiObj->engineGetType(nullptr);
1518     EXPECT_EQ(tmp, nullptr);
1519     bool flag = spiObj->engineIsRevoked(nullptr, nullptr);
1520     EXPECT_EQ(flag, false);
1521     ret = spiObj->engineGetEncoded(nullptr, nullptr);
1522     EXPECT_NE(ret, CF_SUCCESS);
1523     ret = spiObj->engineVerify(nullptr, nullptr);
1524     EXPECT_NE(ret, CF_SUCCESS);
1525     long ver = spiObj->engineGetVersion(nullptr);
1526     EXPECT_EQ(ver, -1);
1527     ret = spiObj->engineGetIssuerName(nullptr, nullptr);
1528     EXPECT_NE(ret, CF_SUCCESS);
1529     ret = spiObj->engineGetLastUpdate(nullptr, nullptr);
1530     EXPECT_NE(ret, CF_SUCCESS);
1531     ret = spiObj->engineGetNextUpdate(nullptr, nullptr);
1532     EXPECT_NE(ret, CF_SUCCESS);
1533     ret = spiObj->engineGetRevokedCert(nullptr, &serialBlob, nullptr);
1534     EXPECT_NE(ret, CF_SUCCESS);
1535     ret = spiObj->engineGetRevokedCertWithCert(nullptr, nullptr, nullptr);
1536     EXPECT_NE(ret, CF_SUCCESS);
1537     ret = spiObj->engineGetRevokedCerts(nullptr, nullptr);
1538     EXPECT_NE(ret, CF_SUCCESS);
1539     ret = spiObj->engineGetTbsInfo(nullptr, nullptr);
1540     EXPECT_NE(ret, CF_SUCCESS);
1541     ret = spiObj->engineGetSignature(nullptr, nullptr);
1542     EXPECT_NE(ret, CF_SUCCESS);
1543     ret = spiObj->engineGetSignatureAlgName(nullptr, nullptr);
1544     EXPECT_NE(ret, CF_SUCCESS);
1545     ret = spiObj->engineGetSignatureAlgOid(nullptr, nullptr);
1546     EXPECT_NE(ret, CF_SUCCESS);
1547     ret = spiObj->engineGetSignatureAlgParams(nullptr, nullptr);
1548     EXPECT_NE(ret, CF_SUCCESS);
1549     ret = spiObj->engineMatch(nullptr, nullptr, nullptr);
1550     EXPECT_NE(ret, CF_SUCCESS);
1551 
1552     CfObjDestroy(spiObj);
1553 }
1554 
1555 HWTEST_F(CryptoX509CrlTest, NullSpi2, TestSize.Level0)
1556 {
1557     HcfX509CrlSpi *spiObj = nullptr;
1558     CfBlob out = { 0, nullptr };
1559 
1560     CfResult ret = HcfCX509CrlSpiCreate(&g_crlDerInStream, &spiObj);
1561     EXPECT_EQ(ret, CF_SUCCESS);
1562     EXPECT_NE(spiObj, nullptr);
1563 
1564     ret = spiObj->engineGetExtensions(nullptr, &out);
1565     EXPECT_EQ(ret, CF_INVALID_PARAMS);
1566     CfObjDestroy(spiObj);
1567 }
1568 
1569 HWTEST_F(CryptoX509CrlTest, InvalidCrlSpiClass, TestSize.Level0)
1570 {
1571     HcfX509CrlSpi invalidSpi = { { 0 } };
1572     CfBlob serialBlob = { 0, nullptr };
1573     invalidSpi.base.getClass = GetInvalidCrlClass;
1574     CfBlob invalidOut = { 0, nullptr };
1575     CfEncodingBlob encoding = { nullptr, 0, CF_FORMAT_PEM };
1576     HcfX509CrlEntry *entry = nullptr;
1577     HcfX509CrlSpi *spiObj = nullptr;
1578     CfResult ret = HcfCX509CrlSpiCreate(&g_crlDerInStream, &spiObj);
1579     (void)spiObj->base.destroy(&(invalidSpi.base));
1580     const char *tmp = spiObj->engineGetType(&invalidSpi);
1581     EXPECT_EQ(tmp, nullptr);
1582     HcfCertificate cert;
1583     bool flag = spiObj->engineIsRevoked(&invalidSpi, &cert);
1584     EXPECT_EQ(flag, false);
1585     ret = spiObj->engineGetEncoded(&invalidSpi, &encoding);
1586     EXPECT_NE(ret, CF_SUCCESS);
1587     HcfPubKey pubKey;
1588     ret = spiObj->engineVerify(&invalidSpi, &pubKey);
1589     EXPECT_NE(ret, CF_SUCCESS);
1590     long ver = spiObj->engineGetVersion(&invalidSpi);
1591     EXPECT_EQ(ver, -1);
1592     ret = spiObj->engineGetIssuerName(&invalidSpi, &invalidOut);
1593     EXPECT_NE(ret, CF_SUCCESS);
1594     ret = spiObj->engineGetLastUpdate(&invalidSpi, &invalidOut);
1595     EXPECT_NE(ret, CF_SUCCESS);
1596     ret = spiObj->engineGetNextUpdate(&invalidSpi, &invalidOut);
1597     EXPECT_NE(ret, CF_SUCCESS);
1598     ret = spiObj->engineGetRevokedCert(&invalidSpi, &serialBlob, &entry);
1599     EXPECT_NE(ret, CF_SUCCESS);
1600 
1601     HcfX509Certificate x509Cert;
1602     ret = spiObj->engineGetRevokedCertWithCert(&invalidSpi, &x509Cert, &entry);
1603     EXPECT_NE(ret, CF_SUCCESS);
1604     CfArray invalidArr = { nullptr, CF_FORMAT_PEM, 0 };
1605     ret = spiObj->engineGetRevokedCerts(&invalidSpi, &invalidArr);
1606     EXPECT_NE(ret, CF_SUCCESS);
1607     ret = spiObj->engineGetTbsInfo(&invalidSpi, &invalidOut);
1608     EXPECT_NE(ret, CF_SUCCESS);
1609     ret = spiObj->engineGetSignature(&invalidSpi, &invalidOut);
1610     EXPECT_NE(ret, CF_SUCCESS);
1611     ret = spiObj->engineGetSignatureAlgName(&invalidSpi, &invalidOut);
1612     EXPECT_NE(ret, CF_SUCCESS);
1613     ret = spiObj->engineGetSignatureAlgOid(&invalidSpi, &invalidOut);
1614     EXPECT_NE(ret, CF_SUCCESS);
1615     ret = spiObj->engineGetSignatureAlgParams(&invalidSpi, &invalidOut);
1616     EXPECT_NE(ret, CF_SUCCESS);
1617     CfObjDestroy(spiObj);
1618 }
1619 
1620 HWTEST_F(CryptoX509CrlTest, InvalidCrlSpiClass2, TestSize.Level0)
1621 {
1622     HcfX509CrlSpi invalidSpi = { { 0 } };
1623     invalidSpi.base.getClass = GetInvalidCrlClass;
1624     HcfX509CrlEntry *entry = nullptr;
1625     HcfX509CrlSpi *spiObj = nullptr;
1626     CfResult ret = HcfCX509CrlSpiCreate(&g_crlDerInStream, &spiObj);
1627 
1628     CfBlob testSnBlob = { 2, g_testSn };
1629     ret = spiObj->engineGetRevokedCert(&invalidSpi, &testSnBlob, &entry);
1630     EXPECT_NE(ret, CF_SUCCESS);
1631 
1632     HcfX509CrlMatchParams matchParams;
1633     bool bOut = true;
1634     ret = spiObj->engineMatch(&invalidSpi, &matchParams, &bOut);
1635     EXPECT_NE(ret, CF_SUCCESS);
1636     CfObjDestroy(spiObj);
1637 }
1638 
1639 HWTEST_F(CryptoX509CrlTest, InvalidCrlClass, TestSize.Level0)
1640 {
1641     ASSERT_NE(g_x509Crl, nullptr);
1642     CfBlob serialBlob = { 0, nullptr };
1643     HcfX509Crl invalidCrl;
1644     invalidCrl.base.base.getClass = GetInvalidCrlClass;
1645     CfBlob invalidOut = { 0, nullptr };
1646     CfEncodingBlob encoding = { nullptr, 0, CF_FORMAT_PEM };
1647     HcfX509CrlEntry *entry = nullptr;
1648 
1649     g_x509Crl->base.base.destroy(nullptr);
1650     g_x509Crl->base.base.destroy(&(invalidCrl.base.base));
1651     const char *tmp = g_x509Crl->base.getType(&(invalidCrl.base));
1652     EXPECT_EQ(tmp, nullptr);
1653     HcfCertificate cert;
1654     bool flag = g_x509Crl->base.isRevoked(&(invalidCrl.base), &cert);
1655     EXPECT_EQ(flag, false);
1656     CfResult ret = g_x509Crl->getEncoded(&invalidCrl, &encoding);
1657     EXPECT_NE(ret, CF_SUCCESS);
1658     HcfPubKey pubKey;
1659     ret = g_x509Crl->verify(&invalidCrl, &pubKey);
1660     EXPECT_NE(ret, CF_SUCCESS);
1661     long ver = g_x509Crl->getVersion(&invalidCrl);
1662     EXPECT_EQ(ver, -1);
1663     ret = g_x509Crl->getIssuerName(&invalidCrl, &invalidOut);
1664     EXPECT_NE(ret, CF_SUCCESS);
1665     ret = g_x509Crl->getLastUpdate(&invalidCrl, &invalidOut);
1666     EXPECT_NE(ret, CF_SUCCESS);
1667     ret = g_x509Crl->getNextUpdate(&invalidCrl, &invalidOut);
1668     EXPECT_NE(ret, CF_SUCCESS);
1669     ret = g_x509Crl->getRevokedCert(&invalidCrl, &serialBlob, &entry);
1670     EXPECT_NE(ret, CF_SUCCESS);
1671     HcfX509Certificate x509Cert;
1672     ret = g_x509Crl->getRevokedCertWithCert(&invalidCrl, &x509Cert, &entry);
1673     EXPECT_NE(ret, CF_SUCCESS);
1674     CfArray invalidArr = { nullptr, CF_FORMAT_PEM, 0 };
1675     ret = g_x509Crl->getRevokedCerts(&invalidCrl, &invalidArr);
1676     EXPECT_NE(ret, CF_SUCCESS);
1677     ret = g_x509Crl->getTbsInfo(&invalidCrl, &invalidOut);
1678     EXPECT_NE(ret, CF_SUCCESS);
1679     ret = g_x509Crl->getSignature(&invalidCrl, &invalidOut);
1680     EXPECT_NE(ret, CF_SUCCESS);
1681     ret = g_x509Crl->getSignatureAlgName(&invalidCrl, &invalidOut);
1682     EXPECT_NE(ret, CF_SUCCESS);
1683     ret = g_x509Crl->getSignatureAlgOid(&invalidCrl, &invalidOut);
1684     EXPECT_NE(ret, CF_SUCCESS);
1685     ret = g_x509Crl->getSignatureAlgParams(&invalidCrl, &invalidOut);
1686     EXPECT_NE(ret, CF_SUCCESS);
1687 }
1688 
1689 HWTEST_F(CryptoX509CrlTest, InvalidCrlClass2, TestSize.Level0)
1690 {
1691     HcfX509CrlMatchParams matchParams;
1692     HcfX509Crl invalidCrl;
1693     invalidCrl.base.base.getClass = GetInvalidCrlClass;
1694     bool bOut = true;
1695     CfResult ret = g_x509Crl->match(&invalidCrl, &matchParams, &bOut);
1696     EXPECT_NE(ret, CF_SUCCESS);
1697 }
1698 
1699 HWTEST_F(CryptoX509CrlTest, InvalidMalloc, TestSize.Level0)
1700 {
1701     ASSERT_NE(g_x509Crl, nullptr);
1702     SetMockFlag(true);
1703     CfBlob out = { 0, nullptr };
1704     CfEncodingBlob encoding = { nullptr, 0, CF_FORMAT_PEM };
1705     HcfX509CrlEntry *entry = nullptr;
1706     CfResult ret = g_x509Crl->getEncoded(g_x509Crl, &encoding);
1707     EXPECT_NE(ret, CF_SUCCESS);
1708     ret = g_x509Crl->getIssuerName(g_x509Crl, &out);
1709     EXPECT_NE(ret, CF_SUCCESS);
1710     ret = g_x509Crl->getLastUpdate(g_x509Crl, &out);
1711     EXPECT_NE(ret, CF_SUCCESS);
1712     ret = g_x509Crl->getNextUpdate(g_x509Crl, &out);
1713     EXPECT_NE(ret, CF_SUCCESS);
1714     ret = g_x509Crl->getRevokedCert(g_x509Crl, &out, &entry);
1715     EXPECT_NE(ret, CF_SUCCESS);
1716     CfArray arr = { nullptr, CF_FORMAT_PEM, 0 };
1717     ret = g_x509Crl->getRevokedCerts(g_x509Crl, &arr);
1718     EXPECT_NE(ret, CF_SUCCESS);
1719     ret = g_x509Crl->getTbsInfo(g_x509Crl, &out);
1720     EXPECT_NE(ret, CF_SUCCESS);
1721     ret = g_x509Crl->getSignature(g_x509Crl, &out);
1722     EXPECT_NE(ret, CF_SUCCESS);
1723     ret = g_x509Crl->getSignatureAlgName(g_x509Crl, &out);
1724     EXPECT_NE(ret, CF_SUCCESS);
1725     ret = g_x509Crl->getSignatureAlgOid(g_x509Crl, &out);
1726     EXPECT_NE(ret, CF_SUCCESS);
1727     ret = g_x509Crl->getSignatureAlgParams(g_x509Crl, &out);
1728     EXPECT_NE(ret, CF_SUCCESS);
1729     SetMockFlag(false);
1730 }
1731 
1732 HWTEST_F(CryptoX509CrlTest, HcfCX509CRLEntryCreateInvalid, TestSize.Level0)
1733 {
1734     SetMockFlag(true);
1735     X509_REVOKED *rev = X509_REVOKED_new();
1736     HcfX509CrlEntry *crlEntryOut = nullptr;
1737     CfBlob certIssuer;
1738     CfResult ret = HcfCX509CRLEntryCreate(rev, &crlEntryOut, &certIssuer);
1739     EXPECT_NE(ret, CF_SUCCESS);
1740     SetMockFlag(false);
1741 
1742     ret = HcfCX509CRLEntryCreate(nullptr, &crlEntryOut, &certIssuer);
1743     EXPECT_NE(ret, CF_SUCCESS);
1744 
1745     ret = HcfCX509CRLEntryCreate(rev, nullptr, &certIssuer);
1746     EXPECT_NE(ret, CF_SUCCESS);
1747 
1748     ret = HcfCX509CRLEntryCreate(rev, &crlEntryOut, nullptr);
1749     EXPECT_NE(ret, CF_SUCCESS);
1750 
1751     ret = HcfCX509CRLEntryCreate(rev, &crlEntryOut, &certIssuer);
1752     EXPECT_NE(ret, CF_SUCCESS);
1753 
1754     X509_REVOKED_free(rev);
1755 }
1756 
1757 HWTEST_F(CryptoX509CrlTest, CompareUpdateDateTimeTest001, TestSize.Level0)
1758 {
1759     CF_LOG_I("CompareUpdateDateTimeTest001");
1760     HcfX509CrlSpi *spiObj = nullptr;
1761     CfResult ret = HcfCX509CrlSpiCreate(&g_crlDerInStream, &spiObj);
1762 
1763     HcfX509CrlMatchParams matchParams;
1764     CfBlob blob;
1765     blob.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_testUpdateDateTime));
1766     blob.size = strlen(g_testUpdateDateTime) + 1;
1767     matchParams.updateDateTime = &blob;
1768 
1769     bool bOut = true;
1770     ret = spiObj->engineMatch(spiObj, &matchParams, &bOut);
1771     EXPECT_EQ(ret, CF_SUCCESS);
1772     CfObjDestroy(spiObj);
1773 }
1774 
1775 HWTEST_F(CryptoX509CrlTest, CompareMaxCRLTest001, TestSize.Level0)
1776 {
1777     CF_LOG_I("CompareMaxCRLTest001");
1778     HcfX509CrlSpi *spiObj = nullptr;
1779     CfResult ret = HcfCX509CrlSpiCreate(&g_crlDerInStream, &spiObj);
1780 
1781     HcfX509CrlMatchParams matchParams;
1782     CfBlob blob;
1783     blob.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_testUpdateDateTime));
1784     blob.size = strlen(g_testUpdateDateTime) + 1;
1785     matchParams.maxCRL = &blob;
1786 
1787     bool bOut = true;
1788     ret = spiObj->engineMatch(spiObj, &matchParams, &bOut);
1789     EXPECT_EQ(ret, CF_SUCCESS);
1790 
1791     CfObjDestroy(spiObj);
1792 }
1793 
1794 HWTEST_F(CryptoX509CrlTest, CompareMinCRLTest001, TestSize.Level0)
1795 {
1796     CF_LOG_I("CompareMinCRLTest001");
1797     HcfX509CrlSpi *spiObj = nullptr;
1798     CfResult ret = HcfCX509CrlSpiCreate(&g_crlDerInStream, &spiObj);
1799 
1800     HcfX509CrlMatchParams matchParams;
1801     CfBlob blob;
1802     blob.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_testUpdateDateTime));
1803     blob.size = strlen(g_testUpdateDateTime) + 1;
1804     matchParams.minCRL = &blob;
1805 
1806     bool bOut = true;
1807     ret = spiObj->engineMatch(spiObj, &matchParams, &bOut);
1808     EXPECT_EQ(ret, CF_SUCCESS);
1809 
1810     CfObjDestroy(spiObj);
1811 }
1812 
1813 HWTEST_F(CryptoX509CrlTest, GetX509FromCertificateBranchTest, TestSize.Level0)
1814 {
1815     CF_LOG_I("GetX509FromCertificateBranchTest");
1816     HcfX509CrlSpi invalidSpi = { { 0 } };
1817     invalidSpi.base.getClass = GetValidCrlClass;
1818     HcfX509CrlEntry *entry = nullptr;
1819     HcfX509CrlSpi *spiObj = nullptr;
1820 
1821     // test ParseX509CRL invalid encodingFormat
1822     CfResult ret = HcfCX509CrlSpiCreate(&g_invalidCrlDerInStream, &spiObj);
1823     EXPECT_EQ(ret, CF_INVALID_PARAMS);
1824 
1825     ret = HcfCX509CrlSpiCreate(&g_crlDerInStream, &spiObj);
1826     EXPECT_EQ(ret, CF_SUCCESS);
1827 
1828     HcfCertificate cert;
1829     cert.base.getClass = GetInvalidCertClass;
1830     bool flag = spiObj->engineIsRevoked(&invalidSpi, &cert);
1831     EXPECT_EQ(flag, false);
1832 
1833     HcfX509Certificate x509Cert;
1834     x509Cert.base.base.getClass = GetInvalidCertClass;
1835     ret = spiObj->engineGetRevokedCertWithCert(&invalidSpi, &x509Cert, &entry);
1836     EXPECT_EQ(ret, CF_INVALID_PARAMS);
1837 
1838     x509Cert.base.base.getClass = GetValidX509CertificateClass;
1839     HcfX509CertificateImpl *impl = (HcfX509CertificateImpl *)(&x509Cert);
1840     HcfX509CertificateSpi spi;
1841     impl->spiObj = &spi;
1842     ((CfObjectBase *)(impl->spiObj))->getClass = GetInvalidCertClass;
1843     ret = spiObj->engineGetRevokedCertWithCert(&invalidSpi, &x509Cert, &entry);
1844     EXPECT_EQ(ret, CF_INVALID_PARAMS);
1845 
1846     CfObjDestroy(spiObj);
1847 }
1848 } // namespace
1849