Correctly handle SSL Client Authentication requests when connecting...

net/socket/ssl_client_socket_nss.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This file includes code SSLClientSocketNSS::DoVerifyCertComplete() derived
 // from AuthCertificateCallback() in
 // mozilla/security/manager/ssl/src/nsNSSCallbacks.cpp.
 
 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
@@ skipping 378 matching lines @@
   }
 
  private:
   unsigned num_certs_;
   CERTCertificate** certs_;
 };
 
 }  // namespace
 
 SSLClientSocketNSS::SSLClientSocketNSS(ClientSocketHandle* transport_socket,
-                                       const std::string& hostname,
+                                       const HostPortPair& host_and_port,
                                        const SSLConfig& ssl_config,
                                        SSLHostInfo* ssl_host_info,
                                        DnsRRResolver* dnsrr_resolver)
     : ALLOW_THIS_IN_INITIALIZER_LIST(buffer_send_callback_(
           this, &SSLClientSocketNSS::BufferSendComplete)),
       ALLOW_THIS_IN_INITIALIZER_LIST(buffer_recv_callback_(
           this, &SSLClientSocketNSS::BufferRecvComplete)),
       transport_send_busy_(false),
       transport_recv_busy_(false),
       corked_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(handshake_io_callback_(
           this, &SSLClientSocketNSS::OnHandshakeIOComplete)),
       transport_(transport_socket),
-      hostname_(hostname),
+      host_and_port_(host_and_port),
       ssl_config_(ssl_config),
       user_connect_callback_(NULL),
       user_read_callback_(NULL),
       user_write_callback_(NULL),
       user_read_buf_len_(0),
       user_write_buf_len_(0),
       server_cert_nss_(NULL),
       server_cert_verify_result_(NULL),
       ssl_connection_status_(0),
       client_auth_cert_needed_(false),
@@ skipping 48 matching lines @@
 
   SECStatus rv;
   SSLSnapStartResult snap_start_type;
   rv = SSL_GetSnapStartResult(nss_fd_, &snap_start_type);
   if (rv != SECSuccess) {
     NOTREACHED();
     return;
   }
   net_log_.AddEvent(NetLog::TYPE_SSL_SNAP_START,
                     new NetLogIntegerParameter("type", snap_start_type));
-  LOG(ERROR) << "Snap Start: " << snap_start_type << " " << hostname_;
+  LOG(ERROR) << "Snap Start: " << snap_start_type << " "
+             << host_and_port_.ToString();
   if (snap_start_type == SSL_SNAP_START_FULL ||
       snap_start_type == SSL_SNAP_START_RESUME) {
     // If we did a successful Snap Start then our information was correct and
     // there's no point saving it again.
     return;
   }
 
   const unsigned char* hello_data;
   unsigned hello_data_len;
   rv = SSL_GetPredictedServerHelloData(nss_fd_, &hello_data, &hello_data_len);
@@ skipping 18 matching lines @@
   PeerCertificateChain certs(nss_fd_);
   for (unsigned i = 0; i < certs.size(); i++) {
     if (certs[i]->derCert.len > std::numeric_limits<uint16>::max())
       return;
 
     state->certs.push_back(std::string(
           reinterpret_cast<char*>(certs[i]->derCert.data),
           certs[i]->derCert.len));
   }
 
-  LOG(ERROR) << "Setting Snap Start info " << hostname_;
+  LOG(ERROR) << "Setting Snap Start info " << host_and_port_.ToString();
   ssl_host_info_->Persist();
 }
 
 static void DestroyCertificates(CERTCertificate** certs, unsigned len) {
   for (unsigned i = 0; i < len; i++)
     CERT_DestroyCertificate(certs[i]);
 }
 
 // LoadSnapStartInfo parses |info|, which contains data previously serialised
 // by |SaveSnapStartInfo|, and sets the predicted certificates and ServerHello
