proxygen: wangle::SSLAcceptorHandshakeHelper Class Reference

#include <SSLAcceptorHandshakeHelper.h>

Inheritance diagram for wangle::SSLAcceptorHandshakeHelper:

Public Member Functions
	SSLAcceptorHandshakeHelper (const folly::SocketAddress &clientAddr, std::chrono::steady_clock::time_point acceptTime, TransportInfo &tinfo)

void	start (folly::AsyncSSLSocket::UniquePtr sock, AcceptorHandshakeHelper::Callback *callback) noexceptoverride

void	dropConnection (SSLErrorEnum reason=SSLErrorEnum::NO_ERROR) override

Public Member Functions inherited from folly::DelayedDestruction
virtual void	destroy ()

bool	getDestroyPending () const

Public Member Functions inherited from folly::DelayedDestructionBase
virtual	~DelayedDestructionBase ()=default

Public Member Functions inherited from folly::AsyncSSLSocket::HandshakeCB
virtual	~HandshakeCB ()=default

virtual bool	handshakeVer (AsyncSSLSocket , bool preverifyOk, X509_STORE_CTX ) noexcept

Static Public Member Functions
static void	fillSSLTransportInfoFields (folly::AsyncSSLSocket *sock, TransportInfo &tinfo)

Protected Member Functions
void	handshakeSuc (folly::AsyncSSLSocket *sock) noexceptoverride

void	handshakeErr (folly::AsyncSSLSocket *sock, const folly::AsyncSocketException &ex) noexceptoverride

Protected Member Functions inherited from folly::DelayedDestruction
	~DelayedDestruction () override=default

	DelayedDestruction ()

Protected Member Functions inherited from folly::DelayedDestructionBase
	DelayedDestructionBase ()

uint32_t	getDestructorGuardCount () const

Protected Attributes
folly::AsyncSSLSocket::UniquePtr	socket_

AcceptorHandshakeHelper::Callback *	callback_

const folly::SocketAddress &	clientAddr_

std::chrono::steady_clock::time_point	acceptTime_

TransportInfo &	tinfo_

SSLErrorEnum	sslError_ {SSLErrorEnum::NO_ERROR}

Additional Inherited Members
Public Types inherited from wangle::AcceptorHandshakeHelper
using	UniquePtr = std::unique_ptr< AcceptorHandshakeHelper, folly::DelayedDestruction::Destructor >

Detailed Description

Definition at line 28 of file SSLAcceptorHandshakeHelper.h.

Constructor & Destructor Documentation

wangle::SSLAcceptorHandshakeHelper::SSLAcceptorHandshakeHelper	(	const folly::SocketAddress &	clientAddr,
		std::chrono::steady_clock::time_point	acceptTime,
		TransportInfo &	tinfo
	)

inline

Definition at line 31 of file SSLAcceptorHandshakeHelper.h.

References folly::pushmi::__adl::noexcept(), and start().

Referenced by wangle::DefaultToSSLPeekingCallback::getHelper().

                             :
     clientAddr_(clientAddr),
     acceptTime_(acceptTime),
     tinfo_(tinfo) {}

Member Function Documentation

void wangle::SSLAcceptorHandshakeHelper::dropConnection ( SSLErrorEnum reason = SSLErrorEnum::NO_ERROR )

inlineoverridevirtual

Implements wangle::AcceptorHandshakeHelper.

Definition at line 43 of file SSLAcceptorHandshakeHelper.h.

References fillSSLTransportInfoFields(), handshakeErr(), handshakeSuc(), socket_, and sslError_.

                                                                            {
     sslError_ = reason;
     if (socket_) {
       socket_->closeNow();
     }
   }

void wangle::SSLAcceptorHandshakeHelper::fillSSLTransportInfoFields	(	folly::AsyncSSLSocket *	sock,
		TransportInfo &	tinfo
	)

static

Definition at line 39 of file SSLAcceptorHandshakeHelper.cpp.

