Reject renegotiations in SSLClientSocket by default.

net/socket/ssl_client_socket_nss.cc

 // Copyright (c) 2012 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 506 matching lines @@
   bool WasEverUsed() const;
 
   // Called on the network task runner.
   // Causes the associated SSL/TLS session ID to be added to NSS's session
   // cache, but only if the connection has not been False Started.
   //
   // This should only be called after the server's certificate has been
   // verified, and may not be called within an NSS callback.
   void CacheSessionIfNecessary();
 
+  // Called on the network task runner.
+  void SetRenegotiationsAllowed(bool allowed);
+
  private:
   friend class base::RefCountedThreadSafe<Core>;
   ~Core();
 
   enum State {
     STATE_NONE,
     STATE_HANDSHAKE,
     STATE_GET_DOMAIN_BOUND_CERT_COMPLETE,
   };
 
@@ skipping 566 matching lines @@
   // sessions should only be cached *after* the peer's Finished message is
   // processed.
   // In the case of False Start, the session will be cached once the
   // HandshakeCallback is called, which signals the receipt and processing of
   // the Finished message, and which will happen during a call to
   // PR_Read/PR_Write.
   if (!false_started_)
     SSL_CacheSession(nss_fd_);
 }
 
+void SSLClientSocketNSS::Core::SetRenegotiationsAllowed(bool allowed) {
+  if (!OnNSSTaskRunner()) {
+    DCHECK(!detached_);
+    nss_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&Core::SetRenegotiationsAllowed, this, allowed));
+    return;
+  }
+
+  // We allow servers to request renegotiation. Since we're a client,
+  // prohibiting this is rather a waste of time. Only servers are in a
+  // position to prevent renegotiation attacks.

[Ryan Sleevi, 2015/05/07 01:41:26]

Word it w/o pronouns :)

Also, this comment doesn't make sense with lines 1128 - 1130. You set
SSL_RENEGOTIATE_NEVER but then you say in the comment prohibiting it is a waste
of time?

[davidben, 2015/05/07 19:12:34]

I just copied it from the other one. I think it's explaining why we do
transition vs requiring renegotiation info? I've just removed it because the
link is dead and I'm not sure exactly what it's saying.

+  // http://extendedsubset.com/?p=8

[Ryan Sleevi, 2015/05/07 01:41:26]

Bad link? Doesn't load here

[davidben, 2015/05/07 19:12:34]

Removed.

+  SECStatus rv = SSL_OptionSet(
+      nss_fd_, SSL_ENABLE_RENEGOTIATION,
+      allowed ? SSL_RENEGOTIATE_TRANSITIONAL : SSL_RENEGOTIATE_NEVER);
+  DCHECK_EQ(SECSuccess, rv);
+}
+
 bool SSLClientSocketNSS::Core::OnNSSTaskRunner() const {
   return nss_task_runner_->RunsTasksOnCurrentThread();
 }
 
 bool SSLClientSocketNSS::Core::OnNetworkTaskRunner() const {
   return network_task_runner_->RunsTasksOnCurrentThread();
 }
 
 // static
 SECStatus SSLClientSocketNSS::Core::OwnAuthCertHandler(
@@ skipping 1330 matching lines @@
                 << " for cipherSuite " << cipher_suite;
   }
 
   ssl_info->handshake_type = core_->state().resumed_handshake ?
       SSLInfo::HANDSHAKE_RESUME : SSLInfo::HANDSHAKE_FULL;
 
   LeaveFunction("");
   return true;
 }
 
+void SSLClientSocketNSS::SetRenegotiationsAllowed(bool allowed) {
+  core_->SetRenegotiationsAllowed(allowed);
+}
+
 void SSLClientSocketNSS::GetSSLCertRequestInfo(
     SSLCertRequestInfo* cert_request_info) {
   EnterFunction("");
   cert_request_info->host_and_port = host_and_port_;
   cert_request_info->cert_authorities = core_->state().cert_authorities;
   LeaveFunction("");
 }
 
 int SSLClientSocketNSS::ExportKeyingMaterial(const base::StringPiece& label,
                                              bool has_context,
@@ skipping 312 matching lines @@
   if (rv != SECSuccess) {
     LogFailedNSSFunction(
         net_log_, "SSL_OptionSet", "SSL_ENABLE_SESSION_TICKETS");
   }
 
   rv = SSL_OptionSet(nss_fd_, SSL_ENABLE_FALSE_START,
                      ssl_config_.false_start_enabled);
   if (rv != SECSuccess)
     LogFailedNSSFunction(net_log_, "SSL_OptionSet", "SSL_ENABLE_FALSE_START");
 
-  // We allow servers to request renegotiation. Since we're a client,
-  // prohibiting this is rather a waste of time. Only servers are in a
-  // position to prevent renegotiation attacks.
-  // http://extendedsubset.com/?p=8
-
-  rv = SSL_OptionSet(nss_fd_, SSL_ENABLE_RENEGOTIATION,
-                     SSL_RENEGOTIATE_TRANSITIONAL);
+  // Forbid renegotiation by default. Callers must opt into requesting
+  // renegotiation.
+  rv = SSL_OptionSet(nss_fd_, SSL_ENABLE_RENEGOTIATION, SSL_RENEGOTIATE_NEVER);
   if (rv != SECSuccess) {
     LogFailedNSSFunction(
         net_log_, "SSL_OptionSet", "SSL_ENABLE_RENEGOTIATION");
   }
 
   rv = SSL_OptionSet(nss_fd_, SSL_CBC_RANDOM_IV, PR_TRUE);
   if (rv != SECSuccess)
     LogFailedNSSFunction(net_log_, "SSL_OptionSet", "SSL_CBC_RANDOM_IV");
 
 // Added in NSS 3.15
@@ skipping 363 matching lines @@
 scoped_refptr<X509Certificate>
 SSLClientSocketNSS::GetUnverifiedServerCertificateChain() const {
   return core_->state().server_cert.get();
 }
 
 ChannelIDService* SSLClientSocketNSS::GetChannelIDService() const {
   return channel_id_service_;
 }
 
 }  // namespace net