1 // Copyright (c) 2012 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 // OpenSSL binding for SSLClientSocket. The class layout and general principle 6 // of operation is derived from SSLClientSocketNSS. 7 8 #include "net/socket/ssl_client_socket_openssl.h" 9 10 #include <errno.h> 11 #include <openssl/bio.h> 12 #include <openssl/err.h> 13 #include <openssl/ssl.h> 14 15 #include "base/bind.h" 16 #include "base/callback_helpers.h" 17 #include "base/environment.h" 18 #include "base/memory/singleton.h" 19 #include "base/metrics/histogram.h" 20 #include "base/strings/string_piece.h" 21 #include "base/synchronization/lock.h" 22 #include "crypto/ec_private_key.h" 23 #include "crypto/openssl_util.h" 24 #include "crypto/scoped_openssl_types.h" 25 #include "net/base/net_errors.h" 26 #include "net/cert/cert_verifier.h" 27 #include "net/cert/ct_verifier.h" 28 #include "net/cert/single_request_cert_verifier.h" 29 #include "net/cert/x509_certificate_net_log_param.h" 30 #include "net/cert/x509_util_openssl.h" 31 #include "net/http/transport_security_state.h" 32 #include "net/socket/ssl_session_cache_openssl.h" 33 #include "net/ssl/openssl_ssl_util.h" 34 #include "net/ssl/ssl_cert_request_info.h" 35 #include "net/ssl/ssl_connection_status_flags.h" 36 #include "net/ssl/ssl_info.h" 37 38 #if defined(OS_WIN) 39 #include "base/win/windows_version.h" 40 #endif 41 42 #if defined(USE_OPENSSL_CERTS) 43 #include "net/ssl/openssl_client_key_store.h" 44 #else 45 #include "net/ssl/openssl_platform_key.h" 46 #endif 47 48 namespace net { 49 50 namespace { 51 52 // Enable this to see logging for state machine state transitions. 53 #if 0 54 #define GotoState(s) do { DVLOG(2) << (void *)this << " " << __FUNCTION__ << \ 55 " jump to state " << s; \ 56 next_handshake_state_ = s; } while (0) 57 #else 58 #define GotoState(s) next_handshake_state_ = s 59 #endif 60 61 // This constant can be any non-negative/non-zero value (eg: it does not 62 // overlap with any value of the net::Error range, including net::OK). 63 const int kNoPendingReadResult = 1; 64 65 // If a client doesn't have a list of protocols that it supports, but 66 // the server supports NPN, choosing "http/1.1" is the best answer. 67 const char kDefaultSupportedNPNProtocol[] = "http/1.1"; 68 69 void FreeX509Stack(STACK_OF(X509)* ptr) { 70 sk_X509_pop_free(ptr, X509_free); 71 } 72 73 typedef crypto::ScopedOpenSSL<X509, X509_free>::Type ScopedX509; 74 typedef crypto::ScopedOpenSSL<STACK_OF(X509), FreeX509Stack>::Type 75 ScopedX509Stack; 76 77 #if OPENSSL_VERSION_NUMBER < 0x1000103fL 78 // This method doesn't seem to have made it into the OpenSSL headers. 79 unsigned long SSL_CIPHER_get_id(const SSL_CIPHER* cipher) { return cipher->id; } 80 #endif 81 82 // Used for encoding the |connection_status| field of an SSLInfo object. 83 int EncodeSSLConnectionStatus(int cipher_suite, 84 int compression, 85 int version) { 86 return ((cipher_suite & SSL_CONNECTION_CIPHERSUITE_MASK) << 87 SSL_CONNECTION_CIPHERSUITE_SHIFT) | 88 ((compression & SSL_CONNECTION_COMPRESSION_MASK) << 89 SSL_CONNECTION_COMPRESSION_SHIFT) | 90 ((version & SSL_CONNECTION_VERSION_MASK) << 91 SSL_CONNECTION_VERSION_SHIFT); 92 } 93 94 // Returns the net SSL version number (see ssl_connection_status_flags.h) for 95 // this SSL connection. 96 int GetNetSSLVersion(SSL* ssl) { 97 switch (SSL_version(ssl)) { 98 case SSL2_VERSION: 99 return SSL_CONNECTION_VERSION_SSL2; 100 case SSL3_VERSION: 101 return SSL_CONNECTION_VERSION_SSL3; 102 case TLS1_VERSION: 103 return SSL_CONNECTION_VERSION_TLS1; 104 case 0x0302: 105 return SSL_CONNECTION_VERSION_TLS1_1; 106 case 0x0303: 107 return SSL_CONNECTION_VERSION_TLS1_2; 108 default: 109 return SSL_CONNECTION_VERSION_UNKNOWN; 110 } 111 } 112 113 ScopedX509 OSCertHandleToOpenSSL( 114 X509Certificate::OSCertHandle os_handle) { 115 #if defined(USE_OPENSSL_CERTS) 116 return ScopedX509(X509Certificate::DupOSCertHandle(os_handle)); 117 #else // !defined(USE_OPENSSL_CERTS) 118 std::string der_encoded; 119 if (!X509Certificate::GetDEREncoded(os_handle, &der_encoded)) 120 return ScopedX509(); 121 const uint8_t* bytes = reinterpret_cast<const uint8_t*>(der_encoded.data()); 122 return ScopedX509(d2i_X509(NULL, &bytes, der_encoded.size())); 123 #endif // defined(USE_OPENSSL_CERTS) 124 } 125 126 ScopedX509Stack OSCertHandlesToOpenSSL( 127 const X509Certificate::OSCertHandles& os_handles) { 128 ScopedX509Stack stack(sk_X509_new_null()); 129 for (size_t i = 0; i < os_handles.size(); i++) { 130 ScopedX509 x509 = OSCertHandleToOpenSSL(os_handles[i]); 131 if (!x509) 132 return ScopedX509Stack(); 133 sk_X509_push(stack.get(), x509.release()); 134 } 135 return stack.Pass(); 136 } 137 138 int LogErrorCallback(const char* str, size_t len, void* context) { 139 LOG(ERROR) << base::StringPiece(str, len); 140 return 1; 141 } 142 143 } // namespace 144 145 class SSLClientSocketOpenSSL::SSLContext { 146 public: 147 static SSLContext* GetInstance() { return Singleton<SSLContext>::get(); } 148 SSL_CTX* ssl_ctx() { return ssl_ctx_.get(); } 149 SSLSessionCacheOpenSSL* session_cache() { return &session_cache_; } 150 151 SSLClientSocketOpenSSL* GetClientSocketFromSSL(const SSL* ssl) { 152 DCHECK(ssl); 153 SSLClientSocketOpenSSL* socket = static_cast<SSLClientSocketOpenSSL*>( 154 SSL_get_ex_data(ssl, ssl_socket_data_index_)); 155 DCHECK(socket); 156 return socket; 157 } 158 159 bool SetClientSocketForSSL(SSL* ssl, SSLClientSocketOpenSSL* socket) { 160 return SSL_set_ex_data(ssl, ssl_socket_data_index_, socket) != 0; 161 } 162 163 private: 164 friend struct DefaultSingletonTraits<SSLContext>; 165 166 SSLContext() { 167 crypto::EnsureOpenSSLInit(); 168 ssl_socket_data_index_ = SSL_get_ex_new_index(0, 0, 0, 0, 0); 169 DCHECK_NE(ssl_socket_data_index_, -1); 170 ssl_ctx_.reset(SSL_CTX_new(SSLv23_client_method())); 171 session_cache_.Reset(ssl_ctx_.get(), kDefaultSessionCacheConfig); 172 SSL_CTX_set_cert_verify_callback(ssl_ctx_.get(), CertVerifyCallback, NULL); 173 SSL_CTX_set_cert_cb(ssl_ctx_.get(), ClientCertRequestCallback, NULL); 174 SSL_CTX_set_verify(ssl_ctx_.get(), SSL_VERIFY_PEER, NULL); 175 // TODO(kristianm): Only select this if ssl_config_.next_proto is not empty. 176 // It would be better if the callback were not a global setting, 177 // but that is an OpenSSL issue. 178 SSL_CTX_set_next_proto_select_cb(ssl_ctx_.get(), SelectNextProtoCallback, 179 NULL); 180 ssl_ctx_->tlsext_channel_id_enabled_new = 1; 181 182 scoped_ptr<base::Environment> env(base::Environment::Create()); 183 std::string ssl_keylog_file; 184 if (env->GetVar("SSLKEYLOGFILE", &ssl_keylog_file) && 185 !ssl_keylog_file.empty()) { 186 crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE); 187 BIO* bio = BIO_new_file(ssl_keylog_file.c_str(), "a"); 188 if (!bio) { 189 LOG(ERROR) << "Failed to open " << ssl_keylog_file; 190 ERR_print_errors_cb(&LogErrorCallback, NULL); 191 } else { 192 SSL_CTX_set_keylog_bio(ssl_ctx_.get(), bio); 193 } 194 } 195 } 196 197 static std::string GetSessionCacheKey(const SSL* ssl) { 198 SSLClientSocketOpenSSL* socket = GetInstance()->GetClientSocketFromSSL(ssl); 199 DCHECK(socket); 200 return socket->GetSessionCacheKey(); 201 } 202 203 static SSLSessionCacheOpenSSL::Config kDefaultSessionCacheConfig; 204 205 static int ClientCertRequestCallback(SSL* ssl, void* arg) { 206 SSLClientSocketOpenSSL* socket = GetInstance()->GetClientSocketFromSSL(ssl); 207 DCHECK(socket); 208 return socket->ClientCertRequestCallback(ssl); 209 } 210 211 static int CertVerifyCallback(X509_STORE_CTX *store_ctx, void *arg) { 212 SSL* ssl = reinterpret_cast<SSL*>(X509_STORE_CTX_get_ex_data( 213 store_ctx, SSL_get_ex_data_X509_STORE_CTX_idx())); 214 SSLClientSocketOpenSSL* socket = GetInstance()->GetClientSocketFromSSL(ssl); 215 CHECK(socket); 216 217 return socket->CertVerifyCallback(store_ctx); 218 } 219 220 static int SelectNextProtoCallback(SSL* ssl, 221 unsigned char** out, unsigned char* outlen, 222 const unsigned char* in, 223 unsigned int inlen, void* arg) { 224 SSLClientSocketOpenSSL* socket = GetInstance()->GetClientSocketFromSSL(ssl); 225 return socket->SelectNextProtoCallback(out, outlen, in, inlen); 226 } 227 228 // This is the index used with SSL_get_ex_data to retrieve the owner 229 // SSLClientSocketOpenSSL object from an SSL instance. 230 int ssl_socket_data_index_; 231 232 crypto::ScopedOpenSSL<SSL_CTX, SSL_CTX_free>::Type ssl_ctx_; 233 // |session_cache_| must be destroyed before |ssl_ctx_|. 234 SSLSessionCacheOpenSSL session_cache_; 235 }; 236 237 // PeerCertificateChain is a helper object which extracts the certificate 238 // chain, as given by the server, from an OpenSSL socket and performs the needed 239 // resource management. The first element of the chain is the leaf certificate 240 // and the other elements are in the order given by the server. 241 class SSLClientSocketOpenSSL::PeerCertificateChain { 242 public: 243 explicit PeerCertificateChain(STACK_OF(X509)* chain) { Reset(chain); } 244 PeerCertificateChain(const PeerCertificateChain& other) { *this = other; } 245 ~PeerCertificateChain() {} 246 PeerCertificateChain& operator=(const PeerCertificateChain& other); 247 248 // Resets the PeerCertificateChain to the set of certificates in|chain|, 249 // which may be NULL, indicating to empty the store certificates. 250 // Note: If an error occurs, such as being unable to parse the certificates, 251 // this will behave as if Reset(NULL) was called. 252 void Reset(STACK_OF(X509)* chain); 253 254 // Note that when USE_OPENSSL is defined, OSCertHandle is X509* 255 scoped_refptr<X509Certificate> AsOSChain() const; 256 257 size_t size() const { 258 if (!openssl_chain_.get()) 259 return 0; 260 return sk_X509_num(openssl_chain_.get()); 261 } 262 263 bool empty() const { 264 return size() == 0; 265 } 266 267 X509* Get(size_t index) const { 268 DCHECK_LT(index, size()); 269 return sk_X509_value(openssl_chain_.get(), index); 270 } 271 272 private: 273 ScopedX509Stack openssl_chain_; 274 }; 275 276 SSLClientSocketOpenSSL::PeerCertificateChain& 277 SSLClientSocketOpenSSL::PeerCertificateChain::operator=( 278 const PeerCertificateChain& other) { 279 if (this == &other) 280 return *this; 281 282 openssl_chain_.reset(X509_chain_up_ref(other.openssl_chain_.get())); 283 return *this; 284 } 285 286 void SSLClientSocketOpenSSL::PeerCertificateChain::Reset( 287 STACK_OF(X509)* chain) { 288 openssl_chain_.reset(chain ? X509_chain_up_ref(chain) : NULL); 289 } 290 291 scoped_refptr<X509Certificate> 292 SSLClientSocketOpenSSL::PeerCertificateChain::AsOSChain() const { 293 #if defined(USE_OPENSSL_CERTS) 294 // When OSCertHandle is typedef'ed to X509, this implementation does a short 295 // cut to avoid converting back and forth between DER and the X509 struct. 296 X509Certificate::OSCertHandles intermediates; 297 for (size_t i = 1; i < sk_X509_num(openssl_chain_.get()); ++i) { 298 intermediates.push_back(sk_X509_value(openssl_chain_.get(), i)); 299 } 300 301 return make_scoped_refptr(X509Certificate::CreateFromHandle( 302 sk_X509_value(openssl_chain_.get(), 0), intermediates)); 303 #else 304 // DER-encode the chain and convert to a platform certificate handle. 305 std::vector<base::StringPiece> der_chain; 306 for (size_t i = 0; i < sk_X509_num(openssl_chain_.get()); ++i) { 307 X509* x = sk_X509_value(openssl_chain_.get(), i); 308 base::StringPiece der; 309 if (!x509_util::GetDER(x, &der)) 310 return NULL; 311 der_chain.push_back(der); 312 } 313 314 return make_scoped_refptr(X509Certificate::CreateFromDERCertChain(der_chain)); 315 #endif 316 } 317 318 // static 319 SSLSessionCacheOpenSSL::Config 320 SSLClientSocketOpenSSL::SSLContext::kDefaultSessionCacheConfig = { 321 &GetSessionCacheKey, // key_func 322 1024, // max_entries 323 256, // expiration_check_count 324 60 * 60, // timeout_seconds 325 }; 326 327 // static 328 void SSLClientSocket::ClearSessionCache() { 329 SSLClientSocketOpenSSL::SSLContext* context = 330 SSLClientSocketOpenSSL::SSLContext::GetInstance(); 331 context->session_cache()->Flush(); 332 } 333 334 SSLClientSocketOpenSSL::SSLClientSocketOpenSSL( 335 scoped_ptr<ClientSocketHandle> transport_socket, 336 const HostPortPair& host_and_port, 337 const SSLConfig& ssl_config, 338 const SSLClientSocketContext& context) 339 : transport_send_busy_(false), 340 transport_recv_busy_(false), 341 pending_read_error_(kNoPendingReadResult), 342 transport_read_error_(OK), 343 transport_write_error_(OK), 344 server_cert_chain_(new PeerCertificateChain(NULL)), 345 completed_connect_(false), 346 was_ever_used_(false), 347 client_auth_cert_needed_(false), 348 cert_verifier_(context.cert_verifier), 349 cert_transparency_verifier_(context.cert_transparency_verifier), 350 channel_id_service_(context.channel_id_service), 351 ssl_(NULL), 352 transport_bio_(NULL), 353 transport_(transport_socket.Pass()), 354 host_and_port_(host_and_port), 355 ssl_config_(ssl_config), 356 ssl_session_cache_shard_(context.ssl_session_cache_shard), 357 trying_cached_session_(false), 358 next_handshake_state_(STATE_NONE), 359 npn_status_(kNextProtoUnsupported), 360 channel_id_xtn_negotiated_(false), 361 handshake_succeeded_(false), 362 marked_session_as_good_(false), 363 transport_security_state_(context.transport_security_state), 364 net_log_(transport_->socket()->NetLog()), 365 weak_factory_(this) { 366 } 367 368 SSLClientSocketOpenSSL::~SSLClientSocketOpenSSL() { 369 Disconnect(); 370 } 371 372 std::string SSLClientSocketOpenSSL::GetSessionCacheKey() const { 373 std::string result = host_and_port_.ToString(); 374 result.append("/"); 375 result.append(ssl_session_cache_shard_); 376 return result; 377 } 378 379 bool SSLClientSocketOpenSSL::InSessionCache() const { 380 SSLContext* context = SSLContext::GetInstance(); 381 std::string cache_key = GetSessionCacheKey(); 382 return context->session_cache()->SSLSessionIsInCache(cache_key); 383 } 384 385 void SSLClientSocketOpenSSL::SetHandshakeCompletionCallback( 386 const base::Closure& callback) { 387 handshake_completion_callback_ = callback; 388 } 389 390 void SSLClientSocketOpenSSL::GetSSLCertRequestInfo( 391 SSLCertRequestInfo* cert_request_info) { 392 cert_request_info->host_and_port = host_and_port_; 393 cert_request_info->cert_authorities = cert_authorities_; 394 cert_request_info->cert_key_types = cert_key_types_; 395 } 396 397 SSLClientSocket::NextProtoStatus SSLClientSocketOpenSSL::GetNextProto( 398 std::string* proto) { 399 *proto = npn_proto_; 400 return npn_status_; 401 } 402 403 ChannelIDService* 404 SSLClientSocketOpenSSL::GetChannelIDService() const { 405 return channel_id_service_; 406 } 407 408 int SSLClientSocketOpenSSL::ExportKeyingMaterial( 409 const base::StringPiece& label, 410 bool has_context, const base::StringPiece& context, 411 unsigned char* out, unsigned int outlen) { 412 crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE); 413 414 int rv = SSL_export_keying_material( 415 ssl_, out, outlen, label.data(), label.size(), 416 reinterpret_cast<const unsigned char*>(context.data()), 417 context.length(), context.length() > 0); 418 419 if (rv != 1) { 420 int ssl_error = SSL_get_error(ssl_, rv); 421 LOG(ERROR) << "Failed to export keying material;" 422 << " returned " << rv 423 << ", SSL error code " << ssl_error; 424 return MapOpenSSLError(ssl_error, err_tracer); 425 } 426 return OK; 427 } 428 429 int SSLClientSocketOpenSSL::GetTLSUniqueChannelBinding(std::string* out) { 430 NOTIMPLEMENTED(); 431 return ERR_NOT_IMPLEMENTED; 432 } 433 434 int SSLClientSocketOpenSSL::Connect(const CompletionCallback& callback) { 435 // It is an error to create an SSLClientSocket whose context has no 436 // TransportSecurityState. 437 DCHECK(transport_security_state_); 438 439 net_log_.BeginEvent(NetLog::TYPE_SSL_CONNECT); 440 441 // Set up new ssl object. 442 int rv = Init(); 443 if (rv != OK) { 444 net_log_.EndEventWithNetErrorCode(NetLog::TYPE_SSL_CONNECT, rv); 445 return rv; 446 } 447 448 // Set SSL to client mode. Handshake happens in the loop below. 449 SSL_set_connect_state(ssl_); 450 451 GotoState(STATE_HANDSHAKE); 452 rv = DoHandshakeLoop(OK); 453 if (rv == ERR_IO_PENDING) { 454 user_connect_callback_ = callback; 455 } else { 456 net_log_.EndEventWithNetErrorCode(NetLog::TYPE_SSL_CONNECT, rv); 457 if (rv < OK) 458 OnHandshakeCompletion(); 459 } 460 461 return rv > OK ? OK : rv; 462 } 463 464 void SSLClientSocketOpenSSL::Disconnect() { 465 // If a handshake was pending (Connect() had been called), notify interested 466 // parties that it's been aborted now. If the handshake had already 467 // completed, this is a no-op. 468 OnHandshakeCompletion(); 469 if (ssl_) { 470 // Calling SSL_shutdown prevents the session from being marked as 471 // unresumable. 472 SSL_shutdown(ssl_); 473 SSL_free(ssl_); 474 ssl_ = NULL; 475 } 476 if (transport_bio_) { 477 BIO_free_all(transport_bio_); 478 transport_bio_ = NULL; 479 } 480 481 // Shut down anything that may call us back. 482 verifier_.reset(); 483 transport_->socket()->Disconnect(); 484 485 // Null all callbacks, delete all buffers. 486 transport_send_busy_ = false; 487 send_buffer_ = NULL; 488 transport_recv_busy_ = false; 489 recv_buffer_ = NULL; 490 491 user_connect_callback_.Reset(); 492 user_read_callback_.Reset(); 493 user_write_callback_.Reset(); 494 user_read_buf_ = NULL; 495 user_read_buf_len_ = 0; 496 user_write_buf_ = NULL; 497 user_write_buf_len_ = 0; 498 499 pending_read_error_ = kNoPendingReadResult; 500 transport_read_error_ = OK; 501 transport_write_error_ = OK; 502 503 server_cert_verify_result_.Reset(); 504 completed_connect_ = false; 505 506 cert_authorities_.clear(); 507 cert_key_types_.clear(); 508 client_auth_cert_needed_ = false; 509 510 start_cert_verification_time_ = base::TimeTicks(); 511 512 npn_status_ = kNextProtoUnsupported; 513 npn_proto_.clear(); 514 515 channel_id_xtn_negotiated_ = false; 516 channel_id_request_handle_.Cancel(); 517 } 518 519 bool SSLClientSocketOpenSSL::IsConnected() const { 520 // If the handshake has not yet completed. 521 if (!completed_connect_) 522 return false; 523 // If an asynchronous operation is still pending. 524 if (user_read_buf_.get() || user_write_buf_.get()) 525 return true; 526 527 return transport_->socket()->IsConnected(); 528 } 529 530 bool SSLClientSocketOpenSSL::IsConnectedAndIdle() const { 531 // If the handshake has not yet completed. 532 if (!completed_connect_) 533 return false; 534 // If an asynchronous operation is still pending. 535 if (user_read_buf_.get() || user_write_buf_.get()) 536 return false; 537 // If there is data waiting to be sent, or data read from the network that 538 // has not yet been consumed. 539 if (BIO_pending(transport_bio_) > 0 || 540 BIO_wpending(transport_bio_) > 0) { 541 return false; 542 } 543 544 return transport_->socket()->IsConnectedAndIdle(); 545 } 546 547 int SSLClientSocketOpenSSL::GetPeerAddress(IPEndPoint* addressList) const { 548 return transport_->socket()->GetPeerAddress(addressList); 549 } 550 551 int SSLClientSocketOpenSSL::GetLocalAddress(IPEndPoint* addressList) const { 552 return transport_->socket()->GetLocalAddress(addressList); 553 } 554 555 const BoundNetLog& SSLClientSocketOpenSSL::NetLog() const { 556 return net_log_; 557 } 558 559 void SSLClientSocketOpenSSL::SetSubresourceSpeculation() { 560 if (transport_.get() && transport_->socket()) { 561 transport_->socket()->SetSubresourceSpeculation(); 562 } else { 563 NOTREACHED(); 564 } 565 } 566 567 void SSLClientSocketOpenSSL::SetOmniboxSpeculation() { 568 if (transport_.get() && transport_->socket()) { 569 transport_->socket()->SetOmniboxSpeculation(); 570 } else { 571 NOTREACHED(); 572 } 573 } 574 575 bool SSLClientSocketOpenSSL::WasEverUsed() const { 576 return was_ever_used_; 577 } 578 579 bool SSLClientSocketOpenSSL::UsingTCPFastOpen() const { 580 if (transport_.get() && transport_->socket()) 581 return transport_->socket()->UsingTCPFastOpen(); 582 583 NOTREACHED(); 584 return false; 585 } 586 587 bool SSLClientSocketOpenSSL::GetSSLInfo(SSLInfo* ssl_info) { 588 ssl_info->Reset(); 589 if (server_cert_chain_->empty()) 590 return false; 591 592 ssl_info->cert = server_cert_verify_result_.verified_cert; 593 ssl_info->cert_status = server_cert_verify_result_.cert_status; 594 ssl_info->is_issued_by_known_root = 595 server_cert_verify_result_.is_issued_by_known_root; 596 ssl_info->public_key_hashes = 597 server_cert_verify_result_.public_key_hashes; 598 ssl_info->client_cert_sent = 599 ssl_config_.send_client_cert && ssl_config_.client_cert.get(); 600 ssl_info->channel_id_sent = WasChannelIDSent(); 601 ssl_info->pinning_failure_log = pinning_failure_log_; 602 603 AddSCTInfoToSSLInfo(ssl_info); 604 605 const SSL_CIPHER* cipher = SSL_get_current_cipher(ssl_); 606 CHECK(cipher); 607 ssl_info->security_bits = SSL_CIPHER_get_bits(cipher, NULL); 608 609 ssl_info->connection_status = EncodeSSLConnectionStatus( 610 SSL_CIPHER_get_id(cipher), 0 /* no compression */, 611 GetNetSSLVersion(ssl_)); 612 613 if (!SSL_get_secure_renegotiation_support(ssl_)) 614 ssl_info->connection_status |= SSL_CONNECTION_NO_RENEGOTIATION_EXTENSION; 615 616 if (ssl_config_.version_fallback) 617 ssl_info->connection_status |= SSL_CONNECTION_VERSION_FALLBACK; 618 619 ssl_info->handshake_type = SSL_session_reused(ssl_) ? 620 SSLInfo::HANDSHAKE_RESUME : SSLInfo::HANDSHAKE_FULL; 621 622 DVLOG(3) << "Encoded connection status: cipher suite = " 623 << SSLConnectionStatusToCipherSuite(ssl_info->connection_status) 624 << " version = " 625 << SSLConnectionStatusToVersion(ssl_info->connection_status); 626 return true; 627 } 628 629 int SSLClientSocketOpenSSL::Read(IOBuffer* buf, 630 int buf_len, 631 const CompletionCallback& callback) { 632 user_read_buf_ = buf; 633 user_read_buf_len_ = buf_len; 634 635 int rv = DoReadLoop(); 636 637 if (rv == ERR_IO_PENDING) { 638 user_read_callback_ = callback; 639 } else { 640 if (rv > 0) 641 was_ever_used_ = true; 642 user_read_buf_ = NULL; 643 user_read_buf_len_ = 0; 644 if (rv <= 0) { 645 // Failure of a read attempt may indicate a failed false start 646 // connection. 647 OnHandshakeCompletion(); 648 } 649 } 650 651 return rv; 652 } 653 654 int SSLClientSocketOpenSSL::Write(IOBuffer* buf, 655 int buf_len, 656 const CompletionCallback& callback) { 657 user_write_buf_ = buf; 658 user_write_buf_len_ = buf_len; 659 660 int rv = DoWriteLoop(); 661 662 if (rv == ERR_IO_PENDING) { 663 user_write_callback_ = callback; 664 } else { 665 if (rv > 0) 666 was_ever_used_ = true; 667 user_write_buf_ = NULL; 668 user_write_buf_len_ = 0; 669 if (rv < 0) { 670 // Failure of a write attempt may indicate a failed false start 671 // connection. 672 OnHandshakeCompletion(); 673 } 674 } 675 676 return rv; 677 } 678 679 int SSLClientSocketOpenSSL::SetReceiveBufferSize(int32 size) { 680 return transport_->socket()->SetReceiveBufferSize(size); 681 } 682 683 int SSLClientSocketOpenSSL::SetSendBufferSize(int32 size) { 684 return transport_->socket()->SetSendBufferSize(size); 685 } 686 687 int SSLClientSocketOpenSSL::Init() { 688 DCHECK(!ssl_); 689 DCHECK(!transport_bio_); 690 691 SSLContext* context = SSLContext::GetInstance(); 692 crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE); 693 694 ssl_ = SSL_new(context->ssl_ctx()); 695 if (!ssl_ || !context->SetClientSocketForSSL(ssl_, this)) 696 return ERR_UNEXPECTED; 697 698 if (!SSL_set_tlsext_host_name(ssl_, host_and_port_.host().c_str())) 699 return ERR_UNEXPECTED; 700 701 // Set an OpenSSL callback to monitor this SSL*'s connection. 702 SSL_set_info_callback(ssl_, &InfoCallback); 703 704 trying_cached_session_ = context->session_cache()->SetSSLSessionWithKey( 705 ssl_, GetSessionCacheKey()); 706 707 BIO* ssl_bio = NULL; 708 // 0 => use default buffer sizes. 709 if (!BIO_new_bio_pair(&ssl_bio, 0, &transport_bio_, 0)) 710 return ERR_UNEXPECTED; 711 DCHECK(ssl_bio); 712 DCHECK(transport_bio_); 713 714 // Install a callback on OpenSSL's end to plumb transport errors through. 715 BIO_set_callback(ssl_bio, BIOCallback); 716 BIO_set_callback_arg(ssl_bio, reinterpret_cast<char*>(this)); 717 718 SSL_set_bio(ssl_, ssl_bio, ssl_bio); 719 720 // OpenSSL defaults some options to on, others to off. To avoid ambiguity, 721 // set everything we care about to an absolute value. 722 SslSetClearMask options; 723 options.ConfigureFlag(SSL_OP_NO_SSLv2, true); 724 bool ssl3_enabled = (ssl_config_.version_min == SSL_PROTOCOL_VERSION_SSL3); 725 options.ConfigureFlag(SSL_OP_NO_SSLv3, !ssl3_enabled); 726 bool tls1_enabled = (ssl_config_.version_min <= SSL_PROTOCOL_VERSION_TLS1 && 727 ssl_config_.version_max >= SSL_PROTOCOL_VERSION_TLS1); 728 options.ConfigureFlag(SSL_OP_NO_TLSv1, !tls1_enabled); 729 bool tls1_1_enabled = 730 (ssl_config_.version_min <= SSL_PROTOCOL_VERSION_TLS1_1 && 731 ssl_config_.version_max >= SSL_PROTOCOL_VERSION_TLS1_1); 732 options.ConfigureFlag(SSL_OP_NO_TLSv1_1, !tls1_1_enabled); 733 bool tls1_2_enabled = 734 (ssl_config_.version_min <= SSL_PROTOCOL_VERSION_TLS1_2 && 735 ssl_config_.version_max >= SSL_PROTOCOL_VERSION_TLS1_2); 736 options.ConfigureFlag(SSL_OP_NO_TLSv1_2, !tls1_2_enabled); 737 738 options.ConfigureFlag(SSL_OP_NO_COMPRESSION, true); 739 740 // TODO(joth): Set this conditionally, see http://crbug.com/55410 741 options.ConfigureFlag(SSL_OP_LEGACY_SERVER_CONNECT, true); 742 743 SSL_set_options(ssl_, options.set_mask); 744 SSL_clear_options(ssl_, options.clear_mask); 745 746 // Same as above, this time for the SSL mode. 747 SslSetClearMask mode; 748 749 mode.ConfigureFlag(SSL_MODE_RELEASE_BUFFERS, true); 750 mode.ConfigureFlag(SSL_MODE_CBC_RECORD_SPLITTING, true); 751 752 mode.ConfigureFlag(SSL_MODE_HANDSHAKE_CUTTHROUGH, 753 ssl_config_.false_start_enabled); 754 755 SSL_set_mode(ssl_, mode.set_mask); 756 SSL_clear_mode(ssl_, mode.clear_mask); 757 758 // Removing ciphers by ID from OpenSSL is a bit involved as we must use the 759 // textual name with SSL_set_cipher_list because there is no public API to 760 // directly remove a cipher by ID. 761 STACK_OF(SSL_CIPHER)* ciphers = SSL_get_ciphers(ssl_); 762 DCHECK(ciphers); 763 // See SSLConfig::disabled_cipher_suites for description of the suites 764 // disabled by default. Note that !SHA256 and !SHA384 only remove HMAC-SHA256 765 // and HMAC-SHA384 cipher suites, not GCM cipher suites with SHA256 or SHA384 766 // as the handshake hash. 767 std::string command("DEFAULT:!NULL:!aNULL:!IDEA:!FZA:!SRP:!SHA256:!SHA384:" 768 "!aECDH:!AESGCM+AES256"); 769 // Walk through all the installed ciphers, seeing if any need to be 770 // appended to the cipher removal |command|. 771 for (size_t i = 0; i < sk_SSL_CIPHER_num(ciphers); ++i) { 772 const SSL_CIPHER* cipher = sk_SSL_CIPHER_value(ciphers, i); 773 const uint16 id = SSL_CIPHER_get_id(cipher); 774 // Remove any ciphers with a strength of less than 80 bits. Note the NSS 775 // implementation uses "effective" bits here but OpenSSL does not provide 776 // this detail. This only impacts Triple DES: reports 112 vs. 168 bits, 777 // both of which are greater than 80 anyway. 778 bool disable = SSL_CIPHER_get_bits(cipher, NULL) < 80; 779 if (!disable) { 780 disable = std::find(ssl_config_.disabled_cipher_suites.begin(), 781 ssl_config_.disabled_cipher_suites.end(), id) != 782 ssl_config_.disabled_cipher_suites.end(); 783 } 784 if (disable) { 785 const char* name = SSL_CIPHER_get_name(cipher); 786 DVLOG(3) << "Found cipher to remove: '" << name << "', ID: " << id 787 << " strength: " << SSL_CIPHER_get_bits(cipher, NULL); 788 command.append(":!"); 789 command.append(name); 790 } 791 } 792 793 // Disable ECDSA cipher suites on platforms that do not support ECDSA 794 // signed certificates, as servers may use the presence of such 795 // ciphersuites as a hint to send an ECDSA certificate. 796 #if defined(OS_WIN) 797 if (base::win::GetVersion() < base::win::VERSION_VISTA) 798 command.append(":!ECDSA"); 799 #endif 800 801 int rv = SSL_set_cipher_list(ssl_, command.c_str()); 802 // If this fails (rv = 0) it means there are no ciphers enabled on this SSL. 803 // This will almost certainly result in the socket failing to complete the 804 // handshake at which point the appropriate error is bubbled up to the client. 805 LOG_IF(WARNING, rv != 1) << "SSL_set_cipher_list('" << command << "') " 806 "returned " << rv; 807 808 if (ssl_config_.version_fallback) 809 SSL_enable_fallback_scsv(ssl_); 810 811 // TLS channel ids. 812 if (IsChannelIDEnabled(ssl_config_, channel_id_service_)) { 813 SSL_enable_tls_channel_id(ssl_); 814 } 815 816 if (!ssl_config_.next_protos.empty()) { 817 std::vector<uint8_t> wire_protos = 818 SerializeNextProtos(ssl_config_.next_protos); 819 SSL_set_alpn_protos(ssl_, wire_protos.empty() ? NULL : &wire_protos[0], 820 wire_protos.size()); 821 } 822 823 if (ssl_config_.signed_cert_timestamps_enabled) { 824 SSL_enable_signed_cert_timestamps(ssl_); 825 SSL_enable_ocsp_stapling(ssl_); 826 } 827 828 // TODO(davidben): Enable OCSP stapling on platforms which support it and pass 829 // into the certificate verifier. https://crbug.com/398677 830 831 return OK; 832 } 833 834 void SSLClientSocketOpenSSL::DoReadCallback(int rv) { 835 // Since Run may result in Read being called, clear |user_read_callback_| 836 // up front. 837 if (rv > 0) 838 was_ever_used_ = true; 839 user_read_buf_ = NULL; 840 user_read_buf_len_ = 0; 841 if (rv <= 0) { 842 // Failure of a read attempt may indicate a failed false start 843 // connection. 844 OnHandshakeCompletion(); 845 } 846 base::ResetAndReturn(&user_read_callback_).Run(rv); 847 } 848 849 void SSLClientSocketOpenSSL::DoWriteCallback(int rv) { 850 // Since Run may result in Write being called, clear |user_write_callback_| 851 // up front. 852 if (rv > 0) 853 was_ever_used_ = true; 854 user_write_buf_ = NULL; 855 user_write_buf_len_ = 0; 856 if (rv < 0) { 857 // Failure of a write attempt may indicate a failed false start 858 // connection. 859 OnHandshakeCompletion(); 860 } 861 base::ResetAndReturn(&user_write_callback_).Run(rv); 862 } 863 864 void SSLClientSocketOpenSSL::OnHandshakeCompletion() { 865 if (!handshake_completion_callback_.is_null()) 866 base::ResetAndReturn(&handshake_completion_callback_).Run(); 867 } 868 869 bool SSLClientSocketOpenSSL::DoTransportIO() { 870 bool network_moved = false; 871 int rv; 872 // Read and write as much data as possible. The loop is necessary because 873 // Write() may return synchronously. 874 do { 875 rv = BufferSend(); 876 if (rv != ERR_IO_PENDING && rv != 0) 877 network_moved = true; 878 } while (rv > 0); 879 if (transport_read_error_ == OK && BufferRecv() != ERR_IO_PENDING) 880 network_moved = true; 881 return network_moved; 882 } 883 884 int SSLClientSocketOpenSSL::DoHandshake() { 885 crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE); 886 int net_error = OK; 887 int rv = SSL_do_handshake(ssl_); 888 889 if (client_auth_cert_needed_) { 890 net_error = ERR_SSL_CLIENT_AUTH_CERT_NEEDED; 891 // If the handshake already succeeded (because the server requests but 892 // doesn't require a client cert), we need to invalidate the SSL session 893 // so that we won't try to resume the non-client-authenticated session in 894 // the next handshake. This will cause the server to ask for a client 895 // cert again. 896 if (rv == 1) { 897 // Remove from session cache but don't clear this connection. 898 SSL_SESSION* session = SSL_get_session(ssl_); 899 if (session) { 900 int rv = SSL_CTX_remove_session(SSL_get_SSL_CTX(ssl_), session); 901 LOG_IF(WARNING, !rv) << "Couldn't invalidate SSL session: " << session; 902 } 903 } 904 } else if (rv == 1) { 905 if (trying_cached_session_ && logging::DEBUG_MODE) { 906 DVLOG(2) << "Result of session reuse for " << host_and_port_.ToString() 907 << " is: " << (SSL_session_reused(ssl_) ? "Success" : "Fail"); 908 } 909 910 if (ssl_config_.version_fallback && 911 ssl_config_.version_max < ssl_config_.version_fallback_min) { 912 return ERR_SSL_FALLBACK_BEYOND_MINIMUM_VERSION; 913 } 914 915 // SSL handshake is completed. If NPN wasn't negotiated, see if ALPN was. 916 if (npn_status_ == kNextProtoUnsupported) { 917 const uint8_t* alpn_proto = NULL; 918 unsigned alpn_len = 0; 919 SSL_get0_alpn_selected(ssl_, &alpn_proto, &alpn_len); 920 if (alpn_len > 0) { 921 npn_proto_.assign(reinterpret_cast<const char*>(alpn_proto), alpn_len); 922 npn_status_ = kNextProtoNegotiated; 923 } 924 } 925 926 RecordChannelIDSupport(channel_id_service_, 927 channel_id_xtn_negotiated_, 928 ssl_config_.channel_id_enabled, 929 crypto::ECPrivateKey::IsSupported()); 930 931 uint8_t* ocsp_response; 932 size_t ocsp_response_len; 933 SSL_get0_ocsp_response(ssl_, &ocsp_response, &ocsp_response_len); 934 set_stapled_ocsp_response_received(ocsp_response_len != 0); 935 936 uint8_t* sct_list; 937 size_t sct_list_len; 938 SSL_get0_signed_cert_timestamp_list(ssl_, &sct_list, &sct_list_len); 939 set_signed_cert_timestamps_received(sct_list_len != 0); 940 941 // Verify the certificate. 942 UpdateServerCert(); 943 GotoState(STATE_VERIFY_CERT); 944 } else { 945 int ssl_error = SSL_get_error(ssl_, rv); 946 947 if (ssl_error == SSL_ERROR_WANT_CHANNEL_ID_LOOKUP) { 948 // The server supports channel ID. Stop to look one up before returning to 949 // the handshake. 950 channel_id_xtn_negotiated_ = true; 951 GotoState(STATE_CHANNEL_ID_LOOKUP); 952 return OK; 953 } 954 955 OpenSSLErrorInfo error_info; 956 net_error = MapOpenSSLErrorWithDetails(ssl_error, err_tracer, &error_info); 957 958 // If not done, stay in this state 959 if (net_error == ERR_IO_PENDING) { 960 GotoState(STATE_HANDSHAKE); 961 } else { 962 LOG(ERROR) << "handshake failed; returned " << rv 963 << ", SSL error code " << ssl_error 964 << ", net_error " << net_error; 965 net_log_.AddEvent( 966 NetLog::TYPE_SSL_HANDSHAKE_ERROR, 967 CreateNetLogOpenSSLErrorCallback(net_error, ssl_error, error_info)); 968 } 969 } 970 return net_error; 971 } 972 973 int SSLClientSocketOpenSSL::DoChannelIDLookup() { 974 GotoState(STATE_CHANNEL_ID_LOOKUP_COMPLETE); 975 return channel_id_service_->GetOrCreateChannelID( 976 host_and_port_.host(), 977 &channel_id_private_key_, 978 &channel_id_cert_, 979 base::Bind(&SSLClientSocketOpenSSL::OnHandshakeIOComplete, 980 base::Unretained(this)), 981 &channel_id_request_handle_); 982 } 983 984 int SSLClientSocketOpenSSL::DoChannelIDLookupComplete(int result) { 985 if (result < 0) 986 return result; 987 988 DCHECK_LT(0u, channel_id_private_key_.size()); 989 // Decode key. 990 std::vector<uint8> encrypted_private_key_info; 991 std::vector<uint8> subject_public_key_info; 992 encrypted_private_key_info.assign( 993 channel_id_private_key_.data(), 994 channel_id_private_key_.data() + channel_id_private_key_.size()); 995 subject_public_key_info.assign( 996 channel_id_cert_.data(), 997 channel_id_cert_.data() + channel_id_cert_.size()); 998 scoped_ptr<crypto::ECPrivateKey> ec_private_key( 999 crypto::ECPrivateKey::CreateFromEncryptedPrivateKeyInfo( 1000 ChannelIDService::kEPKIPassword, 1001 encrypted_private_key_info, 1002 subject_public_key_info)); 1003 if (!ec_private_key) { 1004 LOG(ERROR) << "Failed to import Channel ID."; 1005 return ERR_CHANNEL_ID_IMPORT_FAILED; 1006 } 1007 1008 // Hand the key to OpenSSL. Check for error in case OpenSSL rejects the key 1009 // type. 1010 crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE); 1011 int rv = SSL_set1_tls_channel_id(ssl_, ec_private_key->key()); 1012 if (!rv) { 1013 LOG(ERROR) << "Failed to set Channel ID."; 1014 int err = SSL_get_error(ssl_, rv); 1015 return MapOpenSSLError(err, err_tracer); 1016 } 1017 1018 // Return to the handshake. 1019 set_channel_id_sent(true); 1020 GotoState(STATE_HANDSHAKE); 1021 return OK; 1022 } 1023 1024 int SSLClientSocketOpenSSL::DoVerifyCert(int result) { 1025 DCHECK(!server_cert_chain_->empty()); 1026 DCHECK(start_cert_verification_time_.is_null()); 1027 1028 GotoState(STATE_VERIFY_CERT_COMPLETE); 1029 1030 // If the certificate is bad and has been previously accepted, use 1031 // the previous status and bypass the error. 1032 base::StringPiece der_cert; 1033 if (!x509_util::GetDER(server_cert_chain_->Get(0), &der_cert)) { 1034 NOTREACHED(); 1035 return ERR_CERT_INVALID; 1036 } 1037 CertStatus cert_status; 1038 if (ssl_config_.IsAllowedBadCert(der_cert, &cert_status)) { 1039 VLOG(1) << "Received an expected bad cert with status: " << cert_status; 1040 server_cert_verify_result_.Reset(); 1041 server_cert_verify_result_.cert_status = cert_status; 1042 server_cert_verify_result_.verified_cert = server_cert_; 1043 return OK; 1044 } 1045 1046 // When running in a sandbox, it may not be possible to create an 1047 // X509Certificate*, as that may depend on OS functionality blocked 1048 // in the sandbox. 1049 if (!server_cert_.get()) { 1050 server_cert_verify_result_.Reset(); 1051 server_cert_verify_result_.cert_status = CERT_STATUS_INVALID; 1052 return ERR_CERT_INVALID; 1053 } 1054 1055 start_cert_verification_time_ = base::TimeTicks::Now(); 1056 1057 int flags = 0; 1058 if (ssl_config_.rev_checking_enabled) 1059 flags |= CertVerifier::VERIFY_REV_CHECKING_ENABLED; 1060 if (ssl_config_.verify_ev_cert) 1061 flags |= CertVerifier::VERIFY_EV_CERT; 1062 if (ssl_config_.cert_io_enabled) 1063 flags |= CertVerifier::VERIFY_CERT_IO_ENABLED; 1064 if (ssl_config_.rev_checking_required_local_anchors) 1065 flags |= CertVerifier::VERIFY_REV_CHECKING_REQUIRED_LOCAL_ANCHORS; 1066 verifier_.reset(new SingleRequestCertVerifier(cert_verifier_)); 1067 return verifier_->Verify( 1068 server_cert_.get(), 1069 host_and_port_.host(), 1070 flags, 1071 // TODO(davidben): Route the CRLSet through SSLConfig so 1072 // SSLClientSocket doesn't depend on SSLConfigService. 1073 SSLConfigService::GetCRLSet().get(), 1074 &server_cert_verify_result_, 1075 base::Bind(&SSLClientSocketOpenSSL::OnHandshakeIOComplete, 1076 base::Unretained(this)), 1077 net_log_); 1078 } 1079 1080 int SSLClientSocketOpenSSL::DoVerifyCertComplete(int result) { 1081 verifier_.reset(); 1082 1083 if (!start_cert_verification_time_.is_null()) { 1084 base::TimeDelta verify_time = 1085 base::TimeTicks::Now() - start_cert_verification_time_; 1086 if (result == OK) { 1087 UMA_HISTOGRAM_TIMES("Net.SSLCertVerificationTime", verify_time); 1088 } else { 1089 UMA_HISTOGRAM_TIMES("Net.SSLCertVerificationTimeError", verify_time); 1090 } 1091 } 1092 1093 const CertStatus cert_status = server_cert_verify_result_.cert_status; 1094 if (transport_security_state_ && 1095 (result == OK || 1096 (IsCertificateError(result) && IsCertStatusMinorError(cert_status))) && 1097 !transport_security_state_->CheckPublicKeyPins( 1098 host_and_port_.host(), 1099 server_cert_verify_result_.is_issued_by_known_root, 1100 server_cert_verify_result_.public_key_hashes, 1101 &pinning_failure_log_)) { 1102 result = ERR_SSL_PINNED_KEY_NOT_IN_CERT_CHAIN; 1103 } 1104 1105 if (result == OK) { 1106 // Only check Certificate Transparency if there were no other errors with 1107 // the connection. 1108 VerifyCT(); 1109 1110 // TODO(joth): Work out if we need to remember the intermediate CA certs 1111 // when the server sends them to us, and do so here. 1112 SSLContext::GetInstance()->session_cache()->MarkSSLSessionAsGood(ssl_); 1113 marked_session_as_good_ = true; 1114 CheckIfHandshakeFinished(); 1115 } else { 1116 DVLOG(1) << "DoVerifyCertComplete error " << ErrorToString(result) 1117 << " (" << result << ")"; 1118 } 1119 1120 completed_connect_ = true; 1121 1122 // Exit DoHandshakeLoop and return the result to the caller to Connect. 1123 DCHECK_EQ(STATE_NONE, next_handshake_state_); 1124 return result; 1125 } 1126 1127 void SSLClientSocketOpenSSL::DoConnectCallback(int rv) { 1128 if (rv < OK) 1129 OnHandshakeCompletion(); 1130 if (!user_connect_callback_.is_null()) { 1131 CompletionCallback c = user_connect_callback_; 1132 user_connect_callback_.Reset(); 1133 c.Run(rv > OK ? OK : rv); 1134 } 1135 } 1136 1137 void SSLClientSocketOpenSSL::UpdateServerCert() { 1138 server_cert_chain_->Reset(SSL_get_peer_cert_chain(ssl_)); 1139 server_cert_ = server_cert_chain_->AsOSChain(); 1140 1141 if (server_cert_.get()) { 1142 net_log_.AddEvent( 1143 NetLog::TYPE_SSL_CERTIFICATES_RECEIVED, 1144 base::Bind(&NetLogX509CertificateCallback, 1145 base::Unretained(server_cert_.get()))); 1146 } 1147 } 1148 1149 void SSLClientSocketOpenSSL::VerifyCT() { 1150 if (!cert_transparency_verifier_) 1151 return; 1152 1153 uint8_t* ocsp_response_raw; 1154 size_t ocsp_response_len; 1155 SSL_get0_ocsp_response(ssl_, &ocsp_response_raw, &ocsp_response_len); 1156 std::string ocsp_response; 1157 if (ocsp_response_len > 0) { 1158 ocsp_response.assign(reinterpret_cast<const char*>(ocsp_response_raw), 1159 ocsp_response_len); 1160 } 1161 1162 uint8_t* sct_list_raw; 1163 size_t sct_list_len; 1164 SSL_get0_signed_cert_timestamp_list(ssl_, &sct_list_raw, &sct_list_len); 1165 std::string sct_list; 1166 if (sct_list_len > 0) 1167 sct_list.assign(reinterpret_cast<const char*>(sct_list_raw), sct_list_len); 1168 1169 // Note that this is a completely synchronous operation: The CT Log Verifier 1170 // gets all the data it needs for SCT verification and does not do any 1171 // external communication. 1172 int result = cert_transparency_verifier_->Verify( 1173 server_cert_verify_result_.verified_cert.get(), 1174 ocsp_response, sct_list, &ct_verify_result_, net_log_); 1175 1176 VLOG(1) << "CT Verification complete: result " << result 1177 << " Invalid scts: " << ct_verify_result_.invalid_scts.size() 1178 << " Verified scts: " << ct_verify_result_.verified_scts.size() 1179 << " scts from unknown logs: " 1180 << ct_verify_result_.unknown_logs_scts.size(); 1181 } 1182 1183 void SSLClientSocketOpenSSL::OnHandshakeIOComplete(int result) { 1184 int rv = DoHandshakeLoop(result); 1185 if (rv != ERR_IO_PENDING) { 1186 net_log_.EndEventWithNetErrorCode(NetLog::TYPE_SSL_CONNECT, rv); 1187 DoConnectCallback(rv); 1188 } 1189 } 1190 1191 void SSLClientSocketOpenSSL::OnSendComplete(int result) { 1192 if (next_handshake_state_ == STATE_HANDSHAKE) { 1193 // In handshake phase. 1194 OnHandshakeIOComplete(result); 1195 return; 1196 } 1197 1198 // OnSendComplete may need to call DoPayloadRead while the renegotiation 1199 // handshake is in progress. 1200 int rv_read = ERR_IO_PENDING; 1201 int rv_write = ERR_IO_PENDING; 1202 bool network_moved; 1203 do { 1204 if (user_read_buf_.get()) 1205 rv_read = DoPayloadRead(); 1206 if (user_write_buf_.get()) 1207 rv_write = DoPayloadWrite(); 1208 network_moved = DoTransportIO(); 1209 } while (rv_read == ERR_IO_PENDING && rv_write == ERR_IO_PENDING && 1210 (user_read_buf_.get() || user_write_buf_.get()) && network_moved); 1211 1212 // Performing the Read callback may cause |this| to be deleted. If this 1213 // happens, the Write callback should not be invoked. Guard against this by 1214 // holding a WeakPtr to |this| and ensuring it's still valid. 1215 base::WeakPtr<SSLClientSocketOpenSSL> guard(weak_factory_.GetWeakPtr()); 1216 if (user_read_buf_.get() && rv_read != ERR_IO_PENDING) 1217 DoReadCallback(rv_read); 1218 1219 if (!guard.get()) 1220 return; 1221 1222 if (user_write_buf_.get() && rv_write != ERR_IO_PENDING) 1223 DoWriteCallback(rv_write); 1224 } 1225 1226 void SSLClientSocketOpenSSL::OnRecvComplete(int result) { 1227 if (next_handshake_state_ == STATE_HANDSHAKE) { 1228 // In handshake phase. 1229 OnHandshakeIOComplete(result); 1230 return; 1231 } 1232 1233 // Network layer received some data, check if client requested to read 1234 // decrypted data. 1235 if (!user_read_buf_.get()) 1236 return; 1237 1238 int rv = DoReadLoop(); 1239 if (rv != ERR_IO_PENDING) 1240 DoReadCallback(rv); 1241 } 1242 1243 int SSLClientSocketOpenSSL::DoHandshakeLoop(int last_io_result) { 1244 int rv = last_io_result; 1245 do { 1246 // Default to STATE_NONE for next state. 1247 // (This is a quirk carried over from the windows 1248 // implementation. It makes reading the logs a bit harder.) 1249 // State handlers can and often do call GotoState just 1250 // to stay in the current state. 1251 State state = next_handshake_state_; 1252 GotoState(STATE_NONE); 1253 switch (state) { 1254 case STATE_HANDSHAKE: 1255 rv = DoHandshake(); 1256 break; 1257 case STATE_CHANNEL_ID_LOOKUP: 1258 DCHECK_EQ(OK, rv); 1259 rv = DoChannelIDLookup(); 1260 break; 1261 case STATE_CHANNEL_ID_LOOKUP_COMPLETE: 1262 rv = DoChannelIDLookupComplete(rv); 1263 break; 1264 case STATE_VERIFY_CERT: 1265 DCHECK_EQ(OK, rv); 1266 rv = DoVerifyCert(rv); 1267 break; 1268 case STATE_VERIFY_CERT_COMPLETE: 1269 rv = DoVerifyCertComplete(rv); 1270 break; 1271 case STATE_NONE: 1272 default: 1273 rv = ERR_UNEXPECTED; 1274 NOTREACHED() << "unexpected state" << state; 1275 break; 1276 } 1277 1278 bool network_moved = DoTransportIO(); 1279 if (network_moved && next_handshake_state_ == STATE_HANDSHAKE) { 1280 // In general we exit the loop if rv is ERR_IO_PENDING. In this 1281 // special case we keep looping even if rv is ERR_IO_PENDING because 1282 // the transport IO may allow DoHandshake to make progress. 1283 rv = OK; // This causes us to stay in the loop. 1284 } 1285 } while (rv != ERR_IO_PENDING && next_handshake_state_ != STATE_NONE); 1286 1287 return rv; 1288 } 1289 1290 int SSLClientSocketOpenSSL::DoReadLoop() { 1291 bool network_moved; 1292 int rv; 1293 do { 1294 rv = DoPayloadRead(); 1295 network_moved = DoTransportIO(); 1296 } while (rv == ERR_IO_PENDING && network_moved); 1297 1298 return rv; 1299 } 1300 1301 int SSLClientSocketOpenSSL::DoWriteLoop() { 1302 bool network_moved; 1303 int rv; 1304 do { 1305 rv = DoPayloadWrite(); 1306 network_moved = DoTransportIO(); 1307 } while (rv == ERR_IO_PENDING && network_moved); 1308 1309 return rv; 1310 } 1311 1312 int SSLClientSocketOpenSSL::DoPayloadRead() { 1313 crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE); 1314 1315 int rv; 1316 if (pending_read_error_ != kNoPendingReadResult) { 1317 rv = pending_read_error_; 1318 pending_read_error_ = kNoPendingReadResult; 1319 if (rv == 0) { 1320 net_log_.AddByteTransferEvent(NetLog::TYPE_SSL_SOCKET_BYTES_RECEIVED, 1321 rv, user_read_buf_->data()); 1322 } 1323 return rv; 1324 } 1325 1326 int total_bytes_read = 0; 1327 do { 1328 rv = SSL_read(ssl_, user_read_buf_->data() + total_bytes_read, 1329 user_read_buf_len_ - total_bytes_read); 1330 if (rv > 0) 1331 total_bytes_read += rv; 1332 } while (total_bytes_read < user_read_buf_len_ && rv > 0); 1333 1334 if (total_bytes_read == user_read_buf_len_) { 1335 rv = total_bytes_read; 1336 } else { 1337 // Otherwise, an error occurred (rv <= 0). The error needs to be handled 1338 // immediately, while the OpenSSL errors are still available in 1339 // thread-local storage. However, the handled/remapped error code should 1340 // only be returned if no application data was already read; if it was, the 1341 // error code should be deferred until the next call of DoPayloadRead. 1342 // 1343 // If no data was read, |*next_result| will point to the return value of 1344 // this function. If at least some data was read, |*next_result| will point 1345 // to |pending_read_error_|, to be returned in a future call to 1346 // DoPayloadRead() (e.g.: after the current data is handled). 1347 int *next_result = &rv; 1348 if (total_bytes_read > 0) { 1349 pending_read_error_ = rv; 1350 rv = total_bytes_read; 1351 next_result = &pending_read_error_; 1352 } 1353 1354 if (client_auth_cert_needed_) { 1355 *next_result = ERR_SSL_CLIENT_AUTH_CERT_NEEDED; 1356 } else if (*next_result < 0) { 1357 int err = SSL_get_error(ssl_, *next_result); 1358 *next_result = MapOpenSSLError(err, err_tracer); 1359 1360 // Many servers do not reliably send a close_notify alert when shutting 1361 // down a connection, and instead terminate the TCP connection. This is 1362 // reported as ERR_CONNECTION_CLOSED. Because of this, map the unclean 1363 // shutdown to a graceful EOF, instead of treating it as an error as it 1364 // should be. 1365 if (*next_result == ERR_CONNECTION_CLOSED) 1366 *next_result = 0; 1367 1368 if (rv > 0 && *next_result == ERR_IO_PENDING) { 1369 // If at least some data was read from SSL_read(), do not treat 1370 // insufficient data as an error to return in the next call to 1371 // DoPayloadRead() - instead, let the call fall through to check 1372 // SSL_read() again. This is because DoTransportIO() may complete 1373 // in between the next call to DoPayloadRead(), and thus it is 1374 // important to check SSL_read() on subsequent invocations to see 1375 // if a complete record may now be read. 1376 *next_result = kNoPendingReadResult; 1377 } 1378 } 1379 } 1380 1381 if (rv >= 0) { 1382 net_log_.AddByteTransferEvent(NetLog::TYPE_SSL_SOCKET_BYTES_RECEIVED, rv, 1383 user_read_buf_->data()); 1384 } 1385 return rv; 1386 } 1387 1388 int SSLClientSocketOpenSSL::DoPayloadWrite() { 1389 crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE); 1390 int rv = SSL_write(ssl_, user_write_buf_->data(), user_write_buf_len_); 1391 if (rv >= 0) { 1392 net_log_.AddByteTransferEvent(NetLog::TYPE_SSL_SOCKET_BYTES_SENT, rv, 1393 user_write_buf_->data()); 1394 return rv; 1395 } 1396 1397 int err = SSL_get_error(ssl_, rv); 1398 return MapOpenSSLError(err, err_tracer); 1399 } 1400 1401 int SSLClientSocketOpenSSL::BufferSend(void) { 1402 if (transport_send_busy_) 1403 return ERR_IO_PENDING; 1404 1405 if (!send_buffer_.get()) { 1406 // Get a fresh send buffer out of the send BIO. 1407 size_t max_read = BIO_pending(transport_bio_); 1408 if (!max_read) 1409 return 0; // Nothing pending in the OpenSSL write BIO. 1410 send_buffer_ = new DrainableIOBuffer(new IOBuffer(max_read), max_read); 1411 int read_bytes = BIO_read(transport_bio_, send_buffer_->data(), max_read); 1412 DCHECK_GT(read_bytes, 0); 1413 CHECK_EQ(static_cast<int>(max_read), read_bytes); 1414 } 1415 1416 int rv = transport_->socket()->Write( 1417 send_buffer_.get(), 1418 send_buffer_->BytesRemaining(), 1419 base::Bind(&SSLClientSocketOpenSSL::BufferSendComplete, 1420 base::Unretained(this))); 1421 if (rv == ERR_IO_PENDING) { 1422 transport_send_busy_ = true; 1423 } else { 1424 TransportWriteComplete(rv); 1425 } 1426 return rv; 1427 } 1428 1429 int SSLClientSocketOpenSSL::BufferRecv(void) { 1430 if (transport_recv_busy_) 1431 return ERR_IO_PENDING; 1432 1433 // Determine how much was requested from |transport_bio_| that was not 1434 // actually available. 1435 size_t requested = BIO_ctrl_get_read_request(transport_bio_); 1436 if (requested == 0) { 1437 // This is not a perfect match of error codes, as no operation is 1438 // actually pending. However, returning 0 would be interpreted as 1439 // a possible sign of EOF, which is also an inappropriate match. 1440 return ERR_IO_PENDING; 1441 } 1442 1443 // Known Issue: While only reading |requested| data is the more correct 1444 // implementation, it has the downside of resulting in frequent reads: 1445 // One read for the SSL record header (~5 bytes) and one read for the SSL 1446 // record body. Rather than issuing these reads to the underlying socket 1447 // (and constantly allocating new IOBuffers), a single Read() request to 1448 // fill |transport_bio_| is issued. As long as an SSL client socket cannot 1449 // be gracefully shutdown (via SSL close alerts) and re-used for non-SSL 1450 // traffic, this over-subscribed Read()ing will not cause issues. 1451 size_t max_write = BIO_ctrl_get_write_guarantee(transport_bio_); 1452 if (!max_write) 1453 return ERR_IO_PENDING; 1454 1455 recv_buffer_ = new IOBuffer(max_write); 1456 int rv = transport_->socket()->Read( 1457 recv_buffer_.get(), 1458 max_write, 1459 base::Bind(&SSLClientSocketOpenSSL::BufferRecvComplete, 1460 base::Unretained(this))); 1461 if (rv == ERR_IO_PENDING) { 1462 transport_recv_busy_ = true; 1463 } else { 1464 rv = TransportReadComplete(rv); 1465 } 1466 return rv; 1467 } 1468 1469 void SSLClientSocketOpenSSL::BufferSendComplete(int result) { 1470 transport_send_busy_ = false; 1471 TransportWriteComplete(result); 1472 OnSendComplete(result); 1473 } 1474 1475 void SSLClientSocketOpenSSL::BufferRecvComplete(int result) { 1476 result = TransportReadComplete(result); 1477 OnRecvComplete(result); 1478 } 1479 1480 void SSLClientSocketOpenSSL::TransportWriteComplete(int result) { 1481 DCHECK(ERR_IO_PENDING != result); 1482 if (result < 0) { 1483 // Record the error. Save it to be reported in a future read or write on 1484 // transport_bio_'s peer. 1485 transport_write_error_ = result; 1486 send_buffer_ = NULL; 1487 } else { 1488 DCHECK(send_buffer_.get()); 1489 send_buffer_->DidConsume(result); 1490 DCHECK_GE(send_buffer_->BytesRemaining(), 0); 1491 if (send_buffer_->BytesRemaining() <= 0) 1492 send_buffer_ = NULL; 1493 } 1494 } 1495 1496 int SSLClientSocketOpenSSL::TransportReadComplete(int result) { 1497 DCHECK(ERR_IO_PENDING != result); 1498 // If an EOF, canonicalize to ERR_CONNECTION_CLOSED here so MapOpenSSLError 1499 // does not report success. 1500 if (result == 0) 1501 result = ERR_CONNECTION_CLOSED; 1502 if (result < 0) { 1503 DVLOG(1) << "TransportReadComplete result " << result; 1504 // Received an error. Save it to be reported in a future read on 1505 // transport_bio_'s peer. 1506 transport_read_error_ = result; 1507 } else { 1508 DCHECK(recv_buffer_.get()); 1509 int ret = BIO_write(transport_bio_, recv_buffer_->data(), result); 1510 // A write into a memory BIO should always succeed. 1511 DCHECK_EQ(result, ret); 1512 } 1513 recv_buffer_ = NULL; 1514 transport_recv_busy_ = false; 1515 return result; 1516 } 1517 1518 int SSLClientSocketOpenSSL::ClientCertRequestCallback(SSL* ssl) { 1519 DVLOG(3) << "OpenSSL ClientCertRequestCallback called"; 1520 DCHECK(ssl == ssl_); 1521 1522 // Clear any currently configured certificates. 1523 SSL_certs_clear(ssl_); 1524 1525 #if defined(OS_IOS) 1526 // TODO(droger): Support client auth on iOS. See http://crbug.com/145954). 1527 LOG(WARNING) << "Client auth is not supported"; 1528 #else // !defined(OS_IOS) 1529 if (!ssl_config_.send_client_cert) { 1530 // First pass: we know that a client certificate is needed, but we do not 1531 // have one at hand. 1532 client_auth_cert_needed_ = true; 1533 STACK_OF(X509_NAME) *authorities = SSL_get_client_CA_list(ssl); 1534 for (size_t i = 0; i < sk_X509_NAME_num(authorities); i++) { 1535 X509_NAME *ca_name = (X509_NAME *)sk_X509_NAME_value(authorities, i); 1536 unsigned char* str = NULL; 1537 int length = i2d_X509_NAME(ca_name, &str); 1538 cert_authorities_.push_back(std::string( 1539 reinterpret_cast<const char*>(str), 1540 static_cast<size_t>(length))); 1541 OPENSSL_free(str); 1542 } 1543 1544 const unsigned char* client_cert_types; 1545 size_t num_client_cert_types = 1546 SSL_get0_certificate_types(ssl, &client_cert_types); 1547 for (size_t i = 0; i < num_client_cert_types; i++) { 1548 cert_key_types_.push_back( 1549 static_cast<SSLClientCertType>(client_cert_types[i])); 1550 } 1551 1552 return -1; // Suspends handshake. 1553 } 1554 1555 // Second pass: a client certificate should have been selected. 1556 if (ssl_config_.client_cert.get()) { 1557 ScopedX509 leaf_x509 = 1558 OSCertHandleToOpenSSL(ssl_config_.client_cert->os_cert_handle()); 1559 if (!leaf_x509) { 1560 LOG(WARNING) << "Failed to import certificate"; 1561 OpenSSLPutNetError(FROM_HERE, ERR_SSL_CLIENT_AUTH_CERT_BAD_FORMAT); 1562 return -1; 1563 } 1564 1565 ScopedX509Stack chain = OSCertHandlesToOpenSSL( 1566 ssl_config_.client_cert->GetIntermediateCertificates()); 1567 if (!chain) { 1568 LOG(WARNING) << "Failed to import intermediate certificates"; 1569 OpenSSLPutNetError(FROM_HERE, ERR_SSL_CLIENT_AUTH_CERT_BAD_FORMAT); 1570 return -1; 1571 } 1572 1573 // TODO(davidben): With Linux client auth support, this should be 1574 // conditioned on OS_ANDROID and then, with https://crbug.com/394131, 1575 // removed altogether. OpenSSLClientKeyStore is mostly an artifact of the 1576 // net/ client auth API lacking a private key handle. 1577 #if defined(USE_OPENSSL_CERTS) 1578 crypto::ScopedEVP_PKEY privkey = 1579 OpenSSLClientKeyStore::GetInstance()->FetchClientCertPrivateKey( 1580 ssl_config_.client_cert.get()); 1581 #else // !defined(USE_OPENSSL_CERTS) 1582 crypto::ScopedEVP_PKEY privkey = 1583 FetchClientCertPrivateKey(ssl_config_.client_cert.get()); 1584 #endif // defined(USE_OPENSSL_CERTS) 1585 if (!privkey) { 1586 // Could not find the private key. Fail the handshake and surface an 1587 // appropriate error to the caller. 1588 LOG(WARNING) << "Client cert found without private key"; 1589 OpenSSLPutNetError(FROM_HERE, ERR_SSL_CLIENT_AUTH_CERT_NO_PRIVATE_KEY); 1590 return -1; 1591 } 1592 1593 if (!SSL_use_certificate(ssl_, leaf_x509.get()) || 1594 !SSL_use_PrivateKey(ssl_, privkey.get()) || 1595 !SSL_set1_chain(ssl_, chain.get())) { 1596 LOG(WARNING) << "Failed to set client certificate"; 1597 return -1; 1598 } 1599 return 1; 1600 } 1601 #endif // defined(OS_IOS) 1602 1603 // Send no client certificate. 1604 return 1; 1605 } 1606 1607 int SSLClientSocketOpenSSL::CertVerifyCallback(X509_STORE_CTX* store_ctx) { 1608 if (!completed_connect_) { 1609 // If the first handshake hasn't completed then we accept any certificates 1610 // because we verify after the handshake. 1611 return 1; 1612 } 1613 1614 // Disallow the server certificate to change in a renegotiation. 1615 if (server_cert_chain_->empty()) { 1616 LOG(ERROR) << "Received invalid certificate chain between handshakes"; 1617 return 0; 1618 } 1619 base::StringPiece old_der, new_der; 1620 if (store_ctx->cert == NULL || 1621 !x509_util::GetDER(server_cert_chain_->Get(0), &old_der) || 1622 !x509_util::GetDER(store_ctx->cert, &new_der)) { 1623 LOG(ERROR) << "Failed to encode certificates"; 1624 return 0; 1625 } 1626 if (old_der != new_der) { 1627 LOG(ERROR) << "Server certificate changed between handshakes"; 1628 return 0; 1629 } 1630 1631 return 1; 1632 } 1633 1634 // SelectNextProtoCallback is called by OpenSSL during the handshake. If the 1635 // server supports NPN, selects a protocol from the list that the server 1636 // provides. According to third_party/openssl/openssl/ssl/ssl_lib.c, the 1637 // callback can assume that |in| is syntactically valid. 1638 int SSLClientSocketOpenSSL::SelectNextProtoCallback(unsigned char** out, 1639 unsigned char* outlen, 1640 const unsigned char* in, 1641 unsigned int inlen) { 1642 if (ssl_config_.next_protos.empty()) { 1643 *out = reinterpret_cast<uint8*>( 1644 const_cast<char*>(kDefaultSupportedNPNProtocol)); 1645 *outlen = arraysize(kDefaultSupportedNPNProtocol) - 1; 1646 npn_status_ = kNextProtoUnsupported; 1647 return SSL_TLSEXT_ERR_OK; 1648 } 1649 1650 // Assume there's no overlap between our protocols and the server's list. 1651 npn_status_ = kNextProtoNoOverlap; 1652 1653 // For each protocol in server preference order, see if we support it. 1654 for (unsigned int i = 0; i < inlen; i += in[i] + 1) { 1655 for (std::vector<std::string>::const_iterator 1656 j = ssl_config_.next_protos.begin(); 1657 j != ssl_config_.next_protos.end(); ++j) { 1658 if (in[i] == j->size() && 1659 memcmp(&in[i + 1], j->data(), in[i]) == 0) { 1660 // We found a match. 1661 *out = const_cast<unsigned char*>(in) + i + 1; 1662 *outlen = in[i]; 1663 npn_status_ = kNextProtoNegotiated; 1664 break; 1665 } 1666 } 1667 if (npn_status_ == kNextProtoNegotiated) 1668 break; 1669 } 1670 1671 // If we didn't find a protocol, we select the first one from our list. 1672 if (npn_status_ == kNextProtoNoOverlap) { 1673 *out = reinterpret_cast<uint8*>(const_cast<char*>( 1674 ssl_config_.next_protos[0].data())); 1675 *outlen = ssl_config_.next_protos[0].size(); 1676 } 1677 1678 npn_proto_.assign(reinterpret_cast<const char*>(*out), *outlen); 1679 DVLOG(2) << "next protocol: '" << npn_proto_ << "' status: " << npn_status_; 1680 return SSL_TLSEXT_ERR_OK; 1681 } 1682 1683 long SSLClientSocketOpenSSL::MaybeReplayTransportError( 1684 BIO *bio, 1685 int cmd, 1686 const char *argp, int argi, long argl, 1687 long retvalue) { 1688 if (cmd == (BIO_CB_READ|BIO_CB_RETURN) && retvalue <= 0) { 1689 // If there is no more data in the buffer, report any pending errors that 1690 // were observed. Note that both the readbuf and the writebuf are checked 1691 // for errors, since the application may have encountered a socket error 1692 // while writing that would otherwise not be reported until the application 1693 // attempted to write again - which it may never do. See 1694 // https://crbug.com/249848. 1695 if (transport_read_error_ != OK) { 1696 OpenSSLPutNetError(FROM_HERE, transport_read_error_); 1697 return -1; 1698 } 1699 if (transport_write_error_ != OK) { 1700 OpenSSLPutNetError(FROM_HERE, transport_write_error_); 1701 return -1; 1702 } 1703 } else if (cmd == BIO_CB_WRITE) { 1704 // Because of the write buffer, this reports a failure from the previous 1705 // write payload. If the current payload fails to write, the error will be 1706 // reported in a future write or read to |bio|. 1707 if (transport_write_error_ != OK) { 1708 OpenSSLPutNetError(FROM_HERE, transport_write_error_); 1709 return -1; 1710 } 1711 } 1712 return retvalue; 1713 } 1714 1715 // static 1716 long SSLClientSocketOpenSSL::BIOCallback( 1717 BIO *bio, 1718 int cmd, 1719 const char *argp, int argi, long argl, 1720 long retvalue) { 1721 SSLClientSocketOpenSSL* socket = reinterpret_cast<SSLClientSocketOpenSSL*>( 1722 BIO_get_callback_arg(bio)); 1723 CHECK(socket); 1724 return socket->MaybeReplayTransportError( 1725 bio, cmd, argp, argi, argl, retvalue); 1726 } 1727 1728 // static 1729 void SSLClientSocketOpenSSL::InfoCallback(const SSL* ssl, 1730 int type, 1731 int /*val*/) { 1732 if (type == SSL_CB_HANDSHAKE_DONE) { 1733 SSLClientSocketOpenSSL* ssl_socket = 1734 SSLContext::GetInstance()->GetClientSocketFromSSL(ssl); 1735 ssl_socket->handshake_succeeded_ = true; 1736 ssl_socket->CheckIfHandshakeFinished(); 1737 } 1738 } 1739 1740 // Determines if both the handshake and certificate verification have completed 1741 // successfully, and calls the handshake completion callback if that is the 1742 // case. 1743 // 1744 // CheckIfHandshakeFinished is called twice per connection: once after 1745 // MarkSSLSessionAsGood, when the certificate has been verified, and 1746 // once via an OpenSSL callback when the handshake has completed. On the 1747 // second call, when the certificate has been verified and the handshake 1748 // has completed, the connection's handshake completion callback is run. 1749 void SSLClientSocketOpenSSL::CheckIfHandshakeFinished() { 1750 if (handshake_succeeded_ && marked_session_as_good_) 1751 OnHandshakeCompletion(); 1752 } 1753 1754 void SSLClientSocketOpenSSL::AddSCTInfoToSSLInfo(SSLInfo* ssl_info) const { 1755 for (ct::SCTList::const_iterator iter = 1756 ct_verify_result_.verified_scts.begin(); 1757 iter != ct_verify_result_.verified_scts.end(); ++iter) { 1758 ssl_info->signed_certificate_timestamps.push_back( 1759 SignedCertificateTimestampAndStatus(*iter, ct::SCT_STATUS_OK)); 1760 } 1761 for (ct::SCTList::const_iterator iter = 1762 ct_verify_result_.invalid_scts.begin(); 1763 iter != ct_verify_result_.invalid_scts.end(); ++iter) { 1764 ssl_info->signed_certificate_timestamps.push_back( 1765 SignedCertificateTimestampAndStatus(*iter, ct::SCT_STATUS_INVALID)); 1766 } 1767 for (ct::SCTList::const_iterator iter = 1768 ct_verify_result_.unknown_logs_scts.begin(); 1769 iter != ct_verify_result_.unknown_logs_scts.end(); ++iter) { 1770 ssl_info->signed_certificate_timestamps.push_back( 1771 SignedCertificateTimestampAndStatus(*iter, 1772 ct::SCT_STATUS_LOG_UNKNOWN)); 1773 } 1774 } 1775 1776 scoped_refptr<X509Certificate> 1777 SSLClientSocketOpenSSL::GetUnverifiedServerCertificateChain() const { 1778 return server_cert_; 1779 } 1780 1781 } // namespace net 1782
