net/socket/ssl_server_socket_nss.cc

   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 #include "net/socket/ssl_server_socket_nss.h"
   6
   7 #if defined(OS_WIN)
   8 #include <winsock2.h>
   9 #endif
  10
  11 #if defined(USE_SYSTEM_SSL)
  12 #include <dlfcn.h>
  13 #endif
  14 #if defined(OS_MACOSX)
  15 #include <Security/Security.h>
  16 #endif
  17 #include <certdb.h>
  18 #include <cryptohi.h>
  19 #include <hasht.h>
  20 #include <keyhi.h>
  21 #include <nspr.h>
  22 #include <nss.h>
  23 #include <pk11pub.h>
  24 #include <secerr.h>
  25 #include <sechash.h>
  26 #include <ssl.h>
  27 #include <sslerr.h>
  28 #include <sslproto.h>
  29
  30 #include <limits>
  31
  32 #include "base/callback_helpers.h"
  33 #include "base/lazy_instance.h"
  34 #include "base/memory/ref_counted.h"
  35 #include "crypto/rsa_private_key.h"
  36 #include "crypto/nss_util_internal.h"
  37 #include "net/base/io_buffer.h"
  38 #include "net/base/net_errors.h"
  39 #include "net/base/net_log.h"
  40 #include "net/socket/nss_ssl_util.h"
  41 #include "net/socket/ssl_error_params.h"
  42
  43 // SSL plaintext fragments are shorter than 16KB. Although the record layer
  44 // overhead is allowed to be 2K + 5 bytes, in practice the overhead is much
  45 // smaller than 1KB. So a 17KB buffer should be large enough to hold an
  46 // entire SSL record.
  47 static const int kRecvBufferSize = 17 * 1024;
  48 static const int kSendBufferSize = 17 * 1024;
  49
  50 #define GotoState(s) next_handshake_state_ = s
  51
  52 namespace net {
  53
  54 namespace {
  55
  56 bool g_nss_server_sockets_init = false;
  57
  58 class NSSSSLServerInitSingleton {
  59  public:
  60   NSSSSLServerInitSingleton() {
  61     EnsureNSSSSLInit();
  62
  63     SSL_ConfigServerSessionIDCache(1024, 5, 5, NULL);
  64     g_nss_server_sockets_init = true;
  65   }
  66
  67   ~NSSSSLServerInitSingleton() {
  68     SSL_ShutdownServerSessionIDCache();
  69     g_nss_server_sockets_init = false;
  70   }
  71 };
  72
  73 static base::LazyInstance<NSSSSLServerInitSingleton>
  74     g_nss_ssl_server_init_singleton = LAZY_INSTANCE_INITIALIZER;
  75
  76 }  // namespace
  77
  78 void EnableSSLServerSockets() {
  79   g_nss_ssl_server_init_singleton.Get();
  80 }
  81
  82 scoped_ptr<SSLServerSocket> CreateSSLServerSocket(
  83     scoped_ptr<StreamSocket> socket,
  84     X509Certificate* cert,
  85     crypto::RSAPrivateKey* key,
  86     const SSLConfig& ssl_config) {
  87   DCHECK(g_nss_server_sockets_init) << "EnableSSLServerSockets() has not been"
  88                                     << "called yet!";
  89
  90   return scoped_ptr<SSLServerSocket>(
  91       new SSLServerSocketNSS(socket.Pass(), cert, key, ssl_config));
  92 }
  93
  94 SSLServerSocketNSS::SSLServerSocketNSS(
  95     scoped_ptr<StreamSocket> transport_socket,
  96     scoped_refptr<X509Certificate> cert,
  97     crypto::RSAPrivateKey* key,
  98     const SSLConfig& ssl_config)
  99     : transport_send_busy_(false),
 100       transport_recv_busy_(false),
 101       user_read_buf_len_(0),
 102       user_write_buf_len_(0),
 103       nss_fd_(NULL),
 104       nss_bufs_(NULL),
 105       transport_socket_(transport_socket.Pass()),
 106       ssl_config_(ssl_config),
 107       cert_(cert),
 108       next_handshake_state_(STATE_NONE),
 109       completed_handshake_(false) {
 110   // TODO(hclam): Need a better way to clone a key.
 111   std::vector<uint8> key_bytes;
 112   CHECK(key->ExportPrivateKey(&key_bytes));
 113   key_.reset(crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(key_bytes));
 114   CHECK(key_.get());
 115 }
 116
 117 SSLServerSocketNSS::~SSLServerSocketNSS() {
 118   if (nss_fd_ != NULL) {
 119     PR_Close(nss_fd_);
 120     nss_fd_ = NULL;
 121   }
 122 }
 123
 124 int SSLServerSocketNSS::Handshake(const CompletionCallback& callback) {
 125   net_log_.BeginEvent(NetLog::TYPE_SSL_SERVER_HANDSHAKE);
 126
 127   int rv = Init();
 128   if (rv != OK) {
 129     LOG(ERROR) << "Failed to initialize NSS";
 130     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_SSL_SERVER_HANDSHAKE, rv);
 131     return rv;
 132   }
 133
 134   rv = InitializeSSLOptions();
 135   if (rv != OK) {
 136     LOG(ERROR) << "Failed to initialize SSL options";
 137     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_SSL_SERVER_HANDSHAKE, rv);
 138     return rv;
 139   }
 140
 141   // Set peer address. TODO(hclam): This should be in a separate method.
 142   PRNetAddr peername;
 143   memset(&peername, 0, sizeof(peername));
 144   peername.raw.family = AF_INET;
 145   memio_SetPeerName(nss_fd_, &peername);
 146
 147   GotoState(STATE_HANDSHAKE);
 148   rv = DoHandshakeLoop(OK);
 149   if (rv == ERR_IO_PENDING) {
 150     user_handshake_callback_ = callback;
 151   } else {
 152     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_SSL_SERVER_HANDSHAKE, rv);
 153   }
 154
 155   return rv > OK ? OK : rv;
 156 }
 157
 158 int SSLServerSocketNSS::ExportKeyingMaterial(const base::StringPiece& label,
 159                                              bool has_context,
 160                                              const base::StringPiece& context,
 161                                              unsigned char* out,
 162                                              unsigned int outlen) {
 163   if (!IsConnected())
 164     return ERR_SOCKET_NOT_CONNECTED;
 165   SECStatus result = SSL_ExportKeyingMaterial(
 166       nss_fd_, label.data(), label.size(), has_context,
 167       reinterpret_cast<const unsigned char*>(context.data()),
 168       context.length(), out, outlen);
 169   if (result != SECSuccess) {
 170     LogFailedNSSFunction(net_log_, "SSL_ExportKeyingMaterial", "");
 171     return MapNSSError(PORT_GetError());
 172   }
 173   return OK;
 174 }
 175
 176 int SSLServerSocketNSS::GetTLSUniqueChannelBinding(std::string* out) {
 177   if (!IsConnected())
 178     return ERR_SOCKET_NOT_CONNECTED;
 179   unsigned char buf[64];
 180   unsigned int len;
 181   SECStatus result = SSL_GetChannelBinding(nss_fd_,
 182                                            SSL_CHANNEL_BINDING_TLS_UNIQUE,
 183                                            buf, &len, arraysize(buf));
 184   if (result != SECSuccess) {
 185     LogFailedNSSFunction(net_log_, "SSL_GetChannelBinding", "");
 186     return MapNSSError(PORT_GetError());
 187   }
 188   out->assign(reinterpret_cast<char*>(buf), len);
 189   return OK;
 190 }
 191
 192 int SSLServerSocketNSS::Connect(const CompletionCallback& callback) {
 193   NOTIMPLEMENTED();
 194   return ERR_NOT_IMPLEMENTED;
 195 }
 196
 197 int SSLServerSocketNSS::Read(IOBuffer* buf, int buf_len,
 198                              const CompletionCallback& callback) {
 199   DCHECK(user_read_callback_.is_null());
 200   DCHECK(user_handshake_callback_.is_null());
 201   DCHECK(!user_read_buf_.get());
 202   DCHECK(nss_bufs_);
 203   DCHECK(!callback.is_null());
 204
 205   user_read_buf_ = buf;
 206   user_read_buf_len_ = buf_len;
 207
 208   DCHECK(completed_handshake_);
 209
 210   int rv = DoReadLoop(OK);
 211
 212   if (rv == ERR_IO_PENDING) {
 213     user_read_callback_ = callback;
 214   } else {
 215     user_read_buf_ = NULL;
 216     user_read_buf_len_ = 0;
 217   }
 218   return rv;
 219 }
 220
 221 int SSLServerSocketNSS::Write(IOBuffer* buf, int buf_len,
 222                               const CompletionCallback& callback) {
 223   DCHECK(user_write_callback_.is_null());
 224   DCHECK(!user_write_buf_.get());
 225   DCHECK(nss_bufs_);
 226   DCHECK(!callback.is_null());
 227
 228   user_write_buf_ = buf;
 229   user_write_buf_len_ = buf_len;
 230
 231   int rv = DoWriteLoop(OK);
 232
 233   if (rv == ERR_IO_PENDING) {
 234     user_write_callback_ = callback;
 235   } else {
 236     user_write_buf_ = NULL;
 237     user_write_buf_len_ = 0;
 238   }
 239   return rv;
 240 }
 241
 242 int SSLServerSocketNSS::SetReceiveBufferSize(int32 size) {
 243   return transport_socket_->SetReceiveBufferSize(size);
 244 }
 245
 246 int SSLServerSocketNSS::SetSendBufferSize(int32 size) {
 247   return transport_socket_->SetSendBufferSize(size);
 248 }
 249
 250 bool SSLServerSocketNSS::IsConnected() const {
 251   // TODO(wtc): Find out if we should check transport_socket_->IsConnected()
 252   // as well.
 253   return completed_handshake_;
 254 }
 255
 256 void SSLServerSocketNSS::Disconnect() {
 257   transport_socket_->Disconnect();
 258 }
 259
 260 bool SSLServerSocketNSS::IsConnectedAndIdle() const {
 261   return completed_handshake_ && transport_socket_->IsConnectedAndIdle();
 262 }
 263
 264 int SSLServerSocketNSS::GetPeerAddress(IPEndPoint* address) const {
 265   if (!IsConnected())
 266     return ERR_SOCKET_NOT_CONNECTED;
 267   return transport_socket_->GetPeerAddress(address);
 268 }
 269
 270 int SSLServerSocketNSS::GetLocalAddress(IPEndPoint* address) const {
 271   if (!IsConnected())
 272     return ERR_SOCKET_NOT_CONNECTED;
 273   return transport_socket_->GetLocalAddress(address);
 274 }
 275
 276 const BoundNetLog& SSLServerSocketNSS::NetLog() const {
 277   return net_log_;
 278 }
 279
 280 void SSLServerSocketNSS::SetSubresourceSpeculation() {
 281   transport_socket_->SetSubresourceSpeculation();
 282 }
 283
 284 void SSLServerSocketNSS::SetOmniboxSpeculation() {
 285   transport_socket_->SetOmniboxSpeculation();
 286 }
 287
 288 bool SSLServerSocketNSS::WasEverUsed() const {
 289   return transport_socket_->WasEverUsed();
 290 }
 291
 292 bool SSLServerSocketNSS::UsingTCPFastOpen() const {
 293   return transport_socket_->UsingTCPFastOpen();
 294 }
 295
 296 bool SSLServerSocketNSS::WasNpnNegotiated() const {
 297   NOTIMPLEMENTED();
 298   return false;
 299 }
 300
 301 NextProto SSLServerSocketNSS::GetNegotiatedProtocol() const {
 302   // NPN is not supported by this class.
 303   return kProtoUnknown;
 304 }
 305
 306 bool SSLServerSocketNSS::GetSSLInfo(SSLInfo* ssl_info) {
 307   NOTIMPLEMENTED();
 308   return false;
 309 }
 310
 311 int SSLServerSocketNSS::InitializeSSLOptions() {
 312   // Transport connected, now hook it up to nss
 313   nss_fd_ = memio_CreateIOLayer(kRecvBufferSize, kSendBufferSize);
 314   if (nss_fd_ == NULL) {
 315     return ERR_OUT_OF_MEMORY;  // TODO(port): map NSPR error code.
 316   }
 317
 318   // Grab pointer to buffers
 319   nss_bufs_ = memio_GetSecret(nss_fd_);
 320
 321   /* Create SSL state machine */
 322   /* Push SSL onto our fake I/O socket */
 323   nss_fd_ = SSL_ImportFD(NULL, nss_fd_);
 324   if (nss_fd_ == NULL) {
 325     LogFailedNSSFunction(net_log_, "SSL_ImportFD", "");
 326     return ERR_OUT_OF_MEMORY;  // TODO(port): map NSPR/NSS error code.
 327   }
 328   // TODO(port): set more ssl options!  Check errors!
 329
 330   int rv;
 331
 332   rv = SSL_OptionSet(nss_fd_, SSL_SECURITY, PR_TRUE);
 333   if (rv != SECSuccess) {
 334     LogFailedNSSFunction(net_log_, "SSL_OptionSet", "SSL_SECURITY");
 335     return ERR_UNEXPECTED;
 336   }
 337
 338   rv = SSL_OptionSet(nss_fd_, SSL_ENABLE_SSL2, PR_FALSE);
 339   if (rv != SECSuccess) {
 340     LogFailedNSSFunction(net_log_, "SSL_OptionSet", "SSL_ENABLE_SSL2");
 341     return ERR_UNEXPECTED;
 342   }
 343
 344   SSLVersionRange version_range;
 345   version_range.min = ssl_config_.version_min;
 346   version_range.max = ssl_config_.version_max;
 347   rv = SSL_VersionRangeSet(nss_fd_, &version_range);
 348   if (rv != SECSuccess) {
 349     LogFailedNSSFunction(net_log_, "SSL_VersionRangeSet", "");
 350     return ERR_NO_SSL_VERSIONS_ENABLED;
 351   }
 352
 353   if (ssl_config_.require_forward_secrecy) {
 354     const PRUint16* const ssl_ciphers = SSL_GetImplementedCiphers();
 355     const PRUint16 num_ciphers = SSL_GetNumImplementedCiphers();
 356
 357     // Require forward security by iterating over the cipher suites and
 358     // disabling all those that don't use ECDHE.
 359     for (unsigned i = 0; i < num_ciphers; i++) {
 360       SSLCipherSuiteInfo info;
 361       if (SSL_GetCipherSuiteInfo(ssl_ciphers[i], &info, sizeof(info)) ==
 362           SECSuccess) {
 363         if (strcmp(info.keaTypeName, "ECDHE") != 0) {
 364           SSL_CipherPrefSet(nss_fd_, ssl_ciphers[i], PR_FALSE);
 365         }
 366       }
 367     }
 368   }
 369
 370   for (std::vector<uint16>::const_iterator it =
 371            ssl_config_.disabled_cipher_suites.begin();
 372        it != ssl_config_.disabled_cipher_suites.end(); ++it) {
 373     // This will fail if the specified cipher is not implemented by NSS, but
 374     // the failure is harmless.
 375     SSL_CipherPrefSet(nss_fd_, *it, PR_FALSE);
 376   }
 377
 378   // Server socket doesn't need session tickets.
 379   rv = SSL_OptionSet(nss_fd_, SSL_ENABLE_SESSION_TICKETS, PR_FALSE);
 380   if (rv != SECSuccess) {
 381     LogFailedNSSFunction(
 382         net_log_, "SSL_OptionSet", "SSL_ENABLE_SESSION_TICKETS");
 383   }
 384
 385   // Doing this will force PR_Accept perform handshake as server.
 386   rv = SSL_OptionSet(nss_fd_, SSL_HANDSHAKE_AS_CLIENT, PR_FALSE);
 387   if (rv != SECSuccess) {
 388     LogFailedNSSFunction(net_log_, "SSL_OptionSet", "SSL_HANDSHAKE_AS_CLIENT");
 389     return ERR_UNEXPECTED;
 390   }
 391
 392   rv = SSL_OptionSet(nss_fd_, SSL_HANDSHAKE_AS_SERVER, PR_TRUE);
 393   if (rv != SECSuccess) {
 394     LogFailedNSSFunction(net_log_, "SSL_OptionSet", "SSL_HANDSHAKE_AS_SERVER");
 395     return ERR_UNEXPECTED;
 396   }
 397
 398   rv = SSL_OptionSet(nss_fd_, SSL_REQUEST_CERTIFICATE, PR_FALSE);
 399   if (rv != SECSuccess) {
 400     LogFailedNSSFunction(net_log_, "SSL_OptionSet", "SSL_REQUEST_CERTIFICATE");
 401     return ERR_UNEXPECTED;
 402   }
 403
 404   rv = SSL_OptionSet(nss_fd_, SSL_REQUIRE_CERTIFICATE, PR_FALSE);
 405   if (rv != SECSuccess) {
 406     LogFailedNSSFunction(net_log_, "SSL_OptionSet", "SSL_REQUIRE_CERTIFICATE");
 407     return ERR_UNEXPECTED;
 408   }
 409
 410   rv = SSL_AuthCertificateHook(nss_fd_, OwnAuthCertHandler, this);
 411   if (rv != SECSuccess) {
 412     LogFailedNSSFunction(net_log_, "SSL_AuthCertificateHook", "");
 413     return ERR_UNEXPECTED;
 414   }
 415
 416   rv = SSL_HandshakeCallback(nss_fd_, HandshakeCallback, this);
 417   if (rv != SECSuccess) {
 418     LogFailedNSSFunction(net_log_, "SSL_HandshakeCallback", "");
 419     return ERR_UNEXPECTED;
 420   }
 421
 422   // Get a certificate of CERTCertificate structure.
 423   std::string der_string;
 424   if (!X509Certificate::GetDEREncoded(cert_->os_cert_handle(), &der_string))
 425     return ERR_UNEXPECTED;
 426
 427   SECItem der_cert;
 428   der_cert.data = reinterpret_cast<unsigned char*>(const_cast<char*>(
 429       der_string.data()));
 430   der_cert.len  = der_string.length();
 431   der_cert.type = siDERCertBuffer;
 432
 433   // Parse into a CERTCertificate structure.
 434   CERTCertificate* cert = CERT_NewTempCertificate(
 435       CERT_GetDefaultCertDB(), &der_cert, NULL, PR_FALSE, PR_TRUE);
 436   if (!cert) {
 437     LogFailedNSSFunction(net_log_, "CERT_NewTempCertificate", "");
 438     return MapNSSError(PORT_GetError());
 439   }
 440
 441   // Get a key of SECKEYPrivateKey* structure.
 442   std::vector<uint8> key_vector;
 443   if (!key_->ExportPrivateKey(&key_vector)) {
 444     CERT_DestroyCertificate(cert);
 445     return ERR_UNEXPECTED;
 446   }
 447
 448   SECKEYPrivateKeyStr* private_key = NULL;
 449   PK11SlotInfo* slot = PK11_GetInternalSlot();
 450   if (!slot) {
 451     CERT_DestroyCertificate(cert);
 452     return ERR_UNEXPECTED;
 453   }
 454
 455   SECItem der_private_key_info;
 456   der_private_key_info.data =
 457       const_cast<unsigned char*>(&key_vector.front());
 458   der_private_key_info.len = key_vector.size();
 459   // The server's RSA private key must be imported into NSS with the
 460   // following key usage bits:
 461   // - KU_KEY_ENCIPHERMENT, required for the RSA key exchange algorithm.
 462   // - KU_DIGITAL_SIGNATURE, required for the DHE_RSA and ECDHE_RSA key
 463   //   exchange algorithms.
 464   const unsigned int key_usage = KU_KEY_ENCIPHERMENT | KU_DIGITAL_SIGNATURE;
 465   rv =  PK11_ImportDERPrivateKeyInfoAndReturnKey(
 466       slot, &der_private_key_info, NULL, NULL, PR_FALSE, PR_FALSE,
 467       key_usage, &private_key, NULL);
 468   PK11_FreeSlot(slot);
 469   if (rv != SECSuccess) {
 470     CERT_DestroyCertificate(cert);
 471     return ERR_UNEXPECTED;
 472   }
 473
 474   // Assign server certificate and private key.
 475   SSLKEAType cert_kea = NSS_FindCertKEAType(cert);
 476   rv = SSL_ConfigSecureServer(nss_fd_, cert, private_key, cert_kea);
 477   CERT_DestroyCertificate(cert);
 478   SECKEY_DestroyPrivateKey(private_key);
 479
 480   if (rv != SECSuccess) {
 481     PRErrorCode prerr = PR_GetError();
 482     LOG(ERROR) << "Failed to config SSL server: " << prerr;
 483     LogFailedNSSFunction(net_log_, "SSL_ConfigureSecureServer", "");
 484     return ERR_UNEXPECTED;
 485   }
 486
 487   // Tell SSL we're a server; needed if not letting NSPR do socket I/O
 488   rv = SSL_ResetHandshake(nss_fd_, PR_TRUE);
 489   if (rv != SECSuccess) {
 490     LogFailedNSSFunction(net_log_, "SSL_ResetHandshake", "");
 491     return ERR_UNEXPECTED;
 492   }
 493
 494   return OK;
 495 }
 496
 497 void SSLServerSocketNSS::OnSendComplete(int result) {
 498   if (next_handshake_state_ == STATE_HANDSHAKE) {
 499     // In handshake phase.
 500     OnHandshakeIOComplete(result);
 501     return;
 502   }
 503
 504   // TODO(byungchul): This state machine is not correct. Copy the state machine
 505   // of SSLClientSocketNSS::OnSendComplete() which handles it better.
 506   if (!completed_handshake_)
 507     return;
 508
 509   if (user_write_buf_.get()) {
 510     int rv = DoWriteLoop(result);
 511     if (rv != ERR_IO_PENDING)
 512       DoWriteCallback(rv);
 513   } else {
 514     // Ensure that any queued ciphertext is flushed.
 515     DoTransportIO();
 516   }
 517 }
 518
 519 void SSLServerSocketNSS::OnRecvComplete(int result) {
 520   if (next_handshake_state_ == STATE_HANDSHAKE) {
 521     // In handshake phase.
 522     OnHandshakeIOComplete(result);
 523     return;
 524   }
 525
 526   // Network layer received some data, check if client requested to read
 527   // decrypted data.
 528   if (!user_read_buf_.get() || !completed_handshake_)
 529     return;
 530
 531   int rv = DoReadLoop(result);
 532   if (rv != ERR_IO_PENDING)
 533     DoReadCallback(rv);
 534 }
 535
 536 void SSLServerSocketNSS::OnHandshakeIOComplete(int result) {
 537   int rv = DoHandshakeLoop(result);
 538   if (rv == ERR_IO_PENDING)
 539     return;
 540
 541   net_log_.EndEventWithNetErrorCode(NetLog::TYPE_SSL_SERVER_HANDSHAKE, rv);
 542   if (!user_handshake_callback_.is_null())
 543     DoHandshakeCallback(rv);
 544 }
 545
 546 // Return 0 for EOF,
 547 // > 0 for bytes transferred immediately,
 548 // < 0 for error (or the non-error ERR_IO_PENDING).
 549 int SSLServerSocketNSS::BufferSend(void) {
 550   if (transport_send_busy_)
 551     return ERR_IO_PENDING;
 552
 553   const char* buf1;
 554   const char* buf2;
 555   unsigned int len1, len2;
 556   if (memio_GetWriteParams(nss_bufs_, &buf1, &len1, &buf2, &len2)) {
 557     // The error code itself is ignored, so just return ERR_ABORTED.
 558     return ERR_ABORTED;
 559   }
 560   const unsigned int len = len1 + len2;
 561
 562   int rv = 0;
 563   if (len) {
 564     scoped_refptr<IOBuffer> send_buffer(new IOBuffer(len));
 565     memcpy(send_buffer->data(), buf1, len1);
 566     memcpy(send_buffer->data() + len1, buf2, len2);
 567     rv = transport_socket_->Write(
 568         send_buffer.get(),
 569         len,
 570         base::Bind(&SSLServerSocketNSS::BufferSendComplete,
 571                    base::Unretained(this)));
 572     if (rv == ERR_IO_PENDING) {
 573       transport_send_busy_ = true;
 574     } else {
 575       memio_PutWriteResult(nss_bufs_, MapErrorToNSS(rv));
 576     }
 577   }
 578
 579   return rv;
 580 }
 581
 582 void SSLServerSocketNSS::BufferSendComplete(int result) {
 583   memio_PutWriteResult(nss_bufs_, MapErrorToNSS(result));
 584   transport_send_busy_ = false;
 585   OnSendComplete(result);
 586 }
 587
 588 int SSLServerSocketNSS::BufferRecv(void) {
 589   if (transport_recv_busy_) return ERR_IO_PENDING;
 590
 591   char* buf;
 592   int nb = memio_GetReadParams(nss_bufs_, &buf);
 593   int rv;
 594   if (!nb) {
 595     // buffer too full to read into, so no I/O possible at moment
 596     rv = ERR_IO_PENDING;
 597   } else {
 598     recv_buffer_ = new IOBuffer(nb);
 599     rv = transport_socket_->Read(
 600         recv_buffer_.get(),
 601         nb,
 602         base::Bind(&SSLServerSocketNSS::BufferRecvComplete,
 603                    base::Unretained(this)));
 604     if (rv == ERR_IO_PENDING) {
 605       transport_recv_busy_ = true;
 606     } else {
 607       if (rv > 0)
 608         memcpy(buf, recv_buffer_->data(), rv);
 609       memio_PutReadResult(nss_bufs_, MapErrorToNSS(rv));
 610       recv_buffer_ = NULL;
 611     }
 612   }
 613   return rv;
 614 }
 615
 616 void SSLServerSocketNSS::BufferRecvComplete(int result) {
 617   if (result > 0) {
 618     char* buf;
 619     memio_GetReadParams(nss_bufs_, &buf);
 620     memcpy(buf, recv_buffer_->data(), result);
 621   }
 622   recv_buffer_ = NULL;
 623   memio_PutReadResult(nss_bufs_, MapErrorToNSS(result));
 624   transport_recv_busy_ = false;
 625   OnRecvComplete(result);
 626 }
 627
 628 // Do as much network I/O as possible between the buffer and the
 629 // transport socket. Return true if some I/O performed, false
 630 // otherwise (error or ERR_IO_PENDING).
 631 bool SSLServerSocketNSS::DoTransportIO() {
 632   bool network_moved = false;
 633   if (nss_bufs_ != NULL) {
 634     int rv;
 635     // Read and write as much data as we can. The loop is neccessary
 636     // because Write() may return synchronously.
 637     do {
 638       rv = BufferSend();
 639       if (rv > 0)
 640         network_moved = true;
 641     } while (rv > 0);
 642     if (BufferRecv() >= 0)
 643       network_moved = true;
 644   }
 645   return network_moved;
 646 }
 647
 648 int SSLServerSocketNSS::DoPayloadRead() {
 649   DCHECK(user_read_buf_.get());
 650   DCHECK_GT(user_read_buf_len_, 0);
 651   int rv = PR_Read(nss_fd_, user_read_buf_->data(), user_read_buf_len_);
 652   if (rv >= 0)
 653     return rv;
 654   PRErrorCode prerr = PR_GetError();
 655   if (prerr == PR_WOULD_BLOCK_ERROR) {
 656     return ERR_IO_PENDING;
 657   }
 658   rv = MapNSSError(prerr);
 659   net_log_.AddEvent(NetLog::TYPE_SSL_READ_ERROR,
 660                     CreateNetLogSSLErrorCallback(rv, prerr));
 661   return rv;
 662 }
 663
 664 int SSLServerSocketNSS::DoPayloadWrite() {
 665   DCHECK(user_write_buf_.get());
 666   int rv = PR_Write(nss_fd_, user_write_buf_->data(), user_write_buf_len_);
 667   if (rv >= 0)
 668     return rv;
 669   PRErrorCode prerr = PR_GetError();
 670   if (prerr == PR_WOULD_BLOCK_ERROR) {
 671     return ERR_IO_PENDING;
 672   }
 673   rv = MapNSSError(prerr);
 674   net_log_.AddEvent(NetLog::TYPE_SSL_WRITE_ERROR,
 675                     CreateNetLogSSLErrorCallback(rv, prerr));
 676   return rv;
 677 }
 678
 679 int SSLServerSocketNSS::DoHandshakeLoop(int last_io_result) {
 680   int rv = last_io_result;
 681   do {
 682     // Default to STATE_NONE for next state.
 683     // (This is a quirk carried over from the windows
 684     // implementation.  It makes reading the logs a bit harder.)
 685     // State handlers can and often do call GotoState just
 686     // to stay in the current state.
 687     State state = next_handshake_state_;
 688     GotoState(STATE_NONE);
 689     switch (state) {
 690       case STATE_HANDSHAKE:
 691         rv = DoHandshake();
 692         break;
 693       case STATE_NONE:
 694       default:
 695         rv = ERR_UNEXPECTED;
 696         LOG(DFATAL) << "unexpected state " << state;
 697         break;
 698     }
 699
 700     // Do the actual network I/O
 701     bool network_moved = DoTransportIO();
 702     if (network_moved && next_handshake_state_ == STATE_HANDSHAKE) {
 703       // In general we exit the loop if rv is ERR_IO_PENDING.  In this
 704       // special case we keep looping even if rv is ERR_IO_PENDING because
 705       // the transport IO may allow DoHandshake to make progress.
 706       rv = OK;  // This causes us to stay in the loop.
 707     }
 708   } while (rv != ERR_IO_PENDING && next_handshake_state_ != STATE_NONE);
 709   return rv;
 710 }
 711
 712 int SSLServerSocketNSS::DoReadLoop(int result) {
 713   DCHECK(completed_handshake_);
 714   DCHECK(next_handshake_state_ == STATE_NONE);
 715
 716   if (result < 0)
 717     return result;
 718
 719   if (!nss_bufs_) {
 720     LOG(DFATAL) << "!nss_bufs_";
 721     int rv = ERR_UNEXPECTED;
 722     net_log_.AddEvent(NetLog::TYPE_SSL_READ_ERROR,
 723                       CreateNetLogSSLErrorCallback(rv, 0));
 724     return rv;
 725   }
 726
 727   bool network_moved;
 728   int rv;
 729   do {
 730     rv = DoPayloadRead();
 731     network_moved = DoTransportIO();
 732   } while (rv == ERR_IO_PENDING && network_moved);
 733   return rv;
 734 }
 735
 736 int SSLServerSocketNSS::DoWriteLoop(int result) {
 737   DCHECK(completed_handshake_);
 738   DCHECK_EQ(next_handshake_state_, STATE_NONE);
 739
 740   if (result < 0)
 741     return result;
 742
 743   if (!nss_bufs_) {
 744     LOG(DFATAL) << "!nss_bufs_";
 745     int rv = ERR_UNEXPECTED;
 746     net_log_.AddEvent(NetLog::TYPE_SSL_WRITE_ERROR,
 747                       CreateNetLogSSLErrorCallback(rv, 0));
 748     return rv;
 749   }
 750
 751   bool network_moved;
 752   int rv;
 753   do {
 754     rv = DoPayloadWrite();
 755     network_moved = DoTransportIO();
 756   } while (rv == ERR_IO_PENDING && network_moved);
 757   return rv;
 758 }
 759
 760 int SSLServerSocketNSS::DoHandshake() {
 761   int net_error = OK;
 762   SECStatus rv = SSL_ForceHandshake(nss_fd_);
 763
 764   if (rv == SECSuccess) {
 765     completed_handshake_ = true;
 766   } else {
 767     PRErrorCode prerr = PR_GetError();
 768     net_error = MapNSSError(prerr);
 769
 770     // If not done, stay in this state
 771     if (net_error == ERR_IO_PENDING) {
 772       GotoState(STATE_HANDSHAKE);
 773     } else {
 774       LOG(ERROR) << "handshake failed; NSS error code " << prerr
 775                  << ", net_error " << net_error;
 776       net_log_.AddEvent(NetLog::TYPE_SSL_HANDSHAKE_ERROR,
 777                         CreateNetLogSSLErrorCallback(net_error, prerr));
 778     }
 779   }
 780   return net_error;
 781 }
 782
 783 void SSLServerSocketNSS::DoHandshakeCallback(int rv) {
 784   DCHECK_NE(rv, ERR_IO_PENDING);
 785   ResetAndReturn(&user_handshake_callback_).Run(rv > OK ? OK : rv);
 786 }
 787
 788 void SSLServerSocketNSS::DoReadCallback(int rv) {
 789   DCHECK(rv != ERR_IO_PENDING);
 790   DCHECK(!user_read_callback_.is_null());
 791
 792   user_read_buf_ = NULL;
 793   user_read_buf_len_ = 0;
 794   ResetAndReturn(&user_read_callback_).Run(rv);
 795 }
 796
 797 void SSLServerSocketNSS::DoWriteCallback(int rv) {
 798   DCHECK(rv != ERR_IO_PENDING);
 799   DCHECK(!user_write_callback_.is_null());
 800
 801   user_write_buf_ = NULL;
 802   user_write_buf_len_ = 0;
 803   ResetAndReturn(&user_write_callback_).Run(rv);
 804 }
 805
 806 // static
 807 // NSS calls this if an incoming certificate needs to be verified.
 808 // Do nothing but return SECSuccess.
 809 // This is called only in full handshake mode.
 810 // Peer certificate is retrieved in HandshakeCallback() later, which is called
 811 // in full handshake mode or in resumption handshake mode.
 812 SECStatus SSLServerSocketNSS::OwnAuthCertHandler(void* arg,
 813                                                  PRFileDesc* socket,
 814                                                  PRBool checksig,
 815                                                  PRBool is_server) {
 816   // TODO(hclam): Implement.
 817   // Tell NSS to not verify the certificate.
 818   return SECSuccess;
 819 }
 820
 821 // static
 822 // NSS calls this when handshake is completed.
 823 // After the SSL handshake is finished we need to verify the certificate.
 824 void SSLServerSocketNSS::HandshakeCallback(PRFileDesc* socket,
 825                                            void* arg) {
 826   // TODO(hclam): Implement.
 827 }
 828
 829 int SSLServerSocketNSS::Init() {
 830   // Initialize the NSS SSL library in a threadsafe way.  This also
 831   // initializes the NSS base library.
 832   EnsureNSSSSLInit();
 833   if (!NSS_IsInitialized())
 834     return ERR_UNEXPECTED;
 835
 836   EnableSSLServerSockets();
 837   return OK;
 838 }
 839
 840 }  // namespace net