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