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 
18 #include "cert_crl_collection.h"
19 #include "certificate_openssl_common.h"
20 #include "cf_api.h"
21 #include "cf_blob.h"
22 #include "cf_param.h"
23 #include "cf_result.h"
24 #include "cf_type.h"
25 #include "crypto_x509_test_common.h"
26 #include "memory_mock.h"
27 #include "securec.h"
28 #include "x509_certificate.h"
29 #include "x509_certificate_openssl.h"
30 
31 using namespace std;
32 using namespace testing::ext;
33 
34 namespace {
35 static HcfCertCrlCollection *g_x509CertCrlCollection = nullptr;
36 static HcfX509Certificate *g_x509CertObj = nullptr;
37 static HcfX509Crl *g_x509Crl = nullptr;
38 
39 class CryptoX509CertCrlCollectionTest : public testing::Test {
40 public:
41     static void SetUpTestCase(void);
42 
43     static void TearDownTestCase(void);
44 
45     void SetUp();
46 
47     void TearDown();
48 };
49 
SetUpTestCase(void)50 void CryptoX509CertCrlCollectionTest::SetUpTestCase(void)
51 {
52     CfEncodingBlob inStream = { 0 };
53     inStream.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_testSelfSignedCaCert));
54     inStream.encodingFormat = CF_FORMAT_PEM;
55     inStream.len = strlen(g_testSelfSignedCaCert) + 1;
56     CfResult ret = HcfX509CertificateCreate(&inStream, &g_x509CertObj);
57     ASSERT_EQ(ret, CF_SUCCESS);
58     ASSERT_NE(g_x509CertObj, nullptr);
59 
60     ret = HcfX509CrlCreate(&g_crlDerInStream, &g_x509Crl);
61     ASSERT_EQ(ret, CF_SUCCESS);
62     ASSERT_NE(g_x509Crl, nullptr);
63 
64     HcfX509CertificateArray certArray = { 0 };
65     HcfX509CrlArray crlArray = { 0 };
66 
67     certArray.data = static_cast<HcfX509Certificate **>(CfMalloc(1 * sizeof(HcfX509Certificate *), 0));
68     ASSERT_NE(certArray.data, nullptr);
69     certArray.data[0] = g_x509CertObj;
70     certArray.count = 1;
71 
72     crlArray.data = static_cast<HcfX509Crl **>(CfMalloc(1 * sizeof(HcfX509Crl *), 0));
73     ASSERT_NE(crlArray.data, nullptr);
74     crlArray.data[0] = g_x509Crl;
75     crlArray.count = 1;
76 
77     ret = HcfCertCrlCollectionCreate(&certArray, &crlArray, &g_x509CertCrlCollection);
78     ASSERT_EQ(ret, CF_SUCCESS);
79     ASSERT_NE(g_x509CertCrlCollection, nullptr);
80 
81     CfFree(certArray.data);
82     CfFree(crlArray.data);
83 }
84 
TearDownTestCase(void)85 void CryptoX509CertCrlCollectionTest::TearDownTestCase(void)
86 {
87     CfObjDestroy(g_x509CertObj);
88     CfObjDestroy(g_x509Crl);
89     CfObjDestroy(g_x509CertCrlCollection);
90 }
91 
SetUp()92 void CryptoX509CertCrlCollectionTest::SetUp() {}
93 
TearDown()94 void CryptoX509CertCrlCollectionTest::TearDown() {}
95 
GetInvalidCertCrlCollectionClass(void)96 static const char *GetInvalidCertCrlCollectionClass(void)
97 {
98     return "INVALID_CERT_CRL_COLLECTION_CLASS";
99 }
100 
FreeCertArrayData(HcfX509CertificateArray * certs)101 static void FreeCertArrayData(HcfX509CertificateArray *certs)
102 {
103     if (certs == NULL) {
104         return;
105     }
106     for (uint32_t i = 0; i < certs->count; ++i) {
107         CfObjDestroy(certs->data[i]);
108     }
109     CfFree(certs->data);
110     certs->data = NULL;
111     certs->count = 0;
112 }
113 
FreeCrlArrayData(HcfX509CrlArray * crls)114 static void FreeCrlArrayData(HcfX509CrlArray *crls)
115 {
116     if (crls == NULL) {
117         return;
118     }
119     for (uint32_t i = 0; i < crls->count; ++i) {
120         CfObjDestroy(crls->data[i]);
121     }
122     CfFree(crls->data);
123     crls->data = NULL;
124     crls->count = 0;
125 }
126 
127 HWTEST_F(CryptoX509CertCrlCollectionTest, SelectCertsTest001, TestSize.Level0)
128 {
129     ASSERT_NE(g_x509CertCrlCollection, nullptr);
130     HcfX509CertificateArray retCerts;
131     HcfX509CertMatchParams matchParams;
132     CfResult ret = g_x509CertCrlCollection->selectCerts(nullptr, &matchParams, &retCerts);
133     EXPECT_EQ(ret, CF_INVALID_PARAMS);
134 }
135 
136 HWTEST_F(CryptoX509CertCrlCollectionTest, SelectCertsTest002, TestSize.Level0)
137 {
138     HcfCertCrlCollection *invalidTypeCollection = nullptr;
139     HcfX509CertificateArray *certArray =
140         static_cast<HcfX509CertificateArray *>(CfMalloc(sizeof(HcfX509CertificateArray), 0));
141     ASSERT_NE(certArray, nullptr);
142 
143     HcfX509CrlArray *crlArray = static_cast<HcfX509CrlArray *>(CfMalloc(sizeof(HcfX509CrlArray), 0));
144     ASSERT_NE(crlArray, nullptr);
145 
146     CfResult ret = HcfCertCrlCollectionCreate(certArray, crlArray, &invalidTypeCollection);
147     ASSERT_EQ(ret, CF_SUCCESS);
148     ASSERT_NE(invalidTypeCollection, nullptr);
149     invalidTypeCollection->base.getClass = GetInvalidCertCrlCollectionClass;
150 
151     HcfX509CertMatchParams matchCertParams;
152     HcfX509CertificateArray retCerts;
153     ret = invalidTypeCollection->selectCerts(invalidTypeCollection, &matchCertParams, &retCerts);
154     EXPECT_EQ(ret, CF_INVALID_PARAMS);
155 
156     HcfX509CrlArray retCrls;
157     HcfX509CrlMatchParams matchCrlParams;
158     ret = invalidTypeCollection->selectCRLs(invalidTypeCollection, &matchCrlParams, &retCrls);
159     EXPECT_EQ(ret, CF_INVALID_PARAMS);
160 
161     // destroy invalid type class:failed
162     CfObjDestroy(invalidTypeCollection);
163 
164     // destroy normal type class:success
165     ASSERT_NE(g_x509CertCrlCollection, nullptr);
166     invalidTypeCollection->base.getClass = g_x509CertCrlCollection->base.getClass;
167     CfObjDestroy(invalidTypeCollection);
168 
169     CfFree(certArray);
170     CfFree(crlArray);
171     FreeCertArrayData(&retCerts);
172     FreeCrlArrayData(&retCrls);
173 }
174 
175 HWTEST_F(CryptoX509CertCrlCollectionTest, SelectCertsTest003, TestSize.Level0)
176 {
177     ASSERT_NE(g_x509CertCrlCollection, nullptr);
178     HcfX509CertMatchParams matchParams;
179     CfResult ret = g_x509CertCrlCollection->selectCerts(g_x509CertCrlCollection, &matchParams, nullptr);
180     EXPECT_EQ(ret, CF_INVALID_PARAMS);
181 }
182 
183 HWTEST_F(CryptoX509CertCrlCollectionTest, SelectCertsTest004, TestSize.Level0)
184 {
185     HcfCertCrlCollection *x509CertCrlCollection = nullptr;
186     HcfX509CertificateArray *certArray =
187         static_cast<HcfX509CertificateArray *>(CfMalloc(sizeof(HcfX509CertificateArray), 0));
188     ASSERT_NE(certArray, nullptr);
189 
190     HcfX509CrlArray *crlArray = static_cast<HcfX509CrlArray *>(CfMalloc(sizeof(HcfX509CrlArray), 0));
191     ASSERT_NE(crlArray, nullptr);
192 
193     CfResult ret = HcfCertCrlCollectionCreate(certArray, crlArray, &x509CertCrlCollection);
194     ASSERT_EQ(ret, CF_SUCCESS);
195     ASSERT_NE(x509CertCrlCollection, nullptr);
196 
197     HcfX509CertificateArray retCerts;
198     HcfX509CertMatchParams matchParams;
199     ret = x509CertCrlCollection->selectCerts(x509CertCrlCollection, &matchParams, &retCerts);
200     EXPECT_NE(ret, CF_SUCCESS);
201 
202     CfFree(certArray);
203     CfFree(crlArray);
204     CfObjDestroy(x509CertCrlCollection);
205     FreeCertArrayData(&retCerts);
206 }
207 
208 HWTEST_F(CryptoX509CertCrlCollectionTest, SelectCertsTest005, TestSize.Level0)
209 {
210     ASSERT_NE(g_x509CertCrlCollection, nullptr);
211     HcfX509CertificateArray retCerts;
212     CfResult ret = g_x509CertCrlCollection->selectCerts(g_x509CertCrlCollection, nullptr, &retCerts);
213     EXPECT_EQ(ret, CF_INVALID_PARAMS);
214 }
215 
216 HWTEST_F(CryptoX509CertCrlCollectionTest, SelectCertsTest006, TestSize.Level0)
217 {
218     ASSERT_NE(g_x509CertCrlCollection, nullptr);
219 
220     HcfX509Certificate *x509Cert = nullptr;
221     CfEncodingBlob inStream = { 0 };
222     inStream.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_secondCert));
223     inStream.encodingFormat = CF_FORMAT_PEM;
224     inStream.len = strlen(g_secondCert) + 1;
225     CfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert);
226     EXPECT_EQ(ret, CF_SUCCESS);
227     EXPECT_NE(x509Cert, nullptr);
228 
229     HcfX509CertificateArray retCerts;
230     HcfX509CertMatchParams matchParams;
231     matchParams.x509Cert = &(x509Cert->base);
232     ret = g_x509CertCrlCollection->selectCerts(g_x509CertCrlCollection, &matchParams, &retCerts);
233     EXPECT_EQ(ret, CF_SUCCESS);
234 
235     CfObjDestroy(x509Cert);
236     FreeCertArrayData(&retCerts);
237 }
238 
239 HWTEST_F(CryptoX509CertCrlCollectionTest, SelectCertsTest007, TestSize.Level0)
240 {
241     ASSERT_NE(g_x509CertCrlCollection, nullptr);
242 
243     HcfX509Certificate *x509Cert = nullptr;
244     CfEncodingBlob inStream = { 0 };
245     inStream.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_testSelfSignedCaCert));
246     inStream.encodingFormat = CF_FORMAT_PEM;
247     inStream.len = strlen(g_testSelfSignedCaCert) + 1;
248     CfResult ret = HcfX509CertificateCreate(&inStream, &x509Cert);
249     EXPECT_EQ(ret, CF_SUCCESS);
250     EXPECT_NE(x509Cert, nullptr);
251 
252     HcfX509CertificateArray retCerts;
253     HcfX509CertMatchParams matchParams;
254     matchParams.x509Cert = &(x509Cert->base);
255     ret = g_x509CertCrlCollection->selectCerts(g_x509CertCrlCollection, &matchParams, &retCerts);
256     EXPECT_EQ(ret, CF_SUCCESS);
257 
258     CfObjDestroy(x509Cert);
259     FreeCertArrayData(&retCerts);
260 }
261 
262 HWTEST_F(CryptoX509CertCrlCollectionTest, SelectCertsTest008, TestSize.Level0)
263 {
264     HcfCertCrlCollection *x509CertCrlCollection = nullptr;
265     HcfX509CertificateArray *certArray =
266         static_cast<HcfX509CertificateArray *>(CfMalloc(sizeof(HcfX509CertificateArray), 0));
267     ASSERT_NE(certArray, nullptr);
268 
269     HcfX509CrlArray *crlArray = static_cast<HcfX509CrlArray *>(CfMalloc(sizeof(HcfX509CrlArray), 0));
270     ASSERT_NE(crlArray, nullptr);
271 
272     CfResult ret = HcfCertCrlCollectionCreate(certArray, crlArray, &x509CertCrlCollection);
273     ASSERT_EQ(ret, CF_SUCCESS);
274     ASSERT_NE(x509CertCrlCollection, nullptr);
275 
276     certArray->count = 1;
277     crlArray->count = 1;
278 
279     HcfX509CertificateArray retCerts;
280     HcfX509CertMatchParams matchParams;
281     ret = x509CertCrlCollection->selectCerts(x509CertCrlCollection, &matchParams, &retCerts);
282     EXPECT_NE(ret, CF_SUCCESS);
283 
284     HcfX509CrlArray retCrls;
285     HcfX509CrlMatchParams matchCrlParams;
286     ret = x509CertCrlCollection->selectCRLs(x509CertCrlCollection, &matchCrlParams, &retCrls);
287     EXPECT_NE(ret, CF_SUCCESS);
288 
289     CfFree(certArray);
290     CfFree(crlArray);
291     CfObjDestroy(x509CertCrlCollection);
292 }
293 
294 HWTEST_F(CryptoX509CertCrlCollectionTest, SelectCertsTest009, TestSize.Level0)
295 {
296     HcfCertCrlCollection *x509CertCrlCollection = nullptr;
297     HcfX509CertificateArray *certArray =
298         static_cast<HcfX509CertificateArray *>(CfMalloc(sizeof(HcfX509CertificateArray), 0));
299     ASSERT_NE(certArray, nullptr);
300 
301     certArray->data = static_cast<HcfX509Certificate **>(CfMalloc(1 * sizeof(HcfX509Certificate *), 0));
302     ASSERT_NE(certArray->data, nullptr);
303     certArray->data[0] = g_x509CertObj;
304     certArray->count = MAX_LEN_OF_CERT_CRL_ARR + 1;
305 
306     HcfX509CrlArray *crlArray = static_cast<HcfX509CrlArray *>(CfMalloc(sizeof(HcfX509CrlArray), 0));
307     ASSERT_NE(crlArray, nullptr);
308 
309     CfResult ret = HcfCertCrlCollectionCreate(certArray, crlArray, &x509CertCrlCollection);
310     ASSERT_NE(ret, CF_SUCCESS);
311 
312     CfFree(certArray->data);
313     CfFree(certArray);
314     CfFree(crlArray);
315 }
316 
317 HWTEST_F(CryptoX509CertCrlCollectionTest, SelectCRLsTest001, TestSize.Level0)
318 {
319     ASSERT_NE(g_x509CertCrlCollection, nullptr);
320 
321     HcfX509CrlArray retCrls;
322     HcfX509CrlMatchParams matchParams;
323     CfResult ret = g_x509CertCrlCollection->selectCRLs(nullptr, &matchParams, &retCrls);
324     EXPECT_EQ(ret, CF_INVALID_PARAMS);
325 }
326 
327 HWTEST_F(CryptoX509CertCrlCollectionTest, SelectCRLsTest002, TestSize.Level0)
328 {
329     ASSERT_NE(g_x509CertCrlCollection, nullptr);
330 
331     HcfX509CrlArray retCrls;
332     CfResult ret = g_x509CertCrlCollection->selectCRLs(g_x509CertCrlCollection, nullptr, &retCrls);
333     EXPECT_EQ(ret, CF_INVALID_PARAMS);
334 }
335 
336 HWTEST_F(CryptoX509CertCrlCollectionTest, SelectCRLsTest003, TestSize.Level0)
337 {
338     ASSERT_NE(g_x509CertCrlCollection, nullptr);
339 
340     HcfX509CrlMatchParams matchParams;
341     CfResult ret = g_x509CertCrlCollection->selectCRLs(g_x509CertCrlCollection, &matchParams, nullptr);
342     EXPECT_EQ(ret, CF_INVALID_PARAMS);
343 }
344 
345 HWTEST_F(CryptoX509CertCrlCollectionTest, SelectCRLsTest004, TestSize.Level0)
346 {
347     HcfCertCrlCollection *x509CertCrlCollection = nullptr;
348     HcfX509CertificateArray *certArray =
349         static_cast<HcfX509CertificateArray *>(CfMalloc(sizeof(HcfX509CertificateArray), 0));
350     ASSERT_NE(certArray, nullptr);
351 
352     HcfX509CrlArray *crlArray = static_cast<HcfX509CrlArray *>(CfMalloc(sizeof(HcfX509CrlArray), 0));
353     ASSERT_NE(crlArray, nullptr);
354 
355     CfResult ret = HcfCertCrlCollectionCreate(certArray, crlArray, &x509CertCrlCollection);
356     ASSERT_EQ(ret, CF_SUCCESS);
357     ASSERT_NE(x509CertCrlCollection, nullptr);
358 
359     HcfX509CrlMatchParams matchParams;
360     HcfX509CrlArray retCrls;
361     ret = x509CertCrlCollection->selectCRLs(x509CertCrlCollection, &matchParams, &retCrls);
362     EXPECT_EQ(ret, CF_INVALID_PARAMS);
363 
364     CfFree(certArray);
365     CfFree(crlArray);
366     CfObjDestroy(x509CertCrlCollection);
367 }
368 
369 HWTEST_F(CryptoX509CertCrlCollectionTest, SelectCRLsTest005, TestSize.Level0)
370 {
371     ASSERT_NE(g_x509CertCrlCollection, nullptr);
372 
373     HcfX509Certificate *x509Cert = nullptr;
374     CfEncodingBlob inStreamCert = { nullptr, 0, CF_FORMAT_PEM };
375     inStreamCert.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_testErrorCert));
376     inStreamCert.encodingFormat = CF_FORMAT_PEM;
377     inStreamCert.len = strlen(g_testErrorCert) + 1;
378     CfResult ret = HcfX509CertificateCreate(&inStreamCert, &x509Cert);
379     EXPECT_EQ(ret, CF_SUCCESS);
380     EXPECT_NE(x509Cert, nullptr);
381 
382     HcfX509CrlMatchParams matchParams;
383     matchParams.x509Cert = &(x509Cert->base);
384     HcfX509CrlArray retCrls;
385     ret = g_x509CertCrlCollection->selectCRLs(g_x509CertCrlCollection, &matchParams, &retCrls);
386     EXPECT_EQ(ret, CF_SUCCESS);
387     EXPECT_EQ(retCrls.data, nullptr);
388     CfObjDestroy(x509Cert);
389 }
390 
391 HWTEST_F(CryptoX509CertCrlCollectionTest, SelectCRLsTest006, TestSize.Level0)
392 {
393     ASSERT_NE(g_x509CertCrlCollection, nullptr);
394 
395     // Get cert
396     HcfX509Certificate *x509Cert = nullptr;
397     CfResult ret = HcfX509CertificateCreate(&g_inStreamCert, &x509Cert);
398     EXPECT_EQ(ret, CF_SUCCESS);
399     EXPECT_NE(x509Cert, nullptr);
400 
401     HcfX509CrlMatchParams matchParams;
402     matchParams.x509Cert = &(x509Cert->base);
403     HcfX509CrlArray retCrls;
404     ret = g_x509CertCrlCollection->selectCRLs(g_x509CertCrlCollection, &matchParams, &retCrls);
405     EXPECT_EQ(ret, CF_SUCCESS);
406     EXPECT_EQ(retCrls.count > 0, true);
407     EXPECT_NE(retCrls.data, nullptr);
408     CfObjDestroy(x509Cert);
409     FreeCrlArrayData(&retCrls);
410 }
411 
412 HWTEST_F(CryptoX509CertCrlCollectionTest, SelectCRLsTest007, TestSize.Level0)
413 {
414     HcfX509CertificateArray *certArray =
415         static_cast<HcfX509CertificateArray *>(CfMalloc(sizeof(HcfX509CertificateArray), 0));
416     ASSERT_NE(certArray, nullptr);
417 
418     HcfX509CrlArray *crlArray = static_cast<HcfX509CrlArray *>(CfMalloc(sizeof(HcfX509CrlArray), 0));
419     ASSERT_NE(crlArray, nullptr);
420 
421     CfResult ret = HcfCertCrlCollectionCreate(certArray, crlArray, nullptr);
422     EXPECT_EQ(ret, CF_INVALID_PARAMS);
423 
424     CfFree(certArray);
425     CfFree(crlArray);
426 }
427 
428 HWTEST_F(CryptoX509CertCrlCollectionTest, SelectCRLsTest008, TestSize.Level0)
429 {
430     HcfCertCrlCollection *x509CertCrlCollection = nullptr;
431     HcfX509CertificateArray *certArray =
432         static_cast<HcfX509CertificateArray *>(CfMalloc(sizeof(HcfX509CertificateArray), 0));
433     ASSERT_NE(certArray, nullptr);
434 
435     HcfX509CrlArray *crlArray = static_cast<HcfX509CrlArray *>(CfMalloc(sizeof(HcfX509CrlArray), 0));
436     ASSERT_NE(crlArray, nullptr);
437 
438     HcfX509Crl *x509Crl = nullptr;
439     CfResult ret = HcfX509CrlCreate(&g_crlDerInStream, &x509Crl);
440     ASSERT_EQ(ret, CF_SUCCESS);
441     ASSERT_NE(x509Crl, nullptr);
442 
443     crlArray->data = static_cast<HcfX509Crl **>(CfMalloc(1 * sizeof(HcfX509Crl *), 0));
444     ASSERT_NE(crlArray->data, nullptr);
445     crlArray->data[0] = x509Crl;
446     crlArray->count = MAX_LEN_OF_CERT_CRL_ARR + 1;
447 
448     ret = HcfCertCrlCollectionCreate(certArray, crlArray, &x509CertCrlCollection);
449     ASSERT_NE(ret, CF_SUCCESS);
450 
451     CfFree(crlArray->data);
452     CfFree(certArray);
453     CfFree(crlArray);
454     CfObjDestroy(x509Crl);
455 }
456 
457 HWTEST_F(CryptoX509CertCrlCollectionTest, InvalidCert, TestSize.Level0)
458 {
459     HcfCertCrlCollection *x509CertCrlCollection = nullptr;
460     HcfX509CertificateArray *certArray =
461         static_cast<HcfX509CertificateArray *>(CfMalloc(sizeof(HcfX509CertificateArray), 0));
462     ASSERT_NE(certArray, nullptr);
463 
464     HcfX509CrlArray *crlArray = static_cast<HcfX509CrlArray *>(CfMalloc(sizeof(HcfX509CrlArray), 0));
465     ASSERT_NE(crlArray, nullptr);
466 
467     HcfX509Certificate *x509CertObj = nullptr;
468     CfEncodingBlob inStream = { 0 };
469     inStream.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_testSelfSignedCaCert));
470     inStream.encodingFormat = CF_FORMAT_PEM;
471     inStream.len = strlen(g_testSelfSignedCaCert) + 1;
472     (void)HcfX509CertificateCreate(&inStream, &x509CertObj);
473     x509CertObj->base.base.getClass = GetInvalidCertClass;
474 
475     HcfX509Crl *x509Crl = nullptr;
476     CfResult ret = HcfX509CrlCreate(&g_crlDerInStream, &x509Crl);
477     ASSERT_EQ(ret, CF_SUCCESS);
478     ASSERT_NE(x509Crl, nullptr);
479 
480     certArray->data = static_cast<HcfX509Certificate **>(CfMalloc(1 * sizeof(HcfX509Certificate *), 0));
481     ASSERT_NE(certArray->data, nullptr);
482     certArray->data[0] = x509CertObj;
483     certArray->count = 1;
484 
485     crlArray->data = static_cast<HcfX509Crl **>(CfMalloc(1 * sizeof(HcfX509Crl *), 0));
486     ASSERT_NE(crlArray->data, nullptr);
487     crlArray->data[0] = x509Crl;
488     crlArray->count = 1;
489 
490     ret = HcfCertCrlCollectionCreate(certArray, crlArray, &x509CertCrlCollection);
491     ASSERT_NE(ret, CF_SUCCESS);
492 
493     x509CertObj->base.base.getClass = g_x509CertObj->base.base.getClass;
494 
495     CfObjDestroy(x509CertObj);
496     CfObjDestroy(x509Crl);
497     CfFree(certArray->data);
498     CfFree(crlArray->data);
499     CfFree(certArray);
500     CfFree(crlArray);
501 }
502 
503 HWTEST_F(CryptoX509CertCrlCollectionTest, InvalidCrl, TestSize.Level0)
504 {
505     HcfCertCrlCollection *x509CertCrlCollection = nullptr;
506     HcfX509CertificateArray *certArray =
507         static_cast<HcfX509CertificateArray *>(CfMalloc(sizeof(HcfX509CertificateArray), 0));
508     ASSERT_NE(certArray, nullptr);
509 
510     HcfX509CrlArray *crlArray = static_cast<HcfX509CrlArray *>(CfMalloc(sizeof(HcfX509CrlArray), 0));
511     ASSERT_NE(crlArray, nullptr);
512 
513     HcfX509Certificate *x509CertObj = nullptr;
514     CfEncodingBlob inStream = { 0 };
515     inStream.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_testSelfSignedCaCert));
516     inStream.encodingFormat = CF_FORMAT_PEM;
517     inStream.len = strlen(g_testSelfSignedCaCert) + 1;
518     (void)HcfX509CertificateCreate(&inStream, &x509CertObj);
519 
520     HcfX509Crl *x509Crl = nullptr;
521     CfResult ret = HcfX509CrlCreate(&g_crlDerInStream, &x509Crl);
522     ASSERT_EQ(ret, CF_SUCCESS);
523     ASSERT_NE(x509Crl, nullptr);
524 
525     certArray->data = static_cast<HcfX509Certificate **>(CfMalloc(1 * sizeof(HcfX509Certificate *), 0));
526     ASSERT_NE(certArray->data, nullptr);
527     certArray->data[0] = x509CertObj;
528     certArray->count = 1;
529 
530     crlArray->data = static_cast<HcfX509Crl **>(CfMalloc(1 * sizeof(HcfX509Crl *), 0));
531     ASSERT_NE(crlArray->data, nullptr);
532     crlArray->data[0] = x509Crl;
533     crlArray->count = 1;
534     x509Crl->base.base.getClass = GetInvalidCrlClass;
535 
536     ret = HcfCertCrlCollectionCreate(certArray, crlArray, &x509CertCrlCollection);
537     ASSERT_NE(ret, CF_SUCCESS);
538 
539     x509Crl->base.base.getClass = g_x509Crl->base.base.getClass;
540 
541     CfObjDestroy(x509CertObj);
542     CfObjDestroy(x509Crl);
543     CfFree(certArray->data);
544     CfFree(crlArray->data);
545     CfFree(certArray);
546     CfFree(crlArray);
547 }
548 
549 } // namespace
550