src/third_party/libjingle/source/talk/base/openssladapter.cc

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