From 060ade8600c34739aea91246a43c526f96568310 Mon Sep 17 00:00:00 2001 From: Arthur Chan Date: Mon, 16 Nov 2026 10:23:16 +0000 Subject: [PATCH] OSS-Fuzz: Add new fuzzer/corpus targets x509 crl processing Signed-off-by: Arthur Chan --- .../config/xmlsec_x509crl_fuzzer.dict | 9 + .../config/xmlsec_x509crl_fuzzer.options | 3 + .../corpus/xmlsec_x509crl/der-trusted.seed | Bin 0 -> 1883 bytes .../corpus/xmlsec_x509crl/der-untrusted.seed | Bin 0 -> 1883 bytes .../corpus/xmlsec_x509crl/pem-trusted.seed | Bin 0 -> 2657 bytes .../corpus/xmlsec_x509crl/pem-untrusted.seed | 44 ++++ apps/oss-fuzz/xmlsec_x509crl_target.c | 199 ++++++++++++++++++ 7 files changed, 255 insertions(+) create mode 100644 apps/oss-fuzz/config/xmlsec_x509crl_fuzzer.dict create mode 100644 apps/oss-fuzz/config/xmlsec_x509crl_fuzzer.options create mode 100644 apps/oss-fuzz/corpus/xmlsec_x509crl/der-trusted.seed create mode 100644 apps/oss-fuzz/corpus/xmlsec_x509crl/der-untrusted.seed create mode 100644 apps/oss-fuzz/corpus/xmlsec_x509crl/pem-trusted.seed create mode 100644 apps/oss-fuzz/corpus/xmlsec_x509crl/pem-untrusted.seed create mode 100644 apps/oss-fuzz/xmlsec_x509crl_target.c diff --git a/apps/oss-fuzz/config/xmlsec_x509crl_fuzzer.dict b/apps/oss-fuzz/config/xmlsec_x509crl_fuzzer.dict new file mode 100644 index 000000000..7f9bdb2c1 --- /dev/null +++ b/apps/oss-fuzz/config/xmlsec_x509crl_fuzzer.dict @@ -0,0 +1,9 @@ +# PEM armor names (OpenSSL PEM_read_bio_* headers). DER structure cannot be +# mutated into existence, so seeds carry it; these tokens only help the PEM +# path. All multi-byte and traceable to OpenSSL PEM names. +"-----BEGIN CERTIFICATE-----" +"-----END CERTIFICATE-----" +"-----BEGIN X509 CRL-----" +"-----END X509 CRL-----" +"-----BEGIN TRUSTED CERTIFICATE-----" +"-----END TRUSTED CERTIFICATE-----" diff --git a/apps/oss-fuzz/config/xmlsec_x509crl_fuzzer.options b/apps/oss-fuzz/config/xmlsec_x509crl_fuzzer.options new file mode 100644 index 000000000..fb9f90927 --- /dev/null +++ b/apps/oss-fuzz/config/xmlsec_x509crl_fuzzer.options @@ -0,0 +1,3 @@ +[libfuzzer] +dict = xmlsec_x509crl_fuzzer.dict +max_len = 65536 diff --git a/apps/oss-fuzz/corpus/xmlsec_x509crl/der-trusted.seed b/apps/oss-fuzz/corpus/xmlsec_x509crl/der-trusted.seed new file mode 100644 index 0000000000000000000000000000000000000000..d1df9939e0a58dc74bec3b540c8b9a93d8d508da GIT binary patch literal 1883 zcmZQ%vNLF66*FjJ{d#AN85K^ zMn-N{27|_JhTI06Y|No7Y{E>T!G^*Hf*=luFqd;;PG(wuQC?=Ep{;>6NRUg|B*NE6 zAviU;v?#NrQo$!PsVK3iQb8l5q@=(~U%$M(TrV*vHM=;qQZG3_SHB`Rr#LlP(@?@d z45Xb~m>;M$KQBcgC$%g!N5R?AP|QFCB*QGs>j=@O5S*BonP;eIAP;vYC!?4U#3TnK z!wnR~d5z2rj14S|j0{Z-&7vgujSPVTKmsaYP)mECNf}5$+%FiCT3n*wom#0-RGg@5 zWME=p(8Q>O9N3Jk49rc8{0u;GE~X|%MuvN;=`E&D8#1Qtjh%lx?2vu4L#3s`qNnT4 zFYSG(92f3ec<%N2=ERBluZ+e0Z{+eT_itscdZbXWi*b$qV~^9B@0c=QTYO(o5&nI1 zWZ1tTR?kL@Dbei5=btWH>G$P*RLn^y;T@5o2VJa|F}u6TdK+r3d2FeEtYp?fA7+ zZ2f{~-9o7w@5^U3{de4dVA0ZOBg2c$j~x}V{v3O~sNGAKiJ6gsad8u405C*+40wRy zC@ajuYQW6M_}@T>jWeOmgR$+06C*E+yqK(iL26!bu#bX!YF=tlVo7R>f^%w7NoHDR zGLT~+3)0KSBE}+;dw9C}&o^Q5Y*|;L3s#-aH)72pI5zk_@*ndr*FU31yj}30oHTM^1IX zEDlU{j0`^9`=svHXz?;dpA`NTU$*f#@2N9Ef1h#kSM;9p-m<{&TVLwb4X-bKo8itA zt93a#|D!fXpO)1|7x9JsO+OnBC|B4T&sb(Yv*N1ZO!1hB-X1%{o=YyP>?zFljqplQ zy_d$mvLaOAl;Wz3-lclX>1wIB<6UlxGZpUMp!BGdq4Hp2iRAWO3)sFSzX);3JACWs z2`0@&x5C-=7@EI6y)F5fx8<6;`HN_uYk7yhom4RG(R&vfHF<7jeZ#RlpP0UFLE|$VzL6|NG3)`wBQ-CB_O2yGc*N4Geh$zFxLcF6hgQL>ISOV zYXG!za{-?Lj{z4bhlsEMs|{wf-~p!|=jxv+TyA;%hUs}8hpLy}TCaXa`NfbYESzhy44^yz~F&Uzgv+qQmk!{MZdeY5x(uh&x(W%)ba~JmsES1^zd&8{16}3vY#aGnZpHglKVB!D(-i59G literal 0 HcmV?d00001 diff --git a/apps/oss-fuzz/corpus/xmlsec_x509crl/der-untrusted.seed b/apps/oss-fuzz/corpus/xmlsec_x509crl/der-untrusted.seed new file mode 100644 index 0000000000000000000000000000000000000000..aba899dee68d7cfa6d5006bedef4fbffff3f038f GIT binary patch literal 1883 zcmZQ(vNLF66*FjJ{d#AN85K^ zMn-N{27|_JhTI06Y|No7Y{E>T!G^*Hf*=luFqd;;PG(wuQC?=Ep{;>6NRUg|B*NE6 zAviU;v?#NrQo$!PsVK3iQb8l5q@=(~U%$M(TrV*vHM=;qQZG3_SHB`Rr#LlP(@?@d z45Xb~m>;M$KQBcgC$%g!N5R?AP|QFCB*QGs>j=@O5S*BonP;eIAP;vYC!?4U#3TnK z!wnR~d5z2rj14S|j0{Z-&7vgujSPVTKmsaYP)mECNf}5$+%FiCT3n*wom#0-RGg@5 zWME=p(8Q>O9N3Jk49rc8{0u;GE~X|%MuvN;=`E&D8#1Qtjh%lx?2vu4L#3s`qNnT4 zFYSG(92f3ec<%N2=ERBluZ+e0Z{+eT_itscdZbXWi*b$qV~^9B@0c=QTYO(o5&nI1 zWZ1tTR?kL@Dbei5=btWH>G$P*RLn^y;T@5o2VJa|F}u6TdK+r3d2FeEtYp?fA7+ zZ2f{~-9o7w@5^U3{de4dVA0ZOBg2c$j~x}V{v3O~sNGAKiJ6gsad8u405C*+40wRy zC@ajuYQW6M_}@T>jWeOmgR$+06C*E+yqK(iL26!bu#bX!YF=tlVo7R>f^%w7NoHDR zGLT~+3)0KSBE}+;dw9C}&o^Q5Y*|;L3s#-aH)72pI5zk_@*ndr*FU31yj}30oHTM^1IX zEDlU{j0`^9`=svHXz?;dpA`NTU$*f#@2N9Ef1h#kSM;9p-m<{&TVLwb4X-bKo8itA zt93a#|D!fXpO)1|7x9JsO+OnBC|B4T&sb(Yv*N1ZO!1hB-X1%{o=YyP>?zFljqplQ zy_d$mvLaOAl;Wz3-lclX>1wIB<6UlxGZpUMp!BGdq4Hp2iRAWO3)sFSzX);3JACWs z2`0@&x5C-=7@EI6y)F5fx8<6;`HN_uYk7yhom4RG(R&vfHF<7jeZ#RlpP0UFLE|$VzL6|NG3)`wBQ-CB_O2yGc*N4Geh$zFxLcF6hgQL>ISOV zYXG!za{-?Lj{z4bhlsEMs|{wf-~p!|=jxv+TyA;%hUs}8hpLy}TCaXa`NfbYESzhy44^yz~F&Uzgv+qQmk!{MZdeY5x(uh&x(W%)ba~JmsES1^zd&8{16}3vY#aGnZpHglKVB!D(?K`di literal 0 HcmV?d00001 diff --git a/apps/oss-fuzz/corpus/xmlsec_x509crl/pem-trusted.seed b/apps/oss-fuzz/corpus/xmlsec_x509crl/pem-trusted.seed new file mode 100644 index 0000000000000000000000000000000000000000..f4afcd6df7f31e17fea590dc1694bc88aa486b91 GIT binary patch literal 2657 zcmai$$&!Oc5{4&YZajtWiV3j@2_nXaDkv7A05Xq|ki-0Ugl~e&Z=*voARh6Vl5WxPJgGq%TSKVw423z6V@cl9O ztoN>q^&%dV)uHetn&DY%BefV)9hm4sKod-P63)U3&M?dBrLm~axKg*ZIqP*h-5qqn;2{IbMXoIbm-VRh9D^+T?;o^RV>=R4btWxfa{^mH;pWU~=Ho zFXY;`Mt~{3CsBw&oy(;^di0&965)E#!OeM0?ck3(uki<4zj-7zufurFY1vA4?JAM` zFfqBRI=Lco8`M0#wD3dNS2likr~KR<*NSPCBH&MY)9-f1L1oCw8U2f$V^tQmNj5_tSOqEmYol=KO0B5x@~*o8`9{^pwimMS(DP5kFrDY zW)SfTd@dc7yj(us;Tkxpab$dccRps4QBtB478-tNEK}hgw^?1^kej_+C3lipBOPcH zA&%)DQXld?^>a<_I8vgcZGflds5y{npXR(Ium4g ztxOxf_Bi=y+f2Kdst8N~+k*;SaZ{-~O(NJ@+}ifrZoq`#eg!?u>%4g6kSNAt`y?b% z<}h;@SSPjaY)zv?K3i{sA|v0-P1;+st;u3vFEZJkluwmfqyb@w2uWtddcCtJDZ0bv z!}S^AwbI-obGnRGW%z6y#l|SVg;RbrfTT;jbetu#eHpt11jIRWxwI>@Qf%usl*vw& zXROKtHv38Vo(D3T&Yrs>2X8~^Qwsvbnn_E2>_;P!Hf$F> zR@{akGXaXGgM19lFFTmAPMCiLfKKSMT~eU}Lrxa#mu#yEBbw+8tkC{FuqpplY(!pI zjDBO)J6)9YD6h3o`wH%_-Kbxk_3xtUe-jk~4j6Xwo8ky9Ck3B-IJ=ss`+Ki1{cP`V z;aOx#eR&LIi%xXa_+D>}Hs2MBD3LFcdXJplt5w+^iQYAX*4zoZPy{NI^O!9govja) zBS#XoSTCzj?oqzCQ$_1 z7akRBBhBXz%Ky=i$&73SIyuR?Iigv0dJZ-H;-17RT-&D_VlA9G#csIEaG2r}wl1~5 zKa`J7pqy0YB=lOI7k(WWp#;OnJJN1&&uM)BK^)$@GE?7A*}}$Zy=(1pHHKJ`8ICH< z13guT+lvjIOnJL0$@?PKn3kI4^FENf%LQhHp|Q{2NDSXEY4H}zLN*w4!tP=+zn@N6 zf9|P~ns*BnCUm6kGA*DrF^1!G^`($e-^3|p6Y^HF46gRg#RC(Y&|2T?|=0 z&=eeo>{Y(g)9b;q^ijK#G_T$d{!zUU-h51U8M)_V&TYnIl-lCl8SiE3-sCej45Yc~ edmN@_qz-rcl1Rs5f92Y$kigdef0oZ*CGsEMN>_IP literal 0 HcmV?d00001 diff --git a/apps/oss-fuzz/corpus/xmlsec_x509crl/pem-untrusted.seed b/apps/oss-fuzz/corpus/xmlsec_x509crl/pem-untrusted.seed new file mode 100644 index 000000000..888fe19cb --- /dev/null +++ b/apps/oss-fuzz/corpus/xmlsec_x509crl/pem-untrusted.seed @@ -0,0 +1,44 @@ +<-----BEGIN CERTIFICATE----- +MIIFFjCCA/6gAwIBAgIUdzXuSH9oYtrxs5VtlhzLD6bzT1MwDQYJKoZIhvcNAQEL +BQAwgbYxCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpDYWxpZm9ybmlhMT0wOwYDVQQK +EzRYTUwgU2VjdXJpdHkgTGlicmFyeSAoaHR0cDovL3d3dy5hbGVrc2V5LmNvbS94 +bWxzZWMpMRgwFgYDVQQLEw9TZWNvbmQgbGV2ZWwgQ0ExFjAUBgNVBAMTDUFsZWtz +ZXkgU2FuaW4xITAfBgkqhkiG9w0BCQEWEnhtbHNlY0BhbGVrc2V5LmNvbTAgFw0y +NjAzMDgyMjE0MTZaGA8yMTI2MDIxMjIyMTQxNlowfTELMAkGA1UEBhMCVVMxEzAR +BgNVBAgTCkNhbGlmb3JuaWExPTA7BgNVBAoTNFhNTCBTZWN1cml0eSBMaWJyYXJ5 +IChodHRwOi8vd3d3LmFsZWtzZXkuY29tL3htbHNlYykxGjAYBgNVBAMTEVRlc3Qg +S2V5IHJzYS0yMDQ4MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA3iVn +hDXlgGiWvV2f21bCP4NAeTkwouWvN9K94SNeV01xzuvPg2GRb+ozF0/YbQ8jj7UD +euIgcLoBrC/jSMtp7gJp6zj3oHhX97NZVv5SBUmBOJRbB8efy3apTvTvWlzJQhO4 +WVXBRDqmA0dGHPRRuMB6l125wy+WBMWxO6BzUooe9m0OpQXjKokJKFcl9Zd4ht3E +qXW8cuHgiyrtYzXTcO63W9+J6dFOi1DTYhKMkK53jMsModlleEUdqUHgTbxK0TBS +YMa2sB1rGfcVq+QanOlsRHXAXiZM/BE6uPqlFq+g5osSZbHfH2qC/0G/wKKlWzIx +0YPjQSBq/MbroodKLQIDAQABo4IBUDCCAUwwDAYDVR0TBAUwAwEB/zAsBglghkgB +hvhCAQ0EHxYdT3BlblNTTCBHZW5lcmF0ZWQgQ2VydGlmaWNhdGUwHQYDVR0OBBYE +FG3Dlzf57FZfBmrUW3Cqz28yG8NGMIHuBgNVHSMEgeYwgeOAFNF9F6xFQoqO+bAX +JdU8cpidiDoloYG0pIGxMIGuMQswCQYDVQQGEwJVUzETMBEGA1UECBMKQ2FsaWZv +cm5pYTE9MDsGA1UEChM0WE1MIFNlY3VyaXR5IExpYnJhcnkgKGh0dHA6Ly93d3cu +YWxla3NleS5jb20veG1sc2VjKTEQMA4GA1UECxMHUm9vdCBDQTEWMBQGA1UEAxMN +QWxla3NleSBTYW5pbjEhMB8GCSqGSIb3DQEJARYSeG1sc2VjQGFsZWtzZXkuY29t +ghR3Ne5If2hi2vGzlW2WHMsPpvNPTzANBgkqhkiG9w0BAQsFAAOCAQEATAu+Gt18 +Kg0CW8kT+l92sfsNysxS/eYJD3iNyku0oE72jmWVsOvS9phHDF0q01tv8SsIjio6 +sUQXoQ+C+YDAI3g9M5imN5l41TGZF1yRS0i5VucZpnmMcWtNWEpkJd5mB6l4VRDK +IarRS3UuA2cmZdtfRNsXAnG7sCLiiQB5wWF0Gbe6oAb0Y+hURG7D2vnIAimi2lcH +LgCD9eXbGfMNhNYnN+hbTNZuwvbJIDWMLu5VWpOdeX+Axm5MXI7lNPMRda75uPRQ +O52QICz4Cz3lbq4SEhiF4CQ5h/FRj6Yc8m+ZY3/5khICap0dUjAmmezcVwMJlxXr +hwvZjgian+dyQw== +-----END CERTIFICATE----- +-----BEGIN X509 CRL----- +MIICOjCCASICAQEwDQYJKoZIhvcNAQELBQAwgbYxCzAJBgNVBAYTAlVTMRMwEQYD +VQQIEwpDYWxpZm9ybmlhMT0wOwYDVQQKEzRYTUwgU2VjdXJpdHkgTGlicmFyeSAo +aHR0cDovL3d3dy5hbGVrc2V5LmNvbS94bWxzZWMpMRgwFgYDVQQLEw9TZWNvbmQg +bGV2ZWwgQ0ExFjAUBgNVBAMTDUFsZWtzZXkgU2FuaW4xITAfBgkqhkiG9w0BCQEW +EnhtbHNlY0BhbGVrc2V5LmNvbRcNMjYwMzE1MTUxNjE3WhcNMjYwNDE0MTUxNjE3 +WjAnMCUCFHc17kh/aGLa8bOVbZYcyw+m809TFw0yNjAzMDgyMjE0MTZaoA4wDDAK +BgNVHRQEAwIBAzANBgkqhkiG9w0BAQsFAAOCAQEAQ3v5ZApGbg8xZ25Iwnul2q8n +zCPonIYMKYx8HSm8Lu4waiBoU1/fkHrpC1TcI8FEqynL9zu3CiAurtZKeB/8K9sr +4t+idItnGRMOzRtlKkPOuaHG381hQ42wj4eq5YTdHtUc09WDMK3o1wGJ/XGpLLBd +OK5nsObOWWi2DeaGCduOxb5+a0gf77MNn/1v1x+yBCwE61fG2CEzbOu6wPWFY3It +7c5b0eh/BjS3TiWgDz8jFGMyvQfo++aB5NXKHMYY5PGf2wqk5526KP029If4W6IL +Vx6b+d0/8G8UmvbvFohJpOtyypt0naOOEKUctvuwmv14fSLbF6h/P8ojhFACCA== +-----END X509 CRL----- diff --git a/apps/oss-fuzz/xmlsec_x509crl_target.c b/apps/oss-fuzz/xmlsec_x509crl_target.c new file mode 100644 index 000000000..21af8420d --- /dev/null +++ b/apps/oss-fuzz/xmlsec_x509crl_target.c @@ -0,0 +1,199 @@ +/* + * xmlsec X509 store / CRL verification fuzz target. + * + * Threat model: certificates and CRLs are attacker-controlled in X509Data + * elements of signatures, and CRL validation decides revocation. Production + * coverage: src/openssl/x509vfy.c 487/1701 lines, 26/49 functions unreached + * (VerifyCrl, FindBestCrl, VerifyCertAgainstRevoked, FilterCrlsByTime are + * never called by the signature-verify harness); openssl/app.c 97/1359. + * + * Input container (cheap, mutator-friendly): + * byte 0 : format selector (Pem/Der) and cert trust-type bit + * bytes 1..2 : CRL blob length, big endian (clamped) + * bytes 3.. : certificate blob, then the CRL blob + * + * Harness shape (component API): load the blobs through xmlsec's own memory + * loaders (src/openssl/app.c), then call the exported store entries + * xmlSecOpenSSLX509StoreVerifyCrl() and xmlSecOpenSSLX509StoreVerify() with + * typed OpenSSL objects. Expected bugs: memory safety and time/issuer + * comparison logic in CRL chain checking. + */ +#include +#include +#include + +#include +#include +#include + +#include +#include +#include + +int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size); + +#include +#include +#include +#include +#include + +#include +#include +#include + +static int g_initialized = 0; +static int g_init_failed = 0; + +static void ignore_libxml_error(void* ctx, const char* msg, ...) { + (void)ctx; (void)msg; +} + +static void ignore_xmlsec_error(const char* file, int line, const char* func, + const char* errorObject, const char* errorSubject, + int reason, const char* msg) { + (void)file; (void)line; (void)func; + (void)errorObject; (void)errorSubject; (void)reason; (void)msg; +} + +static int do_init(void) { + xmlInitParser(); + if (xmlSecInit() < 0) { + return -1; + } + if (xmlSecCheckVersion() != 1) { + xmlSecShutdown(); + return -1; + } + if (xmlSecOpenSSLAppInit(NULL) < 0) { + xmlSecShutdown(); + return -1; + } + if (xmlSecOpenSSLInit() < 0) { + xmlSecOpenSSLShutdown(); + xmlSecOpenSSLAppShutdown(); + xmlSecShutdown(); + return -1; + } + xmlSetGenericErrorFunc(NULL, &ignore_libxml_error); + xmlSecErrorsSetCallback(&ignore_xmlsec_error); + return 0; +} + +static X509_CRL* parse_crl(const uint8_t* data, size_t size, int der) { + X509_CRL* crl = NULL; + + if (der) { + const unsigned char* p = data; + crl = d2i_X509_CRL(NULL, &p, (long)size); + } else { + BIO* bio = BIO_new_mem_buf(data, (int)size); + if (bio != NULL) { + crl = PEM_read_bio_X509_CRL(bio, NULL, NULL, NULL); + BIO_free(bio); + } + } + return crl; +} + +static X509* parse_cert(const uint8_t* data, size_t size, int der) { + X509* cert = NULL; + + if (der) { + const unsigned char* p = data; + cert = d2i_X509(NULL, &p, (long)size); + } else { + BIO* bio = BIO_new_mem_buf(data, (int)size); + if (bio != NULL) { + cert = PEM_read_bio_X509(bio, NULL, NULL, NULL); + BIO_free(bio); + } + } + return cert; +} + +int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { + xmlSecKeysMngrPtr mngr = NULL; + xmlSecKeyDataStorePtr store = NULL; + xmlSecKeyInfoCtxPtr keyInfoCtx = NULL; + xmlSecKeyDataType certType = xmlSecKeyDataTypeTrusted; + xmlSecKeyDataFormat fmt; + X509* cert = NULL; + X509_CRL* crl = NULL; + XMLSEC_STACK_OF_X509* certs = NULL; + XMLSEC_STACK_OF_X509_CRL* crls = NULL; + size_t crlLen, certLen; + int der; + + if (!g_initialized) { + g_init_failed = (do_init() < 0); + g_initialized = 1; + } + /* byte 0 = selector, bytes 1..2 = crl length, then cert and crl blobs. */ + if (g_init_failed || size < 5 || size > 65536) { + return 0; + } + der = (data[0] & 1) != 0; + certType = ((data[0] & 2) != 0) ? xmlSecKeyDataTypeTrusted + : xmlSecKeyDataTypeNone; + fmt = der ? xmlSecKeyDataFormatDer : xmlSecKeyDataFormatPem; + crlLen = ((size_t)data[1] << 8) | (size_t)data[2]; + if (crlLen > size - 3) { + crlLen = size - 3; + } + certLen = size - 3 - crlLen; + if (crlLen == 0 || certLen == 0) { + return 0; + } + + mngr = xmlSecKeysMngrCreate(); + if (mngr == NULL) { + return 0; + } + if (xmlSecOpenSSLAppDefaultKeysMngrInit(mngr) < 0) { + xmlSecKeysMngrDestroy(mngr); + return 0; + } + store = xmlSecKeysMngrGetDataStore(mngr, xmlSecOpenSSLX509StoreId); + + /* xmlsec's own untrusted-input loaders (src/openssl/app.c). */ + (void)xmlSecOpenSSLAppKeysMngrCertLoadMemory(mngr, data + 3, certLen, + fmt, certType); + (void)xmlSecOpenSSLAppKeysMngrCrlLoadMemory(mngr, data + 3 + certLen, + crlLen, fmt); + + cert = parse_cert(data + 3, certLen, der); + crl = parse_crl(data + 3 + certLen, crlLen, der); + + keyInfoCtx = xmlSecKeyInfoCtxCreate(mngr); + if (keyInfoCtx == NULL) { + if (cert != NULL) X509_free(cert); + if (crl != NULL) X509_CRL_free(crl); + xmlSecKeysMngrDestroy(mngr); + return 0; + } + + /* The dark entries: CRL validation against the store. */ + if (crl != NULL && store != NULL) { + (void)xmlSecOpenSSLX509StoreVerifyCrl(store, crl, keyInfoCtx); + } + if (cert != NULL && crl != NULL && store != NULL) { + certs = sk_X509_new_null(); + crls = sk_X509_CRL_new_null(); + if (certs != NULL && crls != NULL) { + X509* cert_dup = X509_dup(cert); + X509_CRL* crl_dup = X509_CRL_dup(crl); + if (cert_dup != NULL) sk_X509_push(certs, cert_dup); + if (crl_dup != NULL) sk_X509_CRL_push(crls, crl_dup); + (void)xmlSecOpenSSLX509StoreVerify(store, certs, crls, keyInfoCtx); + } + } + + if (certs != NULL) sk_X509_pop_free(certs, X509_free); + if (crls != NULL) sk_X509_CRL_pop_free(crls, X509_CRL_free); + if (cert != NULL) X509_free(cert); + if (crl != NULL) X509_CRL_free(crl); + xmlSecKeyInfoCtxDestroy(keyInfoCtx); + xmlSecKeysMngrDestroy(mngr); + return 0; +}