1 /*
2 * Copyright (C) 2022 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 "securec.h"
17
18 #include <gtest/gtest.h>
19 #include <openssl/x509.h>
20
21 #include "asy_key_generator.h"
22 #include "cipher.h"
23 #include "key_pair.h"
24 #include "memory.h"
25 #include "memory_mock.h"
26 #include "openssl_class.h"
27 #include "x509_crl.h"
28 #include "x509_crl_openssl.h"
29 #include"x509_crl_entry_openssl.h"
30
31 using namespace std;
32 using namespace testing::ext;
33
34 namespace {
35 constexpr int TEST_VERSION = 3;
36 constexpr int TEST_EXT_VERSION = 4;
37 constexpr int TEST_OFFSET_TIME = 1000;
38 constexpr int TEST_SN = 1000;
39 constexpr int TEST_TIME = 1986598400;
40 constexpr int TEST_OFFSET = 10;
41 constexpr int TEST_CRL_LEN = 256;
42
43 static char g_testErrorCert[] =
44 "-----BEGIN CERTIFICATE-----\r\n"
45 "MIIEQDCCAyigAwIBAgIQICAIMRlDU0ytSEUfNeOUJTANBgkqhkiG9w0BAQsFADBcMQswCQYDVQQG\r\n"
46 "EwJDTjEPMA0GA1UECgwGSHVhd2VpMRMwEQYDVQQLDApIdWF3ZWkgQ0JHMScwJQYDVQQDDB5IdWF3\r\n"
47 "ZWkgQ0JHIE1vYmlsZSBFcXVpcG1lbnQgQ0EwHhcNMjAwODMxMTE0MzUzWhcNMzAwODI5MTE0MzUz\r\n"
48 "WjBvMQswCQYDVQQGEwJDTjEPMA0GA1UECgwGSHVhd2VpMRMwEQYDVQQLDApIdWF3ZWkgQ0JHMTow\r\n"
49 "OAYDVQQDDDFIVUFXRUlfSFdKQURfODE4ZjhjNDUtOGNmNC00ZTM2LTkxOTMtNTQ5OWMwNzM0YzM4\r\n"
50 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArZcfL6ot4z6k3T4X3C26EI557Zvrx9Ci\r\n"
51 "hNx6RMy+vjXa3E4BkxwZ3r0ADbc+msJOq0IyQJNujaLq35oQvJgMIvBn1xFurBXdOzbygc7G9GKt\r\n"
52 "sb4rmKUP0QEPHM2/TrxAJT2LNPLrOE047ESe2X76FpDY6oZdsoGJ5I9m/mlfGsxR1l1TeUjwA/Rs\r\n"
53 "UtISR66aastBy2tU7IubP0B0Gceqy9DnjTQtY9OpkOql08H20C30iCVijK6BmP43X4OMz2MS0leV\r\n"
54 "K0AHmhiv6ufu166Xtc2JOXRk/MJ+53iprvVEUowKY/ZATUz6iDHDZYM3MdQV+VbFrOevUceOSweY\r\n"
55 "PaXCzwIDAQABo4HqMIHnMB8GA1UdIwQYMBaAFDXT2UhPcFFNI7Ey1dXdJSHOBS7dMB0GA1UdDgQW\r\n"
56 "BBSndBqCYYcTB1kMNhYMM4r/vDLteTARBglghkgBhvhCAQEEBAMCBsAwCwYDVR0PBAQDAgTwMGYG\r\n"
57 "A1UdHwRfMF0wW6BZoFeGVWh0dHA6Ly9jcGtpLWNhd2ViLmh1YXdlaS5jb20vY3BraS9zZXJ2bGV0\r\n"
58 "L2NybEZpbGVEb3duLmNybD9jZXJ0eXBlPTQmeWVhcj0vY3JsMjAyMC5jcmwwHQYDVR0lBBYwFAYI\r\n"
59 "KwYBBQUHAwEGCCsGAQUFBwMCMA0GCSqGSIb3DQEBCwUAA4IBAQCNTqZHRy7BJ+KFOflqwYkeD1Yd\r\n"
60 "K5XxcZUykw8AefX3SMYzSBzy7IIIhM5bvhWF6r5NnBJYqmyQfy+3K0Z0LQXfsY95U9JBkKl3nQPn\r\n"
61 "p1PzV8wLp/XYE7ePsbIbjQ1gQdC47sTDjoA73X4wEchdEVJBNUs2e15HRxbzaVJ6ABSKI9AHkxKv\r\n"
62 "o9iYKFozQaL4y+3Y+Yei/N1kiZZayJqC1uXq45kelc3SCJrVPE4g/Uspf2jjp7xsS+MkmxvSAT9X\r\n"
63 "OJeDWEeXyt7tvJeodRQgGZVhdtN78mtoaqWqD9Z6a6wpWdC4sZCWJfMjCu4Wd889Pn4MT5DBKBN3\r\n"
64 "f3+JpOzUJlM9\r\n"
65 "-----END CERTIFICATE-----\r\n";
66
67 static char g_testCert[] =
68 "-----BEGIN CERTIFICATE-----\r\n"
69 "MIID/jCCAuagAwIBAgIBATANBgkqhkiG9w0BAQsFADCBjDELMAkGA1UEBhMCQ04x\r\n"
70 "ETAPBgNVBAgMCHNoYW5naGFpMQ8wDQYDVQQHDAZodWF3ZWkxFTATBgNVBAoMDHd3\r\n"
71 "dy50ZXN0LmNvbTENMAsGA1UECwwEdGVzdDEVMBMGA1UEAwwMd3d3LnRlc3QuY29t\r\n"
72 "MRwwGgYJKoZIhvcNAQkBFg10ZXN0QHRlc3QuY29tMB4XDTIyMDgyOTA2NTUwM1oX\r\n"
73 "DTIzMDgyOTA2NTUwM1owezELMAkGA1UEBhMCQ04xETAPBgNVBAgMCHNoYW5naGFp\r\n"
74 "MRUwEwYDVQQKDAx3d3cudGVzdC5jb20xDTALBgNVBAsMBHRlc3QxFTATBgNVBAMM\r\n"
75 "DHd3dy50ZXN0LmNvbTEcMBoGCSqGSIb3DQEJARYNdGVzdEB0ZXN0LmNvbTCCASIw\r\n"
76 "DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAJmY9T4SzXXwKvfMvnvMWY7TqUJK\r\n"
77 "jnWf2Puv0YUQ2fdvyoKQ2LQXdtzoUL53j587oI+IXelOr7dg020zPyun0cmZHZ4y\r\n"
78 "l/qAcrWbDjZeEGcbbb5UtQtn1WOEnv8pkXluO355mbZQUKK9L3gFWseXJKGbIXw0\r\n"
79 "NRpaJZzqvPor4m3a5pmJKPHOlivUdYfLaKSkNj3DlaFzCWKV82k5ee6gzVyETtG+\r\n"
80 "XN+vq8qLybT+fIFsLNMmAHzRxlqz3NiH7yh+1/p/Knvf8bkkRVR2btH51RyX2RSu\r\n"
81 "DjPM0/VRL8fxDSDeWBq+Gvn/E6AbOVMmkx63tcyWHhklCSaZtyz7kq39TQMCAwEA\r\n"
82 "AaN7MHkwCQYDVR0TBAIwADAsBglghkgBhvhCAQ0EHxYdT3BlblNTTCBHZW5lcmF0\r\n"
83 "ZWQgQ2VydGlmaWNhdGUwHQYDVR0OBBYEFFiFDysfADQCzRZCOSPupQxFicwzMB8G\r\n"
84 "A1UdIwQYMBaAFNYQRQiPsG8HefOTsmsVhaVjY7IPMA0GCSqGSIb3DQEBCwUAA4IB\r\n"
85 "AQAeppxf6sKQJxJQXKPTT3xHKaskidNwDBbOSIvnVvWXicZXDs+1sF6tUaRgvPxL\r\n"
86 "OL58+P2Jy0tfSwj2WhqQRGe9MvQ5iFHcdelZc0ciW6EQ0VDHIaDAQc2nQzej/79w\r\n"
87 "UE7BJJV3b9n1be2iCsuodKO14pOkMb84WcIxng+8SD+MiFqV5BPO1QyKGdO1PE1b\r\n"
88 "+evjyTpFSTgZf2Mw3fGtu5hfEXyHw1lnsFY2MlSwiRlAym/gm4aXy+4H6LyXKd56\r\n"
89 "UYQ6fituD0ziaw3RI6liyIe7aENHCkZf6bAvMRhk4QiU4xu6emwX8Qt1bT7RthP0\r\n"
90 "1Vsro0IOeXT9WAcqEtQUegsi\r\n"
91 "-----END CERTIFICATE-----\r\n";
92
93 static char g_testCrl[] =
94 "-----BEGIN X509 CRL-----\r\n"
95 "MIIB/DCB5QIBATANBgkqhkiG9w0BAQsFADCBjDELMAkGA1UEBhMCQ04xETAPBgNV\r\n"
96 "BAgMCHNoYW5naGFpMQ8wDQYDVQQHDAZodWF3ZWkxFTATBgNVBAoMDHd3dy50ZXN0\r\n"
97 "LmNvbTENMAsGA1UECwwEdGVzdDEVMBMGA1UEAwwMd3d3LnRlc3QuY29tMRwwGgYJ\r\n"
98 "KoZIhvcNAQkBFg10ZXN0QHRlc3QuY29tFw0yMjA4MjkwNzAwMTRaFw0yMjA5Mjgw\r\n"
99 "NzAwMTRaMBQwEgIBARcNMjIwODI5MDY1OTUzWqAOMAwwCgYDVR0UBAMCAQAwDQYJ\r\n"
100 "KoZIhvcNAQELBQADggEBAHpfFhhUR59OAvOSuKDQUC5tKeLEuPbY8bYdmQVI8EFd\r\n"
101 "xDkZTXmT3CX1aDPYKVsG/jH9KPAmCV/ODKEGiJzclb3Z4am7tT+Wy4mpXypNS1od\r\n"
102 "wPDcQGsMrjT6iSp6JImiB0dDDSleBTBcYR/hhtFaiGSncyqJ0mhyaXPxIkNOO6nY\r\n"
103 "v+rcTEPQWavViDRyNDhnTbN868I3fzFVBcidF13CA0sCJ91ZvsE9h/YmPO2+e0YE\r\n"
104 "IUgzn37UOiLGObCVBY12QjGiuvVvCl7ncncsFEJuGfvONOqyFHjyxDHo5W0fqTn2\r\n"
105 "eCtiNcgUr9Kz2bwCmvEXhP7PuF4RMLq4vfzi0YjCG98=\r\n"
106 "-----END X509 CRL-----\r\n";
107
108 HcfX509Crl *g_x509Crl = nullptr;
109 HcfKeyPair *g_keyPair = nullptr;
110 ASN1_TIME *g_lastUpdate = nullptr;
111 ASN1_TIME *g_nextUpdate = nullptr;
112 ASN1_TIME *g_rvTime = nullptr;
113 HcfEncodingBlob *g_crlDerInStream = nullptr;
114 unsigned char *g_tbs = nullptr;
115 unsigned char *g_signatureStr = nullptr;
116 int g_signatureLen = 0;
117 class CryptoX509CrlTest : public testing::Test {
118 public:
119 static void SetUpTestCase();
120 static void TearDownTestCase();
121 void SetUp();
122 void TearDown();
123 };
124
GetCrlStream()125 static unsigned char *GetCrlStream()
126 {
127 int ret, len;
128 unsigned char *buf, *p;
129 time_t t;
130 X509_NAME *issuer;
131 X509_CRL *crl = nullptr;
132 X509_REVOKED *revoked;
133 EVP_PKEY *prikey;
134 ASN1_INTEGER *serial;
135
136 // Generate keyPair
137 HcfAsyKeyGenerator *generator = nullptr;
138 HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_3", &generator);
139 generator->generateKeyPair(generator, nullptr, &g_keyPair);
140 RSA *rsaPrikey = ((HcfOpensslRsaPriKey *)g_keyPair->priKey)->sk;
141 prikey = EVP_PKEY_new();
142 EVP_PKEY_assign_RSA(prikey, rsaPrikey);
143
144 // Set version
145 crl = X509_CRL_new();
146 ret = X509_CRL_set_version(crl, TEST_VERSION);
147
148 // Set Issuer
149 issuer = X509_NAME_new();
150 ret = X509_NAME_add_entry_by_NID(issuer, NID_commonName, V_ASN1_PRINTABLESTRING,
151 (const unsigned char *)"CRL issuer", 10, -1, 0);
152 ret = X509_CRL_set_issuer_name(crl, issuer);
153
154 // Set last time
155 g_lastUpdate = ASN1_TIME_new();
156 t = time(nullptr);
157 ASN1_TIME_set(g_lastUpdate, t + TEST_OFFSET_TIME);
158 ret = X509_CRL_set_lastUpdate(crl, g_lastUpdate);
159
160 // Set next time
161 g_nextUpdate = ASN1_TIME_new();
162 t = TEST_TIME;
163 ASN1_TIME_set(g_nextUpdate, t);
164 ret = X509_CRL_set_nextUpdate(crl, g_nextUpdate);
165
166 // Add serial number
167 revoked = X509_REVOKED_new();
168 serial = ASN1_INTEGER_new();
169 ret = ASN1_INTEGER_set(serial, TEST_SN);
170 ret = X509_REVOKED_set_serialNumber(revoked, serial);
171
172 // Set revocationDate
173 g_rvTime = ASN1_TIME_new();
174 t = TEST_TIME;
175 ASN1_TIME_set(g_rvTime, t);
176 ret = X509_CRL_set_nextUpdate(crl, g_rvTime);
177 ret = X509_REVOKED_set_revocationDate(revoked, g_rvTime);
178 ret = X509_CRL_add0_revoked(crl, revoked);
179
180 // Sort
181 ret = X509_CRL_sort(crl);
182
183 // Sign
184 ret = X509_CRL_sign(crl, prikey, EVP_md5());
185
186 len = i2d_X509_CRL(crl, nullptr);
187 buf = (unsigned char *)malloc(len + TEST_OFFSET);
188 p = buf;
189 len = i2d_X509_CRL(crl, &p);
190
191 // Get sign
192 const ASN1_BIT_STRING *ASN1Signature = NULL;
193 X509_CRL_get0_signature(crl, &ASN1Signature, NULL);
194 g_signatureStr = (unsigned char *)ASN1_STRING_get0_data(ASN1Signature);
195 g_signatureLen = ASN1_STRING_length(ASN1Signature);
196 // Get Tbs
197 i2d_re_X509_CRL_tbs(crl, &g_tbs);
198
199 return buf;
200 }
201
SetUpTestCase()202 void CryptoX509CrlTest::SetUpTestCase()
203 {
204 HcfX509Crl *x509Crl = nullptr;
205 g_crlDerInStream = (HcfEncodingBlob *)HcfMalloc(sizeof(HcfEncodingBlob), 0);
206 unsigned char *crlStream = GetCrlStream();
207 g_crlDerInStream->data = (uint8_t *)crlStream;
208 g_crlDerInStream->encodingFormat = HCF_FORMAT_DER;
209 g_crlDerInStream->len = TEST_CRL_LEN;
210 HcfX509CrlCreate(g_crlDerInStream, &x509Crl);
211 g_x509Crl = (HcfX509Crl *)x509Crl;
212 }
TearDownTestCase()213 void CryptoX509CrlTest::TearDownTestCase()
214 {
215 if (g_x509Crl != nullptr) {
216 HcfObjDestroy(g_x509Crl);
217 g_x509Crl = nullptr;
218 }
219 if (g_keyPair != nullptr) {
220 HcfObjDestroy(g_keyPair);
221 g_keyPair = nullptr;
222 }
223 if (g_lastUpdate != nullptr) {
224 ASN1_TIME_free(g_lastUpdate);
225 g_lastUpdate = nullptr;
226 }
227 if (g_nextUpdate != nullptr) {
228 ASN1_TIME_free(g_nextUpdate);
229 g_nextUpdate = nullptr;
230 }
231 if (g_rvTime != nullptr) {
232 ASN1_TIME_free(g_rvTime);
233 g_rvTime = nullptr;
234 }
235 if (g_crlDerInStream != nullptr) {
236 HcfFree(g_crlDerInStream->data);
237 HcfFree(g_crlDerInStream);
238 g_crlDerInStream = nullptr;
239 }
240 }
SetUp()241 void CryptoX509CrlTest::SetUp() {}
TearDown()242 void CryptoX509CrlTest::TearDown() {}
243
244 // Begin test crl create, test crl create PEM true
245 HWTEST_F(CryptoX509CrlTest, X509CrlTest001, TestSize.Level0)
246 {
247 HcfX509Crl *x509Crl = nullptr;
248 HcfEncodingBlob inStreamCrl = { 0 };
249 inStreamCrl.data = (uint8_t *)g_testCrl;
250 inStreamCrl.encodingFormat = HCF_FORMAT_PEM;
251 inStreamCrl.len = strlen(g_testCrl) + 1;
252 HcfResult ret = HcfX509CrlCreate(&inStreamCrl, &x509Crl);
253 EXPECT_EQ(ret, HCF_SUCCESS);
254 EXPECT_NE(x509Crl, nullptr);
255 HcfObjDestroy(x509Crl);
256 }
257
258 // Test crl create DER true
259 HWTEST_F(CryptoX509CrlTest, X509CrlTest002, TestSize.Level0)
260 {
261 HcfX509Crl *x509Crl = nullptr;
262 HcfResult ret = HcfX509CrlCreate(g_crlDerInStream, &x509Crl);
263 EXPECT_EQ(ret, HCF_SUCCESS);
264 EXPECT_NE(x509Crl, nullptr);
265 HcfObjDestroy(x509Crl);
266 }
267
268 // Test crl create error | encodingFormat
269 HWTEST_F(CryptoX509CrlTest, X509CrlTest003, TestSize.Level0)
270 {
271 HcfX509Crl *x509Crl = nullptr;
272 HcfEncodingBlob inStreamCrl = { 0 };
273 inStreamCrl.data = (uint8_t *)g_testCrl;
274 inStreamCrl.encodingFormat = HCF_FORMAT_DER;
275 inStreamCrl.len = strlen(g_testCrl) + 1;
276 HcfResult ret = HcfX509CrlCreate(&inStreamCrl, &x509Crl);
277 EXPECT_NE(ret, HCF_SUCCESS);
278 EXPECT_EQ(x509Crl, nullptr);
279 }
280
281 // Test crl create error | Crl data
282 HWTEST_F(CryptoX509CrlTest, X509CrlTest004, TestSize.Level0)
283 {
284 HcfX509Crl *x509Crl = nullptr;
285 HcfEncodingBlob inStreamCrl = { 0 };
286 inStreamCrl.data = nullptr;
287 inStreamCrl.encodingFormat = HCF_FORMAT_PEM;
288 inStreamCrl.len = strlen(g_testCrl) + 1;
289 HcfResult ret = HcfX509CrlCreate(&inStreamCrl, &x509Crl);
290 EXPECT_NE(ret, HCF_SUCCESS);
291 EXPECT_EQ(x509Crl, nullptr);
292 }
293
294 // Test crl create error | Crl len
295 HWTEST_F(CryptoX509CrlTest, X509CrlTest005, TestSize.Level0)
296 {
297 HcfX509Crl *x509Crl = nullptr;
298 HcfEncodingBlob inStreamCrl = { 0 };
299 inStreamCrl.data = (uint8_t *)g_testCrl;
300 inStreamCrl.encodingFormat = HCF_FORMAT_PEM;
301 inStreamCrl.len = 0;
302 HcfResult ret = HcfX509CrlCreate(&inStreamCrl, &x509Crl);
303 EXPECT_NE(ret, HCF_SUCCESS);
304 EXPECT_EQ(x509Crl, nullptr);
305 }
306
307 // Test crl create error | Crl nullptr
308 HWTEST_F(CryptoX509CrlTest, X509CrlTest006, TestSize.Level0)
309 {
310 HcfX509Crl *x509Crl = nullptr;
311 HcfEncodingBlob *inStreamCrl = nullptr;
312 HcfResult ret = HcfX509CrlCreate(inStreamCrl, &x509Crl);
313 EXPECT_NE(ret, HCF_SUCCESS);
314 EXPECT_EQ(x509Crl, nullptr);
315 }
316
317 // Begin test crl isRevoked, test crl isRevoked true
318 HWTEST_F(CryptoX509CrlTest, X509CrlTest011, TestSize.Level0)
319 {
320 // Get cert
321 HcfX509Certificate *x509Cert = nullptr;
322 HcfEncodingBlob inStreamCert = { 0 };
323 inStreamCert.data = (uint8_t *)g_testCert;
324 inStreamCert.encodingFormat = HCF_FORMAT_PEM;
325 inStreamCert.len = strlen(g_testCert) + 1;
326 HcfResult ret = HcfX509CertificateCreate(&inStreamCert, &x509Cert);
327 EXPECT_EQ(ret, HCF_SUCCESS);
328 EXPECT_NE(x509Cert, nullptr);
329
330 // Get crl
331 HcfX509Crl *x509Crl = nullptr;
332 HcfEncodingBlob inStreamCrl = { 0 };
333 inStreamCrl.data = (uint8_t *)g_testCrl;
334 inStreamCrl.encodingFormat = HCF_FORMAT_PEM;
335 inStreamCrl.len = strlen(g_testCrl) + 1;
336 ret = HcfX509CrlCreate(&inStreamCrl, &x509Crl);
337 EXPECT_EQ(ret, HCF_SUCCESS);
338 EXPECT_NE(x509Crl, nullptr);
339
340 bool resIsRevoked = x509Crl->base.isRevoked((HcfCrl *)x509Crl, (HcfCertificate *)x509Cert);
341 EXPECT_EQ(resIsRevoked, true);
342 HcfObjDestroy(x509Crl);
343 HcfObjDestroy(x509Cert);
344 }
345
346 // Test crl isRevoked error | crl null
347 HWTEST_F(CryptoX509CrlTest, X509CrlTest012, TestSize.Level0)
348 {
349 // Get cert
350 HcfX509Certificate *x509Cert = nullptr;
351 HcfEncodingBlob inStreamCert = { 0 };
352 inStreamCert.data = (uint8_t *)g_testCert;
353 inStreamCert.encodingFormat = HCF_FORMAT_PEM;
354 inStreamCert.len = strlen(g_testCert) + 1;
355 HcfResult ret = HcfX509CertificateCreate(&inStreamCert, &x509Cert);
356 EXPECT_EQ(ret, HCF_SUCCESS);
357 EXPECT_NE(x509Cert, nullptr);
358
359 bool resIsRevoked = g_x509Crl->base.isRevoked(nullptr, (HcfCertificate *)x509Cert);
360 EXPECT_EQ(resIsRevoked, false);
361 HcfObjDestroy(x509Cert);
362 }
363
364 // Test crl isRevoked error | x509Cert null
365 HWTEST_F(CryptoX509CrlTest, X509CrlTest013, TestSize.Level0)
366 {
367 // Get crl
368 HcfX509Crl *x509Crl = nullptr;
369 HcfEncodingBlob inStreamCrl = { 0 };
370 inStreamCrl.data = (uint8_t *)g_testCrl;
371 inStreamCrl.encodingFormat = HCF_FORMAT_PEM;
372 inStreamCrl.len = strlen(g_testCrl) + 1;
373 HcfResult ret = HcfX509CrlCreate(&inStreamCrl, &x509Crl);
374 EXPECT_EQ(ret, HCF_SUCCESS);
375 EXPECT_NE(x509Crl, nullptr);
376
377 bool resIsRevoked = x509Crl->base.isRevoked((HcfCrl *)x509Crl, nullptr);
378 EXPECT_EQ(resIsRevoked, false);
379 HcfObjDestroy(x509Crl);
380 }
381
382 // Test crl isRevoked error | x509Crl error
383 HWTEST_F(CryptoX509CrlTest, X509CrlTest014, TestSize.Level0)
384 {
385 // Get cert
386 HcfX509Certificate *x509Cert = nullptr;
387 HcfEncodingBlob inStreamCert = { 0 };
388 inStreamCert.data = (uint8_t *)g_testCert;
389 inStreamCert.encodingFormat = HCF_FORMAT_PEM;
390 inStreamCert.len = strlen(g_testCert) + 1;
391 HcfResult ret = HcfX509CertificateCreate(&inStreamCert, &x509Cert);
392 EXPECT_EQ(ret, HCF_SUCCESS);
393 EXPECT_NE(x509Cert, nullptr);
394
395 // Get crl
396 HcfX509Crl *x509Crl = nullptr;
397 ret = HcfX509CrlCreate(g_crlDerInStream, &x509Crl);
398 EXPECT_EQ(ret, HCF_SUCCESS);
399 EXPECT_NE(x509Crl, nullptr);
400
401 bool resIsRevoked = x509Crl->base.isRevoked((HcfCrl *)x509Crl, (HcfCertificate *)x509Cert);
402 EXPECT_EQ(resIsRevoked, false);
403 HcfObjDestroy(x509Cert);
404 HcfObjDestroy(x509Crl);
405 }
406
407 // Test crl isRevoked error | x509Crl error
408 HWTEST_F(CryptoX509CrlTest, X509CrlTest015, TestSize.Level0)
409 {
410 // Get cert
411 HcfX509Certificate *x509Cert = nullptr;
412 HcfEncodingBlob inStreamCert = { 0 };
413 inStreamCert.data = (uint8_t *)g_testErrorCert;
414 inStreamCert.encodingFormat = HCF_FORMAT_PEM;
415 inStreamCert.len = strlen(g_testErrorCert) + 1;
416 HcfResult ret = HcfX509CertificateCreate(&inStreamCert, &x509Cert);
417 EXPECT_EQ(ret, HCF_SUCCESS);
418 EXPECT_NE(x509Cert, nullptr);
419
420 // Get crl
421 HcfX509Crl *x509Crl = nullptr;
422 HcfEncodingBlob inStreamCrl = { 0 };
423 inStreamCrl.data = (uint8_t *)g_testCrl;
424 inStreamCrl.encodingFormat = HCF_FORMAT_PEM;
425 inStreamCrl.len = strlen(g_testCrl) + 1;
426 ret = HcfX509CrlCreate(&inStreamCrl, &x509Crl);
427 EXPECT_EQ(ret, HCF_SUCCESS);
428 EXPECT_NE(x509Crl, nullptr);
429
430 bool resIsRevoked = x509Crl->base.isRevoked((HcfCrl *)x509Crl, (HcfCertificate *)x509Cert);
431 EXPECT_EQ(resIsRevoked, false);
432 HcfObjDestroy(x509Cert);
433 HcfObjDestroy(x509Crl);
434 }
435
436 // Test crl GetType true
437 HWTEST_F(CryptoX509CrlTest, X509CrlTest021, TestSize.Level0)
438 {
439 // Get crl
440 HcfX509Crl *x509Crl = nullptr;
441 HcfEncodingBlob inStreamCrl = { 0 };
442 inStreamCrl.data = (uint8_t *)g_testCrl;
443 inStreamCrl.encodingFormat = HCF_FORMAT_PEM;
444 inStreamCrl.len = strlen(g_testCrl) + 1;
445 HcfResult ret = HcfX509CrlCreate(&inStreamCrl, &x509Crl);
446 EXPECT_EQ(ret, HCF_SUCCESS);
447 EXPECT_NE(x509Crl, nullptr);
448
449 const char *resStr = x509Crl->base.getType((HcfCrl *)x509Crl);
450 EXPECT_STREQ(resStr, "X509");
451 HcfObjDestroy(x509Crl);
452 }
453
454 // Test crl GetType error
455 HWTEST_F(CryptoX509CrlTest, X509CrlTest022, TestSize.Level0)
456 {
457 // Get crl
458 HcfX509Crl *x509Crl = nullptr;
459 HcfEncodingBlob inStreamCrl = { 0 };
460 inStreamCrl.data = (uint8_t *)g_testCrl;
461 inStreamCrl.encodingFormat = HCF_FORMAT_PEM;
462 inStreamCrl.len = strlen(g_testCrl) + 1;
463 HcfResult ret = HcfX509CrlCreate(&inStreamCrl, &x509Crl);
464 EXPECT_EQ(ret, HCF_SUCCESS);
465 EXPECT_NE(x509Crl, nullptr);
466
467 const char *resStr = x509Crl->base.getType(nullptr);
468 EXPECT_EQ(resStr, nullptr);
469 HcfObjDestroy(x509Crl);
470 }
471
472 // Test crl getEncoded DER true
473 HWTEST_F(CryptoX509CrlTest, X509CrlTest031, TestSize.Level0)
474 {
475 HcfEncodingBlob inStreamInput = { 0 };
476 HcfResult ret = g_x509Crl->getEncoded(g_x509Crl, &inStreamInput);
477 EXPECT_EQ(ret, HCF_SUCCESS);
478 HcfX509Crl *crl2 = nullptr;
479 ret = HcfX509CrlCreate(&inStreamInput, &crl2);
480 EXPECT_EQ(ret, HCF_SUCCESS);
481 EXPECT_NE(crl2, nullptr);
482 HcfObjDestroy(crl2);
483 HcfFree(inStreamInput.data);
484 }
485
486 // Test crl getEncoded PEM true
487 HWTEST_F(CryptoX509CrlTest, X509CrlTest032, TestSize.Level0)
488 {
489 // Get crl
490 HcfX509Crl *x509Crl = nullptr;
491 HcfEncodingBlob inStreamCrl = { 0 };
492 inStreamCrl.data = (uint8_t *)g_testCrl;
493 inStreamCrl.encodingFormat = HCF_FORMAT_PEM;
494 inStreamCrl.len = strlen(g_testCrl) + 1;
495 HcfResult ret = HcfX509CrlCreate(&inStreamCrl, &x509Crl);
496 EXPECT_EQ(ret, HCF_SUCCESS);
497 EXPECT_NE(x509Crl, nullptr);
498
499 HcfEncodingBlob inStreamInput = { 0 };
500 ret = x509Crl->getEncoded(x509Crl, &inStreamInput);
501 EXPECT_EQ(ret, HCF_SUCCESS);
502 HcfX509Crl *crl2 = nullptr;
503 ret = HcfX509CrlCreate(&inStreamInput, &crl2);
504 EXPECT_EQ(ret, HCF_SUCCESS);
505 EXPECT_NE(crl2, nullptr);
506 HcfFree(inStreamInput.data);
507 HcfObjDestroy(crl2);
508 HcfObjDestroy(x509Crl);
509 }
510
511 // Test crl getEncoded error
512 HWTEST_F(CryptoX509CrlTest, X509CrlTest033, TestSize.Level0)
513 {
514 HcfResult ret = g_x509Crl->getEncoded(g_x509Crl, nullptr);
515 EXPECT_NE(ret, HCF_SUCCESS);
516 }
517
518 // Test crl getEncoded error
519 HWTEST_F(CryptoX509CrlTest, X509CrlTest034, TestSize.Level0)
520 {
521 HcfEncodingBlob inStreamInput = { 0 };
522 HcfResult ret = g_x509Crl->getEncoded(nullptr, &inStreamInput);
523 EXPECT_NE(ret, HCF_SUCCESS);
524 }
525
526 // Test crl getEncoded error
527 HWTEST_F(CryptoX509CrlTest, X509CrlTest035, TestSize.Level0)
528 {
529 HcfResult ret = g_x509Crl->getEncoded(nullptr, nullptr);
530 EXPECT_NE(ret, HCF_SUCCESS);
531 }
532
533 // Test crl verify true
534 HWTEST_F(CryptoX509CrlTest, X509CrlTest041, TestSize.Level0)
535 {
536 HcfResult ret = g_x509Crl->verify(g_x509Crl, g_keyPair->pubKey);
537 EXPECT_EQ(ret, HCF_SUCCESS);
538 }
539
540 // Test crl verify false
541 HWTEST_F(CryptoX509CrlTest, X509CrlTest042, TestSize.Level0)
542 {
543 HcfKeyPair *keyPair = nullptr;
544 HcfAsyKeyGenerator *generator = nullptr;
545 HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_3", &generator);
546 generator->generateKeyPair(generator, nullptr, &keyPair);
547
548 HcfResult ret = g_x509Crl->verify(g_x509Crl, keyPair->pubKey);
549 EXPECT_NE(ret, HCF_SUCCESS);
550 HcfObjDestroy(keyPair);
551 HcfObjDestroy(generator);
552 }
553
554 // Test crl verify false
555 HWTEST_F(CryptoX509CrlTest, X509CrlTest043, TestSize.Level0)
556 {
557 HcfResult ret = g_x509Crl->verify(nullptr, g_keyPair->pubKey);
558 EXPECT_NE(ret, HCF_SUCCESS);
559 }
560
561 // Test crl verify false
562 HWTEST_F(CryptoX509CrlTest, X509CrlTest044, TestSize.Level0)
563 {
564 HcfResult ret = g_x509Crl->verify(g_x509Crl, nullptr);
565 EXPECT_NE(ret, HCF_SUCCESS);
566 }
567
568 // Test crl verify false
569 HWTEST_F(CryptoX509CrlTest, X509CrlTest045, TestSize.Level0)
570 {
571 // Get crl
572 HcfX509Crl *x509Crl = nullptr;
573 HcfEncodingBlob inStreamCrl = { 0 };
574 inStreamCrl.data = (uint8_t *)g_testCrl;
575 inStreamCrl.encodingFormat = HCF_FORMAT_PEM;
576 inStreamCrl.len = strlen(g_testCrl) + 1;
577 HcfResult ret = HcfX509CrlCreate(&inStreamCrl, &x509Crl);
578 EXPECT_EQ(ret, HCF_SUCCESS);
579 EXPECT_NE(x509Crl, nullptr);
580
581 ret = x509Crl->verify(x509Crl, nullptr);
582 EXPECT_NE(ret, HCF_SUCCESS);
583 HcfObjDestroy(x509Crl);
584 }
585
586 // Test crl getVersion true
587 HWTEST_F(CryptoX509CrlTest, X509CrlTest051, TestSize.Level0)
588 {
589 long version = g_x509Crl->getVersion(g_x509Crl);
590 EXPECT_EQ(version, TEST_EXT_VERSION);
591 }
592
593 // Test crl getVersion false
594 HWTEST_F(CryptoX509CrlTest, X509CrlTest052, TestSize.Level0)
595 {
596 long version = g_x509Crl->getVersion(nullptr);
597 EXPECT_EQ(version, -1);
598 }
599
600 // Test crl getIssuerName true
601 HWTEST_F(CryptoX509CrlTest, X509CrlTest061, TestSize.Level0)
602 {
603 HcfBlob out = { 0 };
604 HcfResult ret = g_x509Crl->getIssuerName(g_x509Crl, &out);
605 EXPECT_EQ(ret, HCF_SUCCESS);
606 EXPECT_NE(out.data, nullptr);
607 EXPECT_STREQ("/CN=CRL issuer", (char *)(out.data));
608 HcfFree(out.data);
609 }
610
611 // Test crl getIssuerName false
612 HWTEST_F(CryptoX509CrlTest, X509CrlTest062, TestSize.Level0)
613 {
614 HcfBlob out = { 0 };
615 HcfResult ret = g_x509Crl->getIssuerName(nullptr, &out);
616 EXPECT_NE(ret, HCF_SUCCESS);
617 EXPECT_EQ(out.data, nullptr);
618 }
619
620 // Test crl getIssuerName false
621 HWTEST_F(CryptoX509CrlTest, X509CrlTest063, TestSize.Level0)
622 {
623 HcfResult ret = g_x509Crl->getIssuerName(g_x509Crl, nullptr);
624 EXPECT_NE(ret, HCF_SUCCESS);
625 }
626
627 // Test crl getIssuerName false
628 HWTEST_F(CryptoX509CrlTest, X509CrlTest064, TestSize.Level0)
629 {
630 HcfResult ret = g_x509Crl->getIssuerName(nullptr, nullptr);
631 EXPECT_NE(ret, HCF_SUCCESS);
632 }
633
634 // Test crl getLastUpdate true
635 HWTEST_F(CryptoX509CrlTest, X509CrlTest071, TestSize.Level0)
636 {
637 HcfBlob out = { 0 };
638 HcfResult ret = g_x509Crl->getLastUpdate(g_x509Crl, &out);
639 EXPECT_EQ(ret, HCF_SUCCESS);
640 EXPECT_NE(out.data, nullptr);
641 EXPECT_STREQ((char *)g_lastUpdate->data, (char *)out.data);
642 HcfFree(out.data);
643 }
644
645 // Test crl getLastUpdate false
646 HWTEST_F(CryptoX509CrlTest, X509CrlTest072, TestSize.Level0)
647 {
648 HcfBlob out = { 0 };
649 HcfResult ret = g_x509Crl->getLastUpdate(nullptr, &out);
650 EXPECT_NE(ret, HCF_SUCCESS);
651 EXPECT_EQ(out.data, nullptr);
652 }
653
654 // Test crl getLastUpdate false
655 HWTEST_F(CryptoX509CrlTest, X509CrlTest073, TestSize.Level0)
656 {
657 HcfResult ret = g_x509Crl->getLastUpdate(g_x509Crl, nullptr);
658 EXPECT_NE(ret, HCF_SUCCESS);
659 }
660
661 // Test crl getLastUpdate false
662 HWTEST_F(CryptoX509CrlTest, X509CrlTest074, TestSize.Level0)
663 {
664 HcfResult ret = g_x509Crl->getLastUpdate(nullptr, nullptr);
665 EXPECT_NE(ret, HCF_SUCCESS);
666 }
667
668 // Test crl getNextUpdate true
669 HWTEST_F(CryptoX509CrlTest, X509CrlTest081, TestSize.Level0)
670 {
671 HcfBlob out = { 0 };
672 HcfResult ret = g_x509Crl->getNextUpdate(g_x509Crl, &out);
673 EXPECT_EQ(ret, HCF_SUCCESS);
674 EXPECT_NE(out.data, nullptr);
675 EXPECT_STREQ((char *)g_nextUpdate->data, (char *)out.data);
676 HcfFree(out.data);
677 }
678
679 // Test crl getNextUpdate false
680 HWTEST_F(CryptoX509CrlTest, X509CrlTest082, TestSize.Level0)
681 {
682 HcfBlob out = { 0 };
683 HcfResult ret = g_x509Crl->getNextUpdate(nullptr, &out);
684 EXPECT_NE(ret, HCF_SUCCESS);
685 EXPECT_EQ(out.data, nullptr);
686 }
687
688 // Test crl getNextUpdate false
689 HWTEST_F(CryptoX509CrlTest, X509CrlTest083, TestSize.Level0)
690 {
691 HcfResult ret = g_x509Crl->getNextUpdate(g_x509Crl, nullptr);
692 EXPECT_NE(ret, HCF_SUCCESS);
693 }
694
695 // Test crl getNextUpdate false
696 HWTEST_F(CryptoX509CrlTest, X509CrlTest084, TestSize.Level0)
697 {
698 HcfResult ret = g_x509Crl->getNextUpdate(nullptr, nullptr);
699 EXPECT_NE(ret, HCF_SUCCESS);
700 }
701
702 // Test crl getRevokedCert true
703 HWTEST_F(CryptoX509CrlTest, X509CrlTest091, TestSize.Level0)
704 {
705 HcfX509CrlEntry *crlEntry = nullptr;
706 HcfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, 1000, &crlEntry);
707 EXPECT_EQ(ret, HCF_SUCCESS);
708 EXPECT_NE(crlEntry, nullptr);
709 HcfObjDestroy(crlEntry);
710 }
711
712 // Test crl getRevokedCert false
713 HWTEST_F(CryptoX509CrlTest, X509CrlTest092, TestSize.Level0)
714 {
715 HcfX509CrlEntry *crlEntry = nullptr;
716 HcfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, 9999, &crlEntry);
717 EXPECT_NE(ret, HCF_SUCCESS);
718 }
719
720 // Test crl getRevokedCert false
721 HWTEST_F(CryptoX509CrlTest, X509CrlTest093, TestSize.Level0)
722 {
723 HcfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, 1000, nullptr);
724 EXPECT_NE(ret, HCF_SUCCESS);
725 }
726
727 // Test crl getRevokedCert false
728 HWTEST_F(CryptoX509CrlTest, X509CrlTest094, TestSize.Level0)
729 {
730 HcfX509CrlEntry *crlEntry = nullptr;
731 HcfResult ret = g_x509Crl->getRevokedCert(nullptr, 1000, &crlEntry);
732 EXPECT_NE(ret, HCF_SUCCESS);
733 }
734
735 // Test crl getRevokedCert false
736 HWTEST_F(CryptoX509CrlTest, X509CrlTest095, TestSize.Level0)
737 {
738 HcfResult ret = g_x509Crl->getRevokedCert(nullptr, 1000, nullptr);
739 EXPECT_NE(ret, HCF_SUCCESS);
740 }
741
742 // Test crl entry getSerialNumber true
743 HWTEST_F(CryptoX509CrlTest, X509CrlTest101, TestSize.Level0)
744 {
745 HcfX509CrlEntry *crlEntry = nullptr;
746 HcfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, 1000, &crlEntry);
747 EXPECT_EQ(ret, HCF_SUCCESS);
748 EXPECT_NE(crlEntry, nullptr);
749 long sn = crlEntry->getSerialNumber(crlEntry);
750 EXPECT_EQ(sn, 1000);
751 HcfObjDestroy(crlEntry);
752 }
753
754 // Test crl entry getSerialNumber false
755 HWTEST_F(CryptoX509CrlTest, X509CrlTest102, TestSize.Level0)
756 {
757 HcfX509CrlEntry *crlEntry = nullptr;
758 HcfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, 1000, &crlEntry);
759 EXPECT_EQ(ret, HCF_SUCCESS);
760 EXPECT_NE(crlEntry, nullptr);
761 long sn = crlEntry->getSerialNumber(nullptr);
762 EXPECT_EQ(sn, -1);
763 HcfObjDestroy(crlEntry);
764 }
765
766 // Test crl entry getSerialNumber false
767 HWTEST_F(CryptoX509CrlTest, X509CrlTest103, TestSize.Level0)
768 {
769 HcfX509CrlEntry *crlEntry = nullptr;
770 HcfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, 1000, &crlEntry);
771 EXPECT_EQ(ret, HCF_SUCCESS);
772 EXPECT_NE(crlEntry, nullptr);
773 long sn = crlEntry->getSerialNumber(nullptr);
774 EXPECT_EQ(sn, -1);
775 HcfObjDestroy(crlEntry);
776 }
777
778 // Test crl entry getEncoded true
779 HWTEST_F(CryptoX509CrlTest, X509CrlTest111, TestSize.Level0)
780 {
781 HcfX509CrlEntry *crlEntry = nullptr;
782 HcfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, 1000, &crlEntry);
783 EXPECT_EQ(ret, HCF_SUCCESS);
784 EXPECT_NE(crlEntry, nullptr);
785
786 HcfEncodingBlob encodingBlob = { 0 };
787 ret = crlEntry->getEncoded(crlEntry, &encodingBlob);
788 EXPECT_EQ(ret, HCF_SUCCESS);
789 EXPECT_NE(encodingBlob.data, nullptr);
790 HcfObjDestroy(crlEntry);
791 HcfFree(encodingBlob.data);
792 }
793
794 // Test crl entry getEncoded false
795 HWTEST_F(CryptoX509CrlTest, X509CrlTest112, TestSize.Level0)
796 {
797 HcfX509CrlEntry *crlEntry = nullptr;
798 HcfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, 1000, &crlEntry);
799 EXPECT_EQ(ret, HCF_SUCCESS);
800 EXPECT_NE(crlEntry, nullptr);
801
802 HcfEncodingBlob encodingBlob = { 0 };
803 ret = crlEntry->getEncoded(nullptr, &encodingBlob);
804 EXPECT_NE(ret, HCF_SUCCESS);
805 EXPECT_EQ(encodingBlob.data, nullptr);
806 HcfObjDestroy(crlEntry);
807 }
808
809 // Test crl entry getEncoded false
810 HWTEST_F(CryptoX509CrlTest, X509CrlTest113, TestSize.Level0)
811 {
812 HcfX509CrlEntry *crlEntry = nullptr;
813 HcfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, 1000, &crlEntry);
814 EXPECT_EQ(ret, HCF_SUCCESS);
815 EXPECT_NE(crlEntry, nullptr);
816
817 ret = crlEntry->getEncoded(crlEntry, nullptr);
818 EXPECT_NE(ret, HCF_SUCCESS);
819 HcfObjDestroy(crlEntry);
820 }
821
822 // Test crl entry getEncoded false
823 HWTEST_F(CryptoX509CrlTest, X509CrlTest114, TestSize.Level0)
824 {
825 HcfX509CrlEntry *crlEntry = nullptr;
826 HcfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, 1000, &crlEntry);
827 EXPECT_EQ(ret, HCF_SUCCESS);
828 EXPECT_NE(crlEntry, nullptr);
829
830 ret = crlEntry->getEncoded(nullptr, nullptr);
831 EXPECT_NE(ret, HCF_SUCCESS);
832 HcfObjDestroy(crlEntry);
833 }
834
835 // Test crl entry getCertIssuer true
836 HWTEST_F(CryptoX509CrlTest, X509CrlTest121, TestSize.Level0)
837 {
838 HcfX509CrlEntry *crlEntry = nullptr;
839 HcfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, 1000, &crlEntry);
840 EXPECT_EQ(ret, HCF_SUCCESS);
841 EXPECT_NE(crlEntry, nullptr);
842
843 HcfBlob out = { 0 };
844 ret = crlEntry->getCertIssuer(crlEntry, &out);
845 EXPECT_EQ(ret, HCF_SUCCESS);
846 EXPECT_NE(out.data, nullptr);
847 EXPECT_STREQ("/CN=CRL issuer", (char *)out.data);
848 HcfObjDestroy(crlEntry);
849 HcfFree(out.data);
850 }
851
852 // Test crl entry getCertIssuer false
853 HWTEST_F(CryptoX509CrlTest, X509CrlTest122, TestSize.Level0)
854 {
855 HcfX509CrlEntry *crlEntry = nullptr;
856 HcfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, 1000, &crlEntry);
857 EXPECT_EQ(ret, HCF_SUCCESS);
858 EXPECT_NE(crlEntry, nullptr);
859
860 HcfBlob out = { 0 };
861 ret = crlEntry->getCertIssuer(nullptr, &out);
862 EXPECT_NE(ret, HCF_SUCCESS);
863 EXPECT_EQ(out.data, nullptr);
864 HcfObjDestroy(crlEntry);
865 }
866
867 // Test crl entry getCertIssuer false
868 HWTEST_F(CryptoX509CrlTest, X509CrlTest123, TestSize.Level0)
869 {
870 HcfX509CrlEntry *crlEntry = nullptr;
871 HcfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, 1000, &crlEntry);
872 EXPECT_EQ(ret, HCF_SUCCESS);
873 EXPECT_NE(crlEntry, nullptr);
874
875 ret = crlEntry->getCertIssuer(crlEntry, nullptr);
876 EXPECT_NE(ret, HCF_SUCCESS);
877 HcfObjDestroy(crlEntry);
878 }
879
880 // Test crl entry getRevocationDate true
881 HWTEST_F(CryptoX509CrlTest, X509CrlTest131, TestSize.Level0)
882 {
883 HcfX509CrlEntry *crlEntry = nullptr;
884 HcfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, 1000, &crlEntry);
885 EXPECT_EQ(ret, HCF_SUCCESS);
886 EXPECT_NE(crlEntry, nullptr);
887
888 HcfBlob out = { 0 };
889 ret = crlEntry->getRevocationDate(crlEntry, &out);
890 EXPECT_EQ(ret, HCF_SUCCESS);
891 EXPECT_NE(out.data, nullptr);
892 EXPECT_STREQ((char *)g_rvTime->data, (char *)out.data);
893 HcfObjDestroy(crlEntry);
894 HcfFree(out.data);
895 }
896
897 // Test crl entry getRevocationDate false
898 HWTEST_F(CryptoX509CrlTest, X509CrlTest132, TestSize.Level0)
899 {
900 HcfX509CrlEntry *crlEntry = nullptr;
901 HcfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, 1000, &crlEntry);
902 EXPECT_EQ(ret, HCF_SUCCESS);
903 EXPECT_NE(crlEntry, nullptr);
904
905 HcfBlob out = { 0 };
906 ret = crlEntry->getRevocationDate(nullptr, &out);
907 EXPECT_NE(ret, HCF_SUCCESS);
908 EXPECT_EQ(out.data, nullptr);
909 HcfObjDestroy(crlEntry);
910 }
911
912 // Test crl entry getRevocationDate false
913 HWTEST_F(CryptoX509CrlTest, X509CrlTest133, TestSize.Level0)
914 {
915 HcfX509CrlEntry *crlEntry = nullptr;
916 HcfResult ret = g_x509Crl->getRevokedCert(g_x509Crl, 1000, &crlEntry);
917 EXPECT_EQ(ret, HCF_SUCCESS);
918 EXPECT_NE(crlEntry, nullptr);
919
920 ret = crlEntry->getRevocationDate(crlEntry, nullptr);
921 EXPECT_NE(ret, HCF_SUCCESS);
922 HcfObjDestroy(crlEntry);
923 }
924
925 // Test crl getRevokedCertWithCert true
926 HWTEST_F(CryptoX509CrlTest, X509CrlTest141, TestSize.Level0)
927 {
928 // Get cert
929 HcfX509Certificate *x509Cert = nullptr;
930 HcfEncodingBlob inStreamCert = { 0 };
931 inStreamCert.data = (uint8_t *)g_testCert;
932 inStreamCert.encodingFormat = HCF_FORMAT_PEM;
933 inStreamCert.len = strlen(g_testCert) + 1;
934 HcfResult ret = HcfX509CertificateCreate(&inStreamCert, &x509Cert);
935 EXPECT_EQ(ret, HCF_SUCCESS);
936 EXPECT_NE(x509Cert, nullptr);
937
938 // Get crl
939 HcfX509Crl *x509Crl = nullptr;
940 HcfEncodingBlob inStreamCrl = { 0 };
941 inStreamCrl.data = (uint8_t *)g_testCrl;
942 inStreamCrl.encodingFormat = HCF_FORMAT_PEM;
943 inStreamCrl.len = strlen(g_testCrl) + 1;
944 ret = HcfX509CrlCreate(&inStreamCrl, &x509Crl);
945 EXPECT_EQ(ret, HCF_SUCCESS);
946 EXPECT_NE(x509Crl, nullptr);
947
948 HcfX509CrlEntry *crlEntry = nullptr;
949 ret = x509Crl->getRevokedCertWithCert(x509Crl, x509Cert, &crlEntry);
950 EXPECT_EQ(ret, HCF_SUCCESS);
951 EXPECT_NE(crlEntry, nullptr);
952
953 HcfBlob out = { 0 };
954 ret = crlEntry->getRevocationDate(crlEntry, &out);
955 EXPECT_EQ(ret, HCF_SUCCESS);
956 EXPECT_NE(out.data, nullptr);
957 EXPECT_STREQ("220829065953Z", (char *)out.data);
958
959 HcfObjDestroy(x509Cert);
960 HcfObjDestroy(x509Crl);
961 HcfObjDestroy(crlEntry);
962 HcfFree(out.data);
963 }
964
965 // Test crl getRevokedCertWithCert true
966 HWTEST_F(CryptoX509CrlTest, X509CrlTest142, TestSize.Level0)
967 {
968 // Get cert
969 HcfX509Certificate *x509Cert = nullptr;
970 HcfEncodingBlob inStreamCert = { 0 };
971 inStreamCert.data = (uint8_t *)g_testCert;
972 inStreamCert.encodingFormat = HCF_FORMAT_PEM;
973 inStreamCert.len = strlen(g_testCert) + 1;
974 HcfResult ret = HcfX509CertificateCreate(&inStreamCert, &x509Cert);
975 EXPECT_EQ(ret, HCF_SUCCESS);
976 EXPECT_NE(x509Cert, nullptr);
977
978 // Get crl
979 HcfX509Crl *x509Crl = nullptr;
980 HcfEncodingBlob inStreamCrl = { 0 };
981 inStreamCrl.data = (uint8_t *)g_testCrl;
982 inStreamCrl.encodingFormat = HCF_FORMAT_PEM;
983 inStreamCrl.len = strlen(g_testCrl) + 1;
984 ret = HcfX509CrlCreate(&inStreamCrl, &x509Crl);
985 EXPECT_EQ(ret, HCF_SUCCESS);
986 EXPECT_NE(x509Crl, nullptr);
987
988 HcfX509CrlEntry *crlEntry = nullptr;
989 ret = x509Crl->getRevokedCertWithCert(x509Crl, x509Cert, &crlEntry);
990 EXPECT_EQ(ret, HCF_SUCCESS);
991 EXPECT_NE(crlEntry, nullptr);
992
993 HcfBlob out = { 0 };
994 ret = crlEntry->getCertIssuer(crlEntry, &out);
995 EXPECT_EQ(ret, HCF_SUCCESS);
996 EXPECT_NE(out.data, nullptr);
997 EXPECT_STREQ("/C=CN/ST=shanghai/L=huawei/O=www.test.com/OU=test/CN=www.test.com/emailAddress=test@test.com",
998 (char *)out.data);
999
1000 HcfObjDestroy(x509Cert);
1001 HcfObjDestroy(x509Crl);
1002 HcfObjDestroy(crlEntry);
1003 HcfFree(out.data);
1004 }
1005
1006 // Test crl getRevokedCertWithCert true
1007 HWTEST_F(CryptoX509CrlTest, X509CrlTest143, TestSize.Level0)
1008 {
1009 // Get cert
1010 HcfX509Certificate *x509Cert = nullptr;
1011 HcfEncodingBlob inStreamCert = { 0 };
1012 inStreamCert.data = (uint8_t *)g_testCert;
1013 inStreamCert.encodingFormat = HCF_FORMAT_PEM;
1014 inStreamCert.len = strlen(g_testCert) + 1;
1015 HcfResult ret = HcfX509CertificateCreate(&inStreamCert, &x509Cert);
1016 EXPECT_EQ(ret, HCF_SUCCESS);
1017 EXPECT_NE(x509Cert, nullptr);
1018
1019 // Get crl
1020 HcfX509Crl *x509Crl = nullptr;
1021 HcfEncodingBlob inStreamCrl = { 0 };
1022 inStreamCrl.data = (uint8_t *)g_testCrl;
1023 inStreamCrl.encodingFormat = HCF_FORMAT_PEM;
1024 inStreamCrl.len = strlen(g_testCrl) + 1;
1025 ret = HcfX509CrlCreate(&inStreamCrl, &x509Crl);
1026 EXPECT_EQ(ret, HCF_SUCCESS);
1027 EXPECT_NE(x509Crl, nullptr);
1028
1029 HcfX509CrlEntry *crlEntry = nullptr;
1030 ret = x509Crl->getRevokedCertWithCert(x509Crl, x509Cert, &crlEntry);
1031 EXPECT_EQ(ret, HCF_SUCCESS);
1032 EXPECT_NE(crlEntry, nullptr);
1033
1034 HcfEncodingBlob encodingBlob = { 0 };
1035 ret = crlEntry->getEncoded(crlEntry, &encodingBlob);
1036 EXPECT_EQ(ret, HCF_SUCCESS);
1037 EXPECT_NE(encodingBlob.data, nullptr);
1038
1039 HcfFree(encodingBlob.data);
1040 HcfObjDestroy(x509Cert);
1041 HcfObjDestroy(x509Crl);
1042 HcfObjDestroy(crlEntry);
1043 }
1044
1045 // Test crl getRevokedCertWithCert false
1046 HWTEST_F(CryptoX509CrlTest, X509CrlTest144, TestSize.Level0)
1047 {
1048 // Get crl
1049 HcfX509Crl *x509Crl = nullptr;
1050 HcfEncodingBlob inStreamCrl = { 0 };
1051 inStreamCrl.data = (uint8_t *)g_testCrl;
1052 inStreamCrl.encodingFormat = HCF_FORMAT_PEM;
1053 inStreamCrl.len = strlen(g_testCrl) + 1;
1054 HcfResult ret = HcfX509CrlCreate(&inStreamCrl, &x509Crl);
1055 EXPECT_EQ(ret, HCF_SUCCESS);
1056 EXPECT_NE(x509Crl, nullptr);
1057
1058 HcfX509CrlEntry *crlEntry = nullptr;
1059 ret = x509Crl->getRevokedCertWithCert(x509Crl, nullptr, &crlEntry);
1060 EXPECT_NE(ret, HCF_SUCCESS);
1061 EXPECT_EQ(crlEntry, nullptr);
1062
1063 HcfObjDestroy(x509Crl);
1064 }
1065
1066 // Test crl getRevokedCertWithCert false
1067 HWTEST_F(CryptoX509CrlTest, X509CrlTest145, TestSize.Level0)
1068 {
1069 // Get cert
1070 HcfX509Certificate *x509Cert = nullptr;
1071 HcfEncodingBlob inStreamCert = { 0 };
1072 inStreamCert.data = (uint8_t *)g_testCert;
1073 inStreamCert.encodingFormat = HCF_FORMAT_PEM;
1074 inStreamCert.len = strlen(g_testCert) + 1;
1075 HcfResult ret = HcfX509CertificateCreate(&inStreamCert, &x509Cert);
1076 EXPECT_EQ(ret, HCF_SUCCESS);
1077 EXPECT_NE(x509Cert, nullptr);
1078
1079 // Get crl
1080 HcfX509Crl *x509Crl = nullptr;
1081 HcfEncodingBlob inStreamCrl = { 0 };
1082 inStreamCrl.data = (uint8_t *)g_testCrl;
1083 inStreamCrl.encodingFormat = HCF_FORMAT_PEM;
1084 inStreamCrl.len = strlen(g_testCrl) + 1;
1085 ret = HcfX509CrlCreate(&inStreamCrl, &x509Crl);
1086 EXPECT_EQ(ret, HCF_SUCCESS);
1087 EXPECT_NE(x509Crl, nullptr);
1088
1089 HcfX509CrlEntry *crlEntry = nullptr;
1090 ret = x509Crl->getRevokedCertWithCert(nullptr, x509Cert, &crlEntry);
1091 EXPECT_NE(ret, HCF_SUCCESS);
1092 EXPECT_EQ(crlEntry, nullptr);
1093
1094 HcfObjDestroy(x509Cert);
1095 HcfObjDestroy(x509Crl);
1096 }
1097
1098 // Test crl getRevokedCertWithCert false
1099 HWTEST_F(CryptoX509CrlTest, X509CrlTest146, TestSize.Level0)
1100 {
1101 // Get cert
1102 HcfX509Certificate *x509Cert = nullptr;
1103 HcfEncodingBlob inStreamCert = { 0 };
1104 inStreamCert.data = (uint8_t *)g_testCert;
1105 inStreamCert.encodingFormat = HCF_FORMAT_PEM;
1106 inStreamCert.len = strlen(g_testCert) + 1;
1107 HcfResult ret = HcfX509CertificateCreate(&inStreamCert, &x509Cert);
1108 EXPECT_EQ(ret, HCF_SUCCESS);
1109 EXPECT_NE(x509Cert, nullptr);
1110
1111 // Get crl
1112 HcfX509Crl *x509Crl = nullptr;
1113 HcfEncodingBlob inStreamCrl = { 0 };
1114 inStreamCrl.data = (uint8_t *)g_testCrl;
1115 inStreamCrl.encodingFormat = HCF_FORMAT_PEM;
1116 inStreamCrl.len = strlen(g_testCrl) + 1;
1117 ret = HcfX509CrlCreate(&inStreamCrl, &x509Crl);
1118 EXPECT_EQ(ret, HCF_SUCCESS);
1119 EXPECT_NE(x509Crl, nullptr);
1120
1121 ret = x509Crl->getRevokedCertWithCert(x509Crl, x509Cert, nullptr);
1122 EXPECT_NE(ret, HCF_SUCCESS);
1123
1124 HcfObjDestroy(x509Cert);
1125 HcfObjDestroy(x509Crl);
1126 }
1127
1128 // Test crl getRevokedCertWithCert false
1129 HWTEST_F(CryptoX509CrlTest, X509CrlTest147, TestSize.Level0)
1130 {
1131 // Get cert
1132 HcfX509Certificate *x509Cert = nullptr;
1133 HcfEncodingBlob inStreamCert = { 0 };
1134 inStreamCert.data = (uint8_t *)g_testCert;
1135 inStreamCert.encodingFormat = HCF_FORMAT_PEM;
1136 inStreamCert.len = strlen(g_testCert) + 1;
1137 HcfResult ret = HcfX509CertificateCreate(&inStreamCert, &x509Cert);
1138 EXPECT_EQ(ret, HCF_SUCCESS);
1139 EXPECT_NE(x509Cert, nullptr);
1140
1141 // Get crl
1142 HcfX509Crl *x509Crl = nullptr;
1143 HcfEncodingBlob inStreamCrl = { 0 };
1144 inStreamCrl.data = (uint8_t *)g_testCrl;
1145 inStreamCrl.encodingFormat = HCF_FORMAT_PEM;
1146 inStreamCrl.len = strlen(g_testCrl) + 1;
1147 ret = HcfX509CrlCreate(&inStreamCrl, &x509Crl);
1148 EXPECT_EQ(ret, HCF_SUCCESS);
1149 EXPECT_NE(x509Crl, nullptr);
1150
1151 HcfX509CrlEntry *crlEntry = nullptr;
1152 ret = x509Crl->getRevokedCertWithCert(x509Crl, x509Cert, &crlEntry);
1153 EXPECT_EQ(ret, HCF_SUCCESS);
1154 EXPECT_NE(crlEntry, nullptr);
1155
1156 HcfBlob out = { 0 };
1157 ret = crlEntry->getRevocationDate(nullptr, &out);
1158 EXPECT_NE(ret, HCF_SUCCESS);
1159 EXPECT_EQ(out.data, nullptr);
1160
1161 HcfObjDestroy(x509Cert);
1162 HcfObjDestroy(x509Crl);
1163 HcfObjDestroy(crlEntry);
1164 }
1165
1166 // Test crl entry getRevokedCerts true
1167 HWTEST_F(CryptoX509CrlTest, X509CrlTest151, TestSize.Level0)
1168 {
1169 HcfArray entrysOut = { 0 };
1170 HcfResult ret = g_x509Crl->getRevokedCerts(g_x509Crl, &entrysOut);
1171 EXPECT_EQ(ret, HCF_SUCCESS);
1172 EXPECT_NE(entrysOut.data, nullptr);
1173
1174 HcfX509CrlEntry *crlEntry = reinterpret_cast<HcfX509CrlEntry *>(entrysOut.data[0].data);
1175 HcfBlob out = { 0 };
1176 ret = crlEntry->getRevocationDate(crlEntry, &out);
1177 EXPECT_EQ(ret, HCF_SUCCESS);
1178 EXPECT_NE(out.data, nullptr);
1179 EXPECT_STREQ((char *)g_rvTime->data, (char *)out.data);
1180
1181 HcfFree(out.data);
1182 HcfObjDestroy(crlEntry);
1183 }
1184
1185 // Test crl entry getRevokedCerts false
1186 HWTEST_F(CryptoX509CrlTest, X509CrlTest152, TestSize.Level0)
1187 {
1188 HcfResult ret = g_x509Crl->getRevokedCerts(g_x509Crl, nullptr);
1189 EXPECT_NE(ret, HCF_SUCCESS);
1190 }
1191
1192 // Test crl entry getRevokedCerts false
1193 HWTEST_F(CryptoX509CrlTest, X509CrlTest153, TestSize.Level0)
1194 {
1195 HcfArray entrysOut = { 0 };
1196 HcfResult ret = g_x509Crl->getRevokedCerts(nullptr, &entrysOut);
1197 EXPECT_NE(ret, HCF_SUCCESS);
1198 EXPECT_EQ(entrysOut.data, nullptr);
1199 }
1200
1201 // Test crl entry getRevokedCerts false
1202 HWTEST_F(CryptoX509CrlTest, X509CrlTest154, TestSize.Level0)
1203 {
1204 HcfResult ret = g_x509Crl->getRevokedCerts(nullptr, nullptr);
1205 EXPECT_NE(ret, HCF_SUCCESS);
1206 }
1207
1208 // Test crl getTbsInfo true
1209 HWTEST_F(CryptoX509CrlTest, X509CrlTest161, TestSize.Level0)
1210 {
1211 HcfBlob tbsCertListOut = { 0 };
1212 HcfResult ret = g_x509Crl->getTbsInfo(g_x509Crl, &tbsCertListOut);
1213 EXPECT_EQ(ret, HCF_SUCCESS);
1214 EXPECT_NE(tbsCertListOut.data, nullptr);
1215
1216 EXPECT_STREQ((char *)g_tbs, (char *)tbsCertListOut.data);
1217 HcfFree(tbsCertListOut.data);
1218 }
1219
1220 // Test crl getTbsInfo false
1221 HWTEST_F(CryptoX509CrlTest, X509CrlTest162, TestSize.Level0)
1222 {
1223 HcfBlob tbsCertListOut = { 0 };
1224 HcfResult ret = g_x509Crl->getTbsInfo(nullptr, &tbsCertListOut);
1225 EXPECT_NE(ret, HCF_SUCCESS);
1226 EXPECT_EQ(tbsCertListOut.data, nullptr);
1227 }
1228
1229 // Test crl getTbsInfo false
1230 HWTEST_F(CryptoX509CrlTest, X509CrlTest163, TestSize.Level0)
1231 {
1232 HcfResult ret = g_x509Crl->getTbsInfo(g_x509Crl, nullptr);
1233 EXPECT_NE(ret, HCF_SUCCESS);
1234 }
1235
1236 // Test crl getTbsInfo false
1237 HWTEST_F(CryptoX509CrlTest, X509CrlTest164, TestSize.Level0)
1238 {
1239 HcfResult ret = g_x509Crl->getTbsInfo(nullptr, nullptr);
1240 EXPECT_NE(ret, HCF_SUCCESS);
1241 }
1242
1243 // Test crl getSignature true
1244 HWTEST_F(CryptoX509CrlTest, X509CrlTest171, TestSize.Level0)
1245 {
1246 HcfBlob signature = { 0 };
1247 HcfResult ret = g_x509Crl->getSignature(g_x509Crl, &signature);
1248 EXPECT_EQ(ret, HCF_SUCCESS);
1249 EXPECT_NE(signature.data, nullptr);
1250 bool isEqual = (memcmp(g_signatureStr, signature.data, g_signatureLen) == 0);
1251 EXPECT_EQ(isEqual, true);
1252 HcfFree(signature.data);
1253 }
1254
1255 // Test crl getSignature false
1256 HWTEST_F(CryptoX509CrlTest, X509CrlTest172, TestSize.Level0)
1257 {
1258 HcfBlob signature = { 0 };
1259 HcfResult ret = g_x509Crl->getSignature(nullptr, &signature);
1260 EXPECT_NE(ret, HCF_SUCCESS);
1261 EXPECT_EQ(signature.data, nullptr);
1262 }
1263
1264 // Test crl getSignature false
1265 HWTEST_F(CryptoX509CrlTest, X509CrlTest173, TestSize.Level0)
1266 {
1267 HcfResult ret = g_x509Crl->getSignature(g_x509Crl, nullptr);
1268 EXPECT_NE(ret, HCF_SUCCESS);
1269 }
1270
1271 // Test crl getSignature false
1272 HWTEST_F(CryptoX509CrlTest, X509CrlTest174, TestSize.Level0)
1273 {
1274 HcfResult ret = g_x509Crl->getSignature(nullptr, nullptr);
1275 EXPECT_NE(ret, HCF_SUCCESS);
1276 }
1277
1278 // Test crl getSignatureAlgName true
1279 HWTEST_F(CryptoX509CrlTest, X509CrlTest181, TestSize.Level0)
1280 {
1281 HcfBlob out = { 0 };
1282 HcfResult ret = g_x509Crl->getSignatureAlgName(g_x509Crl, &out);
1283 EXPECT_EQ(ret, HCF_SUCCESS);
1284 EXPECT_NE(out.data, nullptr);
1285 EXPECT_STREQ("MD5withRSA", (char *)out.data);
1286 HcfFree(out.data);
1287 }
1288
1289 // Test crl getSignatureAlgName false
1290 HWTEST_F(CryptoX509CrlTest, X509CrlTest182, TestSize.Level0)
1291 {
1292 HcfBlob out = { 0 };
1293 HcfResult ret = g_x509Crl->getSignatureAlgName(nullptr, &out);
1294 EXPECT_NE(ret, HCF_SUCCESS);
1295 EXPECT_EQ(out.data, nullptr);
1296 }
1297
1298 // Test crl getSignatureAlgName false
1299 HWTEST_F(CryptoX509CrlTest, X509CrlTest183, TestSize.Level0)
1300 {
1301 HcfResult ret = g_x509Crl->getSignatureAlgName(g_x509Crl, nullptr);
1302 EXPECT_NE(ret, HCF_SUCCESS);
1303 }
1304
1305 // Test crl getSignatureAlgName false
1306 HWTEST_F(CryptoX509CrlTest, X509CrlTest184, TestSize.Level0)
1307 {
1308 HcfResult ret = g_x509Crl->getSignatureAlgName(nullptr, nullptr);
1309 EXPECT_NE(ret, HCF_SUCCESS);
1310 }
1311
1312 // Test crl getSignatureAlgOid true
1313 HWTEST_F(CryptoX509CrlTest, X509CrlTest191, TestSize.Level0)
1314 {
1315 HcfBlob out = { 0 };
1316 HcfResult ret = g_x509Crl->getSignatureAlgOid(g_x509Crl, &out);
1317 EXPECT_EQ(ret, HCF_SUCCESS);
1318 EXPECT_NE(out.data, nullptr);
1319 EXPECT_STREQ("1.2.840.113549.1.1.4", (char *)out.data);
1320 HcfFree(out.data);
1321 }
1322
1323 // Test crl getSignatureAlgOid false
1324 HWTEST_F(CryptoX509CrlTest, X509CrlTest192, TestSize.Level0)
1325 {
1326 HcfBlob out = { 0 };
1327 HcfResult ret = g_x509Crl->getSignatureAlgOid(nullptr, &out);
1328 EXPECT_NE(ret, HCF_SUCCESS);
1329 EXPECT_EQ(out.data, nullptr);
1330 }
1331
1332 // Test crl getSignatureAlgOid false
1333 HWTEST_F(CryptoX509CrlTest, X509CrlTest193, TestSize.Level0)
1334 {
1335 HcfResult ret = g_x509Crl->getSignatureAlgOid(g_x509Crl, nullptr);
1336 EXPECT_NE(ret, HCF_SUCCESS);
1337 }
1338
1339 // Test crl getSignatureAlgOid false
1340 HWTEST_F(CryptoX509CrlTest, X509CrlTest194, TestSize.Level0)
1341 {
1342 HcfResult ret = g_x509Crl->getSignatureAlgOid(nullptr, nullptr);
1343 EXPECT_NE(ret, HCF_SUCCESS);
1344 }
1345
1346 // Test crl getSignatureAlgParams true
1347 HWTEST_F(CryptoX509CrlTest, X509CrlTest201, TestSize.Level0)
1348 {
1349 HcfBlob sigAlgParamOut = { 0 };
1350 HcfResult ret = g_x509Crl->getSignatureAlgParams(g_x509Crl, &sigAlgParamOut);
1351 EXPECT_EQ(ret, HCF_SUCCESS);
1352 EXPECT_NE(sigAlgParamOut.data, nullptr);
1353 HcfFree(sigAlgParamOut.data);
1354 }
1355
1356 // Test crl getSignatureAlgParams false
1357 HWTEST_F(CryptoX509CrlTest, X509CrlTest202, TestSize.Level0)
1358 {
1359 HcfBlob sigAlgParamOut = { 0 };
1360 HcfResult ret = g_x509Crl->getSignatureAlgParams(nullptr, &sigAlgParamOut);
1361 EXPECT_NE(ret, HCF_SUCCESS);
1362 EXPECT_EQ(sigAlgParamOut.data, nullptr);
1363 }
1364
1365 // Test crl getSignatureAlgParams false
1366 HWTEST_F(CryptoX509CrlTest, X509CrlTest203, TestSize.Level0)
1367 {
1368 HcfResult ret = g_x509Crl->getSignatureAlgParams(g_x509Crl, nullptr);
1369 EXPECT_NE(ret, HCF_SUCCESS);
1370 }
1371
1372 // Test crl getSignatureAlgParams false
1373 HWTEST_F(CryptoX509CrlTest, X509CrlTest204, TestSize.Level0)
1374 {
1375 HcfResult ret = g_x509Crl->getSignatureAlgParams(nullptr, nullptr);
1376 EXPECT_NE(ret, HCF_SUCCESS);
1377 }
1378
1379 HWTEST_F(CryptoX509CrlTest, NullSpi, TestSize.Level0)
1380 {
1381 (void)HcfCX509CrlSpiCreate(nullptr, nullptr);
1382 (void)HcfCX509CRLEntryCreate(nullptr, nullptr, nullptr);
1383 HcfX509CrlSpi *spiObj = nullptr;
1384 HcfResult ret = HcfCX509CrlSpiCreate(g_crlDerInStream, &spiObj);
1385 EXPECT_EQ(ret, HCF_SUCCESS);
1386 EXPECT_NE(spiObj, nullptr);
1387
1388 (void)spiObj->base.destroy(nullptr);
1389 const char *tmp = spiObj->engineGetType(nullptr);
1390 EXPECT_EQ(tmp, nullptr);
1391 bool flag = spiObj->engineIsRevoked(nullptr, nullptr);
1392 EXPECT_EQ(flag, false);
1393 ret = spiObj->engineGetEncoded(nullptr, nullptr);
1394 EXPECT_NE(ret, HCF_SUCCESS);
1395 ret = spiObj->engineVerify(nullptr, nullptr);
1396 EXPECT_NE(ret, HCF_SUCCESS);
1397 long ver = spiObj->engineGetVersion(nullptr);
1398 EXPECT_EQ(ver, -1);
1399 ret = spiObj->engineGetIssuerName(nullptr, nullptr);
1400 EXPECT_NE(ret, HCF_SUCCESS);
1401 ret = spiObj->engineGetLastUpdate(nullptr, nullptr);
1402 EXPECT_NE(ret, HCF_SUCCESS);
1403 ret = spiObj->engineGetNextUpdate(nullptr, nullptr);
1404 EXPECT_NE(ret, HCF_SUCCESS);
1405 ret = spiObj->engineGetRevokedCert(nullptr, 0, nullptr);
1406 EXPECT_NE(ret, HCF_SUCCESS);
1407 ret = spiObj->engineGetRevokedCertWithCert(nullptr, nullptr, nullptr);
1408 EXPECT_NE(ret, HCF_SUCCESS);
1409 ret = spiObj->engineGetRevokedCerts(nullptr, nullptr);
1410 EXPECT_NE(ret, HCF_SUCCESS);
1411 ret = spiObj->engineGetTbsInfo(nullptr, nullptr);
1412 EXPECT_NE(ret, HCF_SUCCESS);
1413 ret = spiObj->engineGetSignature(nullptr, nullptr);
1414 EXPECT_NE(ret, HCF_SUCCESS);
1415 ret = spiObj->engineGetSignatureAlgName(nullptr, nullptr);
1416 EXPECT_NE(ret, HCF_SUCCESS);
1417 ret = spiObj->engineGetSignatureAlgOid(nullptr, nullptr);
1418 EXPECT_NE(ret, HCF_SUCCESS);
1419 ret = spiObj->engineGetSignatureAlgParams(nullptr, nullptr);
1420 EXPECT_NE(ret, HCF_SUCCESS);
1421
1422 HcfObjDestroy(spiObj);
1423 }
1424
GetInvalidCrlClass(void)1425 static const char *GetInvalidCrlClass(void)
1426 {
1427 return "INVALID_CRL_CLASS";
1428 }
1429
1430 HWTEST_F(CryptoX509CrlTest, InvalidCrlSpiClass, TestSize.Level0)
1431 {
1432 HcfX509CrlSpi invalidSpi = { {0} };
1433 invalidSpi.base.getClass = GetInvalidCrlClass;
1434 HcfBlob invalidOut = { 0 };
1435 HcfEncodingBlob encoding = { 0 };
1436 HcfX509CrlEntry *entry = nullptr;
1437 HcfX509CrlSpi *spiObj = nullptr;
1438 HcfResult ret = HcfCX509CrlSpiCreate(g_crlDerInStream, &spiObj);
1439 (void)spiObj->base.destroy(&(invalidSpi.base));
1440 const char *tmp = spiObj->engineGetType(&invalidSpi);
1441 EXPECT_EQ(tmp, nullptr);
1442 HcfCertificate cert;
1443 bool flag = spiObj->engineIsRevoked(&invalidSpi, &cert);
1444 EXPECT_EQ(flag, false);
1445 ret = spiObj->engineGetEncoded(&invalidSpi, &encoding);
1446 EXPECT_NE(ret, HCF_SUCCESS);
1447 HcfPubKey pubKey;
1448 ret = spiObj->engineVerify(&invalidSpi, &pubKey);
1449 EXPECT_NE(ret, HCF_SUCCESS);
1450 long ver = spiObj->engineGetVersion(&invalidSpi);
1451 EXPECT_EQ(ver, -1);
1452 ret = spiObj->engineGetIssuerName(&invalidSpi, &invalidOut);
1453 EXPECT_NE(ret, HCF_SUCCESS);
1454 ret = spiObj->engineGetLastUpdate(&invalidSpi, &invalidOut);
1455 EXPECT_NE(ret, HCF_SUCCESS);
1456 ret = spiObj->engineGetNextUpdate(&invalidSpi, &invalidOut);
1457 EXPECT_NE(ret, HCF_SUCCESS);
1458 ret = spiObj->engineGetRevokedCert(&invalidSpi, 0, &entry);
1459 EXPECT_NE(ret, HCF_SUCCESS);
1460 HcfX509Certificate x509Cert;
1461 ret = spiObj->engineGetRevokedCertWithCert(&invalidSpi, &x509Cert, &entry);
1462 EXPECT_NE(ret, HCF_SUCCESS);
1463 HcfArray invalidArr = { 0 };
1464 ret = spiObj->engineGetRevokedCerts(&invalidSpi, &invalidArr);
1465 EXPECT_NE(ret, HCF_SUCCESS);
1466 ret = spiObj->engineGetTbsInfo(&invalidSpi, &invalidOut);
1467 EXPECT_NE(ret, HCF_SUCCESS);
1468 ret = spiObj->engineGetSignature(&invalidSpi, &invalidOut);
1469 EXPECT_NE(ret, HCF_SUCCESS);
1470 ret = spiObj->engineGetSignatureAlgName(&invalidSpi, &invalidOut);
1471 EXPECT_NE(ret, HCF_SUCCESS);
1472 ret = spiObj->engineGetSignatureAlgOid(&invalidSpi, &invalidOut);
1473 EXPECT_NE(ret, HCF_SUCCESS);
1474 ret = spiObj->engineGetSignatureAlgParams(&invalidSpi, &invalidOut);
1475 EXPECT_NE(ret, HCF_SUCCESS);
1476 HcfObjDestroy(spiObj);
1477 }
1478
1479 HWTEST_F(CryptoX509CrlTest, InvalidCrlClass, TestSize.Level0)
1480 {
1481 HcfX509Crl invalidCrl;
1482 invalidCrl.base.base.getClass = GetInvalidCrlClass;
1483 HcfBlob invalidOut = { 0 };
1484 HcfEncodingBlob encoding = { 0 };
1485 HcfX509CrlEntry *entry = nullptr;
1486
1487 g_x509Crl->base.base.destroy(nullptr);
1488 g_x509Crl->base.base.destroy(&(invalidCrl.base.base));
1489 const char *tmp = g_x509Crl->base.getType(&(invalidCrl.base));
1490 EXPECT_EQ(tmp, nullptr);
1491 HcfCertificate cert;
1492 bool flag = g_x509Crl->base.isRevoked(&(invalidCrl.base), &cert);
1493 EXPECT_EQ(flag, false);
1494 HcfResult ret = g_x509Crl->getEncoded(&invalidCrl, &encoding);
1495 EXPECT_NE(ret, HCF_SUCCESS);
1496 HcfPubKey pubKey;
1497 ret = g_x509Crl->verify(&invalidCrl, &pubKey);
1498 EXPECT_NE(ret, HCF_SUCCESS);
1499 long ver = g_x509Crl->getVersion(&invalidCrl);
1500 EXPECT_EQ(ver, -1);
1501 ret = g_x509Crl->getIssuerName(&invalidCrl, &invalidOut);
1502 EXPECT_NE(ret, HCF_SUCCESS);
1503 ret = g_x509Crl->getLastUpdate(&invalidCrl, &invalidOut);
1504 EXPECT_NE(ret, HCF_SUCCESS);
1505 ret = g_x509Crl->getNextUpdate(&invalidCrl, &invalidOut);
1506 EXPECT_NE(ret, HCF_SUCCESS);
1507 ret = g_x509Crl->getRevokedCert(&invalidCrl, 0, &entry);
1508 EXPECT_NE(ret, HCF_SUCCESS);
1509 HcfX509Certificate x509Cert;
1510 ret = g_x509Crl->getRevokedCertWithCert(&invalidCrl, &x509Cert, &entry);
1511 EXPECT_NE(ret, HCF_SUCCESS);
1512 HcfArray invalidArr = { 0 };
1513 ret = g_x509Crl->getRevokedCerts(&invalidCrl, &invalidArr);
1514 EXPECT_NE(ret, HCF_SUCCESS);
1515 ret = g_x509Crl->getTbsInfo(&invalidCrl, &invalidOut);
1516 EXPECT_NE(ret, HCF_SUCCESS);
1517 ret = g_x509Crl->getSignature(&invalidCrl, &invalidOut);
1518 EXPECT_NE(ret, HCF_SUCCESS);
1519 ret = g_x509Crl->getSignatureAlgName(&invalidCrl, &invalidOut);
1520 EXPECT_NE(ret, HCF_SUCCESS);
1521 ret = g_x509Crl->getSignatureAlgOid(&invalidCrl, &invalidOut);
1522 EXPECT_NE(ret, HCF_SUCCESS);
1523 ret = g_x509Crl->getSignatureAlgParams(&invalidCrl, &invalidOut);
1524 EXPECT_NE(ret, HCF_SUCCESS);
1525 }
1526
1527 HWTEST_F(CryptoX509CrlTest, InvalidMalloc, TestSize.Level0)
1528 {
1529 SetMockFlag(true);
1530 HcfBlob out = { 0 };
1531 HcfEncodingBlob encoding = { 0 };
1532 HcfX509CrlEntry *entry = nullptr;
1533 HcfResult ret = g_x509Crl->getEncoded(g_x509Crl, &encoding);
1534 EXPECT_NE(ret, HCF_SUCCESS);
1535 ret = g_x509Crl->getIssuerName(g_x509Crl, &out);
1536 EXPECT_NE(ret, HCF_SUCCESS);
1537 ret = g_x509Crl->getLastUpdate(g_x509Crl, &out);
1538 EXPECT_NE(ret, HCF_SUCCESS);
1539 ret = g_x509Crl->getNextUpdate(g_x509Crl, &out);
1540 EXPECT_NE(ret, HCF_SUCCESS);
1541 ret = g_x509Crl->getRevokedCert(g_x509Crl, 0, &entry);
1542 EXPECT_NE(ret, HCF_SUCCESS);
1543 HcfArray arr = { 0 };
1544 ret = g_x509Crl->getRevokedCerts(g_x509Crl, &arr);
1545 EXPECT_NE(ret, HCF_SUCCESS);
1546 ret = g_x509Crl->getTbsInfo(g_x509Crl, &out);
1547 EXPECT_NE(ret, HCF_SUCCESS);
1548 ret = g_x509Crl->getSignature(g_x509Crl, &out);
1549 EXPECT_NE(ret, HCF_SUCCESS);
1550 ret = g_x509Crl->getSignatureAlgName(g_x509Crl, &out);
1551 EXPECT_NE(ret, HCF_SUCCESS);
1552 ret = g_x509Crl->getSignatureAlgOid(g_x509Crl, &out);
1553 EXPECT_NE(ret, HCF_SUCCESS);
1554 ret = g_x509Crl->getSignatureAlgParams(g_x509Crl, &out);
1555 EXPECT_NE(ret, HCF_SUCCESS);
1556 SetMockFlag(false);
1557 }
1558 }