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 "x509crl_fuzzer.h"
17 
18 #include <openssl/x509.h>
19 
20 #include "asy_key_generator.h"
21 #include "certificate_openssl_class.h"
22 #include "crypto_x509_test_common.h"
23 #include "cf_log.h"
24 #include "cf_blob.h"
25 #include "cf_memory.h"
26 #include "cf_result.h"
27 #include "cipher.h"
28 #include "key_pair.h"
29 #include "securec.h"
30 #include "x509_certificate.h"
31 #include "x509_crl.h"
32 #include "x509_crl_entry.h"
33 #include "cert_crl_collection.h"
34 
35 namespace OHOS {
36     constexpr int TEST_VERSION = 3;
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     HcfKeyPair *g_keyPair = nullptr;
44     ASN1_TIME *g_lastUpdate = nullptr;
45     ASN1_TIME *g_nextUpdate = nullptr;
46     ASN1_TIME *g_rvTime = nullptr;
47     static bool g_testFlag = true;
48 
49     static char g_testCrl[] =
50     "-----BEGIN X509 CRL-----\r\n"
51     "MIIB4zCBzAIBATANBgkqhkiG9w0BAQsFADAsMQswCQYDVQQGEwJDTjENMAsGA1UE\r\n"
52     "CgwEdGVzdDEOMAwGA1UEAwwFc3ViY2EXDTIzMDkxMjA2NDc1MFoXDTIzMTAxMjA2\r\n"
53     "NDc1MFowOzATAgID6BcNMjMwOTEyMDY0NzQ5WjAkAhMXXWqf7KkJ1xKySFKmPkj2\r\n"
54     "EpOpFw0yMzA5MTIwNjQyNTRaoC8wLTAfBgNVHSMEGDAWgBQiKxjehNkwTvY939f0\r\n"
55     "Au1EIoQg6DAKBgNVHRQEAwIBAjANBgkqhkiG9w0BAQsFAAOCAQEAQKGCXs5aXY56\r\n"
56     "06A/0HynLmq+frJ7p5Uj9cD2vwbZV4xaP2E5jXogBz7YCjmxp0PB995XC9oi3QKQ\r\n"
57     "gLVKY4Nz21WQRecmmZm1cDweDDPwGJ8/I0d2CwMTJfP7rEgsuhgIBq+JUjFcNNaW\r\n"
58     "dia2Gu/aAuIjlaJ5A4W7vvhGVUx9CDUdN8YF5knA3BoQ1uFc1z7gNckkIpTTccQL\r\n"
59     "zoELFDG8/z+bOnAuSg1lZCyv9fOz9lVafC+qaHo+NW9rdChxV1oC5S6jHTu879CO\r\n"
60     "MQnLr3jEBCszNzDjFI64l6f3JVnLZepp6NU1gdunjQL4gtWQXZFlFV75xR8aahd8\r\n"
61     "seB5oDTPQg==\r\n"
62     "-----END X509 CRL-----\r\n";
63 
64     static char g_testCert[] =
65     "-----BEGIN CERTIFICATE-----\r\n"
66     "MIIDTzCCAjegAwIBAgICA+gwDQYJKoZIhvcNAQELBQAwLDELMAkGA1UEBhMCQ04x\r\n"
67     "DTALBgNVBAoMBHRlc3QxDjAMBgNVBAMMBXN1YmNhMB4XDTIzMDkxMjA2NDc0OVoX\r\n"
68     "DTMzMDkwOTA2NDc0OVowLDELMAkGA1UEBhMCQ04xDTALBgNVBAoMBHRlc3QxDjAM\r\n"
69     "BgNVBAMMBWxvY2FsMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuEcw\r\n"
70     "tv/K2MnMB+AX2oL2KsTMjKteaQncpr6BPfe/LvSXQImnETvzSSIX2Iy19ZEbEDxn\r\n"
71     "osFXGvmrE8iT1P8lP+LYC8WIjzArbQeBvM6n8gq7QW2jAlfAmVy2/SBeBhRFT1Eq\r\n"
72     "rwqld6qqGa0WTnRTnax7v52FddvpG9XBAexE2gQ6UyScWikAKuDgnSQsivz6SMTQ\r\n"
73     "vbax3ffiy2p2RjxH9ZrQTxpUFDRHqMxJvq57wBDLkAtG4TlhQMDIB86cbOQfHHam\r\n"
74     "VHPVSvyZgmr3V4kb9UlDwB9bjrjSMlRsnNqocGEepZQ57IKgLf5SCWRec5Oww+OO\r\n"
75     "3WJOa7ja10sZ0LDdxwIDAQABo3sweTAJBgNVHRMEAjAAMCwGCWCGSAGG+EIBDQQf\r\n"
76     "Fh1PcGVuU1NMIEdlbmVyYXRlZCBDZXJ0aWZpY2F0ZTAdBgNVHQ4EFgQURsHdrG4w\r\n"
77     "i4GQKaFbmEpdNyNkvB4wHwYDVR0jBBgwFoAUIisY3oTZME72Pd/X9ALtRCKEIOgw\r\n"
78     "DQYJKoZIhvcNAQELBQADggEBAKVdgTE4Q8Nl5nQUQVL/uZMVCmDRcpXdJHq3cyAH\r\n"
79     "4BtbFW/K3MbVcZl2j1tPl6bgI5pn9Tk4kkc+SfxGUKAPR7FQ01zfgEJipSlsmAxS\r\n"
80     "wOZL+PGUbYUL1jzU8207PZOIZcyD67Sj8LeOV4BCNLiBIo++MjpD++x77GnP3veg\r\n"
81     "bDKHfDSVILdH/qnqyGSAGJ4YGJld00tehnTAqBWzmkXVIgWk0bnPTNE0dn5Tj7ZY\r\n"
82     "7zh6YU5JILHnrkjRGdNGmpz8SXJ+bh7u8ffHc4R9FO1q4c9/1YSsOXQj0KazyDIP\r\n"
83     "IArlydFj8wK8sHvYC9WhPs+hiirrRb9Y2ApFzcYX5aYn46Y=\r\n"
84     "-----END CERTIFICATE-----\r\n";
85     const CfEncodingBlob g_crlDerInStream = { const_cast<uint8_t *>(g_crlDerData),
86         sizeof(g_crlDerData), CF_FORMAT_DER };
87 
FreeCrlData()88     static void FreeCrlData()
89     {
90         if (g_keyPair != nullptr) {
91             CfObjDestroy(g_keyPair);
92             g_keyPair = nullptr;
93         }
94         if (g_lastUpdate != nullptr) {
95             ASN1_TIME_free(g_lastUpdate);
96             g_lastUpdate = nullptr;
97         }
98         if (g_nextUpdate != nullptr) {
99             ASN1_TIME_free(g_nextUpdate);
100             g_nextUpdate = nullptr;
101         }
102         if (g_rvTime != nullptr) {
103             ASN1_TIME_free(g_rvTime);
104             g_rvTime = nullptr;
105         }
106     }
107 
GetCrlStream()108     static unsigned char *GetCrlStream()
109     {
110         unsigned char *buf = nullptr;
111         unsigned char *p = nullptr;
112         HcfAsyKeyGenerator *generator = nullptr;
113         HcfAsyKeyGeneratorCreate("RSA1024|PRIMES_3", &generator);
114         generator->generateKeyPair(generator, nullptr, &g_keyPair);
115         RSA *rsaPrikey = (reinterpret_cast<HcfOpensslRsaPriKey *>(g_keyPair->priKey))->sk;
116         EVP_PKEY *prikey = EVP_PKEY_new();
117         EVP_PKEY_assign_RSA(prikey, rsaPrikey);
118 
119         X509_CRL *crl = X509_CRL_new();
120         (void)X509_CRL_set_version(crl, TEST_VERSION);
121 
122         // Set Issuer
123         X509_NAME *issuer = X509_NAME_new();
124         const char *tmp = "CRL issuer";
125         (void)X509_NAME_add_entry_by_NID(issuer, NID_commonName, V_ASN1_PRINTABLESTRING,
126             reinterpret_cast<const unsigned char *>(tmp), 10, -1, 0);
127         (void)X509_CRL_set_issuer_name(crl, issuer);
128 
129         g_lastUpdate = ASN1_TIME_new();
130         time_t t = time(nullptr);
131         ASN1_TIME_set(g_lastUpdate, t + TEST_OFFSET_TIME);
132         (void)X509_CRL_set_lastUpdate(crl, g_lastUpdate);
133 
134         g_nextUpdate = ASN1_TIME_new();
135         t = TEST_TIME;
136         ASN1_TIME_set(g_nextUpdate, t);
137         (void)X509_CRL_set_nextUpdate(crl, g_nextUpdate);
138 
139         X509_REVOKED *revoked = X509_REVOKED_new();
140         ASN1_INTEGER *serial = ASN1_INTEGER_new();
141         (void)ASN1_INTEGER_set(serial, TEST_SN);
142         (void)X509_REVOKED_set_serialNumber(revoked, serial);
143 
144         g_rvTime = ASN1_TIME_new();
145         t = TEST_TIME;
146         ASN1_TIME_set(g_rvTime, t);
147         (void)X509_CRL_set_nextUpdate(crl, g_rvTime);
148         (void)X509_REVOKED_set_revocationDate(revoked, g_rvTime);
149         (void)X509_CRL_add0_revoked(crl, revoked);
150 
151         (void)X509_CRL_sort(crl);
152         (void)X509_CRL_sign(crl, prikey, EVP_sha256());
153         int len = i2d_X509_CRL(crl, nullptr);
154         buf = reinterpret_cast<unsigned char *>(malloc(len + TEST_OFFSET));
155         p = buf;
156         (void)i2d_X509_CRL(crl, &p);
157         return buf;
158     }
159 
TestX509CrlPemName(HcfX509Crl * x509CrlPem)160     static void TestX509CrlPemName(HcfX509Crl *x509CrlPem)
161     {
162         CfBlob toStringBlob = { 0 };
163         (void)x509CrlPem->toString(x509CrlPem, &toStringBlob);
164         CfBlobDataClearAndFree(&toStringBlob);
165 
166         CfBlob hashCodeBlob = { 0 };
167         (void)x509CrlPem->hashCode(x509CrlPem, &hashCodeBlob);
168         CfBlobDataClearAndFree(&hashCodeBlob);
169 
170         CfBlob extensionsObjectBlob = { 0 };
171         (void)x509CrlPem->getExtensionsObject(x509CrlPem, &extensionsObjectBlob);
172         CfBlobDataClearAndFree(&extensionsObjectBlob);
173     }
174 
TestX509CrlPem(HcfX509Crl * x509CrlPem)175     static void TestX509CrlPem(HcfX509Crl *x509CrlPem)
176     {
177         CfEncodingBlob encodingBlob = { 0 };
178         (void)x509CrlPem->getEncoded(x509CrlPem, &encodingBlob);
179         if (encodingBlob.data != nullptr) {
180             CfFree(encodingBlob.data);
181         }
182         CfBlob issuerName = { 0 };
183         (void)x509CrlPem->getIssuerName(x509CrlPem, &issuerName);
184         if (issuerName.data != nullptr) {
185             CfFree(issuerName.data);
186         }
187         CfBlob lastUpdate = { 0 };
188         (void)x509CrlPem->getLastUpdate(x509CrlPem, &lastUpdate);
189         if (lastUpdate.data != nullptr) {
190             CfFree(lastUpdate.data);
191         }
192         CfBlob nextUpdate = { 0 };
193         (void)x509CrlPem->getNextUpdate(x509CrlPem, &nextUpdate);
194         if (nextUpdate.data != nullptr) {
195             CfFree(nextUpdate.data);
196         }
197         (void)x509CrlPem->base.getType(&(x509CrlPem->base));
198         TestX509CrlPemName(x509CrlPem);
199         HcfX509Certificate *x509Cert = nullptr;
200         CfEncodingBlob inStreamCert = { 0 };
201         inStreamCert.data = reinterpret_cast<uint8_t *>(g_testCert);
202         inStreamCert.encodingFormat = CF_FORMAT_PEM;
203         inStreamCert.len = strlen(g_testCert) + 1;
204         CfResult result = HcfX509CertificateCreate(&inStreamCert, &x509Cert);
205         if (result != CF_SUCCESS) {
206             return;
207         }
208         HcfX509CrlEntry *crlEntry = nullptr;
209         x509CrlPem->getRevokedCertWithCert(x509CrlPem, x509Cert, &crlEntry);
210         if (crlEntry != nullptr) {
211             CfObjDestroy(crlEntry);
212         }
213         (void)x509CrlPem->base.isRevoked(&(x509CrlPem->base), &(x509Cert->base));
214         CfObjDestroy(x509Cert);
215     }
216 
TestX509CrlEntryName(HcfX509CrlEntry * entry)217     static void TestX509CrlEntryName(HcfX509CrlEntry *entry)
218     {
219         CfBlob toStringBlob = { 0 };
220         entry->toString(entry, &toStringBlob);
221         CfBlobDataClearAndFree(&toStringBlob);
222 
223         CfBlob hashCodeBlob = { 0 };
224         entry->hashCode(entry, &hashCodeBlob);
225         CfBlobDataClearAndFree(&hashCodeBlob);
226 
227         CfBlob extensionsObjectBlob = { 0 };
228         entry->getExtensionsObject(entry, &extensionsObjectBlob);
229         CfBlobDataClearAndFree(&extensionsObjectBlob);
230     }
231 
TestX509CrlEntry(HcfX509Crl * x509CrlDer,const uint8_t * data,size_t size)232     static void TestX509CrlEntry(HcfX509Crl *x509CrlDer, const uint8_t *data, size_t size)
233     {
234         long serialNumber = 1000;
235 		CfBlob serialBlob = { sizeof(long), reinterpret_cast<uint8_t *>(&serialNumber) };
236         HcfX509CrlEntry *entry = nullptr;
237         x509CrlDer->getRevokedCert(x509CrlDer, &serialBlob, &entry);
238         if (entry != nullptr) {
239             CfEncodingBlob entryEncoded = { 0 };
240             entry->getEncoded(entry, &entryEncoded);
241             if (entryEncoded.data != nullptr) {
242                 CfFree(entryEncoded.data);
243             }
244             CfBlob certIssuer = { 0 };
245             entry->getCertIssuer(entry, &certIssuer);
246             if (certIssuer.data != nullptr) {
247                 CfFree(certIssuer.data);
248             }
249             CfBlob revocationDate = { 0 };
250             entry->getRevocationDate(entry, &revocationDate);
251             if (revocationDate.data != nullptr) {
252                 CfFree(revocationDate.data);
253             }
254             CfBlob snBlob = { 0 };
255             entry->getSerialNumber(entry, &snBlob);
256             if (snBlob.data != nullptr) {
257                 CfFree(snBlob.data);
258             }
259 
260             TestX509CrlEntryName(entry);
261             CfObjDestroy(entry);
262         }
263         if (size >= sizeof(long)) {
264             entry = nullptr;
265             serialBlob.size = sizeof(long);
266             serialBlob.data = const_cast<uint8_t *>(data);
267             x509CrlDer->getRevokedCert(x509CrlDer, &serialBlob, &entry);
268             if (entry != nullptr) {
269                 CfObjDestroy(entry);
270             }
271         }
272     }
273 
TestX509CrlDer(HcfX509Crl * x509CrlDer)274     static void TestX509CrlDer(HcfX509Crl *x509CrlDer)
275     {
276         CfArray entrys = { 0 };
277         x509CrlDer->getRevokedCerts(x509CrlDer, &entrys);
278         if (entrys.data != nullptr) {
279             HcfX509CrlEntry *crlEntry = reinterpret_cast<HcfX509CrlEntry *>(entrys.data[0].data);
280             CfObjDestroy(crlEntry);
281         }
282 
283         CfBlob signature = { 0 };
284         x509CrlDer->getSignature(x509CrlDer, &signature);
285         if (signature.data != nullptr) {
286             CfFree(signature.data);
287         }
288         CfBlob signatureAlgName = { 0 };
289         x509CrlDer->getSignatureAlgName(x509CrlDer, &signatureAlgName);
290         if (signatureAlgName.data != nullptr) {
291             CfFree(signatureAlgName.data);
292         }
293         CfBlob signatureAlgOid = { 0 };
294         x509CrlDer->getSignatureAlgOid(x509CrlDer, &signatureAlgOid);
295         if (signatureAlgOid.data != nullptr) {
296             CfFree(signatureAlgOid.data);
297         }
298         CfBlob signatureAlgParams = { 0 };
299         x509CrlDer->getSignatureAlgParams(x509CrlDer, &signatureAlgParams);
300         if (signatureAlgParams.data != nullptr) {
301             CfFree(signatureAlgParams.data);
302         }
303         CfBlob tbsInfo = { 0 };
304         x509CrlDer->getTbsInfo(x509CrlDer, &tbsInfo);
305         if (tbsInfo.data != nullptr) {
306             CfFree(tbsInfo.data);
307         }
308         (void)x509CrlDer->getVersion(x509CrlDer);
309         (void)x509CrlDer->verify(x509CrlDer, g_keyPair->pubKey);
310     }
311 
FuzzDoX509CrlTest(const uint8_t * data,size_t size)312     bool FuzzDoX509CrlTest(const uint8_t *data, size_t size)
313     {
314         HcfX509Crl *x509CrlDer = nullptr;
315         CfEncodingBlob crlDerInStream = { 0 };
316         unsigned char *crlStream = GetCrlStream();
317         crlDerInStream.data = reinterpret_cast<uint8_t *>(crlStream);
318         crlDerInStream.encodingFormat = CF_FORMAT_DER;
319         crlDerInStream.len = TEST_CRL_LEN;
320         CfResult result = HcfX509CrlCreate(&crlDerInStream, &x509CrlDer);
321         CfFree(crlStream);
322         if (result != CF_SUCCESS) {
323             FreeCrlData();
324             return false;
325         }
326         CfEncodingBlob crlPemInStream = { 0 };
327         crlPemInStream.data = reinterpret_cast<uint8_t *>(g_testCrl);
328         crlPemInStream.encodingFormat = CF_FORMAT_PEM;
329         crlPemInStream.len = strlen(g_testCrl) + 1;
330         HcfX509Crl *x509CrlPem = nullptr;
331         result = HcfX509CrlCreate(&crlPemInStream, &x509CrlPem);
332         if (result != CF_SUCCESS) {
333             FreeCrlData();
334             CfObjDestroy(x509CrlDer);
335             return false;
336         }
337         TestX509CrlPem(x509CrlPem);
338         CfObjDestroy(x509CrlPem);
339 
340         TestX509CrlEntry(x509CrlDer, data, size);
341         TestX509CrlDer(x509CrlDer);
342         FreeCrlData();
343         CfObjDestroy(x509CrlDer);
344 
345         HcfX509Crl *x509Crl = nullptr;
346         CfEncodingBlob crlInStream = { 0 };
347         crlInStream.data = const_cast<uint8_t *>(data);
348         crlInStream.encodingFormat = CF_FORMAT_PEM;
349         crlInStream.len = size;
350         result = HcfX509CrlCreate(&crlInStream, &x509Crl);
351         if (result == CF_SUCCESS) {
352             CfObjDestroy(x509Crl);
353         }
354         return true;
355     }
OneCrlCollectionTest()356     void OneCrlCollectionTest()
357     {
358         CfEncodingBlob inStream = { 0 };
359         HcfX509Crl *x509Crl = nullptr;
360         HcfCertCrlCollection *x509CertCrlCollection = nullptr;
361         HcfX509Certificate *x509CertObj = nullptr;
362         HcfX509CertificateArray certArray = { 0 };
363         HcfX509CrlArray crlArray = { 0 };
364         inStream.data = reinterpret_cast<uint8_t *>(const_cast<char *>(g_testSelfSignedCaCert));
365         inStream.encodingFormat = CF_FORMAT_PEM;
366         inStream.len = strlen(g_testSelfSignedCaCert) + 1;
367         CfResult ret = HcfX509CertificateCreate(&inStream, &x509CertObj);
368         if (ret != CF_SUCCESS || x509CertObj == nullptr) {
369             goto Exit;
370         }
371         ret = HcfX509CrlCreate(&g_crlDerInStream, &x509Crl);
372         if (ret != CF_SUCCESS || x509Crl == nullptr) {
373             goto Exit;
374         }
375         certArray.data = static_cast<HcfX509Certificate **>(CfMalloc(1 * sizeof(HcfX509Certificate *), 0));
376         if (certArray.data == nullptr) {
377             goto Exit;
378         }
379         certArray.data[0] = x509CertObj;
380         certArray.count = 1;
381 
382         crlArray.data = static_cast<HcfX509Crl **>(CfMalloc(1 * sizeof(HcfX509Crl *), 0));
383         if (crlArray.data == nullptr) {
384             goto Exit;
385         }
386         crlArray.data[0] = x509Crl;
387         crlArray.count = 1;
388 
389         ret = HcfCertCrlCollectionCreate(&certArray, &crlArray, &x509CertCrlCollection);
390         if (ret != CF_SUCCESS || x509CertCrlCollection == nullptr) {
391             goto Exit;
392         }
393 
394     Exit:
395         CfObjDestroy(x509CertObj);
396         CfObjDestroy(x509Crl);
397         CfFree(crlArray.data);
398         CfFree(certArray.data);
399         CfObjDestroy(x509CertCrlCollection);
400     }
401 
FuzzDoX509CrlCollectionTest(const uint8_t * data,size_t size,CfEncodingFormat format)402     void FuzzDoX509CrlCollectionTest(const uint8_t *data, size_t size, CfEncodingFormat format)
403     {
404         if (g_testFlag) {
405             OneCrlCollectionTest();
406             g_testFlag = false;
407         }
408 
409         if (data == nullptr || size < sizeof(HcfX509Certificate) || size < sizeof(HcfX509Crl)) {
410             return;
411         }
412 
413         HcfX509CertificateArray certArray = { 0 };
414         HcfX509CrlArray crlArray = { 0 };
415         HcfCertCrlCollection *x509CertCrlCollection = nullptr;
416         HcfX509Crl *x509Crl = nullptr;
417         HcfX509Certificate *x509CertObj = nullptr;
418 
419         const CfEncodingBlob inStream = { reinterpret_cast<uint8_t *>(const_cast<char *>(g_testSelfSignedCaCert)),
420             sizeof(g_testSelfSignedCaCert) + 1, CF_FORMAT_DER };
421         CfResult ret = HcfX509CertificateCreate(&inStream, &x509CertObj);
422         if (ret != CF_SUCCESS || x509CertObj == nullptr) {
423             return;
424         }
425 
426         const CfEncodingBlob crlDerInStream = { const_cast<uint8_t *>(data), size, CF_FORMAT_DER };
427         ret = HcfX509CrlCreate(&crlDerInStream, &x509Crl);
428         if (ret != CF_SUCCESS || x509Crl == nullptr) {
429             return;
430         }
431         certArray.data = static_cast<HcfX509Certificate **>(CfMalloc(1 * sizeof(HcfX509Certificate *), 0));
432         if (certArray.data == nullptr) {
433             return;
434         }
435         certArray.data[0] = x509CertObj;
436         certArray.count = 1;
437 
438         crlArray.data = static_cast<HcfX509Crl **>(CfMalloc(1 * sizeof(HcfX509Crl *), 0));
439         if (crlArray.data == nullptr) {
440             CfFree(certArray.data);
441             return;
442         }
443         crlArray.data[0] = x509Crl;
444         crlArray.count = 1;
445 
446         ret = HcfCertCrlCollectionCreate(&certArray, &crlArray, &x509CertCrlCollection);
447         if (ret != CF_SUCCESS || x509CertCrlCollection == nullptr) {
448             CfFree(certArray.data);
449             CfFree(crlArray.data);
450             return;
451         }
452 
453         CfFree(certArray.data);
454         CfFree(crlArray.data);
455         CfObjDestroy(x509CertCrlCollection);
456         return;
457     }
458 }
459 
460 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)461 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
462 {
463     /* Run your code on data */
464     OHOS::FuzzDoX509CrlTest(data, size);
465     OHOS::FuzzDoX509CrlCollectionTest(data, size, CF_FORMAT_DER);
466     OHOS::FuzzDoX509CrlCollectionTest(data, size, CF_FORMAT_PEM);
467     OHOS::FuzzDoX509CrlCollectionTest(data, size, CF_FORMAT_PKCS7);
468     return 0;
469 }
470