Referenced by dropConnection(), and wangle::FizzAcceptorHandshakeHelper::handshakeSuc().

                                                 {
   tinfo.secure = true;
   tinfo.securityType = sock->getSecurityProtocol();
   tinfo.sslSetupBytesRead = sock->getRawBytesReceived();
   tinfo.sslSetupBytesWritten = sock->getRawBytesWritten();
   tinfo.sslServerName = sock->getSSLServerName() ?
     std::make_shared<std::string>(sock->getSSLServerName()) : nullptr;
   tinfo.sslCipher = sock->getNegotiatedCipherName() ?
     std::make_shared<std::string>(sock->getNegotiatedCipherName()) : nullptr;
   tinfo.sslVersion = sock->getSSLVersion();
   const char* sigAlgName = sock->getSSLCertSigAlgName();
   tinfo.sslCertSigAlgName =
     std::make_shared<std::string>(sigAlgName ? sigAlgName : "");
   tinfo.sslCertSize = sock->getSSLCertSize();
   tinfo.sslResume = SSLUtil::getResumeState(sock);
   tinfo.sslClientCiphers = std::make_shared<std::string>();
   sock->getSSLClientCiphers(*tinfo.sslClientCiphers);
   tinfo.sslClientCiphersHex = std::make_shared<std::string>();
   sock->getSSLClientCiphers(
       *tinfo.sslClientCiphersHex, /* convertToString = */ false);
   tinfo.sslServerCiphers = std::make_shared<std::string>();
   sock->getSSLServerCiphers(*tinfo.sslServerCiphers);
   tinfo.sslClientComprMethods =
       std::make_shared<std::string>(sock->getSSLClientComprMethods());
   tinfo.sslClientExts =
       std::make_shared<std::string>(sock->getSSLClientExts());
   tinfo.sslClientSigAlgs =
       std::make_shared<std::string>(sock->getSSLClientSigAlgs());
   tinfo.sslClientSupportedVersions =
       std::make_shared<std::string>(sock->getSSLClientSupportedVersions());
 }

void wangle::SSLAcceptorHandshakeHelper::handshakeErr	(	folly::AsyncSSLSocket *	sock,
		const folly::AsyncSocketException &	ex
	)

overrideprotectedvirtualnoexcept

handshakeErr() is called if an error occurs while establishing the SSL connection.

The HandshakeCB will be uninstalled before handshakeErr() is called.

Parameters

sock	SSL socket on which the handshake was initiated
ex	An exception representing the error.

Implements folly::AsyncSSLSocket::HandshakeCB.

Definition at line 104 of file SSLAcceptorHandshakeHelper.cpp.

References callback_, now(), and socket_.

Referenced by dropConnection().

                                              {
   auto elapsedTime =
     std::chrono::duration_cast<std::chrono::milliseconds>(
         std::chrono::steady_clock::now() - acceptTime_);
   VLOG(3) << "SSL handshake error after " << elapsedTime.count() <<
       " ms; " << sock->getRawBytesReceived() << " bytes received & " <<
       sock->getRawBytesWritten() << " bytes sent: " <<
       ex.what();
 
   auto sslEx = folly::make_exception_wrapper<SSLException>(
       sslError_, elapsedTime, sock->getRawBytesReceived());
 
   // The callback will delete this.
   callback_->connectionError(socket_.get(), sslEx, sslError_);
 }

void wangle::SSLAcceptorHandshakeHelper::handshakeSuc ( folly::AsyncSSLSocket * sock )

overrideprotectedvirtualnoexcept

handshakeSuc() is called when a new SSL connection is established, i.e., after SSL_accept/connect() returns successfully.

The HandshakeCB will be uninstalled before handshakeSuc() is called.

Parameters

sock	SSL socket on which the handshake was initiated

Implements folly::AsyncSSLSocket::HandshakeCB.

Definition at line 72 of file SSLAcceptorHandshakeHelper.cpp.

References callback_, wangle::empty_string, folly::gen::move, wangle::NO_ERROR, now(), socket_, string, and wangle::TLS.

Referenced by dropConnection().

                                                                            {
   const unsigned char* nextProto = nullptr;
   unsigned nextProtoLength = 0;
   sock->getSelectedNextProtocolNoThrow(&nextProto, &nextProtoLength);
   if (VLOG_IS_ON(3)) {
     if (nextProto) {
       VLOG(3) << "Client selected next protocol " <<
           std::string((const char*)nextProto, nextProtoLength);
     } else {
       VLOG(3) << "Client did not select a next protocol";
     }
   }
 
   // fill in SSL-related fields from TransportInfo
   // the other fields like RTT are filled in the Acceptor
   tinfo_.acceptTime = acceptTime_;
   tinfo_.sslSetupTime = std::chrono::duration_cast<std::chrono::milliseconds>(
     std::chrono::steady_clock::now() - acceptTime_
   );
   fillSSLTransportInfoFields(sock, tinfo_);
 
   auto nextProtocol = nextProto ?
     std::string((const char*)nextProto, nextProtoLength) : empty_string;
 
   // The callback will delete this.
   callback_->connectionReady(
       std::move(socket_),
       std::move(nextProtocol),
       SecureTransportType::TLS,
       SSLErrorEnum::NO_ERROR);
 }

void wangle::SSLAcceptorHandshakeHelper::start	(	folly::AsyncSSLSocket::UniquePtr	sock,
		AcceptorHandshakeHelper::Callback *	callback
	)

overridevirtualnoexcept

Implements wangle::AcceptorHandshakeHelper.

Definition at line 28 of file SSLAcceptorHandshakeHelper.cpp.

References callback_, folly::gen::move, and socket_.

Referenced by SSLAcceptorHandshakeHelper().

                                                         {
   socket_ = std::move(sock);
   callback_ = callback;
 
   socket_->enableClientHelloParsing();
   socket_->forceCacheAddrOnFailure(true);
   socket_->sslAccept(this);
 }