@@ skipping 202 matching lines @@
   // See http://crbug.com/31628
   rv = SSL_OptionSet(nss_fd_, SSL_ENABLE_DEFLATE, ssl_config_.tls1_enabled);
   if (rv != SECSuccess)
     LogFailedNSSFunction(net_log_, "SSL_OptionSet", "SSL_ENABLE_DEFLATE");
 #endif
 
 #ifdef SSL_ENABLE_FALSE_START
   rv = SSL_OptionSet(
       nss_fd_, SSL_ENABLE_FALSE_START,
       ssl_config_.false_start_enabled &&
-      !SSLConfigService::IsKnownFalseStartIncompatibleServer(hostname_));
+      !SSLConfigService::IsKnownFalseStartIncompatibleServer(
+          host_and_port_.host()));
   if (rv != SECSuccess)
     LogFailedNSSFunction(net_log_, "SSL_OptionSet", "SSL_ENABLE_FALSE_START");
 #endif
 
 #ifdef SSL_ENABLE_SNAP_START
   // TODO(agl): check that SSL_ENABLE_SNAP_START actually does something in the
   // current NSS code.
   rv = SSL_OptionSet(nss_fd_, SSL_ENABLE_SNAP_START,
                      ssl_config_.snap_start_enabled);
   if (rv != SECSuccess)
     VLOG(1) << "SSL_ENABLE_SNAP_START failed.  Old system nss?";
 #endif
 
 #ifdef SSL_ENABLE_RENEGOTIATION
   // Deliberately disable this check for now: http://crbug.com/55410
   if (false &&
-      SSLConfigService::IsKnownStrictTLSServer(hostname_) &&
+      SSLConfigService::IsKnownStrictTLSServer(host_and_port_.host()) &&
       !ssl_config_.mitm_proxies_allowed) {
     rv = SSL_OptionSet(nss_fd_, SSL_REQUIRE_SAFE_NEGOTIATION, PR_TRUE);
     if (rv != SECSuccess) {
       LogFailedNSSFunction(
           net_log_, "SSL_OptionSet", "SSL_REQUIRE_SAFE_NEGOTIATION");
     }
     rv = SSL_OptionSet(nss_fd_, SSL_ENABLE_RENEGOTIATION,
                        SSL_RENEGOTIATE_REQUIRES_XTN);
   } else {
     // We allow servers to request renegotiation. Since we're a client,
@@ skipping 44 matching lines @@
     return ERR_UNEXPECTED;
   }
 
   rv = SSL_HandshakeCallback(nss_fd_, HandshakeCallback, this);
   if (rv != SECSuccess) {
     LogFailedNSSFunction(net_log_, "SSL_HandshakeCallback", "");
     return ERR_UNEXPECTED;
   }
 
   // Tell SSL the hostname we're trying to connect to.
