Home | History | Annotate | Download | only in base 
      1 /*
      2  * libjingle
      3  * Copyright 2004--2008, Google Inc.
      4  *
      5  * Redistribution and use in source and binary forms, with or without
      6  * modification, are permitted provided that the following conditions are met:
      7  *
      8  *  1. Redistributions of source code must retain the above copyright notice,
      9  *     this list of conditions and the following disclaimer.
     10  *  2. Redistributions in binary form must reproduce the above copyright notice,
     11  *     this list of conditions and the following disclaimer in the documentation
     12  *     and/or other materials provided with the distribution.
     13  *  3. The name of the author may not be used to endorse or promote products
     14  *     derived from this software without specific prior written permission.
     15  *
     16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
     17  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
     18  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
     19  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     20  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
     21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
     22  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
     23  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
     24  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
     25  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     26  */
     27 
     28 #if HAVE_CONFIG_H
     29 #include "config.h"
     30 #endif  // HAVE_CONFIG_H
     31 
     32 #if HAVE_OPENSSL_SSL_H
     33 
     34 #include "talk/base/opensslstreamadapter.h"
     35 
     36 #include <openssl/bio.h>
     37 #include <openssl/crypto.h>
     38 #include <openssl/err.h>
     39 #include <openssl/rand.h>
     40 #include <openssl/ssl.h>
     41 #include <openssl/x509v3.h>
     42 
     43 #include <vector>
     44 
     45 #include "talk/base/common.h"
     46 #include "talk/base/logging.h"
     47 #include "talk/base/stream.h"
     48 #include "talk/base/openssladapter.h"
     49 #include "talk/base/openssldigest.h"
     50 #include "talk/base/opensslidentity.h"
     51 #include "talk/base/stringutils.h"
     52 #include "talk/base/thread.h"
     53 
     54 namespace talk_base {
     55 
     56 #if (OPENSSL_VERSION_NUMBER >= 0x10001000L)
     57 #define HAVE_DTLS_SRTP
     58 #endif
     59 
     60 #if (OPENSSL_VERSION_NUMBER >= 0x10000000L)
     61 #define HAVE_DTLS
     62 #endif
     63 
     64 #ifdef HAVE_DTLS_SRTP
     65 // SRTP cipher suite table
     66 struct SrtpCipherMapEntry {
     67   const char* external_name;
     68   const char* internal_name;
     69 };
     70 
     71 // This isn't elegant, but it's better than an external reference
     72 static SrtpCipherMapEntry SrtpCipherMap[] = {
     73   {"AES_CM_128_HMAC_SHA1_80", "SRTP_AES128_CM_SHA1_80"},
     74   {"AES_CM_128_HMAC_SHA1_32", "SRTP_AES128_CM_SHA1_32"},
     75   {NULL, NULL}
     76 };
     77 #endif
     78 
     79 //////////////////////////////////////////////////////////////////////
     80 // StreamBIO
     81 //////////////////////////////////////////////////////////////////////
     82 
     83 static int stream_write(BIO* h, const char* buf, int num);
     84 static int stream_read(BIO* h, char* buf, int size);
     85 static int stream_puts(BIO* h, const char* str);
     86 static long stream_ctrl(BIO* h, int cmd, long arg1, void* arg2);
     87 static int stream_new(BIO* h);
     88 static int stream_free(BIO* data);
     89 
     90 static BIO_METHOD methods_stream = {
     91   BIO_TYPE_BIO,
     92   "stream",
     93   stream_write,
     94   stream_read,
     95   stream_puts,
     96   0,
     97   stream_ctrl,
     98   stream_new,
     99   stream_free,
    100   NULL,
    101 };
    102 
    103 static BIO_METHOD* BIO_s_stream() { return(&methods_stream); }
    104 
    105 static BIO* BIO_new_stream(StreamInterface* stream) {
    106   BIO* ret = BIO_new(BIO_s_stream());
    107   if (ret == NULL)
    108     return NULL;
    109   ret->ptr = stream;
    110   return ret;
    111 }
    112 
    113 // bio methods return 1 (or at least non-zero) on success and 0 on failure.
    114 
    115 static int stream_new(BIO* b) {
    116   b->shutdown = 0;
    117   b->init = 1;
    118   b->num = 0;  // 1 means end-of-stream
    119   b->ptr = 0;
    120   return 1;
    121 }
    122 
    123 static int stream_free(BIO* b) {
    124   if (b == NULL)
    125     return 0;
    126   return 1;
    127 }
    128 
    129 static int stream_read(BIO* b, char* out, int outl) {
    130   if (!out)
    131     return -1;
    132   StreamInterface* stream = static_cast<StreamInterface*>(b->ptr);
    133   BIO_clear_retry_flags(b);
    134   size_t read;
    135   int error;
    136   StreamResult result = stream->Read(out, outl, &read, &error);
    137   if (result == SR_SUCCESS) {
    138     return read;
    139   } else if (result == SR_EOS) {
    140     b->num = 1;
    141   } else if (result == SR_BLOCK) {
    142     BIO_set_retry_read(b);
    143   }
    144   return -1;
    145 }
    146 
    147 static int stream_write(BIO* b, const char* in, int inl) {
    148   if (!in)
    149     return -1;
    150   StreamInterface* stream = static_cast<StreamInterface*>(b->ptr);
    151   BIO_clear_retry_flags(b);
    152   size_t written;
    153   int error;
    154   StreamResult result = stream->Write(in, inl, &written, &error);
    155   if (result == SR_SUCCESS) {
    156     return written;
    157   } else if (result == SR_BLOCK) {
    158     BIO_set_retry_write(b);
    159   }
    160   return -1;
    161 }
    162 
    163 static int stream_puts(BIO* b, const char* str) {
    164   return stream_write(b, str, strlen(str));
    165 }
    166 
    167 static long stream_ctrl(BIO* b, int cmd, long num, void* ptr) {
    168   UNUSED(num);
    169   UNUSED(ptr);
    170 
    171   switch (cmd) {
    172     case BIO_CTRL_RESET:
    173       return 0;
    174     case BIO_CTRL_EOF:
    175       return b->num;
    176     case BIO_CTRL_WPENDING:
    177     case BIO_CTRL_PENDING:
    178       return 0;
    179     case BIO_CTRL_FLUSH:
    180       return 1;
    181     default:
    182       return 0;
    183   }
    184 }
    185 
    186 /////////////////////////////////////////////////////////////////////////////
    187 // OpenSSLStreamAdapter
    188 /////////////////////////////////////////////////////////////////////////////
    189 
    190 OpenSSLStreamAdapter::OpenSSLStreamAdapter(StreamInterface* stream)
    191     : SSLStreamAdapter(stream),
    192       state_(SSL_NONE),
    193       role_(SSL_CLIENT),
    194       ssl_read_needs_write_(false), ssl_write_needs_read_(false),
    195       ssl_(NULL), ssl_ctx_(NULL),
    196       custom_verification_succeeded_(false),
    197       ssl_mode_(SSL_MODE_TLS) {
    198 }
    199 
    200 OpenSSLStreamAdapter::~OpenSSLStreamAdapter() {
    201   Cleanup();
    202 }
    203 
    204 void OpenSSLStreamAdapter::SetIdentity(SSLIdentity* identity) {
    205   ASSERT(!identity_);
    206   identity_.reset(static_cast<OpenSSLIdentity*>(identity));
    207 }
    208 
    209 void OpenSSLStreamAdapter::SetServerRole(SSLRole role) {
    210   role_ = role;
    211 }
    212 
    213 void OpenSSLStreamAdapter::SetPeerCertificate(SSLCertificate* cert) {
    214   ASSERT(!peer_certificate_);
    215   ASSERT(peer_certificate_digest_algorithm_.empty());
    216   ASSERT(ssl_server_name_.empty());
    217   peer_certificate_.reset(static_cast<OpenSSLCertificate*>(cert));
    218 }
    219 
    220 bool OpenSSLStreamAdapter::GetPeerCertificate(SSLCertificate** cert) const {
    221   if (!peer_certificate_)
    222     return false;
    223 
    224   *cert = peer_certificate_->GetReference();
    225   return true;
    226 }
    227 
    228 bool OpenSSLStreamAdapter::SetPeerCertificateDigest(const std::string
    229                                                     &digest_alg,
    230                                                     const unsigned char*
    231                                                     digest_val,
    232                                                     size_t digest_len) {
    233   ASSERT(!peer_certificate_);
    234   ASSERT(peer_certificate_digest_algorithm_.size() == 0);
    235   ASSERT(ssl_server_name_.empty());
    236   size_t expected_len;
    237 
    238   if (!OpenSSLDigest::GetDigestSize(digest_alg, &expected_len)) {
    239     LOG(LS_WARNING) << "Unknown digest algorithm: " << digest_alg;
    240     return false;
    241   }
    242   if (expected_len != digest_len)
    243     return false;
    244 
    245   peer_certificate_digest_value_.SetData(digest_val, digest_len);
    246   peer_certificate_digest_algorithm_ = digest_alg;
    247 
    248   return true;
    249 }
    250 
    251 // Key Extractor interface
    252 bool OpenSSLStreamAdapter::ExportKeyingMaterial(const std::string& label,
    253                                                 const uint8* context,
    254                                                 size_t context_len,
    255                                                 bool use_context,
    256                                                 uint8* result,
    257                                                 size_t result_len) {
    258 #ifdef HAVE_DTLS_SRTP
    259   int i;
    260 
    261   i = SSL_export_keying_material(ssl_, result, result_len,
    262                                  label.c_str(), label.length(),
    263                                  const_cast<uint8 *>(context),
    264                                  context_len, use_context);
    265 
    266   if (i != 1)
    267     return false;
    268 
    269   return true;
    270 #else
    271   return false;
    272 #endif
    273 }
    274 
    275 bool OpenSSLStreamAdapter::SetDtlsSrtpCiphers(
    276     const std::vector<std::string>& ciphers) {
    277   std::string internal_ciphers;
    278 
    279   if (state_ != SSL_NONE)
    280     return false;
    281 
    282 #ifdef HAVE_DTLS_SRTP
    283   for (std::vector<std::string>::const_iterator cipher = ciphers.begin();
    284        cipher != ciphers.end(); ++cipher) {
    285     bool found = false;
    286     for (SrtpCipherMapEntry *entry = SrtpCipherMap; entry->internal_name;
    287          ++entry) {
    288       if (*cipher == entry->external_name) {
    289         found = true;
    290         if (!internal_ciphers.empty())
    291           internal_ciphers += ":";
    292         internal_ciphers += entry->internal_name;
    293         break;
    294       }
    295     }
    296 
    297     if (!found) {
    298       LOG(LS_ERROR) << "Could not find cipher: " << *cipher;
    299       return false;
    300     }
    301   }
    302 
    303   if (internal_ciphers.empty())
    304     return false;
    305 
    306   srtp_ciphers_ = internal_ciphers;
    307   return true;
    308 #else
    309   return false;
    310 #endif
    311 }
    312 
    313 bool OpenSSLStreamAdapter::GetDtlsSrtpCipher(std::string* cipher) {
    314 #ifdef HAVE_DTLS_SRTP
    315   ASSERT(state_ == SSL_CONNECTED);
    316   if (state_ != SSL_CONNECTED)
    317     return false;
    318 
    319   SRTP_PROTECTION_PROFILE *srtp_profile =
    320       SSL_get_selected_srtp_profile(ssl_);
    321 
    322   if (!srtp_profile)
    323     return false;
    324 
    325   for (SrtpCipherMapEntry *entry = SrtpCipherMap;
    326        entry->internal_name; ++entry) {
    327     if (!strcmp(entry->internal_name, srtp_profile->name)) {
    328       *cipher = entry->external_name;
    329       return true;
    330     }
    331   }
    332 
    333   ASSERT(false);  // This should never happen
    334 
    335   return false;
    336 #else
    337   return false;
    338 #endif
    339 }
    340 
    341 int OpenSSLStreamAdapter::StartSSLWithServer(const char* server_name) {
    342   ASSERT(server_name != NULL && server_name[0] != '\0');
    343   ssl_server_name_ = server_name;
    344   return StartSSL();
    345 }
    346 
    347 int OpenSSLStreamAdapter::StartSSLWithPeer() {
    348   ASSERT(ssl_server_name_.empty());
    349   // It is permitted to specify peer_certificate_ only later.
    350   return StartSSL();
    351 }
    352 
    353 void OpenSSLStreamAdapter::SetMode(SSLMode mode) {
    354   ASSERT(state_ == SSL_NONE);
    355   ssl_mode_ = mode;
    356 }
    357 
    358 //
    359 // StreamInterface Implementation
    360 //
    361 
    362 StreamResult OpenSSLStreamAdapter::Write(const void* data, size_t data_len,
    363                                          size_t* written, int* error) {
    364   LOG(LS_VERBOSE) << "OpenSSLStreamAdapter::Write(" << data_len << ")";
    365 
    366   switch (state_) {
    367   case SSL_NONE:
    368     // pass-through in clear text
    369     return StreamAdapterInterface::Write(data, data_len, written, error);
    370 
    371   case SSL_WAIT:
    372   case SSL_CONNECTING:
    373     return SR_BLOCK;
    374 
    375   case SSL_CONNECTED:
    376     break;
    377 
    378   case SSL_ERROR:
    379   case SSL_CLOSED:
    380   default:
    381     if (error)
    382       *error = ssl_error_code_;
    383     return SR_ERROR;
    384   }
    385 
    386   // OpenSSL will return an error if we try to write zero bytes
    387   if (data_len == 0) {
    388     if (written)
    389       *written = 0;
    390     return SR_SUCCESS;
    391   }
    392 
    393   ssl_write_needs_read_ = false;
    394 
    395   int code = SSL_write(ssl_, data, data_len);
    396   int ssl_error = SSL_get_error(ssl_, code);
    397   switch (ssl_error) {
    398   case SSL_ERROR_NONE:
    399     LOG(LS_VERBOSE) << " -- success";
    400     ASSERT(0 < code && static_cast<unsigned>(code) <= data_len);
    401     if (written)
    402       *written = code;
    403     return SR_SUCCESS;
    404   case SSL_ERROR_WANT_READ:
    405     LOG(LS_VERBOSE) << " -- error want read";
    406     ssl_write_needs_read_ = true;
    407     return SR_BLOCK;
    408   case SSL_ERROR_WANT_WRITE:
    409     LOG(LS_VERBOSE) << " -- error want write";
    410     return SR_BLOCK;
    411 
    412   case SSL_ERROR_ZERO_RETURN:
    413   default:
    414     Error("SSL_write", (ssl_error ? ssl_error : -1), false);
    415     if (error)
    416       *error = ssl_error_code_;
    417     return SR_ERROR;
    418   }
    419   // not reached
    420 }
    421 
    422 StreamResult OpenSSLStreamAdapter::Read(void* data, size_t data_len,
    423                                         size_t* read, int* error) {
    424   LOG(LS_VERBOSE) << "OpenSSLStreamAdapter::Read(" << data_len << ")";
    425   switch (state_) {
    426     case SSL_NONE:
    427       // pass-through in clear text
    428       return StreamAdapterInterface::Read(data, data_len, read, error);
    429 
    430     case SSL_WAIT:
    431     case SSL_CONNECTING:
    432       return SR_BLOCK;
    433 
    434     case SSL_CONNECTED:
    435       break;
    436 
    437     case SSL_CLOSED:
    438       return SR_EOS;
    439 
    440     case SSL_ERROR:
    441     default:
    442       if (error)
    443         *error = ssl_error_code_;
    444       return SR_ERROR;
    445   }
    446 
    447   // Don't trust OpenSSL with zero byte reads
    448   if (data_len == 0) {
    449     if (read)
    450       *read = 0;
    451     return SR_SUCCESS;
    452   }
    453 
    454   ssl_read_needs_write_ = false;
    455 
    456   int code = SSL_read(ssl_, data, data_len);
    457   int ssl_error = SSL_get_error(ssl_, code);
    458   switch (ssl_error) {
    459     case SSL_ERROR_NONE:
    460       LOG(LS_VERBOSE) << " -- success";
    461       ASSERT(0 < code && static_cast<unsigned>(code) <= data_len);
    462       if (read)
    463         *read = code;
    464 
    465       if (ssl_mode_ == SSL_MODE_DTLS) {
    466         // Enforce atomic reads -- this is a short read
    467         unsigned int pending = SSL_pending(ssl_);
    468 
    469         if (pending) {
    470           LOG(LS_INFO) << " -- short DTLS read. flushing";
    471           FlushInput(pending);
    472           if (error)
    473             *error = SSE_MSG_TRUNC;
    474           return SR_ERROR;
    475         }
    476       }
    477       return SR_SUCCESS;
    478     case SSL_ERROR_WANT_READ:
    479       LOG(LS_VERBOSE) << " -- error want read";
    480       return SR_BLOCK;
    481     case SSL_ERROR_WANT_WRITE:
    482       LOG(LS_VERBOSE) << " -- error want write";
    483       ssl_read_needs_write_ = true;
    484       return SR_BLOCK;
    485     case SSL_ERROR_ZERO_RETURN:
    486       LOG(LS_VERBOSE) << " -- remote side closed";
    487       return SR_EOS;
    488       break;
    489     default:
    490       LOG(LS_VERBOSE) << " -- error " << code;
    491       Error("SSL_read", (ssl_error ? ssl_error : -1), false);
    492       if (error)
    493         *error = ssl_error_code_;
    494       return SR_ERROR;
    495   }
    496   // not reached
    497 }
    498 
    499 void OpenSSLStreamAdapter::FlushInput(unsigned int left) {
    500   unsigned char buf[2048];
    501 
    502   while (left) {
    503     // This should always succeed
    504     int toread = (sizeof(buf) < left) ? sizeof(buf) : left;
    505     int code = SSL_read(ssl_, buf, toread);
    506 
    507     int ssl_error = SSL_get_error(ssl_, code);
    508     ASSERT(ssl_error == SSL_ERROR_NONE);
    509 
    510     if (ssl_error != SSL_ERROR_NONE) {
    511       LOG(LS_VERBOSE) << " -- error " << code;
    512       Error("SSL_read", (ssl_error ? ssl_error : -1), false);
    513       return;
    514     }
    515 
    516     LOG(LS_VERBOSE) << " -- flushed " << code << " bytes";
    517     left -= code;
    518   }
    519 }
    520 
    521 void OpenSSLStreamAdapter::Close() {
    522   Cleanup();
    523   ASSERT(state_ == SSL_CLOSED || state_ == SSL_ERROR);
    524   StreamAdapterInterface::Close();
    525 }
    526 
    527 StreamState OpenSSLStreamAdapter::GetState() const {
    528   switch (state_) {
    529     case SSL_WAIT:
    530     case SSL_CONNECTING:
    531       return SS_OPENING;
    532     case SSL_CONNECTED:
    533       return SS_OPEN;
    534     default:
    535       return SS_CLOSED;
    536   };
    537   // not reached
    538 }
    539 
    540 void OpenSSLStreamAdapter::OnEvent(StreamInterface* stream, int events,
    541                                    int err) {
    542   int events_to_signal = 0;
    543   int signal_error = 0;
    544   ASSERT(stream == this->stream());
    545   if ((events & SE_OPEN)) {
    546     LOG(LS_VERBOSE) << "OpenSSLStreamAdapter::OnEvent SE_OPEN";
    547     if (state_ != SSL_WAIT) {
    548       ASSERT(state_ == SSL_NONE);
    549       events_to_signal |= SE_OPEN;
    550     } else {
    551       state_ = SSL_CONNECTING;
    552       if (int err = BeginSSL()) {
    553         Error("BeginSSL", err, true);
    554         return;
    555       }
    556     }
    557   }
    558   if ((events & (SE_READ|SE_WRITE))) {
    559     LOG(LS_VERBOSE) << "OpenSSLStreamAdapter::OnEvent"
    560                  << ((events & SE_READ) ? " SE_READ" : "")
    561                  << ((events & SE_WRITE) ? " SE_WRITE" : "");
    562     if (state_ == SSL_NONE) {
    563       events_to_signal |= events & (SE_READ|SE_WRITE);
    564     } else if (state_ == SSL_CONNECTING) {
    565       if (int err = ContinueSSL()) {
    566         Error("ContinueSSL", err, true);
    567         return;
    568       }
    569     } else if (state_ == SSL_CONNECTED) {
    570       if (((events & SE_READ) && ssl_write_needs_read_) ||
    571           (events & SE_WRITE)) {
    572         LOG(LS_VERBOSE) << " -- onStreamWriteable";
    573         events_to_signal |= SE_WRITE;
    574       }
    575       if (((events & SE_WRITE) && ssl_read_needs_write_) ||
    576           (events & SE_READ)) {
    577         LOG(LS_VERBOSE) << " -- onStreamReadable";
    578         events_to_signal |= SE_READ;
    579       }
    580     }
    581   }
    582   if ((events & SE_CLOSE)) {
    583     LOG(LS_VERBOSE) << "OpenSSLStreamAdapter::OnEvent(SE_CLOSE, " << err << ")";
    584     Cleanup();
    585     events_to_signal |= SE_CLOSE;
    586     // SE_CLOSE is the only event that uses the final parameter to OnEvent().
    587     ASSERT(signal_error == 0);
    588     signal_error = err;
    589   }
    590   if (events_to_signal)
    591     StreamAdapterInterface::OnEvent(stream, events_to_signal, signal_error);
    592 }
    593 
    594 int OpenSSLStreamAdapter::StartSSL() {
    595   ASSERT(state_ == SSL_NONE);
    596 
    597   if (StreamAdapterInterface::GetState() != SS_OPEN) {
    598     state_ = SSL_WAIT;
    599     return 0;
    600   }
    601 
    602   state_ = SSL_CONNECTING;
    603   if (int err = BeginSSL()) {
    604     Error("BeginSSL", err, false);
    605     return err;
    606   }
    607 
    608   return 0;
    609 }
    610 
    611 int OpenSSLStreamAdapter::BeginSSL() {
    612   ASSERT(state_ == SSL_CONNECTING);
    613   // The underlying stream has open. If we are in peer-to-peer mode
    614   // then a peer certificate must have been specified by now.
    615   ASSERT(!ssl_server_name_.empty() ||
    616          peer_certificate_ ||
    617          !peer_certificate_digest_algorithm_.empty());
    618   LOG(LS_INFO) << "BeginSSL: "
    619                << (!ssl_server_name_.empty() ? ssl_server_name_ :
    620                                                "with peer");
    621 
    622   BIO* bio = NULL;
    623 
    624   // First set up the context
    625   ASSERT(ssl_ctx_ == NULL);
    626   ssl_ctx_ = SetupSSLContext();
    627   if (!ssl_ctx_)
    628     return -1;
    629 
    630   bio = BIO_new_stream(static_cast<StreamInterface*>(stream()));
    631   if (!bio)
    632     return -1;
    633 
    634   ssl_ = SSL_new(ssl_ctx_);
    635   if (!ssl_) {
    636     BIO_free(bio);
    637     return -1;
    638   }
    639 
    640   SSL_set_app_data(ssl_, this);
    641 
    642   SSL_set_bio(ssl_, bio, bio);  // the SSL object owns the bio now.
    643 
    644   SSL_set_mode(ssl_, SSL_MODE_ENABLE_PARTIAL_WRITE |
    645                SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);
    646 
    647   // Do the connect
    648   return ContinueSSL();
    649 }
    650 
    651 int OpenSSLStreamAdapter::ContinueSSL() {
    652   LOG(LS_VERBOSE) << "ContinueSSL";
    653   ASSERT(state_ == SSL_CONNECTING);
    654 
    655   // Clear the DTLS timer
    656   Thread::Current()->Clear(this, MSG_TIMEOUT);
    657 
    658   int code = (role_ == SSL_CLIENT) ? SSL_connect(ssl_) : SSL_accept(ssl_);
    659   int ssl_error;
    660   switch (ssl_error = SSL_get_error(ssl_, code)) {
    661     case SSL_ERROR_NONE:
    662       LOG(LS_VERBOSE) << " -- success";
    663 
    664       if (!SSLPostConnectionCheck(ssl_, ssl_server_name_.c_str(),
    665                                   peer_certificate_ ?
    666                                       peer_certificate_->x509() : NULL,
    667                                   peer_certificate_digest_algorithm_)) {
    668         LOG(LS_ERROR) << "TLS post connection check failed";
    669         return -1;
    670       }
    671 
    672       state_ = SSL_CONNECTED;
    673       StreamAdapterInterface::OnEvent(stream(), SE_OPEN|SE_READ|SE_WRITE, 0);
    674       break;
    675 
    676     case SSL_ERROR_WANT_READ: {
    677         LOG(LS_VERBOSE) << " -- error want read";
    678 #ifdef HAVE_DTLS
    679         struct timeval timeout;
    680         if (DTLSv1_get_timeout(ssl_, &timeout)) {
    681           int delay = timeout.tv_sec * 1000 + timeout.tv_usec/1000;
    682 
    683           Thread::Current()->PostDelayed(delay, this, MSG_TIMEOUT, 0);
    684         }
    685 #endif
    686       }
    687       break;
    688 
    689     case SSL_ERROR_WANT_WRITE:
    690       LOG(LS_VERBOSE) << " -- error want write";
    691       break;
    692 
    693     case SSL_ERROR_ZERO_RETURN:
    694     default:
    695       LOG(LS_VERBOSE) << " -- error " << code;
    696       return (ssl_error != 0) ? ssl_error : -1;
    697   }
    698 
    699   return 0;
    700 }
    701 
    702 void OpenSSLStreamAdapter::Error(const char* context, int err, bool signal) {
    703   LOG(LS_WARNING) << "OpenSSLStreamAdapter::Error("
    704                   << context << ", " << err << ")";
    705   state_ = SSL_ERROR;
    706   ssl_error_code_ = err;
    707   Cleanup();
    708   if (signal)
    709     StreamAdapterInterface::OnEvent(stream(), SE_CLOSE, err);
    710 }
    711 
    712 void OpenSSLStreamAdapter::Cleanup() {
    713   LOG(LS_INFO) << "Cleanup";
    714 
    715   if (state_ != SSL_ERROR) {
    716     state_ = SSL_CLOSED;
    717     ssl_error_code_ = 0;
    718   }
    719 
    720   if (ssl_) {
    721     SSL_free(ssl_);
    722     ssl_ = NULL;
    723   }
    724   if (ssl_ctx_) {
    725     SSL_CTX_free(ssl_ctx_);
    726     ssl_ctx_ = NULL;
    727   }
    728   identity_.reset();
    729   peer_certificate_.reset();
    730 
    731   // Clear the DTLS timer
    732   Thread::Current()->Clear(this, MSG_TIMEOUT);
    733 }
    734 
    735 
    736 void OpenSSLStreamAdapter::OnMessage(Message* msg) {
    737   // Process our own messages and then pass others to the superclass
    738   if (MSG_TIMEOUT == msg->message_id) {
    739     LOG(LS_INFO) << "DTLS timeout expired";
    740 #ifdef HAVE_DTLS
    741     DTLSv1_handle_timeout(ssl_);
    742 #endif
    743     ContinueSSL();
    744   } else {
    745     StreamInterface::OnMessage(msg);
    746   }
    747 }
    748 
    749 SSL_CTX* OpenSSLStreamAdapter::SetupSSLContext() {
    750   SSL_CTX *ctx = NULL;
    751 
    752   if (role_ == SSL_CLIENT) {
    753 #ifdef HAVE_DTLS
    754     ctx = SSL_CTX_new(ssl_mode_ == SSL_MODE_DTLS ?
    755         DTLSv1_client_method() : TLSv1_client_method());
    756 #else
    757     ctx = SSL_CTX_new(TLSv1_client_method());
    758 #endif
    759   } else {
    760 #ifdef HAVE_DTLS
    761     ctx = SSL_CTX_new(ssl_mode_ == SSL_MODE_DTLS ?
    762         DTLSv1_server_method() : TLSv1_server_method());
    763 #else
    764     ctx = SSL_CTX_new(TLSv1_server_method());
    765 #endif
    766   }
    767   if (ctx == NULL)
    768     return NULL;
    769 
    770   if (identity_ && !identity_->ConfigureIdentity(ctx)) {
    771     SSL_CTX_free(ctx);
    772     return NULL;
    773   }
    774 
    775   if (!peer_certificate_) {  // traditional mode
    776     // Add the root cert to the SSL context
    777     if (!OpenSSLAdapter::ConfigureTrustedRootCertificates(ctx)) {
    778       SSL_CTX_free(ctx);
    779       return NULL;
    780     }
    781   }
    782 
    783   if (peer_certificate_ && role_ == SSL_SERVER)
    784     // we must specify which client cert to ask for
    785     SSL_CTX_add_client_CA(ctx, peer_certificate_->x509());
    786 
    787 #ifdef _DEBUG
    788   SSL_CTX_set_info_callback(ctx, OpenSSLAdapter::SSLInfoCallback);
    789 #endif
    790 
    791   SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER |SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
    792                      SSLVerifyCallback);
    793   SSL_CTX_set_verify_depth(ctx, 4);
    794   SSL_CTX_set_cipher_list(ctx, "ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
    795 
    796 #ifdef HAVE_DTLS_SRTP
    797   if (!srtp_ciphers_.empty()) {
    798     if (SSL_CTX_set_tlsext_use_srtp(ctx, srtp_ciphers_.c_str())) {
    799       SSL_CTX_free(ctx);
    800       return NULL;
    801     }
    802   }
    803 #endif
    804 
    805   return ctx;
    806 }
    807 
    808 int OpenSSLStreamAdapter::SSLVerifyCallback(int ok, X509_STORE_CTX* store) {
    809 #if _DEBUG
    810   if (!ok) {
    811     char data[256];
    812     X509* cert = X509_STORE_CTX_get_current_cert(store);
    813     int depth = X509_STORE_CTX_get_error_depth(store);
    814     int err = X509_STORE_CTX_get_error(store);
    815 
    816     LOG(LS_INFO) << "Error with certificate at depth: " << depth;
    817     X509_NAME_oneline(X509_get_issuer_name(cert), data, sizeof(data));
    818     LOG(LS_INFO) << "  issuer  = " << data;
    819     X509_NAME_oneline(X509_get_subject_name(cert), data, sizeof(data));
    820     LOG(LS_INFO) << "  subject = " << data;
    821     LOG(LS_INFO) << "  err     = " << err
    822       << ":" << X509_verify_cert_error_string(err);
    823   }
    824 #endif
    825 
    826   // Get our SSL structure from the store
    827   SSL* ssl = reinterpret_cast<SSL*>(X509_STORE_CTX_get_ex_data(
    828                                         store,
    829                                         SSL_get_ex_data_X509_STORE_CTX_idx()));
    830 
    831   OpenSSLStreamAdapter* stream =
    832     reinterpret_cast<OpenSSLStreamAdapter*>(SSL_get_app_data(ssl));
    833 
    834   // In peer-to-peer mode, no root cert / certificate authority was
    835   // specified, so the libraries knows of no certificate to accept,
    836   // and therefore it will necessarily call here on the first cert it
    837   // tries to verify.
    838   if (!ok && stream->peer_certificate_) {
    839     X509* cert = X509_STORE_CTX_get_current_cert(store);
    840     int err = X509_STORE_CTX_get_error(store);
    841     // peer-to-peer mode: allow the certificate to be self-signed,
    842     // assuming it matches the cert that was specified.
    843     if (err == X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT &&
    844         X509_cmp(cert, stream->peer_certificate_->x509()) == 0) {
    845       LOG(LS_INFO) << "Accepted self-signed peer certificate authority";
    846       ok = 1;
    847     }
    848   } else if (!ok && !stream->peer_certificate_digest_algorithm_.empty()) {
    849     X509* cert = X509_STORE_CTX_get_current_cert(store);
    850     int err = X509_STORE_CTX_get_error(store);
    851 
    852     // peer-to-peer mode: allow the certificate to be self-signed,
    853     // assuming it matches the digest that was specified.
    854     if (err == X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT) {
    855       unsigned char digest[EVP_MAX_MD_SIZE];
    856       std::size_t digest_length;
    857 
    858       if (OpenSSLCertificate::
    859          ComputeDigest(cert,
    860                        stream->peer_certificate_digest_algorithm_,
    861                        digest, sizeof(digest),
    862                        &digest_length)) {
    863         Buffer computed_digest(digest, digest_length);
    864         if (computed_digest == stream->peer_certificate_digest_value_) {
    865           LOG(LS_INFO) <<
    866               "Accepted self-signed peer certificate authority";
    867           ok = 1;
    868 
    869           // Record the peer's certificate.
    870           stream->peer_certificate_.reset(new OpenSSLCertificate(cert));
    871         }
    872       }
    873     }
    874   } else if (!ok && OpenSSLAdapter::custom_verify_callback_) {
    875     // this applies only in traditional mode
    876     void* cert =
    877         reinterpret_cast<void*>(X509_STORE_CTX_get_current_cert(store));
    878     if (OpenSSLAdapter::custom_verify_callback_(cert)) {
    879       stream->custom_verification_succeeded_ = true;
    880       LOG(LS_INFO) << "validated certificate using custom callback";
    881       ok = 1;
    882     }
    883   }
    884 
    885   if (!ok && stream->ignore_bad_cert()) {
    886     LOG(LS_WARNING) << "Ignoring cert error while verifying cert chain";
    887     ok = 1;
    888   }
    889 
    890   return ok;
    891 }
    892 
    893 // This code is taken from the "Network Security with OpenSSL"
    894 // sample in chapter 5
    895 bool OpenSSLStreamAdapter::SSLPostConnectionCheck(SSL* ssl,
    896                                                   const char* server_name,
    897                                                   const X509* peer_cert,
    898                                                   const std::string
    899                                                   &peer_digest) {
    900   ASSERT(server_name != NULL);
    901   bool ok;
    902   if (server_name[0] != '\0') {  // traditional mode
    903     ok = OpenSSLAdapter::VerifyServerName(ssl, server_name, ignore_bad_cert());
    904 
    905     if (ok) {
    906       ok = (SSL_get_verify_result(ssl) == X509_V_OK ||
    907             custom_verification_succeeded_);
    908     }
    909   } else {  // peer-to-peer mode
    910     ASSERT((peer_cert != NULL) || (!peer_digest.empty()));
    911     // no server name validation
    912     ok = true;
    913   }
    914 
    915   if (!ok && ignore_bad_cert()) {
    916     LOG(LS_ERROR) << "SSL_get_verify_result(ssl) = "
    917                   << SSL_get_verify_result(ssl);
    918     LOG(LS_INFO) << "Other TLS post connection checks failed.";
    919     ok = true;
    920   }
    921 
    922   return ok;
    923 }
    924 
    925 bool OpenSSLStreamAdapter::HaveDtls() {
    926 #ifdef HAVE_DTLS
    927   return true;
    928 #else
    929   return false;
    930 #endif
    931 }
    932 
    933 bool OpenSSLStreamAdapter::HaveDtlsSrtp() {
    934 #ifdef HAVE_DTLS_SRTP
    935   return true;
    936 #else
    937   return false;
    938 #endif
    939 }
    940 
    941 bool OpenSSLStreamAdapter::HaveExporter() {
    942 #ifdef HAVE_DTLS_SRTP
    943   return true;
    944 #else
    945   return false;
    946 #endif
    947 }
    948 
    949 }  // namespace talk_base
    950 
    951 #endif  // HAVE_OPENSSL_SSL_H
    952