Change the bad-certificate handler for SSL (using NSS) to return an...

net/base/ssl_client_socket_nss.cc

 // Copyright (c) 2006-2008 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.
 
 #include "net/base/ssl_client_socket_nss.h"
 
 #include <nspr.h>
 #include <nss.h>
 #include <secerr.h>
 // Work around https://bugzilla.mozilla.org/show_bug.cgi?id=455424
 // until NSS 3.12.2 comes out and we update to it.
 #define Lock FOO_NSS_Lock
 #include <ssl.h>
 #include <sslerr.h>
 #include <pk11pub.h>
 #undef Lock
 
+#include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/nss_init.h"
 #include "base/string_util.h"
 #include "net/base/net_errors.h"
 #include "net/base/ssl_info.h"
 
 static const int kRecvBufferSize = 4096;
 
 namespace net {
 
@@ skipping 94 matching lines @@
 
 int SSLClientSocketNSS::Init() {
   EnterFunction("");
   // Call NSS_NoDB_Init() in a threadsafe way.
   base::EnsureNSSInit();
 
   LeaveFunction("");
   return OK;
 }
 
+// As part of Connect(), the SSLClientSocketNSS object performs an SSL
+// handshake. This requires network IO, which in turn calls
+// BufferRecvComplete() with a non-zero byte count. This byte count eventually
+// winds its way through the state machine and ends up being passed to the
+// callback. For Read() and Write(), that's what we want. But for Connect(),
+// the caller expects OK (i.e. 0) for success.
+//
+// The ConnectCallbackWrapper object changes the argument that gets passed
+// to the callback function. Any positive value gets turned into OK.
+class ConnectCallbackWrapper :
+      public CompletionCallbackImpl<ConnectCallbackWrapper> {
+ public:
+  ConnectCallbackWrapper(CompletionCallback* user_callback)
+      : ALLOW_THIS_IN_INITIALIZER_LIST(
+          CompletionCallbackImpl<ConnectCallbackWrapper>(this,
+                                 &ConnectCallbackWrapper::ReturnValueWrapper)),
+        user_callback_(user_callback) {
+  }
+
+ private:
+  void ReturnValueWrapper(int rv) {
+    user_callback_->Run(rv > OK ? OK : rv);
+    delete this;
+  }
+
+  CompletionCallback* user_callback_;
+};
+
 int SSLClientSocketNSS::Connect(CompletionCallback* callback) {
   EnterFunction("");
   DCHECK(transport_.get());
   DCHECK(next_state_ == STATE_NONE);
   DCHECK(!user_callback_);
 
   GotoState(STATE_CONNECT);
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
-    user_callback_ = callback;
+    user_callback_ = new ConnectCallbackWrapper(callback);
 
   LeaveFunction("");
-  return rv;
+  return rv > OK ? OK : rv;
 }
 
-int SSLClientSocketNSS::ReconnectIgnoringLastError(
-        CompletionCallback* callback) {
-  EnterFunction("");
-  // TODO(darin): implement me!
-  LeaveFunction("");
-  return ERR_FAILED;
+void SSLClientSocketNSS::InvalidateSessionIfBadCertificate() {
+  if (UpdateServerCert() != NULL &&
+      ssl_config_.allowed_bad_certs_.count(server_cert_)) {
+    SSL_InvalidateSession(nss_fd_);
+  }
 }
 
 void SSLClientSocketNSS::Disconnect() {
   EnterFunction("");
+
+  // Reset object state
+  transport_send_busy_ = false;
+  transport_recv_busy_ = false;
+  user_buf_            = NULL;
+  user_buf_len_        = 0;
+  server_cert_error_   = OK;
+  completed_handshake_ = false;
+  nss_bufs_            = NULL;
+
   // TODO(wtc): Send SSL close_notify alert.
   if (nss_fd_ != NULL) {
+    InvalidateSessionIfBadCertificate();
     PR_Close(nss_fd_);
     nss_fd_ = NULL;
   }
-  completed_handshake_ = false;
+
   transport_->Disconnect();
   LeaveFunction("");
 }
 
 bool SSLClientSocketNSS::IsConnected() const {
   // Ideally, we should also check if we have received the close_notify alert
   // message from the server, and return false in that case.  We're not doing
   // that, so this function may return a false positive.  Since the upper
   // layer (HttpNetworkTransaction) needs to handle a persistent connection
   // closed by the server when we send a request anyway, a false positive in
@@ skipping 49 matching lines @@
   user_buf_len_ = buf_len;
 
   GotoState(STATE_PAYLOAD_WRITE);
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
     user_callback_ = callback;
   LeaveFunction(rv);
   return rv;
 }
 
+X509Certificate *SSLClientSocketNSS::UpdateServerCert() {
+  // We set the server_cert_ from OwnAuthCertHandler(), but this handler
+  // does not necessarily get called if we are continuing a cached SSL
+  // session.
+  if (server_cert_ == NULL) {
+    X509Certificate::OSCertHandle nss_cert = SSL_PeerCertificate(nss_fd_);
+    if (nss_cert) {
+      server_cert_ = X509Certificate::CreateFromHandle(
+          nss_cert, X509Certificate::SOURCE_FROM_NETWORK);
+    }
+  }
+  return server_cert_;
+}
+
 void SSLClientSocketNSS::GetSSLInfo(SSLInfo* ssl_info) {
   EnterFunction("");
   ssl_info->Reset();
   SSLChannelInfo channel_info;
   SECStatus ok = SSL_GetChannelInfo(nss_fd_,
                                     &channel_info, sizeof(channel_info));
   if (ok == SECSuccess &&
       channel_info.length == sizeof(channel_info) &&
       channel_info.cipherSuite) {
     SSLCipherSuiteInfo cipher_info;
     ok = SSL_GetCipherSuiteInfo(channel_info.cipherSuite,
                                 &cipher_info, sizeof(cipher_info));
     if (ok == SECSuccess) {
       ssl_info->security_bits = cipher_info.effectiveKeyBits;
     } else {
       ssl_info->security_bits = -1;
       LOG(DFATAL) << "SSL_GetCipherSuiteInfo returned " << PR_GetError()
                   << " for cipherSuite " << channel_info.cipherSuite;
     }
+    UpdateServerCert();
   }
   if (server_cert_error_ != net::OK)
     ssl_info->SetCertError(server_cert_error_);
-  X509Certificate::OSCertHandle nss_cert = SSL_PeerCertificate(nss_fd_);
-  if (nss_cert)
-    ssl_info->cert = X509Certificate::CreateFromHandle(nss_cert,
-                         X509Certificate::SOURCE_FROM_NETWORK);
+  DCHECK(server_cert_ != NULL);
+  ssl_info->cert = server_cert_;
   LeaveFunction("");
 }
 
 void SSLClientSocketNSS::DoCallback(int rv) {
   EnterFunction(rv);
   DCHECK(rv != ERR_IO_PENDING);
   DCHECK(user_callback_);
 
   // since Run may result in Read being called, clear user_callback_ up front.
   CompletionCallback* c = user_callback_;
@@ skipping 80 matching lines @@
 }
 
 void SSLClientSocketNSS::BufferRecvComplete(int result) {
   EnterFunction(result);
   memio_PutReadResult(nss_bufs_, result);
   transport_recv_busy_ = false;
   OnIOComplete(result);
   LeaveFunction("");
 }
 
-
 int SSLClientSocketNSS::DoLoop(int last_io_result) {
   EnterFunction(last_io_result);
   bool network_moved;
   int rv = last_io_result;
   do {
     network_moved = false;
     // Default to STATE_NONE for next state.
     // (This is a quirk carried over from the windows
     // implementation.  It makes reading the logs a bit harder.)
     // State handlers can and often do call GotoState just
@@ skipping 33 matching lines @@
     }
   } while ((rv != ERR_IO_PENDING || network_moved) &&
             next_state_ != STATE_NONE);
   LeaveFunction("");
   return rv;
 }
 
 int SSLClientSocketNSS::DoConnect() {
   EnterFunction("");
   GotoState(STATE_CONNECT_COMPLETE);
-  return transport_->Connect(&io_callback_);
+
+  // The caller has to make sure that the transport socket is connected. If
+  // it isn't, we will eventually fail when trying to negotiate an SSL session.
+  // But we cannot call transport_->Connect(), as we do not know if there is
+  // any proxy negotiation that needs to be performed prior to establishing
+  // the SSL session.
+  return OK;
+}
+
+// static
+// NSS calls this if an incoming certificate needs to be verified.
+SECStatus SSLClientSocketNSS::OwnAuthCertHandler(void* arg,
+                                                 PRFileDesc* socket,
+                                                 PRBool checksig,
+                                                 PRBool is_server) {
+  SSLClientSocketNSS* that = reinterpret_cast<SSLClientSocketNSS*>(arg);
+
+  // Remember the certificate as it will no longer be accessible if the
+  // handshake fails.
+  that->UpdateServerCert();
+
+  return SSL_AuthCertificate(CERT_GetDefaultCertDB(), socket, checksig,
+                             is_server);
 }
 
 // static
 // NSS calls this if an incoming certificate is invalid.
-SECStatus SSLClientSocketNSS::OwnBadCertHandler(void* arg, PRFileDesc* socket) {
+SECStatus SSLClientSocketNSS::OwnBadCertHandler(void* arg,
+                                                PRFileDesc* socket) {
   SSLClientSocketNSS* that = reinterpret_cast<SSLClientSocketNSS*>(arg);
+
+  if (that->server_cert_ &&
+      that->ssl_config_.allowed_bad_certs_.count(that->server_cert_)) {
+    LOG(INFO) << "accepting bad SSL certificate, as user told us to";
+
+    return SECSuccess;
+  }
   PRErrorCode prerr = PR_GetError();
   that->server_cert_error_ = NetErrorFromNSPRError(prerr);
   LOG(INFO) << "server certificate is invalid; NSS error code " << prerr
             << ", net error " << that->server_cert_error_;
-  // Return SECSuccess to override the problem.
-  // Chromium wants it to succeed here, and may abort the connection later.
-  return SECSuccess;
+
+  return SECFailure;
 }
 
 int SSLClientSocketNSS::DoConnectComplete(int result) {
   EnterFunction(result);
   if (result < 0)
     return result;
 
   if (Init() != OK) {
     NOTREACHED() << "Couldn't initialize nss";
   }
@@ skipping 60 matching lines @@
   if (rv != SECSuccess)
      LOG(INFO) << "SSL_ENABLE_SESSION_TICKETS failed.  Old system nss?";
 #else
   #error "You need to install NSS-3.12 or later to build chromium"
 #endif
 
   rv = SSL_OptionSet(nss_fd_, SSL_HANDSHAKE_AS_CLIENT, PR_TRUE);
   if (rv != SECSuccess)
      return ERR_UNEXPECTED;
 
+  rv = SSL_AuthCertificateHook(nss_fd_, OwnAuthCertHandler, this);
+  if (rv != SECSuccess)
+     return ERR_UNEXPECTED;
+
   rv = SSL_BadCertHook(nss_fd_, OwnBadCertHandler, this);
   if (rv != SECSuccess)
      return ERR_UNEXPECTED;
 
   // Tell SSL the hostname we're trying to connect to.
   SSL_SetURL(nss_fd_, hostname_.c_str());
 
   // Tell SSL we're a client; needed if not letting NSPR do socket I/O
   SSL_ResetHandshake(nss_fd_, 0);
   GotoState(STATE_HANDSHAKE_READ);
   // Return OK so DoLoop tries handshaking
   LeaveFunction("");
   return OK;
 }
 
 int SSLClientSocketNSS::DoHandshakeRead() {
   EnterFunction("");
-  int net_error;
+  int net_error = net::OK;
   int rv = SSL_ForceHandshake(nss_fd_);
 
   if (rv == SECSuccess) {
-    net_error = server_cert_error_;
+    DCHECK(server_cert_error_ == net::OK);
+
+    InvalidateSessionIfBadCertificate();
+
     // there's a callback for this, too
     completed_handshake_ = true;
     // Done!
   } else {
     PRErrorCode prerr = PR_GetError();
     net_error = NetErrorFromNSPRError(prerr);
 
     // If not done, stay in this state
     if (net_error == ERR_IO_PENDING) {
       GotoState(STATE_HANDSHAKE_READ);
@@ skipping 41 matching lines @@
   if (prerr == PR_WOULD_BLOCK_ERROR) {
     GotoState(STATE_PAYLOAD_WRITE);
     return ERR_IO_PENDING;
   }
   user_buf_ = NULL;
   LeaveFunction("");
   return NetErrorFromNSPRError(prerr);
 }
 
 }  // namespace net