-  SSL_SetURL(nss_fd_, hostname_.c_str());
+  SSL_SetURL(nss_fd_, host_and_port_.host().c_str());
 
   // Tell SSL we're a client; needed if not letting NSPR do socket I/O
   SSL_ResetHandshake(nss_fd_, 0);
 
   return OK;
 }
 
 int SSLClientSocketNSS::InitializeSSLPeerName() {
   // Tell NSS who we're connected to
   AddressList peer_address;
@@ skipping 14 matching lines @@
   // structure has a one-byte length and one-byte address family
   // field at the beginning.  PRNetAddr has a two-byte address
   // family field at the beginning.
   peername.raw.family = ai->ai_addr->sa_family;
 
   memio_SetPeerName(nss_fd_, &peername);
 
   // Set the peer ID for session reuse.  This is necessary when we create an
   // SSL tunnel through a proxy -- GetPeerName returns the proxy's address
   // rather than the destination server's address in that case.
-  // TODO(wtc): port in |peer_address| is not the server's port when a proxy is
-  // used.
-  std::string peer_id = base::StringPrintf("%s:%d", hostname_.c_str(),
-                                           peer_address.GetPort());
+  std::string peer_id = host_and_port_.ToString();
   SECStatus rv = SSL_SetSockPeerID(nss_fd_, const_cast<char*>(peer_id.c_str()));
   if (rv != SECSuccess)
     LogFailedNSSFunction(net_log_, "SSL_SetSockPeerID", peer_id.c_str());
 
   peername_initialized_ = true;
   return OK;
 }
 
 void SSLClientSocketNSS::Disconnect() {
   EnterFunction("");
@@ skipping 258 matching lines @@
   // SSL_MAX_EXTENSIONS for the presence of SSL_HandshakeNegotiatedExtension.
 #if defined(SSL_MAX_EXTENSIONS)
   PRBool peer_supports_renego_ext;
   ok = SSL_HandshakeNegotiatedExtension(nss_fd_, ssl_renegotiation_info_xtn,
                                         &peer_supports_renego_ext);
   if (ok == SECSuccess) {
     if (!peer_supports_renego_ext) {
       ssl_connection_status_ |= SSL_CONNECTION_NO_RENEGOTIATION_EXTENSION;
       // Log an informational message if the server does not support secure
       // renegotiation (RFC 5746).
-      VLOG(1) << "The server " << hostname_
+      VLOG(1) << "The server " << host_and_port_.ToString()
               << " does not support the TLS renegotiation_info extension.";
     }
     UMA_HISTOGRAM_ENUMERATION("Net.RenegotiationExtensionSupported",
                               peer_supports_renego_ext, 2);
   }
 #endif
 
   if (ssl_config_.ssl3_fallback)
     ssl_connection_status_ |= SSL_CONNECTION_SSL3_FALLBACK;
 }
