1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include <openssl/x509.h>
18
19 #include "asy_key_generator.h"
20 #include "certificate_openssl_class.h"
21 #include "cf_memory.h"
22 #include "cf_log.h"
23 #include "cipher.h"
24 #include "crypto_x509_test_common.h"
25 #include "key_pair.h"
26 #include "memory_mock.h"
27 #include "securec.h"
28 #include "x509_crl.h"
29 #include "x509_crl_entry_openssl.h"
30 #include "x509_crl_match_parameters.h"
31 #include "x509_crl_openssl.h"
32
33 using namespace std;
34 using namespace testing::ext;
35
36 namespace {
37 static uint8_t g_testSn[] = { 0x03, 0xe8 };
38 HcfX509Crl *g_x509Crl = nullptr;
39 HcfX509CrlEntry *g_crlEntry = nullptr;
40 HcfX509CrlSpi *g_crlSpiObj = nullptr;
41
42 class CryptoX509CrlTestPart2 : public testing::Test {
43 public:
44 static void SetUpTestCase();
45 static void TearDownTestCase();
46 void SetUp();
47 void TearDown();
48 };
49
SetUpTestCase()50 void CryptoX509CrlTestPart2::SetUpTestCase()
51 {
52 HcfX509Crl *x509Crl = nullptr;
53 CfResult ret = HcfX509CrlCreate(&g_crlDerInStream, &x509Crl);
54 ASSERT_EQ(ret, 0);
55 ASSERT_NE(x509Crl, nullptr);
56 g_x509Crl = x509Crl;
57
58 CfBlob testSnBlob = { 2, g_testSn };
59 ret = g_x509Crl->getRevokedCert(g_x509Crl, &testSnBlob, &g_crlEntry);
60 EXPECT_EQ(ret, CF_SUCCESS);
61 EXPECT_NE(g_crlEntry, nullptr);
62
63 ret = HcfCX509CrlSpiCreate(&g_crlDerInStream, &g_crlSpiObj);
64 EXPECT_EQ(ret, CF_SUCCESS);
65 EXPECT_NE(g_crlSpiObj, nullptr);
66 }
67
TearDownTestCase()68 void CryptoX509CrlTestPart2::TearDownTestCase()
69 {
70 if (g_x509Crl != nullptr) {
71 CfObjDestroy(g_x509Crl);
72 g_x509Crl = nullptr;
73 }
74
75 if (g_crlEntry != nullptr) {
76 CfObjDestroy(g_crlEntry);
77 g_crlEntry = nullptr;
78 }
79
80 if (g_crlSpiObj != nullptr) {
81 CfObjDestroy(g_crlSpiObj);
82 g_crlSpiObj = nullptr;
83 }
84 }
SetUp()85 void CryptoX509CrlTestPart2::SetUp() {}
TearDown()86 void CryptoX509CrlTestPart2::TearDown() {}
87
88 static const char g_testUtf8CrlData[] =
89 "-----BEGIN X509 CRL-----\r\n"
90 "MIIBTDCBtgIBATANBgkqhkiG9w0BAQsFADBZMQswCQYDVQQGEwJDTjEPMA0GA1UE\r\n"
91 "CAwG6ZmV6KW/MQ8wDQYDVQQHDAbopb/lrokxDzANBgNVBAoMBua1i+ivlTEXMBUG\r\n"
92 "A1UEAwwO5Lit5paH5rWL6K+VIyMXDTI1MDMyNDA5MTExNVoXDTI1MDQyMzA5MTEx\r\n"
93 "NVowGTAXAgYBcqcmOsAXDTI1MDIyMDA2MTMwM1qgDjAMMAoGA1UdFAQDAgECMA0G\r\n"
94 "CSqGSIb3DQEBCwUAA4GBACedFnn4unfYLiRCl1ZAFXx6LFdX6U+IZ/buW44xKAWi\r\n"
95 "fyvcSxKIeGtMVjmQSs4HeNfNujIjaDN1+/J2nLSmHPiQ/c0LAc47zefVt2VnFuR4\r\n"
96 "TMUJEDUlnekYfDMxQqtihAO/Bpw33twK6otDvaAPm9vJoCu8JmGXxt6g+8vbYuNT\r\n"
97 "-----END X509 CRL-----\r\n";
98
GetInvalidCrlClass(void)99 static const char *GetInvalidCrlClass(void)
100 {
101 return "INVALID_CRL_CLASS";
102 }
103
104 /* self point is nullptr */
105 HWTEST_F(CryptoX509CrlTestPart2, MatchX509CRLTest001, TestSize.Level0)
106 {
107 bool bResult = true;
108 HcfX509CrlMatchParams matchParams = { 0 };
109 CfResult ret = g_x509Crl->match(nullptr, &matchParams, &bResult);
110 EXPECT_EQ(ret, CF_INVALID_PARAMS);
111 }
112
113 /* x509Cert point is nullptr */
114 HWTEST_F(CryptoX509CrlTestPart2, MatchX509CRLTest002, TestSize.Level0)
115 {
116 ASSERT_NE(g_x509Crl, nullptr);
117 bool bResult = true;
118 CfResult ret = g_x509Crl->match(g_x509Crl, nullptr, &bResult);
119 EXPECT_EQ(ret, CF_INVALID_PARAMS);
120 }
121
122 /* out point is nullptr */
123 HWTEST_F(CryptoX509CrlTestPart2, MatchX509CRLTest003, TestSize.Level0)
124 {
125 ASSERT_NE(g_x509Crl, nullptr);
126 HcfX509CrlMatchParams matchParams = { 0 };
127 CfResult ret = g_x509Crl->match(g_x509Crl, &matchParams, nullptr);
128 EXPECT_EQ(ret, CF_INVALID_PARAMS);
129 }
130
131 /* Get Invalid Crl Class */
132 HWTEST_F(CryptoX509CrlTestPart2, MatchX509CRLTest004, TestSize.Level0)
133 {
134 ASSERT_NE(g_x509Crl, nullptr);
135 HcfX509CrlMatchParams matchParams = { 0 };
136 HcfX509Crl invalidCrl;
137 memset_s(&invalidCrl, sizeof(HcfX509Crl), 0, sizeof(HcfX509Crl));
138 invalidCrl.base.base.getClass = GetInvalidCrlClass;
139 bool bResult = true;
140 CfResult ret = g_x509Crl->match(&invalidCrl, &matchParams, &bResult);
141 EXPECT_EQ(ret, CF_INVALID_PARAMS);
142 }
143
144 /* x509Cert is nullptr */
145 HWTEST_F(CryptoX509CrlTestPart2, MatchX509CRLTest005, TestSize.Level0)
146 {
147 ASSERT_NE(g_x509Crl, nullptr);
148 HcfX509CrlMatchParams matchParams = { 0 };
149 matchParams.x509Cert = nullptr;
150 bool bResult = true;
151 CfResult ret = g_x509Crl->match(g_x509Crl, &matchParams, &bResult);
152 EXPECT_EQ(ret, CF_SUCCESS);
153 }
154
155 /* self x509Cert is not equal to x509Crl */
156 HWTEST_F(CryptoX509CrlTestPart2, MatchX509CRLTest006, TestSize.Level0)
157 {
158 // Get cert
159 HcfX509Certificate *x509Cert = nullptr;
160 CfEncodingBlob inStreamCert = { nullptr, 0, CF_FORMAT_PEM };
161 inStreamCert.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_testErrorCert));
162 inStreamCert.encodingFormat = CF_FORMAT_PEM;
163 inStreamCert.len = strlen(g_testErrorCert) + 1;
164 CfResult ret = HcfX509CertificateCreate(&inStreamCert, &x509Cert);
165 EXPECT_EQ(ret, CF_SUCCESS);
166 EXPECT_NE(x509Cert, nullptr);
167
168 // Get crl
169 HcfX509Crl *x509Crl = nullptr;
170 ret = HcfX509CrlCreate(&g_inStreamCrl, &x509Crl);
171 EXPECT_EQ(ret, CF_SUCCESS);
172 EXPECT_NE(x509Crl, nullptr);
173
174 HcfX509CrlMatchParams matchParams = { 0 };
175 matchParams.x509Cert = &(x509Cert->base);
176 bool bResult = true;
177 ret = x509Crl->match(x509Crl, &matchParams, &bResult);
178 EXPECT_EQ(ret, CF_SUCCESS);
179 EXPECT_EQ(bResult, false);
180 CfObjDestroy(x509Cert);
181 CfObjDestroy(x509Crl);
182 }
183
184 /* self x509Cert is equal to x509Crl */
185 HWTEST_F(CryptoX509CrlTestPart2, MatchX509CRLTest007, TestSize.Level0)
186 {
187 // Get cert
188 HcfX509Certificate *x509Cert = nullptr;
189 CfResult ret = HcfX509CertificateCreate(&g_inStreamCert, &x509Cert);
190 EXPECT_EQ(ret, CF_SUCCESS);
191 EXPECT_NE(x509Cert, nullptr);
192
193 HcfX509CrlMatchParams matchParams = { 0 };
194 matchParams.x509Cert = &(x509Cert->base);
195 bool bResult = true;
196 ret = g_x509Crl->match(g_x509Crl, &matchParams, &bResult);
197 EXPECT_EQ(ret, CF_SUCCESS);
198 EXPECT_EQ(bResult, true);
199 CfObjDestroy(x509Cert);
200 }
201
202 /* issuer is nullptr */
203 HWTEST_F(CryptoX509CrlTestPart2, MatchX509CRLTest008, TestSize.Level0)
204 {
205 ASSERT_NE(g_x509Crl, nullptr);
206 HcfX509CrlMatchParams matchParams = { 0 };
207 matchParams.issuer = nullptr;
208 bool bResult = true;
209 CfResult ret = g_x509Crl->match(g_x509Crl, &matchParams, &bResult);
210 EXPECT_EQ(ret, CF_SUCCESS);
211 }
212
213 /* self issuer is equal to x509Crl */
214 HWTEST_F(CryptoX509CrlTestPart2, MatchX509CRLTest009, TestSize.Level0)
215 {
216 // get issuer name
217 ASSERT_NE(g_x509Crl, nullptr);
218 CfBlob out1 = { 0, nullptr };
219 out1.data = (uint8_t *)(&g_testCrlSubAndIssNameDerData[0]);
220 out1.size = g_testCrlSubAndIssNameDerDataSize;
221
222 CfBlobArray cfBlobArr;
223 CfBlob cfb[2] = { out1, out1 };
224 cfBlobArr.data = cfb;
225 cfBlobArr.count = 2;
226
227 HcfX509CrlMatchParams matchParams = { 0 };
228 matchParams.issuer = &cfBlobArr;
229 bool bResult = true;
230 CfResult ret = g_x509Crl->match(g_x509Crl, &matchParams, &bResult);
231 EXPECT_EQ(ret, CF_SUCCESS);
232 EXPECT_EQ(bResult, true);
233 }
234
235 /* self issuer is not equal to x509Crl */
236 HWTEST_F(CryptoX509CrlTestPart2, MatchX509CRLTest010, TestSize.Level0)
237 {
238 // get issuer name
239 ASSERT_NE(g_x509Crl, nullptr);
240 CfBlob out1 = { 0, nullptr };
241 CfResult ret = g_x509Crl->getIssuerName(g_x509Crl, &out1);
242 EXPECT_EQ(ret, CF_SUCCESS);
243 EXPECT_EQ((out1.size >= 2), true);
244 out1.data[1] = out1.data[1] + 1; // modify to a different value.
245
246 CfBlobArray cfBlobArr;
247 CfBlob cfb[2] = { out1, out1 };
248 cfBlobArr.data = cfb;
249 cfBlobArr.count = 2;
250
251 // Get crl
252 HcfX509Crl *x509Crl = nullptr;
253 ret = HcfX509CrlCreate(&g_crlDerInStream, &x509Crl);
254 EXPECT_EQ(ret, CF_SUCCESS);
255 EXPECT_NE(x509Crl, nullptr);
256
257 HcfX509CrlMatchParams matchParams = { 0 };
258 matchParams.issuer = &cfBlobArr;
259 bool bResult = true;
260 ret = x509Crl->match(x509Crl, &matchParams, &bResult);
261 EXPECT_NE(ret, CF_SUCCESS);
262
263 CfFree(out1.data);
264 CfObjDestroy(x509Crl);
265 }
266
267 /* issuer->count is 0 and outTmpSelf.size is not 0 */
268 HWTEST_F(CryptoX509CrlTestPart2, MatchX509CRLTest011, TestSize.Level0)
269 {
270 // get issuer name
271 ASSERT_NE(g_x509Crl, nullptr);
272 CfBlob out1 = { 0, nullptr };
273 out1.data = (uint8_t *)(&g_testCrlSubAndIssNameDerData[0]);
274 out1.size = g_testCrlSubAndIssNameDerDataSize;
275
276 CfBlobArray cfBlobArr;
277 CfBlob cfb[2] = { out1, out1 };
278 cfBlobArr.data = cfb;
279 cfBlobArr.count = 0;
280
281 HcfX509CrlMatchParams matchParams = { 0 };
282 matchParams.issuer = &cfBlobArr;
283 bool bResult = true;
284 CfResult ret = g_x509Crl->match(g_x509Crl, &matchParams, &bResult);
285 EXPECT_EQ(ret, CF_INVALID_PARAMS);
286 }
287
288 /* issuer->data[0].data is nullptr */
289 HWTEST_F(CryptoX509CrlTestPart2, MatchX509CRLTest012, TestSize.Level0)
290 {
291 // get issuer name
292 ASSERT_NE(g_x509Crl, nullptr);
293 CfBlob out1 = { 0, nullptr };
294 CfBlob out2 = { 0, nullptr };
295 out1.data = nullptr;
296 out1.size = g_testCrlSubAndIssNameDerDataSize;
297 out2.data = (uint8_t *)(&g_testCrlSubAndIssNameDerData[0]);
298 out2.size = g_testCrlSubAndIssNameDerDataSize;
299
300 CfBlobArray cfBlobArr;
301 CfBlob cfb[2] = { out1, out2 };
302 cfBlobArr.data = cfb;
303 cfBlobArr.count = 2;
304
305 HcfX509CrlMatchParams matchParams = { 0 };
306 matchParams.issuer = &cfBlobArr;
307 bool bResult = true;
308 CfResult ret = g_x509Crl->match(g_x509Crl, &matchParams, &bResult);
309 EXPECT_EQ(ret, CF_INVALID_PARAMS);
310 }
311
312 /* i == issuer->count - 1 */
313 HWTEST_F(CryptoX509CrlTestPart2, MatchX509CRLTest013, TestSize.Level0)
314 {
315 // get issuer name
316 ASSERT_NE(g_x509Crl, nullptr);
317 CfBlob out1 = { 0, nullptr };
318 out1.data = (uint8_t *)(&g_testCrlSubAndIssNameDerData[0]);
319 out1.size = g_testCrlSubAndIssNameDerDataSize;
320
321 CfBlobArray cfBlobArr;
322 CfBlob cfb[2] = { out1, out1 };
323 cfBlobArr.data = cfb;
324 cfBlobArr.count = 2;
325
326 // Get crl
327 HcfX509Crl *x509Crl = nullptr;
328 CfResult ret = HcfX509CrlCreate(&g_crlWithoutExtPemInStream, &x509Crl);
329 EXPECT_EQ(ret, CF_SUCCESS);
330 EXPECT_NE(x509Crl, nullptr);
331
332 HcfX509CrlMatchParams matchParams = { 0 };
333 matchParams.issuer = &cfBlobArr;
334 bool bResult = true;
335 ret = x509Crl->match(x509Crl, &matchParams, &bResult);
336 EXPECT_EQ(ret, CF_SUCCESS);
337 EXPECT_EQ(bResult, false);
338
339 CfObjDestroy(x509Crl);
340 }
341
342 /* match all params */
343 HWTEST_F(CryptoX509CrlTestPart2, MatchX509CRLTest014, TestSize.Level0)
344 {
345 // Get cert
346 HcfX509Certificate *x509Cert = nullptr;
347 CfResult ret = HcfX509CertificateCreate(&g_inStreamCert, &x509Cert);
348 EXPECT_EQ(ret, CF_SUCCESS);
349 EXPECT_NE(x509Cert, nullptr);
350
351 // get issuer name
352 ASSERT_NE(g_x509Crl, nullptr);
353 CfBlob out1 = { 0, nullptr };
354 out1.data = (uint8_t *)(&g_testCrlSubAndIssNameDerData[0]);
355 out1.size = g_testCrlSubAndIssNameDerDataSize;
356
357 CfBlobArray cfBlobArr;
358 CfBlob cfb[2] = { out1, out1 };
359 cfBlobArr.data = cfb;
360 cfBlobArr.count = 2;
361
362 HcfX509CrlMatchParams matchParams = { 0 };
363 matchParams.x509Cert = &(x509Cert->base);
364 matchParams.issuer = &cfBlobArr;
365 bool bResult = true;
366 ret = g_x509Crl->match(g_x509Crl, &matchParams, &bResult);
367 EXPECT_EQ(ret, CF_SUCCESS);
368 EXPECT_EQ(bResult, true);
369 CfObjDestroy(x509Cert);
370 }
371
372 HWTEST_F(CryptoX509CrlTestPart2, CrlToStringTest001, TestSize.Level0)
373 {
374 CF_LOG_I("CrlToStringTest001");
375 ASSERT_NE(g_x509Crl, nullptr);
376
377 CfBlob blob = { 0, nullptr };
378 CfResult ret = g_x509Crl->toString(g_x509Crl, &blob);
379 EXPECT_EQ(ret, CF_SUCCESS);
380 CfBlobDataFree(&blob);
381
382 HcfX509Crl invalidCrl;
383 memset_s(&invalidCrl, sizeof(HcfX509Crl), 0, sizeof(HcfX509Crl));
384 invalidCrl.base.base.getClass = GetInvalidCrlClass;
385
386 ret = g_x509Crl->toString(&invalidCrl, &blob);
387 EXPECT_EQ(ret, CF_INVALID_PARAMS);
388
389 ret = g_x509Crl->toString(NULL, &blob);
390 EXPECT_EQ(ret, CF_INVALID_PARAMS);
391
392 ret = g_x509Crl->toString(g_x509Crl, NULL);
393 EXPECT_EQ(ret, CF_INVALID_PARAMS);
394
395 ret = g_x509Crl->toString(NULL, NULL);
396 EXPECT_EQ(ret, CF_INVALID_PARAMS);
397 }
398
399 HWTEST_F(CryptoX509CrlTestPart2, CrlHashCodeTest001, TestSize.Level0)
400 {
401 CF_LOG_I("CrlHashCodeTest001");
402 ASSERT_NE(g_x509Crl, nullptr);
403
404 CfBlob blob = { 0, nullptr };
405 CfResult ret = g_x509Crl->hashCode(g_x509Crl, &blob);
406 EXPECT_EQ(ret, CF_SUCCESS);
407 CfBlobDataFree(&blob);
408
409 HcfX509Crl invalidCrl;
410 memset_s(&invalidCrl, sizeof(HcfX509Crl), 0, sizeof(HcfX509Crl));
411 invalidCrl.base.base.getClass = GetInvalidCrlClass;
412
413 ret = g_x509Crl->hashCode(&invalidCrl, &blob);
414 EXPECT_EQ(ret, CF_INVALID_PARAMS);
415
416 ret = g_x509Crl->hashCode(NULL, &blob);
417 EXPECT_EQ(ret, CF_INVALID_PARAMS);
418
419 ret = g_x509Crl->hashCode(g_x509Crl, NULL);
420 EXPECT_EQ(ret, CF_INVALID_PARAMS);
421
422 ret = g_x509Crl->hashCode(NULL, NULL);
423 EXPECT_EQ(ret, CF_INVALID_PARAMS);
424 }
425
426 HWTEST_F(CryptoX509CrlTestPart2, CrlGetExtensionsObjectTest001, TestSize.Level0)
427 {
428 CF_LOG_I("CrlGetExtensionsObjectTest001");
429 ASSERT_NE(g_x509Crl, nullptr);
430
431 CfBlob blob = { 0, nullptr };
432 CfResult ret = g_x509Crl->getExtensionsObject(g_x509Crl, &blob);
433 EXPECT_EQ(ret, CF_SUCCESS);
434 CfBlobDataFree(&blob);
435
436 HcfX509Crl invalidCrl;
437 memset_s(&invalidCrl, sizeof(HcfX509Crl), 0, sizeof(HcfX509Crl));
438 invalidCrl.base.base.getClass = GetInvalidCrlClass;
439
440 ret = g_x509Crl->getExtensionsObject(&invalidCrl, &blob);
441 EXPECT_EQ(ret, CF_INVALID_PARAMS);
442
443 ret = g_x509Crl->getExtensionsObject(NULL, &blob);
444 EXPECT_EQ(ret, CF_INVALID_PARAMS);
445
446 ret = g_x509Crl->getExtensionsObject(g_x509Crl, NULL);
447 EXPECT_EQ(ret, CF_INVALID_PARAMS);
448
449 ret = g_x509Crl->getExtensionsObject(NULL, NULL);
450 EXPECT_EQ(ret, CF_INVALID_PARAMS);
451 }
452
453 HWTEST_F(CryptoX509CrlTestPart2, CrlEntryToStringTest001, TestSize.Level0)
454 {
455 CF_LOG_I("CrlEntryToStringTest001");
456 ASSERT_NE(g_crlEntry, nullptr);
457
458 CfBlob blob = { 0, nullptr };
459 CfResult ret = g_crlEntry->toString(g_crlEntry, &blob);
460 EXPECT_EQ(ret, CF_SUCCESS);
461 CfBlobDataFree(&blob);
462
463 HcfX509CrlEntry invalidCrlEntry;
464 HcfX509CRLEntryOpensslImpl *imp = (HcfX509CRLEntryOpensslImpl*)&invalidCrlEntry;
465 imp->base.base.getClass = GetInvalidCrlClass;
466
467 ret = g_crlEntry->toString(&invalidCrlEntry, &blob);
468 EXPECT_EQ(ret, CF_INVALID_PARAMS);
469
470 ret = g_crlEntry->toString(NULL, &blob);
471 EXPECT_EQ(ret, CF_INVALID_PARAMS);
472
473 ret = g_crlEntry->toString(g_crlEntry, NULL);
474 EXPECT_EQ(ret, CF_INVALID_PARAMS);
475
476 ret = g_crlEntry->toString(NULL, NULL);
477 EXPECT_EQ(ret, CF_INVALID_PARAMS);
478 }
479
480 HWTEST_F(CryptoX509CrlTestPart2, CrlEntryHashCodeTest001, TestSize.Level0)
481 {
482 CF_LOG_I("CrlEntryHashCodeTest001");
483 ASSERT_NE(g_crlEntry, nullptr);
484
485 CfBlob blob = { 0, nullptr };
486 CfResult ret = g_crlEntry->hashCode(g_crlEntry, &blob);
487 EXPECT_EQ(ret, CF_SUCCESS);
488 CfBlobDataFree(&blob);
489
490 HcfX509CrlEntry invalidCrlEntry;
491 HcfX509CRLEntryOpensslImpl *imp = (HcfX509CRLEntryOpensslImpl*)&invalidCrlEntry;
492 imp->base.base.getClass = GetInvalidCrlClass;
493
494 ret = g_crlEntry->hashCode(&invalidCrlEntry, &blob);
495 EXPECT_EQ(ret, CF_INVALID_PARAMS);
496
497 ret = g_crlEntry->hashCode(NULL, &blob);
498 EXPECT_EQ(ret, CF_INVALID_PARAMS);
499
500 ret = g_crlEntry->hashCode(g_crlEntry, NULL);
501 EXPECT_EQ(ret, CF_INVALID_PARAMS);
502
503 ret = g_crlEntry->hashCode(NULL, NULL);
504 EXPECT_EQ(ret, CF_INVALID_PARAMS);
505 }
506
507 HWTEST_F(CryptoX509CrlTestPart2, CrlEntryGetExtensionsObjectTest001, TestSize.Level0)
508 {
509 CF_LOG_I("CrlEntryGetExtensionsObjectTest001");
510 ASSERT_NE(g_crlEntry, nullptr);
511
512 CfBlob blob = { 0, nullptr };
513 CfResult ret = g_crlEntry->getExtensionsObject(g_crlEntry, &blob);
514 EXPECT_EQ(ret, CF_SUCCESS);
515 CfBlobDataFree(&blob);
516
517 HcfX509CrlEntry invalidCrlEntry;
518 HcfX509CRLEntryOpensslImpl *imp = (HcfX509CRLEntryOpensslImpl*)&invalidCrlEntry;
519 imp->base.base.getClass = GetInvalidCrlClass;
520
521 ret = g_crlEntry->getExtensionsObject(&invalidCrlEntry, &blob);
522 EXPECT_EQ(ret, CF_INVALID_PARAMS);
523
524 ret = g_crlEntry->getExtensionsObject(NULL, &blob);
525 EXPECT_EQ(ret, CF_INVALID_PARAMS);
526
527 ret = g_crlEntry->getExtensionsObject(g_crlEntry, NULL);
528 EXPECT_EQ(ret, CF_INVALID_PARAMS);
529
530 ret = g_crlEntry->getExtensionsObject(NULL, NULL);
531 EXPECT_EQ(ret, CF_INVALID_PARAMS);
532 }
533
534 HWTEST_F(CryptoX509CrlTestPart2, HcfX509CrlSpiEngineToStringTest001, TestSize.Level0)
535 {
536 CF_LOG_I("HcfX509CrlSpiEngineToStringTest001");
537 ASSERT_NE(g_crlSpiObj, nullptr);
538
539 CfBlob blob = { 0, nullptr };
540 CfResult ret = g_crlSpiObj->engineToString(g_crlSpiObj, &blob);
541 EXPECT_EQ(ret, CF_SUCCESS);
542 CfBlobDataFree(&blob);
543
544 HcfX509CrlSpi invalidCrlSpi;
545 invalidCrlSpi.base.getClass = GetInvalidCrlClass;
546
547 ret = g_crlSpiObj->engineToString(&invalidCrlSpi, &blob);
548 EXPECT_EQ(ret, CF_INVALID_PARAMS);
549
550 ret = g_crlSpiObj->engineToString(NULL, &blob);
551 EXPECT_EQ(ret, CF_INVALID_PARAMS);
552
553 ret = g_crlSpiObj->engineToString(g_crlSpiObj, NULL);
554 EXPECT_EQ(ret, CF_INVALID_PARAMS);
555
556 ret = g_crlSpiObj->engineToString(NULL, NULL);
557 EXPECT_EQ(ret, CF_INVALID_PARAMS);
558 }
559
560 HWTEST_F(CryptoX509CrlTestPart2, HcfX509CrlSpiEngineHashCodeTest001, TestSize.Level0)
561 {
562 CF_LOG_I("HcfX509CrlSpiEngineHashCodeTest001");
563 ASSERT_NE(g_crlSpiObj, nullptr);
564
565 CfBlob blob = { 0, nullptr };
566 CfResult ret = g_crlSpiObj->engineHashCode(g_crlSpiObj, &blob);
567 EXPECT_EQ(ret, CF_SUCCESS);
568 CfBlobDataFree(&blob);
569
570 HcfX509CrlSpi invalidCrlSpi;
571 invalidCrlSpi.base.getClass = GetInvalidCrlClass;
572
573 ret = g_crlSpiObj->engineHashCode(&invalidCrlSpi, &blob);
574 EXPECT_EQ(ret, CF_INVALID_PARAMS);
575
576 ret = g_crlSpiObj->engineHashCode(NULL, &blob);
577 EXPECT_EQ(ret, CF_INVALID_PARAMS);
578
579 ret = g_crlSpiObj->engineHashCode(g_crlSpiObj, NULL);
580 EXPECT_EQ(ret, CF_INVALID_PARAMS);
581
582 ret = g_crlSpiObj->engineHashCode(NULL, NULL);
583 EXPECT_EQ(ret, CF_INVALID_PARAMS);
584 }
585
586 HWTEST_F(CryptoX509CrlTestPart2, HcfX509CrlSpiEngineGetExtensionsObjectTest001, TestSize.Level0)
587 {
588 CF_LOG_I("HcfX509CrlSpiEngineGetExtensionsObjectTest001");
589 ASSERT_NE(g_crlSpiObj, nullptr);
590
591 CfBlob blob = { 0, nullptr };
592 CfResult ret = g_crlSpiObj->engineGetExtensionsObject(g_crlSpiObj, &blob);
593 EXPECT_EQ(ret, CF_SUCCESS);
594 CfBlobDataFree(&blob);
595
596 HcfX509CrlSpi invalidCrlSpi;
597 invalidCrlSpi.base.getClass = GetInvalidCrlClass;
598
599 ret = g_crlSpiObj->engineGetExtensionsObject(&invalidCrlSpi, &blob);
600 EXPECT_EQ(ret, CF_INVALID_PARAMS);
601
602 ret = g_crlSpiObj->engineGetExtensionsObject(NULL, &blob);
603 EXPECT_EQ(ret, CF_INVALID_PARAMS);
604
605 ret = g_crlSpiObj->engineGetExtensionsObject(g_crlSpiObj, NULL);
606 EXPECT_EQ(ret, CF_INVALID_PARAMS);
607
608 ret = g_crlSpiObj->engineGetExtensionsObject(NULL, NULL);
609 EXPECT_EQ(ret, CF_INVALID_PARAMS);
610 }
611
612 HWTEST_F(CryptoX509CrlTestPart2, X509CRLUtf8Test001, TestSize.Level0)
613 {
614 CfEncodingBlob inStream = { 0 };
615 inStream.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_testUtf8CrlData));
616 inStream.encodingFormat = CF_FORMAT_PEM;
617 inStream.len = strlen(g_testUtf8CrlData) + 1;
618 HcfX509Crl *x509Crl = nullptr;
619 CfResult ret = HcfX509CrlCreate(&inStream, &x509Crl);
620 EXPECT_EQ(ret, CF_SUCCESS);
621 EXPECT_NE(x509Crl, nullptr);
622
623 CfBlob out = { 0 };
624 ret = x509Crl->getIssuerNameEx(x509Crl, CF_ENCODING_UTF8, &out);
625 EXPECT_EQ(ret, CF_SUCCESS);
626 EXPECT_NE(out.data, nullptr);
627 CfBlobDataClearAndFree(&out);
628
629 ret = x509Crl->toStringEx(x509Crl, CF_ENCODING_UTF8, &out);
630 EXPECT_EQ(ret, CF_SUCCESS);
631 EXPECT_NE(out.data, nullptr);
632 CfBlobDataClearAndFree(&out);
633
634 CfBlob outData = { 0 };
635 ret = x509Crl->getIssuerNameDer(x509Crl, &outData);
636 EXPECT_EQ(ret, CF_SUCCESS);
637 EXPECT_NE(outData.data, nullptr);
638
639 HcfX509DistinguishedName *x509Name = nullptr;
640 ret = HcfX509DistinguishedNameCreate(&outData, false, &x509Name);
641 EXPECT_EQ(ret, CF_SUCCESS);
642 EXPECT_NE(x509Name, nullptr);
643
644 ret = x509Name->getNameEx(x509Name, CF_ENCODING_UTF8, &out);
645 EXPECT_EQ(ret, CF_SUCCESS);
646 EXPECT_NE(out.data, nullptr);
647
648 CfBlobDataClearAndFree(&outData);
649 CfBlobDataClearAndFree(&out);
650 CfObjDestroy(x509Name);
651 CfObjDestroy(x509Crl);
652 }
653
654 // invalid input.
655 HWTEST_F(CryptoX509CrlTestPart2, X509CRLUtf8Test002, TestSize.Level0)
656 {
657 HcfX509Crl *x509Crl = nullptr;
658 CfEncodingBlob inStream = { 0 };
659 inStream.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_testUtf8CrlData));
660 inStream.encodingFormat = CF_FORMAT_PEM;
661 inStream.len = strlen(g_testUtf8CrlData) + 1;
662 CfResult ret = HcfX509CrlCreate(&inStream, &x509Crl);
663 EXPECT_EQ(ret, CF_SUCCESS);
664 EXPECT_NE(x509Crl, nullptr);
665
666 CfBlob out = { 0 };
667 ret = x509Crl->getIssuerNameEx(nullptr, CF_ENCODING_UTF8, &out);
668 EXPECT_EQ(ret, CF_ERR_INTERNAL);
669 EXPECT_EQ(out.data, nullptr);
670
671 CfEncodinigType encodingType = static_cast<CfEncodinigType>(1);
672 ret = x509Crl->getIssuerNameEx(nullptr, encodingType, &out);
673 EXPECT_EQ(ret, CF_ERR_INTERNAL);
674 EXPECT_EQ(out.data, nullptr);
675
676 ret = x509Crl->getIssuerNameEx(x509Crl, CF_ENCODING_UTF8, nullptr);
677 EXPECT_EQ(ret, CF_ERR_INTERNAL);
678
679 ret = x509Crl->toStringEx(nullptr, CF_ENCODING_UTF8, &out);
680 EXPECT_EQ(ret, CF_ERR_INTERNAL);
681 EXPECT_EQ(out.data, nullptr);
682
683 ret = x509Crl->toStringEx(nullptr, encodingType, &out);
684 EXPECT_EQ(ret, CF_ERR_INTERNAL);
685 EXPECT_EQ(out.data, nullptr);
686
687 ret = x509Crl->toStringEx(x509Crl, CF_ENCODING_UTF8, nullptr);
688 EXPECT_EQ(ret, CF_ERR_INTERNAL);
689
690 CfBlob outData = { 0 };
691 ret = x509Crl->getIssuerNameDer(x509Crl, &outData);
692 EXPECT_EQ(ret, CF_SUCCESS);
693 EXPECT_NE(outData.data, nullptr);
694
695 HcfX509DistinguishedName *x509Name = nullptr;
696 ret = HcfX509DistinguishedNameCreate(&outData, false, &x509Name);
697 EXPECT_EQ(ret, CF_SUCCESS);
698 EXPECT_NE(x509Name, nullptr);
699
700 ret = x509Name->getNameEx(nullptr, CF_ENCODING_UTF8, &out);
701 EXPECT_EQ(ret, CF_ERR_INTERNAL);
702 EXPECT_EQ(out.data, nullptr);
703
704 ret = x509Name->getNameEx(x509Name, encodingType, &out);
705 EXPECT_EQ(ret, CF_ERR_PARAMETER_CHECK);
706 EXPECT_EQ(out.data, nullptr);
707
708 ret = x509Name->getNameEx(x509Name, encodingType, nullptr);
709 EXPECT_EQ(ret, CF_ERR_INTERNAL);
710
711 CfBlobDataFree(&outData);
712 CfObjDestroy(x509Crl);
713 CfObjDestroy(x509Name);
714 }
715
716 HWTEST_F(CryptoX509CrlTestPart2, X509CRLEntryUtf8Test001, TestSize.Level0)
717 {
718 CfEncodingBlob inStream = { 0 };
719 inStream.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_testUtf8CrlData));
720 inStream.encodingFormat = CF_FORMAT_PEM;
721 inStream.len = strlen(g_testUtf8CrlData) + 1;
722 HcfX509Crl *x509Crl = nullptr;
723 CfResult ret = HcfX509CrlCreate(&inStream, &x509Crl);
724 EXPECT_EQ(ret, CF_SUCCESS);
725 EXPECT_NE(x509Crl, nullptr);
726
727 uint8_t testSN[] = { 0x01, 0x72, 0xA7, 0x26, 0x3A, 0xC0 };
728 CfBlob testSnBlob = { sizeof(testSN), testSN };
729 HcfX509CrlEntry *crlEntry = nullptr;
730 ret = x509Crl->getRevokedCert(x509Crl, &testSnBlob, &crlEntry);
731 EXPECT_EQ(ret, CF_SUCCESS);
732 EXPECT_NE(crlEntry, nullptr);
733
734 CfBlob out = { 0, nullptr };
735 ret = crlEntry->getCertIssuerEx(crlEntry, CF_ENCODING_UTF8, &out);
736 EXPECT_EQ(ret, CF_SUCCESS);
737 EXPECT_NE(out.data, nullptr);
738
739 CfBlobDataClearAndFree(&out);
740 CfObjDestroy(x509Crl);
741 CfObjDestroy(crlEntry);
742 }
743
744 // invalid input.
745 HWTEST_F(CryptoX509CrlTestPart2, X509CRLEntryUtf8Test002, TestSize.Level0)
746 {
747 CfEncodingBlob inStream = { 0 };
748 inStream.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_testUtf8CrlData));
749 inStream.encodingFormat = CF_FORMAT_PEM;
750 inStream.len = strlen(g_testUtf8CrlData) + 1;
751 HcfX509Crl *x509Crl = nullptr;
752 CfResult ret = HcfX509CrlCreate(&inStream, &x509Crl);
753 EXPECT_EQ(ret, CF_SUCCESS);
754 EXPECT_NE(x509Crl, nullptr);
755
756 uint8_t testSN[] = { 0x01, 0x72, 0xA7, 0x26, 0x3A, 0xC0 };
757 CfBlob testSnBlob = { sizeof(testSN), testSN };
758 HcfX509CrlEntry *crlEntry = nullptr;
759 ret = x509Crl->getRevokedCert(x509Crl, &testSnBlob, &crlEntry);
760 EXPECT_EQ(ret, CF_SUCCESS);
761 EXPECT_NE(crlEntry, nullptr);
762
763 CfBlob out = { 0, nullptr };
764 ret = crlEntry->getCertIssuerEx(crlEntry, CF_ENCODING_UTF8, nullptr);
765 EXPECT_EQ(ret, CF_ERR_INTERNAL);
766
767 CfEncodinigType encodingType = static_cast<CfEncodinigType>(1);
768 ret = crlEntry->getCertIssuerEx(crlEntry, encodingType, &out);
769 EXPECT_EQ(ret, CF_ERR_PARAMETER_CHECK);
770 EXPECT_EQ(out.data, nullptr);
771
772 ret = crlEntry->getCertIssuerEx(nullptr, CF_ENCODING_UTF8, &out);
773 EXPECT_EQ(ret, CF_ERR_INTERNAL);
774 EXPECT_EQ(out.data, nullptr);
775
776 CfObjDestroy(x509Crl);
777 CfObjDestroy(crlEntry);
778 }
779 } // namespace
780