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