diff --git a/.github/configs/os-check-linux.json b/.github/configs/os-check-linux.json index c90ad57e2ed..59782cf789e 100644 --- a/.github/configs/os-check-linux.json +++ b/.github/configs/os-check-linux.json @@ -663,5 +663,11 @@ {"name": "sp-math-sakke", "comment": "SAKKE on WOLFSSL_SP_MATH without RSA, DH, or ECCSI: its blinded RSK inverse needs sp_mulmod, which nothing else builds in this shape.", "configure": ["--enable-cryptonly", "--enable-sp-math", "--enable-sp", - "--disable-rsa", "--disable-dh", "--enable-sakke"]} + "--disable-rsa", "--disable-dh", "--enable-sakke"]}, +{"name": "cert-events-crl", + "comment": "Certificate validation events without the compatibility layer. --enable-all covers them with OPENSSL_EXTRA on, where the TLS verify path and the error codes it passes on differ.", + "configure": ["--enable-cert-events", "--enable-crl"]}, +{"name": "cert-events-tiny", + "comment": "Certificate validation events without CRL and with WOLFSSL_X509_TINY, which does not decode some extensions.", + "configure": ["--enable-cert-events", "CPPFLAGS=-DWOLFSSL_X509_TINY"]} ] diff --git a/CMakeLists.txt b/CMakeLists.txt index c0e67a1a620..abccf2a1654 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -368,7 +368,8 @@ if(WOLFSSL_ALL) # implication and hard-errors without it, so name it explicitly. foreach(_o WOLFSSL_HPKE - WOLFSSL_ALPN WOLFSSL_CRL_MONITOR WOLFSSL_DTLS WOLFSSL_DTLS13 + WOLFSSL_ALPN WOLFSSL_CERT_EVENTS WOLFSSL_CRL_MONITOR WOLFSSL_DTLS + WOLFSSL_DTLS13 WOLFSSL_DTLS_CH_FRAG WOLFSSL_DTLS_MTU WOLFSSL_DTLS_CID WOLFSSL_EARLYDATA WOLFSSL_ECH WOLFSSL_HRR_COOKIE WOLFSSL_MCAST WOLFSSL_OCSP WOLFSSL_OCSPSTAPLING WOLFSSL_OCSPSTAPLING_V2 WOLFSSL_OPENSSLALL @@ -1954,6 +1955,10 @@ add_option("WOLFSSL_CERTGENCACHE" "Enable decoded cert caching (default: disabled)" "no" "yes;no") +add_option("WOLFSSL_CERT_EVENTS" + "Enable structured certificate and CRL validation event callback (default: disabled)" + "no" "yes;no") + # Chain verify callback add_option("WOLFSSL_CHAIN_VERIFY_CB" "Enable replacing peer certificate verification with a user callback (default: disabled)" @@ -3596,6 +3601,9 @@ endif() if(WOLFSSL_CERTGENCACHE) list(APPEND WOLFSSL_DEFINITIONS "-DWOLFSSL_CERT_GEN_CACHE") endif() +if(WOLFSSL_CERT_EVENTS) + list(APPEND WOLFSSL_DEFINITIONS "-DWOLFSSL_CERT_EVENTS") +endif() if(WOLFSSL_CHAIN_VERIFY_CB) list(APPEND WOLFSSL_DEFINITIONS "-DWOLFSSL_CHAIN_VERIFY_CB") diff --git a/ChangeLog.md b/ChangeLog.md index a8273b994ff..55f16d0bb9f 100644 --- a/ChangeLog.md +++ b/ChangeLog.md @@ -26,6 +26,20 @@ curve equation need no curve arithmetic, so both are still done on the host. Both macros are documented in `wolfcrypt/src/port/nxp/README_SE050.md` and `IDE/CRYPTOCELL/README.md`. by @SparkiDev +* Added certificate validation events (`--enable-cert-events`, + `WOLFSSL_CERT_EVENTS`; off by default and in `--enable-all`). A callback set + with `wolfSSL_CertManagerSetCertEventCb()`, `wolfSSL_CTX_SetCertEventCb()`, + `wolfSSL_X509_STORE_SetCertEventCb()` or `wc_SetCertEventCallback()` + observes each certificate check: a DEFECT event for each failed check, + with the certificate's role and chain depth, the RFC 5280 field and the + reason; a RESULT event when a verification finishes; the certificate's + subject, issuer and serial number and the TLS connection; and a stable + condition value for each failure, named after the IEC 62351-9 and + IEC 62351-3 audit events, for security logging such as the EU Cyber + Resilience Act calls for. Events come from the TLS peer chain, + `wolfSSL_CertManagerVerify*()`, `X509_verify_cert()`, trust anchors loaded + with verification, and parsing without a certificate manager. The callback + cannot change a result; the verify callback still decides. by @sameehj ## Behavioral Changes * **Behavioral change (DSA now uses the leftmost |q| bytes of the digest)**: diff --git a/certs/test/catalog.txt b/certs/test/catalog.txt index e9b835b865d..55121fe7250 100644 --- a/certs/test/catalog.txt +++ b/certs/test/catalog.txt @@ -25,3 +25,12 @@ server-self-issued-cert.pem: ca-cert-unknown-crit-ext.pem: ../ca-cert.pem with the same name and key, plus an unknown critical extension. Regenerate with certs/test/gen-verify-cb-certs.sh. +cert-events/*.der, cert-events/*.pem: + Copies of certs/server-cert.der, each with exactly one defect and signed + again with certs/ca-key.pem, so verification reaches the defect. + good.der has no defect. The chain-*.pem files are chains for a server + using certs/server-key.pem, with CAs keyed by + certs/intermediate/ca-int*-key.pem under certs/ca-cert.pem; chain-good.pem + has no fault. Used by the certificate validation event tests in + tests/api/test_certman.c. Valid until 2049. Regenerate with + certs/test/gen-cert-events.py. diff --git a/certs/test/cert-events/aia-malformed.der b/certs/test/cert-events/aia-malformed.der new file mode 100644 index 00000000000..cdd7409bf16 Binary files /dev/null and b/certs/test/cert-events/aia-malformed.der differ diff --git a/certs/test/cert-events/akid-malformed.der b/certs/test/cert-events/akid-malformed.der new file mode 100644 index 00000000000..e0b124f3207 Binary files /dev/null and b/certs/test/cert-events/akid-malformed.der differ diff --git a/certs/test/cert-events/bc-malformed.der b/certs/test/cert-events/bc-malformed.der new file mode 100644 index 00000000000..46ce7970c38 Binary files /dev/null and b/certs/test/cert-events/bc-malformed.der differ diff --git a/certs/test/cert-events/chain-good.pem b/certs/test/cert-events/chain-good.pem new file mode 100644 index 00000000000..23ae52445b0 --- /dev/null +++ b/certs/test/cert-events/chain-good.pem @@ -0,0 +1,44 @@ +-----BEGIN CERTIFICATE----- +MIIDjTCCAnWgAwIBAgIEDOfhATANBgkqhkiG9w0BAQsFADAdMRswGQYDVQQDDBJD +ZXJ0IEV2ZW50cyBJbnQgQ0EwHhcNMjUwMTAxMDAwMDAwWhcNNDkxMjMxMjM1OTU5 +WjCBkTELMAkGA1UEBhMCVVMxEDAOBgNVBAgMB01vbnRhbmExEDAOBgNVBAcMB0Jv +emVtYW4xEDAOBgNVBAoMB3dvbGZTU0wxEDAOBgNVBAsMB1N1cHBvcnQxGDAWBgNV +BAMMD3d3dy53b2xmc3NsLmNvbTEgMB4GCSqGSIb3DQEJARYRZmFjdHNAd29sZnNz +bC5jb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDAlQjhV0HycW23 +0kVBJwFlxkWu8rwkMLiVzi9O1vYciLx8n/uoZ3/+XJxRdfeKygfnNS+P4b17wC98 +q2SoF/zKXXu64CHlci5vLobYlXParBtTuV8/1xkNJU/hY2NRiwtkP61DuKUcXDSz +rgCgY8X2fwtZaHhzpowYqQJtr8MZAS64EOPGzEC0aaNGM2mHbsS7F6bz6N2tc7x7 +LyG1/WZRDL1Us+FtXxy8I3PRCQOJFNIQuWTDKtChlkq84dQaW8egwMFjeA9ENzAy +loAyI5Whd7oT0pdz4l0lyWoNwzlgpLSwaUJCCenYCLwzILNYIqeq68Th5mGDxdKW +39nQT63XAgMBAAGjYDBeMB0GA1UdDgQWBBThtKDO3gM48K71o8iI1Qzx51GhMTAf +BgNVHSMEGDAWgBTVJPMMuhIZLGVl2yrQko+ZE1Z6zzAMBgNVHRMBAf8EAjAAMA4G +A1UdDwEB/wQEAwIFoDANBgkqhkiG9w0BAQsFAAOCAQEADFPxXawK3q/t9put9pte +o8hbpqwzHz09yq5ulKczd554M+RQPDqabj6w9ew7jaa45bqgl+5lX5e4TGW0/XNV +T29z7cpk5aeaddcEqqPrftU0xDMEMeIaYxB4HZRRy+h2tefHVhpT4y7oUzTJAkXx +s9EYvAPOvhPwxkMtZKD5BOeB5LzmilLVxtjWQJjIQjxk45T6Mxij8xeEJBZ1YjBo +4bqunXBay1MI8Z0vyN9VNU4+rLY4xpy8R3SoEjUHK+TmpB6ukJr0HVd6xoCezvmz +LEmpUtwEmz53/QJIYumZNqZA+a+6SnWTq/lCrvhjP/rVr4LRe62PSqChlKwa/BXh +Eg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDlDCCAnygAwIBAgIEDOfhAjANBgkqhkiG9w0BAQsFADCBlTELMAkGA1UEBhMC +VVMxEDAOBgNVBAgMB01vbnRhbmExEDAOBgNVBAcMB0JvemVtYW4xETAPBgNVBAoM +CFNhd3Rvb3RoMRMwEQYDVQQLDApDb25zdWx0aW5nMRgwFgYDVQQDDA93d3cud29s +ZnNzbC5jb20xIDAeBgkqhkiG9w0BCQEWEWZhY3RzQHdvbGZzc2wuY29tMB4XDTI1 +MDEwMTAwMDAwMFoXDTQ5MTIzMTIzNTk1OVowHTEbMBkGA1UEAwwSQ2VydCBFdmVu +dHMgSW50IENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAw6JzXSFi +IM46cTinlLvbhwQcWhueSw0+yvil9w1q3COQImorWGNKKGpIqOdzH6JV2E0CO+LL +a+KDyVGPd/3cLV0jtyOafrYpaOgqTqn+MnAxnvDv7viN4/zz1yjdeh2erSMr8aZ/ +NFIpZtLlZFVk1t1LQTtVg27AEQ5uIMIWc+sw/wlGu+fMxgNEQRHGwWw2L0r5kVXK +WF43uCgQMIlAlnfPcGakVftpC+fZsjNl23I6d7crSfy2zVgQjauqy0BFdwI5GLOP +MwFId1C+jnOn3jagSY4sFq+5+0ItNWrbNDfVFFl9ZXLli2VVSyBeR/n4OtNs2Tr1 +xwFGMcN5mhi+SQIDAQABo2MwYTAdBgNVHQ4EFgQU1STzDLoSGSxlZdsq0JKPmRNW +es8wHwYDVR0jBBgwFoAUJ45nEXTDJh0/7TNjs6TYHTDl6NUwDwYDVR0TAQH/BAUw +AwEB/zAOBgNVHQ8BAf8EBAMCAQYwDQYJKoZIhvcNAQELBQADggEBACbBE+e3IaQt +2VDvUXw3pZWoXuXDTCwI022Go69y7n0lUXoA1O2yPwVQmexeiIo7w3V5K4Z/RzSg +Sm30R+7XeB6Z6SQ08sm5FKXg3fNOlC7OIrcGZYqRX+ztOViKEtUqADhK2aQeMKxx +Awf586aef8Ilk8eRyt92pmbscJCa//rdn8PQEbDQQ/LOQUN/wLw32p8aEtO85xvf +fBh+UUKeFZCRPUTnHvr/Z2Vwc9cxDkR+1c228u2OZJl1EnwIQOBfZypuxgczuP8G +OHHe0Zsd7TSNUblIwEeb9GqpwRk1Jym31DZU/lmf+jhmSLH2YhJanaMXGnPPgix2 +1p6wecWxr+c= +-----END CERTIFICATE----- diff --git a/certs/test/cert-events/chain-leaf-eku-client-only.pem b/certs/test/cert-events/chain-leaf-eku-client-only.pem new file mode 100644 index 00000000000..14f16b8d9e1 --- /dev/null +++ b/certs/test/cert-events/chain-leaf-eku-client-only.pem @@ -0,0 +1,44 @@ +-----BEGIN CERTIFICATE----- +MIIDojCCAoqgAwIBAgIEDOfhDjANBgkqhkiG9w0BAQsFADAdMRswGQYDVQQDDBJD +ZXJ0IEV2ZW50cyBJbnQgQ0EwHhcNMjUwMTAxMDAwMDAwWhcNNDkxMjMxMjM1OTU5 +WjCBkTELMAkGA1UEBhMCVVMxEDAOBgNVBAgMB01vbnRhbmExEDAOBgNVBAcMB0Jv +emVtYW4xEDAOBgNVBAoMB3dvbGZTU0wxEDAOBgNVBAsMB1N1cHBvcnQxGDAWBgNV +BAMMD3d3dy53b2xmc3NsLmNvbTEgMB4GCSqGSIb3DQEJARYRZmFjdHNAd29sZnNz +bC5jb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDAlQjhV0HycW23 +0kVBJwFlxkWu8rwkMLiVzi9O1vYciLx8n/uoZ3/+XJxRdfeKygfnNS+P4b17wC98 +q2SoF/zKXXu64CHlci5vLobYlXParBtTuV8/1xkNJU/hY2NRiwtkP61DuKUcXDSz +rgCgY8X2fwtZaHhzpowYqQJtr8MZAS64EOPGzEC0aaNGM2mHbsS7F6bz6N2tc7x7 +LyG1/WZRDL1Us+FtXxy8I3PRCQOJFNIQuWTDKtChlkq84dQaW8egwMFjeA9ENzAy +loAyI5Whd7oT0pdz4l0lyWoNwzlgpLSwaUJCCenYCLwzILNYIqeq68Th5mGDxdKW +39nQT63XAgMBAAGjdTBzMB0GA1UdDgQWBBThtKDO3gM48K71o8iI1Qzx51GhMTAf +BgNVHSMEGDAWgBTVJPMMuhIZLGVl2yrQko+ZE1Z6zzAMBgNVHRMBAf8EAjAAMA4G +A1UdDwEB/wQEAwIFoDATBgNVHSUEDDAKBggrBgEFBQcDAjANBgkqhkiG9w0BAQsF +AAOCAQEAYaZZL5eho/TnyO7CliZC1aMJUVSD9n98K28bxuPrtO3KAPuJd3krLvQU +dJR6Zg7e3A/whY/fn35Oi7KL0MYULO1bWUZQXO+0X2L5PR3WX2IPsG5R3RCsP3rz +JoIgajfHnmjeD35Oq1RUDwaCpt00hDW7VXqyrTZg2SG78niO/+DJDNhy9IwQFUHX +1l+z034eDTQaecb3vZsvqsn5OdynK8EGLK0sHcgwp7BK7gRg0KwVKCSoLrwDE3QC +7l9wO+xb+NAQw5xxupitWUfrQUY3ZxHXAJOLSD5guR3ho4wN2ibCotWflfBuuLNR +NzsM1UBzJLqRS3zNb7vZW+VsQWvw3g== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDlDCCAnygAwIBAgIEDOfhDzANBgkqhkiG9w0BAQsFADCBlTELMAkGA1UEBhMC +VVMxEDAOBgNVBAgMB01vbnRhbmExEDAOBgNVBAcMB0JvemVtYW4xETAPBgNVBAoM +CFNhd3Rvb3RoMRMwEQYDVQQLDApDb25zdWx0aW5nMRgwFgYDVQQDDA93d3cud29s +ZnNzbC5jb20xIDAeBgkqhkiG9w0BCQEWEWZhY3RzQHdvbGZzc2wuY29tMB4XDTI1 +MDEwMTAwMDAwMFoXDTQ5MTIzMTIzNTk1OVowHTEbMBkGA1UEAwwSQ2VydCBFdmVu +dHMgSW50IENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAw6JzXSFi +IM46cTinlLvbhwQcWhueSw0+yvil9w1q3COQImorWGNKKGpIqOdzH6JV2E0CO+LL +a+KDyVGPd/3cLV0jtyOafrYpaOgqTqn+MnAxnvDv7viN4/zz1yjdeh2erSMr8aZ/ +NFIpZtLlZFVk1t1LQTtVg27AEQ5uIMIWc+sw/wlGu+fMxgNEQRHGwWw2L0r5kVXK +WF43uCgQMIlAlnfPcGakVftpC+fZsjNl23I6d7crSfy2zVgQjauqy0BFdwI5GLOP +MwFId1C+jnOn3jagSY4sFq+5+0ItNWrbNDfVFFl9ZXLli2VVSyBeR/n4OtNs2Tr1 +xwFGMcN5mhi+SQIDAQABo2MwYTAdBgNVHQ4EFgQU1STzDLoSGSxlZdsq0JKPmRNW +es8wHwYDVR0jBBgwFoAUJ45nEXTDJh0/7TNjs6TYHTDl6NUwDwYDVR0TAQH/BAUw +AwEB/zAOBgNVHQ8BAf8EBAMCAQYwDQYJKoZIhvcNAQELBQADggEBAK5snKw4GCEV +bR/TRttX83AE9dc8OlxTZdedHtYQ8LtWfZhzogjdbsETkpymXi+fFv5Orci5ihh+ +ev730zu0vl1uDo7abKhOLOS3ytSeTwwi37Fw2cVRiTxPq7aBrXAxobesAW2afDRu +ZaimDeQNKtoV7RmR8LcyT8YYY2fL+IvwZGac2A/yFNAUjqHQOwJEDcbMyeq0bFU0 +dSHGQrlbrjUQlQuNabKBOncaeyHxw9YPlcb67BYp+F8se7nKemFMgRJGpPj04VX1 +DqZbih17h1QGH6xgDxasHSPbGfK57oYh9+ria493rhrxtzaqYYpz39GB6X8zrjnu +m6FofCWCgRQ= +-----END CERTIFICATE----- diff --git a/certs/test/cert-events/chain-leaf-ku-no-digsig.pem b/certs/test/cert-events/chain-leaf-ku-no-digsig.pem new file mode 100644 index 00000000000..80deec1308e --- /dev/null +++ b/certs/test/cert-events/chain-leaf-ku-no-digsig.pem @@ -0,0 +1,44 @@ +-----BEGIN CERTIFICATE----- +MIIDjTCCAnWgAwIBAgIEDOfhDDANBgkqhkiG9w0BAQsFADAdMRswGQYDVQQDDBJD +ZXJ0IEV2ZW50cyBJbnQgQ0EwHhcNMjUwMTAxMDAwMDAwWhcNNDkxMjMxMjM1OTU5 +WjCBkTELMAkGA1UEBhMCVVMxEDAOBgNVBAgMB01vbnRhbmExEDAOBgNVBAcMB0Jv +emVtYW4xEDAOBgNVBAoMB3dvbGZTU0wxEDAOBgNVBAsMB1N1cHBvcnQxGDAWBgNV +BAMMD3d3dy53b2xmc3NsLmNvbTEgMB4GCSqGSIb3DQEJARYRZmFjdHNAd29sZnNz +bC5jb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDAlQjhV0HycW23 +0kVBJwFlxkWu8rwkMLiVzi9O1vYciLx8n/uoZ3/+XJxRdfeKygfnNS+P4b17wC98 +q2SoF/zKXXu64CHlci5vLobYlXParBtTuV8/1xkNJU/hY2NRiwtkP61DuKUcXDSz +rgCgY8X2fwtZaHhzpowYqQJtr8MZAS64EOPGzEC0aaNGM2mHbsS7F6bz6N2tc7x7 +LyG1/WZRDL1Us+FtXxy8I3PRCQOJFNIQuWTDKtChlkq84dQaW8egwMFjeA9ENzAy +loAyI5Whd7oT0pdz4l0lyWoNwzlgpLSwaUJCCenYCLwzILNYIqeq68Th5mGDxdKW +39nQT63XAgMBAAGjYDBeMB0GA1UdDgQWBBThtKDO3gM48K71o8iI1Qzx51GhMTAf +BgNVHSMEGDAWgBTVJPMMuhIZLGVl2yrQko+ZE1Z6zzAMBgNVHRMBAf8EAjAAMA4G +A1UdDwEB/wQEAwIFIDANBgkqhkiG9w0BAQsFAAOCAQEAMmOO4rOcYcZjZdZrvBaT +KmF3e1N3unte3MmsCetDCrLNk80Mk8zRfQE17RXp082rXI2s+7JfarmZkxXa4wBF +rX4Vw/RPy8YWisA7snEmNIfjxbtS0UONdBkL5F08u8n8YmDIUEdQhD6OwgujUeXW ++NnXBTM35XRmqDXEJCIUyCLjMjFxruRYbN2nEhSF7KuSF+hivWDGzz/4gj2lAWe/ +7fvPAb0HaauYpfCOOCMaJmIYwPWwliA9QDewvyuI3OXBy91tHMaF+UkY6IFUhytr +RQOXVTOXND9ke9zNodGLUjkPxQnkBpllyebZujRSlMNdjlKk6aQ47FzOSwKkefB0 +kw== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDlDCCAnygAwIBAgIEDOfhDTANBgkqhkiG9w0BAQsFADCBlTELMAkGA1UEBhMC +VVMxEDAOBgNVBAgMB01vbnRhbmExEDAOBgNVBAcMB0JvemVtYW4xETAPBgNVBAoM +CFNhd3Rvb3RoMRMwEQYDVQQLDApDb25zdWx0aW5nMRgwFgYDVQQDDA93d3cud29s +ZnNzbC5jb20xIDAeBgkqhkiG9w0BCQEWEWZhY3RzQHdvbGZzc2wuY29tMB4XDTI1 +MDEwMTAwMDAwMFoXDTQ5MTIzMTIzNTk1OVowHTEbMBkGA1UEAwwSQ2VydCBFdmVu +dHMgSW50IENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAw6JzXSFi +IM46cTinlLvbhwQcWhueSw0+yvil9w1q3COQImorWGNKKGpIqOdzH6JV2E0CO+LL +a+KDyVGPd/3cLV0jtyOafrYpaOgqTqn+MnAxnvDv7viN4/zz1yjdeh2erSMr8aZ/ +NFIpZtLlZFVk1t1LQTtVg27AEQ5uIMIWc+sw/wlGu+fMxgNEQRHGwWw2L0r5kVXK +WF43uCgQMIlAlnfPcGakVftpC+fZsjNl23I6d7crSfy2zVgQjauqy0BFdwI5GLOP +MwFId1C+jnOn3jagSY4sFq+5+0ItNWrbNDfVFFl9ZXLli2VVSyBeR/n4OtNs2Tr1 +xwFGMcN5mhi+SQIDAQABo2MwYTAdBgNVHQ4EFgQU1STzDLoSGSxlZdsq0JKPmRNW +es8wHwYDVR0jBBgwFoAUJ45nEXTDJh0/7TNjs6TYHTDl6NUwDwYDVR0TAQH/BAUw +AwEB/zAOBgNVHQ8BAf8EBAMCAQYwDQYJKoZIhvcNAQELBQADggEBAK2TiY13fREh +iaOc3+iG9cS1hDmyAV0bCQXNQeNIyu7M2OQJ014Qp6FU0Ntkng4R6+/Jo/QdhXJu +bBVebYSvrLQMiOzvuBUhuyS3J/s5ht1baiHrNkg+b1OurFED1VPKZNHXZzQDmdZV +nuN26H5jPpH5+gbHCSmZtBeaPinSBnjjVX6zqYwURKna3UO3NRET4ARYm35s3Jag +X70KedeHjJJn93oMh20PqTiwWMmbxF9VGC/EO+AOPV9pbzph/Mwupo+99uZlzWPm +JGPCq2AN0VwwA7IiZF70xvkoVBJ9sWydJvhtmwhlL9s9AqLIQSoP99jF+ygxL4UT +fsnuu2qjGno= +-----END CERTIFICATE----- diff --git a/certs/test/cert-events/chain-pathlen-exceeded.pem b/certs/test/cert-events/chain-pathlen-exceeded.pem new file mode 100644 index 00000000000..6e962eedefe --- /dev/null +++ b/certs/test/cert-events/chain-pathlen-exceeded.pem @@ -0,0 +1,64 @@ +-----BEGIN CERTIFICATE----- +MIIDmzCCAoOgAwIBAgIEDOfhCDANBgkqhkiG9w0BAQsFADArMSkwJwYDVQQDDCBD +ZXJ0IEV2ZW50cyBJbnQgQmVsb3cgUGF0aCBMZW4gMDAeFw0yNTAxMDEwMDAwMDBa +Fw00OTEyMzEyMzU5NTlaMIGRMQswCQYDVQQGEwJVUzEQMA4GA1UECAwHTW9udGFu +YTEQMA4GA1UEBwwHQm96ZW1hbjEQMA4GA1UECgwHd29sZlNTTDEQMA4GA1UECwwH +U3VwcG9ydDEYMBYGA1UEAwwPd3d3LndvbGZzc2wuY29tMSAwHgYJKoZIhvcNAQkB +FhFmYWN0c0B3b2xmc3NsLmNvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC +ggEBAMCVCOFXQfJxbbfSRUEnAWXGRa7yvCQwuJXOL07W9hyIvHyf+6hnf/5cnFF1 +94rKB+c1L4/hvXvAL3yrZKgX/Mpde7rgIeVyLm8uhtiVc9qsG1O5Xz/XGQ0lT+Fj +Y1GLC2Q/rUO4pRxcNLOuAKBjxfZ/C1loeHOmjBipAm2vwxkBLrgQ48bMQLRpo0Yz +aYduxLsXpvPo3a1zvHsvIbX9ZlEMvVSz4W1fHLwjc9EJA4kU0hC5ZMMq0KGWSrzh +1Bpbx6DAwWN4D0Q3MDKWgDIjlaF3uhPSl3PiXSXJag3DOWCktLBpQkIJ6dgIvDMg +s1gip6rrxOHmYYPF0pbf2dBPrdcCAwEAAaNgMF4wHQYDVR0OBBYEFOG0oM7eAzjw +rvWjyIjVDPHnUaExMB8GA1UdIwQYMBaAFLVTZnQGSfrz9de5DFQNb1IVzo47MAwG +A1UdEwEB/wQCMAAwDgYDVR0PAQH/BAQDAgWgMA0GCSqGSIb3DQEBCwUAA4IBAQCz +CQjW+raVw32vb3OLunuaXcrei1Z8eEQr0zITtGA9DcbbuQKFl9J9zMa+TK0vxHcn +od8bEehanjIOx6D2O3TuwV5eXL+RAFioC7AddhSzbqcgsJ1+0oiRSFaQphBnK0Hj +5OZMNtTCbt0/CyZShizv7KPik1gvdFUOEt7WQm8I1uSZAZiSxYdXale/ucZfZQE+ +XdCZPzR3aHvMsMyEoYieKnd+N5pm73eI7dsDCmqLbxRkzMpJ44RulESU19u8at8d +YtKNmgWGOal2SpLK1CEBZQcwFUQ49BYJZxwoELzy6r2zUbq2nWOJh+Y0uYfrIq0S +Cw2lw/2U3KEgHbFZAjd3 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDMTCCAhmgAwIBAgIEDOfhBzANBgkqhkiG9w0BAQsFADAlMSMwIQYDVQQDDBpD +ZXJ0IEV2ZW50cyBJbnQgUGF0aCBMZW4gMDAeFw0yNTAxMDEwMDAwMDBaFw00OTEy +MzEyMzU5NTlaMCsxKTAnBgNVBAMMIENlcnQgRXZlbnRzIEludCBCZWxvdyBQYXRo +IExlbiAwMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAz8k9WQGfHXeR +VsurBoLBgTGa4vnG+aNALYZC119BpQVCD18ra70pkuVSxlz5fp37jtZpjAORhxwf +vyRZRMzvr5IqBuGhAVsEV4oatgTiwjwQPEIxAarD8jIeAZXQkadmwSJoNlMqUgPr +tZuCAST50a77U0xaBuVuWtasWygaU+jXpc5unDTDCAvLL47f74w19bC8XQ+uCkrP +VAHSPLR47kgQVoBPg4dOZx9PFy4+LfVtyQeiPjKSDx6kC1WmH4TvnXXvZnx19+dA +OpzBM0I9L3+ZXXsE1alsQeiJFlj9OqAEvXfWY15qE1k3X/FZAUVInIv3FvRQ91q0 +WjP29UHBPQIDAQABo2MwYTAdBgNVHQ4EFgQUtVNmdAZJ+vP117kMVA1vUhXOjjsw +HwYDVR0jBBgwFoAU1STzDLoSGSxlZdsq0JKPmRNWes8wDwYDVR0TAQH/BAUwAwEB +/zAOBgNVHQ8BAf8EBAMCAQYwDQYJKoZIhvcNAQELBQADggEBAF8swcw3zBIwEpo3 +bNoUdwQbxOsEjllRW3ntFrXOQIN+CaeUZS4m3gFWcxc+I+BWNG9xI1MUe4e2ONB3 +rVssRcb+EwhbsBdy69wfozme4mz4TPwvCScFskBx8JTlSYmkUlIvriG/DOnxnh5V +VPz3d7PZMG8Xfs5gCmiA9Ce92dVMCvS9iLO7E7s2s8tNS4BXg7jHkErT3EXl/Em5 +PDWAB78w+Hi+BdSObrQXyqJFbvH3EU+JUp8bopC1c1kpuGaio3+BCvLjq3QWxxVq +tIQY7X4igZ6eHBwqdgPdMRrqP0w2Pxrvk2LgmIiaBVINupZuAxcp3bSbFC/9JvFR +GzYwgPQ= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDnzCCAoegAwIBAgIEDOfhCTANBgkqhkiG9w0BAQsFADCBlTELMAkGA1UEBhMC +VVMxEDAOBgNVBAgMB01vbnRhbmExEDAOBgNVBAcMB0JvemVtYW4xETAPBgNVBAoM +CFNhd3Rvb3RoMRMwEQYDVQQLDApDb25zdWx0aW5nMRgwFgYDVQQDDA93d3cud29s +ZnNzbC5jb20xIDAeBgkqhkiG9w0BCQEWEWZhY3RzQHdvbGZzc2wuY29tMB4XDTI1 +MDEwMTAwMDAwMFoXDTQ5MTIzMTIzNTk1OVowJTEjMCEGA1UEAwwaQ2VydCBFdmVu +dHMgSW50IFBhdGggTGVuIDAwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB +AQDDonNdIWIgzjpxOKeUu9uHBBxaG55LDT7K+KX3DWrcI5AiaitYY0ooakio53Mf +olXYTQI74str4oPJUY93/dwtXSO3I5p+tilo6CpOqf4ycDGe8O/u+I3j/PPXKN16 +HZ6tIyvxpn80Uilm0uVkVWTW3UtBO1WDbsARDm4gwhZz6zD/CUa758zGA0RBEcbB +bDYvSvmRVcpYXje4KBAwiUCWd89wZqRV+2kL59myM2Xbcjp3tytJ/LbNWBCNq6rL +QEV3AjkYs48zAUh3UL6Oc6feNqBJjiwWr7n7Qi01ats0N9UUWX1lcuWLZVVLIF5H ++fg602zZOvXHAUYxw3maGL5JAgMBAAGjZjBkMB0GA1UdDgQWBBTVJPMMuhIZLGVl +2yrQko+ZE1Z6zzAfBgNVHSMEGDAWgBQnjmcRdMMmHT/tM2OzpNgdMOXo1TASBgNV +HRMBAf8ECDAGAQH/AgEAMA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQsFAAOC +AQEArg2UeBHCzg64mtL7TjeqMHeCGWOHRcRsFAVOXMCv1X+5wDILGGeDj+R6LKCR +0lQ+pwCXTE4vPaD0wT1KmxamDxu2IkKyFWhO9sXUoeu+9gGf/bNiLQFcUrJfWcDm +7Kr/q2dHxgk3BiRog5c+mgVIn398HmECEE07KPL/+HmPn+Xq7m6ZepvvCKPmYJiV +HsURIJlyIRJub5Gqc9Q4/9uyw0uKKicwaJBS//LAHJrqgTHm3nwXdt1dEQnsVDbt +bpgxKHEcZAg3k6KrWpBY0BeyBbMler/B1FDvglmQNvwG3m6JnkTvN3GHfk5Jswe/ +49t0gvVXrtDazlmtqm8Pmhx2CQ== +-----END CERTIFICATE----- diff --git a/certs/test/cert-events/chain-signer-no-certsign.pem b/certs/test/cert-events/chain-signer-no-certsign.pem new file mode 100644 index 00000000000..e23ad134337 --- /dev/null +++ b/certs/test/cert-events/chain-signer-no-certsign.pem @@ -0,0 +1,44 @@ +-----BEGIN CERTIFICATE----- +MIIDlzCCAn+gAwIBAgIEDOfhBTANBgkqhkiG9w0BAQsFADAnMSUwIwYDVQQDDBxD +ZXJ0IEV2ZW50cyBJbnQgTm8gQ2VydCBTaWduMB4XDTI1MDEwMTAwMDAwMFoXDTQ5 +MTIzMTIzNTk1OVowgZExCzAJBgNVBAYTAlVTMRAwDgYDVQQIDAdNb250YW5hMRAw +DgYDVQQHDAdCb3plbWFuMRAwDgYDVQQKDAd3b2xmU1NMMRAwDgYDVQQLDAdTdXBw +b3J0MRgwFgYDVQQDDA93d3cud29sZnNzbC5jb20xIDAeBgkqhkiG9w0BCQEWEWZh +Y3RzQHdvbGZzc2wuY29tMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA +wJUI4VdB8nFtt9JFQScBZcZFrvK8JDC4lc4vTtb2HIi8fJ/7qGd//lycUXX3isoH +5zUvj+G9e8AvfKtkqBf8yl17uuAh5XIuby6G2JVz2qwbU7lfP9cZDSVP4WNjUYsL +ZD+tQ7ilHFw0s64AoGPF9n8LWWh4c6aMGKkCba/DGQEuuBDjxsxAtGmjRjNph27E +uxem8+jdrXO8ey8htf1mUQy9VLPhbV8cvCNz0QkDiRTSELlkwyrQoZZKvOHUGlvH +oMDBY3gPRDcwMpaAMiOVoXe6E9KXc+JdJclqDcM5YKS0sGlCQgnp2Ai8MyCzWCKn +quvE4eZhg8XSlt/Z0E+t1wIDAQABo2AwXjAdBgNVHQ4EFgQU4bSgzt4DOPCu9aPI +iNUM8edRoTEwHwYDVR0jBBgwFoAU1STzDLoSGSxlZdsq0JKPmRNWes8wDAYDVR0T +AQH/BAIwADAOBgNVHQ8BAf8EBAMCBaAwDQYJKoZIhvcNAQELBQADggEBAL0W4MsN +3twP4O/NGU0YBCWgQTehvpP7ZdztPFuZcn7Uw9nqjsNGg/De8cwKx3/TNtafaQ9Z +/gElj5PBGsvc4V/Lr2BjW7hGBiB46O2OvAtyeIj82jjst5ZKDU67tvFfBAq1WcTN +biGPglbUBkTPatPnsMmnWtf6aYvJwpvXxPhNeCORGPzNsICw8/erVAUPEpKTg+Bp +yy58dmEjX2ebhVJJx56rpdeNMdQyVbTgrIs0l6vYegSMka9+8Xnmd5UkkIZPotuu +plmWGJ8mv80z+WWaUNwdqSSkBPSOw0nOA9LL8QQZ0azeEXnQRQqOPNGo8tlPEOGt +nP7FN7jo4ACAwCY= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDnjCCAoagAwIBAgIEDOfhBjANBgkqhkiG9w0BAQsFADCBlTELMAkGA1UEBhMC +VVMxEDAOBgNVBAgMB01vbnRhbmExEDAOBgNVBAcMB0JvemVtYW4xETAPBgNVBAoM +CFNhd3Rvb3RoMRMwEQYDVQQLDApDb25zdWx0aW5nMRgwFgYDVQQDDA93d3cud29s +ZnNzbC5jb20xIDAeBgkqhkiG9w0BCQEWEWZhY3RzQHdvbGZzc2wuY29tMB4XDTI1 +MDEwMTAwMDAwMFoXDTQ5MTIzMTIzNTk1OVowJzElMCMGA1UEAwwcQ2VydCBFdmVu +dHMgSW50IE5vIENlcnQgU2lnbjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC +ggEBAMOic10hYiDOOnE4p5S724cEHFobnksNPsr4pfcNatwjkCJqK1hjSihqSKjn +cx+iVdhNAjviy2vig8lRj3f93C1dI7cjmn62KWjoKk6p/jJwMZ7w7+74jeP889co +3Xodnq0jK/GmfzRSKWbS5WRVZNbdS0E7VYNuwBEObiDCFnPrMP8JRrvnzMYDREER +xsFsNi9K+ZFVylheN7goEDCJQJZ3z3BmpFX7aQvn2bIzZdtyOne3K0n8ts1YEI2r +qstARXcCORizjzMBSHdQvo5zp942oEmOLBavuftCLTVq2zQ31RRZfWVy5YtlVUsg +Xkf5+DrTbNk69ccBRjHDeZoYvkkCAwEAAaNjMGEwHQYDVR0OBBYEFNUk8wy6Ehks +ZWXbKtCSj5kTVnrPMB8GA1UdIwQYMBaAFCeOZxF0wyYdP+0zY7Ok2B0w5ejVMA8G +A1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgeAMA0GCSqGSIb3DQEBCwUAA4IB +AQBtYp7VKBfbxDzwVvIj0mIRImJxndgvoP5xhieeIzfDubZfbdsLJvZq2XDLlI2p +dwnyCHNdLShq39salj8xeCE34QaiwBGrARqvd6CBOJ1vs4Xb0BNlWuRoQa0cnw9x +oRb61apTJwtzTgFTxeOA/OcTwUaOBYnRLucGU5awy5ecGkUOpbqqd5hA2KBr9/bq +ullwRNzjzwPupuPJc1W6WvfXzi3hxmT487F0XLwhlWTDGqkbM+KfE1vZsVScCs+r +VZmgcCw8sIvMp3U9Y/v/I+vnrrNU52vUlfr+4oyBt2UBoWiNcT03uFtLichAR3lZ +w6fHwSp1UphPOiQH67zF0JKp +-----END CERTIFICATE----- diff --git a/certs/test/cert-events/chain-signer-not-ca.pem b/certs/test/cert-events/chain-signer-not-ca.pem new file mode 100644 index 00000000000..a64e5da76c8 --- /dev/null +++ b/certs/test/cert-events/chain-signer-not-ca.pem @@ -0,0 +1,44 @@ +-----BEGIN CERTIFICATE----- +MIIDkTCCAnmgAwIBAgIEDOfhAzANBgkqhkiG9w0BAQsFADAhMR8wHQYDVQQDDBZD +ZXJ0IEV2ZW50cyBJbnQgTm90IENBMB4XDTI1MDEwMTAwMDAwMFoXDTQ5MTIzMTIz +NTk1OVowgZExCzAJBgNVBAYTAlVTMRAwDgYDVQQIDAdNb250YW5hMRAwDgYDVQQH +DAdCb3plbWFuMRAwDgYDVQQKDAd3b2xmU1NMMRAwDgYDVQQLDAdTdXBwb3J0MRgw +FgYDVQQDDA93d3cud29sZnNzbC5jb20xIDAeBgkqhkiG9w0BCQEWEWZhY3RzQHdv +bGZzc2wuY29tMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAwJUI4VdB +8nFtt9JFQScBZcZFrvK8JDC4lc4vTtb2HIi8fJ/7qGd//lycUXX3isoH5zUvj+G9 +e8AvfKtkqBf8yl17uuAh5XIuby6G2JVz2qwbU7lfP9cZDSVP4WNjUYsLZD+tQ7il +HFw0s64AoGPF9n8LWWh4c6aMGKkCba/DGQEuuBDjxsxAtGmjRjNph27Euxem8+jd +rXO8ey8htf1mUQy9VLPhbV8cvCNz0QkDiRTSELlkwyrQoZZKvOHUGlvHoMDBY3gP +RDcwMpaAMiOVoXe6E9KXc+JdJclqDcM5YKS0sGlCQgnp2Ai8MyCzWCKnquvE4eZh +g8XSlt/Z0E+t1wIDAQABo2AwXjAdBgNVHQ4EFgQU4bSgzt4DOPCu9aPIiNUM8edR +oTEwHwYDVR0jBBgwFoAU1STzDLoSGSxlZdsq0JKPmRNWes8wDAYDVR0TAQH/BAIw +ADAOBgNVHQ8BAf8EBAMCBaAwDQYJKoZIhvcNAQELBQADggEBAJJMWcibCn6Q7dwN +HoYqGsLcQSO1jvGEcSrHmzL2RSkXnfZ5ffE+r+A4lkyj/lERu0+6qkcby8qn1OYH +EqSHAL8ax0m0UXWBCSGf4iag5Yls4dsTmCKRQlfPa5wW/ZaPivYZkKW2hwzJj+Rk +0kuYo4v1jNDVRj7t94pAqODcLmZ2UhxgEselcAUIh3HjCrpXzdxMmXKH6Q2saxBV +emqsrE1Mk21g89mfNI9oo6NaBSgRR1SMKwxWcce52w6MGotyxSFdv+vPQsvTU6Sb +aZE+efUslUxdXY7rktoNuIAL0miU2ktpXm5Ay7RfooY/Vy093jLEXkjOzfJje283 +bmRUXSs= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDlTCCAn2gAwIBAgIEDOfhBDANBgkqhkiG9w0BAQsFADCBlTELMAkGA1UEBhMC +VVMxEDAOBgNVBAgMB01vbnRhbmExEDAOBgNVBAcMB0JvemVtYW4xETAPBgNVBAoM +CFNhd3Rvb3RoMRMwEQYDVQQLDApDb25zdWx0aW5nMRgwFgYDVQQDDA93d3cud29s +ZnNzbC5jb20xIDAeBgkqhkiG9w0BCQEWEWZhY3RzQHdvbGZzc2wuY29tMB4XDTI1 +MDEwMTAwMDAwMFoXDTQ5MTIzMTIzNTk1OVowITEfMB0GA1UEAwwWQ2VydCBFdmVu +dHMgSW50IE5vdCBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMOi +c10hYiDOOnE4p5S724cEHFobnksNPsr4pfcNatwjkCJqK1hjSihqSKjncx+iVdhN +Ajviy2vig8lRj3f93C1dI7cjmn62KWjoKk6p/jJwMZ7w7+74jeP889co3Xodnq0j +K/GmfzRSKWbS5WRVZNbdS0E7VYNuwBEObiDCFnPrMP8JRrvnzMYDREERxsFsNi9K ++ZFVylheN7goEDCJQJZ3z3BmpFX7aQvn2bIzZdtyOne3K0n8ts1YEI2rqstARXcC +ORizjzMBSHdQvo5zp942oEmOLBavuftCLTVq2zQ31RRZfWVy5YtlVUsgXkf5+DrT +bNk69ccBRjHDeZoYvkkCAwEAAaNgMF4wHQYDVR0OBBYEFNUk8wy6EhksZWXbKtCS +j5kTVnrPMB8GA1UdIwQYMBaAFCeOZxF0wyYdP+0zY7Ok2B0w5ejVMAwGA1UdEwEB +/wQCMAAwDgYDVR0PAQH/BAQDAgWgMA0GCSqGSIb3DQEBCwUAA4IBAQAxkqgrxPAW ++FbOyF8YzlRz9C8uT8P3yx38sl9sSZm9+P3Egd1bEHkCmWmrHZHQYG6IZuR2YEnd +Ibz8BhURDIf2pZKbJepF5rVlh5GVwvpoCBIzu7ZvK9MoaiQbYufk92OUkFqXcpvF +vMZK73o+IY3bidT92KUXZxTO9NnOAYfV04NAX9+BgkN6uCHzf+GeayrS/yv6JmO4 ++JITj33HwJzye8k1CIsziBz82nlGc+58n+4eI5myaMjdsNCr1JWE7ulQmm+iqOo0 +HvqUV6KXDLy2x9bTtCnBDfRWEFrSPfJAxMfCBX/S9QmtZO4cfxnkIy75lR1TPnw2 +icULR9nrcurI +-----END CERTIFICATE----- diff --git a/certs/test/cert-events/crldp-malformed.der b/certs/test/cert-events/crldp-malformed.der new file mode 100644 index 00000000000..5180bfc7771 Binary files /dev/null and b/certs/test/cert-events/crldp-malformed.der differ diff --git a/certs/test/cert-events/eku-malformed.der b/certs/test/cert-events/eku-malformed.der new file mode 100644 index 00000000000..ee2ec936e89 Binary files /dev/null and b/certs/test/cert-events/eku-malformed.der differ diff --git a/certs/test/cert-events/good.der b/certs/test/cert-events/good.der new file mode 100644 index 00000000000..226c5f2b072 Binary files /dev/null and b/certs/test/cert-events/good.der differ diff --git a/certs/test/cert-events/issuer-malformed.der b/certs/test/cert-events/issuer-malformed.der new file mode 100644 index 00000000000..60d54635202 Binary files /dev/null and b/certs/test/cert-events/issuer-malformed.der differ diff --git a/certs/test/cert-events/issuer-uid.der b/certs/test/cert-events/issuer-uid.der new file mode 100644 index 00000000000..48b09db0043 Binary files /dev/null and b/certs/test/cert-events/issuer-uid.der differ diff --git a/certs/test/cert-events/ku-malformed.der b/certs/test/cert-events/ku-malformed.der new file mode 100644 index 00000000000..91ebd0fe334 Binary files /dev/null and b/certs/test/cert-events/ku-malformed.der differ diff --git a/certs/test/cert-events/leaf-bad-signature.der b/certs/test/cert-events/leaf-bad-signature.der new file mode 100644 index 00000000000..6eef306278d Binary files /dev/null and b/certs/test/cert-events/leaf-bad-signature.der differ diff --git a/certs/test/cert-events/leaf-unknown-issuer.der b/certs/test/cert-events/leaf-unknown-issuer.der new file mode 100644 index 00000000000..73f0ec66bc6 Binary files /dev/null and b/certs/test/cert-events/leaf-unknown-issuer.der differ diff --git a/certs/test/cert-events/policy-malformed.der b/certs/test/cert-events/policy-malformed.der new file mode 100644 index 00000000000..b127c188f23 Binary files /dev/null and b/certs/test/cert-events/policy-malformed.der differ diff --git a/certs/test/cert-events/san-malformed.der b/certs/test/cert-events/san-malformed.der new file mode 100644 index 00000000000..f85223ff83c Binary files /dev/null and b/certs/test/cert-events/san-malformed.der differ diff --git a/certs/test/cert-events/serial-empty.der b/certs/test/cert-events/serial-empty.der new file mode 100644 index 00000000000..1cd5ecf19e0 Binary files /dev/null and b/certs/test/cert-events/serial-empty.der differ diff --git a/certs/test/cert-events/serial-not-integer.der b/certs/test/cert-events/serial-not-integer.der new file mode 100644 index 00000000000..cc93681dedc Binary files /dev/null and b/certs/test/cert-events/serial-not-integer.der differ diff --git a/certs/test/cert-events/sigalg-mismatch.der b/certs/test/cert-events/sigalg-mismatch.der new file mode 100644 index 00000000000..d3e67377a22 Binary files /dev/null and b/certs/test/cert-events/sigalg-mismatch.der differ diff --git a/certs/test/cert-events/signature-not-bitstring.der b/certs/test/cert-events/signature-not-bitstring.der new file mode 100644 index 00000000000..35c082225fa Binary files /dev/null and b/certs/test/cert-events/signature-not-bitstring.der differ diff --git a/certs/test/cert-events/skid-malformed.der b/certs/test/cert-events/skid-malformed.der new file mode 100644 index 00000000000..1c9ee95e2c7 Binary files /dev/null and b/certs/test/cert-events/skid-malformed.der differ diff --git a/certs/test/cert-events/spki-bad-bitstring.der b/certs/test/cert-events/spki-bad-bitstring.der new file mode 100644 index 00000000000..aff7ad4419c Binary files /dev/null and b/certs/test/cert-events/spki-bad-bitstring.der differ diff --git a/certs/test/cert-events/spki-unknown-alg.der b/certs/test/cert-events/spki-unknown-alg.der new file mode 100644 index 00000000000..201e57f981d Binary files /dev/null and b/certs/test/cert-events/spki-unknown-alg.der differ diff --git a/certs/test/cert-events/subject-malformed.der b/certs/test/cert-events/subject-malformed.der new file mode 100644 index 00000000000..8c9a94f6140 Binary files /dev/null and b/certs/test/cert-events/subject-malformed.der differ diff --git a/certs/test/cert-events/subject-uid.der b/certs/test/cert-events/subject-uid.der new file mode 100644 index 00000000000..3d027a4d777 Binary files /dev/null and b/certs/test/cert-events/subject-uid.der differ diff --git a/certs/test/cert-events/tbs-sigalg-unknown.der b/certs/test/cert-events/tbs-sigalg-unknown.der new file mode 100644 index 00000000000..d8f95146d2b Binary files /dev/null and b/certs/test/cert-events/tbs-sigalg-unknown.der differ diff --git a/certs/test/cert-events/trailing-data.der b/certs/test/cert-events/trailing-data.der new file mode 100644 index 00000000000..3de0e2f4ff9 Binary files /dev/null and b/certs/test/cert-events/trailing-data.der differ diff --git a/certs/test/cert-events/unknown-critical.der b/certs/test/cert-events/unknown-critical.der new file mode 100644 index 00000000000..b705fbef21a Binary files /dev/null and b/certs/test/cert-events/unknown-critical.der differ diff --git a/certs/test/cert-events/validity-not-time.der b/certs/test/cert-events/validity-not-time.der new file mode 100644 index 00000000000..126a05bdcd0 Binary files /dev/null and b/certs/test/cert-events/validity-not-time.der differ diff --git a/certs/test/cert-events/version-not-integer.der b/certs/test/cert-events/version-not-integer.der new file mode 100644 index 00000000000..c236e5030ae Binary files /dev/null and b/certs/test/cert-events/version-not-integer.der differ diff --git a/certs/test/cert-events/version-unsupported.der b/certs/test/cert-events/version-unsupported.der new file mode 100644 index 00000000000..dac17cf3912 Binary files /dev/null and b/certs/test/cert-events/version-unsupported.der differ diff --git a/certs/test/gen-cert-events.py b/certs/test/gen-cert-events.py new file mode 100644 index 00000000000..204c995833c --- /dev/null +++ b/certs/test/gen-cert-events.py @@ -0,0 +1,455 @@ +#!/usr/bin/env python3 +""" + Generates certs/test/cert-events/*.der, the certificates used by the + certificate validation event tests in tests/api/test_certman.c. + + Each certificate is a copy of certs/server-cert.der (same subject and + public key) with exactly one defect, signed again with certs/ca-key.pem. + Signing again matters: verification then reaches the defect instead of + stopping at a bad signature. good.der has no defect and must verify. + + Defects in an extension are placed inside the extension's OCTET STRING, + so the certificate as a whole is still valid DER. Defects in other fields + break the encoding of that field only. + + The validity period runs to 2049, so the certificates do not need to be + renewed with the other test certificates. The CA must still be the one in + certs/ca-cert.pem: run this again if that CA's key changes. + + The chain-*.pem files are certificate chains for a TLS server using + certs/server-key.pem: the server's certificate first, then the CAs it + sends. Their CAs use the keys in certs/intermediate/ and lead up to + certs/ca-cert.pem. + + Requires: Python 3 and an openssl command line tool (no Python packages). + Usage: python3 ./certs/test/gen-cert-events.py + (run from the top of the wolfSSL source tree) +""" +import base64 +import hashlib +import os +import subprocess +import tempfile + +SRC_CERT = './certs/server-cert.der' +CA_CERT = './certs/ca-cert.der' +CA_KEY = './certs/ca-key.pem' +SERVER_KEY = './certs/server-key.pem' +INT_KEY = './certs/intermediate/ca-int-key.pem' +INT2_KEY = './certs/intermediate/ca-int2-key.pem' +OUT_DIR = './certs/test/cert-events' + +# UTCTime, YYMMDDHHMMSSZ. 49 maps to 2049 per RFC 5280 4.1.2.5.1. +NOT_BEFORE = '250101000000Z' +NOT_AFTER = '491231235959Z' +FIRST_SERIAL = 0x0CE7E000 + +OID_SHA256_RSA = '1.2.840.113549.1.1.11' +OID_SKID = '2.5.29.14' +OID_KEY_USAGE = '2.5.29.15' +OID_ALT_NAMES = '2.5.29.17' +OID_BASIC_CA = '2.5.29.19' +OID_CRL_DIST = '2.5.29.31' +OID_CERT_POLICY = '2.5.29.32' +OID_AKID = '2.5.29.35' +OID_EXT_KEY_USAGE = '2.5.29.37' +OID_AUTH_INFO = '1.3.6.1.5.5.7.1.1' +OID_UNKNOWN = '1.3.6.1.4.1.99999.1' +OID_SHA384_RSA = '1.2.840.113549.1.1.12' +OID_COMMON_NAME = '2.5.4.3' +OID_CLIENT_AUTH = '1.3.6.1.5.5.7.3.2' + +# Inside an extension value: a SEQUENCE whose first element claims more bytes +# than there are. The outer certificate stays valid DER. +TRUNCATED_INNER = bytes([0x30, 0x03, 0x30, 0x05, 0x00]) + + +def tlv(tag: int, value: bytes) -> bytes: + """Encode one DER tag, length and value.""" + n = len(value) + if n < 0x80: + length = bytes([n]) + else: + enc = n.to_bytes((n.bit_length() + 7) // 8, 'big') + length = bytes([0x80 | len(enc)]) + enc + return bytes([tag]) + length + value + + +def der_sequence(*items: bytes) -> bytes: + return tlv(0x30, b''.join(items)) + + +def der_oid(dotted: str) -> bytes: + arcs = [int(a) for a in dotted.split('.')] + body = bytes([arcs[0] * 40 + arcs[1]]) + for arc in arcs[2:]: + enc = [arc & 0x7f] + arc >>= 7 + while arc: + enc.insert(0, 0x80 | (arc & 0x7f)) + arc >>= 7 + body += bytes(enc) + return tlv(0x06, body) + + +def der_integer(value: int) -> bytes: + body = value.to_bytes((value.bit_length() + 8) // 8, 'big') + return tlv(0x02, body) + + +def der_octet_string(value: bytes) -> bytes: + return tlv(0x04, value) + + +def read_tlv(data: bytes, idx: int): + """Return (tag, header length, value length) of the TLV at idx.""" + tag = data[idx] + n = data[idx + 1] + if n < 0x80: + return tag, 2, n + cnt = n & 0x7f + return tag, 2 + cnt, int.from_bytes(data[idx + 2:idx + 2 + cnt], 'big') + + +def children(data: bytes) -> list: + """Split the value of a constructed TLV into its encoded children.""" + out = [] + idx = 0 + while idx < len(data): + _, hdr, n = read_tlv(data, idx) + out.append(data[idx:idx + hdr + n]) + idx += hdr + n + return out + + +def value_of(encoded: bytes) -> bytes: + _, hdr, n = read_tlv(encoded, 0) + return encoded[hdr:hdr + n] + + +def extension(oid: str, value: bytes, critical: bool = False) -> bytes: + crit = tlv(0x01, b'\xff') if critical else b'' + return der_sequence(der_oid(oid), crit, der_octet_string(value)) + + +def load_parts(): + """Subject, issuer and key come from the existing test certificates.""" + with open(SRC_CERT, 'rb') as f: + tbs = children(value_of(f.read()))[0] + fields = children(value_of(tbs)) + # version, serial, signature, issuer, validity, subject, spki, ... + subject, spki = fields[5], fields[6] + with open(CA_CERT, 'rb') as f: + ca_tbs = children(value_of(f.read()))[0] + ca_fields = children(value_of(ca_tbs)) + issuer = ca_fields[5] + ca_skid = None + for f_ in ca_fields: + if f_[0] == 0xa3: + for ext in children(value_of(children(value_of(f_))[0])): + parts = children(value_of(ext)) + if parts[0] == der_oid(OID_SKID): + ca_skid = value_of(value_of(parts[-1])) + return subject, spki, issuer, ca_skid + + +def base_extensions(ca_skid: bytes) -> dict: + """The extensions of good.der, by name. Each defect replaces one.""" + return { + 'skid': extension(OID_SKID, der_octet_string(bytes(range(1, 21)))), + 'akid': extension(OID_AKID, der_sequence(tlv(0x80, ca_skid))), + 'bc': extension(OID_BASIC_CA, der_sequence(), critical=True), + # digitalSignature and keyEncipherment + 'ku': extension(OID_KEY_USAGE, tlv(0x03, b'\x05\xa0'), critical=True), + } + + +def bad_name(parts): + """A Name whose RDN holds an INTEGER where a SET is expected.""" + return der_sequence(der_integer(5)) + + +def unknown_key_spki(parts): + """The real key under an unknown algorithm OID.""" + spki = children(value_of(parts[1])) + return der_sequence(der_sequence(der_oid(OID_UNKNOWN), tlv(0x05, b'')), + spki[1]) + + +def bad_bitstring_spki(parts): + """A subjectPublicKey BIT STRING claiming 9 unused bits.""" + spki = children(value_of(parts[1])) + key = value_of(spki[1]) + return der_sequence(spki[0], tlv(0x03, b'\x09' + key[1:])) + + +# Defects in fields other than extensions: field name -> replacement, or a +# function of the parts read from the existing certificates. +FIELD_CASES = { + 'version-unsupported': ('version is v6, which does not exist', + {'version': tlv(0xa0, der_integer(5))}), + 'version-not-integer': ('version is an OCTET STRING', + {'version': tlv(0xa0, der_octet_string(b'\x02'))}), + 'serial-empty': ('serialNumber is an INTEGER with no content', + {'serial': tlv(0x02, b'')}), + 'serial-not-integer': ('serialNumber is an OCTET STRING', + {'serial': der_octet_string(b'\x01\x02')}), + 'tbs-sigalg-unknown': ('signature algorithm in the TBS is unknown', + {'tbs_sig_alg': der_sequence(der_oid(OID_UNKNOWN), + tlv(0x05, b''))}), + 'issuer-malformed': ('issuer Name holds an INTEGER, not a SET', + {'issuer': bad_name}), + 'validity-not-time': ('notBefore is an OCTET STRING, not a time', + {'validity': der_sequence( + der_octet_string(b'250101000000Z'), + tlv(0x17, NOT_AFTER.encode()))}), + 'subject-malformed': ('subject Name holds an INTEGER, not a SET', + {'subject': bad_name}), + 'spki-unknown-alg': ('public key algorithm is unknown', + {'spki': unknown_key_spki}), + 'spki-bad-bitstring': ('public key BIT STRING claims 9 unused bits', + {'spki': bad_bitstring_spki}), + 'sigalg-mismatch': ('outer signature algorithm differs from the TBS one', + {'outer_sig_alg': der_sequence( + der_oid(OID_SHA384_RSA), tlv(0x05, b''))}), + 'signature-not-bitstring': ('signatureValue is an OCTET STRING', + {'sig_tag': 0x04}), + 'trailing-data': ('two bytes after the certificate', + {'trailing': b'\x00\x00'}), +} + +# name: (description, extensions to replace or add, unique IDs to add) +CASES = { + 'good': ('no defect: must verify', {}, b''), + 'ku-malformed': ('keyUsage is an OCTET STRING, not a BIT STRING', + {'ku': extension(OID_KEY_USAGE, der_octet_string(b'\xa0'), + critical=True)}, b''), + 'bc-malformed': ('basicConstraints cA is a 2-byte BOOLEAN', + {'bc': extension(OID_BASIC_CA, + der_sequence(tlv(0x01, b'\xff\xff')), + critical=True)}, b''), + 'akid-malformed': ('authorityKeyIdentifier is not a SEQUENCE', + {'akid': extension(OID_AKID, + der_octet_string(b'\x00\x00'))}, b''), + 'skid-malformed': ('subjectKeyIdentifier is not an OCTET STRING', + {'skid': extension(OID_SKID, der_sequence())}, b''), + 'eku-malformed': ('extendedKeyUsage holds an INTEGER, not an OID', + {'eku': extension(OID_EXT_KEY_USAGE, + der_sequence(der_integer(1)))}, b''), + 'san-malformed': ('subjectAltName entry claims more bytes than it has', + {'san': extension(OID_ALT_NAMES, + bytes([0x30, 0x03, 0x82, 0x05, + 0x61]))}, b''), + 'crldp-malformed': ('cRLDistributionPoints is truncated inside', + {'crldp': extension(OID_CRL_DIST, TRUNCATED_INNER)}, + b''), + 'aia-malformed': ('authorityInfoAccess is truncated inside', + {'aia': extension(OID_AUTH_INFO, TRUNCATED_INNER)}, b''), + 'policy-malformed': ('certificatePolicies is truncated inside', + {'policy': extension(OID_CERT_POLICY, + TRUNCATED_INNER)}, b''), + 'unknown-critical': ('an unknown extension marked critical', + {'unknown': extension(OID_UNKNOWN, b'\x05\x00', + critical=True)}, b''), + 'issuer-uid': ('issuerUniqueID present', + {}, tlv(0x81, b'\x00\xab\xcd')), + 'subject-uid': ('subjectUniqueID present', + {}, tlv(0x82, b'\x00\xab\xcd')), +} + + +def sign(tbs: bytes, key: str = CA_KEY) -> bytes: + with tempfile.TemporaryDirectory() as tmp: + tbs_file = os.path.join(tmp, 'tbs.der') + sig_file = os.path.join(tmp, 'sig.bin') + with open(tbs_file, 'wb') as f: + f.write(tbs) + subprocess.run(['openssl', 'dgst', '-sha256', '-sign', key, + '-out', sig_file, tbs_file], check=True) + with open(sig_file, 'rb') as f: + return f.read() + + +def public_key(key: str) -> bytes: + """SubjectPublicKeyInfo of an RSA private key file.""" + out = subprocess.run(['openssl', 'rsa', '-in', key, '-pubout', + '-outform', 'DER'], check=True, + capture_output=True) + return out.stdout + + +def name(common_name: str) -> bytes: + atv = der_sequence(der_oid(OID_COMMON_NAME), + tlv(0x0c, common_name.encode())) + return der_sequence(tlv(0x31, atv)) + + +def chain_cert(serial: int, subject: bytes, spki: bytes, issuer: bytes, + issuer_skid: bytes, key: str, ca: bool = False, + path_len: int = None, key_usage: bytes = None, + eku: list = None) -> bytes: + """A certificate for a chain, with the extensions a CA or leaf needs.""" + sig_alg = der_sequence(der_oid(OID_SHA256_RSA), tlv(0x05, b'')) + validity = der_sequence(tlv(0x17, NOT_BEFORE.encode()), + tlv(0x17, NOT_AFTER.encode())) + bc = tlv(0x01, b'\xff') if ca else b'' + if path_len is not None: + bc += der_integer(path_len) + if key_usage is None: + # keyCertSign and cRLSign for a CA; else digitalSignature and + # keyEncipherment + key_usage = b'\x01\x06' if ca else b'\x05\xa0' + exts = [ + extension(OID_SKID, der_octet_string(skid_of(spki))), + extension(OID_AKID, der_sequence(tlv(0x80, issuer_skid))), + extension(OID_BASIC_CA, der_sequence(bc), critical=True), + extension(OID_KEY_USAGE, tlv(0x03, key_usage), critical=True), + ] + if eku is not None: + exts.append(extension(OID_EXT_KEY_USAGE, + der_sequence(*[der_oid(o) for o in eku]))) + tbs = der_sequence(tlv(0xa0, der_integer(2)), der_integer(serial), + sig_alg, issuer, validity, subject, spki, + tlv(0xa3, der_sequence(*exts))) + return der_sequence(tbs, sig_alg, tlv(0x03, b'\x00' + sign(tbs, key))) + + +def skid_of(spki: bytes) -> bytes: + return hashlib.sha1(spki).digest() + + +def pem(der: bytes) -> str: + b64 = base64.b64encode(der).decode() + lines = [b64[i:i + 64] for i in range(0, len(b64), 64)] + return ('-----BEGIN CERTIFICATE-----\n' + '\n'.join(lines) + + '\n-----END CERTIFICATE-----\n') + + +def build_chains(parts, serial: int): + """Chains for a TLS server, and leaves that fail against their signer.""" + subject, spki, root, root_skid = parts + int_spki = public_key(INT_KEY) + int2_spki = public_key(INT2_KEY) + out = {} + + def next_serial(): + nonlocal serial + serial += 1 + return serial + + def ca_under_root(cn, **kw): + return chain_cert(next_serial(), name(cn), int_spki, root, + root_skid, CA_KEY, **kw) + + def leaf_under(cn, **kw): + return chain_cert(next_serial(), subject, spki, name(cn), + skid_of(int_spki), INT_KEY, **kw) + + # Good: server, then a CA signed by the root. + cn = 'Cert Events Int CA' + out['chain-good'] = ('a good chain', + [leaf_under(cn), ca_under_root(cn, ca=True)]) + # The server's signer is not a CA. + cn = 'Cert Events Int Not CA' + out['chain-signer-not-ca'] = ('the signer is not a CA', + [leaf_under(cn), ca_under_root(cn)]) + # The signer is a CA that may not sign certificates. + cn = 'Cert Events Int No Cert Sign' + out['chain-signer-no-certsign'] = ( + 'the signer has keyUsage without keyCertSign', + [leaf_under(cn), ca_under_root(cn, ca=True, key_usage=b'\x07\x80')]) + # A CA with pathLenConstraint 0 signs another CA. + cn = 'Cert Events Int Path Len 0' + cn2 = 'Cert Events Int Below Path Len 0' + int2 = chain_cert(next_serial(), name(cn2), int2_spki, name(cn), + skid_of(int_spki), INT_KEY, ca=True) + leaf = chain_cert(next_serial(), subject, spki, name(cn2), + skid_of(int2_spki), INT2_KEY) + out['chain-pathlen-exceeded'] = ( + 'a CA with pathLenConstraint 0 signs another CA', + [leaf, int2, ca_under_root(cn, ca=True, path_len=0)]) + + singles = { + # Claims the root as issuer, but signed with another key. + 'leaf-bad-signature': ('signed with a key other than the issuer\'s', + chain_cert(next_serial(), subject, spki, root, + root_skid, SERVER_KEY)), + 'leaf-unknown-issuer': ('issued by a CA nobody trusts', + chain_cert(next_serial(), subject, spki, + name('Cert Events Unknown CA'), + bytes(20), CA_KEY)), + } + + # Added later, so the serials above stay the same. The server's own + # certificate may not be used for this TLS connection. + cn = 'Cert Events Int CA' + out['chain-leaf-ku-no-digsig'] = ( + 'the server\'s keyUsage has keyEncipherment only', + [leaf_under(cn, key_usage=b'\x05\x20'), ca_under_root(cn, ca=True)]) + out['chain-leaf-eku-client-only'] = ( + 'the server\'s extendedKeyUsage allows clientAuth only', + [leaf_under(cn, eku=[OID_CLIENT_AUTH]), ca_under_root(cn, ca=True)]) + + return out, singles + + +def build(serial: int, exts: dict, uids: bytes, parts, + fields: dict = None) -> bytes: + subject, spki, issuer, _ = parts + sig_alg = der_sequence(der_oid(OID_SHA256_RSA), tlv(0x05, b'')) + f = { + 'version': tlv(0xa0, der_integer(2)), + 'serial': der_integer(serial), + 'tbs_sig_alg': sig_alg, + 'issuer': issuer, + 'validity': der_sequence(tlv(0x17, NOT_BEFORE.encode()), + tlv(0x17, NOT_AFTER.encode())), + 'subject': subject, + 'spki': spki, + 'outer_sig_alg': sig_alg, + 'sig_tag': 0x03, + 'trailing': b'', + } + for name, value in (fields or {}).items(): + f[name] = value(parts) if callable(value) else value + ext_block = tlv(0xa3, der_sequence(*exts.values())) + tbs = der_sequence(f['version'], f['serial'], f['tbs_sig_alg'], + f['issuer'], f['validity'], f['subject'], f['spki'], + uids, ext_block) + signature = tlv(f['sig_tag'], b'\x00' + sign(tbs)) + return der_sequence(tbs, f['outer_sig_alg'], signature) + f['trailing'] + + +def main(): + parts = load_parts() + if parts[3] is None: + raise SystemExit('CA certificate has no subjectKeyIdentifier') + os.makedirs(OUT_DIR, exist_ok=True) + jobs = [(name, desc, changes, uids, None) + for name, (desc, changes, uids) in CASES.items()] + jobs += [(name, desc, {}, b'', fields) + for name, (desc, fields) in FIELD_CASES.items()] + for i, (name, desc, changes, uids, fields) in enumerate(jobs): + exts = base_extensions(parts[3]) + exts.update(changes) + der = build(FIRST_SERIAL + i, exts, uids, parts, fields) + path = os.path.join(OUT_DIR, name + '.der') + with open(path, 'wb') as f: + f.write(der) + print('Created: %s (%s)' % (path, desc)) + + chains, singles = build_chains(parts, FIRST_SERIAL + 0x100) + for name_, (desc, certs) in chains.items(): + path = os.path.join(OUT_DIR, name_ + '.pem') + with open(path, 'w') as f: + f.write(''.join(pem(c) for c in certs)) + print('Created: %s (%s)' % (path, desc)) + for name_, (desc, der) in singles.items(): + path = os.path.join(OUT_DIR, name_ + '.der') + with open(path, 'wb') as f: + f.write(der) + print('Created: %s (%s)' % (path, desc)) + + +if __name__ == '__main__': + main() diff --git a/certs/test/include.am b/certs/test/include.am index a84dc109a29..caeac441c48 100644 --- a/certs/test/include.am +++ b/certs/test/include.am @@ -135,4 +135,39 @@ EXTRA_DIST += \ certs/test/alt-chain-forged-ca/gen-alt-chain-forged-ca.sh \ certs/test/alt-chain-forged-ca/realRoot-cert.pem \ certs/test/alt-chain-forged-ca/leaf-key.pem \ - certs/test/alt-chain-forged-ca/server-chain.pem + certs/test/alt-chain-forged-ca/server-chain.pem \ + certs/test/gen-cert-events.py \ + certs/test/cert-events/aia-malformed.der \ + certs/test/cert-events/akid-malformed.der \ + certs/test/cert-events/bc-malformed.der \ + certs/test/cert-events/chain-good.pem \ + certs/test/cert-events/chain-leaf-eku-client-only.pem \ + certs/test/cert-events/chain-leaf-ku-no-digsig.pem \ + certs/test/cert-events/chain-pathlen-exceeded.pem \ + certs/test/cert-events/chain-signer-no-certsign.pem \ + certs/test/cert-events/chain-signer-not-ca.pem \ + certs/test/cert-events/crldp-malformed.der \ + certs/test/cert-events/eku-malformed.der \ + certs/test/cert-events/good.der \ + certs/test/cert-events/issuer-malformed.der \ + certs/test/cert-events/issuer-uid.der \ + certs/test/cert-events/ku-malformed.der \ + certs/test/cert-events/leaf-bad-signature.der \ + certs/test/cert-events/leaf-unknown-issuer.der \ + certs/test/cert-events/policy-malformed.der \ + certs/test/cert-events/san-malformed.der \ + certs/test/cert-events/serial-empty.der \ + certs/test/cert-events/serial-not-integer.der \ + certs/test/cert-events/sigalg-mismatch.der \ + certs/test/cert-events/signature-not-bitstring.der \ + certs/test/cert-events/skid-malformed.der \ + certs/test/cert-events/spki-bad-bitstring.der \ + certs/test/cert-events/spki-unknown-alg.der \ + certs/test/cert-events/subject-malformed.der \ + certs/test/cert-events/subject-uid.der \ + certs/test/cert-events/tbs-sigalg-unknown.der \ + certs/test/cert-events/trailing-data.der \ + certs/test/cert-events/unknown-critical.der \ + certs/test/cert-events/validity-not-time.der \ + certs/test/cert-events/version-not-integer.der \ + certs/test/cert-events/version-unsupported.der diff --git a/cmake/options.h.in b/cmake/options.h.in index c19d8fc163d..160e9b54a20 100644 --- a/cmake/options.h.in +++ b/cmake/options.h.in @@ -337,6 +337,8 @@ extern "C" { #cmakedefine WOLFSSL_CERT_GEN #undef WOLFSSL_CERT_GEN_CACHE #cmakedefine WOLFSSL_CERT_GEN_CACHE +#undef WOLFSSL_CERT_EVENTS +#cmakedefine WOLFSSL_CERT_EVENTS #undef WOLFSSL_CERT_NAME_ALL #cmakedefine WOLFSSL_CERT_NAME_ALL #undef WOLFSSL_CERT_REQ diff --git a/configure.ac b/configure.ac index 811af03a738..13d57069277 100644 --- a/configure.ac +++ b/configure.ac @@ -1572,6 +1572,7 @@ then test "$enable_savecert" = "" && enable_savecert=yes test "$enable_postauth" = "" && enable_postauth=yes test "$enable_chain_verify_cb" = "" && enable_chain_verify_cb=yes + test "$enable_cert_events" = "" && enable_cert_events=yes test "$enable_hrrcookie" = "" && enable_hrrcookie=yes test "$enable_crl_monitor" = "" && enable_crl_monitor=yes test "$enable_sni" = "" && enable_sni=yes @@ -6362,6 +6363,19 @@ then fi +# CERTIFICATE VALIDATION EVENTS +AC_ARG_ENABLE([cert-events], + [AS_HELP_STRING([--enable-cert-events],[Enable structured certificate and CRL validation event callback (default: disabled)])], + [ ENABLED_CERT_EVENTS=$enableval ], + [ ENABLED_CERT_EVENTS=no ] + ) + +if test "$ENABLED_CERT_EVENTS" = "yes" +then + AM_CFLAGS="$AM_CFLAGS -DWOLFSSL_CERT_EVENTS" +fi + + # CERT SIGN CALLBACK AC_ARG_ENABLE([certsigncb], [AS_HELP_STRING([--enable-certsigncb],[Enable cert signing callback API for TPM/HSM (default: disabled)])], @@ -15350,6 +15364,7 @@ echo " * certgen: $ENABLED_CERTGEN" echo " * certreq: $ENABLED_CERTREQ" echo " * certext: $ENABLED_CERTEXT" echo " * certgencache: $ENABLED_certgencache" +echo " * cert events: $ENABLED_CERT_EVENTS" echo " * CHACHA: $ENABLED_CHACHA" echo " * XCHACHA: $ENABLED_XCHACHA" echo " * Hash DRBG: $ENABLED_HASHDRBG" diff --git a/doc/dox_comments/header_files/asn_public.h b/doc/dox_comments/header_files/asn_public.h index f940f0bff87..80faecb6c28 100644 --- a/doc/dox_comments/header_files/asn_public.h +++ b/doc/dox_comments/header_files/asn_public.h @@ -4267,6 +4267,39 @@ int wc_SetCustomExtension(Cert *cert, int critical, const char *oid, int wc_SetUnknownExtCallback(DecodedCert* cert, wc_UnknownExtCallback cb); +/*! + \ingroup ASN + + \brief This function registers a callback that observes validation events + while a certificate is parsed and verified without a Certificate Manager. + Requires WOLFSSL_CERT_EVENTS (--enable-cert-events). A Certificate Manager + sets this for the certificates it verifies; see + wolfSSL_CertManagerSetCertEventCb() for the events and their rules. + + \return 0 Returned on success. + \return BAD_FUNC_ARG Returned when cert is NULL. + + \param cert the DecodedCert struct that is to be associated with this + callback. + \param cb function to register as the event callback. NULL turns events + off. + \param ctx a pointer passed to the callback with each event. + + _Example_ + \code + DecodedCert cert; + + wc_InitDecodedCert(&cert, der, derSz, NULL); + wc_SetCertEventCallback(&cert, myCertEvent, myLogger); + ret = wc_ParseCert(&cert, CERT_TYPE, VERIFY, NULL); + wc_FreeDecodedCert(&cert); + \endcode + + \sa wolfSSL_CertManagerSetCertEventCb +*/ +int wc_SetCertEventCallback(DecodedCert* cert, WOLFSSL_CERT_EVENT_CB cb, + void* ctx); + /*! \ingroup ASN diff --git a/doc/dox_comments/header_files/ssl.h b/doc/dox_comments/header_files/ssl.h index 920183f4e1a..ab444872e89 100644 --- a/doc/dox_comments/header_files/ssl.h +++ b/doc/dox_comments/header_files/ssl.h @@ -12521,6 +12521,152 @@ int wolfSSL_CertManagerVerifyBuffer(WOLFSSL_CERT_MANAGER* cm, void wolfSSL_CertManagerSetVerify(WOLFSSL_CERT_MANAGER* cm, VerifyCallback verify_callback); +/*! + \ingroup CertManager + \brief Sets a callback that observes certificate validation events in the + Certificate Manager. Requires WOLFSSL_CERT_EVENTS (--enable-cert-events). + + Each failed certificate check raises a WC_CEV_KIND_DEFECT event that says + which certificate failed (role and chain depth), which field failed and + why. Checks on the connection rather than the certificate, + such as the host name and OCSP, are reported in the WC_CEV_KIND_RESULT + event's error only. + Each verification ends with a WC_CEV_KIND_RESULT event that holds the + final error, or 0 when the certificate was accepted. A defect followed by + a passed result means the verify callback allowed the failure. A TLS 1.2 + client that asked for the server's certificate status sends it once the + status was checked at ServerHelloDone, as revocation can still fail + there; that RESULT has no subject, issuer or serial. + The condition field holds a stable value for each kind of failure. + + The fields of WOLFSSL_CERT_EVENT, all defined in + wolfssl/wolfcrypt/asn_public.h: + + - size: sizeof(WOLFSSL_CERT_EVENT). Fields are only ever added at the + end, so check size before reading a newer one. + - kind: DEFECT or RESULT (enum wc_CertEventKind). + - category: a certificate or a CRL (enum wc_CertEventCategory). + - error: the wolfSSL error code, such as ASN_AFTER_DATE_E. 0 on a RESULT + that passed. + - role and depth: which object it is about (enum wc_CertEventRole) and + where it sits in the chain: 0 for the peer's certificate, 1 for the CA + that signed it, and so on. -1 when not known. + - field and reason: which part failed, by its RFC 5280 name, and why + (enum wc_CertEventField, enum wc_CertEventReason). + - condition: the stable key to map to your own codes (enum + wc_CertEventCondition). The values are named after the IEC 62351-9 and + IEC 62351-3 audit events and never change. + - extOID, extOidData, extOidSz and critical: the extension, when the field + is an extension. extOID is wolfSSL's OID sum and depends on the build; + extOidData holds the OID's content octets, the same in every build. + - der and derSz: the encoded certificate. + - subject, issuer, serial and serialSz: which certificate it is, as far + as it was decoded. The names are one-line strings. NULL when not known, + such as on a certificate that could not be decoded, and on the RESULT + of X509_verify_cert(). + - ssl: the WOLFSSL object whose handshake raised the event, so that the + application can tell which peer it was. NULL outside a handshake. + + The callback only observes: it cannot change the result. Use + wolfSSL_CertManagerSetVerify() to override a failure. The event and the + data it points to are only valid during the call and come from untrusted + input. The callback must not call back into this Certificate Manager and + may be called from several threads at once. + + \return WOLFSSL_SUCCESS on success. + \return BAD_FUNC_ARG when cm is NULL. + + \param cm a pointer to a WOLFSSL_CERT_MANAGER structure, created using + wolfSSL_CertManagerNew(). + \param cb the event callback. NULL turns events off. + \param ctx a pointer passed to the callback with each event. + + _Example_ + \code + #include + + static void myCertEvent(const WOLFSSL_CERT_EVENT* ev, void* ctx) + { + if (ev->kind == WC_CEV_KIND_DEFECT) { + // log ev->error, ev->role, ev->depth, ev->field and ev->reason + } + else { + // ev->error is 0 when the certificate was accepted + } + } + + WOLFSSL_CERT_MANAGER* cm = wolfSSL_CertManagerNew(); + ... + wolfSSL_CertManagerSetCertEventCb(cm, myCertEvent, myLogger); + + \endcode + + \sa wolfSSL_CTX_SetCertEventCb + \sa wolfSSL_X509_STORE_SetCertEventCb + \sa wc_SetCertEventCallback + \sa wolfSSL_CertManagerSetVerify +*/ +int wolfSSL_CertManagerSetCertEventCb(WOLFSSL_CERT_MANAGER* cm, + WOLFSSL_CERT_EVENT_CB cb, void* ctx); + +/*! + \ingroup CertManager + \brief Sets the certificate validation event callback in the + Certificate Manager of an SSL/TLS context. Requires WOLFSSL_CERT_EVENTS. + See wolfSSL_CertManagerSetCertEventCb() for what the callback receives. + + \return WOLFSSL_SUCCESS on success. + \return BAD_FUNC_ARG when ctx is NULL or has no Certificate Manager. + + \param ctx a pointer to a WOLFSSL_CTX structure, created using + wolfSSL_CTX_new(). + \param cb the event callback. NULL turns events off. + \param cbCtx a pointer passed to the callback with each event. + + _Example_ + \code + WOLFSSL_CTX* ctx = wolfSSL_CTX_new(wolfTLS_client_method()); + ... + wolfSSL_CTX_SetCertEventCb(ctx, myCertEvent, myLogger); + \endcode + + \sa wolfSSL_CertManagerSetCertEventCb +*/ +int wolfSSL_CTX_SetCertEventCb(WOLFSSL_CTX* ctx, WOLFSSL_CERT_EVENT_CB cb, + void* cbCtx); + +/*! + \ingroup CertManager + \brief Sets the certificate validation event callback in the Certificate + Manager of an X509 store, so that X509_verify_cert() raises events. + Requires WOLFSSL_CERT_EVENTS and OPENSSL_EXTRA. See + wolfSSL_CertManagerSetCertEventCb() for what the callback receives. + + X509_verify_cert() sends a RESULT for each certificate it tries while + building the chain, so one verification can send several, and a chain + check after the last one, such as the chain length, can still fail it. + Use X509_verify_cert()'s return value for the verdict. These RESULT + events have no subject, issuer or serial: use the X509 store context. + + \return WOLFSSL_SUCCESS on success. + \return BAD_FUNC_ARG when store is NULL or has no Certificate Manager. + + \param store a pointer to a WOLFSSL_X509_STORE structure. + \param cb the event callback. NULL turns events off. + \param ctx a pointer passed to the callback with each event. + + _Example_ + \code + WOLFSSL_X509_STORE* store = wolfSSL_X509_STORE_new(); + ... + wolfSSL_X509_STORE_SetCertEventCb(store, myCertEvent, myLogger); + \endcode + + \sa wolfSSL_CertManagerSetCertEventCb +*/ +int wolfSSL_X509_STORE_SetCertEventCb(WOLFSSL_X509_STORE* store, + WOLFSSL_CERT_EVENT_CB cb, void* ctx); + /*! \brief Check CRL if the option is enabled and compares the cert to the CRL list. diff --git a/src/internal.c b/src/internal.c index 5a8af6ee8e1..9dcbaf69a76 100644 --- a/src/internal.c +++ b/src/internal.c @@ -18173,6 +18173,72 @@ static int CheckTrustedPeerDates(const DecodedCert* cert) } #endif /* WOLFSSL_TRUST_PEER_CERT && !NO_ASN_TIME_CHECK */ +#ifdef WOLFSSL_CERT_EVENTS +/* Send the RESULT event that ends processing of the peer's certificates. + * + * @param [in] ssl SSL/TLS object. + * @param [in] args Peer certificate processing arguments. May be NULL. + * @param [in] ret Final error, 0 when the peer's certificate was accepted. + */ +static void PeerCertEventResult(WOLFSSL* ssl, ProcPeerCertArgs* args, int ret) +{ + WOLFSSL_CERT_MANAGER* cm = SSL_CM(ssl); + WOLFSSL_CERT_EVENT ev; + int haveCert = (args != NULL) && (args->certs != NULL) && + (args->count > 0); + + /* Nothing was received and nothing failed: nothing to report. */ + if ((cm == NULL) || (cm->certEventCb == NULL) || + ((!haveCert) && (ret == 0))) { + return; + } + + XMEMSET(&ev, 0, sizeof(ev)); + ev.kind = WC_CEV_KIND_RESULT; + ev.category = WC_CEV_CAT_CERT; + ev.error = ret; + ev.role = WC_CEV_ROLE_CANDIDATE; + ev.depth = 0; + /* Failures of the chain as a whole have no certificate to report on. */ + if (ret == WC_NO_ERR_TRACE(NO_PEER_CERT)) { + ev.condition = WC_CEV_COND_TLS_NO_PEER_CERT; + } + else if (ret == WC_NO_ERR_TRACE(MAX_CHAIN_ERROR)) { + ev.condition = WC_CEV_COND_TLS_CHAIN_TOO_LONG; + } +#if defined(HAVE_CERTIFICATE_STATUS_REQUEST) || \ + defined(HAVE_CERTIFICATE_STATUS_REQUEST_V2) + ssl->certEventResultHeld = 0; + /* A TLS 1.2 client checks the server's certificate status after this + * message, so the verdict is final only then. */ + if ((ret == 0) && haveCert && + (ssl->options.side == WOLFSSL_CLIENT_END) && + !IsAtLeastTLSv1_3(ssl->version) && (0 + #ifdef HAVE_CERTIFICATE_STATUS_REQUEST + || ssl->status_request + #endif + #ifdef HAVE_CERTIFICATE_STATUS_REQUEST_V2 + || ssl->status_request_v2 + #endif + )) { + ssl->certEventResultHeld = 1; + return; + } +#endif + if (haveCert) { + ev.der = args->certs[0].buffer; + ev.derSz = args->certs[0].length; + /* The peer's certificate, when it is the one still decoded. */ + if (args->dCertInit && (args->dCert != NULL) && + (args->dCert->source == args->certs[0].buffer)) { + wc_CertEventIdentity(args->dCert, &ev); + } + } + ev.ssl = ssl; + wc_CertEventSend(cm->certEventCb, cm->certEventCtx, &ev); +} +#endif /* WOLFSSL_CERT_EVENTS */ + static int ProcessPeerCertParse(WOLFSSL* ssl, ProcPeerCertArgs* args, int certType, int verify, byte** pSubjectHash, int* pAlreadySigner) { @@ -18311,6 +18377,17 @@ PRAGMA_GCC_DIAG_POP if (verify != NO_VERIFY && TLSX_CSR2_IsMulti(ssl->extensions)) { extraSigners = TLSX_CSR2_GetPendingSigners(ssl->extensions); } +#endif +#ifdef WOLFSSL_CERT_EVENTS + /* Index 0 is the peer's certificate; the rest are the CAs it sent. */ + if ((verify != NO_VERIFY) && (SSL_CM(ssl) != NULL)) { + wc_SetCertEventCallback(args->dCert, SSL_CM(ssl)->certEventCb, + SSL_CM(ssl)->certEventCtx); + wc_CertEventSetPosition(args->dCert, (args->certIdx == 0) ? + WC_CEV_ROLE_CANDIDATE : WC_CEV_ROLE_SIGNER, args->certIdx); + wc_CertEventSetConnection(args->dCert, ssl, + args->notCaSet ? args->notCaHash : NULL); + } #endif /* Parse Certificate */ ret = ParseCertRelative(args->dCert, certType, verify, SSL_CM(ssl), extraSigners); @@ -18531,6 +18608,11 @@ static int ProcessPeerCertCheckKey(WOLFSSL* ssl, ProcPeerCertArgs* args) break; } +#ifdef WOLFSSL_CERT_EVENTS + /* A key below the configured minimum is a policy failure. */ + wc_CertEventFailure(args->dCert, ret, WC_CEV_FIELD_SPKI, + WC_CEV_REASON_POLICY); +#endif return ret; } @@ -19579,6 +19661,14 @@ static int ProcessPeerCertDecodeKey(WOLFSSL* ssl, ProcPeerCertArgs* args, break; } +#ifdef WOLFSSL_CERT_EVENTS + /* A peer key below the configured minimum is a policy failure. */ + if ((ret == WC_NO_ERR_TRACE(RSA_KEY_SIZE_E)) || + (ret == WC_NO_ERR_TRACE(ECC_KEY_SIZE_E))) { + wc_CertEventFailure(args->dCert, ret, WC_CEV_FIELD_SPKI, + WC_CEV_REASON_POLICY); + } +#endif *pRet = ret; return 0; } @@ -20618,6 +20708,15 @@ int ProcessPeerCerts(WOLFSSL* ssl, byte* input, word32* inOutIdx, } #endif /* HAVE_CERTIFICATE_STATUS_REQUEST_V2 */ + #ifdef WOLFSSL_CERT_EVENTS + /* Not a CA: a certificate it issued is reported as + * signed by a non-CA. */ + if ((ret == 0) && !args->dCert->isCA) { + XMEMCPY(args->notCaHash, args->dCert->subjectHash, + KEYID_SIZE); + args->notCaSet = 1; + } + #endif /* If valid CA then add to Certificate Manager */ if (ret == 0 && args->dCert->isCA && !ssl->options.verifyNone && !skipAddCA) { @@ -20657,6 +20756,13 @@ int ProcessPeerCerts(WOLFSSL* ssl, byte* input, word32* inOutIdx, ssl->peerVerifyRet = WOLFSSL_X509_V_ERR_INVALID_CA; } #endif + #ifdef WOLFSSL_CERT_EVENTS + /* The CA the peer sent may not sign certificates. */ + if (ret == WC_NO_ERR_TRACE(NOT_CA_ERROR)) { + wc_CertEventFailure(args->dCert, ret, + WC_CEV_FIELD_CHAIN, WC_CEV_REASON_CONSTRAINT); + } + #endif /* Handle error codes */ ssl->error = ret; /* Report SSL error or clear error if @@ -21148,6 +21254,21 @@ int ProcessPeerCerts(WOLFSSL* ssl, byte* input, word32* inOutIdx, } } } + #ifdef WOLFSSL_CERT_EVENTS + /* The peer's key usage or extended key usage does not allow + * it to be used for this TLS connection. */ + if ((ret == WC_NO_ERR_TRACE(KEYUSE_SIGNATURE_E)) || + (ret == WC_NO_ERR_TRACE(KEYUSE_ENCIPHER_E))) { + wc_CertEventFailureCond(args->dCert, ret, + WC_CEV_FIELD_EXTENSION, WC_CEV_REASON_CONSTRAINT, + WC_CEV_COND_CERT_KU_PURPOSE); + } + else if (ret == WC_NO_ERR_TRACE(EXTKEYUSE_AUTH_E)) { + wc_CertEventFailureCond(args->dCert, ret, + WC_CEV_FIELD_EXTENSION, WC_CEV_REASON_CONSTRAINT, + WC_CEV_COND_CERT_EKU_PURPOSE); + } + #endif #endif /* IGNORE_KEY_EXTENSIONS */ if (args->fatal) { @@ -21411,6 +21532,11 @@ int ProcessPeerCerts(WOLFSSL* ssl, byte* input, word32* inOutIdx, } #endif /* WOLFSSL_HAVE_HS_SUSPEND */ +#ifdef WOLFSSL_CERT_EVENTS + /* A suspended handshake returned above: this is the final outcome. */ + PeerCertEventResult(ssl, args, ret); +#endif + #ifdef WOLFSSL_HAVE_HS_SUSPEND /* Cleanup async */ FreeAsyncCtx(ssl, 0); @@ -22585,6 +22711,58 @@ static int ResetHandshakeStateForReneg(WOLFSSL* ssl) } #endif +#if defined(WOLFSSL_CERT_EVENTS) && \ + (defined(HAVE_CERTIFICATE_STATUS_REQUEST) || \ + defined(HAVE_CERTIFICATE_STATUS_REQUEST_V2)) +/* Send the RESULT event held for the server's certificate status. + * + * Sent once the status was checked at ServerHelloDone, or when the handshake + * fails first. It has no subject, issuer or serial. + * + * @param [in] ssl SSL/TLS object. + * @param [in] ret Result of the handshake message just processed. + */ +static void PeerCertEventHeldResult(WOLFSSL* ssl, int ret) +{ + WOLFSSL_CERT_MANAGER* cm = SSL_CM(ssl); + WOLFSSL_CERT_EVENT ev; + /* Not final yet: the message is processed again. */ + int again = (ret == WC_NO_ERR_TRACE(WC_PENDING_E)); + +#ifdef WOLFSSL_NONBLOCK_OCSP + again = again || (ret == WC_NO_ERR_TRACE(OCSP_WANT_READ)); +#endif +#ifdef WOLFSSL_HAVE_HS_SUSPEND + again = again || IsHsSuspendErr(ret); +#endif + if ((!ssl->certEventResultHeld) || again) { + return; + } + ssl->certEventResultHeld = 0; + if ((cm == NULL) || (cm->certEventCb == NULL)) { + return; + } + + XMEMSET(&ev, 0, sizeof(ev)); + ev.kind = WC_CEV_KIND_RESULT; + ev.category = WC_CEV_CAT_CERT; + ev.error = ret; + ev.role = WC_CEV_ROLE_CANDIDATE; + ev.depth = 0; +#ifdef KEEP_PEER_CERT + { + const DerBuffer* peerDer = GetPeerCertDer(ssl); + if (peerDer != NULL) { + ev.der = peerDer->buffer; + ev.derSz = peerDer->length; + } + } +#endif + ev.ssl = ssl; + wc_CertEventSend(cm->certEventCb, cm->certEventCtx, &ev); +} +#endif + int DoHandShakeMsgType(WOLFSSL* ssl, byte* input, word32* inOutIdx, byte type, word32 size, word32 totalSz) { @@ -22657,6 +22835,12 @@ int DoHandShakeMsgType(WOLFSSL* ssl, byte* input, word32* inOutIdx, /* sanity check msg received */ if ( (ret = SanityCheckMsgReceived(ssl, type)) != 0) { WOLFSSL_MSG("Sanity Check on handshake message type received failed"); +#if defined(WOLFSSL_CERT_EVENTS) && \ + (defined(HAVE_CERTIFICATE_STATUS_REQUEST) || \ + defined(HAVE_CERTIFICATE_STATUS_REQUEST_V2)) + /* Such as the status check at ServerHelloDone failing. */ + PeerCertEventHeldResult(ssl, ret); +#endif #ifdef WOLFSSL_NONBLOCK_OCSP if (ret == WC_NO_ERR_TRACE(OCSP_WANT_READ)) { word32 hdrSz = HANDSHAKE_HEADER_SZ; @@ -22929,6 +23113,15 @@ int DoHandShakeMsgType(WOLFSSL* ssl, byte* input, word32* inOutIdx, ret = DECODE_E; WOLFSSL_ERROR_VERBOSE(ret); } +#if defined(WOLFSSL_CERT_EVENTS) && \ + (defined(HAVE_CERTIFICATE_STATUS_REQUEST) || \ + defined(HAVE_CERTIFICATE_STATUS_REQUEST_V2)) + /* The server's certificate status was checked, or the handshake + * failed. */ + if ((ret != 0) || (type == server_hello_done)) { + PeerCertEventHeldResult(ssl, ret); + } +#endif #ifdef WOLFSSL_HAVE_HS_SUSPEND /* if suspended, offset index so this msg will be processed again */ diff --git a/src/ssl_api_cert.c b/src/ssl_api_cert.c index a581651dbcc..fbd37cfc944 100644 --- a/src/ssl_api_cert.c +++ b/src/ssl_api_cert.c @@ -1737,6 +1737,27 @@ WOLF_STACK_OF(WOLFSSL_X509_NAME)* wolfSSL_load_client_CA_file(const char* fname) #endif /* !NO_BIO */ #endif /* WOLFSSL_NO_CA_NAMES */ +#ifdef WOLFSSL_CERT_EVENTS +/* Set the validation event callback into the context's certificate manager. + * + * @param [in] ctx SSL/TLS context. + * @param [in] cb Event callback. NULL turns events off. + * @param [in] cbCtx Context passed to the callback. + * @return WOLFSSL_SUCCESS on success. + * @return BAD_FUNC_ARG when ctx is NULL or has no certificate manager. + */ +int wolfSSL_CTX_SetCertEventCb(WOLFSSL_CTX* ctx, WOLFSSL_CERT_EVENT_CB cb, + void* cbCtx) +{ + WOLFSSL_ENTER("wolfSSL_CTX_SetCertEventCb"); + if (ctx == NULL) { + return BAD_FUNC_ARG; + } + + return wolfSSL_CertManagerSetCertEventCb(ctx->cm, cb, cbCtx); +} +#endif /* WOLFSSL_CERT_EVENTS */ + #if defined(OPENSSL_EXTRA) || defined(WOLFSSL_WPAS_SMALL) /* Get the certificate store of the SSL/TLS context. * diff --git a/src/ssl_certman.c b/src/ssl_certman.c index 0946251320b..ede47a50db9 100644 --- a/src/ssl_certman.c +++ b/src/ssl_certman.c @@ -742,6 +742,31 @@ void wolfSSL_CertManagerSetVerify(WOLFSSL_CERT_MANAGER* cm, VerifyCallback vc) } #endif /* !NO_WOLFSSL_CM_VERIFY */ +#ifdef WOLFSSL_CERT_EVENTS +/* Set the validation event callback into certificate manager. + * + * The callback observes events only; it cannot change the result. + * + * @param [in] cm Certificate manager. + * @param [in] cb Event callback. NULL turns events off. + * @param [in] ctx Context passed to the callback. + * @return WOLFSSL_SUCCESS on success. + * @return BAD_FUNC_ARG when cm is NULL. + */ +int wolfSSL_CertManagerSetCertEventCb(WOLFSSL_CERT_MANAGER* cm, + WOLFSSL_CERT_EVENT_CB cb, void* ctx) +{ + WOLFSSL_ENTER("wolfSSL_CertManagerSetCertEventCb"); + if (cm == NULL) { + return BAD_FUNC_ARG; + } + + cm->certEventCb = cb; + cm->certEventCtx = ctx; + return WOLFSSL_SUCCESS; +} +#endif /* WOLFSSL_CERT_EVENTS */ + #ifdef WC_ASN_UNKNOWN_EXT_CB void wolfSSL_CertManagerSetUnknownExtCallback(WOLFSSL_CERT_MANAGER* cm, wc_UnknownExtCallback cb) @@ -878,6 +903,40 @@ static int cm_verify_err_overridable(int err) #if (!defined(NO_WOLFSSL_CLIENT) || !defined(WOLFSSL_NO_CLIENT_AUTH)) || \ defined(OPENSSL_EXTRA) +#ifdef WOLFSSL_CERT_EVENTS +/* Send the RESULT event that ends one verification. + * + * @param [in] cm Certificate manager. + * @param [in] error Final error, 0 when the certificate passed. + * @param [in] depth Chain depth, -1 when not known. + * @param [in] der Encoded certificate. + * @param [in] derSz Size of encoded certificate in bytes. + * @param [in] cert Decoded certificate, or NULL when not available. + */ +void CM_CertEventResult(WOLFSSL_CERT_MANAGER* cm, int error, + int depth, const unsigned char* der, word32 derSz, const DecodedCert* cert) +{ + WOLFSSL_CERT_EVENT ev; + + if (cm->certEventCb == NULL) { + return; + } + + XMEMSET(&ev, 0, sizeof(ev)); + ev.kind = WC_CEV_KIND_RESULT; + ev.category = WC_CEV_CAT_CERT; + ev.error = error; + ev.role = (depth > 0) ? WC_CEV_ROLE_SIGNER : WC_CEV_ROLE_CANDIDATE; + ev.depth = depth; + ev.der = der; + ev.derSz = derSz; + if (cert != NULL) { + wc_CertEventIdentity(cert, &ev); + } + wc_CertEventSend(cm->certEventCb, cm->certEventCtx, &ev); +} +#endif /* WOLFSSL_CERT_EVENTS */ + /* Verify the certificate. * * Uses the verification callback if available. @@ -890,13 +949,17 @@ static int cm_verify_err_overridable(int err) * @param [in] prev_err Previous error. Passed to callback. * @param [out] crlErr CRL result, not merged into the return value. May be * NULL. + * @param [in] depth Chain depth for validation events, -1 when not known. + * @param [in] sendResult 1 to send the RESULT event. 0 when the caller has + * more checks to run and sends it. * @return WOLFSSL_SUCCESS on success. * @return MEMORY_E when dynamic memory allocation fails. * @return NOT_COMPILED_IN when converting from PEM to DER is not a feature of * the wolfSSL build. */ -int CM_VerifyBuffer_ex(WOLFSSL_CERT_MANAGER* cm, const unsigned char* buff, - long sz, int format, int prev_err, int* crlErr) +static int CM_VerifyBuffer_int(WOLFSSL_CERT_MANAGER* cm, + const unsigned char* buff, long sz, int format, int prev_err, int* crlErr, + int depth, int sendResult) { int ret = 0; int crlRet = 0; @@ -904,9 +967,11 @@ int CM_VerifyBuffer_ex(WOLFSSL_CERT_MANAGER* cm, const unsigned char* buff, DerBuffer* der = NULL; WC_DECLARE_VAR(cert, DecodedCert, 1, 0); - WOLFSSL_ENTER("CM_VerifyBuffer_ex"); + WOLFSSL_ENTER("CM_VerifyBuffer_int"); (void)prev_err; + (void)depth; + (void)sendResult; if (crlErr != NULL) { *crlErr = 0; @@ -951,6 +1016,15 @@ int CM_VerifyBuffer_ex(WOLFSSL_CERT_MANAGER* cm, const unsigned char* buff, if (cm->unknownExtCallback != NULL) wc_SetUnknownExtCallback(cert, cm->unknownExtCallback); #endif +#ifdef WOLFSSL_CERT_EVENTS + /* A previous error means a failed load is being handed to the verify + * callback, which is not a verification of its own. */ + if (prev_err == 0) { + wc_SetCertEventCallback(cert, cm->certEventCb, cm->certEventCtx); + wc_CertEventSetPosition(cert, (depth > 0) ? + WC_CEV_ROLE_SIGNER : WC_CEV_ROLE_CANDIDATE, depth); + } +#endif /* Parse DER into decoded certificate fields and verify signature * against a known CA. */ @@ -1054,6 +1128,14 @@ int CM_VerifyBuffer_ex(WOLFSSL_CERT_MANAGER* cm, const unsigned char* buff, #endif (void)crlRet; +#ifdef WOLFSSL_CERT_EVENTS + /* The final outcome, after any verify callback override. */ + if ((prev_err == 0) && sendResult) { + CM_CertEventResult(cm, ret, depth, buff, (word32)sz, + WC_VAR_OK(cert) ? cert : NULL); + } +#endif + /* Dispose of allocated memory. */ FreeDecodedCert(cert); FreeDer(&der); @@ -1063,6 +1145,63 @@ int CM_VerifyBuffer_ex(WOLFSSL_CERT_MANAGER* cm, const unsigned char* buff, return (ret == 0) ? WOLFSSL_SUCCESS : ret; } +/* Verify the certificate. + * + * Uses the verification callback if available. + * + * @param [in] cm Certificate manager. + * @param [in] buff Buffer holding encoded certificate. + * @param [in] sz Size in bytes of data in buffer. + * @param [in] format Format of encoding. Valid values: + * WOLFSSL_FILETYPE_ASN1, WOLFSSL_FILETYPE_PEM. + * @param [in] prev_err Previous error. Passed to callback. + * @param [out] crlErr CRL result, not merged into the return value. May be + * NULL. + * @return WOLFSSL_SUCCESS on success. + * @return MEMORY_E when dynamic memory allocation fails. + * @return NOT_COMPILED_IN when converting from PEM to DER is not a feature of + * the wolfSSL build. + */ +int CM_VerifyBuffer_ex(WOLFSSL_CERT_MANAGER* cm, const unsigned char* buff, + long sz, int format, int prev_err, int* crlErr) +{ + return CM_VerifyBuffer_int(cm, buff, sz, format, prev_err, crlErr, -1, + 1); +} + +#ifdef WOLFSSL_CERT_EVENTS +/* Verify one certificate of a chain, reporting its chain depth in events. + * + * Does not send the RESULT event: the caller sends it with + * CM_CertEventResult() once its own checks and verify callback are done. + * + * @param [in] cm Certificate manager. + * @param [in] buff Buffer holding encoded certificate. + * @param [in] sz Size in bytes of data in buffer. + * @param [in] format Format of encoding. Valid values: + * WOLFSSL_FILETYPE_ASN1, WOLFSSL_FILETYPE_PEM. + * @param [in] depth Chain depth: 0 for the certificate being verified. + * @param [out] crlErr CRL result, not merged into the return value. May be + * NULL. + * @return WOLFSSL_SUCCESS on success. + * @return BAD_FUNC_ARG when cm or buff is NULL, or sz is not positive. + * @return WOLFSSL_BAD_FILETYPE when format is not supported. + * @return Other values on failure, as CM_VerifyBuffer_ex(). + */ +int CM_VerifyBufferDepth(WOLFSSL_CERT_MANAGER* cm, const unsigned char* buff, + long sz, int format, int depth, int* crlErr) +{ + /* Same validation as wolfSSL_CertManagerVerifyBuffer(). */ + if ((cm == NULL) || (buff == NULL) || (sz <= 0)) { + return BAD_FUNC_ARG; + } + if ((format != WOLFSSL_FILETYPE_ASN1) && (format != WOLFSSL_FILETYPE_PEM)) { + return WOLFSSL_BAD_FILETYPE; + } + return CM_VerifyBuffer_int(cm, buff, sz, format, 0, crlErr, depth, 0); +} +#endif /* WOLFSSL_CERT_EVENTS */ + /* Verify the certificate. * * Uses the verification callback if available. @@ -3263,6 +3402,15 @@ int AddCA(WOLFSSL_CERT_MANAGER* cm, DerBuffer** pDer, int type, int verify) } #endif +#ifdef WOLFSSL_CERT_EVENTS + /* A CA the application loads as trusted. CAs from a peer's chain are + * reported by the TLS code that verified them. */ + if ((type == WOLFSSL_USER_CA) && (verify != NO_VERIFY)) { + wc_SetCertEventCallback(cert, cm->certEventCb, cm->certEventCtx); + wc_CertEventSetPosition(cert, WC_CEV_ROLE_TRUST_ANCHOR, -1); + } +#endif + WOLFSSL_MSG_CERT("\tParsing new CA"); ret = ParseCert(cert, CA_TYPE, verify, cm); diff --git a/src/x509_str.c b/src/x509_str.c index 5b9c910a4a6..42a390849f5 100644 --- a/src/x509_str.c +++ b/src/x509_str.c @@ -612,6 +612,30 @@ static WOLFSSL_X509_STORE_CTX_verify_cb X509StoreGetVerifyCb( return NULL; } +#ifdef WOLFSSL_CERT_EVENTS +/* Send the RESULT event for ctx->current_cert. + * + * @param [in] ctx X509 store context. + * @param [in] ret Outcome: WOLFSSL_SUCCESS or the error it failed with. + * @param [in] err Error the certificate failed with, 0 when not known. + * @param [in] depth Chain depth. + */ +static void X509StoreCertEventResult(WOLFSSL_X509_STORE_CTX* ctx, int ret, + int err, int depth) +{ + if (ret == WOLFSSL_SUCCESS) { + err = 0; + } + else if (err == 0) { + /* Rejected by the verify callback or a date check. */ + err = VERIFY_CERT_ERROR; + } + CM_CertEventResult(ctx->store->cm, err, depth, + ctx->current_cert->derCert->buffer, + ctx->current_cert->derCert->length, NULL); +} +#endif + /* Verify ctx->current_cert against the store. * * is an out-parameter, never NULL. It is set to 1 when the @@ -630,15 +654,28 @@ static int X509StoreVerifyCert(WOLFSSL_X509_STORE_CTX* ctx, int* cbRejected, int crlRet = 0; int datesChecked = 0; int accepted = 0; /* callback accepted a cert that verified */ +#ifdef WOLFSSL_CERT_EVENTS + /* Same depth as SetupStoreCtxError() records for this certificate. */ + int depth = (ctx->chain != NULL) ? (int)ctx->chain->num : 0; + /* The error the certificate failed with, for the RESULT event. */ + int evErr = 0; +#endif WOLFSSL_ENTER("X509StoreVerifyCert"); *cbRejected = 0; if (ctx->current_cert != NULL && ctx->current_cert->derCert != NULL) { + #ifdef WOLFSSL_CERT_EVENTS + ret = CM_VerifyBufferDepth(ctx->store->cm, + ctx->current_cert->derCert->buffer, + (long)ctx->current_cert->derCert->length, + WOLFSSL_FILETYPE_ASN1, depth, &crlRet); + #else ret = CM_VerifyBuffer_ex(ctx->store->cm, ctx->current_cert->derCert->buffer, ctx->current_cert->derCert->length, WOLFSSL_FILETYPE_ASN1, 0, &crlRet); + #endif datesChecked = (ret == WOLFSSL_SUCCESS) || (ret == WC_NO_ERR_TRACE(ASN_BEFORE_DATE_E)) || (ret == WC_NO_ERR_TRACE(ASN_AFTER_DATE_E)); @@ -659,6 +696,9 @@ static int X509StoreVerifyCert(WOLFSSL_X509_STORE_CTX* ctx, int* cbRejected, if (crlRet != 0) { SetupStoreCtxError(ctx, crlRet); if ((verifyCb == NULL) || (verifyCb(0, ctx) != 1)) { + #ifdef WOLFSSL_CERT_EVENTS + X509StoreCertEventResult(ctx, crlRet, crlRet, depth); + #endif return crlRet; } } @@ -666,6 +706,11 @@ static int X509StoreVerifyCert(WOLFSSL_X509_STORE_CTX* ctx, int* cbRejected, #ifndef NO_ASN_TIME /* update return value with any date validation overrides */ ret = X509StoreVerifyCertDate(ctx, ret); + #endif + #ifdef WOLFSSL_CERT_EVENTS + if (ret != WOLFSSL_SUCCESS) { + evErr = ret; + } #endif SetupStoreCtxError(ctx, ret); if (verifyCb != NULL) { @@ -710,6 +755,11 @@ static int X509StoreVerifyCert(WOLFSSL_X509_STORE_CTX* ctx, int* cbRejected, * as it skips date validation when other errors are present. */ ret = X509StoreVerifyCertDate(ctx, ret); + #ifdef WOLFSSL_CERT_EVENTS + if (ret != WOLFSSL_SUCCESS) { + evErr = ret; + } + #endif /* Like OpenSSL, report a cert that verified only once. */ if (!accepted || ret != WOLFSSL_SUCCESS) { SetupStoreCtxError(ctx, ret); @@ -724,6 +774,13 @@ static int X509StoreVerifyCert(WOLFSSL_X509_STORE_CTX* ctx, int* cbRejected, } } } +#endif +#ifdef WOLFSSL_CERT_EVENTS + /* The final outcome, after the date overrides, the context's CRLs and + * the verify callback. */ + if (ctx->current_cert != NULL && ctx->current_cert->derCert != NULL) { + X509StoreCertEventResult(ctx, ret, evErr, depth); + } #endif (void)datesChecked; (void)accepted; @@ -2437,6 +2494,29 @@ int wolfSSL_X509_STORE_add_cert(WOLFSSL_X509_STORE* store, WOLFSSL_X509* x509) return result; } +#ifdef WOLFSSL_CERT_EVENTS +/* Set the validation event callback into the store's certificate manager. + * + * X509_verify_cert() verifies through this certificate manager. + * + * @param [in] store X509 certificate store. + * @param [in] cb Event callback. NULL turns events off. + * @param [in] ctx Context passed to the callback. + * @return WOLFSSL_SUCCESS on success. + * @return BAD_FUNC_ARG when store is NULL or has no certificate manager. + */ +int wolfSSL_X509_STORE_SetCertEventCb(WOLFSSL_X509_STORE* store, + WOLFSSL_CERT_EVENT_CB cb, void* ctx) +{ + WOLFSSL_ENTER("wolfSSL_X509_STORE_SetCertEventCb"); + if (store == NULL) { + return BAD_FUNC_ARG; + } + + return wolfSSL_CertManagerSetCertEventCb(store->cm, cb, ctx); +} +#endif /* WOLFSSL_CERT_EVENTS */ + int wolfSSL_X509_STORE_set_flags(WOLFSSL_X509_STORE* store, unsigned long flag) { int ret = WOLFSSL_SUCCESS; diff --git a/tests/api/test_certman.c b/tests/api/test_certman.c index 2b8f2064c34..bd3ba6eef42 100644 --- a/tests/api/test_certman.c +++ b/tests/api/test_certman.c @@ -757,6 +757,1037 @@ int test_wolfSSL_CertManagerSetVerify(void) return EXPECT_RESULT(); } +/* TEST_CERT_EVENTS implies !NO_FILESYSTEM, but check-api-guards.py does not + * expand it, so the tests that load files repeat that condition. */ +#if defined(WOLFSSL_CERT_EVENTS) && defined(WOLFSSL_ASN_TEMPLATE) && \ + !defined(NO_FILESYSTEM) && \ + !defined(NO_CERTS) && !defined(NO_TLS) && !defined(NO_ASN_TIME) && \ + !defined(NO_WOLFSSL_CM_VERIFY) && !defined(NO_RSA) && \ + (!defined(NO_WOLFSSL_CLIENT) || !defined(WOLFSSL_NO_CLIENT_AUTH)) && \ + !(defined(NO_WOLFSSL_CLIENT) && defined(NO_WOLFSSL_SERVER)) +#define TEST_CERT_EVENTS +#endif + +#ifdef TEST_CERT_EVENTS +/* Events seen by certEventLogCb. */ +typedef struct CertEventLog { + int defects; + int results; + WOLFSSL_CERT_EVENT defect; /* Last DEFECT event. */ + WOLFSSL_CERT_EVENT result; /* Last RESULT event. */ + WOLFSSL_CERT_EVENT all[4]; /* First DEFECT events, in order. */ + byte oid[16]; /* Last DEFECT's extension OID, copied: the + * event's pointers are only valid during + * the callback. */ + word32 oidSz; + char subject[256]; /* Last DEFECT's or RESULT's subject, + * copied. */ + word32 serialSz; /* Its serial number's size. */ +} CertEventLog; + +/* Copy what the event says about which certificate it is. */ +static void certEventLogIdentity(CertEventLog* log, + const WOLFSSL_CERT_EVENT* ev) +{ + log->subject[0] = '\0'; + if (ev->subject != NULL) { + XSTRNCPY(log->subject, ev->subject, sizeof(log->subject) - 1); + log->subject[sizeof(log->subject) - 1] = '\0'; + } + log->serialSz = (ev->serial != NULL) ? ev->serialSz : 0; +} + +static void certEventLogCb(const WOLFSSL_CERT_EVENT* ev, void* ctx) +{ + CertEventLog* log = (CertEventLog*)ctx; + + if (ev->kind == WC_CEV_KIND_DEFECT) { + if (log->defects < (int)XELEM_CNT(log->all)) { + log->all[log->defects] = *ev; + } + log->defects++; + log->defect = *ev; + certEventLogIdentity(log, ev); + log->oidSz = 0; + if ((ev->extOidData != NULL) && (ev->extOidSz <= sizeof(log->oid))) { + XMEMCPY(log->oid, ev->extOidData, ev->extOidSz); + log->oidSz = ev->extOidSz; + } + } + else if (ev->kind == WC_CEV_KIND_RESULT) { + log->results++; + log->result = *ev; + certEventLogIdentity(log, ev); + } +} + +/* After every test certificate expires, and before 32-bit time_t wraps. */ +static time_t certEventAfterExpiryTimeCb(time_t* t) +{ + time_t when = (time_t)2145916800; /* 2038-01-01 00:00:00 UTC */ + + if (t != NULL) { + *t = when; + } + return when; +} + +/* Before certs/server-cert.pem becomes valid. */ +static time_t certEventBeforeValidTimeCb(time_t* t) +{ + time_t when = (time_t)1577836800; /* 2020-01-01 00:00:00 UTC */ + + if (t != NULL) { + *t = when; + } + return when; +} +#endif + +int test_wolfSSL_CertManagerCertEvents(void) +{ + EXPECT_DECLS; +#if defined(TEST_CERT_EVENTS) && !defined(NO_FILESYSTEM) + WOLFSSL_CERT_MANAGER* cm = NULL; + CertEventLog log; + int tmp = myVerifyAction; +#ifdef WOLFSSL_PEM_TO_DER + const char* ca_cert = "./certs/ca-cert.pem"; + const char* svrCert = "./certs/server-cert.pem"; +#else + const char* ca_cert = "./certs/ca-cert.der"; + const char* svrCert = "./certs/server-cert.der"; +#endif + + XMEMSET(&log, 0, sizeof(log)); + + ExpectIntEQ(wolfSSL_CertManagerSetCertEventCb(NULL, certEventLogCb, &log), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + ExpectIntEQ(wolfSSL_CTX_SetCertEventCb(NULL, certEventLogCb, &log), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + + ExpectNotNull(cm = wolfSSL_CertManagerNew()); + ExpectIntEQ(wolfSSL_CertManagerLoadCA(cm, ca_cert, NULL), + WOLFSSL_SUCCESS); + ExpectIntEQ(wolfSSL_CertManagerSetCertEventCb(cm, certEventLogCb, &log), + WOLFSSL_SUCCESS); + + /* A good certificate: no defects, one passed result. */ + ExpectIntEQ(wolfSSL_CertManagerVerify(cm, svrCert, CERT_FILETYPE), + WOLFSSL_SUCCESS); + ExpectIntEQ(log.defects, 0); + ExpectIntEQ(log.results, 1); + ExpectIntEQ(log.result.size, (int)sizeof(WOLFSSL_CERT_EVENT)); + ExpectIntEQ(log.result.error, 0); + ExpectIntEQ(log.result.category, WC_CEV_CAT_CERT); + ExpectIntEQ(log.result.role, WC_CEV_ROLE_CANDIDATE); + ExpectIntEQ(log.result.depth, -1); + ExpectNotNull(log.result.der); + ExpectIntGT(log.result.derSz, 0); + /* Which certificate it was. Not in a TLS handshake: no connection. */ + ExpectNotNull(XSTRSTR(log.subject, "CN=www.wolfssl.com")); + ExpectIntGT(log.serialSz, 0); + ExpectNull(log.result.ssl); + + /* Move the clock past the certificate's notAfter. The defect says where + * and why; the return code is unchanged. */ + ExpectIntEQ(wc_SetTimeCb(certEventAfterExpiryTimeCb), 0); + XMEMSET(&log, 0, sizeof(log)); + ExpectIntEQ(wolfSSL_CertManagerVerify(cm, svrCert, CERT_FILETYPE), + WC_NO_ERR_TRACE(ASN_AFTER_DATE_E)); + ExpectIntEQ(log.defects, 1); + ExpectIntEQ(log.defect.error, WC_NO_ERR_TRACE(ASN_AFTER_DATE_E)); + ExpectIntEQ(log.defect.category, WC_CEV_CAT_CERT); + ExpectIntEQ(log.defect.role, WC_CEV_ROLE_CANDIDATE); + ExpectIntEQ(log.defect.depth, -1); + ExpectIntEQ(log.defect.field, WC_CEV_FIELD_VALIDITY); + ExpectIntEQ(log.defect.reason, WC_CEV_REASON_EXPIRED); + ExpectIntEQ(log.defect.condition, WC_CEV_COND_CERT_EXPIRED); + ExpectIntEQ(log.results, 1); + ExpectIntEQ(log.result.error, WC_NO_ERR_TRACE(ASN_AFTER_DATE_E)); + + /* The verify callback allows it: the defect is still reported, and the + * result says the verification passed. */ + XMEMSET(&log, 0, sizeof(log)); + wolfSSL_CertManagerSetVerify(cm, myVerify); + myVerifyAction = VERIFY_OVERRIDE_ERROR; + ExpectIntEQ(wolfSSL_CertManagerVerify(cm, svrCert, CERT_FILETYPE), + WOLFSSL_SUCCESS); + ExpectIntEQ(log.defects, 1); + ExpectIntEQ(log.results, 1); + ExpectIntEQ(log.result.error, 0); + wolfSSL_CertManagerSetVerify(cm, NULL); + + /* Move the clock before the certificate's notBefore. */ + ExpectIntEQ(wc_SetTimeCb(certEventBeforeValidTimeCb), 0); + XMEMSET(&log, 0, sizeof(log)); + ExpectIntEQ(wolfSSL_CertManagerVerify(cm, svrCert, CERT_FILETYPE), + WC_NO_ERR_TRACE(ASN_BEFORE_DATE_E)); + ExpectIntEQ(log.defects, 1); + ExpectIntEQ(log.defect.error, WC_NO_ERR_TRACE(ASN_BEFORE_DATE_E)); + ExpectIntEQ(log.defect.field, WC_CEV_FIELD_VALIDITY); + ExpectIntEQ(log.defect.reason, WC_CEV_REASON_NOT_YET_VALID); + ExpectIntEQ(log.defect.condition, WC_CEV_COND_CERT_NOT_YET_VALID); + ExpectIntEQ(log.results, 1); + ExpectIntEQ(log.result.error, WC_NO_ERR_TRACE(ASN_BEFORE_DATE_E)); + + /* Clearing the callback stops events. */ + XMEMSET(&log, 0, sizeof(log)); + ExpectIntEQ(wolfSSL_CertManagerSetCertEventCb(cm, NULL, NULL), + WOLFSSL_SUCCESS); + ExpectIntNE(wolfSSL_CertManagerVerify(cm, svrCert, CERT_FILETYPE), + WOLFSSL_SUCCESS); + ExpectIntEQ(log.defects, 0); + ExpectIntEQ(log.results, 0); + + (void)wc_SetTimeCb(NULL); + wolfSSL_CertManagerFree(cm); + myVerifyAction = tmp; +#endif + + return EXPECT_RESULT(); +} + +/* Every broken certificate gets exactly one RESULT event, and it holds the + * same error the API returned. */ +int test_wolfSSL_CertManagerCertEvents_badCerts(void) +{ + EXPECT_DECLS; +#if defined(TEST_CERT_EVENTS) && !defined(NO_FILESYSTEM) + static const struct { + const char* file; + int expected; /* Return code with the ASN template parser. */ + } bad[] = { + #if defined(OPENSSL_ALL) || defined(WOLFSSL_QT) + /* Self-issued with no signer: reported as self-signed for OpenSSL + * compatibility. */ + { "./certs/test/server-garbage.der", ASN_SELF_SIGNED_E }, + #else + { "./certs/test/server-garbage.der", ASN_NO_SIGNER_E }, + #endif + { "./certs/test/cert-bad-oid.der", ASN_PARSE_E }, + { "./certs/test/cert-bad-neg-int.der", ASN_EXPECT_0_E }, + { "./certs/test/cert-bad-utf8.der", ASN_PARSE_E }, + #ifdef HAVE_ECC + { "./certs/test/server-cert-ecc-badsig.der", ASN_SIG_CONFIRM_E }, + { "./certs/test/cert-ext-oid-collide.der", ASN_SIG_CONFIRM_E }, + #endif + }; + WOLFSSL_CERT_MANAGER* cm = NULL; + CertEventLog log; + size_t i; + int ret; +#ifdef WOLFSSL_PEM_TO_DER + const char* ca_cert = "./certs/ca-cert.pem"; + const char* ca_ecc_cert = "./certs/ca-ecc-cert.pem"; +#else + const char* ca_cert = "./certs/ca-cert.der"; + const char* ca_ecc_cert = "./certs/ca-ecc-cert.der"; +#endif + + ExpectNotNull(cm = wolfSSL_CertManagerNew()); + ExpectIntEQ(wolfSSL_CertManagerLoadCA(cm, ca_cert, NULL), + WOLFSSL_SUCCESS); +#ifdef HAVE_ECC + ExpectIntEQ(wolfSSL_CertManagerLoadCA(cm, ca_ecc_cert, NULL), + WOLFSSL_SUCCESS); +#else + (void)ca_ecc_cert; +#endif + ExpectIntEQ(wolfSSL_CertManagerSetCertEventCb(cm, certEventLogCb, &log), + WOLFSSL_SUCCESS); + + for (i = 0; i < sizeof(bad) / sizeof(bad[0]); i++) { + XMEMSET(&log, 0, sizeof(log)); + ret = wolfSSL_CertManagerVerify(cm, bad[i].file, + WOLFSSL_FILETYPE_ASN1); + ExpectIntEQ(ret, bad[i].expected); + ExpectIntEQ(log.results, 1); + ExpectIntEQ(log.result.kind, WC_CEV_KIND_RESULT); + ExpectIntEQ(log.result.error, ret); + if (EXPECT_FAIL()) { + fprintf(stderr, "cert event test failed for %s\n", bad[i].file); + break; + } + } + + wolfSSL_CertManagerFree(cm); +#endif + + return EXPECT_RESULT(); +} + +/* Each generated certificate in certs/test/cert-events has one defect in one + * extension. The event names the extension by its OID and says why it + * failed; the return code is unchanged. */ +int test_wolfSSL_CertEvents_extensions(void) +{ + EXPECT_DECLS; +#if defined(TEST_CERT_EVENTS) && !defined(NO_FILESYSTEM) +#if !defined(WOLFSSL_X509_TINY) || defined(WOLFSSL_X509_TINY_SKI) + static const byte oidSkid[] = { 0x55, 0x1d, 0x0e }; +#endif + static const byte oidKu[] = { 0x55, 0x1d, 0x0f }; + static const byte oidSan[] = { 0x55, 0x1d, 0x11 }; + static const byte oidBc[] = { 0x55, 0x1d, 0x13 }; +#if !defined(WOLFSSL_X509_TINY) || defined(WOLFSSL_X509_TINY_CRL_DP) + static const byte oidCrlDp[] = { 0x55, 0x1d, 0x1f }; +#endif +#if (defined(WOLFSSL_SEP) || defined(WOLFSSL_CERT_EXT)) && \ + (!defined(WOLFSSL_X509_TINY) || defined(WOLFSSL_X509_TINY_POLICIES)) + static const byte oidPolicy[] = { 0x55, 0x1d, 0x20 }; +#endif +#if !defined(WOLFSSL_X509_TINY) || defined(WOLFSSL_X509_TINY_AKI) + static const byte oidAkid[] = { 0x55, 0x1d, 0x23 }; +#endif + static const byte oidEku[] = { 0x55, 0x1d, 0x25 }; +#if !defined(WOLFSSL_X509_TINY) || defined(WOLFSSL_X509_TINY_AIA) + static const byte oidAia[] = { 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, + 0x01, 0x01 }; +#endif + /* 1.3.6.1.4.1.99999.1 */ + static const byte oidUnknown[] = { 0x2b, 0x06, 0x01, 0x04, 0x01, 0x86, + 0x8d, 0x1f, 0x01 }; + static const struct { + const char* file; + int error; /* ASN template parser */ + int reason; + word32 oidSum; /* 0 when wolfSSL has no constant */ + const byte* oid; + word32 oidSz; + byte critical; + } cases[] = { + { "ku-malformed", ASN_PARSE_E, WC_CEV_REASON_MALFORMED, + KEY_USAGE_OID, oidKu, sizeof(oidKu), 1 }, + { "bc-malformed", ASN_PARSE_E, WC_CEV_REASON_MALFORMED, + BASIC_CA_OID, oidBc, sizeof(oidBc), 1 }, + /* Tiny builds do not decode some extensions. */ + #if !defined(WOLFSSL_X509_TINY) || defined(WOLFSSL_X509_TINY_AKI) + { "akid-malformed", ASN_PARSE_E, WC_CEV_REASON_MALFORMED, + AUTH_KEY_OID, oidAkid, sizeof(oidAkid), 0 }, + #endif + #if !defined(WOLFSSL_X509_TINY) || defined(WOLFSSL_X509_TINY_SKI) + { "skid-malformed", ASN_PARSE_E, WC_CEV_REASON_MALFORMED, + SUBJ_KEY_OID, oidSkid, sizeof(oidSkid), 0 }, + #endif + { "eku-malformed", ASN_PARSE_E, WC_CEV_REASON_MALFORMED, + EXT_KEY_USAGE_OID, oidEku, sizeof(oidEku), 0 }, + { "san-malformed", ASN_PARSE_E, WC_CEV_REASON_MALFORMED, + ALT_NAMES_OID, oidSan, sizeof(oidSan), 0 }, + #if !defined(WOLFSSL_X509_TINY) || defined(WOLFSSL_X509_TINY_CRL_DP) + { "crldp-malformed", ASN_PARSE_E, WC_CEV_REASON_MALFORMED, + CRL_DIST_OID, oidCrlDp, sizeof(oidCrlDp), 0 }, + #endif + #if !defined(WOLFSSL_X509_TINY) || defined(WOLFSSL_X509_TINY_AIA) + { "aia-malformed", ASN_PARSE_E, WC_CEV_REASON_MALFORMED, + AUTH_INFO_OID, oidAia, sizeof(oidAia), 0 }, + #endif + #if (defined(WOLFSSL_SEP) || defined(WOLFSSL_CERT_EXT)) && \ + (!defined(WOLFSSL_X509_TINY) || defined(WOLFSSL_X509_TINY_POLICIES)) + /* Other builds do not parse certificate policies. */ + { "policy-malformed", ASN_PARSE_E, WC_CEV_REASON_MALFORMED, + CERT_POLICY_OID, oidPolicy, sizeof(oidPolicy), 0 }, + #endif + { "unknown-critical", ASN_CRIT_EXT_E, WC_CEV_REASON_UNSUPPORTED, + 0, oidUnknown, sizeof(oidUnknown), 1 }, + }; + /* Certificates that pass. */ + static const char* const clean[] = { + "good", "issuer-uid", "subject-uid" + }; + WOLFSSL_CERT_MANAGER* cm = NULL; + CertEventLog log; + char file[64]; + size_t i; + int ret; +#ifdef WOLFSSL_PEM_TO_DER + const char* ca_cert = "./certs/ca-cert.pem"; +#else + const char* ca_cert = "./certs/ca-cert.der"; +#endif + + ExpectNotNull(cm = wolfSSL_CertManagerNew()); + ExpectIntEQ(wolfSSL_CertManagerLoadCA(cm, ca_cert, NULL), + WOLFSSL_SUCCESS); + ExpectIntEQ(wolfSSL_CertManagerSetCertEventCb(cm, certEventLogCb, &log), + WOLFSSL_SUCCESS); + + for (i = 0; i < XELEM_CNT(clean); i++) { + XMEMSET(&log, 0, sizeof(log)); + (void)XSNPRINTF(file, sizeof(file), "./certs/test/cert-events/%s.der", + clean[i]); + ExpectIntEQ(wolfSSL_CertManagerVerify(cm, file, + WOLFSSL_FILETYPE_ASN1), WOLFSSL_SUCCESS); + ExpectIntEQ(log.defects, 0); + ExpectIntEQ(log.results, 1); + ExpectIntEQ(log.result.error, 0); + if (EXPECT_FAIL()) { + fprintf(stderr, "cert event test failed for %s\n", file); + break; + } + } + + for (i = 0; i < XELEM_CNT(cases); i++) { + XMEMSET(&log, 0, sizeof(log)); + (void)XSNPRINTF(file, sizeof(file), "./certs/test/cert-events/%s.der", + cases[i].file); + ret = wolfSSL_CertManagerVerify(cm, file, WOLFSSL_FILETYPE_ASN1); + ExpectIntEQ(ret, cases[i].error); + /* One defect, in the extension, with the same error. */ + ExpectIntEQ(log.defects, 1); + ExpectIntEQ(log.defect.error, ret); + ExpectIntEQ(log.defect.role, WC_CEV_ROLE_CANDIDATE); + ExpectIntEQ(log.defect.field, WC_CEV_FIELD_EXTENSION); + ExpectIntEQ(log.defect.reason, cases[i].reason); + ExpectIntEQ(log.defect.condition, + (cases[i].reason == WC_CEV_REASON_UNSUPPORTED) ? + WC_CEV_COND_CERT_EXT_UNKNOWN_CRITICAL : + WC_CEV_COND_CERT_EXT_VALUE); + ExpectIntEQ(log.defect.critical, cases[i].critical); + if (cases[i].oidSum != 0) { + ExpectIntEQ(log.defect.extOID, cases[i].oidSum); + } + ExpectIntEQ(log.oidSz, cases[i].oidSz); + if (EXPECT_SUCCESS()) { + ExpectBufEQ(log.oid, cases[i].oid, cases[i].oidSz); + } + ExpectIntEQ(log.results, 1); + ExpectIntEQ(log.result.error, ret); + if (EXPECT_FAIL()) { + fprintf(stderr, "cert event test failed for %s\n", file); + break; + } + } + + wolfSSL_CertManagerFree(cm); +#endif + + return EXPECT_RESULT(); +} + +/* Each generated certificate in certs/test/cert-events has one defect in a + * field outside the extensions. The event names the field, and its error is + * the one the API returned. */ +int test_wolfSSL_CertEvents_fields(void) +{ + EXPECT_DECLS; +#if defined(TEST_CERT_EVENTS) && !defined(NO_FILESYSTEM) + static const struct { + const char* file; + int field; + int error; /* ASN template parser */ + int reason; + int condition; + } cases[] = { + { "version-unsupported", WC_CEV_FIELD_VERSION, + ASN_PARSE_E, WC_CEV_REASON_MALFORMED, + WC_CEV_COND_CERT_VERSION }, + { "version-not-integer", WC_CEV_FIELD_VERSION, + ASN_PARSE_E, WC_CEV_REASON_MALFORMED, + WC_CEV_COND_CERT_VERSION }, + { "serial-empty", WC_CEV_FIELD_SERIAL, + ASN_PARSE_E, WC_CEV_REASON_MALFORMED, + WC_CEV_COND_CERT_FORMAT }, + { "serial-not-integer", WC_CEV_FIELD_SERIAL, + ASN_PARSE_E, WC_CEV_REASON_MALFORMED, + WC_CEV_COND_CERT_FORMAT }, + /* An unknown algorithm in the TBS no longer matches the outer one. */ + { "tbs-sigalg-unknown", WC_CEV_FIELD_SIGALG, + ASN_SIG_OID_E, WC_CEV_REASON_MALFORMED, + WC_CEV_COND_CERT_SIG_ALG_MISMATCH }, + { "issuer-malformed", WC_CEV_FIELD_ISSUER, + ASN_PARSE_E, WC_CEV_REASON_MALFORMED, + WC_CEV_COND_CERT_ISSUER }, + { "validity-not-time", WC_CEV_FIELD_VALIDITY, + ASN_PARSE_E, WC_CEV_REASON_MALFORMED, + WC_CEV_COND_CERT_FORMAT }, + { "subject-malformed", WC_CEV_FIELD_SUBJECT, + ASN_PARSE_E, WC_CEV_REASON_MALFORMED, + WC_CEV_COND_CERT_SUBJECT }, + { "spki-unknown-alg", WC_CEV_FIELD_SPKI, + ASN_UNKNOWN_OID_E, WC_CEV_REASON_UNSUPPORTED, + WC_CEV_COND_CERT_KEY_UNSUPPORTED }, + { "spki-bad-bitstring", WC_CEV_FIELD_SPKI, + ASN_PARSE_E, WC_CEV_REASON_MALFORMED, + WC_CEV_COND_CERT_FORMAT }, + { "sigalg-mismatch", WC_CEV_FIELD_SIGALG, + ASN_SIG_OID_E, WC_CEV_REASON_MALFORMED, + WC_CEV_COND_CERT_SIG_ALG_MISMATCH }, + { "signature-not-bitstring", WC_CEV_FIELD_SIGNATURE, + ASN_BITSTR_E, WC_CEV_REASON_MALFORMED, + WC_CEV_COND_CERT_FORMAT }, + #ifndef WOLFSSL_NO_ASN_STRICT + /* Only strict builds reject data after the certificate. */ + { "trailing-data", WC_CEV_FIELD_ENCODING, + ASN_PARSE_E, WC_CEV_REASON_MALFORMED, + WC_CEV_COND_CERT_FORMAT }, + #endif /* Failures against the signer. */ + { "leaf-bad-signature", WC_CEV_FIELD_SIGNATURE, + ASN_SIG_CONFIRM_E, WC_CEV_REASON_SIGNATURE, + WC_CEV_COND_CERT_SIG_INVALID }, + { "leaf-unknown-issuer", WC_CEV_FIELD_CHAIN, + ASN_NO_SIGNER_E, WC_CEV_REASON_NO_SIGNER, + WC_CEV_COND_CERT_NO_ISSUER }, + }; + WOLFSSL_CERT_MANAGER* cm = NULL; + CertEventLog log; + char file[64]; + size_t i; + int ret; +#ifdef WOLFSSL_PEM_TO_DER + const char* ca_cert = "./certs/ca-cert.pem"; +#else + const char* ca_cert = "./certs/ca-cert.der"; +#endif + + ExpectNotNull(cm = wolfSSL_CertManagerNew()); + ExpectIntEQ(wolfSSL_CertManagerLoadCA(cm, ca_cert, NULL), + WOLFSSL_SUCCESS); + ExpectIntEQ(wolfSSL_CertManagerSetCertEventCb(cm, certEventLogCb, &log), + WOLFSSL_SUCCESS); + + for (i = 0; i < XELEM_CNT(cases); i++) { + XMEMSET(&log, 0, sizeof(log)); + (void)XSNPRINTF(file, sizeof(file), "./certs/test/cert-events/%s.der", + cases[i].file); + ret = wolfSSL_CertManagerVerify(cm, file, WOLFSSL_FILETYPE_ASN1); + ExpectIntNE(ret, WOLFSSL_SUCCESS); + /* Exactly one defect, even when two checks see the same failure. */ + ExpectIntEQ(log.defects, 1); + ExpectIntEQ(log.defect.error, ret); + ExpectIntEQ(log.defect.role, WC_CEV_ROLE_CANDIDATE); + ExpectIntEQ(log.defect.reason, cases[i].reason); + ExpectIntEQ(log.defect.condition, cases[i].condition); + ExpectIntEQ(log.defect.extOID, 0); + ExpectNull(log.defect.extOidData); + ExpectIntEQ(log.defect.field, cases[i].field); + ExpectIntEQ(ret, cases[i].error); + ExpectIntEQ(log.results, 1); + ExpectIntEQ(log.result.error, ret); + if (EXPECT_FAIL()) { + fprintf(stderr, "cert event test failed for %s\n", file); + break; + } + } + + wolfSSL_CertManagerFree(cm); +#endif + + return EXPECT_RESULT(); +} + +/* Parsing without a certificate manager uses the DecodedCert callback. */ +int test_wolfSSL_CertEvents_noCertManager(void) +{ + EXPECT_DECLS; +#ifdef TEST_CERT_EVENTS + DecodedCert cert; + CertEventLog log; + byte* der = NULL; + size_t derSz = 0; + + XMEMSET(&log, 0, sizeof(log)); + ExpectIntEQ(wc_SetCertEventCallback(NULL, certEventLogCb, &log), + WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + + /* A self-signed CA verifies against its own key, so no manager is + * needed. */ + ExpectIntEQ(load_file("./certs/ca-cert.der", &der, &derSz), 0); + + /* Today it parses cleanly: no events. */ + wc_InitDecodedCert(&cert, der, (word32)derSz, NULL); + ExpectIntEQ(wc_SetCertEventCallback(&cert, certEventLogCb, &log), 0); + ExpectIntEQ(wc_ParseCert(&cert, CA_TYPE, VERIFY, NULL), 0); + wc_FreeDecodedCert(&cert); + ExpectIntEQ(log.defects, 0); + + /* In 2038 it has expired: one defect, no RESULT event (results come + * from the certificate manager). */ + ExpectIntEQ(wc_SetTimeCb(certEventAfterExpiryTimeCb), 0); + wc_InitDecodedCert(&cert, der, (word32)derSz, NULL); + ExpectIntEQ(wc_SetCertEventCallback(&cert, certEventLogCb, &log), 0); + ExpectIntEQ(wc_ParseCert(&cert, CA_TYPE, VERIFY, NULL), + WC_NO_ERR_TRACE(ASN_AFTER_DATE_E)); + wc_FreeDecodedCert(&cert); + ExpectIntEQ(log.defects, 1); + ExpectIntEQ(log.defect.field, WC_CEV_FIELD_VALIDITY); + ExpectIntEQ(log.defect.reason, WC_CEV_REASON_EXPIRED); + ExpectIntEQ(log.results, 0); + + /* Without a callback the same failure raises nothing. */ + XMEMSET(&log, 0, sizeof(log)); + wc_InitDecodedCert(&cert, der, (word32)derSz, NULL); + ExpectIntEQ(wc_ParseCert(&cert, CA_TYPE, VERIFY, NULL), + WC_NO_ERR_TRACE(ASN_AFTER_DATE_E)); + wc_FreeDecodedCert(&cert); + ExpectIntEQ(log.defects, 0); + + (void)wc_SetTimeCb(NULL); + XFREE(der, NULL, DYNAMIC_TYPE_TMP_BUFFER); +#endif + + return EXPECT_RESULT(); +} + +#ifdef TEST_CERT_EVENTS +/* Accept every certificate, as a Warn-Allow policy would. */ +static int certEventAllowCb(int preverify, WOLFSSL_X509_STORE_CTX* store) +{ + (void)preverify; + (void)store; + return 1; +} +#endif + +/* The TLS handshake reports each certificate the peer sends, with its + * position in the chain, and one RESULT event for the whole chain. */ +int test_wolfSSL_CertEvents_tls(void) +{ + EXPECT_DECLS; +#if defined(TEST_CERT_EVENTS) && defined(HAVE_SSL_MEMIO_TESTS_DEPENDENCIES) + test_ssl_memio_ctx test_ctx; + CertEventLog log; + int i; + int ret; + + /* Case 1: a good chain. Case 2: the clock is past every certificate's + * notAfter. Case 3: as case 2, with a verify callback that allows it. */ + for (i = 1; i <= 3; i++) { + XMEMSET(&test_ctx, 0, sizeof(test_ctx)); + XMEMSET(&log, 0, sizeof(log)); + ret = TEST_FAIL; + + ExpectIntEQ(test_ssl_memio_setup(&test_ctx), TEST_SUCCESS); + ExpectIntEQ(wolfSSL_CTX_SetCertEventCb(test_ctx.c_ctx, + certEventLogCb, &log), WOLFSSL_SUCCESS); + /* The client verifies the server; OpenSSL-compatible defaults would + * otherwise turn verification off. The server does not ask for a + * client certificate, so only the client's checks are exercised. */ + wolfSSL_set_verify(test_ctx.c_ssl, WOLFSSL_VERIFY_PEER, + (i == 3) ? certEventAllowCb : NULL); + wolfSSL_set_verify(test_ctx.s_ssl, WOLFSSL_VERIFY_NONE, NULL); + + if (EXPECT_SUCCESS()) { + if (i > 1) { + (void)wc_SetTimeCb(certEventAfterExpiryTimeCb); + } + ret = test_ssl_memio_do_handshake(&test_ctx, 10, NULL); + (void)wc_SetTimeCb(NULL); + } + + /* One RESULT for the chain, about the peer's own certificate. */ + ExpectIntEQ(log.results, 1); + ExpectIntEQ(log.result.role, WC_CEV_ROLE_CANDIDATE); + ExpectIntEQ(log.result.depth, 0); + ExpectNotNull(log.result.der); + + if (i == 1) { + ExpectIntEQ(ret, TEST_SUCCESS); + ExpectIntEQ(log.defects, 0); + ExpectIntEQ(log.result.error, 0); + } + else { + int j; + + /* Each expired certificate is reported with its own position: + * depth 0 is the peer, deeper ones are the CAs that signed it. */ + ExpectIntGE(log.defects, 1); + for (j = 0; j < log.defects && j < (int)XELEM_CNT(log.all); j++) { + ExpectIntEQ(log.all[j].error, + WC_NO_ERR_TRACE(ASN_AFTER_DATE_E)); + ExpectIntEQ(log.all[j].field, WC_CEV_FIELD_VALIDITY); + ExpectIntEQ(log.all[j].reason, WC_CEV_REASON_EXPIRED); + ExpectIntEQ(log.all[j].role, (log.all[j].depth == 0) ? + WC_CEV_ROLE_CANDIDATE : WC_CEV_ROLE_SIGNER); + ExpectIntGE(log.all[j].depth, 0); + /* The connection whose handshake raised it. */ + ExpectPtrEq(log.all[j].ssl, test_ctx.c_ssl); + } + ExpectPtrEq(log.result.ssl, test_ctx.c_ssl); + /* The chain is walked from the CA the peer sent (depth 1) down + * to the peer's certificate (depth 0). */ + ExpectIntEQ(log.all[0].depth, 1); + ExpectIntEQ(log.all[0].role, WC_CEV_ROLE_SIGNER); + if (i == 2) { + /* The walk stops at the first failure, and the handshake + * fails with the error the result holds. */ + ExpectIntEQ(log.defects, 1); + ExpectIntNE(ret, TEST_SUCCESS); + ExpectIntEQ(log.result.error, + WC_NO_ERR_TRACE(ASN_AFTER_DATE_E)); + ExpectIntEQ(log.result.error, + wolfSSL_get_error(test_ctx.c_ssl, 0)); + ExpectIntNE(log.result.error, 0); + } + else { + /* Allowed: the walk goes on to the peer's certificate, every + * defect is still logged, and the chain passes. */ + ExpectIntEQ(log.defects, 2); + ExpectIntEQ(log.all[1].depth, 0); + ExpectIntEQ(log.all[1].role, WC_CEV_ROLE_CANDIDATE); + ExpectIntEQ(ret, TEST_SUCCESS); + ExpectIntEQ(log.result.error, 0); + } + } + + test_ssl_memio_cleanup(&test_ctx); + } +#endif + + return EXPECT_RESULT(); +} + +/* Chains a TLS server sends, each with one fault, and the leaves that fail + * against their signer. Each fault is reported once, on the certificate it + * is about, with its position in the chain. */ +int test_wolfSSL_CertEvents_chain(void) +{ + EXPECT_DECLS; +#if defined(TEST_CERT_EVENTS) && defined(HAVE_SSL_MEMIO_TESTS_DEPENDENCIES) + static const struct { + const char* file; + int error; /* 0 when the chain is good */ + int field; + int reason; + int condition; + int role; + int depth; + int minRsaKeySz; /* 0 to keep the default */ + } cases[] = { + { "chain-good", 0, 0, 0, 0, 0, 0, 0 }, + /* The signer is not taken as a CA, so the server's certificate has + * no signer. */ + /* The peer sent the issuer, but it is not a CA. */ + { "chain-signer-not-ca", ASN_NO_SIGNER_E, WC_CEV_FIELD_CHAIN, + WC_CEV_REASON_NO_SIGNER, WC_CEV_COND_CERT_NOT_CA, + WC_CEV_ROLE_CANDIDATE, 0, 0 }, + { "chain-signer-no-certsign", NOT_CA_ERROR, WC_CEV_FIELD_CHAIN, + WC_CEV_REASON_CONSTRAINT, WC_CEV_COND_CERT_ISSUER_KU, + WC_CEV_ROLE_SIGNER, 1, 0 }, + /* The CA below the pathLenConstraint 0 one breaks it. */ + { "chain-pathlen-exceeded", ASN_PATHLEN_INV_E, WC_CEV_FIELD_CHAIN, + WC_CEV_REASON_CONSTRAINT, WC_CEV_COND_CERT_PATH_LEN, + WC_CEV_ROLE_SIGNER, 1, 0 }, + /* Every key is 2048 bits; ask for more. The CA sent is checked + * first. */ + { "chain-good", RSA_KEY_SIZE_E, WC_CEV_FIELD_SPKI, + WC_CEV_REASON_POLICY, WC_CEV_COND_CERT_KEY_TOO_SMALL, + WC_CEV_ROLE_SIGNER, 1, 4096 }, + #ifndef IGNORE_KEY_EXTENSIONS + /* The server's own certificate may not be used for this. */ + { "chain-leaf-ku-no-digsig", KEYUSE_SIGNATURE_E, + WC_CEV_FIELD_EXTENSION, WC_CEV_REASON_CONSTRAINT, + WC_CEV_COND_CERT_KU_PURPOSE, WC_CEV_ROLE_CANDIDATE, 0, 0 }, + { "chain-leaf-eku-client-only", EXTKEYUSE_AUTH_E, + WC_CEV_FIELD_EXTENSION, WC_CEV_REASON_CONSTRAINT, + WC_CEV_COND_CERT_EKU_PURPOSE, WC_CEV_ROLE_CANDIDATE, 0, 0 }, + #endif + }; + test_ssl_memio_ctx test_ctx; + CertEventLog log; + char file[64]; + size_t i; + int ret; + + for (i = 0; i < XELEM_CNT(cases); i++) { + XMEMSET(&test_ctx, 0, sizeof(test_ctx)); + XMEMSET(&log, 0, sizeof(log)); + (void)XSNPRINTF(file, sizeof(file), "./certs/test/cert-events/%s.pem", + cases[i].file); + test_ctx.s_cb.certPemFile = file; + test_ctx.s_cb.keyPemFile = "./certs/server-key.pem"; + ExpectIntEQ(test_ssl_memio_setup(&test_ctx), TEST_SUCCESS); + ExpectIntEQ(wolfSSL_CTX_SetCertEventCb(test_ctx.c_ctx, + certEventLogCb, &log), WOLFSSL_SUCCESS); + wolfSSL_set_verify(test_ctx.c_ssl, WOLFSSL_VERIFY_PEER, NULL); + wolfSSL_set_verify(test_ctx.s_ssl, WOLFSSL_VERIFY_NONE, NULL); + if (cases[i].minRsaKeySz != 0) { + ExpectIntEQ(wolfSSL_SetMinRsaKey_Sz(test_ctx.c_ssl, + (short)cases[i].minRsaKeySz), WOLFSSL_SUCCESS); + } + ret = TEST_FAIL; + if (EXPECT_SUCCESS()) { + ret = test_ssl_memio_do_handshake(&test_ctx, 10, NULL); + } + + ExpectIntEQ(log.results, 1); + if (cases[i].error == 0) { + ExpectIntEQ(ret, TEST_SUCCESS); + ExpectIntEQ(log.defects, 0); + ExpectIntEQ(log.result.error, 0); + ExpectIntEQ(log.result.condition, WC_CEV_COND_NONE); + } + else { + ExpectIntNE(ret, TEST_SUCCESS); + ExpectIntEQ(wolfSSL_get_error(test_ctx.c_ssl, 0), + cases[i].error); + /* One defect, on the certificate at fault. */ + ExpectIntEQ(log.defects, 1); + ExpectIntEQ(log.defect.error, cases[i].error); + ExpectIntEQ(log.defect.field, cases[i].field); + ExpectIntEQ(log.defect.reason, cases[i].reason); + ExpectIntEQ(log.defect.condition, cases[i].condition); + ExpectIntEQ(log.defect.role, cases[i].role); + ExpectIntEQ(log.defect.depth, cases[i].depth); + ExpectIntEQ(log.result.error, cases[i].error); + } + if (EXPECT_FAIL()) { + fprintf(stderr, "cert event test failed for case %d, %s\n", + (int)i, file); + } + + test_ssl_memio_cleanup(&test_ctx); + if (EXPECT_FAIL()) { + break; + } + } +#endif + + return EXPECT_RESULT(); +} + +/* A server that requires a client certificate and gets none reports it on + * the RESULT event: there is no certificate to report a defect on. */ +int test_wolfSSL_CertEvents_noPeerCert(void) +{ + EXPECT_DECLS; +#if defined(TEST_CERT_EVENTS) && defined(HAVE_SSL_MEMIO_TESTS_DEPENDENCIES) && \ + !defined(NO_WOLFSSL_SERVER) + test_ssl_memio_ctx test_ctx; + CertEventLog log; + + XMEMSET(&test_ctx, 0, sizeof(test_ctx)); + XMEMSET(&log, 0, sizeof(log)); + /* The client has no certificate to send. */ + test_ctx.c_cb.certPemFile = ""; + test_ctx.c_cb.keyPemFile = ""; + ExpectIntEQ(test_ssl_memio_setup(&test_ctx), TEST_SUCCESS); + ExpectIntEQ(wolfSSL_CTX_SetCertEventCb(test_ctx.s_ctx, certEventLogCb, + &log), WOLFSSL_SUCCESS); + wolfSSL_set_verify(test_ctx.s_ssl, + WOLFSSL_VERIFY_PEER | WOLFSSL_VERIFY_FAIL_IF_NO_PEER_CERT, NULL); + if (EXPECT_SUCCESS()) { + ExpectIntNE(test_ssl_memio_do_handshake(&test_ctx, 10, NULL), + TEST_SUCCESS); + } + ExpectIntEQ(wolfSSL_get_error(test_ctx.s_ssl, 0), + WC_NO_ERR_TRACE(NO_PEER_CERT)); + ExpectIntEQ(log.defects, 0); + ExpectIntEQ(log.results, 1); + ExpectIntEQ(log.result.error, WC_NO_ERR_TRACE(NO_PEER_CERT)); + ExpectIntEQ(log.result.condition, WC_CEV_COND_TLS_NO_PEER_CERT); + ExpectNull(log.result.der); + + test_ssl_memio_cleanup(&test_ctx); +#endif + + return EXPECT_RESULT(); +} + +#if defined(TEST_CERT_EVENTS) && defined(HAVE_SSL_MEMIO_TESTS_DEPENDENCIES) && \ + defined(HAVE_CRL) && defined(HAVE_OCSP) && \ + defined(HAVE_CERTIFICATE_STATUS_REQUEST) && !defined(WOLFSSL_NO_TLS12) +/* Acknowledge status_request, but send no CertificateStatus. */ +static int certEventStatusNoneCb(WOLFSSL* ssl, void* arg) +{ + (void)ssl; + (void)arg; + return WOLFSSL_OCSP_STATUS_CB_NOACK; +} + +static int certEventStatusSrvReady(WOLFSSL_CTX* ctx) +{ + EXPECT_DECLS; + + ExpectIntEQ(wolfSSL_CTX_EnableOCSPStapling(ctx), WOLFSSL_SUCCESS); + ExpectIntEQ(wolfSSL_CTX_set_tlsext_status_cb(ctx, certEventStatusNoneCb), + WOLFSSL_SUCCESS); + return EXPECT_RESULT(); +} +#endif + +/* A TLS 1.2 client that asks for the server's certificate status checks it + * at ServerHelloDone, so the RESULT event waits for that verdict. Here no + * status arrives and the CRL is missing: the RESULT must say so, not pass. */ +int test_wolfSSL_CertEvents_heldStatus(void) +{ + EXPECT_DECLS; +#if defined(TEST_CERT_EVENTS) && defined(HAVE_SSL_MEMIO_TESTS_DEPENDENCIES) && \ + defined(HAVE_CRL) && defined(HAVE_OCSP) && \ + defined(HAVE_CERTIFICATE_STATUS_REQUEST) && !defined(WOLFSSL_NO_TLS12) + test_ssl_memio_ctx test_ctx; + CertEventLog log; + int ret = TEST_FAIL; + + XMEMSET(&test_ctx, 0, sizeof(test_ctx)); + XMEMSET(&log, 0, sizeof(log)); + test_ctx.c_cb.method = wolfTLSv1_2_client_method; + test_ctx.s_cb.method = wolfTLSv1_2_server_method; + test_ctx.s_cb.ctx_ready = certEventStatusSrvReady; + ExpectIntEQ(test_ssl_memio_setup(&test_ctx), TEST_SUCCESS); + ExpectIntEQ(wolfSSL_CTX_SetCertEventCb(test_ctx.c_ctx, certEventLogCb, + &log), WOLFSSL_SUCCESS); + /* CRL checking with no CRL loaded. */ + ExpectIntEQ(wolfSSL_CTX_EnableCRL(test_ctx.c_ctx, WOLFSSL_CRL_CHECK), + WOLFSSL_SUCCESS); + ExpectIntEQ(wolfSSL_CTX_EnableOCSPStapling(test_ctx.c_ctx), + WOLFSSL_SUCCESS); + ExpectIntEQ(wolfSSL_UseOCSPStapling(test_ctx.c_ssl, WOLFSSL_CSR_OCSP, 0), + WOLFSSL_SUCCESS); + wolfSSL_set_verify(test_ctx.c_ssl, WOLFSSL_VERIFY_PEER, NULL); + if (EXPECT_SUCCESS()) { + ret = test_ssl_memio_do_handshake(&test_ctx, 10, NULL); + } + ExpectIntNE(ret, TEST_SUCCESS); + ExpectIntEQ(wolfSSL_get_error(test_ctx.c_ssl, 0), + WC_NO_ERR_TRACE(CRL_MISSING)); + ExpectIntEQ(log.results, 1); + ExpectIntEQ(log.result.error, WC_NO_ERR_TRACE(CRL_MISSING)); + ExpectPtrEq(log.result.ssl, test_ctx.c_ssl); + test_ssl_memio_cleanup(&test_ctx); + + /* With a CRL that does not revoke it, one passed RESULT. */ + XMEMSET(&test_ctx, 0, sizeof(test_ctx)); + XMEMSET(&log, 0, sizeof(log)); + test_ctx.c_cb.method = wolfTLSv1_2_client_method; + test_ctx.s_cb.method = wolfTLSv1_2_server_method; + test_ctx.s_cb.ctx_ready = certEventStatusSrvReady; + ExpectIntEQ(test_ssl_memio_setup(&test_ctx), TEST_SUCCESS); + ExpectIntEQ(wolfSSL_CTX_SetCertEventCb(test_ctx.c_ctx, certEventLogCb, + &log), WOLFSSL_SUCCESS); + ExpectIntEQ(wolfSSL_CTX_EnableCRL(test_ctx.c_ctx, WOLFSSL_CRL_CHECK), + WOLFSSL_SUCCESS); + ExpectIntEQ(wolfSSL_CTX_LoadCRLFile(test_ctx.c_ctx, "./certs/crl/crl.pem", + WOLFSSL_FILETYPE_PEM), WOLFSSL_SUCCESS); + ExpectIntEQ(wolfSSL_CTX_EnableOCSPStapling(test_ctx.c_ctx), + WOLFSSL_SUCCESS); + ExpectIntEQ(wolfSSL_UseOCSPStapling(test_ctx.c_ssl, WOLFSSL_CSR_OCSP, 0), + WOLFSSL_SUCCESS); + wolfSSL_set_verify(test_ctx.c_ssl, WOLFSSL_VERIFY_PEER, NULL); + ret = TEST_FAIL; + if (EXPECT_SUCCESS()) { + ret = test_ssl_memio_do_handshake(&test_ctx, 10, NULL); + } + ExpectIntEQ(ret, TEST_SUCCESS); + ExpectIntEQ(log.results, 1); + ExpectIntEQ(log.result.error, 0); + ExpectPtrEq(log.result.ssl, test_ctx.c_ssl); + test_ssl_memio_cleanup(&test_ctx); +#endif + + return EXPECT_RESULT(); +} + +/* A CA the application loads as trusted is reported in the trust anchor + * role. */ +int test_wolfSSL_CertEvents_trustAnchor(void) +{ + EXPECT_DECLS; +#ifdef TEST_CERT_EVENTS + WOLFSSL_CERT_MANAGER* cm = NULL; + CertEventLog log; + byte* der = NULL; + size_t derSz = 0; + + XMEMSET(&log, 0, sizeof(log)); + ExpectNotNull(cm = wolfSSL_CertManagerNew()); + ExpectIntEQ(wolfSSL_CertManagerSetCertEventCb(cm, certEventLogCb, &log), + WOLFSSL_SUCCESS); + + /* A good CA: no defect. */ + ExpectIntEQ(load_file("./certs/ca-cert.der", &der, &derSz), 0); + ExpectIntEQ(wolfSSL_CertManagerLoadCABuffer_ex(cm, der, (long)derSz, + WOLFSSL_FILETYPE_ASN1, 0, WOLFSSL_LOAD_FLAG_NONE), WOLFSSL_SUCCESS); + XFREE(der, NULL, DYNAMIC_TYPE_TMP_BUFFER); + der = NULL; + ExpectIntEQ(log.defects, 0); + + /* An expired CA, loaded without permission to ignore its dates. */ + XMEMSET(&log, 0, sizeof(log)); + ExpectIntEQ(load_file("./certs/test/expired/expired-ca.der", &der, + &derSz), 0); + ExpectIntEQ(wolfSSL_CertManagerLoadCABuffer_ex(cm, der, (long)derSz, + WOLFSSL_FILETYPE_ASN1, 0, WOLFSSL_LOAD_FLAG_NONE), + WC_NO_ERR_TRACE(ASN_AFTER_DATE_E)); + XFREE(der, NULL, DYNAMIC_TYPE_TMP_BUFFER); + ExpectIntEQ(log.defects, 1); + ExpectIntEQ(log.defect.role, WC_CEV_ROLE_TRUST_ANCHOR); + ExpectIntEQ(log.defect.depth, -1); + ExpectIntEQ(log.defect.condition, WC_CEV_COND_CERT_EXPIRED); + + wolfSSL_CertManagerFree(cm); +#endif + + return EXPECT_RESULT(); +} + +/* X509_verify_cert() reports events through the store's certificate + * manager, as used by nginx and other OpenSSL-compatible applications. */ +int test_wolfSSL_X509_STORE_CertEvents(void) +{ + EXPECT_DECLS; +#if defined(TEST_CERT_EVENTS) && defined(OPENSSL_EXTRA) + WOLFSSL_X509_STORE* store = NULL; + WOLFSSL_X509_STORE_CTX* sctx = NULL; + WOLFSSL_X509* ca = NULL; + WOLFSSL_X509* leaf = NULL; + CertEventLog log; + + XMEMSET(&log, 0, sizeof(log)); + ExpectIntEQ(wolfSSL_X509_STORE_SetCertEventCb(NULL, certEventLogCb, + &log), WC_NO_ERR_TRACE(BAD_FUNC_ARG)); + + ExpectNotNull(store = wolfSSL_X509_STORE_new()); + ExpectNotNull(ca = wolfSSL_X509_load_certificate_file( + "./certs/ca-cert.der", WOLFSSL_FILETYPE_ASN1)); + ExpectIntEQ(wolfSSL_X509_STORE_add_cert(store, ca), WOLFSSL_SUCCESS); + ExpectIntEQ(wolfSSL_X509_STORE_SetCertEventCb(store, certEventLogCb, + &log), WOLFSSL_SUCCESS); + ExpectNotNull(leaf = wolfSSL_X509_load_certificate_file( + "./certs/server-cert.der", WOLFSSL_FILETYPE_ASN1)); + + /* A good chain: no defects, and the last result passed. */ + ExpectNotNull(sctx = wolfSSL_X509_STORE_CTX_new()); + ExpectIntEQ(wolfSSL_X509_STORE_CTX_init(sctx, store, leaf, NULL), + WOLFSSL_SUCCESS); + ExpectIntEQ(wolfSSL_X509_verify_cert(sctx), WOLFSSL_SUCCESS); + ExpectIntEQ(log.defects, 0); + ExpectIntGE(log.results, 1); + ExpectIntEQ(log.result.error, 0); + wolfSSL_X509_STORE_CTX_free(sctx); + sctx = NULL; + + /* An expired leaf: the OpenSSL error is unchanged, and the event says + * which field failed and why. */ + ExpectIntEQ(wc_SetTimeCb(certEventAfterExpiryTimeCb), 0); + XMEMSET(&log, 0, sizeof(log)); + ExpectNotNull(sctx = wolfSSL_X509_STORE_CTX_new()); + ExpectIntEQ(wolfSSL_X509_STORE_CTX_init(sctx, store, leaf, NULL), + WOLFSSL_SUCCESS); + ExpectIntNE(wolfSSL_X509_verify_cert(sctx), WOLFSSL_SUCCESS); + ExpectIntEQ(wolfSSL_X509_STORE_CTX_get_error(sctx), + WOLFSSL_X509_V_ERR_CERT_HAS_EXPIRED); + ExpectIntGE(log.defects, 1); + ExpectIntEQ(log.defect.error, WC_NO_ERR_TRACE(ASN_AFTER_DATE_E)); + ExpectIntEQ(log.defect.field, WC_CEV_FIELD_VALIDITY); + ExpectIntEQ(log.defect.reason, WC_CEV_REASON_EXPIRED); + /* The event's depth matches the depth OpenSSL-style callers see. */ + ExpectIntEQ(log.defect.depth, + wolfSSL_X509_STORE_CTX_get_error_depth(sctx)); + ExpectIntEQ(log.defect.role, WC_CEV_ROLE_CANDIDATE); + ExpectIntGE(log.results, 1); + ExpectIntEQ(log.result.error, WC_NO_ERR_TRACE(ASN_AFTER_DATE_E)); + (void)wc_SetTimeCb(NULL); + + wolfSSL_X509_STORE_CTX_free(sctx); + wolfSSL_X509_free(leaf); + wolfSSL_X509_free(ca); + wolfSSL_X509_STORE_free(store); +#endif + + return EXPECT_RESULT(); +} + int test_wolfSSL_CertManagerNameConstraint(void) { EXPECT_DECLS; diff --git a/tests/api/test_certman.h b/tests/api/test_certman.h index feb9cb687fa..030d0838c61 100644 --- a/tests/api/test_certman.h +++ b/tests/api/test_certman.h @@ -31,6 +31,17 @@ int test_wolfSSL_CertManagerLoadCABuffer_ex(void); int test_wolfSSL_CertManagerLoadCABufferType(void); int test_wolfSSL_CertManagerGetCerts(void); int test_wolfSSL_CertManagerSetVerify(void); +int test_wolfSSL_CertManagerCertEvents(void); +int test_wolfSSL_CertManagerCertEvents_badCerts(void); +int test_wolfSSL_CertEvents_noCertManager(void); +int test_wolfSSL_X509_STORE_CertEvents(void); +int test_wolfSSL_CertEvents_tls(void); +int test_wolfSSL_CertEvents_chain(void); +int test_wolfSSL_CertEvents_noPeerCert(void); +int test_wolfSSL_CertEvents_heldStatus(void); +int test_wolfSSL_CertEvents_trustAnchor(void); +int test_wolfSSL_CertEvents_extensions(void); +int test_wolfSSL_CertEvents_fields(void); int test_wolfSSL_CertManagerNameConstraint(void); int test_wolfSSL_CertManagerNameConstraint2(void); int test_wolfSSL_CertManagerNameConstraint3(void); @@ -77,6 +88,18 @@ int test_wolfSSL_trust_peer_cert_dates(void); TEST_DECL_GROUP("certman", test_wolfSSL_CertManagerLoadCABufferType), \ TEST_DECL_GROUP("certman", test_wolfSSL_CertManagerGetCerts), \ TEST_DECL_GROUP("certman", test_wolfSSL_CertManagerSetVerify), \ + TEST_DECL_GROUP("certman", test_wolfSSL_CertManagerCertEvents), \ + TEST_DECL_GROUP("certman", \ + test_wolfSSL_CertManagerCertEvents_badCerts), \ + TEST_DECL_GROUP("certman", test_wolfSSL_CertEvents_noCertManager), \ + TEST_DECL_GROUP("certman", test_wolfSSL_X509_STORE_CertEvents), \ + TEST_DECL_GROUP("certman", test_wolfSSL_CertEvents_tls), \ + TEST_DECL_GROUP("certman", test_wolfSSL_CertEvents_chain), \ + TEST_DECL_GROUP("certman", test_wolfSSL_CertEvents_noPeerCert), \ + TEST_DECL_GROUP("certman", test_wolfSSL_CertEvents_heldStatus), \ + TEST_DECL_GROUP("certman", test_wolfSSL_CertEvents_trustAnchor), \ + TEST_DECL_GROUP("certman", test_wolfSSL_CertEvents_extensions), \ + TEST_DECL_GROUP("certman", test_wolfSSL_CertEvents_fields), \ TEST_DECL_GROUP("certman", test_wolfSSL_CertManagerNameConstraint), \ TEST_DECL_GROUP("certman", test_wolfSSL_CertManagerNameConstraint2), \ TEST_DECL_GROUP("certman", test_wolfSSL_CertManagerNameConstraint3), \ diff --git a/wolfcrypt/src/asn.c b/wolfcrypt/src/asn.c index a66b07d1497..45c8900a7a3 100644 --- a/wolfcrypt/src/asn.c +++ b/wolfcrypt/src/asn.c @@ -13344,6 +13344,9 @@ void InitDecodedCert_ex(DecodedCert* cert, cert->maxIdx = inSz; /* can't go over this index */ cert->heap = heap; cert->maxPathLen = WOLFSSL_MAX_PATH_LEN; + #ifdef WOLFSSL_CERT_EVENTS + cert->certEventDepth = -1; /* not known until a caller says */ + #endif #if defined(WOLFSSL_CERT_GEN) || defined(WOLFSSL_CERT_EXT) #ifdef WOLFSSL_CERT_NAME_ALL cert->subjectNEnc = CTC_UTF8; @@ -23997,6 +24000,373 @@ int wc_SetUnknownExtCallback32Ex(DecodedCert* cert, #endif /* WC_ASN_UNKNOWN_EXT_CB */ +#ifdef WOLFSSL_CERT_EVENTS +/* Set the validation event callback on a decoded certificate. + * + * Use this when parsing without a certificate manager. The certificate + * manager sets it for certificates it verifies. + * + * @param [in, out] cert Decoded certificate. + * @param [in] cb Event callback. NULL turns events off. + * @param [in] ctx Context passed to the callback. + * @return 0 on success. + * @return BAD_FUNC_ARG when cert is NULL. + */ +int wc_SetCertEventCallback(DecodedCert* cert, WOLFSSL_CERT_EVENT_CB cb, + void* ctx) +{ + if (cert == NULL) { + return BAD_FUNC_ARG; + } + + cert->certEventCb = cb; + cert->certEventCtx = ctx; + return 0; +} + +/* Record the TLS connection whose handshake verifies the certificate. + * + * @param [in, out] cert Decoded certificate. + * @param [in] ssl TLS connection (WOLFSSL*). + * @param [in] notCaHash Subject hash of a certificate the peer sent + * that is not a CA, or NULL. A certificate whose + * issuer it is fails as signed by a non-CA. + */ +void wc_CertEventSetConnection(DecodedCert* cert, void* ssl, + const byte* notCaHash) +{ + if (cert != NULL) { + cert->certEventSsl = ssl; + cert->certEventNotCaSet = (notCaHash != NULL); + if (notCaHash != NULL) { + XMEMCPY(cert->certEventNotCa, notCaHash, KEYID_SIZE); + } + } +} + +/* Fill in which certificate an event is about, as far as it was decoded. + * + * @param [in] cert Decoded certificate. + * @param [out] ev Event. + */ +void wc_CertEventIdentity(const DecodedCert* cert, WOLFSSL_CERT_EVENT* ev) +{ + if (cert->subject[0] != '\0') { + ev->subject = cert->subject; + } + if (cert->issuer[0] != '\0') { + ev->issuer = cert->issuer; + } + if (cert->serialSz > 0) { + ev->serial = cert->serial; + ev->serialSz = (word32)cert->serialSz; + } + ev->ssl = cert->certEventSsl; +} + +/* Record where the certificate sits in the chain being verified. + * + * @param [in, out] cert Decoded certificate. + * @param [in] role Role of the certificate. enum wc_CertEventRole. + * @param [in] depth Chain depth, -1 when not known. + */ +void wc_CertEventSetPosition(DecodedCert* cert, int role, int depth) +{ + if (cert != NULL) { + cert->certEventRole = role; + cert->certEventDepth = depth; + } +} + +/* Fill in the size of the event and call the callback. + * + * Does nothing when no callback is set. + * + * @param [in] cb Event callback. + * @param [in] ctx Context passed to the callback. + * @param [in, out] ev Event to send. + */ +void wc_CertEventSend(WOLFSSL_CERT_EVENT_CB cb, void* ctx, + WOLFSSL_CERT_EVENT* ev) +{ + if ((cb != NULL) && (ev != NULL)) { + ev->size = (word32)sizeof(WOLFSSL_CERT_EVENT); + cb(ev, ctx); + } +} + +/* Choose the condition that describes a failure. + * + * @param [in] cert Decoded certificate. + * @param [in] error wolfSSL error code. + * @param [in] field Field that failed. enum wc_CertEventField. + * @param [in] reason Why it failed. enum wc_CertEventReason. + * @return Condition. enum wc_CertEventCondition. + */ +static int CertEventCondition(const DecodedCert* cert, int error, int field, + int reason) +{ + switch (reason) { + case WC_CEV_REASON_EXPIRED: + return WC_CEV_COND_CERT_EXPIRED; + case WC_CEV_REASON_NOT_YET_VALID: + return WC_CEV_COND_CERT_NOT_YET_VALID; + case WC_CEV_REASON_SIGNATURE: + return WC_CEV_COND_CERT_SIG_INVALID; + case WC_CEV_REASON_NO_SIGNER: + /* The peer sent the issuer, but it is not a CA. */ + if (cert->certEventNotCaSet && (XMEMCMP(cert->issuerHash, + cert->certEventNotCa, KEYID_SIZE) == 0)) { + return WC_CEV_COND_CERT_NOT_CA; + } + return cert->selfIssued ? WC_CEV_COND_CERT_UNTRUSTED_ROOT : + WC_CEV_COND_CERT_NO_ISSUER; + case WC_CEV_REASON_POLICY: + return (field == WC_CEV_FIELD_SPKI) ? + WC_CEV_COND_CERT_KEY_TOO_SMALL : WC_CEV_COND_NONE; + case WC_CEV_REASON_CONSTRAINT: + if ((error == WC_NO_ERR_TRACE(ASN_PATHLEN_INV_E)) || + (error == WC_NO_ERR_TRACE(ASN_PATHLEN_SIZE_E))) { + return WC_CEV_COND_CERT_PATH_LEN; + } + if (error == WC_NO_ERR_TRACE(ASN_NAME_INVALID_E)) { + return WC_CEV_COND_CERT_NAME_CONSTRAINTS; + } + return WC_CEV_COND_CERT_ISSUER_KU; + case WC_CEV_REASON_UNSUPPORTED: + if (field == WC_CEV_FIELD_EXTENSION) { + return WC_CEV_COND_CERT_EXT_UNKNOWN_CRITICAL; + } + if (field == WC_CEV_FIELD_SPKI) { + return WC_CEV_COND_CERT_KEY_UNSUPPORTED; + } + if ((field == WC_CEV_FIELD_SIGALG) || + (field == WC_CEV_FIELD_TBS_SIGALG)) { + return WC_CEV_COND_CERT_SIG_ALG_UNSUPPORTED; + } + return WC_CEV_COND_CERT_FORMAT; + default: + break; + } + + if (error == WC_NO_ERR_TRACE(ASN_SIG_OID_E)) { + return WC_CEV_COND_CERT_SIG_ALG_MISMATCH; + } + switch (field) { + case WC_CEV_FIELD_EXTENSION: + return WC_CEV_COND_CERT_EXT_VALUE; + case WC_CEV_FIELD_VERSION: + return WC_CEV_COND_CERT_VERSION; + case WC_CEV_FIELD_ISSUER: + return WC_CEV_COND_CERT_ISSUER; + case WC_CEV_FIELD_SUBJECT: + return WC_CEV_COND_CERT_SUBJECT; + default: + return WC_CEV_COND_CERT_FORMAT; + } +} + +/* Fill in and send a DEFECT event for a decoded certificate. + * + * @param [in] cert Decoded certificate. + * @param [in] error wolfSSL error code. + * @param [in] field Field that failed. enum wc_CertEventField. + * @param [in] reason Why it failed. enum wc_CertEventReason. + * @param [in] extOID Extension OID sum when field is an extension. + * @param [in] oidData Extension OID content octets. May be NULL. + * @param [in] oidSz Size of OID content octets in bytes. + * @param [in] critical Whether the extension was marked critical. + * @param [in] condition Condition, or WC_CEV_COND_NONE to choose one from the + * error, field and reason. + */ +static void CertEventDefectOid(DecodedCert* cert, int error, int field, + int reason, word32 extOID, const byte* oidData, word32 oidSz, + byte critical, int condition) +{ + WOLFSSL_CERT_EVENT ev; + + if ((cert == NULL) || (cert->certEventCb == NULL)) { + return; + } + cert->certEventReported = error; + + XMEMSET(&ev, 0, sizeof(ev)); + ev.condition = (condition != WC_CEV_COND_NONE) ? condition : + CertEventCondition(cert, error, field, reason); + wc_CertEventIdentity(cert, &ev); + ev.kind = WC_CEV_KIND_DEFECT; + ev.category = WC_CEV_CAT_CERT; + ev.error = error; + ev.role = cert->certEventRole; + ev.depth = cert->certEventDepth; + ev.field = field; + ev.reason = reason; + ev.extOID = extOID; + ev.extOidData = oidData; + ev.extOidSz = oidSz; + ev.critical = (byte)((critical != 0) ? 1 : 0); + ev.der = cert->source; + ev.derSz = cert->maxIdx; + wc_CertEventSend(cert->certEventCb, cert->certEventCtx, &ev); +} + +/* Report a failed check on a decoded certificate. + * + * Only called on error paths. Does nothing when no callback is set. + * + * @param [in] cert Decoded certificate. + * @param [in] error wolfSSL error code. + * @param [in] field Field that failed. enum wc_CertEventField. + * @param [in] reason Why it failed. enum wc_CertEventReason. + * @param [in] extOID Extension OID sum when field is an extension. + * @param [in] critical Whether the extension was marked critical. + */ +void wc_CertEventDefect(DecodedCert* cert, int error, int field, int reason, + word32 extOID, byte critical) +{ + CertEventDefectOid(cert, error, field, reason, extOID, NULL, 0, critical, + WC_CEV_COND_NONE); +} + +/* Report a failure to decode the certificate's structure. + * + * Sends nothing when a more specific event, such as one for an extension, + * was already sent for this certificate, or when the error is not about the + * certificate: running out of memory, or a date that is checked later. + * + * @param [in] cert Decoded certificate. + * @param [in] error wolfSSL error code. Nothing is sent unless negative. + * @param [in] field Field being decoded. enum wc_CertEventField. + */ +void wc_CertEventField(DecodedCert* cert, int error, int field) +{ + int reason = WC_CEV_REASON_MALFORMED; + + switch (error) { + case WC_NO_ERR_TRACE(ASN_UNKNOWN_OID_E): + case WC_NO_ERR_TRACE(ASN_SIG_HASH_E): + case WC_NO_ERR_TRACE(ASN_SIG_KEY_E): + case WC_NO_ERR_TRACE(ECC_CURVE_OID_E): + case WC_NO_ERR_TRACE(NOT_COMPILED_IN): + reason = WC_CEV_REASON_UNSUPPORTED; + break; + default: + break; + } + wc_CertEventFailure(cert, error, field, reason); +} + +/* Report a failure, unless the same error was just reported for this + * certificate. + * + * Sends nothing for errors that are not about the certificate, such as + * running out of memory, or for dates, which are reported separately. + * + * @param [in] cert Decoded certificate. + * @param [in] error wolfSSL error code. Nothing is sent unless negative. + * @param [in] field Field that failed. enum wc_CertEventField. + * @param [in] reason Why it failed. enum wc_CertEventReason. + */ +void wc_CertEventFailure(DecodedCert* cert, int error, int field, int reason) +{ + wc_CertEventFailureCond(cert, error, field, reason, WC_CEV_COND_NONE); +} + +/* Report a failure with a given condition, unless the same error was just + * reported for this certificate. + * + * The same error reaches here again as it is passed up from where it was + * found; a different error is a further failed check and is reported. + * + * Used where wolfCrypt cannot tell the condition from the error, such as the + * TLS checks on what the certificate may be used for. + * + * @param [in] cert Decoded certificate. + * @param [in] error wolfSSL error code. Nothing is sent unless negative. + * @param [in] field Field that failed. enum wc_CertEventField. + * @param [in] reason Why it failed. enum wc_CertEventReason. + * @param [in] condition Condition. enum wc_CertEventCondition. + */ +void wc_CertEventFailureCond(DecodedCert* cert, int error, int field, + int reason, int condition) +{ + if ((cert == NULL) || (error >= 0) || + (error == cert->certEventReported)) { + return; + } + switch (error) { + case WC_NO_ERR_TRACE(MEMORY_E): + case WC_NO_ERR_TRACE(BAD_FUNC_ARG): + case WC_NO_ERR_TRACE(WC_PENDING_E): + case WC_NO_ERR_TRACE(ASN_BEFORE_DATE_E): + case WC_NO_ERR_TRACE(ASN_AFTER_DATE_E): + return; + default: + break; + } + CertEventDefectOid(cert, error, field, reason, 0, NULL, 0, 0, condition); +} + +/* Report why verifying a certificate against its signer failed. + * + * Called once ParseCertRelative() is done. A failure already reported, such + * as a field that failed to decode, is not reported again; any other failure + * is reported so that each failure has an event. + * + * @param [in] cert Decoded certificate. + * @param [in] error Return of ParseCertRelative(). + */ +static void CertEventChain(DecodedCert* cert, int error) +{ + switch (error) { + case WC_NO_ERR_TRACE(ASN_NO_SIGNER_E): + case WC_NO_ERR_TRACE(ASN_SELF_SIGNED_E): + wc_CertEventFailure(cert, error, WC_CEV_FIELD_CHAIN, + WC_CEV_REASON_NO_SIGNER); + break; + case WC_NO_ERR_TRACE(ASN_SIG_CONFIRM_E): + wc_CertEventFailure(cert, error, WC_CEV_FIELD_SIGNATURE, + WC_CEV_REASON_SIGNATURE); + break; + case WC_NO_ERR_TRACE(ASN_PATHLEN_INV_E): + case WC_NO_ERR_TRACE(ASN_PATHLEN_SIZE_E): + case WC_NO_ERR_TRACE(ASN_NAME_INVALID_E): + case WC_NO_ERR_TRACE(KEYUSAGE_E): + wc_CertEventFailure(cert, error, WC_CEV_FIELD_CHAIN, + WC_CEV_REASON_CONSTRAINT); + break; + default: + wc_CertEventField(cert, error, WC_CEV_FIELD_NONE); + break; + } +} + +#ifdef WOLFSSL_ASN_TEMPLATE +/* Report a certificate extension that failed to decode. + * + * An unknown extension marked critical is unsupported; any other failure + * means the extension is malformed. + * + * @param [in] cert Decoded certificate. + * @param [in] error wolfSSL error code. + * @param [in] oid Extension OID sum, 0 when not known. + * @param [in] oidData Extension OID content octets. May be NULL. + * @param [in] oidSz Size of OID content octets in bytes. + * @param [in] critical Whether the extension was marked critical. + */ +static void CertEventExtension(DecodedCert* cert, int error, word32 oid, + const byte* oidData, word32 oidSz, + byte critical) +{ + CertEventDefectOid(cert, error, WC_CEV_FIELD_EXTENSION, + (error == WC_NO_ERR_TRACE(ASN_CRIT_EXT_E)) ? + WC_CEV_REASON_UNSUPPORTED : WC_CEV_REASON_MALFORMED, + oid, oidData, oidSz, critical, + WC_CEV_COND_NONE); +} +#endif /* WOLFSSL_ASN_TEMPLATE */ +#endif /* WOLFSSL_CERT_EVENTS */ + /* * Processing the Certificate Extensions. This does not modify the current * index. It is works starting with the recorded extensions pointer. @@ -24142,10 +24512,23 @@ static int DecodeCertExtensions(DecodedCert* cert) #else (void)isUnknownExt; #endif +#ifdef WOLFSSL_CERT_EVENTS + if (ret != 0) { + CertEventExtension(cert, ret, oid, + dataASN[CERTEXTASN_IDX_OID].data.oid.data, + dataASN[CERTEXTASN_IDX_OID].data.oid.length, critical); + } +#endif /* Move index on to next extension. */ idx += length; } +#ifdef WOLFSSL_CERT_EVENTS + else { + /* The extension's own wrapper is malformed. */ + CertEventExtension(cert, ret, 0, NULL, 0, critical); + } +#endif /* Don't fail criticality until all other extensions have been checked. */ if (ret == WC_NO_ERR_TRACE(ASN_CRIT_EXT_E)) { @@ -24377,6 +24760,71 @@ static int CheckDate(ASNGetData *dataASN, int dateType) return ret; } +#ifdef WOLFSSL_CERT_EVENTS +/* Find which field of the certificate failed to parse. + * + * GetASN_Items() records each item's offset before checking it, and the data + * starts zeroed, so the last item with an offset is the one that failed. + * + * @param [in] dataASN Template data from a failed GetASN_Items() call. + * @return Field that failed. enum wc_CertEventField. + */ +static int CertEventTemplateField(const ASNGetData* dataASN) +{ + int i; + + for (i = (int)x509CertASN_Length - 1; i > 0; i--) { + if (dataASN[i].offset != 0) { + break; + } + } + + /* The two time formats are optional choices, so a value that is neither + * is skipped and the failure shows at the next required item. A failure + * after the validity with no notBefore or notAfter found is in the + * validity. */ + if ((i >= X509CERTASN_IDX_TBS_SUBJECT_SEQ) && + (((dataASN[X509CERTASN_IDX_TBS_VALIDITY_NOTB_UTC].tag == 0) && + (dataASN[X509CERTASN_IDX_TBS_VALIDITY_NOTB_GT].tag == 0)) || + ((dataASN[X509CERTASN_IDX_TBS_VALIDITY_NOTA_UTC].tag == 0) && + (dataASN[X509CERTASN_IDX_TBS_VALIDITY_NOTA_GT].tag == 0)))) { + return WC_CEV_FIELD_VALIDITY; + } + + if (i >= X509CERTASN_IDX_SIGNATURE) + return WC_CEV_FIELD_SIGNATURE; + if (i >= X509CERTASN_IDX_SIGALGO_SEQ) + return WC_CEV_FIELD_SIGALG; + if (i >= X509CERTASN_IDX_TBS_EXT) + return WC_CEV_FIELD_EXTENSION; + if (i == X509CERTASN_IDX_TBS_SUBJECTUID) + return WC_CEV_FIELD_SUBJECT_UID; + if (i == X509CERTASN_IDX_TBS_ISSUERUID) + return WC_CEV_FIELD_ISSUER_UID; + if (i >= X509CERTASN_IDX_TBS_SPUBKEYINFO_SEQ) + return WC_CEV_FIELD_SPKI; + if (i >= X509CERTASN_IDX_TBS_SUBJECT_SEQ) + return WC_CEV_FIELD_SUBJECT; + if (i >= X509CERTASN_IDX_TBS_VALIDITY_SEQ) + return WC_CEV_FIELD_VALIDITY; + if (i >= X509CERTASN_IDX_TBS_ISSUER_SEQ) + return WC_CEV_FIELD_ISSUER; + if (i >= X509CERTASN_IDX_TBS_ALGOID_SEQ) + return WC_CEV_FIELD_TBS_SIGALG; + if (i == X509CERTASN_IDX_TBS_SERIAL) + return WC_CEV_FIELD_SERIAL; + if (i >= X509CERTASN_IDX_TBS_VER) + return WC_CEV_FIELD_VERSION; + return WC_CEV_FIELD_ENCODING; +} + + /* Record the field about to be decoded, for the event sent on failure. */ + #define CERT_EVENT_AT(field, ret, f) \ + do { if ((ret) == 0) (field) = (f); } while (0) +#else + #define CERT_EVENT_AT(field, ret, f) WC_DO_NOTHING +#endif /* WOLFSSL_CERT_EVENTS */ + /* Decode a certificate. Internal/non-public API. * * @param [in] cert Certificate object. @@ -24418,6 +24866,9 @@ static int DecodeCertInternal(DecodedCert* cert, int verify, int* criticalExt, word32 pubKeyOffset = 0; word32 pubKeyEnd = 0; int done = 0; +#ifdef WOLFSSL_CERT_EVENTS + int cevField = WC_CEV_FIELD_ENCODING; +#endif #if defined(HAVE_RPK) /* try to parse the cert as Raw Public Key cert */ @@ -24508,6 +24959,11 @@ static int DecodeCertInternal(DecodedCert* cert, int verify, int* criticalExt, ret = ASN_PARSE_E; } #endif + #ifdef WOLFSSL_CERT_EVENTS + if (ret < 0) { + cevField = CertEventTemplateField(dataASN); + } + #endif } #ifndef WOLFSSL_NO_ASN_STRICT /* cert->srcIdx is now just past the certificate's outer SEQUENCE. Reject @@ -24522,6 +24978,7 @@ static int DecodeCertInternal(DecodedCert* cert, int verify, int* criticalExt, ret = ASN_PARSE_E; } #endif /* !WOLFSSL_NO_ASN_STRICT */ + CERT_EVENT_AT(cevField, ret, WC_CEV_FIELD_VERSION); /* Check version is valid/supported - can't be negative. */ if ((ret == 0) && (version > MAX_X509_VERSION)) { WOLFSSL_MSG("Unexpected certificate version"); @@ -24536,6 +24993,7 @@ static int DecodeCertInternal(DecodedCert* cert, int verify, int* criticalExt, cert->version = version; cert->serialSz = (int)serialSz; + CERT_EVENT_AT(cevField, ret, WC_CEV_FIELD_SERIAL); /* RFC 5280 requires serial number to be present and at least 1 byte */ if (cert->serialSz == 0) { WOLFSSL_MSG("Error: certificate serial number is empty " @@ -24594,6 +25052,7 @@ static int DecodeCertInternal(DecodedCert* cert, int verify, int* criticalExt, done = 1; } + CERT_EVENT_AT(cevField, ret, WC_CEV_FIELD_SIGALG); if ((ret == 0) && (!done)) { /* Store the signature information. */ cert->sigIndex = dataASN[X509CERTASN_IDX_SIGALGO_SEQ].offset; @@ -24686,6 +25145,7 @@ static int DecodeCertInternal(DecodedCert* cert, int verify, int* criticalExt, if ((ret == 0) && (!done) && (dataASN[X509CERTASN_IDX_TBS_EXT_SEQ].data.ref.data != NULL)) { #ifndef ALLOW_V1_EXTENSIONS + CERT_EVENT_AT(cevField, ret, WC_CEV_FIELD_VERSION); /* Certificate extensions were only defined in version 2. */ if (cert->version < 2) { WOLFSSL_MSG("\tv1 and v2 certs not allowed extensions"); @@ -24706,12 +25166,14 @@ static int DecodeCertInternal(DecodedCert* cert, int verify, int* criticalExt, /* Dispose of memory before allocating for extension decoding. */ FREE_ASNGETDATA(dataASN, cert->heap); + CERT_EVENT_AT(cevField, ret, WC_CEV_FIELD_ISSUER); if ((ret == 0) && (issuer != NULL)) { idx = 0; /* Put issuer into cert and calculate hash. */ ret = GetCertName(cert, cert->issuer, cert->issuerHash, ASN_ISSUER, issuer, &idx, issuerSz); } + CERT_EVENT_AT(cevField, ret, WC_CEV_FIELD_SUBJECT); if ((ret == 0) && (subject != NULL)) { idx = 0; /* Put subject into cert and calculate hash. */ @@ -24735,11 +25197,13 @@ static int DecodeCertInternal(DecodedCert* cert, int verify, int* criticalExt, } } + CERT_EVENT_AT(cevField, ret, WC_CEV_FIELD_SPKI); if ((ret == 0) && (!stopAtPubKey)) { /* Parse the public key. */ idx = pubKeyOffset; ret = GetCertKey(cert, cert->source, &idx, pubKeyEnd); } + CERT_EVENT_AT(cevField, ret, WC_CEV_FIELD_EXTENSION); if ((ret == 0) && (!stopAtPubKey) && (!stopAfterPubKey) && (cert->extensions != NULL)) { /* Decode the extension data starting at [3]. */ @@ -24773,6 +25237,7 @@ static int DecodeCertInternal(DecodedCert* cert, int verify, int* criticalExt, * narrow: when extensions are not parsed (stopAtPubKey/stopAfterPubKey) * isCA is not populated, so the exemption never fires and serial-0 is * always rejected on those paths. */ + CERT_EVENT_AT(cevField, ret, WC_CEV_FIELD_SERIAL); if ((ret == 0) && (cert->serialSz == 1) && (cert->serial[0] == 0)) { if (!(cert->isCA && cert->selfIssued) #ifdef WOLFSSL_CERT_REQ @@ -24785,6 +25250,10 @@ static int DecodeCertInternal(DecodedCert* cert, int verify, int* criticalExt, } #endif +#ifdef WOLFSSL_CERT_EVENTS + /* One event for a structural failure; extensions report their own. */ + wc_CertEventField(cert, ret, cevField); +#endif return ret; } @@ -26137,8 +26606,34 @@ static WC_NO_INLINE int ConfirmSelfSignature(DecodedCert* cert) return ret; } +static int ParseCertRelativeInternal(DecodedCert* cert, int type, int verify, + WOLFSSL_CERT_MANAGER* cm, Signer *extraCAList); + +/* Parse a certificate and verify it against its signer. + * + * With WOLFSSL_CERT_EVENTS, a failure that was not reported while decoding + * is reported here, so that each failure has an event. + * + * @param [in, out] cert Decoded certificate. + * @param [in] type Type of certificate. + * @param [in] verify What verification to do. + * @param [in] cm Certificate manager. May be NULL. + * @param [in] extraCAList Extra signers to try. May be NULL. + * @return 0 on success. + * @return Negative on failure. + */ int ParseCertRelative(DecodedCert* cert, int type, int verify, WOLFSSL_CERT_MANAGER* cm, Signer *extraCAList) +{ + int ret = ParseCertRelativeInternal(cert, type, verify, cm, extraCAList); +#ifdef WOLFSSL_CERT_EVENTS + CertEventChain(cert, ret); +#endif + return ret; +} + +static int ParseCertRelativeInternal(DecodedCert* cert, int type, int verify, + WOLFSSL_CERT_MANAGER* cm, Signer *extraCAList) { int ret = 0; #ifndef WOLFSSL_ASN_TEMPLATE @@ -26997,6 +27492,12 @@ int ParseCertRelative(DecodedCert* cert, int type, int verify, if (cert->badDate != 0) { if (verify != VERIFY_SKIP_DATE) { + #ifdef WOLFSSL_CERT_EVENTS + wc_CertEventDefect(cert, cert->badDate, WC_CEV_FIELD_VALIDITY, + (cert->badDate == WC_NO_ERR_TRACE(ASN_BEFORE_DATE_E)) ? + WC_CEV_REASON_NOT_YET_VALID : WC_CEV_REASON_EXPIRED, + 0, 0); + #endif return cert->badDate; } WOLFSSL_MSG_CERT_LOG("Date error: Verify option is skipping"); diff --git a/wolfssl/internal.h b/wolfssl/internal.h index 22ba3e9ce3f..5e4870c6dba 100644 --- a/wolfssl/internal.h +++ b/wolfssl/internal.h @@ -2993,6 +2993,10 @@ struct WOLFSSL_CERT_MANAGER { #ifdef HAVE_CRL_UPDATE_CB CbUpdateCRL cbUpdateCRL; /* notify thru cb that crl has updated */ #endif +#ifdef WOLFSSL_CERT_EVENTS + WOLFSSL_CERT_EVENT_CB certEventCb; /* validation event callback */ + void* certEventCtx; /* passed to certEventCb */ +#endif }; WOLFSSL_LOCAL int CM_SaveCertCache(WOLFSSL_CERT_MANAGER* cm, @@ -3007,6 +3011,14 @@ WOLFSSL_LOCAL int CM_GetCertCacheMemSize(WOLFSSL_CERT_MANAGER* cm); WOLFSSL_LOCAL int CM_VerifyBuffer_ex(WOLFSSL_CERT_MANAGER* cm, const byte* buff, long sz, int format, int prev_err, int* crlErr); +#ifdef WOLFSSL_CERT_EVENTS +WOLFSSL_LOCAL int CM_VerifyBufferDepth(WOLFSSL_CERT_MANAGER* cm, + const byte* buff, long sz, int format, + int depth, int* crlErr); +WOLFSSL_LOCAL void CM_CertEventResult(WOLFSSL_CERT_MANAGER* cm, int error, + int depth, const byte* der, + word32 derSz, const DecodedCert* cert); +#endif #ifndef NO_CERTS @@ -3059,6 +3071,11 @@ typedef struct ProcPeerCertArgs { #ifdef OPENSSL_ALL word16 peerCertVerified:1; /* cert verify callback accepted peer cert */ #endif +#ifdef WOLFSSL_CERT_EVENTS + word16 notCaSet:1; /* notCaHash is set */ + byte notCaHash[KEYID_SIZE]; /* Subject hash of a certificate the peer + * sent that is not a CA */ +#endif } ProcPeerCertArgs; WOLFSSL_LOCAL int DoVerifyCallback(WOLFSSL_CERT_MANAGER* cm, WOLFSSL* ssl, int cert_err, ProcPeerCertArgs* args); @@ -7410,6 +7427,12 @@ struct WOLFSSL { #ifdef HAVE_CERTIFICATE_STATUS_REQUEST_V2 byte status_request_v2; #endif + #if defined(WOLFSSL_CERT_EVENTS) && \ + (defined(HAVE_CERTIFICATE_STATUS_REQUEST) || \ + defined(HAVE_CERTIFICATE_STATUS_REQUEST_V2)) + /* The peer certificate's RESULT event waits for its status. */ + byte certEventResultHeld; + #endif #if defined(HAVE_CRL) && (defined(HAVE_CERTIFICATE_STATUS_REQUEST) || \ defined(HAVE_CERTIFICATE_STATUS_REQUEST_V2)) /* Leaf CRL verdict taken while the DecodedCert was alive, applied at diff --git a/wolfssl/ssl.h b/wolfssl/ssl.h index 817ad51ac26..8864439bed1 100644 --- a/wolfssl/ssl.h +++ b/wolfssl/ssl.h @@ -2607,6 +2607,11 @@ WOLFSSL_API WOLFSSL_X509_STORE_CTX *wolfSSL_X509_STORE_CTX_get0_parent_ctx( WOLFSSL_X509_STORE_CTX *ctx); WOLFSSL_API int wolfSSL_X509_STORE_set_flags(WOLFSSL_X509_STORE* store, unsigned long flag); +#ifdef WOLFSSL_CERT_EVENTS +/* Register a validation event callback on the store, for X509_verify_cert(). */ +WOLFSSL_API int wolfSSL_X509_STORE_SetCertEventCb(WOLFSSL_X509_STORE* store, + WOLFSSL_CERT_EVENT_CB cb, void* ctx); +#endif WOLFSSL_API int wolfSSL_X509_STORE_get_by_subject(WOLFSSL_X509_STORE_CTX* ctx, int idx, WOLFSSL_X509_NAME* name, WOLFSSL_X509_OBJECT* obj); WOLFSSL_API WOLFSSL_X509_VERIFY_PARAM *wolfSSL_X509_STORE_CTX_get0_param( @@ -4677,6 +4682,16 @@ WOLFSSL_API void wolfSSL_CTX_SetPerformTlsRecordProcessingCb(WOLFSSL_CTX* ctx, WOLFSSL_API void wolfSSL_CertManagerFree(WOLFSSL_CERT_MANAGER* cm); WOLFSSL_API int wolfSSL_CertManager_up_ref(WOLFSSL_CERT_MANAGER* cm); +#ifdef WOLFSSL_CERT_EVENTS + /* Register a callback that observes certificate validation events: one + * DEFECT event per failed check, and one RESULT event when a verification + * finishes. Events never change the verification result. */ + WOLFSSL_API int wolfSSL_CertManagerSetCertEventCb(WOLFSSL_CERT_MANAGER* cm, + WOLFSSL_CERT_EVENT_CB cb, void* ctx); + WOLFSSL_API int wolfSSL_CTX_SetCertEventCb(WOLFSSL_CTX* ctx, + WOLFSSL_CERT_EVENT_CB cb, void* cbCtx); +#endif + #ifdef WC_ASN_UNKNOWN_EXT_CB /* Register a callback invoked for each certificate extension whose OID * the parser does not recognize. Returning 0 accepts the extension; a diff --git a/wolfssl/wolfcrypt/asn.h b/wolfssl/wolfcrypt/asn.h index d5f89a90f0e..c608103688d 100644 --- a/wolfssl/wolfcrypt/asn.h +++ b/wolfssl/wolfcrypt/asn.h @@ -2322,6 +2322,19 @@ struct DecodedCert { void* unknownExtCallbackExCtx; void* unknownExtCallback32ExCtx; #endif +#ifdef WOLFSSL_CERT_EVENTS + WOLFSSL_CERT_EVENT_CB certEventCb; /* Validation event callback */ + void* certEventCtx; /* Callback context */ + int certEventRole; /* enum wc_CertEventRole */ + int certEventDepth; /* Chain depth, -1 unknown */ + int certEventReported; /* Error of the last + * DEFECT sent, 0 if none */ + byte certEventNotCaSet; /* certEventNotCa is set */ + byte certEventNotCa[KEYID_SIZE]; /* Subject hash + * of a certificate the peer + * sent that is not a CA */ + void* certEventSsl; /* TLS connection, or NULL */ +#endif #ifdef WOLFSSL_DUAL_ALG_CERTS /* Subject Alternative Public Key Info */ byte *sapkiDer; @@ -2606,6 +2619,28 @@ WOLFSSL_API int wc_SetUnknownExtCallback32Ex(DecodedCert* cert, void *ctx); #endif +#ifdef WOLFSSL_CERT_EVENTS +WOLFSSL_API int wc_SetCertEventCallback(DecodedCert* cert, + WOLFSSL_CERT_EVENT_CB cb, void* ctx); +WOLFSSL_LOCAL void wc_CertEventSetConnection(DecodedCert* cert, void* ssl, + const byte* notCaHash); +WOLFSSL_LOCAL void wc_CertEventIdentity(const DecodedCert* cert, + WOLFSSL_CERT_EVENT* ev); +WOLFSSL_LOCAL void wc_CertEventSetPosition(DecodedCert* cert, int role, + int depth); +WOLFSSL_LOCAL void wc_CertEventSend(WOLFSSL_CERT_EVENT_CB cb, void* ctx, + WOLFSSL_CERT_EVENT* ev); +WOLFSSL_LOCAL void wc_CertEventDefect(DecodedCert* cert, int error, + int field, int reason, word32 extOID, + byte critical); +WOLFSSL_LOCAL void wc_CertEventField(DecodedCert* cert, int error, int field); +WOLFSSL_LOCAL void wc_CertEventFailure(DecodedCert* cert, int error, + int field, int reason); +WOLFSSL_LOCAL void wc_CertEventFailureCond(DecodedCert* cert, int error, + int field, int reason, + int condition); +#endif + WOLFSSL_LOCAL int DecodePolicyOID(char *out, word32 outSz, const byte *in, word32 inSz); WOLFSSL_LOCAL int EncodePolicyOID(byte *out, word32 *outSz, diff --git a/wolfssl/wolfcrypt/asn_public.h b/wolfssl/wolfcrypt/asn_public.h index 142e0656b2a..68f2d2bcdf5 100644 --- a/wolfssl/wolfcrypt/asn_public.h +++ b/wolfssl/wolfcrypt/asn_public.h @@ -1204,6 +1204,158 @@ WOLFSSL_API int wc_Asn1_PrintAll(Asn1* asn1, Asn1PrintOptions* opts, #endif /* WOLFSSL_ASN_PRINT */ +#ifdef WOLFSSL_CERT_EVENTS +/* Certificate and CRL validation events. + * + * An event describes one failed check (DEFECT) or the outcome of one + * verification (RESULT). Values are only ever appended to these enums so + * that existing applications keep working. */ + +/* What the event reports. */ +enum wc_CertEventKind { + WC_CEV_KIND_DEFECT = 0, /* A check failed. May still be recovered. */ + WC_CEV_KIND_RESULT = 1 /* End of one verification. */ +}; + +/* Kind of object being validated. */ +enum wc_CertEventCategory { + WC_CEV_CAT_CERT = 0, + WC_CEV_CAT_CRL = 1 +}; + +/* Which object in the chain failed. */ +enum wc_CertEventRole { + WC_CEV_ROLE_CANDIDATE = 0, /* End-entity or peer certificate. */ + WC_CEV_ROLE_SIGNER = 1, /* CA that signed the candidate. */ + WC_CEV_ROLE_TRUST_ANCHOR = 2, /* CA being loaded as trusted. */ + WC_CEV_ROLE_CRL = 3, + WC_CEV_ROLE_CRL_SIGNER = 4 +}; + +/* Which part of the object failed, using RFC 5280 names. */ +enum wc_CertEventField { + WC_CEV_FIELD_NONE = 0, /* RESULT events, or not known. */ + WC_CEV_FIELD_ENCODING = 1, /* Not DER or not parseable. */ + WC_CEV_FIELD_VERSION = 2, + WC_CEV_FIELD_SERIAL = 3, + WC_CEV_FIELD_TBS_SIGALG = 4, + WC_CEV_FIELD_ISSUER = 5, + WC_CEV_FIELD_VALIDITY = 6, + WC_CEV_FIELD_SUBJECT = 7, + WC_CEV_FIELD_SPKI = 8, + WC_CEV_FIELD_ISSUER_UID = 9, + WC_CEV_FIELD_SUBJECT_UID = 10, + WC_CEV_FIELD_EXTENSION = 11, /* See extOID. */ + WC_CEV_FIELD_SIGALG = 12, + WC_CEV_FIELD_SIGNATURE = 13, + WC_CEV_FIELD_CHAIN = 14, /* Signer lookup, CA flag, path. */ + WC_CEV_FIELD_CRL_THIS_UPDATE = 15, + WC_CEV_FIELD_CRL_NEXT_UPDATE = 16, + WC_CEV_FIELD_CRL_REVOKED = 17 +}; + +/* Why the check failed. */ +enum wc_CertEventReason { + WC_CEV_REASON_NONE = 0, /* RESULT events, or not known. */ + WC_CEV_REASON_MALFORMED = 1, /* Present but badly encoded. */ + WC_CEV_REASON_MISSING = 2, /* Required but not present. */ + WC_CEV_REASON_UNSUPPORTED = 3, /* Unknown OID or not compiled in. */ + WC_CEV_REASON_NOT_YET_VALID = 4, + WC_CEV_REASON_EXPIRED = 5, + WC_CEV_REASON_SIGNATURE = 6, /* Signature does not verify. */ + WC_CEV_REASON_NO_SIGNER = 7, /* Issuer not found or not a CA. */ + WC_CEV_REASON_REVOKED = 8, + WC_CEV_REASON_POLICY = 9, /* A policy check fired: a key + * that is too small. */ + WC_CEV_REASON_CONSTRAINT = 10 /* A constraint is broken: the + * signer's CA flag or key usage, + * path length, name constraints, or + * the uses the certificate allows. */ +}; + +/* One stable value per condition, for applications to map to their own + * codes. Named after the IEC 62351-9 and IEC 62351-3 audit events. */ +enum wc_CertEventCondition { + WC_CEV_COND_NONE = 0, + WC_CEV_COND_CERT_FORMAT = 1, /* Not decodable; see field. */ + WC_CEV_COND_CERT_VERSION = 2, + WC_CEV_COND_CERT_ISSUER = 3, /* Issuer name invalid. */ + WC_CEV_COND_CERT_SUBJECT = 4, + WC_CEV_COND_CERT_EXT_UNKNOWN_CRITICAL = 5, + WC_CEV_COND_CERT_EXT_VALUE = 6, /* See extOidData. */ + WC_CEV_COND_CERT_EXPIRED = 7, + WC_CEV_COND_CERT_NOT_YET_VALID = 8, + WC_CEV_COND_CERT_SIG_INVALID = 9, + WC_CEV_COND_CERT_SIG_ALG_UNSUPPORTED = 10, + WC_CEV_COND_CERT_SIG_ALG_MISMATCH = 11, /* Inner and outer differ. */ + WC_CEV_COND_CERT_KEY_UNSUPPORTED = 12, + WC_CEV_COND_CERT_KEY_TOO_SMALL = 13, /* Below the minimum set. */ + WC_CEV_COND_CERT_NO_ISSUER = 14, /* No trusted CA matches. */ + WC_CEV_COND_CERT_UNTRUSTED_ROOT = 15, /* Self-issued, not trusted. */ + WC_CEV_COND_CERT_NOT_CA = 16, /* Issuer the peer sent is not + * a CA. */ + WC_CEV_COND_CERT_ISSUER_KU = 17, /* CA without keyCertSign. */ + WC_CEV_COND_CERT_PATH_LEN = 18, + WC_CEV_COND_CERT_NAME_CONSTRAINTS = 19, + WC_CEV_COND_CERT_KU_PURPOSE = 20, /* Key usage forbids the use. */ + WC_CEV_COND_CERT_EKU_PURPOSE = 21, /* EKU forbids the use. */ + WC_CEV_COND_TLS_NO_PEER_CERT = 22, + WC_CEV_COND_TLS_CHAIN_TOO_LONG = 23, + /* Revocation, on the certificate checked. */ + WC_CEV_COND_CERT_REVOKED = 24, + WC_CEV_COND_CRL_MISSING = 25, /* No CRL from its issuer. */ + WC_CEV_COND_CRL_EXPIRED = 26, /* Past the CRL's nextUpdate. */ + /* A CRL that is rejected, when loaded or when used. */ + WC_CEV_COND_CRL_FORMAT = 27, + WC_CEV_COND_CRL_SIG_INVALID = 28, + WC_CEV_COND_CRL_NO_SIGNER = 29, /* Issuer not trusted. */ + WC_CEV_COND_CRL_SIGNER_KU = 30, /* Issuer lacks cRLSign. */ + WC_CEV_COND_CRL_EXT_UNKNOWN_CRITICAL = 31 +}; + +/* One validation event. Pointers are only valid during the callback and + * point at untrusted input: escape before logging. */ +typedef struct WOLFSSL_CERT_EVENT { + word32 size; /* sizeof(WOLFSSL_CERT_EVENT). */ + int kind; /* enum wc_CertEventKind */ + int category; /* enum wc_CertEventCategory */ + int error; /* wolfSSL error code, 0 on success. */ + int role; /* enum wc_CertEventRole */ + int depth; /* Chain depth, -1 when not known. */ + int field; /* enum wc_CertEventField */ + int reason; /* enum wc_CertEventReason */ + word32 extOID; /* Extension OID sum, 0 when none. The + * sums depend on the build: compare + * with wolfSSL's OID constants or use + * extOidData. */ + const unsigned char* extOidData; /* Extension OID content octets, the + * same in every build. NULL when + * none. */ + word32 extOidSz; + byte critical; /* 1 when the extension was marked + * critical, otherwise 0. */ + const unsigned char* der; /* Encoded object, may be NULL. */ + word32 derSz; + int condition; /* enum wc_CertEventCondition */ + /* Which certificate, when it was decoded far enough. NULL when not + * known. */ + const char* subject; /* Subject name, one line. */ + const char* issuer; /* Issuer name, one line. */ + const unsigned char* serial; /* Serial number, big-endian. */ + word32 serialSz; + /* The TLS connection (WOLFSSL*) whose handshake raised the event, NULL + * outside a handshake. Use it to find the peer, for example its socket + * with wolfSSL_get_fd(). */ + void* ssl; +} WOLFSSL_CERT_EVENT; + +/* Observes events only: it cannot accept a certificate. Use the verify + * callback to override a failure. Must not call back into the certificate + * manager that raised the event, and may run on several threads at once. */ +typedef void (*WOLFSSL_CERT_EVENT_CB)(const WOLFSSL_CERT_EVENT* ev, + void* ctx); +#endif /* WOLFSSL_CERT_EVENTS */ + #ifdef __cplusplus } /* extern "C" */ #endif