| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| 5 #include "net/quic/crypto/proof_verifier_chromium.h" | |
| 6 | |
| 7 #include "base/bind.h" | |
| 8 #include "base/bind_helpers.h" | |
| 9 #include "base/callback_helpers.h" | |
| 10 #include "base/compiler_specific.h" | |
| 11 #include "base/logging.h" | |
| 12 #include "base/metrics/histogram.h" | |
| 13 #include "base/profiler/scoped_tracker.h" | |
| 14 #include "base/stl_util.h" | |
| 15 #include "base/strings/stringprintf.h" | |
| 16 #include "crypto/signature_verifier.h" | |
| 17 #include "net/base/net_errors.h" | |
| 18 #include "net/base/net_log.h" | |
| 19 #include "net/cert/asn1_util.h" | |
| 20 #include "net/cert/cert_status_flags.h" | |
| 21 #include "net/cert/cert_verifier.h" | |
| 22 #include "net/cert/cert_verify_result.h" | |
| 23 #include "net/cert/single_request_cert_verifier.h" | |
| 24 #include "net/cert/x509_certificate.h" | |
| 25 #include "net/cert/x509_util.h" | |
| 26 #include "net/http/transport_security_state.h" | |
| 27 #include "net/quic/crypto/crypto_protocol.h" | |
| 28 #include "net/ssl/ssl_config_service.h" | |
| 29 | |
| 30 using base::StringPiece; | |
| 31 using base::StringPrintf; | |
| 32 using std::string; | |
| 33 using std::vector; | |
| 34 | |
| 35 namespace net { | |
| 36 | |
| 37 ProofVerifyDetails* ProofVerifyDetailsChromium::Clone() const { | |
| 38 ProofVerifyDetailsChromium* other = new ProofVerifyDetailsChromium; | |
| 39 other->cert_verify_result = cert_verify_result; | |
| 40 return other; | |
| 41 } | |
| 42 | |
| 43 // A Job handles the verification of a single proof. It is owned by the | |
| 44 // ProofVerifier. If the verification can not complete synchronously, it | |
| 45 // will notify the ProofVerifier upon completion. | |
| 46 class ProofVerifierChromium::Job { | |
| 47 public: | |
| 48 Job(ProofVerifierChromium* proof_verifier, | |
| 49 CertVerifier* cert_verifier, | |
| 50 TransportSecurityState* transport_security_state, | |
| 51 const BoundNetLog& net_log); | |
| 52 | |
| 53 // Starts the proof verification. If |QUIC_PENDING| is returned, then | |
| 54 // |callback| will be invoked asynchronously when the verification completes. | |
| 55 QuicAsyncStatus VerifyProof(const std::string& hostname, | |
| 56 const std::string& server_config, | |
| 57 const std::vector<std::string>& certs, | |
| 58 const std::string& signature, | |
| 59 std::string* error_details, | |
| 60 scoped_ptr<ProofVerifyDetails>* verify_details, | |
| 61 ProofVerifierCallback* callback); | |
| 62 | |
| 63 private: | |
| 64 enum State { | |
| 65 STATE_NONE, | |
| 66 STATE_VERIFY_CERT, | |
| 67 STATE_VERIFY_CERT_COMPLETE, | |
| 68 }; | |
| 69 | |
| 70 int DoLoop(int last_io_result); | |
| 71 void OnIOComplete(int result); | |
| 72 int DoVerifyCert(int result); | |
| 73 int DoVerifyCertComplete(int result); | |
| 74 | |
| 75 bool VerifySignature(const std::string& signed_data, | |
| 76 const std::string& signature, | |
| 77 const std::string& cert); | |
| 78 | |
| 79 // Proof verifier to notify when this jobs completes. | |
| 80 ProofVerifierChromium* proof_verifier_; | |
| 81 | |
| 82 // The underlying verifier used for verifying certificates. | |
| 83 scoped_ptr<SingleRequestCertVerifier> verifier_; | |
| 84 | |
| 85 TransportSecurityState* transport_security_state_; | |
| 86 | |
| 87 // |hostname| specifies the hostname for which |certs| is a valid chain. | |
| 88 std::string hostname_; | |
| 89 | |
| 90 scoped_ptr<ProofVerifierCallback> callback_; | |
| 91 scoped_ptr<ProofVerifyDetailsChromium> verify_details_; | |
| 92 std::string error_details_; | |
| 93 | |
| 94 // X509Certificate from a chain of DER encoded certificates. | |
| 95 scoped_refptr<X509Certificate> cert_; | |
| 96 | |
| 97 State next_state_; | |
| 98 | |
| 99 BoundNetLog net_log_; | |
| 100 | |
| 101 DISALLOW_COPY_AND_ASSIGN(Job); | |
| 102 }; | |
| 103 | |
| 104 ProofVerifierChromium::Job::Job( | |
| 105 ProofVerifierChromium* proof_verifier, | |
| 106 CertVerifier* cert_verifier, | |
| 107 TransportSecurityState* transport_security_state, | |
| 108 const BoundNetLog& net_log) | |
| 109 : proof_verifier_(proof_verifier), | |
| 110 verifier_(new SingleRequestCertVerifier(cert_verifier)), | |
| 111 transport_security_state_(transport_security_state), | |
| 112 next_state_(STATE_NONE), | |
| 113 net_log_(net_log) { | |
| 114 } | |
| 115 | |
| 116 QuicAsyncStatus ProofVerifierChromium::Job::VerifyProof( | |
| 117 const string& hostname, | |
| 118 const string& server_config, | |
| 119 const vector<string>& certs, | |
| 120 const string& signature, | |
| 121 std::string* error_details, | |
| 122 scoped_ptr<ProofVerifyDetails>* verify_details, | |
| 123 ProofVerifierCallback* callback) { | |
| 124 // TODO(vadimt): Remove ScopedTracker below once crbug.com/422516 is fixed. | |
| 125 tracked_objects::ScopedTracker tracking_profile( | |
| 126 FROM_HERE_WITH_EXPLICIT_FUNCTION( | |
| 127 "422516 ProofVerifierChromium::Job::VerifyProof")); | |
| 128 | |
| 129 DCHECK(error_details); | |
| 130 DCHECK(verify_details); | |
| 131 DCHECK(callback); | |
| 132 | |
| 133 error_details->clear(); | |
| 134 | |
| 135 if (STATE_NONE != next_state_) { | |
| 136 *error_details = "Certificate is already set and VerifyProof has begun"; | |
| 137 DLOG(DFATAL) << *error_details; | |
| 138 return QUIC_FAILURE; | |
| 139 } | |
| 140 | |
| 141 verify_details_.reset(new ProofVerifyDetailsChromium); | |
| 142 | |
| 143 if (certs.empty()) { | |
| 144 *error_details = "Failed to create certificate chain. Certs are empty."; | |
| 145 DLOG(WARNING) << *error_details; | |
| 146 verify_details_->cert_verify_result.cert_status = CERT_STATUS_INVALID; | |
| 147 *verify_details = verify_details_.Pass(); | |
| 148 return QUIC_FAILURE; | |
| 149 } | |
| 150 | |
| 151 // Convert certs to X509Certificate. | |
| 152 vector<StringPiece> cert_pieces(certs.size()); | |
| 153 for (unsigned i = 0; i < certs.size(); i++) { | |
| 154 cert_pieces[i] = base::StringPiece(certs[i]); | |
| 155 } | |
| 156 cert_ = X509Certificate::CreateFromDERCertChain(cert_pieces); | |
| 157 if (!cert_.get()) { | |
| 158 *error_details = "Failed to create certificate chain"; | |
| 159 DLOG(WARNING) << *error_details; | |
| 160 verify_details_->cert_verify_result.cert_status = CERT_STATUS_INVALID; | |
| 161 *verify_details = verify_details_.Pass(); | |
| 162 return QUIC_FAILURE; | |
| 163 } | |
| 164 | |
| 165 // We call VerifySignature first to avoid copying of server_config and | |
| 166 // signature. | |
| 167 if (!VerifySignature(server_config, signature, certs[0])) { | |
| 168 *error_details = "Failed to verify signature of server config"; | |
| 169 DLOG(WARNING) << *error_details; | |
| 170 verify_details_->cert_verify_result.cert_status = CERT_STATUS_INVALID; | |
| 171 *verify_details = verify_details_.Pass(); | |
| 172 return QUIC_FAILURE; | |
| 173 } | |
| 174 | |
| 175 hostname_ = hostname; | |
| 176 | |
| 177 next_state_ = STATE_VERIFY_CERT; | |
| 178 switch (DoLoop(OK)) { | |
| 179 case OK: | |
| 180 *verify_details = verify_details_.Pass(); | |
| 181 return QUIC_SUCCESS; | |
| 182 case ERR_IO_PENDING: | |
| 183 callback_.reset(callback); | |
| 184 return QUIC_PENDING; | |
| 185 default: | |
| 186 *error_details = error_details_; | |
| 187 *verify_details = verify_details_.Pass(); | |
| 188 return QUIC_FAILURE; | |
| 189 } | |
| 190 } | |
| 191 | |
| 192 int ProofVerifierChromium::Job::DoLoop(int last_result) { | |
| 193 int rv = last_result; | |
| 194 do { | |
| 195 State state = next_state_; | |
| 196 next_state_ = STATE_NONE; | |
| 197 switch (state) { | |
| 198 case STATE_VERIFY_CERT: | |
| 199 DCHECK(rv == OK); | |
| 200 rv = DoVerifyCert(rv); | |
| 201 break; | |
| 202 case STATE_VERIFY_CERT_COMPLETE: | |
| 203 rv = DoVerifyCertComplete(rv); | |
| 204 break; | |
| 205 case STATE_NONE: | |
| 206 default: | |
| 207 rv = ERR_UNEXPECTED; | |
| 208 LOG(DFATAL) << "unexpected state " << state; | |
| 209 break; | |
| 210 } | |
| 211 } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE); | |
| 212 return rv; | |
| 213 } | |
| 214 | |
| 215 void ProofVerifierChromium::Job::OnIOComplete(int result) { | |
| 216 int rv = DoLoop(result); | |
| 217 if (rv != ERR_IO_PENDING) { | |
| 218 scoped_ptr<ProofVerifierCallback> callback(callback_.Pass()); | |
| 219 // Callback expects ProofVerifyDetails not ProofVerifyDetailsChromium. | |
| 220 scoped_ptr<ProofVerifyDetails> verify_details(verify_details_.Pass()); | |
| 221 callback->Run(rv == OK, error_details_, &verify_details); | |
| 222 // Will delete |this|. | |
| 223 proof_verifier_->OnJobComplete(this); | |
| 224 } | |
| 225 } | |
| 226 | |
| 227 int ProofVerifierChromium::Job::DoVerifyCert(int result) { | |
| 228 next_state_ = STATE_VERIFY_CERT_COMPLETE; | |
| 229 | |
| 230 int flags = 0; | |
| 231 return verifier_->Verify( | |
| 232 cert_.get(), | |
| 233 hostname_, | |
| 234 flags, | |
| 235 SSLConfigService::GetCRLSet().get(), | |
| 236 &verify_details_->cert_verify_result, | |
| 237 base::Bind(&ProofVerifierChromium::Job::OnIOComplete, | |
| 238 base::Unretained(this)), | |
| 239 net_log_); | |
| 240 } | |
| 241 | |
| 242 int ProofVerifierChromium::Job::DoVerifyCertComplete(int result) { | |
| 243 // TODO(vadimt): Remove ScopedTracker below once crbug.com/422516 is fixed. | |
| 244 tracked_objects::ScopedTracker tracking_profile( | |
| 245 FROM_HERE_WITH_EXPLICIT_FUNCTION( | |
| 246 "422516 ProofVerifierChromium::Job::DoVerifyCertComplete")); | |
| 247 | |
| 248 verifier_.reset(); | |
| 249 | |
| 250 const CertVerifyResult& cert_verify_result = | |
| 251 verify_details_->cert_verify_result; | |
| 252 const CertStatus cert_status = cert_verify_result.cert_status; | |
| 253 if (transport_security_state_ && | |
| 254 (result == OK || | |
| 255 (IsCertificateError(result) && IsCertStatusMinorError(cert_status))) && | |
| 256 !transport_security_state_->CheckPublicKeyPins( | |
| 257 hostname_, | |
| 258 cert_verify_result.is_issued_by_known_root, | |
| 259 cert_verify_result.public_key_hashes, | |
| 260 &verify_details_->pinning_failure_log)) { | |
| 261 result = ERR_SSL_PINNED_KEY_NOT_IN_CERT_CHAIN; | |
| 262 } | |
| 263 | |
| 264 scoped_refptr<ct::EVCertsWhitelist> ev_whitelist = | |
| 265 SSLConfigService::GetEVCertsWhitelist(); | |
| 266 if ((cert_status & CERT_STATUS_IS_EV) && ev_whitelist.get() && | |
| 267 ev_whitelist->IsValid()) { | |
| 268 const SHA256HashValue fingerprint( | |
| 269 X509Certificate::CalculateFingerprint256(cert_->os_cert_handle())); | |
| 270 | |
| 271 UMA_HISTOGRAM_BOOLEAN( | |
| 272 "Net.SSL_EVCertificateInWhitelist", | |
| 273 ev_whitelist->ContainsCertificateHash( | |
| 274 std::string(reinterpret_cast<const char*>(fingerprint.data), 8))); | |
| 275 } | |
| 276 | |
| 277 if (result != OK) { | |
| 278 std::string error_string = ErrorToString(result); | |
| 279 error_details_ = StringPrintf("Failed to verify certificate chain: %s", | |
| 280 error_string.c_str()); | |
| 281 DLOG(WARNING) << error_details_; | |
| 282 } | |
| 283 | |
| 284 // Exit DoLoop and return the result to the caller to VerifyProof. | |
| 285 DCHECK_EQ(STATE_NONE, next_state_); | |
| 286 return result; | |
| 287 } | |
| 288 | |
| 289 bool ProofVerifierChromium::Job::VerifySignature(const string& signed_data, | |
| 290 const string& signature, | |
| 291 const string& cert) { | |
| 292 // TODO(vadimt): Remove ScopedTracker below once crbug.com/422516 is fixed. | |
| 293 tracked_objects::ScopedTracker tracking_profile( | |
| 294 FROM_HERE_WITH_EXPLICIT_FUNCTION( | |
| 295 "422516 ProofVerifierChromium::Job::VerifySignature")); | |
| 296 | |
| 297 StringPiece spki; | |
| 298 if (!asn1::ExtractSPKIFromDERCert(cert, &spki)) { | |
| 299 DLOG(WARNING) << "ExtractSPKIFromDERCert failed"; | |
| 300 return false; | |
| 301 } | |
| 302 | |
| 303 crypto::SignatureVerifier verifier; | |
| 304 | |
| 305 size_t size_bits; | |
| 306 X509Certificate::PublicKeyType type; | |
| 307 X509Certificate::GetPublicKeyInfo(cert_->os_cert_handle(), &size_bits, | |
| 308 &type); | |
| 309 if (type == X509Certificate::kPublicKeyTypeRSA) { | |
| 310 crypto::SignatureVerifier::HashAlgorithm hash_alg = | |
| 311 crypto::SignatureVerifier::SHA256; | |
| 312 crypto::SignatureVerifier::HashAlgorithm mask_hash_alg = hash_alg; | |
| 313 unsigned int hash_len = 32; // 32 is the length of a SHA-256 hash. | |
| 314 | |
| 315 bool ok = verifier.VerifyInitRSAPSS( | |
| 316 hash_alg, mask_hash_alg, hash_len, | |
| 317 reinterpret_cast<const uint8*>(signature.data()), signature.size(), | |
| 318 reinterpret_cast<const uint8*>(spki.data()), spki.size()); | |
| 319 if (!ok) { | |
| 320 DLOG(WARNING) << "VerifyInitRSAPSS failed"; | |
| 321 return false; | |
| 322 } | |
| 323 } else if (type == X509Certificate::kPublicKeyTypeECDSA) { | |
| 324 // This is the algorithm ID for ECDSA with SHA-256. Parameters are ABSENT. | |
| 325 // RFC 5758: | |
| 326 // ecdsa-with-SHA256 OBJECT IDENTIFIER ::= { iso(1) member-body(2) | |
| 327 // us(840) ansi-X9-62(10045) signatures(4) ecdsa-with-SHA2(3) 2 } | |
| 328 // ... | |
| 329 // When the ecdsa-with-SHA224, ecdsa-with-SHA256, ecdsa-with-SHA384, or | |
| 330 // ecdsa-with-SHA512 algorithm identifier appears in the algorithm field | |
| 331 // as an AlgorithmIdentifier, the encoding MUST omit the parameters | |
| 332 // field. That is, the AlgorithmIdentifier SHALL be a SEQUENCE of one | |
| 333 // component, the OID ecdsa-with-SHA224, ecdsa-with-SHA256, ecdsa-with- | |
| 334 // SHA384, or ecdsa-with-SHA512. | |
| 335 // See also RFC 5480, Appendix A. | |
| 336 static const uint8 kECDSAWithSHA256AlgorithmID[] = { | |
| 337 0x30, 0x0a, | |
| 338 0x06, 0x08, | |
| 339 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, | |
| 340 }; | |
| 341 | |
| 342 if (!verifier.VerifyInit( | |
| 343 kECDSAWithSHA256AlgorithmID, sizeof(kECDSAWithSHA256AlgorithmID), | |
| 344 reinterpret_cast<const uint8*>(signature.data()), | |
| 345 signature.size(), | |
| 346 reinterpret_cast<const uint8*>(spki.data()), | |
| 347 spki.size())) { | |
| 348 DLOG(WARNING) << "VerifyInit failed"; | |
| 349 return false; | |
| 350 } | |
| 351 } else { | |
| 352 LOG(ERROR) << "Unsupported public key type " << type; | |
| 353 return false; | |
| 354 } | |
| 355 | |
| 356 verifier.VerifyUpdate(reinterpret_cast<const uint8*>(kProofSignatureLabel), | |
| 357 sizeof(kProofSignatureLabel)); | |
| 358 verifier.VerifyUpdate(reinterpret_cast<const uint8*>(signed_data.data()), | |
| 359 signed_data.size()); | |
| 360 | |
| 361 if (!verifier.VerifyFinal()) { | |
| 362 DLOG(WARNING) << "VerifyFinal failed"; | |
| 363 return false; | |
| 364 } | |
| 365 | |
| 366 DVLOG(1) << "VerifyFinal success"; | |
| 367 return true; | |
| 368 } | |
| 369 | |
| 370 ProofVerifierChromium::ProofVerifierChromium( | |
| 371 CertVerifier* cert_verifier, | |
| 372 TransportSecurityState* transport_security_state) | |
| 373 : cert_verifier_(cert_verifier), | |
| 374 transport_security_state_(transport_security_state) { | |
| 375 } | |
| 376 | |
| 377 ProofVerifierChromium::~ProofVerifierChromium() { | |
| 378 STLDeleteElements(&active_jobs_); | |
| 379 } | |
| 380 | |
| 381 QuicAsyncStatus ProofVerifierChromium::VerifyProof( | |
| 382 const std::string& hostname, | |
| 383 const std::string& server_config, | |
| 384 const std::vector<std::string>& certs, | |
| 385 const std::string& signature, | |
| 386 const ProofVerifyContext* verify_context, | |
| 387 std::string* error_details, | |
| 388 scoped_ptr<ProofVerifyDetails>* verify_details, | |
| 389 ProofVerifierCallback* callback) { | |
| 390 // TODO(vadimt): Remove ScopedTracker below once crbug.com/422516 is fixed. | |
| 391 tracked_objects::ScopedTracker tracking_profile( | |
| 392 FROM_HERE_WITH_EXPLICIT_FUNCTION( | |
| 393 "422516 ProofVerifierChromium::VerifyProof")); | |
| 394 | |
| 395 if (!verify_context) { | |
| 396 *error_details = "Missing context"; | |
| 397 return QUIC_FAILURE; | |
| 398 } | |
| 399 const ProofVerifyContextChromium* chromium_context = | |
| 400 reinterpret_cast<const ProofVerifyContextChromium*>(verify_context); | |
| 401 scoped_ptr<Job> job(new Job(this, | |
| 402 cert_verifier_, | |
| 403 transport_security_state_, | |
| 404 chromium_context->net_log)); | |
| 405 QuicAsyncStatus status = job->VerifyProof(hostname, server_config, certs, | |
| 406 signature, error_details, | |
| 407 verify_details, callback); | |
| 408 if (status == QUIC_PENDING) { | |
| 409 active_jobs_.insert(job.release()); | |
| 410 } | |
| 411 return status; | |
| 412 } | |
| 413 | |
| 414 void ProofVerifierChromium::OnJobComplete(Job* job) { | |
| 415 active_jobs_.erase(job); | |
| 416 delete job; | |
| 417 } | |
| 418 | |
| 419 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master