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 000000000..d1df9939e Binary files /dev/null and b/apps/oss-fuzz/corpus/xmlsec_x509crl/der-trusted.seed differ 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 000000000..aba899dee Binary files /dev/null and b/apps/oss-fuzz/corpus/xmlsec_x509crl/der-untrusted.seed differ 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 000000000..f4afcd6df Binary files /dev/null and b/apps/oss-fuzz/corpus/xmlsec_x509crl/pem-trusted.seed differ 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; +}