folly/io/async/AsyncSSLSocket.cpp

   1 /*
   2  * Copyright 2016 Facebook, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *   http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <folly/io/async/AsyncSSLSocket.h>
  18
  19 #include <folly/io/async/EventBase.h>
  20 #include <folly/portability/Sockets.h>
  21
  22 #include <boost/noncopyable.hpp>
  23 #include <errno.h>
  24 #include <fcntl.h>
  25 #include <openssl/err.h>
  26 #include <openssl/asn1.h>
  27 #include <openssl/ssl.h>
  28 #include <sys/types.h>
  29 #include <chrono>
  30
  31 #include <folly/Bits.h>
  32 #include <folly/SocketAddress.h>
  33 #include <folly/SpinLock.h>
  34 #include <folly/io/IOBuf.h>
  35 #include <folly/io/Cursor.h>
  36 #include <folly/portability/Unistd.h>
  37
  38 using folly::SocketAddress;
  39 using folly::SSLContext;
  40 using std::string;
  41 using std::shared_ptr;
  42
  43 using folly::Endian;
  44 using folly::IOBuf;
  45 using folly::SpinLock;
  46 using folly::SpinLockGuard;
  47 using folly::io::Cursor;
  48 using std::unique_ptr;
  49 using std::bind;
  50
  51 namespace {
  52 using folly::AsyncSocket;
  53 using folly::AsyncSocketException;
  54 using folly::AsyncSSLSocket;
  55 using folly::Optional;
  56 using folly::SSLContext;
  57
  58 // We have one single dummy SSL context so that we can implement attach
  59 // and detach methods in a thread safe fashion without modifying opnessl.
  60 static SSLContext *dummyCtx = nullptr;
  61 static SpinLock dummyCtxLock;
  62
  63 // If given min write size is less than this, buffer will be allocated on
  64 // stack, otherwise it is allocated on heap
  65 const size_t MAX_STACK_BUF_SIZE = 2048;
  66
  67 // This converts "illegal" shutdowns into ZERO_RETURN
  68 inline bool zero_return(int error, int rc) {
  69   return (error == SSL_ERROR_ZERO_RETURN || (rc == 0 && errno == 0));
  70 }
  71
  72 class AsyncSSLSocketConnector: public AsyncSocket::ConnectCallback,
  73                                 public AsyncSSLSocket::HandshakeCB {
  74
  75  private:
  76   AsyncSSLSocket *sslSocket_;
  77   AsyncSSLSocket::ConnectCallback *callback_;
  78   int timeout_;
  79   int64_t startTime_;
  80
  81  protected:
  82   ~AsyncSSLSocketConnector() override {}
  83
  84  public:
  85   AsyncSSLSocketConnector(AsyncSSLSocket *sslSocket,
  86                            AsyncSocket::ConnectCallback *callback,
  87                            int timeout) :
  88       sslSocket_(sslSocket),
  89       callback_(callback),
  90       timeout_(timeout),
  91       startTime_(std::chrono::duration_cast<std::chrono::milliseconds>(
  92                    std::chrono::steady_clock::now().time_since_epoch()).count()) {
  93   }
  94
  95   void connectSuccess() noexcept override {
  96     VLOG(7) << "client socket connected";
  97
  98     int64_t timeoutLeft = 0;
  99     if (timeout_ > 0) {
 100       auto curTime = std::chrono::duration_cast<std::chrono::milliseconds>(
 101         std::chrono::steady_clock::now().time_since_epoch()).count();
 102
 103       timeoutLeft = timeout_ - (curTime - startTime_);
 104       if (timeoutLeft <= 0) {
 105         AsyncSocketException ex(AsyncSocketException::TIMED_OUT,
 106                                 "SSL connect timed out");
 107         fail(ex);
 108         delete this;
 109         return;
 110       }
 111     }
 112     sslSocket_->sslConn(this, timeoutLeft);
 113   }
 114
 115   void connectErr(const AsyncSocketException& ex) noexcept override {
 116     LOG(ERROR) << "TCP connect failed: " <<  ex.what();
 117     fail(ex);
 118     delete this;
 119   }
 120
 121   void handshakeSuc(AsyncSSLSocket* /* sock */) noexcept override {
 122     VLOG(7) << "client handshake success";
 123     if (callback_) {
 124       callback_->connectSuccess();
 125     }
 126     delete this;
 127   }
 128
 129   void handshakeErr(AsyncSSLSocket* /* socket */,
 130                     const AsyncSocketException& ex) noexcept override {
 131     LOG(ERROR) << "client handshakeErr: " << ex.what();
 132     fail(ex);
 133     delete this;
 134   }
 135
 136   void fail(const AsyncSocketException &ex) {
 137     // fail is a noop if called twice
 138     if (callback_) {
 139       AsyncSSLSocket::ConnectCallback *cb = callback_;
 140       callback_ = nullptr;
 141
 142       cb->connectErr(ex);
 143       sslSocket_->closeNow();
 144       // closeNow can call handshakeErr if it hasn't been called already.
 145       // So this may have been deleted, no member variable access beyond this
 146       // point
 147       // Note that closeNow may invoke writeError callbacks if the socket had
 148       // write data pending connection completion.
 149     }
 150   }
 151 };
 152
 153 // XXX: implement an equivalent to corking for platforms with TCP_NOPUSH?
 154 #ifdef TCP_CORK // Linux-only
 155 /**
 156  * Utility class that corks a TCP socket upon construction or uncorks
 157  * the socket upon destruction
 158  */
 159 class CorkGuard : private boost::noncopyable {
 160  public:
 161   CorkGuard(int fd, bool multipleWrites, bool haveMore, bool* corked):
 162     fd_(fd), haveMore_(haveMore), corked_(corked) {
 163     if (*corked_) {
 164       // socket is already corked; nothing to do
 165       return;
 166     }
 167     if (multipleWrites || haveMore) {
 168       // We are performing multiple writes in this performWrite() call,
 169       // and/or there are more calls to performWrite() that will be invoked
 170       // later, so enable corking
 171       int flag = 1;
 172       setsockopt(fd_, IPPROTO_TCP, TCP_CORK, &flag, sizeof(flag));
 173       *corked_ = true;
 174     }
 175   }
 176
 177   ~CorkGuard() {
 178     if (haveMore_) {
 179       // more data to come; don't uncork yet
 180       return;
 181     }
 182     if (!*corked_) {
 183       // socket isn't corked; nothing to do
 184       return;
 185     }
 186
 187     int flag = 0;
 188     setsockopt(fd_, IPPROTO_TCP, TCP_CORK, &flag, sizeof(flag));
 189     *corked_ = false;
 190   }
 191
 192  private:
 193   int fd_;
 194   bool haveMore_;
 195   bool* corked_;
 196 };
 197 #else
 198 class CorkGuard : private boost::noncopyable {
 199  public:
 200   CorkGuard(int, bool, bool, bool*) {}
 201 };
 202 #endif
 203
 204 void setup_SSL_CTX(SSL_CTX *ctx) {
 205 #ifdef SSL_MODE_RELEASE_BUFFERS
 206   SSL_CTX_set_mode(ctx,
 207                    SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER |
 208                    SSL_MODE_ENABLE_PARTIAL_WRITE
 209                    | SSL_MODE_RELEASE_BUFFERS
 210                    );
 211 #else
 212   SSL_CTX_set_mode(ctx,
 213                    SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER |
 214                    SSL_MODE_ENABLE_PARTIAL_WRITE
 215                    );
 216 #endif
 217 // SSL_CTX_set_mode is a Macro
 218 #ifdef SSL_MODE_WRITE_IOVEC
 219   SSL_CTX_set_mode(ctx,
 220                    SSL_CTX_get_mode(ctx)
 221                    | SSL_MODE_WRITE_IOVEC);
 222 #endif
 223
 224 }
 225
 226 BIO_METHOD sslWriteBioMethod;
 227
 228 void* initsslWriteBioMethod(void) {
 229   memcpy(&sslWriteBioMethod, BIO_s_socket(), sizeof(sslWriteBioMethod));
 230   // override the bwrite method for MSG_EOR support
 231   sslWriteBioMethod.bwrite = AsyncSSLSocket::bioWrite;
 232
 233   // Note that the sslWriteBioMethod.type and sslWriteBioMethod.name are not
 234   // set here. openssl code seems to be checking ".type == BIO_TYPE_SOCKET" and
 235   // then have specific handlings. The sslWriteBioWrite should be compatible
 236   // with the one in openssl.
 237
 238   // Return something here to enable AsyncSSLSocket to call this method using
 239   // a function-scoped static.
 240   return nullptr;
 241 }
 242
 243 } // anonymous namespace
 244
 245 namespace folly {
 246
 247 /**
 248  * Create a client AsyncSSLSocket
 249  */
 250 AsyncSSLSocket::AsyncSSLSocket(const shared_ptr<SSLContext> &ctx,
 251                                EventBase* evb, bool deferSecurityNegotiation) :
 252     AsyncSocket(evb),
 253     ctx_(ctx),
 254     handshakeTimeout_(this, evb) {
 255   init();
 256   if (deferSecurityNegotiation) {
 257     sslState_ = STATE_UNENCRYPTED;
 258   }
 259 }
 260
 261 /**
 262  * Create a server/client AsyncSSLSocket
 263  */
 264 AsyncSSLSocket::AsyncSSLSocket(const shared_ptr<SSLContext>& ctx,
 265                                EventBase* evb, int fd, bool server,
 266                                bool deferSecurityNegotiation) :
 267     AsyncSocket(evb, fd),
 268     server_(server),
 269     ctx_(ctx),
 270     handshakeTimeout_(this, evb) {
 271   init();
 272   if (server) {
 273     SSL_CTX_set_info_callback(ctx_->getSSLCtx(),
 274                               AsyncSSLSocket::sslInfoCallback);
 275   }
 276   if (deferSecurityNegotiation) {
 277     sslState_ = STATE_UNENCRYPTED;
 278   }
 279 }
 280
 281 #if OPENSSL_VERSION_NUMBER >= 0x1000105fL && !defined(OPENSSL_NO_TLSEXT)
 282 /**
 283  * Create a client AsyncSSLSocket and allow tlsext_hostname
 284  * to be sent in Client Hello.
 285  */
 286 AsyncSSLSocket::AsyncSSLSocket(const shared_ptr<SSLContext> &ctx,
 287                                  EventBase* evb,
 288                                const std::string& serverName,
 289                                bool deferSecurityNegotiation) :
 290     AsyncSSLSocket(ctx, evb, deferSecurityNegotiation) {
 291   tlsextHostname_ = serverName;
 292 }
 293
 294 /**
 295  * Create a client AsyncSSLSocket from an already connected fd
 296  * and allow tlsext_hostname to be sent in Client Hello.
 297  */
 298 AsyncSSLSocket::AsyncSSLSocket(const shared_ptr<SSLContext>& ctx,
 299                                  EventBase* evb, int fd,
 300                                const std::string& serverName,
 301                                bool deferSecurityNegotiation) :
 302     AsyncSSLSocket(ctx, evb, fd, false, deferSecurityNegotiation) {
 303   tlsextHostname_ = serverName;
 304 }
 305 #endif
 306
 307 AsyncSSLSocket::~AsyncSSLSocket() {
 308   VLOG(3) << "actual destruction of AsyncSSLSocket(this=" << this
 309           << ", evb=" << eventBase_ << ", fd=" << fd_
 310           << ", state=" << int(state_) << ", sslState="
 311           << sslState_ << ", events=" << eventFlags_ << ")";
 312 }
 313
 314 void AsyncSSLSocket::init() {
 315   // Do this here to ensure we initialize this once before any use of
 316   // AsyncSSLSocket instances and not as part of library load.
 317   static const auto sslWriteBioMethodInitializer = initsslWriteBioMethod();
 318   (void)sslWriteBioMethodInitializer;
 319
 320   setup_SSL_CTX(ctx_->getSSLCtx());
 321 }
 322
 323 void AsyncSSLSocket::closeNow() {
 324   // Close the SSL connection.
 325   if (ssl_ != nullptr && fd_ != -1) {
 326     int rc = SSL_shutdown(ssl_);
 327     if (rc == 0) {
 328       rc = SSL_shutdown(ssl_);
 329     }
 330     if (rc < 0) {
 331       ERR_clear_error();
 332     }
 333   }
 334
 335   if (sslSession_ != nullptr) {
 336     SSL_SESSION_free(sslSession_);
 337     sslSession_ = nullptr;
 338   }
 339
 340   sslState_ = STATE_CLOSED;
 341
 342   if (handshakeTimeout_.isScheduled()) {
 343     handshakeTimeout_.cancelTimeout();
 344   }
 345
 346   DestructorGuard dg(this);
 347
 348   invokeHandshakeErr(
 349       AsyncSocketException(
 350         AsyncSocketException::END_OF_FILE,
 351         "SSL connection closed locally"));
 352
 353   if (ssl_ != nullptr) {
 354     SSL_free(ssl_);
 355     ssl_ = nullptr;
 356   }
 357
 358   // Close the socket.
 359   AsyncSocket::closeNow();
 360 }
 361
 362 void AsyncSSLSocket::shutdownWrite() {
 363   // SSL sockets do not support half-shutdown, so just perform a full shutdown.
 364   //
 365   // (Performing a full shutdown here is more desirable than doing nothing at
 366   // all.  The purpose of shutdownWrite() is normally to notify the other end
 367   // of the connection that no more data will be sent.  If we do nothing, the
 368   // other end will never know that no more data is coming, and this may result
 369   // in protocol deadlock.)
 370   close();
 371 }
 372
 373 void AsyncSSLSocket::shutdownWriteNow() {
 374   closeNow();
 375 }
 376
 377 bool AsyncSSLSocket::good() const {
 378   return (AsyncSocket::good() &&
 379           (sslState_ == STATE_ACCEPTING || sslState_ == STATE_CONNECTING ||
 380            sslState_ == STATE_ESTABLISHED || sslState_ == STATE_UNENCRYPTED));
 381 }
 382
 383 // The TAsyncTransport definition of 'good' states that the transport is
 384 // ready to perform reads and writes, so sslState_ == UNINIT must report !good.
 385 // connecting can be true when the sslState_ == UNINIT because the AsyncSocket
 386 // is connected but we haven't initiated the call to SSL_connect.
 387 bool AsyncSSLSocket::connecting() const {
 388   return (!server_ &&
 389           (AsyncSocket::connecting() ||
 390            (AsyncSocket::good() && (sslState_ == STATE_UNINIT ||
 391                                      sslState_ == STATE_CONNECTING))));
 392 }
 393
 394 std::string AsyncSSLSocket::getApplicationProtocol() noexcept {
 395   const unsigned char* protoName = nullptr;
 396   unsigned protoLength;
 397   if (getSelectedNextProtocolNoThrow(&protoName, &protoLength)) {
 398     return std::string(reinterpret_cast<const char*>(protoName), protoLength);
 399   }
 400   return "";
 401 }
 402
 403 bool AsyncSSLSocket::isEorTrackingEnabled() const {
 404   return trackEor_;
 405 }
 406
 407 void AsyncSSLSocket::setEorTracking(bool track) {
 408   if (trackEor_ != track) {
 409     trackEor_ = track;
 410     appEorByteNo_ = 0;
 411     minEorRawByteNo_ = 0;
 412   }
 413 }
 414
 415 size_t AsyncSSLSocket::getRawBytesWritten() const {
 416   BIO *b;
 417   if (!ssl_ || !(b = SSL_get_wbio(ssl_))) {
 418     return 0;
 419   }
 420
 421   return BIO_number_written(b);
 422 }
 423
 424 size_t AsyncSSLSocket::getRawBytesReceived() const {
 425   BIO *b;
 426   if (!ssl_ || !(b = SSL_get_rbio(ssl_))) {
 427     return 0;
 428   }
 429
 430   return BIO_number_read(b);
 431 }
 432
 433
 434 void AsyncSSLSocket::invalidState(HandshakeCB* callback) {
 435   LOG(ERROR) << "AsyncSSLSocket(this=" << this << ", fd=" << fd_
 436              << ", state=" << int(state_) << ", sslState=" << sslState_ << ", "
 437              << "events=" << eventFlags_ << ", server=" << short(server_) << "): "
 438              << "sslAccept/Connect() called in invalid "
 439              << "state, handshake callback " << handshakeCallback_ << ", new callback "
 440              << callback;
 441   assert(!handshakeTimeout_.isScheduled());
 442   sslState_ = STATE_ERROR;
 443
 444   AsyncSocketException ex(AsyncSocketException::INVALID_STATE,
 445                          "sslAccept() called with socket in invalid state");
 446
 447   handshakeEndTime_ = std::chrono::steady_clock::now();
 448   if (callback) {
 449     callback->handshakeErr(this, ex);
 450   }
 451
 452   // Check the socket state not the ssl state here.
 453   if (state_ != StateEnum::CLOSED || state_ != StateEnum::ERROR) {
 454     failHandshake(__func__, ex);
 455   }
 456 }
 457
 458 void AsyncSSLSocket::sslAccept(HandshakeCB* callback, uint32_t timeout,
 459       const SSLContext::SSLVerifyPeerEnum& verifyPeer) {
 460   DestructorGuard dg(this);
 461   assert(eventBase_->isInEventBaseThread());
 462   verifyPeer_ = verifyPeer;
 463
 464   // Make sure we're in the uninitialized state
 465   if (!server_ || (sslState_ != STATE_UNINIT &&
 466                    sslState_ != STATE_UNENCRYPTED) ||
 467       handshakeCallback_ != nullptr) {
 468     return invalidState(callback);
 469   }
 470
 471   // Cache local and remote socket addresses to keep them available
 472   // after socket file descriptor is closed.
 473   if (cacheAddrOnFailure_ && -1 != getFd()) {
 474     cacheLocalPeerAddr();
 475   }
 476
 477   handshakeStartTime_ = std::chrono::steady_clock::now();
 478   // Make end time at least >= start time.
 479   handshakeEndTime_ = handshakeStartTime_;
 480
 481   sslState_ = STATE_ACCEPTING;
 482   handshakeCallback_ = callback;
 483
 484   if (timeout > 0) {
 485     handshakeTimeout_.scheduleTimeout(timeout);
 486   }
 487
 488   /* register for a read operation (waiting for CLIENT HELLO) */
 489   updateEventRegistration(EventHandler::READ, EventHandler::WRITE);
 490 }
 491
 492 #if OPENSSL_VERSION_NUMBER >= 0x009080bfL
 493 void AsyncSSLSocket::attachSSLContext(
 494   const std::shared_ptr<SSLContext>& ctx) {
 495
 496   // Check to ensure we are in client mode. Changing a server's ssl
 497   // context doesn't make sense since clients of that server would likely
 498   // become confused when the server's context changes.
 499   DCHECK(!server_);
 500   DCHECK(!ctx_);
 501   DCHECK(ctx);
 502   DCHECK(ctx->getSSLCtx());
 503   ctx_ = ctx;
 504
 505   // In order to call attachSSLContext, detachSSLContext must have been
 506   // previously called which sets the socket's context to the dummy
 507   // context. Thus we must acquire this lock.
 508   SpinLockGuard guard(dummyCtxLock);
 509   SSL_set_SSL_CTX(ssl_, ctx->getSSLCtx());
 510 }
 511
 512 void AsyncSSLSocket::detachSSLContext() {
 513   DCHECK(ctx_);
 514   ctx_.reset();
 515   // We aren't using the initial_ctx for now, and it can introduce race
 516   // conditions in the destructor of the SSL object.
 517 #ifndef OPENSSL_NO_TLSEXT
 518   if (ssl_->initial_ctx) {
 519     SSL_CTX_free(ssl_->initial_ctx);
 520     ssl_->initial_ctx = nullptr;
 521   }
 522 #endif
 523   SpinLockGuard guard(dummyCtxLock);
 524   if (nullptr == dummyCtx) {
 525     // We need to lazily initialize the dummy context so we don't
 526     // accidentally override any programmatic settings to openssl
 527     dummyCtx = new SSLContext;
 528   }
 529   // We must remove this socket's references to its context right now
 530   // since this socket could get passed to any thread. If the context has
 531   // had its locking disabled, just doing a set in attachSSLContext()
 532   // would not be thread safe.
 533   SSL_set_SSL_CTX(ssl_, dummyCtx->getSSLCtx());
 534 }
 535 #endif
 536
 537 #if OPENSSL_VERSION_NUMBER >= 0x1000105fL && !defined(OPENSSL_NO_TLSEXT)
 538 void AsyncSSLSocket::switchServerSSLContext(
 539   const std::shared_ptr<SSLContext>& handshakeCtx) {
 540   CHECK(server_);
 541   if (sslState_ != STATE_ACCEPTING) {
 542     // We log it here and allow the switch.
 543     // It should not affect our re-negotiation support (which
 544     // is not supported now).
 545     VLOG(6) << "fd=" << getFd()
 546             << " renegotation detected when switching SSL_CTX";
 547   }
 548
 549   setup_SSL_CTX(handshakeCtx->getSSLCtx());
 550   SSL_CTX_set_info_callback(handshakeCtx->getSSLCtx(),
 551                             AsyncSSLSocket::sslInfoCallback);
 552   handshakeCtx_ = handshakeCtx;
 553   SSL_set_SSL_CTX(ssl_, handshakeCtx->getSSLCtx());
 554 }
 555
 556 bool AsyncSSLSocket::isServerNameMatch() const {
 557   CHECK(!server_);
 558
 559   if (!ssl_) {
 560     return false;
 561   }
 562
 563   SSL_SESSION *ss = SSL_get_session(ssl_);
 564   if (!ss) {
 565     return false;
 566   }
 567
 568   if(!ss->tlsext_hostname) {
 569     return false;
 570   }
 571   return (tlsextHostname_.compare(ss->tlsext_hostname) ? false : true);
 572 }
 573
 574 void AsyncSSLSocket::setServerName(std::string serverName) noexcept {
 575   tlsextHostname_ = std::move(serverName);
 576 }
 577
 578 #endif
 579
 580 void AsyncSSLSocket::timeoutExpired() noexcept {
 581   if (state_ == StateEnum::ESTABLISHED &&
 582       (sslState_ == STATE_CACHE_LOOKUP ||
 583        sslState_ == STATE_ASYNC_PENDING)) {
 584     sslState_ = STATE_ERROR;
 585     // We are expecting a callback in restartSSLAccept.  The cache lookup
 586     // and rsa-call necessarily have pointers to this ssl socket, so delay
 587     // the cleanup until he calls us back.
 588   } else {
 589     assert(state_ == StateEnum::ESTABLISHED &&
 590            (sslState_ == STATE_CONNECTING || sslState_ == STATE_ACCEPTING));
 591     DestructorGuard dg(this);
 592     AsyncSocketException ex(AsyncSocketException::TIMED_OUT,
 593                            (sslState_ == STATE_CONNECTING) ?
 594                            "SSL connect timed out" : "SSL accept timed out");
 595     failHandshake(__func__, ex);
 596   }
 597 }
 598
 599 int AsyncSSLSocket::getSSLExDataIndex() {
 600   static auto index = SSL_get_ex_new_index(
 601       0, (void*)"AsyncSSLSocket data index", nullptr, nullptr, nullptr);
 602   return index;
 603 }
 604
 605 AsyncSSLSocket* AsyncSSLSocket::getFromSSL(const SSL *ssl) {
 606   return static_cast<AsyncSSLSocket *>(SSL_get_ex_data(ssl,
 607       getSSLExDataIndex()));
 608 }
 609
 610 void AsyncSSLSocket::failHandshake(const char* /* fn */,
 611                                    const AsyncSocketException& ex) {
 612   startFail();
 613   if (handshakeTimeout_.isScheduled()) {
 614     handshakeTimeout_.cancelTimeout();
 615   }
 616   invokeHandshakeErr(ex);
 617   finishFail();
 618 }
 619
 620 void AsyncSSLSocket::invokeHandshakeErr(const AsyncSocketException& ex) {
 621   handshakeEndTime_ = std::chrono::steady_clock::now();
 622   if (handshakeCallback_ != nullptr) {
 623     HandshakeCB* callback = handshakeCallback_;
 624     handshakeCallback_ = nullptr;
 625     callback->handshakeErr(this, ex);
 626   }
 627 }
 628
 629 void AsyncSSLSocket::invokeHandshakeCB() {
 630   handshakeEndTime_ = std::chrono::steady_clock::now();
 631   if (handshakeTimeout_.isScheduled()) {
 632     handshakeTimeout_.cancelTimeout();
 633   }
 634   if (handshakeCallback_) {
 635     HandshakeCB* callback = handshakeCallback_;
 636     handshakeCallback_ = nullptr;
 637     callback->handshakeSuc(this);
 638   }
 639 }
 640
 641 void AsyncSSLSocket::cacheLocalPeerAddr() {
 642   SocketAddress address;
 643   try {
 644     getLocalAddress(&address);
 645     getPeerAddress(&address);
 646   } catch (const std::system_error& e) {
 647     // The handle can be still valid while the connection is already closed.
 648     if (e.code() != std::error_code(ENOTCONN, std::system_category())) {
 649       throw;
 650     }
 651   }
 652 }
 653
 654 void AsyncSSLSocket::connect(ConnectCallback* callback,
 655                               const folly::SocketAddress& address,
 656                               int timeout,
 657                               const OptionMap &options,
 658                               const folly::SocketAddress& bindAddr)
 659                               noexcept {
 660   assert(!server_);
 661   assert(state_ == StateEnum::UNINIT);
 662   assert(sslState_ == STATE_UNINIT);
 663   AsyncSSLSocketConnector *connector =
 664     new AsyncSSLSocketConnector(this, callback, timeout);
 665   AsyncSocket::connect(connector, address, timeout, options, bindAddr);
 666 }
 667
 668 void AsyncSSLSocket::applyVerificationOptions(SSL * ssl) {
 669   // apply the settings specified in verifyPeer_
 670   if (verifyPeer_ == SSLContext::SSLVerifyPeerEnum::USE_CTX) {
 671     if(ctx_->needsPeerVerification()) {
 672       SSL_set_verify(ssl, ctx_->getVerificationMode(),
 673         AsyncSSLSocket::sslVerifyCallback);
 674     }
 675   } else {
 676     if (verifyPeer_ == SSLContext::SSLVerifyPeerEnum::VERIFY ||
 677         verifyPeer_ == SSLContext::SSLVerifyPeerEnum::VERIFY_REQ_CLIENT_CERT) {
 678       SSL_set_verify(ssl, SSLContext::getVerificationMode(verifyPeer_),
 679         AsyncSSLSocket::sslVerifyCallback);
 680     }
 681   }
 682 }
 683
 684 bool AsyncSSLSocket::setupSSLBio() {
 685   auto wb = BIO_new(&sslWriteBioMethod);
 686
 687   if (!wb) {
 688     return false;
 689   }
 690
 691   BIO_set_app_data(wb, this);
 692   BIO_set_fd(wb, fd_, BIO_NOCLOSE);
 693   SSL_set_bio(ssl_, wb, wb);
 694   return true;
 695 }
 696
 697 void AsyncSSLSocket::sslConn(HandshakeCB* callback, uint64_t timeout,
 698         const SSLContext::SSLVerifyPeerEnum& verifyPeer) {
 699   DestructorGuard dg(this);
 700   assert(eventBase_->isInEventBaseThread());
 701
 702   // Cache local and remote socket addresses to keep them available
 703   // after socket file descriptor is closed.
 704   if (cacheAddrOnFailure_ && -1 != getFd()) {
 705     cacheLocalPeerAddr();
 706   }
 707
 708   verifyPeer_ = verifyPeer;
 709
 710   // Make sure we're in the uninitialized state
 711   if (server_ || (sslState_ != STATE_UNINIT && sslState_ !=
 712                   STATE_UNENCRYPTED) ||
 713       handshakeCallback_ != nullptr) {
 714     return invalidState(callback);
 715   }
 716
 717   handshakeStartTime_ = std::chrono::steady_clock::now();
 718   // Make end time at least >= start time.
 719   handshakeEndTime_ = handshakeStartTime_;
 720
 721   sslState_ = STATE_CONNECTING;
 722   handshakeCallback_ = callback;
 723
 724   try {
 725     ssl_ = ctx_->createSSL();
 726   } catch (std::exception &e) {
 727     sslState_ = STATE_ERROR;
 728     AsyncSocketException ex(AsyncSocketException::INTERNAL_ERROR,
 729                            "error calling SSLContext::createSSL()");
 730     LOG(ERROR) << "AsyncSSLSocket::sslConn(this=" << this << ", fd="
 731             << fd_ << "): " << e.what();
 732     return failHandshake(__func__, ex);
 733   }
 734
 735   if (!setupSSLBio()) {
 736     sslState_ = STATE_ERROR;
 737     AsyncSocketException ex(
 738         AsyncSocketException::INTERNAL_ERROR, "error creating SSL bio");
 739     return failHandshake(__func__, ex);
 740   }
 741
 742   applyVerificationOptions(ssl_);
 743
 744   if (sslSession_ != nullptr) {
 745     SSL_set_session(ssl_, sslSession_);
 746     SSL_SESSION_free(sslSession_);
 747     sslSession_ = nullptr;
 748   }
 749 #if OPENSSL_VERSION_NUMBER >= 0x1000105fL && !defined(OPENSSL_NO_TLSEXT)
 750   if (tlsextHostname_.size()) {
 751     SSL_set_tlsext_host_name(ssl_, tlsextHostname_.c_str());
 752   }
 753 #endif
 754
 755   SSL_set_ex_data(ssl_, getSSLExDataIndex(), this);
 756
 757   if (timeout > 0) {
 758     handshakeTimeout_.scheduleTimeout(timeout);
 759   }
 760
 761   handleConnect();
 762 }
 763
 764 SSL_SESSION *AsyncSSLSocket::getSSLSession() {
 765   if (ssl_ != nullptr && sslState_ == STATE_ESTABLISHED) {
 766     return SSL_get1_session(ssl_);
 767   }
 768
 769   return sslSession_;
 770 }
 771
 772 const SSL* AsyncSSLSocket::getSSL() const {
 773   return ssl_;
 774 }
 775
 776 void AsyncSSLSocket::setSSLSession(SSL_SESSION *session, bool takeOwnership) {
 777   sslSession_ = session;
 778   if (!takeOwnership && session != nullptr) {
 779     // Increment the reference count
 780     CRYPTO_add(&session->references, 1, CRYPTO_LOCK_SSL_SESSION);
 781   }
 782 }
 783
 784 void AsyncSSLSocket::getSelectedNextProtocol(
 785     const unsigned char** protoName,
 786     unsigned* protoLen,
 787     SSLContext::NextProtocolType* protoType) const {
 788   if (!getSelectedNextProtocolNoThrow(protoName, protoLen, protoType)) {
 789     throw AsyncSocketException(AsyncSocketException::NOT_SUPPORTED,
 790                               "NPN not supported");
 791   }
 792 }
 793
 794 bool AsyncSSLSocket::getSelectedNextProtocolNoThrow(
 795     const unsigned char** protoName,
 796     unsigned* protoLen,
 797     SSLContext::NextProtocolType* protoType) const {
 798   *protoName = nullptr;
 799   *protoLen = 0;
 800 #if OPENSSL_VERSION_NUMBER >= 0x1000200fL && !defined(OPENSSL_NO_TLSEXT)
 801   SSL_get0_alpn_selected(ssl_, protoName, protoLen);
 802   if (*protoLen > 0) {
 803     if (protoType) {
 804       *protoType = SSLContext::NextProtocolType::ALPN;
 805     }
 806     return true;
 807   }
 808 #endif
 809 #ifdef OPENSSL_NPN_NEGOTIATED
 810   SSL_get0_next_proto_negotiated(ssl_, protoName, protoLen);
 811   if (protoType) {
 812     *protoType = SSLContext::NextProtocolType::NPN;
 813   }
 814   return true;
 815 #else
 816   (void)protoType;
 817   return false;
 818 #endif
 819 }
 820
 821 bool AsyncSSLSocket::getSSLSessionReused() const {
 822   if (ssl_ != nullptr && sslState_ == STATE_ESTABLISHED) {
 823     return SSL_session_reused(ssl_);
 824   }
 825   return false;
 826 }
 827
 828 const char *AsyncSSLSocket::getNegotiatedCipherName() const {
 829   return (ssl_ != nullptr) ? SSL_get_cipher_name(ssl_) : nullptr;
 830 }
 831
 832 /* static */
 833 const char* AsyncSSLSocket::getSSLServerNameFromSSL(SSL* ssl) {
 834   if (ssl == nullptr) {
 835     return nullptr;
 836   }
 837 #ifdef SSL_CTRL_SET_TLSEXT_SERVERNAME_CB
 838   return SSL_get_servername(ssl, TLSEXT_NAMETYPE_host_name);
 839 #else
 840   return nullptr;
 841 #endif
 842 }
 843
 844 const char *AsyncSSLSocket::getSSLServerName() const {
 845 #ifdef SSL_CTRL_SET_TLSEXT_SERVERNAME_CB
 846   return getSSLServerNameFromSSL(ssl_);
 847 #else
 848   throw AsyncSocketException(AsyncSocketException::NOT_SUPPORTED,
 849                              "SNI not supported");
 850 #endif
 851 }
 852
 853 const char *AsyncSSLSocket::getSSLServerNameNoThrow() const {
 854   return getSSLServerNameFromSSL(ssl_);
 855 }
 856
 857 int AsyncSSLSocket::getSSLVersion() const {
 858   return (ssl_ != nullptr) ? SSL_version(ssl_) : 0;
 859 }
 860
 861 const char *AsyncSSLSocket::getSSLCertSigAlgName() const {
 862   X509 *cert = (ssl_ != nullptr) ? SSL_get_certificate(ssl_) : nullptr;
 863   if (cert) {
 864     int nid = OBJ_obj2nid(cert->sig_alg->algorithm);
 865     return OBJ_nid2ln(nid);
 866   }
 867   return nullptr;
 868 }
 869
 870 int AsyncSSLSocket::getSSLCertSize() const {
 871   int certSize = 0;
 872   X509 *cert = (ssl_ != nullptr) ? SSL_get_certificate(ssl_) : nullptr;
 873   if (cert) {
 874     EVP_PKEY *key = X509_get_pubkey(cert);
 875     certSize = EVP_PKEY_bits(key);
 876     EVP_PKEY_free(key);
 877   }
 878   return certSize;
 879 }
 880
 881 bool AsyncSSLSocket::willBlock(int ret,
 882                                int* sslErrorOut,
 883                                unsigned long* errErrorOut) noexcept {
 884   *errErrorOut = 0;
 885   int error = *sslErrorOut = SSL_get_error(ssl_, ret);
 886   if (error == SSL_ERROR_WANT_READ) {
 887     // Register for read event if not already.
 888     updateEventRegistration(EventHandler::READ, EventHandler::WRITE);
 889     return true;
 890   } else if (error == SSL_ERROR_WANT_WRITE) {
 891     VLOG(3) << "AsyncSSLSocket(fd=" << fd_
 892             << ", state=" << int(state_) << ", sslState="
 893             << sslState_ << ", events=" << eventFlags_ << "): "
 894             << "SSL_ERROR_WANT_WRITE";
 895     // Register for write event if not already.
 896     updateEventRegistration(EventHandler::WRITE, EventHandler::READ);
 897     return true;
 898 #ifdef SSL_ERROR_WANT_SESS_CACHE_LOOKUP
 899   } else if (error == SSL_ERROR_WANT_SESS_CACHE_LOOKUP) {
 900     // We will block but we can't register our own socket.  The callback that
 901     // triggered this code will re-call handleAccept at the appropriate time.
 902
 903     // We can only get here if the linked libssl.so has support for this feature
 904     // as well, otherwise SSL_get_error cannot return our error code.
 905     sslState_ = STATE_CACHE_LOOKUP;
 906
 907     // Unregister for all events while blocked here
 908     updateEventRegistration(EventHandler::NONE,
 909                             EventHandler::READ | EventHandler::WRITE);
 910
 911     // The timeout (if set) keeps running here
 912     return true;
 913 #endif
 914   } else if (0
 915 #ifdef SSL_ERROR_WANT_RSA_ASYNC_PENDING
 916       || error == SSL_ERROR_WANT_RSA_ASYNC_PENDING
 917 #endif
 918 #ifdef SSL_ERROR_WANT_ECDSA_ASYNC_PENDING
 919       || error == SSL_ERROR_WANT_ECDSA_ASYNC_PENDING
 920 #endif
 921       ) {
 922     // Our custom openssl function has kicked off an async request to do
 923     // rsa/ecdsa private key operation.  When that call returns, a callback will
 924     // be invoked that will re-call handleAccept.
 925     sslState_ = STATE_ASYNC_PENDING;
 926
 927     // Unregister for all events while blocked here
 928     updateEventRegistration(
 929       EventHandler::NONE,
 930       EventHandler::READ | EventHandler::WRITE
 931     );
 932
 933     // The timeout (if set) keeps running here
 934     return true;
 935   } else {
 936     unsigned long lastError = *errErrorOut = ERR_get_error();
 937     VLOG(6) << "AsyncSSLSocket(fd=" << fd_ << ", "
 938             << "state=" << state_ << ", "
 939             << "sslState=" << sslState_ << ", "
 940             << "events=" << std::hex << eventFlags_ << "): "
 941             << "SSL error: " << error << ", "
 942             << "errno: " << errno << ", "
 943             << "ret: " << ret << ", "
 944             << "read: " << BIO_number_read(SSL_get_rbio(ssl_)) << ", "
 945             << "written: " << BIO_number_written(SSL_get_wbio(ssl_)) << ", "
 946             << "func: " << ERR_func_error_string(lastError) << ", "
 947             << "reason: " << ERR_reason_error_string(lastError);
 948     return false;
 949   }
 950 }
 951
 952 void AsyncSSLSocket::checkForImmediateRead() noexcept {
 953   // openssl may have buffered data that it read from the socket already.
 954   // In this case we have to process it immediately, rather than waiting for
 955   // the socket to become readable again.
 956   if (ssl_ != nullptr && SSL_pending(ssl_) > 0) {
 957     AsyncSocket::handleRead();
 958   }
 959 }
 960
 961 void
 962 AsyncSSLSocket::restartSSLAccept()
 963 {
 964   VLOG(3) << "AsyncSSLSocket::restartSSLAccept() this=" << this << ", fd=" << fd_
 965           << ", state=" << int(state_) << ", "
 966           << "sslState=" << sslState_ << ", events=" << eventFlags_;
 967   DestructorGuard dg(this);
 968   assert(
 969     sslState_ == STATE_CACHE_LOOKUP ||
 970     sslState_ == STATE_ASYNC_PENDING ||
 971     sslState_ == STATE_ERROR ||
 972     sslState_ == STATE_CLOSED
 973   );
 974   if (sslState_ == STATE_CLOSED) {
 975     // I sure hope whoever closed this socket didn't delete it already,
 976     // but this is not strictly speaking an error
 977     return;
 978   }
 979   if (sslState_ == STATE_ERROR) {
 980     // go straight to fail if timeout expired during lookup
 981     AsyncSocketException ex(AsyncSocketException::TIMED_OUT,
 982                            "SSL accept timed out");
 983     failHandshake(__func__, ex);
 984     return;
 985   }
 986   sslState_ = STATE_ACCEPTING;
 987   this->handleAccept();
 988 }
 989
 990 void
 991 AsyncSSLSocket::handleAccept() noexcept {
 992   VLOG(3) << "AsyncSSLSocket::handleAccept() this=" << this
 993           << ", fd=" << fd_ << ", state=" << int(state_) << ", "
 994           << "sslState=" << sslState_ << ", events=" << eventFlags_;
 995   assert(server_);
 996   assert(state_ == StateEnum::ESTABLISHED &&
 997          sslState_ == STATE_ACCEPTING);
 998   if (!ssl_) {
 999     /* lazily create the SSL structure */
1000     try {
1001       ssl_ = ctx_->createSSL();
1002     } catch (std::exception &e) {
1003       sslState_ = STATE_ERROR;
1004       AsyncSocketException ex(AsyncSocketException::INTERNAL_ERROR,
1005                              "error calling SSLContext::createSSL()");
1006       LOG(ERROR) << "AsyncSSLSocket::handleAccept(this=" << this
1007                  << ", fd=" << fd_ << "): " << e.what();
1008       return failHandshake(__func__, ex);
1009     }
1010
1011     if (!setupSSLBio()) {
1012       sslState_ = STATE_ERROR;
1013       AsyncSocketException ex(
1014           AsyncSocketException::INTERNAL_ERROR, "error creating write bio");
1015       return failHandshake(__func__, ex);
1016     }
1017
1018     SSL_set_ex_data(ssl_, getSSLExDataIndex(), this);
1019
1020     applyVerificationOptions(ssl_);
1021   }
1022
1023   if (server_ && parseClientHello_) {
1024     SSL_set_msg_callback(ssl_, &AsyncSSLSocket::clientHelloParsingCallback);
1025     SSL_set_msg_callback_arg(ssl_, this);
1026   }
1027
1028   int ret = SSL_accept(ssl_);
1029   if (ret <= 0) {
1030     int sslError;
1031     unsigned long errError;
1032     int errnoCopy = errno;
1033     if (willBlock(ret, &sslError, &errError)) {
1034       return;
1035     } else {
1036       sslState_ = STATE_ERROR;
1037       SSLException ex(sslError, errError, ret, errnoCopy);
1038       return failHandshake(__func__, ex);
1039     }
1040   }
1041
1042   handshakeComplete_ = true;
1043   updateEventRegistration(0, EventHandler::READ | EventHandler::WRITE);
1044
1045   // Move into STATE_ESTABLISHED in the normal case that we are in
1046   // STATE_ACCEPTING.
1047   sslState_ = STATE_ESTABLISHED;
1048
1049   VLOG(3) << "AsyncSSLSocket " << this << ": fd " << fd_
1050           << " successfully accepted; state=" << int(state_)
1051           << ", sslState=" << sslState_ << ", events=" << eventFlags_;
1052
1053   // Remember the EventBase we are attached to, before we start invoking any
1054   // callbacks (since the callbacks may call detachEventBase()).
1055   EventBase* originalEventBase = eventBase_;
1056
1057   // Call the accept callback.
1058   invokeHandshakeCB();
1059
1060   // Note that the accept callback may have changed our state.
1061   // (set or unset the read callback, called write(), closed the socket, etc.)
1062   // The following code needs to handle these situations correctly.
1063   //
1064   // If the socket has been closed, readCallback_ and writeReqHead_ will
1065   // always be nullptr, so that will prevent us from trying to read or write.
1066   //
1067   // The main thing to check for is if eventBase_ is still originalEventBase.
1068   // If not, we have been detached from this event base, so we shouldn't
1069   // perform any more operations.
1070   if (eventBase_ != originalEventBase) {
1071     return;
1072   }
1073
1074   AsyncSocket::handleInitialReadWrite();
1075 }
1076
1077 void
1078 AsyncSSLSocket::handleConnect() noexcept {
1079   VLOG(3) <<  "AsyncSSLSocket::handleConnect() this=" << this
1080           << ", fd=" << fd_ << ", state=" << int(state_) << ", "
1081           << "sslState=" << sslState_ << ", events=" << eventFlags_;
1082   assert(!server_);
1083   if (state_ < StateEnum::ESTABLISHED) {
1084     return AsyncSocket::handleConnect();
1085   }
1086
1087   assert(state_ == StateEnum::ESTABLISHED &&
1088          sslState_ == STATE_CONNECTING);
1089   assert(ssl_);
1090
1091   int ret = SSL_connect(ssl_);
1092   if (ret <= 0) {
1093     int sslError;
1094     unsigned long errError;
1095     int errnoCopy = errno;
1096     if (willBlock(ret, &sslError, &errError)) {
1097       return;
1098     } else {
1099       sslState_ = STATE_ERROR;
1100       SSLException ex(sslError, errError, ret, errnoCopy);
1101       return failHandshake(__func__, ex);
1102     }
1103   }
1104
1105   handshakeComplete_ = true;
1106   updateEventRegistration(0, EventHandler::READ | EventHandler::WRITE);
1107
1108   // Move into STATE_ESTABLISHED in the normal case that we are in
1109   // STATE_CONNECTING.
1110   sslState_ = STATE_ESTABLISHED;
1111
1112   VLOG(3) << "AsyncSSLSocket " << this << ": "
1113           << "fd " << fd_ << " successfully connected; "
1114           << "state=" << int(state_) << ", sslState=" << sslState_
1115           << ", events=" << eventFlags_;
1116
1117   // Remember the EventBase we are attached to, before we start invoking any
1118   // callbacks (since the callbacks may call detachEventBase()).
1119   EventBase* originalEventBase = eventBase_;
1120
1121   // Call the handshake callback.
1122   invokeHandshakeCB();
1123
1124   // Note that the connect callback may have changed our state.
1125   // (set or unset the read callback, called write(), closed the socket, etc.)
1126   // The following code needs to handle these situations correctly.
1127   //
1128   // If the socket has been closed, readCallback_ and writeReqHead_ will
1129   // always be nullptr, so that will prevent us from trying to read or write.
1130   //
1131   // The main thing to check for is if eventBase_ is still originalEventBase.
1132   // If not, we have been detached from this event base, so we shouldn't
1133   // perform any more operations.
1134   if (eventBase_ != originalEventBase) {
1135     return;
1136   }
1137
1138   AsyncSocket::handleInitialReadWrite();
1139 }
1140
1141 void AsyncSSLSocket::setReadCB(ReadCallback *callback) {
1142 #ifdef SSL_MODE_MOVE_BUFFER_OWNERSHIP
1143   // turn on the buffer movable in openssl
1144   if (bufferMovableEnabled_ && ssl_ != nullptr && !isBufferMovable_ &&
1145       callback != nullptr && callback->isBufferMovable()) {
1146     SSL_set_mode(ssl_, SSL_get_mode(ssl_) | SSL_MODE_MOVE_BUFFER_OWNERSHIP);
1147     isBufferMovable_ = true;
1148   }
1149 #endif
1150
1151   AsyncSocket::setReadCB(callback);
1152 }
1153
1154 void AsyncSSLSocket::setBufferMovableEnabled(bool enabled) {
1155   bufferMovableEnabled_ = enabled;
1156 }
1157
1158 void AsyncSSLSocket::prepareReadBuffer(void** buf, size_t* buflen) noexcept {
1159   CHECK(readCallback_);
1160   if (isBufferMovable_) {
1161     *buf = nullptr;
1162     *buflen = 0;
1163   } else {
1164     // buf is necessary for SSLSocket without SSL_MODE_MOVE_BUFFER_OWNERSHIP
1165     readCallback_->getReadBuffer(buf, buflen);
1166   }
1167 }
1168
1169 void
1170 AsyncSSLSocket::handleRead() noexcept {
1171   VLOG(5) << "AsyncSSLSocket::handleRead() this=" << this << ", fd=" << fd_
1172           << ", state=" << int(state_) << ", "
1173           << "sslState=" << sslState_ << ", events=" << eventFlags_;
1174   if (state_ < StateEnum::ESTABLISHED) {
1175     return AsyncSocket::handleRead();
1176   }
1177
1178
1179   if (sslState_ == STATE_ACCEPTING) {
1180     assert(server_);
1181     handleAccept();
1182     return;
1183   }
1184   else if (sslState_ == STATE_CONNECTING) {
1185     assert(!server_);
1186     handleConnect();
1187     return;
1188   }
1189
1190   // Normal read
1191   AsyncSocket::handleRead();
1192 }
1193
1194 AsyncSocket::ReadResult
1195 AsyncSSLSocket::performRead(void** buf, size_t* buflen, size_t* offset) {
1196   VLOG(4) << "AsyncSSLSocket::performRead() this=" << this << ", buf=" << *buf
1197           << ", buflen=" << *buflen;
1198
1199   if (sslState_ == STATE_UNENCRYPTED) {
1200     return AsyncSocket::performRead(buf, buflen, offset);
1201   }
1202
1203   ssize_t bytes = 0;
1204   if (!isBufferMovable_) {
1205     bytes = SSL_read(ssl_, *buf, *buflen);
1206   }
1207 #ifdef SSL_MODE_MOVE_BUFFER_OWNERSHIP
1208   else {
1209     bytes = SSL_read_buf(ssl_, buf, (int *) offset, (int *) buflen);
1210   }
1211 #endif
1212
1213   if (server_ && renegotiateAttempted_) {
1214     LOG(ERROR) << "AsyncSSLSocket(fd=" << fd_ << ", state=" << int(state_)
1215                << ", sslstate=" << sslState_ << ", events=" << eventFlags_
1216                << "): client intitiated SSL renegotiation not permitted";
1217     return ReadResult(
1218         READ_ERROR,
1219         folly::make_unique<SSLException>(SSLError::CLIENT_RENEGOTIATION));
1220   }
1221   if (bytes <= 0) {
1222     int error = SSL_get_error(ssl_, bytes);
1223     if (error == SSL_ERROR_WANT_READ) {
1224       // The caller will register for read event if not already.
1225       if (errno == EWOULDBLOCK || errno == EAGAIN) {
1226         return ReadResult(READ_BLOCKING);
1227       } else {
1228         return ReadResult(READ_ERROR);
1229       }
1230     } else if (error == SSL_ERROR_WANT_WRITE) {
1231       // TODO: Even though we are attempting to read data, SSL_read() may
1232       // need to write data if renegotiation is being performed.  We currently
1233       // don't support this and just fail the read.
1234       LOG(ERROR) << "AsyncSSLSocket(fd=" << fd_ << ", state=" << int(state_)
1235                  << ", sslState=" << sslState_ << ", events=" << eventFlags_
1236                  << "): unsupported SSL renegotiation during read";
1237       return ReadResult(
1238           READ_ERROR,
1239           folly::make_unique<SSLException>(SSLError::INVALID_RENEGOTIATION));
1240     } else {
1241       if (zero_return(error, bytes)) {
1242         return ReadResult(bytes);
1243       }
1244       long errError = ERR_get_error();
1245       VLOG(6) << "AsyncSSLSocket(fd=" << fd_ << ", "
1246               << "state=" << state_ << ", "
1247               << "sslState=" << sslState_ << ", "
1248               << "events=" << std::hex << eventFlags_ << "): "
1249               << "bytes: " << bytes << ", "
1250               << "error: " << error << ", "
1251               << "errno: " << errno << ", "
1252               << "func: " << ERR_func_error_string(errError) << ", "
1253               << "reason: " << ERR_reason_error_string(errError);
1254       return ReadResult(
1255           READ_ERROR,
1256           folly::make_unique<SSLException>(error, errError, bytes, errno));
1257     }
1258   } else {
1259     appBytesReceived_ += bytes;
1260     return ReadResult(bytes);
1261   }
1262 }
1263
1264 void AsyncSSLSocket::handleWrite() noexcept {
1265   VLOG(5) << "AsyncSSLSocket::handleWrite() this=" << this << ", fd=" << fd_
1266           << ", state=" << int(state_) << ", "
1267           << "sslState=" << sslState_ << ", events=" << eventFlags_;
1268   if (state_ < StateEnum::ESTABLISHED) {
1269     return AsyncSocket::handleWrite();
1270   }
1271
1272   if (sslState_ == STATE_ACCEPTING) {
1273     assert(server_);
1274     handleAccept();
1275     return;
1276   }
1277
1278   if (sslState_ == STATE_CONNECTING) {
1279     assert(!server_);
1280     handleConnect();
1281     return;
1282   }
1283
1284   // Normal write
1285   AsyncSocket::handleWrite();
1286 }
1287
1288 AsyncSocket::WriteResult AsyncSSLSocket::interpretSSLError(int rc, int error) {
1289   if (error == SSL_ERROR_WANT_READ) {
1290     // Even though we are attempting to write data, SSL_write() may
1291     // need to read data if renegotiation is being performed.  We currently
1292     // don't support this and just fail the write.
1293     LOG(ERROR) << "AsyncSSLSocket(fd=" << fd_ << ", state=" << int(state_)
1294                << ", sslState=" << sslState_ << ", events=" << eventFlags_
1295                << "): "
1296                << "unsupported SSL renegotiation during write";
1297     return WriteResult(
1298         WRITE_ERROR,
1299         folly::make_unique<SSLException>(SSLError::INVALID_RENEGOTIATION));
1300   } else {
1301     if (zero_return(error, rc)) {
1302       return WriteResult(0);
1303     }
1304     auto errError = ERR_get_error();
1305     VLOG(3) << "ERROR: AsyncSSLSocket(fd=" << fd_ << ", state=" << int(state_)
1306             << ", sslState=" << sslState_ << ", events=" << eventFlags_ << "): "
1307             << "SSL error: " << error << ", errno: " << errno
1308             << ", func: " << ERR_func_error_string(errError)
1309             << ", reason: " << ERR_reason_error_string(errError);
1310     return WriteResult(
1311         WRITE_ERROR,
1312         folly::make_unique<SSLException>(error, errError, rc, errno));
1313   }
1314 }
1315
1316 AsyncSocket::WriteResult AsyncSSLSocket::performWrite(
1317     const iovec* vec,
1318     uint32_t count,
1319     WriteFlags flags,
1320     uint32_t* countWritten,
1321     uint32_t* partialWritten) {
1322   if (sslState_ == STATE_UNENCRYPTED) {
1323     return AsyncSocket::performWrite(
1324       vec, count, flags, countWritten, partialWritten);
1325   }
1326   if (sslState_ != STATE_ESTABLISHED) {
1327     LOG(ERROR) << "AsyncSSLSocket(fd=" << fd_ << ", state=" << int(state_)
1328                << ", sslState=" << sslState_
1329                << ", events=" << eventFlags_ << "): "
1330                << "TODO: AsyncSSLSocket currently does not support calling "
1331                << "write() before the handshake has fully completed";
1332     return WriteResult(
1333         WRITE_ERROR, folly::make_unique<SSLException>(SSLError::EARLY_WRITE));
1334   }
1335
1336   bool cork = isSet(flags, WriteFlags::CORK);
1337   CorkGuard guard(fd_, count > 1, cork, &corked_);
1338
1339   // Declare a buffer used to hold small write requests.  It could point to a
1340   // memory block either on stack or on heap. If it is on heap, we release it
1341   // manually when scope exits
1342   char* combinedBuf{nullptr};
1343   SCOPE_EXIT {
1344     // Note, always keep this check consistent with what we do below
1345     if (combinedBuf != nullptr && minWriteSize_ > MAX_STACK_BUF_SIZE) {
1346       delete[] combinedBuf;
1347     }
1348   };
1349
1350   *countWritten = 0;
1351   *partialWritten = 0;
1352   ssize_t totalWritten = 0;
1353   size_t bytesStolenFromNextBuffer = 0;
1354   for (uint32_t i = 0; i < count; i++) {
1355     const iovec* v = vec + i;
1356     size_t offset = bytesStolenFromNextBuffer;
1357     bytesStolenFromNextBuffer = 0;
1358     size_t len = v->iov_len - offset;
1359     const void* buf;
1360     if (len == 0) {
1361       (*countWritten)++;
1362       continue;
1363     }
1364     buf = ((const char*)v->iov_base) + offset;
1365
1366     ssize_t bytes;
1367     uint32_t buffersStolen = 0;
1368     if ((len < minWriteSize_) && ((i + 1) < count)) {
1369       // Combine this buffer with part or all of the next buffers in
1370       // order to avoid really small-grained calls to SSL_write().
1371       // Each call to SSL_write() produces a separate record in
1372       // the egress SSL stream, and we've found that some low-end
1373       // mobile clients can't handle receiving an HTTP response
1374       // header and the first part of the response body in two
1375       // separate SSL records (even if those two records are in
1376       // the same TCP packet).
1377
1378       if (combinedBuf == nullptr) {
1379         if (minWriteSize_ > MAX_STACK_BUF_SIZE) {
1380           // Allocate the buffer on heap
1381           combinedBuf = new char[minWriteSize_];
1382         } else {
1383           // Allocate the buffer on stack
1384           combinedBuf = (char*)alloca(minWriteSize_);
1385         }
1386       }
1387       assert(combinedBuf != nullptr);
1388
1389       memcpy(combinedBuf, buf, len);
1390       do {
1391         // INVARIANT: i + buffersStolen == complete chunks serialized
1392         uint32_t nextIndex = i + buffersStolen + 1;
1393         bytesStolenFromNextBuffer = std::min(vec[nextIndex].iov_len,
1394                                              minWriteSize_ - len);
1395         memcpy(combinedBuf + len, vec[nextIndex].iov_base,
1396                bytesStolenFromNextBuffer);
1397         len += bytesStolenFromNextBuffer;
1398         if (bytesStolenFromNextBuffer < vec[nextIndex].iov_len) {
1399           // couldn't steal the whole buffer
1400           break;
1401         } else {
1402           bytesStolenFromNextBuffer = 0;
1403           buffersStolen++;
1404         }
1405       } while ((i + buffersStolen + 1) < count && (len < minWriteSize_));
1406       bytes = eorAwareSSLWrite(
1407         ssl_, combinedBuf, len,
1408         (isSet(flags, WriteFlags::EOR) && i + buffersStolen + 1 == count));
1409
1410     } else {
1411       bytes = eorAwareSSLWrite(ssl_, buf, len,
1412                            (isSet(flags, WriteFlags::EOR) && i + 1 == count));
1413     }
1414
1415     if (bytes <= 0) {
1416       int error = SSL_get_error(ssl_, bytes);
1417       if (error == SSL_ERROR_WANT_WRITE) {
1418         // The caller will register for write event if not already.
1419         *partialWritten = offset;
1420         return WriteResult(totalWritten);
1421       }
1422       auto writeResult = interpretSSLError(bytes, error);
1423       if (writeResult.writeReturn < 0) {
1424         return writeResult;
1425       } // else fall through to below to correctly record totalWritten
1426     }
1427
1428     totalWritten += bytes;
1429
1430     if (bytes == (ssize_t)len) {
1431       // The full iovec is written.
1432       (*countWritten) += 1 + buffersStolen;
1433       i += buffersStolen;
1434       // continue
1435     } else {
1436       bytes += offset; // adjust bytes to account for all of v
1437       while (bytes >= (ssize_t)v->iov_len) {
1438         // We combined this buf with part or all of the next one, and
1439         // we managed to write all of this buf but not all of the bytes
1440         // from the next one that we'd hoped to write.
1441         bytes -= v->iov_len;
1442         (*countWritten)++;
1443         v = &(vec[++i]);
1444       }
1445       *partialWritten = bytes;
1446       return WriteResult(totalWritten);
1447     }
1448   }
1449
1450   return WriteResult(totalWritten);
1451 }
1452
1453 int AsyncSSLSocket::eorAwareSSLWrite(SSL *ssl, const void *buf, int n,
1454                                       bool eor) {
1455   if (eor && trackEor_) {
1456     if (appEorByteNo_) {
1457       // cannot track for more than one app byte EOR
1458       CHECK(appEorByteNo_ == appBytesWritten_ + n);
1459     } else {
1460       appEorByteNo_ = appBytesWritten_ + n;
1461     }
1462
1463     // 1. It is fine to keep updating minEorRawByteNo_.
1464     // 2. It is _min_ in the sense that SSL record will add some overhead.
1465     minEorRawByteNo_ = getRawBytesWritten() + n;
1466   }
1467
1468   n = sslWriteImpl(ssl, buf, n);
1469   if (n > 0) {
1470     appBytesWritten_ += n;
1471     if (appEorByteNo_) {
1472       if (getRawBytesWritten() >= minEorRawByteNo_) {
1473         minEorRawByteNo_ = 0;
1474       }
1475       if(appBytesWritten_ == appEorByteNo_) {
1476         appEorByteNo_ = 0;
1477       } else {
1478         CHECK(appBytesWritten_ < appEorByteNo_);
1479       }
1480     }
1481   }
1482   return n;
1483 }
1484
1485 void AsyncSSLSocket::sslInfoCallback(const SSL* ssl, int where, int ret) {
1486   AsyncSSLSocket *sslSocket = AsyncSSLSocket::getFromSSL(ssl);
1487   if (sslSocket->handshakeComplete_ && (where & SSL_CB_HANDSHAKE_START)) {
1488     sslSocket->renegotiateAttempted_ = true;
1489   }
1490   if (where & SSL_CB_READ_ALERT) {
1491     const char* type = SSL_alert_type_string(ret);
1492     if (type) {
1493       const char* desc = SSL_alert_desc_string(ret);
1494       sslSocket->alertsReceived_.emplace_back(
1495           *type, StringPiece(desc, std::strlen(desc)));
1496     }
1497   }
1498 }
1499
1500 int AsyncSSLSocket::bioWrite(BIO* b, const char* in, int inl) {
1501   int ret;
1502   struct msghdr msg;
1503   struct iovec iov;
1504   int flags = 0;
1505   AsyncSSLSocket* tsslSock;
1506
1507   iov.iov_base = const_cast<char*>(in);
1508   iov.iov_len = inl;
1509   memset(&msg, 0, sizeof(msg));
1510   msg.msg_iov = &iov;
1511   msg.msg_iovlen = 1;
1512
1513   auto appData = BIO_get_app_data(b);
1514   CHECK(appData);
1515
1516   tsslSock = reinterpret_cast<AsyncSSLSocket*>(appData);
1517   CHECK(tsslSock);
1518
1519   if (tsslSock->trackEor_ && tsslSock->minEorRawByteNo_ &&
1520       tsslSock->minEorRawByteNo_ <= BIO_number_written(b) + inl) {
1521     flags = MSG_EOR;
1522   }
1523
1524   ret = sendmsg(BIO_get_fd(b, nullptr), &msg, flags);
1525   BIO_clear_retry_flags(b);
1526   if (ret <= 0) {
1527     if (BIO_sock_should_retry(ret))
1528       BIO_set_retry_write(b);
1529   }
1530   return ret;
1531 }
1532
1533 int AsyncSSLSocket::sslVerifyCallback(int preverifyOk,
1534                                        X509_STORE_CTX* x509Ctx) {
1535   SSL* ssl = (SSL*) X509_STORE_CTX_get_ex_data(
1536     x509Ctx, SSL_get_ex_data_X509_STORE_CTX_idx());
1537   AsyncSSLSocket* self = AsyncSSLSocket::getFromSSL(ssl);
1538
1539   VLOG(3) <<  "AsyncSSLSocket::sslVerifyCallback() this=" << self << ", "
1540           << "fd=" << self->fd_ << ", preverifyOk=" << preverifyOk;
1541   return (self->handshakeCallback_) ?
1542     self->handshakeCallback_->handshakeVer(self, preverifyOk, x509Ctx) :
1543     preverifyOk;
1544 }
1545
1546 void AsyncSSLSocket::enableClientHelloParsing()  {
1547     parseClientHello_ = true;
1548     clientHelloInfo_.reset(new ssl::ClientHelloInfo());
1549 }
1550
1551 void AsyncSSLSocket::resetClientHelloParsing(SSL *ssl)  {
1552   SSL_set_msg_callback(ssl, nullptr);
1553   SSL_set_msg_callback_arg(ssl, nullptr);
1554   clientHelloInfo_->clientHelloBuf_.clear();
1555 }
1556
1557 void AsyncSSLSocket::clientHelloParsingCallback(int written,
1558                                                 int /* version */,
1559                                                 int contentType,
1560                                                 const void* buf,
1561                                                 size_t len,
1562                                                 SSL* ssl,
1563                                                 void* arg) {
1564   AsyncSSLSocket *sock = static_cast<AsyncSSLSocket*>(arg);
1565   if (written != 0) {
1566     sock->resetClientHelloParsing(ssl);
1567     return;
1568   }
1569   if (contentType != SSL3_RT_HANDSHAKE) {
1570     return;
1571   }
1572   if (len == 0) {
1573     return;
1574   }
1575
1576   auto& clientHelloBuf = sock->clientHelloInfo_->clientHelloBuf_;
1577   clientHelloBuf.append(IOBuf::wrapBuffer(buf, len));
1578   try {
1579     Cursor cursor(clientHelloBuf.front());
1580     if (cursor.read<uint8_t>() != SSL3_MT_CLIENT_HELLO) {
1581       sock->resetClientHelloParsing(ssl);
1582       return;
1583     }
1584
1585     if (cursor.totalLength() < 3) {
1586       clientHelloBuf.trimEnd(len);
1587       clientHelloBuf.append(IOBuf::copyBuffer(buf, len));
1588       return;
1589     }
1590
1591     uint32_t messageLength = cursor.read<uint8_t>();
1592     messageLength <<= 8;
1593     messageLength |= cursor.read<uint8_t>();
1594     messageLength <<= 8;
1595     messageLength |= cursor.read<uint8_t>();
1596     if (cursor.totalLength() < messageLength) {
1597       clientHelloBuf.trimEnd(len);
1598       clientHelloBuf.append(IOBuf::copyBuffer(buf, len));
1599       return;
1600     }
1601
1602     sock->clientHelloInfo_->clientHelloMajorVersion_ = cursor.read<uint8_t>();
1603     sock->clientHelloInfo_->clientHelloMinorVersion_ = cursor.read<uint8_t>();
1604
1605     cursor.skip(4); // gmt_unix_time
1606     cursor.skip(28); // random_bytes
1607
1608     cursor.skip(cursor.read<uint8_t>()); // session_id
1609
1610     uint16_t cipherSuitesLength = cursor.readBE<uint16_t>();
1611     for (int i = 0; i < cipherSuitesLength; i += 2) {
1612       sock->clientHelloInfo_->
1613         clientHelloCipherSuites_.push_back(cursor.readBE<uint16_t>());
1614     }
1615
1616     uint8_t compressionMethodsLength = cursor.read<uint8_t>();
1617     for (int i = 0; i < compressionMethodsLength; ++i) {
1618       sock->clientHelloInfo_->
1619         clientHelloCompressionMethods_.push_back(cursor.readBE<uint8_t>());
1620     }
1621
1622     if (cursor.totalLength() > 0) {
1623       uint16_t extensionsLength = cursor.readBE<uint16_t>();
1624       while (extensionsLength) {
1625         ssl::TLSExtension extensionType =
1626             static_cast<ssl::TLSExtension>(cursor.readBE<uint16_t>());
1627         sock->clientHelloInfo_->
1628           clientHelloExtensions_.push_back(extensionType);
1629         extensionsLength -= 2;
1630         uint16_t extensionDataLength = cursor.readBE<uint16_t>();
1631         extensionsLength -= 2;
1632
1633         if (extensionType == ssl::TLSExtension::SIGNATURE_ALGORITHMS) {
1634           cursor.skip(2);
1635           extensionDataLength -= 2;
1636           while (extensionDataLength) {
1637             ssl::HashAlgorithm hashAlg =
1638                 static_cast<ssl::HashAlgorithm>(cursor.readBE<uint8_t>());
1639             ssl::SignatureAlgorithm sigAlg =
1640                 static_cast<ssl::SignatureAlgorithm>(cursor.readBE<uint8_t>());
1641             extensionDataLength -= 2;
1642             sock->clientHelloInfo_->
1643               clientHelloSigAlgs_.emplace_back(hashAlg, sigAlg);
1644           }
1645         } else {
1646           cursor.skip(extensionDataLength);
1647           extensionsLength -= extensionDataLength;
1648         }
1649       }
1650     }
1651   } catch (std::out_of_range& e) {
1652     // we'll use what we found and cleanup below.
1653     VLOG(4) << "AsyncSSLSocket::clientHelloParsingCallback(): "
1654       << "buffer finished unexpectedly." << " AsyncSSLSocket socket=" << sock;
1655   }
1656
1657   sock->resetClientHelloParsing(ssl);
1658 }
1659
1660 } // namespace