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