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
78struct CRYPTO_dynlock_value {
79  MUTEX_TYPE mutex;
80};
81
82//////////////////////////////////////////////////////////////////////
83// SocketBIO
84//////////////////////////////////////////////////////////////////////
85
86static int socket_write(BIO* h, const char* buf, int num);
87static int socket_read(BIO* h, char* buf, int size);
88static int socket_puts(BIO* h, const char* str);
89static long socket_ctrl(BIO* h, int cmd, long arg1, void* arg2);
90static int socket_new(BIO* h);
91static int socket_free(BIO* data);
92
93static 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
106BIO_METHOD* BIO_s_socket2() { return(&methods_socket); }
107
108BIO* 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
117static 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
125static int socket_free(BIO* b) {
126  if (b == NULL)
127    return 0;
128  return 1;
129}
130
131static 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
147static 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
161static int socket_puts(BIO* b, const char* str) {
162  return socket_write(b, str, strlen(str));
163}
164
165static 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
188namespace talk_base {
189
190// This array will store all of the mutexes available to OpenSSL.
191static MUTEX_TYPE* mutex_buf = NULL;
192
193static 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
201static 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
208static 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
216static 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
225static void dyn_destroy_function(CRYPTO_dynlock_value* l,
226                                 const char* file, int line) {
227  MUTEX_CLEANUP(l->mutex);
228  delete l;
229}
230
231VerificationCallback OpenSSLAdapter::custom_verify_callback_ = NULL;
232
233bool 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
247bool 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
264bool 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
279OpenSSLAdapter::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
289OpenSSLAdapter::~OpenSSLAdapter() {
290  Cleanup();
291}
292
293int
294OpenSSLAdapter::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
315int
316OpenSSLAdapter::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
360ssl_error:
361  Cleanup();
362  if (bio)
363    BIO_free(bio);
364
365  return err;
366}
367
368int
369OpenSSLAdapter::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
408void
409OpenSSLAdapter::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
418void
419OpenSSLAdapter::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
442int
443OpenSSLAdapter::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
497int
498OpenSSLAdapter::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
552int
553OpenSSLAdapter::Close() {
554  Cleanup();
555  state_ = restartable_ ? SSL_WAIT : SSL_NONE;
556  return AsyncSocketAdapter::Close();
557}
558
559Socket::ConnState
560OpenSSLAdapter::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
570void
571OpenSSLAdapter::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
585void
586OpenSSLAdapter::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
615void
616OpenSSLAdapter::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
646void
647OpenSSLAdapter::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
655bool 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
770bool 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
790void
791OpenSSLAdapter::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
817int
818OpenSSLAdapter::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
863bool 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
883SSL_CTX*
884OpenSSLAdapter::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
912