src/third_party/webrtc/base/openssladapter.cc

   1 /*
   2  *  Copyright 2008 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_OPENSSL_SSL_H
  12
  13 #include "webrtc/base/openssladapter.h"
  14
  15 #if defined(WEBRTC_POSIX)
  16 #include <unistd.h>
  17 #endif
  18
  19 // Must be included first before openssl headers.
  20 #include "webrtc/base/win32.h"  // NOLINT
  21
  22 #include <openssl/bio.h>
  23 #include <openssl/crypto.h>
  24 #include <openssl/err.h>
  25 #include <openssl/opensslv.h>
  26 #include <openssl/rand.h>
  27 #include <openssl/x509.h>
  28 #include <openssl/x509v3.h>
  29
  30 #if HAVE_CONFIG_H
  31 #include "config.h"
  32 #endif  // HAVE_CONFIG_H
  33
  34 #include "webrtc/base/common.h"
  35 #include "webrtc/base/logging.h"
  36 #include "webrtc/base/openssl.h"
  37 #include "webrtc/base/safe_conversions.h"
  38 #include "webrtc/base/sslroots.h"
  39 #include "webrtc/base/stringutils.h"
  40
  41 // TODO: Use a nicer abstraction for mutex.
  42
  43 #if defined(WEBRTC_WIN)
  44   #define MUTEX_TYPE HANDLE
  45   #define MUTEX_SETUP(x) (x) = CreateMutex(NULL, FALSE, NULL)
  46   #define MUTEX_CLEANUP(x) CloseHandle(x)
  47   #define MUTEX_LOCK(x) WaitForSingleObject((x), INFINITE)
  48   #define MUTEX_UNLOCK(x) ReleaseMutex(x)
  49   #define THREAD_ID GetCurrentThreadId()
  50 #elif defined(WEBRTC_POSIX)
  51   #define MUTEX_TYPE pthread_mutex_t
  52   #define MUTEX_SETUP(x) pthread_mutex_init(&(x), NULL)
  53   #define MUTEX_CLEANUP(x) pthread_mutex_destroy(&(x))
  54   #define MUTEX_LOCK(x) pthread_mutex_lock(&(x))
  55   #define MUTEX_UNLOCK(x) pthread_mutex_unlock(&(x))
  56   #define THREAD_ID pthread_self()
  57 #else
  58   #error You must define mutex operations appropriate for your platform!
  59 #endif
  60
  61 struct CRYPTO_dynlock_value {
  62   MUTEX_TYPE mutex;
  63 };
  64
  65 //////////////////////////////////////////////////////////////////////
  66 // SocketBIO
  67 //////////////////////////////////////////////////////////////////////
  68
  69 static int socket_write(BIO* h, const char* buf, int num);
  70 static int socket_read(BIO* h, char* buf, int size);
  71 static int socket_puts(BIO* h, const char* str);
  72 static long socket_ctrl(BIO* h, int cmd, long arg1, void* arg2);
  73 static int socket_new(BIO* h);
  74 static int socket_free(BIO* data);
  75
  76 static BIO_METHOD methods_socket = {
  77   BIO_TYPE_BIO,
  78   "socket",
  79   socket_write,
  80   socket_read,
  81   socket_puts,
  82   0,
  83   socket_ctrl,
  84   socket_new,
  85   socket_free,
  86   NULL,
  87 };
  88
  89 static BIO_METHOD* BIO_s_socket2() { return(&methods_socket); }
  90
  91 static BIO* BIO_new_socket(rtc::AsyncSocket* socket) {
  92   BIO* ret = BIO_new(BIO_s_socket2());
  93   if (ret == NULL) {
  94           return NULL;
  95   }
  96   ret->ptr = socket;
  97   return ret;
  98 }
  99
 100 static int socket_new(BIO* b) {
 101   b->shutdown = 0;
 102   b->init = 1;
 103   b->num = 0; // 1 means socket closed
 104   b->ptr = 0;
 105   return 1;
 106 }
 107
 108 static int socket_free(BIO* b) {
 109   if (b == NULL)
 110     return 0;
 111   return 1;
 112 }
 113
 114 static int socket_read(BIO* b, char* out, int outl) {
 115   if (!out)
 116     return -1;
 117   rtc::AsyncSocket* socket = static_cast<rtc::AsyncSocket*>(b->ptr);
 118   BIO_clear_retry_flags(b);
 119   int result = socket->Recv(out, outl);
 120   if (result > 0) {
 121     return result;
 122   } else if (result == 0) {
 123     b->num = 1;
 124   } else if (socket->IsBlocking()) {
 125     BIO_set_retry_read(b);
 126   }
 127   return -1;
 128 }
 129
 130 static int socket_write(BIO* b, const char* in, int inl) {
 131   if (!in)
 132     return -1;
 133   rtc::AsyncSocket* socket = static_cast<rtc::AsyncSocket*>(b->ptr);
 134   BIO_clear_retry_flags(b);
 135   int result = socket->Send(in, inl);
 136   if (result > 0) {
 137     return result;
 138   } else if (socket->IsBlocking()) {
 139     BIO_set_retry_write(b);
 140   }
 141   return -1;
 142 }
 143
 144 static int socket_puts(BIO* b, const char* str) {
 145   return socket_write(b, str, rtc::checked_cast<int>(strlen(str)));
 146 }
 147
 148 static long socket_ctrl(BIO* b, int cmd, long num, void* ptr) {
 149   RTC_UNUSED(num);
 150   RTC_UNUSED(ptr);
 151
 152   switch (cmd) {
 153   case BIO_CTRL_RESET:
 154     return 0;
 155   case BIO_CTRL_EOF:
 156     return b->num;
 157   case BIO_CTRL_WPENDING:
 158   case BIO_CTRL_PENDING:
 159     return 0;
 160   case BIO_CTRL_FLUSH:
 161     return 1;
 162   default:
 163     return 0;
 164   }
 165 }
 166
 167 /////////////////////////////////////////////////////////////////////////////
 168 // OpenSSLAdapter
 169 /////////////////////////////////////////////////////////////////////////////
 170
 171 namespace rtc {
 172
 173 // This array will store all of the mutexes available to OpenSSL.
 174 static MUTEX_TYPE* mutex_buf = NULL;
 175
 176 static void locking_function(int mode, int n, const char * file, int line) {
 177   if (mode & CRYPTO_LOCK) {
 178     MUTEX_LOCK(mutex_buf[n]);
 179   } else {
 180     MUTEX_UNLOCK(mutex_buf[n]);
 181   }
 182 }
 183
 184 static unsigned long id_function() {  // NOLINT
 185   // Use old-style C cast because THREAD_ID's type varies with the platform,
 186   // in some cases requiring static_cast, and in others requiring
 187   // reinterpret_cast.
 188   return (unsigned long)THREAD_ID; // NOLINT
 189 }
 190
 191 static CRYPTO_dynlock_value* dyn_create_function(const char* file, int line) {
 192   CRYPTO_dynlock_value* value = new CRYPTO_dynlock_value;
 193   if (!value)
 194     return NULL;
 195   MUTEX_SETUP(value->mutex);
 196   return value;
 197 }
 198
 199 static void dyn_lock_function(int mode, CRYPTO_dynlock_value* l,
 200                               const char* file, int line) {
 201   if (mode & CRYPTO_LOCK) {
 202     MUTEX_LOCK(l->mutex);
 203   } else {
 204     MUTEX_UNLOCK(l->mutex);
 205   }
 206 }
 207
 208 static void dyn_destroy_function(CRYPTO_dynlock_value* l,
 209                                  const char* file, int line) {
 210   MUTEX_CLEANUP(l->mutex);
 211   delete l;
 212 }
 213
 214 VerificationCallback OpenSSLAdapter::custom_verify_callback_ = NULL;
 215
 216 bool OpenSSLAdapter::InitializeSSL(VerificationCallback callback) {
 217   if (!InitializeSSLThread() || !SSL_library_init())
 218       return false;
 219 #if !defined(ADDRESS_SANITIZER) || !defined(WEBRTC_MAC) || defined(WEBRTC_IOS)
 220   // Loading the error strings crashes mac_asan.  Omit this debugging aid there.
 221   SSL_load_error_strings();
 222 #endif
 223   ERR_load_BIO_strings();
 224   OpenSSL_add_all_algorithms();
 225   RAND_poll();
 226   custom_verify_callback_ = callback;
 227   return true;
 228 }
 229
 230 bool OpenSSLAdapter::InitializeSSLThread() {
 231   mutex_buf = new MUTEX_TYPE[CRYPTO_num_locks()];
 232   if (!mutex_buf)
 233     return false;
 234   for (int i = 0; i < CRYPTO_num_locks(); ++i)
 235     MUTEX_SETUP(mutex_buf[i]);
 236
 237   // we need to cast our id_function to return an unsigned long -- pthread_t is
 238   // a pointer
 239   CRYPTO_set_id_callback(id_function);
 240   CRYPTO_set_locking_callback(locking_function);
 241   CRYPTO_set_dynlock_create_callback(dyn_create_function);
 242   CRYPTO_set_dynlock_lock_callback(dyn_lock_function);
 243   CRYPTO_set_dynlock_destroy_callback(dyn_destroy_function);
 244   return true;
 245 }
 246
 247 bool OpenSSLAdapter::CleanupSSL() {
 248   if (!mutex_buf)
 249     return false;
 250   CRYPTO_set_id_callback(NULL);
 251   CRYPTO_set_locking_callback(NULL);
 252   CRYPTO_set_dynlock_create_callback(NULL);
 253   CRYPTO_set_dynlock_lock_callback(NULL);
 254   CRYPTO_set_dynlock_destroy_callback(NULL);
 255   for (int i = 0; i < CRYPTO_num_locks(); ++i)
 256     MUTEX_CLEANUP(mutex_buf[i]);
 257   delete [] mutex_buf;
 258   mutex_buf = NULL;
 259   return true;
 260 }
 261
 262 OpenSSLAdapter::OpenSSLAdapter(AsyncSocket* socket)
 263   : SSLAdapter(socket),
 264     state_(SSL_NONE),
 265     ssl_read_needs_write_(false),
 266     ssl_write_needs_read_(false),
 267     restartable_(false),
 268     ssl_(NULL), ssl_ctx_(NULL),
 269     custom_verification_succeeded_(false) {
 270 }
 271
 272 OpenSSLAdapter::~OpenSSLAdapter() {
 273   Cleanup();
 274 }
 275
 276 int
 277 OpenSSLAdapter::StartSSL(const char* hostname, bool restartable) {
 278   if (state_ != SSL_NONE)
 279     return -1;
 280
 281   ssl_host_name_ = hostname;
 282   restartable_ = restartable;
 283
 284   if (socket_->GetState() != Socket::CS_CONNECTED) {
 285     state_ = SSL_WAIT;
 286     return 0;
 287   }
 288
 289   state_ = SSL_CONNECTING;
 290   if (int err = BeginSSL()) {
 291     Error("BeginSSL", err, false);
 292     return err;
 293   }
 294
 295   return 0;
 296 }
 297
 298 int
 299 OpenSSLAdapter::BeginSSL() {
 300   LOG(LS_INFO) << "BeginSSL: " << ssl_host_name_;
 301   ASSERT(state_ == SSL_CONNECTING);
 302
 303   int err = 0;
 304   BIO* bio = NULL;
 305
 306   // First set up the context
 307   if (!ssl_ctx_)
 308     ssl_ctx_ = SetupSSLContext();
 309
 310   if (!ssl_ctx_) {
 311     err = -1;
 312     goto ssl_error;
 313   }
 314
 315   bio = BIO_new_socket(static_cast<AsyncSocketAdapter*>(socket_));
 316   if (!bio) {
 317     err = -1;
 318     goto ssl_error;
 319   }
 320
 321   ssl_ = SSL_new(ssl_ctx_);
 322   if (!ssl_) {
 323     err = -1;
 324     goto ssl_error;
 325   }
 326
 327   SSL_set_app_data(ssl_, this);
 328
 329   SSL_set_bio(ssl_, bio, bio);
 330   SSL_set_mode(ssl_, SSL_MODE_ENABLE_PARTIAL_WRITE |
 331                      SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);
 332
 333   // the SSL object owns the bio now
 334   bio = NULL;
 335
 336   // Do the connect
 337   err = ContinueSSL();
 338   if (err != 0)
 339     goto ssl_error;
 340
 341   return err;
 342
 343 ssl_error:
 344   Cleanup();
 345   if (bio)
 346     BIO_free(bio);
 347
 348   return err;
 349 }
 350
 351 int
 352 OpenSSLAdapter::ContinueSSL() {
 353   ASSERT(state_ == SSL_CONNECTING);
 354
 355   int code = SSL_connect(ssl_);
 356   switch (SSL_get_error(ssl_, code)) {
 357   case SSL_ERROR_NONE:
 358     if (!SSLPostConnectionCheck(ssl_, ssl_host_name_.c_str())) {
 359       LOG(LS_ERROR) << "TLS post connection check failed";
 360       // make sure we close the socket
 361       Cleanup();
 362       // The connect failed so return -1 to shut down the socket
 363       return -1;
 364     }
 365
 366     state_ = SSL_CONNECTED;
 367     AsyncSocketAdapter::OnConnectEvent(this);
 368 #if 0  // TODO: worry about this
 369     // Don't let ourselves go away during the callbacks
 370     PRefPtr<OpenSSLAdapter> lock(this);
 371     LOG(LS_INFO) << " -- onStreamReadable";
 372     AsyncSocketAdapter::OnReadEvent(this);
 373     LOG(LS_INFO) << " -- onStreamWriteable";
 374     AsyncSocketAdapter::OnWriteEvent(this);
 375 #endif
 376     break;
 377
 378   case SSL_ERROR_WANT_READ:
 379   case SSL_ERROR_WANT_WRITE:
 380     break;
 381
 382   case SSL_ERROR_ZERO_RETURN:
 383   default:
 384     LOG(LS_WARNING) << "ContinueSSL -- error " << code;
 385     return (code != 0) ? code : -1;
 386   }
 387
 388   return 0;
 389 }
 390
 391 void
 392 OpenSSLAdapter::Error(const char* context, int err, bool signal) {
 393   LOG(LS_WARNING) << "OpenSSLAdapter::Error("
 394                   << context << ", " << err << ")";
 395   state_ = SSL_ERROR;
 396   SetError(err);
 397   if (signal)
 398     AsyncSocketAdapter::OnCloseEvent(this, err);
 399 }
 400
 401 void
 402 OpenSSLAdapter::Cleanup() {
 403   LOG(LS_INFO) << "Cleanup";
 404
 405   state_ = SSL_NONE;
 406   ssl_read_needs_write_ = false;
 407   ssl_write_needs_read_ = false;
 408   custom_verification_succeeded_ = false;
 409
 410   if (ssl_) {
 411     SSL_free(ssl_);
 412     ssl_ = NULL;
 413   }
 414
 415   if (ssl_ctx_) {
 416     SSL_CTX_free(ssl_ctx_);
 417     ssl_ctx_ = NULL;
 418   }
 419 }
 420
 421 //
 422 // AsyncSocket Implementation
 423 //
 424
 425 int
 426 OpenSSLAdapter::Send(const void* pv, size_t cb) {
 427   //LOG(LS_INFO) << "OpenSSLAdapter::Send(" << cb << ")";
 428
 429   switch (state_) {
 430   case SSL_NONE:
 431     return AsyncSocketAdapter::Send(pv, cb);
 432
 433   case SSL_WAIT:
 434   case SSL_CONNECTING:
 435     SetError(EWOULDBLOCK);
 436     return SOCKET_ERROR;
 437
 438   case SSL_CONNECTED:
 439     break;
 440
 441   case SSL_ERROR:
 442   default:
 443     return SOCKET_ERROR;
 444   }
 445
 446   // OpenSSL will return an error if we try to write zero bytes
 447   if (cb == 0)
 448     return 0;
 449
 450   ssl_write_needs_read_ = false;
 451
 452   int code = SSL_write(ssl_, pv, checked_cast<int>(cb));
 453   switch (SSL_get_error(ssl_, code)) {
 454   case SSL_ERROR_NONE:
 455     //LOG(LS_INFO) << " -- success";
 456     return code;
 457   case SSL_ERROR_WANT_READ:
 458     //LOG(LS_INFO) << " -- error want read";
 459     ssl_write_needs_read_ = true;
 460     SetError(EWOULDBLOCK);
 461     break;
 462   case SSL_ERROR_WANT_WRITE:
 463     //LOG(LS_INFO) << " -- error want write";
 464     SetError(EWOULDBLOCK);
 465     break;
 466   case SSL_ERROR_ZERO_RETURN:
 467     //LOG(LS_INFO) << " -- remote side closed";
 468     SetError(EWOULDBLOCK);
 469     // do we need to signal closure?
 470     break;
 471   default:
 472     //LOG(LS_INFO) << " -- error " << code;
 473     Error("SSL_write", (code ? code : -1), false);
 474     break;
 475   }
 476
 477   return SOCKET_ERROR;
 478 }
 479
 480 int
 481 OpenSSLAdapter::Recv(void* pv, size_t cb) {
 482   //LOG(LS_INFO) << "OpenSSLAdapter::Recv(" << cb << ")";
 483   switch (state_) {
 484
 485   case SSL_NONE:
 486     return AsyncSocketAdapter::Recv(pv, cb);
 487
 488   case SSL_WAIT:
 489   case SSL_CONNECTING:
 490     SetError(EWOULDBLOCK);
 491     return SOCKET_ERROR;
 492
 493   case SSL_CONNECTED:
 494     break;
 495
 496   case SSL_ERROR:
 497   default:
 498     return SOCKET_ERROR;
 499   }
 500
 501   // Don't trust OpenSSL with zero byte reads
 502   if (cb == 0)
 503     return 0;
 504
 505   ssl_read_needs_write_ = false;
 506
 507   int code = SSL_read(ssl_, pv, checked_cast<int>(cb));
 508   switch (SSL_get_error(ssl_, code)) {
 509   case SSL_ERROR_NONE:
 510     //LOG(LS_INFO) << " -- success";
 511     return code;
 512   case SSL_ERROR_WANT_READ:
 513     //LOG(LS_INFO) << " -- error want read";
 514     SetError(EWOULDBLOCK);
 515     break;
 516   case SSL_ERROR_WANT_WRITE:
 517     //LOG(LS_INFO) << " -- error want write";
 518     ssl_read_needs_write_ = true;
 519     SetError(EWOULDBLOCK);
 520     break;
 521   case SSL_ERROR_ZERO_RETURN:
 522     //LOG(LS_INFO) << " -- remote side closed";
 523     SetError(EWOULDBLOCK);
 524     // do we need to signal closure?
 525     break;
 526   default:
 527     //LOG(LS_INFO) << " -- error " << code;
 528     Error("SSL_read", (code ? code : -1), false);
 529     break;
 530   }
 531
 532   return SOCKET_ERROR;
 533 }
 534
 535 int
 536 OpenSSLAdapter::Close() {
 537   Cleanup();
 538   state_ = restartable_ ? SSL_WAIT : SSL_NONE;
 539   return AsyncSocketAdapter::Close();
 540 }
 541
 542 Socket::ConnState
 543 OpenSSLAdapter::GetState() const {
 544   //if (signal_close_)
 545   //  return CS_CONNECTED;
 546   ConnState state = socket_->GetState();
 547   if ((state == CS_CONNECTED)
 548       && ((state_ == SSL_WAIT) || (state_ == SSL_CONNECTING)))
 549     state = CS_CONNECTING;
 550   return state;
 551 }
 552
 553 void
 554 OpenSSLAdapter::OnConnectEvent(AsyncSocket* socket) {
 555   LOG(LS_INFO) << "OpenSSLAdapter::OnConnectEvent";
 556   if (state_ != SSL_WAIT) {
 557     ASSERT(state_ == SSL_NONE);
 558     AsyncSocketAdapter::OnConnectEvent(socket);
 559     return;
 560   }
 561
 562   state_ = SSL_CONNECTING;
 563   if (int err = BeginSSL()) {
 564     AsyncSocketAdapter::OnCloseEvent(socket, err);
 565   }
 566 }
 567
 568 void
 569 OpenSSLAdapter::OnReadEvent(AsyncSocket* socket) {
 570   //LOG(LS_INFO) << "OpenSSLAdapter::OnReadEvent";
 571
 572   if (state_ == SSL_NONE) {
 573     AsyncSocketAdapter::OnReadEvent(socket);
 574     return;
 575   }
 576
 577   if (state_ == SSL_CONNECTING) {
 578     if (int err = ContinueSSL()) {
 579       Error("ContinueSSL", err);
 580     }
 581     return;
 582   }
 583
 584   if (state_ != SSL_CONNECTED)
 585     return;
 586
 587   // Don't let ourselves go away during the callbacks
 588   //PRefPtr<OpenSSLAdapter> lock(this); // TODO: fix this
 589   if (ssl_write_needs_read_)  {
 590     //LOG(LS_INFO) << " -- onStreamWriteable";
 591     AsyncSocketAdapter::OnWriteEvent(socket);
 592   }
 593
 594   //LOG(LS_INFO) << " -- onStreamReadable";
 595   AsyncSocketAdapter::OnReadEvent(socket);
 596 }
 597
 598 void
 599 OpenSSLAdapter::OnWriteEvent(AsyncSocket* socket) {
 600   //LOG(LS_INFO) << "OpenSSLAdapter::OnWriteEvent";
 601
 602   if (state_ == SSL_NONE) {
 603     AsyncSocketAdapter::OnWriteEvent(socket);
 604     return;
 605   }
 606
 607   if (state_ == SSL_CONNECTING) {
 608     if (int err = ContinueSSL()) {
 609       Error("ContinueSSL", err);
 610     }
 611     return;
 612   }
 613
 614   if (state_ != SSL_CONNECTED)
 615     return;
 616
 617   // Don't let ourselves go away during the callbacks
 618   //PRefPtr<OpenSSLAdapter> lock(this); // TODO: fix this
 619
 620   if (ssl_read_needs_write_)  {
 621     //LOG(LS_INFO) << " -- onStreamReadable";
 622     AsyncSocketAdapter::OnReadEvent(socket);
 623   }
 624
 625   //LOG(LS_INFO) << " -- onStreamWriteable";
 626   AsyncSocketAdapter::OnWriteEvent(socket);
 627 }
 628
 629 void
 630 OpenSSLAdapter::OnCloseEvent(AsyncSocket* socket, int err) {
 631   LOG(LS_INFO) << "OpenSSLAdapter::OnCloseEvent(" << err << ")";
 632   AsyncSocketAdapter::OnCloseEvent(socket, err);
 633 }
 634
 635 // This code is taken from the "Network Security with OpenSSL"
 636 // sample in chapter 5
 637
 638 bool OpenSSLAdapter::VerifyServerName(SSL* ssl, const char* host,
 639                                       bool ignore_bad_cert) {
 640   if (!host)
 641     return false;
 642
 643   // Checking the return from SSL_get_peer_certificate here is not strictly
 644   // necessary.  With our setup, it is not possible for it to return
 645   // NULL.  However, it is good form to check the return.
 646   X509* certificate = SSL_get_peer_certificate(ssl);
 647   if (!certificate)
 648     return false;
 649
 650   // Logging certificates is extremely verbose. So it is disabled by default.
 651 #ifdef LOG_CERTIFICATES
 652   {
 653     LOG(LS_INFO) << "Certificate from server:";
 654     BIO* mem = BIO_new(BIO_s_mem());
 655     X509_print_ex(mem, certificate, XN_FLAG_SEP_CPLUS_SPC, X509_FLAG_NO_HEADER);
 656     BIO_write(mem, "\0", 1);
 657     char* buffer;
 658     BIO_get_mem_data(mem, &buffer);
 659     LOG(LS_INFO) << buffer;
 660     BIO_free(mem);
 661
 662     char* cipher_description =
 663       SSL_CIPHER_description(SSL_get_current_cipher(ssl), NULL, 128);
 664     LOG(LS_INFO) << "Cipher: " << cipher_description;
 665     OPENSSL_free(cipher_description);
 666   }
 667 #endif
 668
 669   bool ok = false;
 670   int extension_count = X509_get_ext_count(certificate);
 671   for (int i = 0; i < extension_count; ++i) {
 672     X509_EXTENSION* extension = X509_get_ext(certificate, i);
 673     int extension_nid = OBJ_obj2nid(X509_EXTENSION_get_object(extension));
 674
 675     if (extension_nid == NID_subject_alt_name) {
 676       const X509V3_EXT_METHOD* meth = X509V3_EXT_get(extension);
 677       if (!meth)
 678         break;
 679
 680       void* ext_str = NULL;
 681
 682       // We assign this to a local variable, instead of passing the address
 683       // directly to ASN1_item_d2i.
 684       // See http://readlist.com/lists/openssl.org/openssl-users/0/4761.html.
 685       unsigned char* ext_value_data = extension->value->data;
 686
 687       const unsigned char **ext_value_data_ptr =
 688           (const_cast<const unsigned char **>(&ext_value_data));
 689
 690       if (meth->it) {
 691         ext_str = ASN1_item_d2i(NULL, ext_value_data_ptr,
 692                                 extension->value->length,
 693                                 ASN1_ITEM_ptr(meth->it));
 694       } else {
 695         ext_str = meth->d2i(NULL, ext_value_data_ptr, extension->value->length);
 696       }
 697
 698       STACK_OF(CONF_VALUE)* value = meth->i2v(meth, ext_str, NULL);
 699
 700       // Cast to size_t to be compilable for both OpenSSL and BoringSSL.
 701       for (size_t j = 0; j < static_cast<size_t>(sk_CONF_VALUE_num(value));
 702            ++j) {
 703         CONF_VALUE* nval = sk_CONF_VALUE_value(value, j);
 704         // The value for nval can contain wildcards
 705         if (!strcmp(nval->name, "DNS") && string_match(host, nval->value)) {
 706           ok = true;
 707           break;
 708         }
 709       }
 710       sk_CONF_VALUE_pop_free(value, X509V3_conf_free);
 711       value = NULL;
 712
 713       if (meth->it) {
 714         ASN1_item_free(reinterpret_cast<ASN1_VALUE*>(ext_str),
 715                        ASN1_ITEM_ptr(meth->it));
 716       } else {
 717         meth->ext_free(ext_str);
 718       }
 719       ext_str = NULL;
 720     }
 721     if (ok)
 722       break;
 723   }
 724
 725   char data[256];
 726   X509_NAME* subject;
 727   if (!ok
 728       && ((subject = X509_get_subject_name(certificate)) != NULL)
 729       && (X509_NAME_get_text_by_NID(subject, NID_commonName,
 730                                     data, sizeof(data)) > 0)) {
 731     data[sizeof(data)-1] = 0;
 732     if (_stricmp(data, host) == 0)
 733       ok = true;
 734   }
 735
 736   X509_free(certificate);
 737
 738   // This should only ever be turned on for debugging and development.
 739   if (!ok && ignore_bad_cert) {
 740     LOG(LS_WARNING) << "TLS certificate check FAILED.  "
 741       << "Allowing connection anyway.";
 742     ok = true;
 743   }
 744
 745   return ok;
 746 }
 747
 748 bool OpenSSLAdapter::SSLPostConnectionCheck(SSL* ssl, const char* host) {
 749   bool ok = VerifyServerName(ssl, host, ignore_bad_cert());
 750
 751   if (ok) {
 752     ok = (SSL_get_verify_result(ssl) == X509_V_OK ||
 753           custom_verification_succeeded_);
 754   }
 755
 756   if (!ok && ignore_bad_cert()) {
 757     LOG(LS_INFO) << "Other TLS post connection checks failed.";
 758     ok = true;
 759   }
 760
 761   return ok;
 762 }
 763
 764 #if _DEBUG
 765
 766 // We only use this for tracing and so it is only needed in debug mode
 767
 768 void
 769 OpenSSLAdapter::SSLInfoCallback(const SSL* s, int where, int ret) {
 770   const char* str = "undefined";
 771   int w = where & ~SSL_ST_MASK;
 772   if (w & SSL_ST_CONNECT) {
 773     str = "SSL_connect";
 774   } else if (w & SSL_ST_ACCEPT) {
 775     str = "SSL_accept";
 776   }
 777   if (where & SSL_CB_LOOP) {
 778     LOG(LS_INFO) <<  str << ":" << SSL_state_string_long(s);
 779   } else if (where & SSL_CB_ALERT) {
 780     str = (where & SSL_CB_READ) ? "read" : "write";
 781     LOG(LS_INFO) <<  "SSL3 alert " << str
 782       << ":" << SSL_alert_type_string_long(ret)
 783       << ":" << SSL_alert_desc_string_long(ret);
 784   } else if (where & SSL_CB_EXIT) {
 785     if (ret == 0) {
 786       LOG(LS_INFO) << str << ":failed in " << SSL_state_string_long(s);
 787     } else if (ret < 0) {
 788       LOG(LS_INFO) << str << ":error in " << SSL_state_string_long(s);
 789     }
 790   }
 791 }
 792
 793 #endif  // _DEBUG
 794
 795 int
 796 OpenSSLAdapter::SSLVerifyCallback(int ok, X509_STORE_CTX* store) {
 797 #if _DEBUG
 798   if (!ok) {
 799     char data[256];
 800     X509* cert = X509_STORE_CTX_get_current_cert(store);
 801     int depth = X509_STORE_CTX_get_error_depth(store);
 802     int err = X509_STORE_CTX_get_error(store);
 803
 804     LOG(LS_INFO) << "Error with certificate at depth: " << depth;
 805     X509_NAME_oneline(X509_get_issuer_name(cert), data, sizeof(data));
 806     LOG(LS_INFO) << "  issuer  = " << data;
 807     X509_NAME_oneline(X509_get_subject_name(cert), data, sizeof(data));
 808     LOG(LS_INFO) << "  subject = " << data;
 809     LOG(LS_INFO) << "  err     = " << err
 810       << ":" << X509_verify_cert_error_string(err);
 811   }
 812 #endif
 813
 814   // Get our stream pointer from the store
 815   SSL* ssl = reinterpret_cast<SSL*>(
 816                 X509_STORE_CTX_get_ex_data(store,
 817                   SSL_get_ex_data_X509_STORE_CTX_idx()));
 818
 819   OpenSSLAdapter* stream =
 820     reinterpret_cast<OpenSSLAdapter*>(SSL_get_app_data(ssl));
 821
 822   if (!ok && custom_verify_callback_) {
 823     void* cert =
 824         reinterpret_cast<void*>(X509_STORE_CTX_get_current_cert(store));
 825     if (custom_verify_callback_(cert)) {
 826       stream->custom_verification_succeeded_ = true;
 827       LOG(LS_INFO) << "validated certificate using custom callback";
 828       ok = true;
 829     }
 830   }
 831
 832   // Should only be used for debugging and development.
 833   if (!ok && stream->ignore_bad_cert()) {
 834     LOG(LS_WARNING) << "Ignoring cert error while verifying cert chain";
 835     ok = 1;
 836   }
 837
 838   return ok;
 839 }
 840
 841 bool OpenSSLAdapter::ConfigureTrustedRootCertificates(SSL_CTX* ctx) {
 842   // Add the root cert that we care about to the SSL context
 843   int count_of_added_certs = 0;
 844   for (int i = 0; i < ARRAY_SIZE(kSSLCertCertificateList); i++) {
 845     const unsigned char* cert_buffer = kSSLCertCertificateList[i];
 846     size_t cert_buffer_len = kSSLCertCertificateSizeList[i];
 847     X509* cert = d2i_X509(NULL, &cert_buffer,
 848                           checked_cast<long>(cert_buffer_len));
 849     if (cert) {
 850       int return_value = X509_STORE_add_cert(SSL_CTX_get_cert_store(ctx), cert);
 851       if (return_value == 0) {
 852         LOG(LS_WARNING) << "Unable to add certificate.";
 853       } else {
 854         count_of_added_certs++;
 855       }
 856       X509_free(cert);
 857     }
 858   }
 859   return count_of_added_certs > 0;
 860 }
 861
 862 SSL_CTX*
 863 OpenSSLAdapter::SetupSSLContext() {
 864   SSL_CTX* ctx = SSL_CTX_new(TLSv1_client_method());
 865   if (ctx == NULL) {
 866     unsigned long error = ERR_get_error();  // NOLINT: type used by OpenSSL.
 867     LOG(LS_WARNING) << "SSL_CTX creation failed: "
 868                     << '"' << ERR_reason_error_string(error) << "\" "
 869                     << "(error=" << error << ')';
 870     return NULL;
 871   }
 872   if (!ConfigureTrustedRootCertificates(ctx)) {
 873     SSL_CTX_free(ctx);
 874     return NULL;
 875   }
 876
 877 #ifdef _DEBUG
 878   SSL_CTX_set_info_callback(ctx, SSLInfoCallback);
 879 #endif
 880
 881   SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, SSLVerifyCallback);
 882   SSL_CTX_set_verify_depth(ctx, 4);
 883   SSL_CTX_set_cipher_list(ctx, "ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
 884
 885   return ctx;
 886 }
 887
 888 } // namespace rtc
 889
 890 #endif  // HAVE_OPENSSL_SSL_H