@@ skipping 23 matching lines @@
     ssl_info->security_bits = -1;
     LOG(DFATAL) << "SSL_GetCipherSuiteInfo returned " << PR_GetError()
                 << " for cipherSuite " << cipher_suite;
   }
   LeaveFunction("");
 }
 
 void SSLClientSocketNSS::GetSSLCertRequestInfo(
     SSLCertRequestInfo* cert_request_info) {
   EnterFunction("");
-  cert_request_info->host_and_port = hostname_;  // TODO(wtc): no port!
+  // TODO(rch): switch SSLCertRequestInfo.host_and_port to a HostPortPair
+  cert_request_info->host_and_port = host_and_port_.ToString();
   cert_request_info->client_certs = client_certs_;
   LeaveFunction(cert_request_info->client_certs.size());
 }
 
 SSLClientSocket::NextProtoStatus
 SSLClientSocketNSS::GetNextProto(std::string* proto) {
 #if defined(SSL_NEXT_PROTO_NEGOTIATED)
   if (!handshake_callback_called_) {
     DCHECK(pseudo_connected_);
     predicted_npn_proto_used_ = true;
@@ skipping 738 matching lines @@
   for (int i = 0; i < n; i++) {
     // Parse each name into a CertPrincipal object.
     CertPrincipal p;
     if (p.ParseDistinguishedName(ca_names->names[i].data,
                                  ca_names->names[i].len)) {
       valid_issuers.push_back(p);
     }
   }
 
   // Now get the available client certs whose issuers are allowed by the server.
-  X509Certificate::GetSSLClientCertificates(that->hostname_,
+  X509Certificate::GetSSLClientCertificates(that->host_and_port_.host(),
                                             valid_issuers,
                                             &that->client_certs_);
 
   // Tell NSS to suspend the client authentication.  We will then abort the
   // handshake by returning ERR_SSL_CLIENT_AUTH_CERT_NEEDED.
   return SECWouldBlock;
 #else
   return SECFailure;
 #endif
 }
@@ skipping 194 matching lines @@
           }
         }
 
         SaveSnapStartInfo();
         // SSL handshake is completed. It's possible that we mispredicted the
         // NPN agreed protocol. In this case, we've just sent a request in the
         // wrong protocol! The higher levels of this network stack aren't
         // prepared for switching the protocol like that so we make up an error
         // and rely on the fact that the request will be retried.
         if (IsNPNProtocolMispredicted()) {
-          LOG(WARNING) << "Mispredicted NPN protocol for " << hostname_;
+          LOG(WARNING) << "Mispredicted NPN protocol for "
+                       << host_and_port_.ToString();
           net_error = ERR_SSL_SNAP_START_NPN_MISPREDICTION;
         } else {
           // Let's verify the certificate.
           GotoState(STATE_VERIFY_DNSSEC);
         }
       }
       // Done!
     } else {
       // Workaround for https://bugzilla.mozilla.org/show_bug.cgi?id=562434 -
       // SSL_ForceHandshake returned SECSuccess prematurely.
@@ skipping 168 matching lines @@
   if (verifier.rrtype() != kDNS_TXT)
     return DNSVR_CONTINUE;
 
   DNSValidationResult r = VerifyTXTRecords(
       true /* DNSSEC verified */, server_cert_nss, verifier.rrdatas());
   SECITEM_FreeItem(&dnssec_embedded_chain, PR_FALSE);
   return r;
 }
 
 int SSLClientSocketNSS::DoVerifyDNSSEC(int result) {
-#if !defined(USE_OPENSSL)
-  if (ssl_config_.dns_cert_provenance_checking_enabled && dnsrr_resolver_) {
-    PeerCertificateChain certs(nss_fd_);
-    DoAsyncDNSCertProvenanceVerification(
-        hostname_, dnsrr_resolver_, certs.AsStringPieceVector());
-  }
-#endif
-
   if (ssl_config_.dnssec_enabled) {
-    DNSValidationResult r = CheckDNSSECChain(hostname_, server_cert_nss_);
+    DNSValidationResult r = CheckDNSSECChain(host_and_port_.host(),
+                                             server_cert_nss_);
     if (r == DNSVR_SUCCESS) {
       local_server_cert_verify_result_.cert_status |= CERT_STATUS_IS_DNSSEC;
       server_cert_verify_result_ = &local_server_cert_verify_result_;
       GotoState(STATE_VERIFY_CERT_COMPLETE);
       return OK;
     }
   }
 
   if (dnssec_provider_ == NULL) {
     GotoState(STATE_VERIFY_CERT);
@@ skipping 75 matching lines @@
     UMA_HISTOGRAM_ENUMERATION("Net.SSLVerificationMerged", 0 /* false */, 2);
   }
 
   int flags = 0;
   if (ssl_config_.rev_checking_enabled)
     flags |= X509Certificate::VERIFY_REV_CHECKING_ENABLED;
   if (ssl_config_.verify_ev_cert)
     flags |= X509Certificate::VERIFY_EV_CERT;
   verifier_.reset(new CertVerifier);
   server_cert_verify_result_ = &local_server_cert_verify_result_;
-  return verifier_->Verify(server_cert_, hostname_, flags,
+  return verifier_->Verify(server_cert_, host_and_port_.host(), flags,
                            &local_server_cert_verify_result_,
                            &handshake_io_callback_);
 }
 
 // Derived from AuthCertificateCallback() in
 // mozilla/source/security/manager/ssl/src/nsNSSCallbacks.cpp.
 int SSLClientSocketNSS::DoVerifyCertComplete(int result) {
   verifier_.reset();
 
   // We used to remember the intermediate CA certs in the NSS database
@@ skipping 139 matching lines @@
     case SSL_CONNECTION_VERSION_TLS1_1:
       UpdateConnectionTypeHistograms(CONNECTION_SSL_TLS1_1);
       break;
     case SSL_CONNECTION_VERSION_TLS1_2:
       UpdateConnectionTypeHistograms(CONNECTION_SSL_TLS1_2);
       break;
   };
 }
 
 }  // namespace net