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