folly/io/async/AsyncSSLSocket.h

   1 /*
   2  * Copyright 2015 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 #pragma once
  18
  19 #include <arpa/inet.h>
  20 #include <iomanip>
  21 #include <openssl/ssl.h>
  22
  23 #include <folly/Optional.h>
  24 #include <folly/String.h>
  25 #include <folly/io/async/AsyncSocket.h>
  26 #include <folly/io/async/SSLContext.h>
  27 #include <folly/io/async/AsyncTimeout.h>
  28 #include <folly/io/async/TimeoutManager.h>
  29
  30 #include <folly/Bits.h>
  31 #include <folly/io/IOBuf.h>
  32 #include <folly/io/Cursor.h>
  33
  34 namespace folly {
  35
  36 class SSLException: public folly::AsyncSocketException {
  37  public:
  38   SSLException(int sslError, int errno_copy);
  39
  40   int getSSLError() const { return error_; }
  41
  42  protected:
  43   int error_;
  44   char msg_[256];
  45 };
  46
  47 /**
  48  * A class for performing asynchronous I/O on an SSL connection.
  49  *
  50  * AsyncSSLSocket allows users to asynchronously wait for data on an
  51  * SSL connection, and to asynchronously send data.
  52  *
  53  * The APIs for reading and writing are intentionally asymmetric.
  54  * Waiting for data to read is a persistent API: a callback is
  55  * installed, and is notified whenever new data is available.  It
  56  * continues to be notified of new events until it is uninstalled.
  57  *
  58  * AsyncSSLSocket does not provide read timeout functionality,
  59  * because it typically cannot determine when the timeout should be
  60  * active.  Generally, a timeout should only be enabled when
  61  * processing is blocked waiting on data from the remote endpoint.
  62  * For server connections, the timeout should not be active if the
  63  * server is currently processing one or more outstanding requests for
  64  * this connection.  For client connections, the timeout should not be
  65  * active if there are no requests pending on the connection.
  66  * Additionally, if a client has multiple pending requests, it will
  67  * ususally want a separate timeout for each request, rather than a
  68  * single read timeout.
  69  *
  70  * The write API is fairly intuitive: a user can request to send a
  71  * block of data, and a callback will be informed once the entire
  72  * block has been transferred to the kernel, or on error.
  73  * AsyncSSLSocket does provide a send timeout, since most callers
  74  * want to give up if the remote end stops responding and no further
  75  * progress can be made sending the data.
  76  */
  77 class AsyncSSLSocket : public virtual AsyncSocket {
  78  public:
  79   typedef std::unique_ptr<AsyncSSLSocket, Destructor> UniquePtr;
  80   using X509_deleter = folly::static_function_deleter<X509, &X509_free>;
  81
  82   class HandshakeCB {
  83    public:
  84     virtual ~HandshakeCB() = default;
  85
  86     /**
  87      * handshakeVer() is invoked during handshaking to give the
  88      * application chance to validate it's peer's certificate.
  89      *
  90      * Note that OpenSSL performs only rudimentary internal
  91      * consistency verification checks by itself. Any other validation
  92      * like whether or not the certificate was issued by a trusted CA.
  93      * The default implementation of this callback mimics what what
  94      * OpenSSL does internally if SSL_VERIFY_PEER is set with no
  95      * verification callback.
  96      *
  97      * See the passages on verify_callback in SSL_CTX_set_verify(3)
  98      * for more details.
  99      */
 100     virtual bool handshakeVer(AsyncSSLSocket* /*sock*/,
 101                                  bool preverifyOk,
 102                                  X509_STORE_CTX* /*ctx*/) noexcept {
 103       return preverifyOk;
 104     }
 105
 106     /**
 107      * handshakeSuc() is called when a new SSL connection is
 108      * established, i.e., after SSL_accept/connect() returns successfully.
 109      *
 110      * The HandshakeCB will be uninstalled before handshakeSuc()
 111      * is called.
 112      *
 113      * @param sock  SSL socket on which the handshake was initiated
 114      */
 115     virtual void handshakeSuc(AsyncSSLSocket *sock) noexcept = 0;
 116
 117     /**
 118      * handshakeErr() is called if an error occurs while
 119      * establishing the SSL connection.
 120      *
 121      * The HandshakeCB will be uninstalled before handshakeErr()
 122      * is called.
 123      *
 124      * @param sock  SSL socket on which the handshake was initiated
 125      * @param ex  An exception representing the error.
 126      */
 127     virtual void handshakeErr(
 128       AsyncSSLSocket *sock,
 129       const AsyncSocketException& ex)
 130       noexcept = 0;
 131   };
 132
 133   class HandshakeTimeout : public AsyncTimeout {
 134    public:
 135     HandshakeTimeout(AsyncSSLSocket* sslSocket, EventBase* eventBase)
 136       : AsyncTimeout(eventBase)
 137       , sslSocket_(sslSocket) {}
 138
 139     virtual void timeoutExpired() noexcept {
 140       sslSocket_->timeoutExpired();
 141     }
 142
 143    private:
 144     AsyncSSLSocket* sslSocket_;
 145   };
 146
 147
 148   /**
 149    * These are passed to the application via errno, packed in an SSL err which
 150    * are outside the valid errno range.  The values are chosen to be unique
 151    * against values in ssl.h
 152    */
 153   enum SSLError {
 154     SSL_CLIENT_RENEGOTIATION_ATTEMPT = 900,
 155     SSL_INVALID_RENEGOTIATION = 901,
 156     SSL_EARLY_WRITE = 902
 157   };
 158
 159   /**
 160    * Create a client AsyncSSLSocket
 161    */
 162   AsyncSSLSocket(const std::shared_ptr<folly::SSLContext> &ctx,
 163                  EventBase* evb, bool deferSecurityNegotiation = false);
 164
 165   /**
 166    * Create a server/client AsyncSSLSocket from an already connected
 167    * socket file descriptor.
 168    *
 169    * Note that while AsyncSSLSocket enables TCP_NODELAY for sockets it creates
 170    * when connecting, it does not change the socket options when given an
 171    * existing file descriptor.  If callers want TCP_NODELAY enabled when using
 172    * this version of the constructor, they need to explicitly call
 173    * setNoDelay(true) after the constructor returns.
 174    *
 175    * @param ctx             SSL context for this connection.
 176    * @param evb EventBase that will manage this socket.
 177    * @param fd  File descriptor to take over (should be a connected socket).
 178    * @param server Is socket in server mode?
 179    * @param deferSecurityNegotiation
 180    *          unencrypted data can be sent before sslConn/Accept
 181    */
 182   AsyncSSLSocket(const std::shared_ptr<folly::SSLContext>& ctx,
 183                  EventBase* evb, int fd,
 184                  bool server = true, bool deferSecurityNegotiation = false);
 185
 186
 187   /**
 188    * Helper function to create a server/client shared_ptr<AsyncSSLSocket>.
 189    */
 190   static std::shared_ptr<AsyncSSLSocket> newSocket(
 191     const std::shared_ptr<folly::SSLContext>& ctx,
 192     EventBase* evb, int fd, bool server=true,
 193     bool deferSecurityNegotiation = false) {
 194     return std::shared_ptr<AsyncSSLSocket>(
 195       new AsyncSSLSocket(ctx, evb, fd, server, deferSecurityNegotiation),
 196       Destructor());
 197   }
 198
 199   /**
 200    * Helper function to create a client shared_ptr<AsyncSSLSocket>.
 201    */
 202   static std::shared_ptr<AsyncSSLSocket> newSocket(
 203     const std::shared_ptr<folly::SSLContext>& ctx,
 204     EventBase* evb, bool deferSecurityNegotiation = false) {
 205     return std::shared_ptr<AsyncSSLSocket>(
 206       new AsyncSSLSocket(ctx, evb, deferSecurityNegotiation),
 207       Destructor());
 208   }
 209
 210
 211 #if OPENSSL_VERSION_NUMBER >= 0x1000105fL && !defined(OPENSSL_NO_TLSEXT)
 212   /**
 213    * Create a client AsyncSSLSocket with tlsext_servername in
 214    * the Client Hello message.
 215    */
 216   AsyncSSLSocket(const std::shared_ptr<folly::SSLContext> &ctx,
 217                   EventBase* evb,
 218                  const std::string& serverName,
 219                 bool deferSecurityNegotiation = false);
 220
 221   /**
 222    * Create a client AsyncSSLSocket from an already connected
 223    * socket file descriptor.
 224    *
 225    * Note that while AsyncSSLSocket enables TCP_NODELAY for sockets it creates
 226    * when connecting, it does not change the socket options when given an
 227    * existing file descriptor.  If callers want TCP_NODELAY enabled when using
 228    * this version of the constructor, they need to explicitly call
 229    * setNoDelay(true) after the constructor returns.
 230    *
 231    * @param ctx  SSL context for this connection.
 232    * @param evb  EventBase that will manage this socket.
 233    * @param fd   File descriptor to take over (should be a connected socket).
 234    * @param serverName tlsext_hostname that will be sent in ClientHello.
 235    */
 236   AsyncSSLSocket(const std::shared_ptr<folly::SSLContext>& ctx,
 237                   EventBase* evb,
 238                   int fd,
 239                  const std::string& serverName,
 240                 bool deferSecurityNegotiation = false);
 241
 242   static std::shared_ptr<AsyncSSLSocket> newSocket(
 243     const std::shared_ptr<folly::SSLContext>& ctx,
 244     EventBase* evb,
 245     const std::string& serverName,
 246     bool deferSecurityNegotiation = false) {
 247     return std::shared_ptr<AsyncSSLSocket>(
 248       new AsyncSSLSocket(ctx, evb, serverName, deferSecurityNegotiation),
 249       Destructor());
 250   }
 251 #endif
 252
 253   /**
 254    * TODO: implement support for SSL renegotiation.
 255    *
 256    * This involves proper handling of the SSL_ERROR_WANT_READ/WRITE
 257    * code as a result of SSL_write/read(), instead of returning an
 258    * error. In that case, the READ/WRITE event should be registered,
 259    * and a flag (e.g., writeBlockedOnRead) should be set to indiciate
 260    * the condition. In the next invocation of read/write callback, if
 261    * the flag is on, performWrite()/performRead() should be called in
 262    * addition to the normal call to performRead()/performWrite(), and
 263    * the flag should be reset.
 264    */
 265
 266   // Inherit TAsyncTransport methods from AsyncSocket except the
 267   // following.
 268   // See the documentation in TAsyncTransport.h
 269   // TODO: implement graceful shutdown in close()
 270   // TODO: implement detachSSL() that returns the SSL connection
 271   virtual void closeNow() override;
 272   virtual void shutdownWrite() override;
 273   virtual void shutdownWriteNow() override;
 274   virtual bool good() const override;
 275   virtual bool connecting() const override;
 276   virtual std::string getApplicationProtocol() noexcept override;
 277
 278   bool isEorTrackingEnabled() const override;
 279   virtual void setEorTracking(bool track) override;
 280   virtual size_t getRawBytesWritten() const override;
 281   virtual size_t getRawBytesReceived() const override;
 282   void enableClientHelloParsing();
 283
 284   /**
 285    * Accept an SSL connection on the socket.
 286    *
 287    * The callback will be invoked and uninstalled when an SSL
 288    * connection has been established on the underlying socket.
 289    * The value of verifyPeer determines the client verification method.
 290    * By default, its set to use the value in the underlying context
 291    *
 292    * @param callback callback object to invoke on success/failure
 293    * @param timeout timeout for this function in milliseconds, or 0 for no
 294    *                timeout
 295    * @param verifyPeer  SSLVerifyPeerEnum uses the options specified in the
 296    *                context by default, can be set explcitly to override the
 297    *                method in the context
 298    */
 299   virtual void sslAccept(HandshakeCB* callback, uint32_t timeout = 0,
 300       const folly::SSLContext::SSLVerifyPeerEnum& verifyPeer =
 301             folly::SSLContext::SSLVerifyPeerEnum::USE_CTX);
 302
 303   /**
 304    * Invoke SSL accept following an asynchronous session cache lookup
 305    */
 306   void restartSSLAccept();
 307
 308   /**
 309    * Connect to the given address, invoking callback when complete or on error
 310    *
 311    * Note timeout applies to TCP + SSL connection time
 312    */
 313   void connect(ConnectCallback* callback,
 314                const folly::SocketAddress& address,
 315                int timeout = 0,
 316                const OptionMap &options = emptyOptionMap,
 317                const folly::SocketAddress& bindAddr = anyAddress())
 318                noexcept override;
 319
 320   using AsyncSocket::connect;
 321
 322   /**
 323    * Initiate an SSL connection on the socket
 324    * The callback will be invoked and uninstalled when an SSL connection
 325    * has been establshed on the underlying socket.
 326    * The verification option verifyPeer is applied if it's passed explicitly.
 327    * If it's not, the options in SSLContext set on the underlying SSLContext
 328    * are applied.
 329    *
 330    * @param callback callback object to invoke on success/failure
 331    * @param timeout timeout for this function in milliseconds, or 0 for no
 332    *                timeout
 333    * @param verifyPeer  SSLVerifyPeerEnum uses the options specified in the
 334    *                context by default, can be set explcitly to override the
 335    *                method in the context. If verification is turned on sets
 336    *                SSL_VERIFY_PEER and invokes
 337    *                HandshakeCB::handshakeVer().
 338    */
 339   virtual void sslConn(HandshakeCB *callback, uint64_t timeout = 0,
 340             const folly::SSLContext::SSLVerifyPeerEnum& verifyPeer =
 341                   folly::SSLContext::SSLVerifyPeerEnum::USE_CTX);
 342
 343   enum SSLStateEnum {
 344     STATE_UNINIT,
 345     STATE_UNENCRYPTED,
 346     STATE_ACCEPTING,
 347     STATE_CACHE_LOOKUP,
 348     STATE_RSA_ASYNC_PENDING,
 349     STATE_CONNECTING,
 350     STATE_ESTABLISHED,
 351     STATE_REMOTE_CLOSED, /// remote end closed; we can still write
 352     STATE_CLOSING,       ///< close() called, but waiting on writes to complete
 353     /// close() called with pending writes, before connect() has completed
 354     STATE_CONNECTING_CLOSING,
 355     STATE_CLOSED,
 356     STATE_ERROR
 357   };
 358
 359   SSLStateEnum getSSLState() const { return sslState_;}
 360
 361   /**
 362    * Get a handle to the negotiated SSL session.  This increments the session
 363    * refcount and must be deallocated by the caller.
 364    */
 365   SSL_SESSION *getSSLSession();
 366
 367   /**
 368    * Set the SSL session to be used during sslConn.  AsyncSSLSocket will
 369    * hold a reference to the session until it is destroyed or released by the
 370    * underlying SSL structure.
 371    *
 372    * @param takeOwnership if true, AsyncSSLSocket will assume the caller's
 373    *                      reference count to session.
 374    */
 375   void setSSLSession(SSL_SESSION *session, bool takeOwnership = false);
 376
 377   /**
 378    * Get the name of the protocol selected by the client during
 379    * Next Protocol Negotiation (NPN)
 380    *
 381    * Throw an exception if openssl does not support NPN
 382    *
 383    * @param protoName      Name of the protocol (not guaranteed to be
 384    *                       null terminated); will be set to nullptr if
 385    *                       the client did not negotiate a protocol.
 386    *                       Note: the AsyncSSLSocket retains ownership
 387    *                       of this string.
 388    * @param protoNameLen   Length of the name.
 389    */
 390   virtual void getSelectedNextProtocol(const unsigned char** protoName,
 391       unsigned* protoLen) const;
 392
 393   /**
 394    * Get the name of the protocol selected by the client during
 395    * Next Protocol Negotiation (NPN)
 396    *
 397    * @param protoName      Name of the protocol (not guaranteed to be
 398    *                       null terminated); will be set to nullptr if
 399    *                       the client did not negotiate a protocol.
 400    *                       Note: the AsyncSSLSocket retains ownership
 401    *                       of this string.
 402    * @param protoNameLen   Length of the name.
 403    * @return false if openssl does not support NPN
 404    */
 405   virtual bool getSelectedNextProtocolNoThrow(const unsigned char** protoName,
 406       unsigned* protoLen) const;
 407
 408   /**
 409    * Determine if the session specified during setSSLSession was reused
 410    * or if the server rejected it and issued a new session.
 411    */
 412   virtual bool getSSLSessionReused() const;
 413
 414   /**
 415    * true if the session was resumed using session ID
 416    */
 417   bool sessionIDResumed() const { return sessionIDResumed_; }
 418
 419   void setSessionIDResumed(bool resumed) {
 420     sessionIDResumed_ = resumed;
 421   }
 422
 423   /**
 424    * Get the negociated cipher name for this SSL connection.
 425    * Returns the cipher used or the constant value "NONE" when no SSL session
 426    * has been established.
 427    */
 428   virtual const char* getNegotiatedCipherName() const;
 429
 430   /**
 431    * Get the server name for this SSL connection.
 432    * Returns the server name used or the constant value "NONE" when no SSL
 433    * session has been established.
 434    * If openssl has no SNI support, throw TTransportException.
 435    */
 436   const char *getSSLServerName() const;
 437
 438   /**
 439    * Get the server name for this SSL connection.
 440    * Returns the server name used or the constant value "NONE" when no SSL
 441    * session has been established.
 442    * If openssl has no SNI support, return "NONE"
 443    */
 444   const char *getSSLServerNameNoThrow() const;
 445
 446   /**
 447    * Get the SSL version for this connection.
 448    * Possible return values are SSL2_VERSION, SSL3_VERSION, TLS1_VERSION,
 449    * with hexa representations 0x200, 0x300, 0x301,
 450    * or 0 if no SSL session has been established.
 451    */
 452   int getSSLVersion() const;
 453
 454   /**
 455    * Get the signature algorithm used in the cert that is used for this
 456    * connection.
 457    */
 458   const char *getSSLCertSigAlgName() const;
 459
 460   /**
 461    * Get the certificate size used for this SSL connection.
 462    */
 463   int getSSLCertSize() const;
 464
 465   virtual void attachEventBase(EventBase* eventBase) override {
 466     AsyncSocket::attachEventBase(eventBase);
 467     handshakeTimeout_.attachEventBase(eventBase);
 468   }
 469
 470   virtual void detachEventBase() override {
 471     AsyncSocket::detachEventBase();
 472     handshakeTimeout_.detachEventBase();
 473   }
 474
 475   virtual bool isDetachable() const override {
 476     return AsyncSocket::isDetachable() && !handshakeTimeout_.isScheduled();
 477   }
 478
 479   virtual void attachTimeoutManager(TimeoutManager* manager) {
 480     handshakeTimeout_.attachTimeoutManager(manager);
 481   }
 482
 483   virtual void detachTimeoutManager() {
 484     handshakeTimeout_.detachTimeoutManager();
 485   }
 486
 487 #if OPENSSL_VERSION_NUMBER >= 0x009080bfL
 488   /**
 489    * This function will set the SSL context for this socket to the
 490    * argument. This should only be used on client SSL Sockets that have
 491    * already called detachSSLContext();
 492    */
 493   void attachSSLContext(const std::shared_ptr<folly::SSLContext>& ctx);
 494
 495   /**
 496    * Detaches the SSL context for this socket.
 497    */
 498   void detachSSLContext();
 499 #endif
 500
 501 #if OPENSSL_VERSION_NUMBER >= 0x1000105fL && !defined(OPENSSL_NO_TLSEXT)
 502   /**
 503    * Switch the SSLContext to continue the SSL handshake.
 504    * It can only be used in server mode.
 505    */
 506   void switchServerSSLContext(
 507     const std::shared_ptr<folly::SSLContext>& handshakeCtx);
 508
 509   /**
 510    * Did server recognize/support the tlsext_hostname in Client Hello?
 511    * It can only be used in client mode.
 512    *
 513    * @return true - tlsext_hostname is matched by the server
 514    *         false - tlsext_hostname is not matched or
 515    *                 is not supported by server
 516    */
 517   bool isServerNameMatch() const;
 518
 519   /**
 520    * Set the SNI hostname that we'll advertise to the server in the
 521    * ClientHello message.
 522    */
 523   void setServerName(std::string serverName) noexcept;
 524 #endif
 525
 526   void timeoutExpired() noexcept;
 527
 528   /**
 529    * Get the list of supported ciphers sent by the client in the client's
 530    * preference order.
 531    */
 532   void getSSLClientCiphers(std::string& clientCiphers) const {
 533     std::stringstream ciphersStream;
 534     std::string cipherName;
 535
 536     if (parseClientHello_ == false
 537         || clientHelloInfo_->clientHelloCipherSuites_.empty()) {
 538       clientCiphers = "";
 539       return;
 540     }
 541
 542     for (auto originalCipherCode : clientHelloInfo_->clientHelloCipherSuites_)
 543     {
 544       // OpenSSL expects code as a big endian char array
 545       auto cipherCode = htons(originalCipherCode);
 546
 547 #if defined(SSL_OP_NO_TLSv1_2)
 548       const SSL_CIPHER* cipher =
 549           TLSv1_2_method()->get_cipher_by_char((unsigned char*)&cipherCode);
 550 #elif defined(SSL_OP_NO_TLSv1_1)
 551       const SSL_CIPHER* cipher =
 552           TLSv1_1_method()->get_cipher_by_char((unsigned char*)&cipherCode);
 553 #elif defined(SSL_OP_NO_TLSv1)
 554       const SSL_CIPHER* cipher =
 555           TLSv1_method()->get_cipher_by_char((unsigned char*)&cipherCode);
 556 #else
 557       const SSL_CIPHER* cipher =
 558           SSLv3_method()->get_cipher_by_char((unsigned char*)&cipherCode);
 559 #endif
 560
 561       if (cipher == nullptr) {
 562         ciphersStream << std::setfill('0') << std::setw(4) << std::hex
 563                       << originalCipherCode << ":";
 564       } else {
 565         ciphersStream << SSL_CIPHER_get_name(cipher) << ":";
 566       }
 567     }
 568
 569     clientCiphers = ciphersStream.str();
 570     clientCiphers.erase(clientCiphers.end() - 1);
 571   }
 572
 573   /**
 574    * Get the list of compression methods sent by the client in TLS Hello.
 575    */
 576   std::string getSSLClientComprMethods() const {
 577     if (!parseClientHello_) {
 578       return "";
 579     }
 580     return folly::join(":", clientHelloInfo_->clientHelloCompressionMethods_);
 581   }
 582
 583   /**
 584    * Get the list of TLS extensions sent by the client in the TLS Hello.
 585    */
 586   std::string getSSLClientExts() const {
 587     if (!parseClientHello_) {
 588       return "";
 589     }
 590     return folly::join(":", clientHelloInfo_->clientHelloExtensions_);
 591   }
 592
 593   std::string getSSLClientSigAlgs() const {
 594     if (!parseClientHello_) {
 595       return "";
 596     }
 597
 598     std::string sigAlgs;
 599     sigAlgs.reserve(clientHelloInfo_->clientHelloSigAlgs_.size() * 4);
 600     for (size_t i = 0; i < clientHelloInfo_->clientHelloSigAlgs_.size(); i++) {
 601       if (i) {
 602         sigAlgs.push_back(':');
 603       }
 604       sigAlgs.append(folly::to<std::string>(
 605           clientHelloInfo_->clientHelloSigAlgs_[i].first));
 606       sigAlgs.push_back(',');
 607       sigAlgs.append(folly::to<std::string>(
 608           clientHelloInfo_->clientHelloSigAlgs_[i].second));
 609     }
 610
 611     return sigAlgs;
 612   }
 613
 614   /**
 615    * Get the list of shared ciphers between the server and the client.
 616    * Works well for only SSLv2, not so good for SSLv3 or TLSv1.
 617    */
 618   void getSSLSharedCiphers(std::string& sharedCiphers) const {
 619     char ciphersBuffer[1024];
 620     ciphersBuffer[0] = '\0';
 621     SSL_get_shared_ciphers(ssl_, ciphersBuffer, sizeof(ciphersBuffer) - 1);
 622     sharedCiphers = ciphersBuffer;
 623   }
 624
 625   /**
 626    * Get the list of ciphers supported by the server in the server's
 627    * preference order.
 628    */
 629   void getSSLServerCiphers(std::string& serverCiphers) const {
 630     serverCiphers = SSL_get_cipher_list(ssl_, 0);
 631     int i = 1;
 632     const char *cipher;
 633     while ((cipher = SSL_get_cipher_list(ssl_, i)) != nullptr) {
 634       serverCiphers.append(":");
 635       serverCiphers.append(cipher);
 636       i++;
 637     }
 638   }
 639
 640   static int getSSLExDataIndex();
 641   static AsyncSSLSocket* getFromSSL(const SSL *ssl);
 642   static int eorAwareBioWrite(BIO *b, const char *in, int inl);
 643   void resetClientHelloParsing(SSL *ssl);
 644   static void clientHelloParsingCallback(int write_p, int version,
 645       int content_type, const void *buf, size_t len, SSL *ssl, void *arg);
 646
 647   // http://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml
 648   enum class TLSExtension: uint16_t {
 649     SERVER_NAME = 0,
 650     MAX_FRAGMENT_LENGTH = 1,
 651     CLIENT_CERTIFICATE_URL = 2,
 652     TRUSTED_CA_KEYS = 3,
 653     TRUNCATED_HMAC = 4,
 654     STATUS_REQUEST = 5,
 655     USER_MAPPING = 6,
 656     CLIENT_AUTHZ = 7,
 657     SERVER_AUTHZ = 8,
 658     CERT_TYPE = 9,
 659     SUPPORTED_GROUPS = 10,
 660     EC_POINT_FORMATS = 11,
 661     SRP = 12,
 662     SIGNATURE_ALGORITHMS = 13,
 663     USE_SRTP = 14,
 664     HEARTBEAT = 15,
 665     APPLICATION_LAYER_PROTOCOL_NEGOTIATION = 16,
 666     STATUS_REQUEST_V2 = 17,
 667     SIGNED_CERTIFICATE_TIMESTAMP = 18,
 668     CLIENT_CERTIFICATE_TYPE = 19,
 669     SERVER_CERTIFICATE_TYPE = 20,
 670     PADDING = 21,
 671     ENCRYPT_THEN_MAC = 22,
 672     EXTENDED_MASTER_SECRET = 23,
 673     SESSION_TICKET = 35,
 674     RENEGOTIATION_INFO = 65281
 675   };
 676
 677   // http://www.iana.org/assignments/tls-parameters/tls-parameters.xhtml#tls-parameters-18
 678   enum class HashAlgorithm: uint8_t {
 679     NONE = 0,
 680     MD5 = 1,
 681     SHA1 = 2,
 682     SHA224 = 3,
 683     SHA256 = 4,
 684     SHA384 = 5,
 685     SHA512 = 6
 686   };
 687
 688   // http://www.iana.org/assignments/tls-parameters/tls-parameters.xhtml#tls-parameters-16
 689   enum class SignatureAlgorithm: uint8_t {
 690     ANONYMOUS = 0,
 691     RSA = 1,
 692     DSA = 2,
 693     ECDSA = 3
 694   };
 695
 696   struct ClientHelloInfo {
 697     folly::IOBufQueue clientHelloBuf_;
 698     uint8_t clientHelloMajorVersion_;
 699     uint8_t clientHelloMinorVersion_;
 700     std::vector<uint16_t> clientHelloCipherSuites_;
 701     std::vector<uint8_t> clientHelloCompressionMethods_;
 702     std::vector<TLSExtension> clientHelloExtensions_;
 703     std::vector<
 704       std::pair<HashAlgorithm, SignatureAlgorithm>> clientHelloSigAlgs_;
 705   };
 706
 707   // For unit-tests
 708   ClientHelloInfo* getClientHelloInfo() const {
 709     return clientHelloInfo_.get();
 710   }
 711
 712   /**
 713    * Returns the time taken to complete a handshake.
 714    */
 715   virtual std::chrono::nanoseconds getHandshakeTime() const {
 716     return handshakeEndTime_ - handshakeStartTime_;
 717   }
 718
 719   void setMinWriteSize(size_t minWriteSize) {
 720     minWriteSize_ = minWriteSize;
 721   }
 722
 723   size_t getMinWriteSize() const {
 724     return minWriteSize_;
 725   }
 726
 727   void setReadCB(ReadCallback* callback) override;
 728
 729   /**
 730    * Returns the peer certificate, or nullptr if no peer certificate received.
 731    */
 732   virtual std::unique_ptr<X509, X509_deleter> getPeerCert() const {
 733     if (!ssl_) {
 734       return nullptr;
 735     }
 736
 737     X509* cert = SSL_get_peer_certificate(ssl_);
 738     return std::unique_ptr<X509, X509_deleter>(cert);
 739   }
 740
 741  private:
 742
 743   void init();
 744
 745  protected:
 746
 747   /**
 748    * Protected destructor.
 749    *
 750    * Users of AsyncSSLSocket must never delete it directly.  Instead, invoke
 751    * destroy() instead.  (See the documentation in DelayedDestruction.h for
 752    * more details.)
 753    */
 754   ~AsyncSSLSocket();
 755
 756   // Inherit event notification methods from AsyncSocket except
 757   // the following.
 758   void prepareReadBuffer(void** buf, size_t* buflen) noexcept override;
 759   void handleRead() noexcept override;
 760   void handleWrite() noexcept override;
 761   void handleAccept() noexcept;
 762   void handleConnect() noexcept override;
 763
 764   void invalidState(HandshakeCB* callback);
 765   bool willBlock(int ret, int *errorOut) noexcept;
 766
 767   virtual void checkForImmediateRead() noexcept override;
 768   // AsyncSocket calls this at the wrong time for SSL
 769   void handleInitialReadWrite() noexcept override {}
 770
 771   int interpretSSLError(int rc, int error);
 772   ssize_t performRead(void** buf, size_t* buflen, size_t* offset) override;
 773   ssize_t performWrite(const iovec* vec, uint32_t count, WriteFlags flags,
 774                        uint32_t* countWritten, uint32_t* partialWritten)
 775     override;
 776
 777   ssize_t performWriteIovec(const iovec* vec, uint32_t count,
 778                             WriteFlags flags, uint32_t* countWritten,
 779                             uint32_t* partialWritten);
 780
 781   // This virtual wrapper around SSL_write exists solely for testing/mockability
 782   virtual int sslWriteImpl(SSL *ssl, const void *buf, int n) {
 783     return SSL_write(ssl, buf, n);
 784   }
 785
 786   /**
 787    * Apply verification options passed to sslConn/sslAccept or those set
 788    * in the underlying SSLContext object.
 789    *
 790    * @param ssl pointer to the SSL object on which verification options will be
 791    * applied. If verifyPeer_ was explicitly set either via sslConn/sslAccept,
 792    * those options override the settings in the underlying SSLContext.
 793    */
 794   void applyVerificationOptions(SSL * ssl);
 795
 796   /**
 797    * A SSL_write wrapper that understand EOR
 798    *
 799    * @param ssl: SSL* object
 800    * @param buf: Buffer to be written
 801    * @param n:   Number of bytes to be written
 802    * @param eor: Does the last byte (buf[n-1]) have the app-last-byte?
 803    * @return:    The number of app bytes successfully written to the socket
 804    */
 805   int eorAwareSSLWrite(SSL *ssl, const void *buf, int n, bool eor);
 806
 807   // Inherit error handling methods from AsyncSocket, plus the following.
 808   void failHandshake(const char* fn, const AsyncSocketException& ex);
 809
 810   void invokeHandshakeErr(const AsyncSocketException& ex);
 811   void invokeHandshakeCB();
 812
 813   static void sslInfoCallback(const SSL *ssl, int type, int val);
 814
 815   // SSL related members.
 816   bool server_{false};
 817   // Used to prevent client-initiated renegotiation.  Note that AsyncSSLSocket
 818   // doesn't fully support renegotiation, so we could just fail all attempts
 819   // to enforce this.  Once it is supported, we should make it an option
 820   // to disable client-initiated renegotiation.
 821   bool handshakeComplete_{false};
 822   bool renegotiateAttempted_{false};
 823   SSLStateEnum sslState_{STATE_UNINIT};
 824   std::shared_ptr<folly::SSLContext> ctx_;
 825   // Callback for SSL_accept() or SSL_connect()
 826   HandshakeCB* handshakeCallback_{nullptr};
 827   SSL* ssl_{nullptr};
 828   SSL_SESSION *sslSession_{nullptr};
 829   HandshakeTimeout handshakeTimeout_;
 830   // whether the SSL session was resumed using session ID or not
 831   bool sessionIDResumed_{false};
 832
 833   // The app byte num that we are tracking for the MSG_EOR
 834   // Only one app EOR byte can be tracked.
 835   size_t appEorByteNo_{0};
 836
 837   // Try to avoid calling SSL_write() for buffers smaller than this.
 838   // It doesn't take effect when it is 0.
 839   size_t minWriteSize_{1500};
 840
 841   // When openssl is about to sendmsg() across the minEorRawBytesNo_,
 842   // it will pass MSG_EOR to sendmsg().
 843   size_t minEorRawByteNo_{0};
 844 #if OPENSSL_VERSION_NUMBER >= 0x1000105fL && !defined(OPENSSL_NO_TLSEXT)
 845   std::shared_ptr<folly::SSLContext> handshakeCtx_;
 846   std::string tlsextHostname_;
 847 #endif
 848   folly::SSLContext::SSLVerifyPeerEnum
 849     verifyPeer_{folly::SSLContext::SSLVerifyPeerEnum::USE_CTX};
 850
 851   // Callback for SSL_CTX_set_verify()
 852   static int sslVerifyCallback(int preverifyOk, X509_STORE_CTX* ctx);
 853
 854   bool parseClientHello_{false};
 855   std::unique_ptr<ClientHelloInfo> clientHelloInfo_;
 856
 857   // Time taken to complete the ssl handshake.
 858   std::chrono::steady_clock::time_point handshakeStartTime_;
 859   std::chrono::steady_clock::time_point handshakeEndTime_;
 860 };
 861
 862 } // namespace