Home | History | Annotate | Download | only in base 
      1 /*
      2  * libjingle
      3  * Copyright 2004--2008, Google Inc.
      4  * Copyright 2004--2011, RTFM, Inc.
      5  *
      6  * Redistribution and use in source and binary forms, with or without
      7  * modification, are permitted provided that the following conditions are met:
      8  *
      9  *  1. Redistributions of source code must retain the above copyright notice,
     10  *     this list of conditions and the following disclaimer.
     11  *  2. Redistributions in binary form must reproduce the above copyright notice,
     12  *     this list of conditions and the following disclaimer in the documentation
     13  *     and/or other materials provided with the distribution.
     14  *  3. The name of the author may not be used to endorse or promote products
     15  *     derived from this software without specific prior written permission.
     16  *
     17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
     18  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
     19  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
     20  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     21  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
     22  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
     23  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
     24  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
     25  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
     26  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     27  */
     28 
     29 #include <vector>
     30 
     31 #if HAVE_CONFIG_H
     32 #include "config.h"
     33 #endif  // HAVE_CONFIG_H
     34 
     35 #if HAVE_NSS_SSL_H
     36 
     37 #include "talk/base/nssstreamadapter.h"
     38 
     39 #include "keyhi.h"
     40 #include "nspr.h"
     41 #include "nss.h"
     42 #include "pk11pub.h"
     43 #include "secerr.h"
     44 
     45 #ifdef NSS_SSL_RELATIVE_PATH
     46 #include "ssl.h"
     47 #include "sslerr.h"
     48 #include "sslproto.h"
     49 #else
     50 #include "net/third_party/nss/ssl/ssl.h"
     51 #include "net/third_party/nss/ssl/sslerr.h"
     52 #include "net/third_party/nss/ssl/sslproto.h"
     53 #endif
     54 
     55 #include "talk/base/nssidentity.h"
     56 #include "talk/base/thread.h"
     57 
     58 namespace talk_base {
     59 
     60 PRDescIdentity NSSStreamAdapter::nspr_layer_identity = PR_INVALID_IO_LAYER;
     61 
     62 #define UNIMPLEMENTED \
     63   PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0); \
     64   LOG(LS_ERROR) \
     65   << "Call to unimplemented function "<< __FUNCTION__; ASSERT(false)
     66 
     67 #ifdef SRTP_AES128_CM_HMAC_SHA1_80
     68 #define HAVE_DTLS_SRTP
     69 #endif
     70 
     71 #ifdef HAVE_DTLS_SRTP
     72 // SRTP cipher suite table
     73 struct SrtpCipherMapEntry {
     74   const char* external_name;
     75   PRUint16 cipher_id;
     76 };
     77 
     78 // This isn't elegant, but it's better than an external reference
     79 static const SrtpCipherMapEntry kSrtpCipherMap[] = {
     80   {"AES_CM_128_HMAC_SHA1_80", SRTP_AES128_CM_HMAC_SHA1_80 },
     81   {"AES_CM_128_HMAC_SHA1_32", SRTP_AES128_CM_HMAC_SHA1_32 },
     82   {NULL, 0}
     83 };
     84 #endif
     85 
     86 
     87 // Implementation of NSPR methods
     88 static PRStatus StreamClose(PRFileDesc *socket) {
     89   // Noop
     90   return PR_SUCCESS;
     91 }
     92 
     93 static PRInt32 StreamRead(PRFileDesc *socket, void *buf, PRInt32 length) {
     94   StreamInterface *stream = reinterpret_cast<StreamInterface *>(socket->secret);
     95   size_t read;
     96   int error;
     97   StreamResult result = stream->Read(buf, length, &read, &error);
     98   if (result == SR_SUCCESS) {
     99     return read;
    100   }
    101 
    102   if (result == SR_EOS) {
    103     return 0;
    104   }
    105 
    106   if (result == SR_BLOCK) {
    107     PR_SetError(PR_WOULD_BLOCK_ERROR, 0);
    108     return -1;
    109   }
    110 
    111   PR_SetError(PR_UNKNOWN_ERROR, error);
    112   return -1;
    113 }
    114 
    115 static PRInt32 StreamWrite(PRFileDesc *socket, const void *buf,
    116                            PRInt32 length) {
    117   StreamInterface *stream = reinterpret_cast<StreamInterface *>(socket->secret);
    118   size_t written;
    119   int error;
    120   StreamResult result = stream->Write(buf, length, &written, &error);
    121   if (result == SR_SUCCESS) {
    122     return written;
    123   }
    124 
    125   if (result == SR_BLOCK) {
    126     LOG(LS_INFO) <<
    127         "NSSStreamAdapter: write to underlying transport would block";
    128     PR_SetError(PR_WOULD_BLOCK_ERROR, 0);
    129     return -1;
    130   }
    131 
    132   LOG(LS_ERROR) << "Write error";
    133   PR_SetError(PR_UNKNOWN_ERROR, error);
    134   return -1;
    135 }
    136 
    137 static PRInt32 StreamAvailable(PRFileDesc *socket) {
    138   UNIMPLEMENTED;
    139   return -1;
    140 }
    141 
    142 PRInt64 StreamAvailable64(PRFileDesc *socket) {
    143   UNIMPLEMENTED;
    144   return -1;
    145 }
    146 
    147 static PRStatus StreamSync(PRFileDesc *socket) {
    148   UNIMPLEMENTED;
    149   return PR_FAILURE;
    150 }
    151 
    152 static PROffset32 StreamSeek(PRFileDesc *socket, PROffset32 offset,
    153                              PRSeekWhence how) {
    154   UNIMPLEMENTED;
    155   return -1;
    156 }
    157 
    158 static PROffset64 StreamSeek64(PRFileDesc *socket, PROffset64 offset,
    159                                PRSeekWhence how) {
    160   UNIMPLEMENTED;
    161   return -1;
    162 }
    163 
    164 static PRStatus StreamFileInfo(PRFileDesc *socket, PRFileInfo *info) {
    165   UNIMPLEMENTED;
    166   return PR_FAILURE;
    167 }
    168 
    169 static PRStatus StreamFileInfo64(PRFileDesc *socket, PRFileInfo64 *info) {
    170   UNIMPLEMENTED;
    171   return PR_FAILURE;
    172 }
    173 
    174 static PRInt32 StreamWritev(PRFileDesc *socket, const PRIOVec *iov,
    175                      PRInt32 iov_size, PRIntervalTime timeout) {
    176   UNIMPLEMENTED;
    177   return -1;
    178 }
    179 
    180 static PRStatus StreamConnect(PRFileDesc *socket, const PRNetAddr *addr,
    181                               PRIntervalTime timeout) {
    182   UNIMPLEMENTED;
    183   return PR_FAILURE;
    184 }
    185 
    186 static PRFileDesc *StreamAccept(PRFileDesc *sd, PRNetAddr *addr,
    187                                 PRIntervalTime timeout) {
    188   UNIMPLEMENTED;
    189   return NULL;
    190 }
    191 
    192 static PRStatus StreamBind(PRFileDesc *socket, const PRNetAddr *addr) {
    193   UNIMPLEMENTED;
    194   return PR_FAILURE;
    195 }
    196 
    197 static PRStatus StreamListen(PRFileDesc *socket, PRIntn depth) {
    198   UNIMPLEMENTED;
    199   return PR_FAILURE;
    200 }
    201 
    202 static PRStatus StreamShutdown(PRFileDesc *socket, PRIntn how) {
    203   UNIMPLEMENTED;
    204   return PR_FAILURE;
    205 }
    206 
    207 // Note: this is always nonblocking and ignores the timeout.
    208 // TODO(ekr (at) rtfm.com): In future verify that the socket is
    209 // actually in non-blocking mode.
    210 // This function does not support peek.
    211 static PRInt32 StreamRecv(PRFileDesc *socket, void *buf, PRInt32 amount,
    212                    PRIntn flags, PRIntervalTime to) {
    213   ASSERT(flags == 0);
    214 
    215   if (flags != 0) {
    216     PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
    217     return -1;
    218   }
    219 
    220   return StreamRead(socket, buf, amount);
    221 }
    222 
    223 // Note: this is always nonblocking and assumes a zero timeout.
    224 // This function does not support peek.
    225 static PRInt32 StreamSend(PRFileDesc *socket, const void *buf,
    226                           PRInt32 amount, PRIntn flags,
    227                           PRIntervalTime to) {
    228   ASSERT(flags == 0);
    229 
    230   return StreamWrite(socket, buf, amount);
    231 }
    232 
    233 static PRInt32 StreamRecvfrom(PRFileDesc *socket, void *buf,
    234                               PRInt32 amount, PRIntn flags,
    235                               PRNetAddr *addr, PRIntervalTime to) {
    236   UNIMPLEMENTED;
    237   return -1;
    238 }
    239 
    240 static PRInt32 StreamSendto(PRFileDesc *socket, const void *buf,
    241                             PRInt32 amount, PRIntn flags,
    242                             const PRNetAddr *addr, PRIntervalTime to) {
    243   UNIMPLEMENTED;
    244   return -1;
    245 }
    246 
    247 static PRInt16 StreamPoll(PRFileDesc *socket, PRInt16 in_flags,
    248                           PRInt16 *out_flags) {
    249   UNIMPLEMENTED;
    250   return -1;
    251 }
    252 
    253 static PRInt32 StreamAcceptRead(PRFileDesc *sd, PRFileDesc **nd,
    254                                 PRNetAddr **raddr,
    255                                 void *buf, PRInt32 amount, PRIntervalTime t) {
    256   UNIMPLEMENTED;
    257   return -1;
    258 }
    259 
    260 static PRInt32 StreamTransmitFile(PRFileDesc *sd, PRFileDesc *socket,
    261                                   const void *headers, PRInt32 hlen,
    262                                   PRTransmitFileFlags flags, PRIntervalTime t) {
    263   UNIMPLEMENTED;
    264   return -1;
    265 }
    266 
    267 static PRStatus StreamGetPeerName(PRFileDesc *socket, PRNetAddr *addr) {
    268   // TODO(ekr (at) rtfm.com): Modify to return unique names for each channel
    269   // somehow, as opposed to always the same static address. The current
    270   // implementation messes up the session cache, which is why it's off
    271   // elsewhere
    272   addr->inet.family = PR_AF_INET;
    273   addr->inet.port = 0;
    274   addr->inet.ip = 0;
    275 
    276   return PR_SUCCESS;
    277 }
    278 
    279 static PRStatus StreamGetSockName(PRFileDesc *socket, PRNetAddr *addr) {
    280   UNIMPLEMENTED;
    281   return PR_FAILURE;
    282 }
    283 
    284 static PRStatus StreamGetSockOption(PRFileDesc *socket, PRSocketOptionData *opt) {
    285   switch (opt->option) {
    286     case PR_SockOpt_Nonblocking:
    287       opt->value.non_blocking = PR_TRUE;
    288       return PR_SUCCESS;
    289     default:
    290       UNIMPLEMENTED;
    291       break;
    292   }
    293 
    294   return PR_FAILURE;
    295 }
    296 
    297 // Imitate setting socket options. These are mostly noops.
    298 static PRStatus StreamSetSockOption(PRFileDesc *socket,
    299                                     const PRSocketOptionData *opt) {
    300   switch (opt->option) {
    301     case PR_SockOpt_Nonblocking:
    302       return PR_SUCCESS;
    303     case PR_SockOpt_NoDelay:
    304       return PR_SUCCESS;
    305     default:
    306       UNIMPLEMENTED;
    307       break;
    308   }
    309 
    310   return PR_FAILURE;
    311 }
    312 
    313 static PRInt32 StreamSendfile(PRFileDesc *out, PRSendFileData *in,
    314                               PRTransmitFileFlags flags, PRIntervalTime to) {
    315   UNIMPLEMENTED;
    316   return -1;
    317 }
    318 
    319 static PRStatus StreamConnectContinue(PRFileDesc *socket, PRInt16 flags) {
    320   UNIMPLEMENTED;
    321   return PR_FAILURE;
    322 }
    323 
    324 static PRIntn StreamReserved(PRFileDesc *socket) {
    325   UNIMPLEMENTED;
    326   return -1;
    327 }
    328 
    329 static const struct PRIOMethods nss_methods = {
    330   PR_DESC_LAYERED,
    331   StreamClose,
    332   StreamRead,
    333   StreamWrite,
    334   StreamAvailable,
    335   StreamAvailable64,
    336   StreamSync,
    337   StreamSeek,
    338   StreamSeek64,
    339   StreamFileInfo,
    340   StreamFileInfo64,
    341   StreamWritev,
    342   StreamConnect,
    343   StreamAccept,
    344   StreamBind,
    345   StreamListen,
    346   StreamShutdown,
    347   StreamRecv,
    348   StreamSend,
    349   StreamRecvfrom,
    350   StreamSendto,
    351   StreamPoll,
    352   StreamAcceptRead,
    353   StreamTransmitFile,
    354   StreamGetSockName,
    355   StreamGetPeerName,
    356   StreamReserved,
    357   StreamReserved,
    358   StreamGetSockOption,
    359   StreamSetSockOption,
    360   StreamSendfile,
    361   StreamConnectContinue,
    362   StreamReserved,
    363   StreamReserved,
    364   StreamReserved,
    365   StreamReserved
    366 };
    367 
    368 NSSStreamAdapter::NSSStreamAdapter(StreamInterface *stream)
    369     : SSLStreamAdapterHelper(stream),
    370       ssl_fd_(NULL),
    371       cert_ok_(false) {
    372 }
    373 
    374 bool NSSStreamAdapter::Init() {
    375   if (nspr_layer_identity == PR_INVALID_IO_LAYER) {
    376     nspr_layer_identity = PR_GetUniqueIdentity("nssstreamadapter");
    377   }
    378   PRFileDesc *pr_fd = PR_CreateIOLayerStub(nspr_layer_identity, &nss_methods);
    379   if (!pr_fd)
    380     return false;
    381   pr_fd->secret = reinterpret_cast<PRFilePrivate *>(stream());
    382 
    383   PRFileDesc *ssl_fd;
    384   if (ssl_mode_ == SSL_MODE_DTLS) {
    385     ssl_fd = DTLS_ImportFD(NULL, pr_fd);
    386   } else {
    387     ssl_fd = SSL_ImportFD(NULL, pr_fd);
    388   }
    389   ASSERT(ssl_fd != NULL);  // This should never happen
    390   if (!ssl_fd) {
    391     PR_Close(pr_fd);
    392     return false;
    393   }
    394 
    395   SECStatus rv;
    396   // Turn on security.
    397   rv = SSL_OptionSet(ssl_fd, SSL_SECURITY, PR_TRUE);
    398   if (rv != SECSuccess) {
    399     LOG(LS_ERROR) << "Error enabling security on SSL Socket";
    400     return false;
    401   }
    402 
    403   // Disable SSLv2.
    404   rv = SSL_OptionSet(ssl_fd, SSL_ENABLE_SSL2, PR_FALSE);
    405   if (rv != SECSuccess) {
    406     LOG(LS_ERROR) << "Error disabling SSL2";
    407     return false;
    408   }
    409 
    410   // Disable caching.
    411   // TODO(ekr (at) rtfm.com): restore this when I have the caching
    412   // identity set.
    413   rv = SSL_OptionSet(ssl_fd, SSL_NO_CACHE, PR_TRUE);
    414   if (rv != SECSuccess) {
    415     LOG(LS_ERROR) << "Error disabling cache";
    416     return false;
    417   }
    418 
    419   // Disable session tickets.
    420   rv = SSL_OptionSet(ssl_fd, SSL_ENABLE_SESSION_TICKETS, PR_FALSE);
    421   if (rv != SECSuccess) {
    422     LOG(LS_ERROR) << "Error enabling tickets";
    423     return false;
    424   }
    425 
    426   // Disable renegotiation.
    427   rv = SSL_OptionSet(ssl_fd, SSL_ENABLE_RENEGOTIATION,
    428                      SSL_RENEGOTIATE_NEVER);
    429   if (rv != SECSuccess) {
    430     LOG(LS_ERROR) << "Error disabling renegotiation";
    431     return false;
    432   }
    433 
    434   // Disable false start.
    435   rv = SSL_OptionSet(ssl_fd, SSL_ENABLE_FALSE_START, PR_FALSE);
    436   if (rv != SECSuccess) {
    437     LOG(LS_ERROR) << "Error disabling false start";
    438     return false;
    439   }
    440 
    441   ssl_fd_ = ssl_fd;
    442 
    443   return true;
    444 }
    445 
    446 NSSStreamAdapter::~NSSStreamAdapter() {
    447   if (ssl_fd_)
    448     PR_Close(ssl_fd_);
    449 };
    450 
    451 
    452 int NSSStreamAdapter::BeginSSL() {
    453   SECStatus rv;
    454 
    455   if (!Init()) {
    456     Error("Init", -1, false);
    457     return -1;
    458   }
    459 
    460   ASSERT(state_ == SSL_CONNECTING);
    461   // The underlying stream has been opened. If we are in peer-to-peer mode
    462   // then a peer certificate must have been specified by now.
    463   ASSERT(!ssl_server_name_.empty() ||
    464          peer_certificate_.get() != NULL ||
    465          !peer_certificate_digest_algorithm_.empty());
    466   LOG(LS_INFO) << "BeginSSL: "
    467                << (!ssl_server_name_.empty() ? ssl_server_name_ :
    468                                                "with peer");
    469 
    470   if (role_ == SSL_CLIENT) {
    471     LOG(LS_INFO) << "BeginSSL: as client";
    472 
    473     rv = SSL_GetClientAuthDataHook(ssl_fd_, GetClientAuthDataHook,
    474                                    this);
    475     if (rv != SECSuccess) {
    476       Error("BeginSSL", -1, false);
    477       return -1;
    478     }
    479   } else {
    480     LOG(LS_INFO) << "BeginSSL: as server";
    481     NSSIdentity *identity;
    482 
    483     if (identity_.get()) {
    484       identity = static_cast<NSSIdentity *>(identity_.get());
    485     } else {
    486       LOG(LS_ERROR) << "Can't be an SSL server without an identity";
    487       Error("BeginSSL", -1, false);
    488       return -1;
    489     }
    490     rv = SSL_ConfigSecureServer(ssl_fd_, identity->certificate().certificate(),
    491                                 identity->keypair()->privkey(),
    492                                 kt_rsa);
    493     if (rv != SECSuccess) {
    494       Error("BeginSSL", -1, false);
    495       return -1;
    496     }
    497 
    498     // Insist on a certificate from the client
    499     rv = SSL_OptionSet(ssl_fd_, SSL_REQUEST_CERTIFICATE, PR_TRUE);
    500     if (rv != SECSuccess) {
    501       Error("BeginSSL", -1, false);
    502       return -1;
    503     }
    504 
    505     rv = SSL_OptionSet(ssl_fd_, SSL_REQUIRE_CERTIFICATE, PR_TRUE);
    506     if (rv != SECSuccess) {
    507       Error("BeginSSL", -1, false);
    508       return -1;
    509     }
    510   }
    511 
    512   // Set the version range.
    513   SSLVersionRange vrange;
    514   vrange.min =  (ssl_mode_ == SSL_MODE_DTLS) ?
    515       SSL_LIBRARY_VERSION_TLS_1_1 :
    516       SSL_LIBRARY_VERSION_TLS_1_0;
    517   vrange.max = SSL_LIBRARY_VERSION_TLS_1_1;
    518 
    519   rv = SSL_VersionRangeSet(ssl_fd_, &vrange);
    520   if (rv != SECSuccess) {
    521     Error("BeginSSL", -1, false);
    522     return -1;
    523   }
    524 
    525   // SRTP
    526 #ifdef HAVE_DTLS_SRTP
    527   if (!srtp_ciphers_.empty()) {
    528     rv = SSL_SetSRTPCiphers(ssl_fd_, &srtp_ciphers_[0], srtp_ciphers_.size());
    529     if (rv != SECSuccess) {
    530       Error("BeginSSL", -1, false);
    531       return -1;
    532     }
    533   }
    534 #endif
    535 
    536   // Certificate validation
    537   rv = SSL_AuthCertificateHook(ssl_fd_, AuthCertificateHook, this);
    538   if (rv != SECSuccess) {
    539     Error("BeginSSL", -1, false);
    540     return -1;
    541   }
    542 
    543   // Now start the handshake
    544   rv = SSL_ResetHandshake(ssl_fd_, role_ == SSL_SERVER ? PR_TRUE : PR_FALSE);
    545   if (rv != SECSuccess) {
    546     Error("BeginSSL", -1, false);
    547     return -1;
    548   }
    549 
    550   return ContinueSSL();
    551 }
    552 
    553 int NSSStreamAdapter::ContinueSSL() {
    554   LOG(LS_INFO) << "ContinueSSL";
    555   ASSERT(state_ == SSL_CONNECTING);
    556 
    557   // Clear the DTLS timer
    558   Thread::Current()->Clear(this, MSG_DTLS_TIMEOUT);
    559 
    560   SECStatus rv = SSL_ForceHandshake(ssl_fd_);
    561 
    562   if (rv == SECSuccess) {
    563     LOG(LS_INFO) << "Handshake complete";
    564 
    565     ASSERT(cert_ok_);
    566     if (!cert_ok_) {
    567       Error("ContinueSSL", -1, true);
    568       return -1;
    569     }
    570 
    571     state_ = SSL_CONNECTED;
    572     StreamAdapterInterface::OnEvent(stream(), SE_OPEN|SE_READ|SE_WRITE, 0);
    573     return 0;
    574   }
    575 
    576   PRInt32 err = PR_GetError();
    577   switch (err) {
    578     case SSL_ERROR_RX_MALFORMED_HANDSHAKE:
    579       if (ssl_mode_ != SSL_MODE_DTLS) {
    580         Error("ContinueSSL", -1, true);
    581         return -1;
    582       } else {
    583         LOG(LS_INFO) << "Malformed DTLS message. Ignoring.";
    584         // Fall through
    585       }
    586     case PR_WOULD_BLOCK_ERROR:
    587       LOG(LS_INFO) << "Would have blocked";
    588       if (ssl_mode_ == SSL_MODE_DTLS) {
    589         PRIntervalTime timeout;
    590 
    591         SECStatus rv = DTLS_GetHandshakeTimeout(ssl_fd_, &timeout);
    592         if (rv == SECSuccess) {
    593           LOG(LS_INFO) << "Timeout is " << timeout << " ms";
    594           Thread::Current()->PostDelayed(PR_IntervalToMilliseconds(timeout),
    595                                          this, MSG_DTLS_TIMEOUT, 0);
    596         }
    597       }
    598 
    599       return 0;
    600     default:
    601       LOG(LS_INFO) << "Error " << err;
    602       break;
    603   }
    604 
    605   Error("ContinueSSL", -1, true);
    606   return -1;
    607 }
    608 
    609 void NSSStreamAdapter::Cleanup() {
    610   if (state_ != SSL_ERROR) {
    611     state_ = SSL_CLOSED;
    612   }
    613 
    614   if (ssl_fd_) {
    615     PR_Close(ssl_fd_);
    616     ssl_fd_ = NULL;
    617   }
    618 
    619   identity_.reset();
    620   peer_certificate_.reset();
    621 
    622   Thread::Current()->Clear(this, MSG_DTLS_TIMEOUT);
    623 }
    624 
    625 StreamResult NSSStreamAdapter::Read(void* data, size_t data_len,
    626                                     size_t* read, int* error) {
    627   // SSL_CONNECTED sanity check.
    628   switch (state_) {
    629     case SSL_NONE:
    630     case SSL_WAIT:
    631     case SSL_CONNECTING:
    632       return SR_BLOCK;
    633 
    634     case SSL_CONNECTED:
    635       break;
    636 
    637     case SSL_CLOSED:
    638       return SR_EOS;
    639 
    640     case SSL_ERROR:
    641     default:
    642       if (error)
    643         *error = ssl_error_code_;
    644       return SR_ERROR;
    645   }
    646 
    647   PRInt32 rv = PR_Read(ssl_fd_, data, data_len);
    648 
    649   if (rv == 0) {
    650     return SR_EOS;
    651   }
    652 
    653   // Error
    654   if (rv < 0) {
    655     PRInt32 err = PR_GetError();
    656 
    657     switch (err) {
    658       case PR_WOULD_BLOCK_ERROR:
    659         return SR_BLOCK;
    660       default:
    661         Error("Read", -1, false);
    662         *error = err;  // libjingle semantics are that this is impl-specific
    663         return SR_ERROR;
    664     }
    665   }
    666 
    667   // Success
    668   *read = rv;
    669 
    670   return SR_SUCCESS;
    671 }
    672 
    673 StreamResult NSSStreamAdapter::Write(const void* data, size_t data_len,
    674                                      size_t* written, int* error) {
    675   // SSL_CONNECTED sanity check.
    676   switch (state_) {
    677     case SSL_NONE:
    678     case SSL_WAIT:
    679     case SSL_CONNECTING:
    680       return SR_BLOCK;
    681 
    682     case SSL_CONNECTED:
    683       break;
    684 
    685     case SSL_ERROR:
    686     case SSL_CLOSED:
    687     default:
    688       if (error)
    689         *error = ssl_error_code_;
    690       return SR_ERROR;
    691   }
    692 
    693   PRInt32 rv = PR_Write(ssl_fd_, data, data_len);
    694 
    695   // Error
    696   if (rv < 0) {
    697     PRInt32 err = PR_GetError();
    698 
    699     switch (err) {
    700       case PR_WOULD_BLOCK_ERROR:
    701         return SR_BLOCK;
    702       default:
    703         Error("Write", -1, false);
    704         *error = err;  // libjingle semantics are that this is impl-specific
    705         return SR_ERROR;
    706     }
    707   }
    708 
    709   // Success
    710   *written = rv;
    711 
    712   return SR_SUCCESS;
    713 }
    714 
    715 void NSSStreamAdapter::OnEvent(StreamInterface* stream, int events,
    716                                int err) {
    717   int events_to_signal = 0;
    718   int signal_error = 0;
    719   ASSERT(stream == this->stream());
    720   if ((events & SE_OPEN)) {
    721     LOG(LS_INFO) << "NSSStreamAdapter::OnEvent SE_OPEN";
    722     if (state_ != SSL_WAIT) {
    723       ASSERT(state_ == SSL_NONE);
    724       events_to_signal |= SE_OPEN;
    725     } else {
    726       state_ = SSL_CONNECTING;
    727       if (int err = BeginSSL()) {
    728         Error("BeginSSL", err, true);
    729         return;
    730       }
    731     }
    732   }
    733   if ((events & (SE_READ|SE_WRITE))) {
    734     LOG(LS_INFO) << "NSSStreamAdapter::OnEvent"
    735                  << ((events & SE_READ) ? " SE_READ" : "")
    736                  << ((events & SE_WRITE) ? " SE_WRITE" : "");
    737     if (state_ == SSL_NONE) {
    738       events_to_signal |= events & (SE_READ|SE_WRITE);
    739     } else if (state_ == SSL_CONNECTING) {
    740       if (int err = ContinueSSL()) {
    741         Error("ContinueSSL", err, true);
    742         return;
    743       }
    744     } else if (state_ == SSL_CONNECTED) {
    745       if (events & SE_WRITE) {
    746         LOG(LS_INFO) << " -- onStreamWriteable";
    747         events_to_signal |= SE_WRITE;
    748       }
    749       if (events & SE_READ) {
    750         LOG(LS_INFO) << " -- onStreamReadable";
    751         events_to_signal |= SE_READ;
    752       }
    753     }
    754   }
    755   if ((events & SE_CLOSE)) {
    756     LOG(LS_INFO) << "NSSStreamAdapter::OnEvent(SE_CLOSE, " << err << ")";
    757     Cleanup();
    758     events_to_signal |= SE_CLOSE;
    759     // SE_CLOSE is the only event that uses the final parameter to OnEvent().
    760     ASSERT(signal_error == 0);
    761     signal_error = err;
    762   }
    763   if (events_to_signal)
    764     StreamAdapterInterface::OnEvent(stream, events_to_signal, signal_error);
    765 }
    766 
    767 void NSSStreamAdapter::OnMessage(Message* msg) {
    768   // Process our own messages and then pass others to the superclass
    769   if (MSG_DTLS_TIMEOUT == msg->message_id) {
    770     LOG(LS_INFO) << "DTLS timeout expired";
    771     ContinueSSL();
    772   } else {
    773     StreamInterface::OnMessage(msg);
    774   }
    775 }
    776 
    777 // Certificate verification callback. Called to check any certificate
    778 SECStatus NSSStreamAdapter::AuthCertificateHook(void *arg,
    779                                                 PRFileDesc *fd,
    780                                                 PRBool checksig,
    781                                                 PRBool isServer) {
    782   LOG(LS_INFO) << "NSSStreamAdapter::AuthCertificateHook";
    783   NSSCertificate peer_cert(SSL_PeerCertificate(fd));
    784   bool ok = false;
    785 
    786   // TODO(ekr (at) rtfm.com): Should we be enforcing self-signed like
    787   // the OpenSSL version?
    788   NSSStreamAdapter *stream = reinterpret_cast<NSSStreamAdapter *>(arg);
    789 
    790   if (stream->peer_certificate_.get()) {
    791     LOG(LS_INFO) << "Checking against specified certificate";
    792 
    793     // The peer certificate was specified
    794     if (reinterpret_cast<NSSCertificate *>(stream->peer_certificate_.get())->
    795         Equals(&peer_cert)) {
    796       LOG(LS_INFO) << "Accepted peer certificate";
    797       ok = true;
    798     }
    799   } else if (!stream->peer_certificate_digest_algorithm_.empty()) {
    800     LOG(LS_INFO) << "Checking against specified digest";
    801     // The peer certificate digest was specified
    802     unsigned char digest[64];  // Maximum size
    803     std::size_t digest_length;
    804 
    805     if (!peer_cert.ComputeDigest(
    806             stream->peer_certificate_digest_algorithm_,
    807             digest, sizeof(digest), &digest_length)) {
    808       LOG(LS_ERROR) << "Digest computation failed";
    809     } else {
    810       Buffer computed_digest(digest, digest_length);
    811       if (computed_digest == stream->peer_certificate_digest_value_) {
    812         LOG(LS_INFO) << "Accepted peer certificate";
    813         ok = true;
    814       }
    815     }
    816   } else {
    817     // Other modes, but we haven't implemented yet
    818     // TODO(ekr (at) rtfm.com): Implement real certificate validation
    819     UNIMPLEMENTED;
    820   }
    821 
    822   if (ok) {
    823     stream->cert_ok_ = true;
    824 
    825     // Record the peer's certificate chain.
    826     CERTCertList* cert_list = SSL_PeerCertificateChain(fd);
    827     ASSERT(cert_list != NULL);
    828 
    829     stream->peer_certificate_.reset(new NSSCertificate(cert_list));
    830     CERT_DestroyCertList(cert_list);
    831     return SECSuccess;
    832   }
    833 
    834   if (!ok && stream->ignore_bad_cert()) {
    835     LOG(LS_WARNING) << "Ignoring cert error while verifying cert chain";
    836     stream->cert_ok_ = true;
    837     return SECSuccess;
    838   }
    839 
    840   PORT_SetError(SEC_ERROR_UNTRUSTED_CERT);
    841   return SECFailure;
    842 }
    843 
    844 
    845 SECStatus NSSStreamAdapter::GetClientAuthDataHook(void *arg, PRFileDesc *fd,
    846                                                   CERTDistNames *caNames,
    847                                                   CERTCertificate **pRetCert,
    848                                                   SECKEYPrivateKey **pRetKey) {
    849   LOG(LS_INFO) << "Client cert requested";
    850   NSSStreamAdapter *stream = reinterpret_cast<NSSStreamAdapter *>(arg);
    851 
    852   if (!stream->identity_.get()) {
    853     LOG(LS_ERROR) << "No identity available";
    854     return SECFailure;
    855   }
    856 
    857   NSSIdentity *identity = static_cast<NSSIdentity *>(stream->identity_.get());
    858   // Destroyed internally by NSS
    859   *pRetCert = CERT_DupCertificate(identity->certificate().certificate());
    860   *pRetKey = SECKEY_CopyPrivateKey(identity->keypair()->privkey());
    861 
    862   return SECSuccess;
    863 }
    864 
    865 // RFC 5705 Key Exporter
    866 bool NSSStreamAdapter::ExportKeyingMaterial(const std::string& label,
    867                                             const uint8* context,
    868                                             size_t context_len,
    869                                             bool use_context,
    870                                             uint8* result,
    871                                             size_t result_len) {
    872   SECStatus rv = SSL_ExportKeyingMaterial(ssl_fd_,
    873                                           label.c_str(), label.size(),
    874                                           use_context,
    875                                           context, context_len,
    876                                           result, result_len);
    877 
    878   return rv == SECSuccess;
    879 }
    880 
    881 bool NSSStreamAdapter::SetDtlsSrtpCiphers(
    882     const std::vector<std::string>& ciphers) {
    883 #ifdef HAVE_DTLS_SRTP
    884   std::vector<PRUint16> internal_ciphers;
    885   if (state_ != SSL_NONE)
    886     return false;
    887 
    888   for (std::vector<std::string>::const_iterator cipher = ciphers.begin();
    889        cipher != ciphers.end(); ++cipher) {
    890     bool found = false;
    891     for (const SrtpCipherMapEntry *entry = kSrtpCipherMap; entry->cipher_id;
    892          ++entry) {
    893       if (*cipher == entry->external_name) {
    894         found = true;
    895         internal_ciphers.push_back(entry->cipher_id);
    896         break;
    897       }
    898     }
    899 
    900     if (!found) {
    901       LOG(LS_ERROR) << "Could not find cipher: " << *cipher;
    902       return false;
    903     }
    904   }
    905 
    906   if (internal_ciphers.empty())
    907     return false;
    908 
    909   srtp_ciphers_ = internal_ciphers;
    910 
    911   return true;
    912 #else
    913   return false;
    914 #endif
    915 }
    916 
    917 bool NSSStreamAdapter::GetDtlsSrtpCipher(std::string* cipher) {
    918 #ifdef HAVE_DTLS_SRTP
    919   ASSERT(state_ == SSL_CONNECTED);
    920   if (state_ != SSL_CONNECTED)
    921     return false;
    922 
    923   PRUint16 selected_cipher;
    924 
    925   SECStatus rv = SSL_GetSRTPCipher(ssl_fd_, &selected_cipher);
    926   if (rv == SECFailure)
    927     return false;
    928 
    929   for (const SrtpCipherMapEntry *entry = kSrtpCipherMap;
    930        entry->cipher_id; ++entry) {
    931     if (selected_cipher == entry->cipher_id) {
    932       *cipher = entry->external_name;
    933       return true;
    934     }
    935   }
    936 
    937   ASSERT(false);  // This should never happen
    938 #endif
    939   return false;
    940 }
    941 
    942 
    943 bool NSSContext::initialized;
    944 NSSContext *NSSContext::global_nss_context;
    945 
    946 // Static initialization and shutdown
    947 NSSContext *NSSContext::Instance() {
    948   if (!global_nss_context) {
    949     NSSContext *new_ctx = new NSSContext();
    950 
    951     if (!(new_ctx->slot_ = PK11_GetInternalSlot())) {
    952       delete new_ctx;
    953       goto fail;
    954     }
    955 
    956     global_nss_context = new_ctx;
    957   }
    958 
    959  fail:
    960   return global_nss_context;
    961 }
    962 
    963 
    964 
    965 bool NSSContext::InitializeSSL(VerificationCallback callback) {
    966   ASSERT(!callback);
    967 
    968   if (!initialized) {
    969     SECStatus rv;
    970 
    971     rv = NSS_NoDB_Init(NULL);
    972     if (rv != SECSuccess) {
    973       LOG(LS_ERROR) << "Couldn't initialize NSS error=" <<
    974           PORT_GetError();
    975       return false;
    976     }
    977 
    978     NSS_SetDomesticPolicy();
    979 
    980     initialized = true;
    981   }
    982 
    983   return true;
    984 }
    985 
    986 bool NSSContext::InitializeSSLThread() {
    987   // Not needed
    988   return true;
    989 }
    990 
    991 bool NSSContext::CleanupSSL() {
    992   // Not needed
    993   return true;
    994 }
    995 
    996 bool NSSStreamAdapter::HaveDtls() {
    997   return true;
    998 }
    999 
   1000 bool NSSStreamAdapter::HaveDtlsSrtp() {
   1001 #ifdef HAVE_DTLS_SRTP
   1002   return true;
   1003 #else
   1004   return false;
   1005 #endif
   1006 }
   1007 
   1008 bool NSSStreamAdapter::HaveExporter() {
   1009   return true;
   1010 }
   1011 
   1012 }  // namespace talk_base
   1013 
   1014 #endif  // HAVE_NSS_SSL_H
   1015