[email protected] | 2662ed56 | 2013-07-03 10:27:46 | [diff] [blame] | 1 | // Copyright 2013 The Chromium Authors. All rights reserved. |
| 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
Ryan Hamilton | a3ee93a7 | 2018-08-01 22:03:08 | [diff] [blame] | 5 | #include "net/quic/crypto/proof_verifier_chromium.h" |
[email protected] | 2662ed56 | 2013-07-03 10:27:46 | [diff] [blame] | 6 | |
dcheng | c7eeda42 | 2015-12-26 03:56:48 | [diff] [blame] | 7 | #include <utility> |
| 8 | |
[email protected] | 2662ed56 | 2013-07-03 10:27:46 | [diff] [blame] | 9 | #include "base/bind.h" |
| 10 | #include "base/bind_helpers.h" |
| 11 | #include "base/callback_helpers.h" |
[email protected] | 2662ed56 | 2013-07-03 10:27:46 | [diff] [blame] | 12 | #include "base/logging.h" |
Ilya Sherman | 0eb3980 | 2017-12-08 20:58:18 | [diff] [blame] | 13 | #include "base/metrics/histogram_functions.h" |
asvitkine | c3c9372 | 2015-06-17 14:48:37 | [diff] [blame] | 14 | #include "base/metrics/histogram_macros.h" |
[email protected] | 2662ed56 | 2013-07-03 10:27:46 | [diff] [blame] | 15 | #include "base/strings/stringprintf.h" |
| 16 | #include "crypto/signature_verifier.h" |
estark | 1a66df7 | 2015-07-28 15:24:00 | [diff] [blame] | 17 | #include "net/base/host_port_pair.h" |
[email protected] | 2662ed56 | 2013-07-03 10:27:46 | [diff] [blame] | 18 | #include "net/base/net_errors.h" |
[email protected] | 2662ed56 | 2013-07-03 10:27:46 | [diff] [blame] | 19 | #include "net/cert/cert_status_flags.h" |
| 20 | #include "net/cert/cert_verifier.h" |
estark | 6f9b3d8 | 2016-01-12 21:37:05 | [diff] [blame] | 21 | #include "net/cert/ct_policy_enforcer.h" |
estark | 723b5eeb | 2016-02-18 21:01:12 | [diff] [blame] | 22 | #include "net/cert/ct_policy_status.h" |
rtenneti | 052774e | 2015-11-24 21:00:12 | [diff] [blame] | 23 | #include "net/cert/ct_verifier.h" |
[email protected] | 2662ed56 | 2013-07-03 10:27:46 | [diff] [blame] | 24 | #include "net/cert/x509_util.h" |
[email protected] | 080b7793 | 2014-08-04 01:22:46 | [diff] [blame] | 25 | #include "net/http/transport_security_state.h" |
Victor Vasiliev | 6bb59d2 | 2019-03-08 21:34:51 | [diff] [blame] | 26 | #include "net/third_party/quiche/src/quic/core/crypto/crypto_protocol.h" |
[email protected] | 2662ed56 | 2013-07-03 10:27:46 | [diff] [blame] | 27 | |
[email protected] | 2662ed56 | 2013-07-03 10:27:46 | [diff] [blame] | 28 | using base::StringPrintf; |
| 29 | using std::string; |
[email protected] | 2662ed56 | 2013-07-03 10:27:46 | [diff] [blame] | 30 | |
| 31 | namespace net { |
| 32 | |
dadrian | df302c4 | 2016-06-10 18:48:59 | [diff] [blame] | 33 | ProofVerifyDetailsChromium::ProofVerifyDetailsChromium() |
Carlos IL | 8113338 | 2017-12-06 17:18:45 | [diff] [blame] | 34 | : pkp_bypassed(false), is_fatal_cert_error(false) {} |
dadrian | df302c4 | 2016-06-10 18:48:59 | [diff] [blame] | 35 | |
| 36 | ProofVerifyDetailsChromium::~ProofVerifyDetailsChromium() {} |
| 37 | |
| 38 | ProofVerifyDetailsChromium::ProofVerifyDetailsChromium( |
| 39 | const ProofVerifyDetailsChromium&) = default; |
| 40 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 41 | quic::ProofVerifyDetails* ProofVerifyDetailsChromium::Clone() const { |
[email protected] | 92bc621d | 2014-07-29 21:42:13 | [diff] [blame] | 42 | ProofVerifyDetailsChromium* other = new ProofVerifyDetailsChromium; |
| 43 | other->cert_verify_result = cert_verify_result; |
rtenneti | 052774e | 2015-11-24 21:00:12 | [diff] [blame] | 44 | other->ct_verify_result = ct_verify_result; |
[email protected] | 92bc621d | 2014-07-29 21:42:13 | [diff] [blame] | 45 | return other; |
| 46 | } |
| 47 | |
[email protected] | 5c78ce6 | 2014-03-13 19:48:01 | [diff] [blame] | 48 | // A Job handles the verification of a single proof. It is owned by the |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 49 | // quic::ProofVerifier. If the verification can not complete synchronously, it |
| 50 | // will notify the quic::ProofVerifier upon completion. |
[email protected] | 5c78ce6 | 2014-03-13 19:48:01 | [diff] [blame] | 51 | class ProofVerifierChromium::Job { |
| 52 | public: |
| 53 | Job(ProofVerifierChromium* proof_verifier, |
| 54 | CertVerifier* cert_verifier, |
estark | 6f9b3d8 | 2016-01-12 21:37:05 | [diff] [blame] | 55 | CTPolicyEnforcer* ct_policy_enforcer, |
[email protected] | 080b7793 | 2014-08-04 01:22:46 | [diff] [blame] | 56 | TransportSecurityState* transport_security_state, |
rtenneti | 052774e | 2015-11-24 21:00:12 | [diff] [blame] | 57 | CTVerifier* cert_transparency_verifier, |
rtenneti | a75df62 | 2015-06-21 23:59:50 | [diff] [blame] | 58 | int cert_verify_flags, |
tfarina | 42834111 | 2016-09-22 13:38:20 | [diff] [blame] | 59 | const NetLogWithSource& net_log); |
rtenneti | dd4f1bd7 | 2015-12-23 19:17:50 | [diff] [blame] | 60 | ~Job(); |
[email protected] | 5c78ce6 | 2014-03-13 19:48:01 | [diff] [blame] | 61 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 62 | // Starts the proof verification. If |quic::QUIC_PENDING| is returned, then |
[email protected] | 05bfc260f | 2014-06-07 06:31:25 | [diff] [blame] | 63 | // |callback| will be invoked asynchronously when the verification completes. |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 64 | quic::QuicAsyncStatus VerifyProof( |
danakj | ad1777e | 2016-04-16 00:56:42 | [diff] [blame] | 65 | const std::string& hostname, |
| 66 | const uint16_t port, |
| 67 | const std::string& server_config, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 68 | quic::QuicTransportVersion quic_version, |
| 69 | quic::QuicStringPiece chlo_hash, |
danakj | ad1777e | 2016-04-16 00:56:42 | [diff] [blame] | 70 | const std::vector<std::string>& certs, |
| 71 | const std::string& cert_sct, |
| 72 | const std::string& signature, |
| 73 | std::string* error_details, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 74 | std::unique_ptr<quic::ProofVerifyDetails>* verify_details, |
| 75 | std::unique_ptr<quic::ProofVerifierCallback> callback); |
[email protected] | 5c78ce6 | 2014-03-13 19:48:01 | [diff] [blame] | 76 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 77 | // Starts the certificate chain verification of |certs|. If |
| 78 | // |quic::QUIC_PENDING| is returned, then |callback| will be invoked |
| 79 | // asynchronously when the verification completes. |
| 80 | quic::QuicAsyncStatus VerifyCertChain( |
rtenneti | d073dd2 | 2016-08-04 01:58:33 | [diff] [blame] | 81 | const std::string& hostname, |
| 82 | const std::vector<std::string>& certs, |
Matt Mueller | 7d5464b | 2019-05-15 20:18:45 | [diff] [blame] | 83 | const std::string& ocsp_response, |
| 84 | const std::string& cert_sct, |
rtenneti | d073dd2 | 2016-08-04 01:58:33 | [diff] [blame] | 85 | std::string* error_details, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 86 | std::unique_ptr<quic::ProofVerifyDetails>* verify_details, |
| 87 | std::unique_ptr<quic::ProofVerifierCallback> callback); |
rtenneti | d073dd2 | 2016-08-04 01:58:33 | [diff] [blame] | 88 | |
[email protected] | 5c78ce6 | 2014-03-13 19:48:01 | [diff] [blame] | 89 | private: |
| 90 | enum State { |
| 91 | STATE_NONE, |
| 92 | STATE_VERIFY_CERT, |
| 93 | STATE_VERIFY_CERT_COMPLETE, |
| 94 | }; |
| 95 | |
rtenneti | d073dd2 | 2016-08-04 01:58:33 | [diff] [blame] | 96 | // Convert |certs| to |cert_|(X509Certificate). Returns true if successful. |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 97 | bool GetX509Certificate( |
| 98 | const std::vector<string>& certs, |
| 99 | std::string* error_details, |
| 100 | std::unique_ptr<quic::ProofVerifyDetails>* verify_details); |
rtenneti | d073dd2 | 2016-08-04 01:58:33 | [diff] [blame] | 101 | |
| 102 | // Start the cert verification. |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 103 | quic::QuicAsyncStatus VerifyCert( |
rtenneti | d073dd2 | 2016-08-04 01:58:33 | [diff] [blame] | 104 | const string& hostname, |
| 105 | const uint16_t port, |
Matt Mueller | 7d5464b | 2019-05-15 20:18:45 | [diff] [blame] | 106 | const std::string& ocsp_response, |
| 107 | const std::string& cert_sct, |
rtenneti | d073dd2 | 2016-08-04 01:58:33 | [diff] [blame] | 108 | std::string* error_details, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 109 | std::unique_ptr<quic::ProofVerifyDetails>* verify_details, |
| 110 | std::unique_ptr<quic::ProofVerifierCallback> callback); |
rtenneti | d073dd2 | 2016-08-04 01:58:33 | [diff] [blame] | 111 | |
[email protected] | 5c78ce6 | 2014-03-13 19:48:01 | [diff] [blame] | 112 | int DoLoop(int last_io_result); |
| 113 | void OnIOComplete(int result); |
| 114 | int DoVerifyCert(int result); |
| 115 | int DoVerifyCertComplete(int result); |
| 116 | |
| 117 | bool VerifySignature(const std::string& signed_data, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 118 | quic::QuicTransportVersion quic_version, |
| 119 | quic::QuicStringPiece chlo_hash, |
[email protected] | 5c78ce6 | 2014-03-13 19:48:01 | [diff] [blame] | 120 | const std::string& signature, |
| 121 | const std::string& cert); |
| 122 | |
| 123 | // Proof verifier to notify when this jobs completes. |
| 124 | ProofVerifierChromium* proof_verifier_; |
| 125 | |
| 126 | // The underlying verifier used for verifying certificates. |
eroman | 7f9236a | 2015-05-11 21:23:43 | [diff] [blame] | 127 | CertVerifier* verifier_; |
danakj | ad1777e | 2016-04-16 00:56:42 | [diff] [blame] | 128 | std::unique_ptr<CertVerifier::Request> cert_verifier_request_; |
[email protected] | 5c78ce6 | 2014-03-13 19:48:01 | [diff] [blame] | 129 | |
estark | 6f9b3d8 | 2016-01-12 21:37:05 | [diff] [blame] | 130 | CTPolicyEnforcer* policy_enforcer_; |
rsleevi | 9541f863 | 2015-07-31 00:07:00 | [diff] [blame] | 131 | |
[email protected] | 080b7793 | 2014-08-04 01:22:46 | [diff] [blame] | 132 | TransportSecurityState* transport_security_state_; |
| 133 | |
rtenneti | 052774e | 2015-11-24 21:00:12 | [diff] [blame] | 134 | CTVerifier* cert_transparency_verifier_; |
| 135 | |
[email protected] | 5c78ce6 | 2014-03-13 19:48:01 | [diff] [blame] | 136 | // |hostname| specifies the hostname for which |certs| is a valid chain. |
| 137 | std::string hostname_; |
elawrence | 954bb547 | 2016-04-04 22:03:11 | [diff] [blame] | 138 | // |port| specifies the target port for the connection. |
| 139 | uint16_t port_; |
Matt Mueller | 7d5464b | 2019-05-15 20:18:45 | [diff] [blame] | 140 | // Encoded stapled OCSP response for |certs|. |
| 141 | std::string ocsp_response_; |
| 142 | // Encoded SignedCertificateTimestampList for |certs|. |
| 143 | std::string cert_sct_; |
[email protected] | 5c78ce6 | 2014-03-13 19:48:01 | [diff] [blame] | 144 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 145 | std::unique_ptr<quic::ProofVerifierCallback> callback_; |
danakj | ad1777e | 2016-04-16 00:56:42 | [diff] [blame] | 146 | std::unique_ptr<ProofVerifyDetailsChromium> verify_details_; |
[email protected] | 5c78ce6 | 2014-03-13 19:48:01 | [diff] [blame] | 147 | std::string error_details_; |
| 148 | |
| 149 | // X509Certificate from a chain of DER encoded certificates. |
| 150 | scoped_refptr<X509Certificate> cert_; |
| 151 | |
rtenneti | a75df62 | 2015-06-21 23:59:50 | [diff] [blame] | 152 | // |cert_verify_flags| is bitwise OR'd of CertVerifier::VerifyFlags and it is |
| 153 | // passed to CertVerifier::Verify. |
| 154 | int cert_verify_flags_; |
| 155 | |
rtenneti | d073dd2 | 2016-08-04 01:58:33 | [diff] [blame] | 156 | // If set to true, enforces policy checking in DoVerifyCertComplete(). |
| 157 | bool enforce_policy_checking_; |
| 158 | |
[email protected] | 5c78ce6 | 2014-03-13 19:48:01 | [diff] [blame] | 159 | State next_state_; |
| 160 | |
rtenneti | dd4f1bd7 | 2015-12-23 19:17:50 | [diff] [blame] | 161 | base::TimeTicks start_time_; |
| 162 | |
tfarina | 42834111 | 2016-09-22 13:38:20 | [diff] [blame] | 163 | NetLogWithSource net_log_; |
[email protected] | 5c78ce6 | 2014-03-13 19:48:01 | [diff] [blame] | 164 | |
| 165 | DISALLOW_COPY_AND_ASSIGN(Job); |
| 166 | }; |
| 167 | |
[email protected] | 080b7793 | 2014-08-04 01:22:46 | [diff] [blame] | 168 | ProofVerifierChromium::Job::Job( |
| 169 | ProofVerifierChromium* proof_verifier, |
| 170 | CertVerifier* cert_verifier, |
estark | 6f9b3d8 | 2016-01-12 21:37:05 | [diff] [blame] | 171 | CTPolicyEnforcer* ct_policy_enforcer, |
[email protected] | 080b7793 | 2014-08-04 01:22:46 | [diff] [blame] | 172 | TransportSecurityState* transport_security_state, |
rtenneti | 052774e | 2015-11-24 21:00:12 | [diff] [blame] | 173 | CTVerifier* cert_transparency_verifier, |
rtenneti | a75df62 | 2015-06-21 23:59:50 | [diff] [blame] | 174 | int cert_verify_flags, |
tfarina | 42834111 | 2016-09-22 13:38:20 | [diff] [blame] | 175 | const NetLogWithSource& net_log) |
[email protected] | 5c78ce6 | 2014-03-13 19:48:01 | [diff] [blame] | 176 | : proof_verifier_(proof_verifier), |
eroman | 7f9236a | 2015-05-11 21:23:43 | [diff] [blame] | 177 | verifier_(cert_verifier), |
estark | 6f9b3d8 | 2016-01-12 21:37:05 | [diff] [blame] | 178 | policy_enforcer_(ct_policy_enforcer), |
[email protected] | 080b7793 | 2014-08-04 01:22:46 | [diff] [blame] | 179 | transport_security_state_(transport_security_state), |
rtenneti | 052774e | 2015-11-24 21:00:12 | [diff] [blame] | 180 | cert_transparency_verifier_(cert_transparency_verifier), |
rtenneti | a75df62 | 2015-06-21 23:59:50 | [diff] [blame] | 181 | cert_verify_flags_(cert_verify_flags), |
rtenneti | d073dd2 | 2016-08-04 01:58:33 | [diff] [blame] | 182 | enforce_policy_checking_(true), |
[email protected] | 5c78ce6 | 2014-03-13 19:48:01 | [diff] [blame] | 183 | next_state_(STATE_NONE), |
rtenneti | dd4f1bd7 | 2015-12-23 19:17:50 | [diff] [blame] | 184 | start_time_(base::TimeTicks::Now()), |
rsleevi | d6de830 | 2016-06-21 01:33:20 | [diff] [blame] | 185 | net_log_(net_log) { |
rsleevi | be81cd6 | 2016-06-24 01:38:59 | [diff] [blame] | 186 | CHECK(proof_verifier_); |
| 187 | CHECK(verifier_); |
| 188 | CHECK(policy_enforcer_); |
| 189 | CHECK(transport_security_state_); |
| 190 | CHECK(cert_transparency_verifier_); |
rsleevi | d6de830 | 2016-06-21 01:33:20 | [diff] [blame] | 191 | } |
[email protected] | 2662ed56 | 2013-07-03 10:27:46 | [diff] [blame] | 192 | |
rtenneti | dd4f1bd7 | 2015-12-23 19:17:50 | [diff] [blame] | 193 | ProofVerifierChromium::Job::~Job() { |
| 194 | base::TimeTicks end_time = base::TimeTicks::Now(); |
| 195 | UMA_HISTOGRAM_TIMES("Net.QuicSession.VerifyProofTime", |
| 196 | end_time - start_time_); |
| 197 | // |hostname_| will always be canonicalized to lowercase. |
| 198 | if (hostname_.compare("www.google.com") == 0) { |
| 199 | UMA_HISTOGRAM_TIMES("Net.QuicSession.VerifyProofTime.google", |
| 200 | end_time - start_time_); |
| 201 | } |
| 202 | } |
| 203 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 204 | quic::QuicAsyncStatus ProofVerifierChromium::Job::VerifyProof( |
[email protected] | 72e6599 | 2013-07-30 17:16:14 | [diff] [blame] | 205 | const string& hostname, |
elawrence | 954bb547 | 2016-04-04 22:03:11 | [diff] [blame] | 206 | const uint16_t port, |
[email protected] | 72e6599 | 2013-07-30 17:16:14 | [diff] [blame] | 207 | const string& server_config, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 208 | quic::QuicTransportVersion quic_version, |
| 209 | quic::QuicStringPiece chlo_hash, |
rch | 872e00e | 2016-12-02 02:48:18 | [diff] [blame] | 210 | const std::vector<string>& certs, |
rjshade | c86dbfa | 2015-11-12 20:16:25 | [diff] [blame] | 211 | const std::string& cert_sct, |
[email protected] | 72e6599 | 2013-07-30 17:16:14 | [diff] [blame] | 212 | const string& signature, |
| 213 | std::string* error_details, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 214 | std::unique_ptr<quic::ProofVerifyDetails>* verify_details, |
| 215 | std::unique_ptr<quic::ProofVerifierCallback> callback) { |
[email protected] | 2662ed56 | 2013-07-03 10:27:46 | [diff] [blame] | 216 | DCHECK(error_details); |
[email protected] | c817c67 | 2014-03-21 22:25:34 | [diff] [blame] | 217 | DCHECK(verify_details); |
[email protected] | 72e6599 | 2013-07-30 17:16:14 | [diff] [blame] | 218 | DCHECK(callback); |
| 219 | |
[email protected] | 2662ed56 | 2013-07-03 10:27:46 | [diff] [blame] | 220 | error_details->clear(); |
| 221 | |
[email protected] | 2662ed56 | 2013-07-03 10:27:46 | [diff] [blame] | 222 | if (STATE_NONE != next_state_) { |
| 223 | *error_details = "Certificate is already set and VerifyProof has begun"; |
[email protected] | 5c78ce6 | 2014-03-13 19:48:01 | [diff] [blame] | 224 | DLOG(DFATAL) << *error_details; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 225 | return quic::QUIC_FAILURE; |
[email protected] | 2662ed56 | 2013-07-03 10:27:46 | [diff] [blame] | 226 | } |
| 227 | |
[email protected] | 72e6599 | 2013-07-30 17:16:14 | [diff] [blame] | 228 | verify_details_.reset(new ProofVerifyDetailsChromium); |
| 229 | |
rtenneti | d073dd2 | 2016-08-04 01:58:33 | [diff] [blame] | 230 | // Converts |certs| to |cert_|. |
| 231 | if (!GetX509Certificate(certs, error_details, verify_details)) |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 232 | return quic::QUIC_FAILURE; |
rtenneti | d073dd2 | 2016-08-04 01:58:33 | [diff] [blame] | 233 | |
rch | 71bd233 | 2017-02-04 00:06:47 | [diff] [blame] | 234 | // Note that this is a completely synchronous operation: The CT Log Verifier |
| 235 | // gets all the data it needs for SCT verification and does not do any |
| 236 | // external communication. |
Rob Percival | bc658a2 | 2017-12-13 08:24:42 | [diff] [blame] | 237 | cert_transparency_verifier_->Verify( |
| 238 | hostname, cert_.get(), std::string(), cert_sct, |
| 239 | &verify_details_->ct_verify_result.scts, net_log_); |
rtenneti | d073dd2 | 2016-08-04 01:58:33 | [diff] [blame] | 240 | |
| 241 | // We call VerifySignature first to avoid copying of server_config and |
| 242 | // signature. |
Ryan Hamilton | a3ee93a7 | 2018-08-01 22:03:08 | [diff] [blame] | 243 | if (!signature.empty() && !VerifySignature(server_config, quic_version, |
| 244 | chlo_hash, signature, certs[0])) { |
rtenneti | d073dd2 | 2016-08-04 01:58:33 | [diff] [blame] | 245 | *error_details = "Failed to verify signature of server config"; |
| 246 | DLOG(WARNING) << *error_details; |
| 247 | verify_details_->cert_verify_result.cert_status = CERT_STATUS_INVALID; |
| 248 | *verify_details = std::move(verify_details_); |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 249 | return quic::QUIC_FAILURE; |
rtenneti | d073dd2 | 2016-08-04 01:58:33 | [diff] [blame] | 250 | } |
| 251 | |
| 252 | DCHECK(enforce_policy_checking_); |
Matt Mueller | 7d5464b | 2019-05-15 20:18:45 | [diff] [blame] | 253 | return VerifyCert(hostname, port, /*ocsp_response=*/std::string(), cert_sct, |
| 254 | error_details, verify_details, std::move(callback)); |
rtenneti | d073dd2 | 2016-08-04 01:58:33 | [diff] [blame] | 255 | } |
| 256 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 257 | quic::QuicAsyncStatus ProofVerifierChromium::Job::VerifyCertChain( |
rtenneti | d073dd2 | 2016-08-04 01:58:33 | [diff] [blame] | 258 | const string& hostname, |
rch | 872e00e | 2016-12-02 02:48:18 | [diff] [blame] | 259 | const std::vector<string>& certs, |
Matt Mueller | 7d5464b | 2019-05-15 20:18:45 | [diff] [blame] | 260 | const std::string& ocsp_response, |
| 261 | const std::string& cert_sct, |
rtenneti | d073dd2 | 2016-08-04 01:58:33 | [diff] [blame] | 262 | std::string* error_details, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 263 | std::unique_ptr<quic::ProofVerifyDetails>* verify_details, |
| 264 | std::unique_ptr<quic::ProofVerifierCallback> callback) { |
rtenneti | d073dd2 | 2016-08-04 01:58:33 | [diff] [blame] | 265 | DCHECK(error_details); |
| 266 | DCHECK(verify_details); |
| 267 | DCHECK(callback); |
| 268 | |
| 269 | error_details->clear(); |
| 270 | |
| 271 | if (STATE_NONE != next_state_) { |
| 272 | *error_details = "Certificate is already set and VerifyCertChain has begun"; |
| 273 | DLOG(DFATAL) << *error_details; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 274 | return quic::QUIC_FAILURE; |
rtenneti | d073dd2 | 2016-08-04 01:58:33 | [diff] [blame] | 275 | } |
| 276 | |
| 277 | verify_details_.reset(new ProofVerifyDetailsChromium); |
| 278 | |
| 279 | // Converts |certs| to |cert_|. |
| 280 | if (!GetX509Certificate(certs, error_details, verify_details)) |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 281 | return quic::QUIC_FAILURE; |
rtenneti | d073dd2 | 2016-08-04 01:58:33 | [diff] [blame] | 282 | |
| 283 | enforce_policy_checking_ = false; |
| 284 | // |port| is not needed because |enforce_policy_checking_| is false. |
Matt Mueller | 7d5464b | 2019-05-15 20:18:45 | [diff] [blame] | 285 | return VerifyCert(hostname, /*port=*/0, ocsp_response, cert_sct, |
| 286 | error_details, verify_details, std::move(callback)); |
rtenneti | d073dd2 | 2016-08-04 01:58:33 | [diff] [blame] | 287 | } |
| 288 | |
| 289 | bool ProofVerifierChromium::Job::GetX509Certificate( |
rch | 872e00e | 2016-12-02 02:48:18 | [diff] [blame] | 290 | const std::vector<string>& certs, |
rtenneti | d073dd2 | 2016-08-04 01:58:33 | [diff] [blame] | 291 | std::string* error_details, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 292 | std::unique_ptr<quic::ProofVerifyDetails>* verify_details) { |
rtenneti | c14d86fd | 2016-07-10 16:33:34 | [diff] [blame] | 293 | if (certs.empty()) { |
| 294 | *error_details = "Failed to create certificate chain. Certs are empty."; |
| 295 | DLOG(WARNING) << *error_details; |
| 296 | verify_details_->cert_verify_result.cert_status = CERT_STATUS_INVALID; |
| 297 | *verify_details = std::move(verify_details_); |
rtenneti | d073dd2 | 2016-08-04 01:58:33 | [diff] [blame] | 298 | return false; |
rtenneti | c14d86fd | 2016-07-10 16:33:34 | [diff] [blame] | 299 | } |
| 300 | |
| 301 | // Convert certs to X509Certificate. |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 302 | std::vector<quic::QuicStringPiece> cert_pieces(certs.size()); |
rtenneti | c14d86fd | 2016-07-10 16:33:34 | [diff] [blame] | 303 | for (unsigned i = 0; i < certs.size(); i++) { |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 304 | cert_pieces[i] = quic::QuicStringPiece(certs[i]); |
rtenneti | c14d86fd | 2016-07-10 16:33:34 | [diff] [blame] | 305 | } |
| 306 | cert_ = X509Certificate::CreateFromDERCertChain(cert_pieces); |
| 307 | if (!cert_.get()) { |
| 308 | *error_details = "Failed to create certificate chain"; |
| 309 | DLOG(WARNING) << *error_details; |
| 310 | verify_details_->cert_verify_result.cert_status = CERT_STATUS_INVALID; |
| 311 | *verify_details = std::move(verify_details_); |
rtenneti | d073dd2 | 2016-08-04 01:58:33 | [diff] [blame] | 312 | return false; |
rtenneti | c14d86fd | 2016-07-10 16:33:34 | [diff] [blame] | 313 | } |
rtenneti | d073dd2 | 2016-08-04 01:58:33 | [diff] [blame] | 314 | return true; |
| 315 | } |
[email protected] | 2662ed56 | 2013-07-03 10:27:46 | [diff] [blame] | 316 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 317 | quic::QuicAsyncStatus ProofVerifierChromium::Job::VerifyCert( |
rtenneti | d073dd2 | 2016-08-04 01:58:33 | [diff] [blame] | 318 | const string& hostname, |
| 319 | const uint16_t port, |
Matt Mueller | 7d5464b | 2019-05-15 20:18:45 | [diff] [blame] | 320 | const std::string& ocsp_response, |
| 321 | const std::string& cert_sct, |
rtenneti | d073dd2 | 2016-08-04 01:58:33 | [diff] [blame] | 322 | std::string* error_details, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 323 | std::unique_ptr<quic::ProofVerifyDetails>* verify_details, |
| 324 | std::unique_ptr<quic::ProofVerifierCallback> callback) { |
[email protected] | 2662ed56 | 2013-07-03 10:27:46 | [diff] [blame] | 325 | hostname_ = hostname; |
elawrence | 954bb547 | 2016-04-04 22:03:11 | [diff] [blame] | 326 | port_ = port; |
Matt Mueller | 7d5464b | 2019-05-15 20:18:45 | [diff] [blame] | 327 | ocsp_response_ = ocsp_response; |
| 328 | cert_sct_ = cert_sct; |
[email protected] | 2662ed56 | 2013-07-03 10:27:46 | [diff] [blame] | 329 | |
| 330 | next_state_ = STATE_VERIFY_CERT; |
[email protected] | 72e6599 | 2013-07-30 17:16:14 | [diff] [blame] | 331 | switch (DoLoop(OK)) { |
| 332 | case OK: |
dcheng | c7eeda42 | 2015-12-26 03:56:48 | [diff] [blame] | 333 | *verify_details = std::move(verify_details_); |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 334 | return quic::QUIC_SUCCESS; |
[email protected] | 72e6599 | 2013-07-30 17:16:14 | [diff] [blame] | 335 | case ERR_IO_PENDING: |
ckrasic | 6567aa5 | 2016-07-08 09:24:35 | [diff] [blame] | 336 | callback_ = std::move(callback); |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 337 | return quic::QUIC_PENDING; |
[email protected] | 72e6599 | 2013-07-30 17:16:14 | [diff] [blame] | 338 | default: |
| 339 | *error_details = error_details_; |
dcheng | c7eeda42 | 2015-12-26 03:56:48 | [diff] [blame] | 340 | *verify_details = std::move(verify_details_); |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 341 | return quic::QUIC_FAILURE; |
[email protected] | 72e6599 | 2013-07-30 17:16:14 | [diff] [blame] | 342 | } |
[email protected] | 2662ed56 | 2013-07-03 10:27:46 | [diff] [blame] | 343 | } |
| 344 | |
[email protected] | 5c78ce6 | 2014-03-13 19:48:01 | [diff] [blame] | 345 | int ProofVerifierChromium::Job::DoLoop(int last_result) { |
[email protected] | 2662ed56 | 2013-07-03 10:27:46 | [diff] [blame] | 346 | int rv = last_result; |
| 347 | do { |
| 348 | State state = next_state_; |
| 349 | next_state_ = STATE_NONE; |
| 350 | switch (state) { |
| 351 | case STATE_VERIFY_CERT: |
| 352 | DCHECK(rv == OK); |
| 353 | rv = DoVerifyCert(rv); |
| 354 | break; |
| 355 | case STATE_VERIFY_CERT_COMPLETE: |
| 356 | rv = DoVerifyCertComplete(rv); |
| 357 | break; |
| 358 | case STATE_NONE: |
| 359 | default: |
| 360 | rv = ERR_UNEXPECTED; |
| 361 | LOG(DFATAL) << "unexpected state " << state; |
| 362 | break; |
| 363 | } |
| 364 | } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE); |
| 365 | return rv; |
| 366 | } |
| 367 | |
[email protected] | 5c78ce6 | 2014-03-13 19:48:01 | [diff] [blame] | 368 | void ProofVerifierChromium::Job::OnIOComplete(int result) { |
[email protected] | 2662ed56 | 2013-07-03 10:27:46 | [diff] [blame] | 369 | int rv = DoLoop(result); |
| 370 | if (rv != ERR_IO_PENDING) { |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 371 | std::unique_ptr<quic::ProofVerifierCallback> callback(std::move(callback_)); |
| 372 | // Callback expects quic::ProofVerifyDetails not ProofVerifyDetailsChromium. |
| 373 | std::unique_ptr<quic::ProofVerifyDetails> verify_details( |
danakj | ad1777e | 2016-04-16 00:56:42 | [diff] [blame] | 374 | std::move(verify_details_)); |
[email protected] | 5c78ce6 | 2014-03-13 19:48:01 | [diff] [blame] | 375 | callback->Run(rv == OK, error_details_, &verify_details); |
| 376 | // Will delete |this|. |
| 377 | proof_verifier_->OnJobComplete(this); |
[email protected] | 2662ed56 | 2013-07-03 10:27:46 | [diff] [blame] | 378 | } |
| 379 | } |
| 380 | |
[email protected] | 5c78ce6 | 2014-03-13 19:48:01 | [diff] [blame] | 381 | int ProofVerifierChromium::Job::DoVerifyCert(int result) { |
[email protected] | 2662ed56 | 2013-07-03 10:27:46 | [diff] [blame] | 382 | next_state_ = STATE_VERIFY_CERT_COMPLETE; |
| 383 | |
rtenneti | a75df62 | 2015-06-21 23:59:50 | [diff] [blame] | 384 | return verifier_->Verify( |
rsleevi | 06bd7855 | 2016-06-08 22:34:46 | [diff] [blame] | 385 | CertVerifier::RequestParams(cert_, hostname_, cert_verify_flags_, |
Matt Mueller | 7d5464b | 2019-05-15 20:18:45 | [diff] [blame] | 386 | ocsp_response_, cert_sct_), |
Ryan Sleevi | b369d71 | 2018-08-20 16:43:22 | [diff] [blame] | 387 | &verify_details_->cert_verify_result, |
Yannic Bonenberger | 3c96beb | 2019-09-03 20:41:37 | [diff] [blame] | 388 | base::BindOnce(&ProofVerifierChromium::Job::OnIOComplete, |
| 389 | base::Unretained(this)), |
rtenneti | a75df62 | 2015-06-21 23:59:50 | [diff] [blame] | 390 | &cert_verifier_request_, net_log_); |
[email protected] | 2662ed56 | 2013-07-03 10:27:46 | [diff] [blame] | 391 | } |
| 392 | |
[email protected] | 5c78ce6 | 2014-03-13 19:48:01 | [diff] [blame] | 393 | int ProofVerifierChromium::Job::DoVerifyCertComplete(int result) { |
Ilya Sherman | 0eb3980 | 2017-12-08 20:58:18 | [diff] [blame] | 394 | base::UmaHistogramSparse("Net.QuicSession.CertVerificationResult", -result); |
eroman | 7f9236a | 2015-05-11 21:23:43 | [diff] [blame] | 395 | cert_verifier_request_.reset(); |
[email protected] | 2662ed56 | 2013-07-03 10:27:46 | [diff] [blame] | 396 | |
[email protected] | 080b7793 | 2014-08-04 01:22:46 | [diff] [blame] | 397 | const CertVerifyResult& cert_verify_result = |
| 398 | verify_details_->cert_verify_result; |
[email protected] | 080b7793 | 2014-08-04 01:22:46 | [diff] [blame] | 399 | const CertStatus cert_status = cert_verify_result.cert_status; |
rsleevi | 4a6ca8c | 2016-06-24 03:05:22 | [diff] [blame] | 400 | |
| 401 | // If the connection was good, check HPKP and CT status simultaneously, |
| 402 | // but prefer to treat the HPKP error as more serious, if there was one. |
Matt Mueller | 93651144 | 2019-09-03 18:15:12 | [diff] [blame] | 403 | if (enforce_policy_checking_ && result == OK) { |
Ryan Sleevi | 8a9c9c1 | 2018-05-09 02:36:23 | [diff] [blame] | 404 | ct::SCTList verified_scts = ct::SCTsMatchingStatus( |
eranm | 4bed0b57 | 2016-08-14 21:00:35 | [diff] [blame] | 405 | verify_details_->ct_verify_result.scts, ct::SCT_STATUS_OK); |
estark | 0fc8d078 | 2016-02-25 20:41:20 | [diff] [blame] | 406 | |
Emily Stark | 627238f | 2017-11-29 03:29:54 | [diff] [blame] | 407 | verify_details_->ct_verify_result.policy_compliance = |
| 408 | policy_enforcer_->CheckCompliance( |
eranm | 4bed0b57 | 2016-08-14 21:00:35 | [diff] [blame] | 409 | cert_verify_result.verified_cert.get(), verified_scts, net_log_); |
Emily Stark | 0d9809e | 2017-10-18 08:29:15 | [diff] [blame] | 410 | if (verify_details_->cert_verify_result.cert_status & CERT_STATUS_IS_EV) { |
Emily Stark | 627238f | 2017-11-29 03:29:54 | [diff] [blame] | 411 | if (verify_details_->ct_verify_result.policy_compliance != |
Ryan Sleevi | 8a9c9c1 | 2018-05-09 02:36:23 | [diff] [blame] | 412 | ct::CTPolicyCompliance::CT_POLICY_COMPLIES_VIA_SCTS && |
| 413 | verify_details_->ct_verify_result.policy_compliance != |
| 414 | ct::CTPolicyCompliance::CT_POLICY_BUILD_NOT_TIMELY) { |
Emily Stark | 0d9809e | 2017-10-18 08:29:15 | [diff] [blame] | 415 | verify_details_->cert_verify_result.cert_status |= |
| 416 | CERT_STATUS_CT_COMPLIANCE_FAILED; |
| 417 | verify_details_->cert_verify_result.cert_status &= ~CERT_STATUS_IS_EV; |
| 418 | } |
| 419 | |
| 420 | // Record the CT compliance status for connections with EV certificates, |
| 421 | // to distinguish how often EV status is being dropped due to failing CT |
| 422 | // compliance. |
Emily Stark | efce783 | 2017-11-30 03:16:16 | [diff] [blame] | 423 | if (verify_details_->cert_verify_result.is_issued_by_known_root) { |
| 424 | UMA_HISTOGRAM_ENUMERATION( |
| 425 | "Net.CertificateTransparency.EVCompliance2.QUIC", |
| 426 | verify_details_->ct_verify_result.policy_compliance, |
Kunihiko Sakamoto | 3646973 | 2018-09-27 03:33:45 | [diff] [blame] | 427 | ct::CTPolicyCompliance::CT_POLICY_COUNT); |
Emily Stark | efce783 | 2017-11-30 03:16:16 | [diff] [blame] | 428 | } |
rsleevi | cd7390e | 2017-06-14 10:18:26 | [diff] [blame] | 429 | } |
rsleevi | 9541f863 | 2015-07-31 00:07:00 | [diff] [blame] | 430 | |
Emily Stark | 0d9809e | 2017-10-18 08:29:15 | [diff] [blame] | 431 | // Record the CT compliance of every connection to get an overall picture of |
| 432 | // how many connections are CT-compliant. |
Emily Stark | efce783 | 2017-11-30 03:16:16 | [diff] [blame] | 433 | if (verify_details_->cert_verify_result.is_issued_by_known_root) { |
| 434 | UMA_HISTOGRAM_ENUMERATION( |
| 435 | "Net.CertificateTransparency.ConnectionComplianceStatus2.QUIC", |
| 436 | verify_details_->ct_verify_result.policy_compliance, |
Kunihiko Sakamoto | 3646973 | 2018-09-27 03:33:45 | [diff] [blame] | 437 | ct::CTPolicyCompliance::CT_POLICY_COUNT); |
Emily Stark | efce783 | 2017-11-30 03:16:16 | [diff] [blame] | 438 | } |
Emily Stark | c96e9bc | 2017-10-10 00:10:39 | [diff] [blame] | 439 | |
rsleevi | 4a6ca8c | 2016-06-24 03:05:22 | [diff] [blame] | 440 | int ct_result = OK; |
Emily Stark | 0d9809e | 2017-10-18 08:29:15 | [diff] [blame] | 441 | TransportSecurityState::CTRequirementsStatus ct_requirement_status = |
| 442 | transport_security_state_->CheckCTRequirements( |
estark | bf1b5296 | 2017-05-05 17:05:25 | [diff] [blame] | 443 | HostPortPair(hostname_, port_), |
| 444 | cert_verify_result.is_issued_by_known_root, |
| 445 | cert_verify_result.public_key_hashes, |
| 446 | cert_verify_result.verified_cert.get(), cert_.get(), |
| 447 | verify_details_->ct_verify_result.scts, |
| 448 | TransportSecurityState::ENABLE_EXPECT_CT_REPORTS, |
Emily Stark | 627238f | 2017-11-29 03:29:54 | [diff] [blame] | 449 | verify_details_->ct_verify_result.policy_compliance); |
Emily Stark | 0d9809e | 2017-10-18 08:29:15 | [diff] [blame] | 450 | if (ct_requirement_status != TransportSecurityState::CT_NOT_REQUIRED) { |
Emily Stark | 8b411de0 | 2017-11-23 20:21:27 | [diff] [blame] | 451 | verify_details_->ct_verify_result.policy_compliance_required = true; |
Emily Stark | efce783 | 2017-11-30 03:16:16 | [diff] [blame] | 452 | if (verify_details_->cert_verify_result.is_issued_by_known_root) { |
| 453 | // Record the CT compliance of connections for which compliance is |
| 454 | // required; this helps answer the question: "Of all connections that |
| 455 | // are supposed to be serving valid CT information, how many fail to do |
| 456 | // so?" |
| 457 | UMA_HISTOGRAM_ENUMERATION( |
| 458 | "Net.CertificateTransparency.CTRequiredConnectionComplianceStatus2." |
| 459 | "QUIC", |
| 460 | verify_details_->ct_verify_result.policy_compliance, |
Kunihiko Sakamoto | 3646973 | 2018-09-27 03:33:45 | [diff] [blame] | 461 | ct::CTPolicyCompliance::CT_POLICY_COUNT); |
Emily Stark | efce783 | 2017-11-30 03:16:16 | [diff] [blame] | 462 | } |
Emily Stark | 8b411de0 | 2017-11-23 20:21:27 | [diff] [blame] | 463 | } else { |
| 464 | verify_details_->ct_verify_result.policy_compliance_required = false; |
Emily Stark | 0d9809e | 2017-10-18 08:29:15 | [diff] [blame] | 465 | } |
| 466 | |
| 467 | switch (ct_requirement_status) { |
| 468 | case TransportSecurityState::CT_REQUIREMENTS_NOT_MET: |
| 469 | verify_details_->cert_verify_result.cert_status |= |
| 470 | CERT_STATUS_CERTIFICATE_TRANSPARENCY_REQUIRED; |
| 471 | ct_result = ERR_CERTIFICATE_TRANSPARENCY_REQUIRED; |
Emily Stark | 8b411de0 | 2017-11-23 20:21:27 | [diff] [blame] | 472 | break; |
Emily Stark | 0d9809e | 2017-10-18 08:29:15 | [diff] [blame] | 473 | case TransportSecurityState::CT_REQUIREMENTS_MET: |
| 474 | case TransportSecurityState::CT_NOT_REQUIRED: |
| 475 | // Intentional fallthrough; this case is just here to make sure that all |
| 476 | // possible values of CheckCTRequirements() are handled. |
| 477 | break; |
rsleevi | 4a6ca8c | 2016-06-24 03:05:22 | [diff] [blame] | 478 | } |
| 479 | |
dadrian | 8f894665 | 2016-06-21 23:48:31 | [diff] [blame] | 480 | TransportSecurityState::PKPStatus pin_validity = |
| 481 | transport_security_state_->CheckPublicKeyPins( |
| 482 | HostPortPair(hostname_, port_), |
| 483 | cert_verify_result.is_issued_by_known_root, |
| 484 | cert_verify_result.public_key_hashes, cert_.get(), |
| 485 | cert_verify_result.verified_cert.get(), |
| 486 | TransportSecurityState::ENABLE_PIN_REPORTS, |
| 487 | &verify_details_->pinning_failure_log); |
| 488 | switch (pin_validity) { |
| 489 | case TransportSecurityState::PKPStatus::VIOLATED: |
| 490 | result = ERR_SSL_PINNED_KEY_NOT_IN_CERT_CHAIN; |
| 491 | verify_details_->cert_verify_result.cert_status |= |
| 492 | CERT_STATUS_PINNED_KEY_MISSING; |
| 493 | break; |
| 494 | case TransportSecurityState::PKPStatus::BYPASSED: |
| 495 | verify_details_->pkp_bypassed = true; |
Nico Weber | 63e0376 | 2018-01-26 17:55:14 | [diff] [blame] | 496 | FALLTHROUGH; |
dadrian | 8f894665 | 2016-06-21 23:48:31 | [diff] [blame] | 497 | case TransportSecurityState::PKPStatus::OK: |
| 498 | // Do nothing. |
| 499 | break; |
rsleevi | 9545d34 | 2016-06-21 03:17:37 | [diff] [blame] | 500 | } |
rsleevi | 4a6ca8c | 2016-06-24 03:05:22 | [diff] [blame] | 501 | if (result != ERR_SSL_PINNED_KEY_NOT_IN_CERT_CHAIN && ct_result != OK) |
| 502 | result = ct_result; |
[email protected] | 080b7793 | 2014-08-04 01:22:46 | [diff] [blame] | 503 | } |
[email protected] | 080b7793 | 2014-08-04 01:22:46 | [diff] [blame] | 504 | |
Nick Harper | 3f3ae7b | 2019-08-22 20:33:37 | [diff] [blame] | 505 | if (result == OK && |
| 506 | !verify_details_->cert_verify_result.is_issued_by_known_root && |
| 507 | !base::Contains(proof_verifier_->hostnames_to_allow_unknown_roots_, |
| 508 | hostname_)) { |
| 509 | result = ERR_QUIC_CERT_ROOT_NOT_KNOWN; |
| 510 | } |
| 511 | |
Carlos IL | 8113338 | 2017-12-06 17:18:45 | [diff] [blame] | 512 | verify_details_->is_fatal_cert_error = |
Matt Mueller | 93651144 | 2019-09-03 18:15:12 | [diff] [blame] | 513 | IsCertStatusError(cert_status) && |
Carlos IL | 8113338 | 2017-12-06 17:18:45 | [diff] [blame] | 514 | transport_security_state_->ShouldSSLErrorsBeFatal(hostname_); |
| 515 | |
[email protected] | 0cceb92 | 2014-07-01 02:00:56 | [diff] [blame] | 516 | if (result != OK) { |
[email protected] | 3030374e3 | 2014-08-07 16:12:06 | [diff] [blame] | 517 | std::string error_string = ErrorToString(result); |
[email protected] | 72e6599 | 2013-07-30 17:16:14 | [diff] [blame] | 518 | error_details_ = StringPrintf("Failed to verify certificate chain: %s", |
[email protected] | 3030374e3 | 2014-08-07 16:12:06 | [diff] [blame] | 519 | error_string.c_str()); |
[email protected] | 72e6599 | 2013-07-30 17:16:14 | [diff] [blame] | 520 | DLOG(WARNING) << error_details_; |
[email protected] | 2662ed56 | 2013-07-03 10:27:46 | [diff] [blame] | 521 | } |
| 522 | |
| 523 | // Exit DoLoop and return the result to the caller to VerifyProof. |
| 524 | DCHECK_EQ(STATE_NONE, next_state_); |
| 525 | return result; |
| 526 | } |
| 527 | |
Michael Warres | 74ee3ce | 2017-10-09 15:26:37 | [diff] [blame] | 528 | bool ProofVerifierChromium::Job::VerifySignature( |
| 529 | const string& signed_data, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 530 | quic::QuicTransportVersion quic_version, |
| 531 | quic::QuicStringPiece chlo_hash, |
Michael Warres | 74ee3ce | 2017-10-09 15:26:37 | [diff] [blame] | 532 | const string& signature, |
| 533 | const string& cert) { |
[email protected] | 2662ed56 | 2013-07-03 10:27:46 | [diff] [blame] | 534 | size_t size_bits; |
| 535 | X509Certificate::PublicKeyType type; |
Matt Mueller | a419327 | 2017-12-07 00:23:34 | [diff] [blame] | 536 | X509Certificate::GetPublicKeyInfo(cert_->cert_buffer(), &size_bits, &type); |
David Benjamin | 8982fe4f | 2018-02-06 19:30:32 | [diff] [blame] | 537 | crypto::SignatureVerifier::SignatureAlgorithm algorithm; |
| 538 | switch (type) { |
| 539 | case X509Certificate::kPublicKeyTypeRSA: |
| 540 | algorithm = crypto::SignatureVerifier::RSA_PSS_SHA256; |
| 541 | break; |
| 542 | case X509Certificate::kPublicKeyTypeECDSA: |
| 543 | algorithm = crypto::SignatureVerifier::ECDSA_SHA256; |
| 544 | break; |
| 545 | default: |
| 546 | LOG(ERROR) << "Unsupported public key type " << type; |
| 547 | return false; |
| 548 | } |
[email protected] | 2662ed56 | 2013-07-03 10:27:46 | [diff] [blame] | 549 | |
David Benjamin | 8982fe4f | 2018-02-06 19:30:32 | [diff] [blame] | 550 | crypto::SignatureVerifier verifier; |
David Benjamin | 03c28a4 | 2018-05-11 23:12:07 | [diff] [blame] | 551 | if (!x509_util::SignatureVerifierInitWithCertificate( |
| 552 | &verifier, algorithm, base::as_bytes(base::make_span(signature)), |
| 553 | cert_->cert_buffer())) { |
| 554 | DLOG(WARNING) << "SignatureVerifierInitWithCertificate failed"; |
[email protected] | 2662ed56 | 2013-07-03 10:27:46 | [diff] [blame] | 555 | return false; |
| 556 | } |
| 557 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 558 | verifier.VerifyUpdate( |
| 559 | base::as_bytes(base::make_span(quic::kProofSignatureLabel))); |
zhongyi | 7cbefb31 | 2016-10-11 19:03:47 | [diff] [blame] | 560 | uint32_t len = chlo_hash.length(); |
jdoerrie | 2917a61e | 2018-05-02 09:39:14 | [diff] [blame] | 561 | verifier.VerifyUpdate(base::as_bytes(base::make_span(&len, 1))); |
| 562 | verifier.VerifyUpdate(base::as_bytes(base::make_span(chlo_hash))); |
| 563 | verifier.VerifyUpdate(base::as_bytes(base::make_span(signed_data))); |
[email protected] | 2662ed56 | 2013-07-03 10:27:46 | [diff] [blame] | 564 | |
| 565 | if (!verifier.VerifyFinal()) { |
| 566 | DLOG(WARNING) << "VerifyFinal failed"; |
| 567 | return false; |
| 568 | } |
| 569 | |
[email protected] | 3e5fed1 | 2013-11-22 22:21:41 | [diff] [blame] | 570 | DVLOG(1) << "VerifyFinal success"; |
[email protected] | 2662ed56 | 2013-07-03 10:27:46 | [diff] [blame] | 571 | return true; |
| 572 | } |
| 573 | |
[email protected] | 080b7793 | 2014-08-04 01:22:46 | [diff] [blame] | 574 | ProofVerifierChromium::ProofVerifierChromium( |
| 575 | CertVerifier* cert_verifier, |
estark | 6f9b3d8 | 2016-01-12 21:37:05 | [diff] [blame] | 576 | CTPolicyEnforcer* ct_policy_enforcer, |
rtenneti | 052774e | 2015-11-24 21:00:12 | [diff] [blame] | 577 | TransportSecurityState* transport_security_state, |
Nick Harper | 3f3ae7b | 2019-08-22 20:33:37 | [diff] [blame] | 578 | CTVerifier* cert_transparency_verifier, |
| 579 | std::set<std::string> hostnames_to_allow_unknown_roots) |
[email protected] | 080b7793 | 2014-08-04 01:22:46 | [diff] [blame] | 580 | : cert_verifier_(cert_verifier), |
estark | 6f9b3d8 | 2016-01-12 21:37:05 | [diff] [blame] | 581 | ct_policy_enforcer_(ct_policy_enforcer), |
rtenneti | 052774e | 2015-11-24 21:00:12 | [diff] [blame] | 582 | transport_security_state_(transport_security_state), |
Nick Harper | 3f3ae7b | 2019-08-22 20:33:37 | [diff] [blame] | 583 | cert_transparency_verifier_(cert_transparency_verifier), |
| 584 | hostnames_to_allow_unknown_roots_(hostnames_to_allow_unknown_roots) { |
rsleevi | d6de830 | 2016-06-21 01:33:20 | [diff] [blame] | 585 | DCHECK(cert_verifier_); |
| 586 | DCHECK(ct_policy_enforcer_); |
| 587 | DCHECK(transport_security_state_); |
| 588 | DCHECK(cert_transparency_verifier_); |
| 589 | } |
[email protected] | 5c78ce6 | 2014-03-13 19:48:01 | [diff] [blame] | 590 | |
Ryan Hamilton | a3ee93a7 | 2018-08-01 22:03:08 | [diff] [blame] | 591 | ProofVerifierChromium::~ProofVerifierChromium() {} |
[email protected] | 5c78ce6 | 2014-03-13 19:48:01 | [diff] [blame] | 592 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 593 | quic::QuicAsyncStatus ProofVerifierChromium::VerifyProof( |
[email protected] | 5c78ce6 | 2014-03-13 19:48:01 | [diff] [blame] | 594 | const std::string& hostname, |
elawrence | 954bb547 | 2016-04-04 22:03:11 | [diff] [blame] | 595 | const uint16_t port, |
[email protected] | 5c78ce6 | 2014-03-13 19:48:01 | [diff] [blame] | 596 | const std::string& server_config, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 597 | quic::QuicTransportVersion quic_version, |
| 598 | quic::QuicStringPiece chlo_hash, |
[email protected] | 5c78ce6 | 2014-03-13 19:48:01 | [diff] [blame] | 599 | const std::vector<std::string>& certs, |
rjshade | c86dbfa | 2015-11-12 20:16:25 | [diff] [blame] | 600 | const std::string& cert_sct, |
[email protected] | 5c78ce6 | 2014-03-13 19:48:01 | [diff] [blame] | 601 | const std::string& signature, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 602 | const quic::ProofVerifyContext* verify_context, |
[email protected] | 5c78ce6 | 2014-03-13 19:48:01 | [diff] [blame] | 603 | std::string* error_details, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 604 | std::unique_ptr<quic::ProofVerifyDetails>* verify_details, |
| 605 | std::unique_ptr<quic::ProofVerifierCallback> callback) { |
[email protected] | c817c67 | 2014-03-21 22:25:34 | [diff] [blame] | 606 | if (!verify_context) { |
Ryan Hamilton | 8bb19a1 | 2018-07-23 20:29:24 | [diff] [blame] | 607 | DLOG(FATAL) << "Missing proof verify context"; |
[email protected] | c817c67 | 2014-03-21 22:25:34 | [diff] [blame] | 608 | *error_details = "Missing context"; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 609 | return quic::QUIC_FAILURE; |
[email protected] | c817c67 | 2014-03-21 22:25:34 | [diff] [blame] | 610 | } |
| 611 | const ProofVerifyContextChromium* chromium_context = |
| 612 | reinterpret_cast<const ProofVerifyContextChromium*>(verify_context); |
Jeremy Roman | 0579ed6 | 2017-08-29 15:56:19 | [diff] [blame] | 613 | std::unique_ptr<Job> job = std::make_unique<Job>( |
avi | b363545 | 2016-10-21 18:33:53 | [diff] [blame] | 614 | this, cert_verifier_, ct_policy_enforcer_, transport_security_state_, |
| 615 | cert_transparency_verifier_, chromium_context->cert_verify_flags, |
| 616 | chromium_context->net_log); |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 617 | quic::QuicAsyncStatus status = job->VerifyProof( |
elawrence | 954bb547 | 2016-04-04 22:03:11 | [diff] [blame] | 618 | hostname, port, server_config, quic_version, chlo_hash, certs, cert_sct, |
ckrasic | 6567aa5 | 2016-07-08 09:24:35 | [diff] [blame] | 619 | signature, error_details, verify_details, std::move(callback)); |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 620 | if (status == quic::QUIC_PENDING) { |
avi | b363545 | 2016-10-21 18:33:53 | [diff] [blame] | 621 | Job* job_ptr = job.get(); |
| 622 | active_jobs_[job_ptr] = std::move(job); |
| 623 | } |
rtenneti | d073dd2 | 2016-08-04 01:58:33 | [diff] [blame] | 624 | return status; |
| 625 | } |
| 626 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 627 | quic::QuicAsyncStatus ProofVerifierChromium::VerifyCertChain( |
rtenneti | d073dd2 | 2016-08-04 01:58:33 | [diff] [blame] | 628 | const std::string& hostname, |
| 629 | const std::vector<std::string>& certs, |
Dan Zhang | 1004241 | 2019-05-09 18:31:01 | [diff] [blame] | 630 | const std::string& ocsp_response, |
| 631 | const std::string& cert_sct, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 632 | const quic::ProofVerifyContext* verify_context, |
rtenneti | d073dd2 | 2016-08-04 01:58:33 | [diff] [blame] | 633 | std::string* error_details, |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 634 | std::unique_ptr<quic::ProofVerifyDetails>* verify_details, |
| 635 | std::unique_ptr<quic::ProofVerifierCallback> callback) { |
rtenneti | d073dd2 | 2016-08-04 01:58:33 | [diff] [blame] | 636 | if (!verify_context) { |
| 637 | *error_details = "Missing context"; |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 638 | return quic::QUIC_FAILURE; |
[email protected] | 5c78ce6 | 2014-03-13 19:48:01 | [diff] [blame] | 639 | } |
rtenneti | d073dd2 | 2016-08-04 01:58:33 | [diff] [blame] | 640 | const ProofVerifyContextChromium* chromium_context = |
| 641 | reinterpret_cast<const ProofVerifyContextChromium*>(verify_context); |
Jeremy Roman | 0579ed6 | 2017-08-29 15:56:19 | [diff] [blame] | 642 | std::unique_ptr<Job> job = std::make_unique<Job>( |
avi | b363545 | 2016-10-21 18:33:53 | [diff] [blame] | 643 | this, cert_verifier_, ct_policy_enforcer_, transport_security_state_, |
| 644 | cert_transparency_verifier_, chromium_context->cert_verify_flags, |
| 645 | chromium_context->net_log); |
Matt Mueller | 7d5464b | 2019-05-15 20:18:45 | [diff] [blame] | 646 | quic::QuicAsyncStatus status = |
| 647 | job->VerifyCertChain(hostname, certs, ocsp_response, cert_sct, |
| 648 | error_details, verify_details, std::move(callback)); |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 649 | if (status == quic::QUIC_PENDING) { |
avi | b363545 | 2016-10-21 18:33:53 | [diff] [blame] | 650 | Job* job_ptr = job.get(); |
| 651 | active_jobs_[job_ptr] = std::move(job); |
| 652 | } |
[email protected] | 5c78ce6 | 2014-03-13 19:48:01 | [diff] [blame] | 653 | return status; |
| 654 | } |
| 655 | |
Ryan Hamilton | 8bb19a1 | 2018-07-23 20:29:24 | [diff] [blame] | 656 | std::unique_ptr<quic::ProofVerifyContext> |
| 657 | ProofVerifierChromium::CreateDefaultContext() { |
| 658 | return std::make_unique<ProofVerifyContextChromium>(0, |
| 659 | net::NetLogWithSource()); |
| 660 | } |
| 661 | |
[email protected] | 5c78ce6 | 2014-03-13 19:48:01 | [diff] [blame] | 662 | void ProofVerifierChromium::OnJobComplete(Job* job) { |
| 663 | active_jobs_.erase(job); |
[email protected] | 5c78ce6 | 2014-03-13 19:48:01 | [diff] [blame] | 664 | } |
| 665 | |
[email protected] | 2662ed56 | 2013-07-03 10:27:46 | [diff] [blame] | 666 | } // namespace net |