proxygen: fizz::sm Namespace Reference

Classes
class	EventHandler

class	EventHandlerBase

struct	Or

struct	Or< Condition, Conditions... >

class	StateMachine

struct	StateSame

struct	StateSame< SM, s, s >

Functions
	FIZZ_DECLARE_EVENT_HANDLER (ClientTypes, StateEnum::Uninitialized, Event::Connect, StateEnum::ExpectingServerHello)

	FIZZ_DECLARE_EVENT_HANDLER (ClientTypes, StateEnum::ExpectingServerHello, Event::HelloRetryRequest, StateEnum::ExpectingServerHello)

	FIZZ_DECLARE_EVENT_HANDLER (ClientTypes, StateEnum::ExpectingServerHello, Event::ServerHello, StateEnum::ExpectingEncryptedExtensions)

	FIZZ_DECLARE_EVENT_HANDLER (ClientTypes, StateEnum::ExpectingServerHello, Event::EarlyAppWrite, StateEnum::Error)

	FIZZ_DECLARE_EVENT_HANDLER (ClientTypes, StateEnum::ExpectingEncryptedExtensions, Event::EncryptedExtensions, StateEnum::ExpectingCertificate, StateEnum::ExpectingFinished)

	FIZZ_DECLARE_EVENT_HANDLER (ClientTypes, StateEnum::ExpectingEncryptedExtensions, Event::EarlyAppWrite, StateEnum::Error)

	FIZZ_DECLARE_EVENT_HANDLER (ClientTypes, StateEnum::ExpectingCertificate, Event::CertificateRequest, StateEnum::ExpectingCertificate)

	FIZZ_DECLARE_EVENT_HANDLER (ClientTypes, StateEnum::ExpectingCertificate, Event::Certificate, StateEnum::ExpectingCertificateVerify)

	FIZZ_DECLARE_EVENT_HANDLER (ClientTypes, StateEnum::ExpectingCertificate, Event::CompressedCertificate, StateEnum::ExpectingCertificateVerify)

	FIZZ_DECLARE_EVENT_HANDLER (ClientTypes, StateEnum::ExpectingCertificate, Event::EarlyAppWrite, StateEnum::Error)

	FIZZ_DECLARE_EVENT_HANDLER (ClientTypes, StateEnum::ExpectingCertificateVerify, Event::CertificateVerify, StateEnum::ExpectingFinished)

	FIZZ_DECLARE_EVENT_HANDLER (ClientTypes, StateEnum::ExpectingCertificateVerify, Event::EarlyAppWrite, StateEnum::Error)

	FIZZ_DECLARE_EVENT_HANDLER (ClientTypes, StateEnum::ExpectingFinished, Event::Finished, StateEnum::Established)

	FIZZ_DECLARE_EVENT_HANDLER (ClientTypes, StateEnum::ExpectingFinished, Event::EarlyAppWrite, StateEnum::Error)

	FIZZ_DECLARE_EVENT_HANDLER (ClientTypes, StateEnum::Established, Event::EarlyAppWrite, StateEnum::Error)

	FIZZ_DECLARE_EVENT_HANDLER (ClientTypes, StateEnum::Established, Event::NewSessionTicket, StateEnum::Error)

	FIZZ_DECLARE_EVENT_HANDLER (ClientTypes, StateEnum::Established, Event::AppData, StateEnum::Error)

	FIZZ_DECLARE_EVENT_HANDLER (ClientTypes, StateEnum::Established, Event::AppWrite, StateEnum::Error)

	FIZZ_DECLARE_EVENT_HANDLER (ClientTypes, StateEnum::Established, Event::KeyUpdate, StateEnum::Error)

static folly::Optional< CachedPsk >	validatePsk (const FizzClientContext &context, folly::Optional< CachedPsk > psk)

static std::map< NamedGroup, std::unique_ptr< KeyExchange > >	getKeyExchangers (const Factory &factory, const std::vector< NamedGroup > &groups)

static ClientHello	getClientHello (const Factory &, const Random &random, const std::vector< CipherSuite > &supportedCiphers, const std::vector< ProtocolVersion > &supportedVersions, const std::vector< NamedGroup > &supportedGroups, const std::map< NamedGroup, std::unique_ptr< KeyExchange >> &shares, const std::vector< SignatureScheme > &supportedSigSchemes, const std::vector< PskKeyExchangeMode > &supportedPskModes, const folly::Optional< std::string > &hostname, const std::vector< std::string > &supportedAlpns, const std::vector< CertificateCompressionAlgorithm > &compressionAlgos, const Optional< EarlyDataParams > &earlyDataParams, const Buf &legacySessionId, ClientExtensions *extensions, Buf cookie=nullptr)

static ClientPresharedKey	getPskExtension (const CachedPsk &psk)

static Buf	encodeAndAddBinders (ClientHello chlo, const CachedPsk &psk, KeyScheduler &scheduler, HandshakeContext &handshakeContext)

static Optional< EarlyDataParams >	getEarlyDataParams (const FizzClientContext &context, const Optional< CachedPsk > &psk)

template<typename ServerMessage >
static std::pair< ProtocolVersion, CipherSuite >	getAndValidateVersionAndCipher (const ServerMessage &msg, const std::vector< ProtocolVersion > &supportedVersions, const std::vector< CipherSuite > &supportedCiphers)

static auto	negotiateParameters (const ServerHello &shlo, const std::vector< ProtocolVersion > &supportedVersions, const std::vector< CipherSuite > &supportedCiphers, const std::map< NamedGroup, std::unique_ptr< KeyExchange >> &keyExchangers)

static void	validateNegotiationConsistency (const State &state, ProtocolVersion version, CipherSuite cipher)

static NegotiatedPsk	negotiatePsk (const std::vector< PskKeyExchangeMode > &supportedPskModes, const folly::Optional< CachedPsk > &attemptedPsk, const ServerHello &shlo, ProtocolVersion version, CipherSuite cipher, bool hasExchange)

static HrrParams	negotiateParameters (const HelloRetryRequest &hrr, const std::vector< ProtocolVersion > &supportedVersions, const std::vector< CipherSuite > &supportedCiphers, const std::vector< NamedGroup > &supportedGroups)

static std::map< NamedGroup, std::unique_ptr< KeyExchange > >	getHrrKeyExchangers (const Factory &factory, std::map< NamedGroup, std::unique_ptr< KeyExchange >> previous, Optional< NamedGroup > negotiatedGroup)

static void	validateAcceptedEarly (const State &state, const Optional< std::string > &alpn)

static std::tuple< folly::Optional< SignatureScheme >, std::shared_ptr< const SelfCert > >	getClientCert (const State &state, const std::vector< SignatureScheme > &schemes)

static MutateState	handleCertMsg (const State &state, CertificateMsg certMsg, folly::Optional< CertificateCompressionAlgorithm > algo)

static uint32_t	getMaxEarlyDataSize (const NewSessionTicket &nst)

static Actions	ignoreEarlyAppWrite (const State &state, EarlyAppWrite write)

static Actions	handleEarlyAppWrite (const State &state, EarlyAppWrite appWrite)

	FIZZ_DECLARE_EVENT_HANDLER (ServerTypes, StateEnum::Uninitialized, Event::Accept, StateEnum::ExpectingClientHello)

	FIZZ_DECLARE_EVENT_HANDLER (ServerTypes, StateEnum::ExpectingClientHello, Event::ClientHello, StateEnum::ExpectingClientHello, StateEnum::ExpectingCertificate, StateEnum::ExpectingFinished, StateEnum::AcceptingEarlyData, StateEnum::Error)

	FIZZ_DECLARE_EVENT_HANDLER (ServerTypes, StateEnum::AcceptingEarlyData, Event::AppData, StateEnum::Error)

	FIZZ_DECLARE_EVENT_HANDLER (ServerTypes, StateEnum::AcceptingEarlyData, Event::AppWrite, StateEnum::Error)

	FIZZ_DECLARE_EVENT_HANDLER (ServerTypes, StateEnum::AcceptingEarlyData, Event::EndOfEarlyData, StateEnum::ExpectingFinished)

	FIZZ_DECLARE_EVENT_HANDLER (ServerTypes, StateEnum::ExpectingCertificate, Event::Certificate, StateEnum::ExpectingCertificateVerify, StateEnum::ExpectingFinished) FIZZ_DECLARE_EVENT_HANDLER(ServerTypes

	FIZZ_DECLARE_EVENT_HANDLER (ServerTypes, StateEnum::ExpectingFinished, Event::AppWrite, StateEnum::Error)

	FIZZ_DECLARE_EVENT_HANDLER (ServerTypes, StateEnum::ExpectingFinished, Event::Finished, StateEnum::AcceptingData)

	FIZZ_DECLARE_EVENT_HANDLER (ServerTypes, StateEnum::AcceptingData, Event::WriteNewSessionTicket, StateEnum::Error)

	FIZZ_DECLARE_EVENT_HANDLER (ServerTypes, StateEnum::AcceptingData, Event::AppData, StateEnum::Error)

	FIZZ_DECLARE_EVENT_HANDLER (ServerTypes, StateEnum::AcceptingData, Event::AppWrite, StateEnum::Error)

	FIZZ_DECLARE_EVENT_HANDLER (ServerTypes, StateEnum::AcceptingData, Event::KeyUpdate, StateEnum::AcceptingData)

static void	addHandshakeLogging (const State &state, const ClientHello &chlo)

static void	validateClientHello (const ClientHello &chlo)

static Optional< ProtocolVersion >	negotiateVersion (const ClientHello &chlo, const std::vector< ProtocolVersion > &versions)

static Optional< CookieState >	getCookieState (const ClientHello &chlo, ProtocolVersion version, CipherSuite cipher, const CookieCipher *cookieCipher)

static ResumptionStateResult	getResumptionState (const ClientHello &chlo, const TicketCipher *ticketCipher, const std::vector< PskKeyExchangeMode > &supportedModes)

Future< ReplayCacheResult >	getReplayCacheResult (const ClientHello &chlo, bool zeroRttEnabled, ReplayCache *replayCache)

static bool	validateResumptionState (const ResumptionState &resState, PskKeyExchangeMode, ProtocolVersion version, CipherSuite cipher)

static CipherSuite	negotiateCipher (const ClientHello &chlo, const std::vector< std::vector< CipherSuite >> &supportedCiphers)

static std::pair< std::unique_ptr< KeyScheduler >, std::unique_ptr< HandshakeContext > >	setupSchedulerAndContext (const Factory &factory, CipherSuite cipher, const ClientHello &chlo, const Optional< ResumptionState > &resState, const Optional< CookieState > &cookieState, PskType pskType, std::unique_ptr< HandshakeContext > handshakeContext, ProtocolVersion)

static void	validateGroups (const std::vector< KeyShareEntry > &client_shares)

static std::tuple< NamedGroup, Optional< Buf > >	negotiateGroup (ProtocolVersion version, const ClientHello &chlo, const std::vector< NamedGroup > &supportedGroups)

static Buf	doKex (const Factory &factory, NamedGroup group, const Buf &clientShare, KeyScheduler &scheduler)

static Buf	getHelloRetryRequest (ProtocolVersion version, CipherSuite cipher, NamedGroup group, Buf legacySessionId, HandshakeContext &handshakeContext)

static Buf	getServerHello (ProtocolVersion version, Random random, CipherSuite cipher, bool psk, Optional< NamedGroup > group, Optional< Buf > serverShare, Buf legacy_session_id, HandshakeContext &handshakeContext)

static Optional< std::string >	negotiateAlpn (const ClientHello &chlo, folly::Optional< std::string > zeroRttAlpn, const FizzServerContext &context)

static Optional< std::chrono::milliseconds >	getClockSkew (const Optional< ResumptionState > &psk, Optional< uint32_t > obfuscatedAge)

static EarlyDataType	negotiateEarlyDataType (bool acceptEarlyData, const ClientHello &chlo, const Optional< ResumptionState > &psk, CipherSuite cipher, Optional< KeyExchangeType > keyExchangeType, const Optional< CookieState > &cookieState, Optional< std::string > alpn, ReplayCacheResult replayCacheResult, Optional< std::chrono::milliseconds > clockSkew, ClockSkewTolerance clockSkewTolerance, const AppTokenValidator *appTokenValidator)

static Buf	getEncryptedExt (HandshakeContext &handshakeContext, const folly::Optional< std::string > &selectedAlpn, EarlyDataType earlyData, std::vector< Extension > otherExtensions)

static std::pair< std::shared_ptr< SelfCert >, SignatureScheme >	chooseCert (const FizzServerContext &context, const ClientHello &chlo)

static std::tuple< Buf, folly::Optional< CertificateCompressionAlgorithm > >	getCertificate (const std::shared_ptr< const SelfCert > &serverCert, const FizzServerContext &context, const ClientHello &chlo, HandshakeContext &handshakeContext)

static Buf	getCertificateVerify (SignatureScheme sigScheme, Buf signature, HandshakeContext &handshakeContext)

static Buf	getCertificateRequest (const std::vector< SignatureScheme > &acceptableSigSchemes, const CertificateVerifier *const verifier, HandshakeContext &handshakeContext)

static WriteToSocket	writeNewSessionTicket (const FizzServerContext &context, const WriteRecordLayer &recordLayer, std::chrono::seconds ticketLifetime, uint32_t ticketAgeAdd, Buf nonce, Buf ticket, ProtocolVersion version)

static Future< Optional< WriteToSocket > >	generateTicket (const State &state, const std::vector< uint8_t > &resumptionMasterSecret, Buf appToken=nullptr)

Function Documentation

static void fizz::sm::addHandshakeLogging	(	const State &	state,
		const ClientHello &	chlo
	)

static

Definition at line 311 of file ServerProtocol.cpp.

Referenced by getCertificateRequest().

                                                                              {
   if (state.handshakeLogging()) {
     state.handshakeLogging()->clientLegacyVersion = chlo.legacy_version;
     auto supportedVersions = getExtension<SupportedVersions>(chlo.extensions);
     if (supportedVersions) {
       state.handshakeLogging()->clientSupportedVersions =
           supportedVersions->versions;
     }
     state.handshakeLogging()->clientCiphers = chlo.cipher_suites;
     state.handshakeLogging()->clientExtensions.clear();
     for (const auto& extension : chlo.extensions) {
       state.handshakeLogging()->clientExtensions.push_back(
           extension.extension_type);
     }
     auto plaintextReadRecord =
         dynamic_cast<PlaintextReadRecordLayer*>(state.readRecordLayer());
     if (plaintextReadRecord) {
       state.handshakeLogging()->clientRecordVersion =
           plaintextReadRecord->getReceivedRecordVersion();
     }
     auto sni = getExtension<ServerNameList>(chlo.extensions);
     if (sni && !sni->server_name_list.empty()) {
       state.handshakeLogging()->clientSni = sni->server_name_list.front()
                                                 .hostname->moveToFbString()
                                                 .toStdString();
     }
     auto supportedGroups = getExtension<SupportedGroups>(chlo.extensions);
     if (supportedGroups) {
       state.handshakeLogging()->clientSupportedGroups =
           std::move(supportedGroups->named_group_list);
     }
 
     auto keyShare = getExtension<ClientKeyShare>(chlo.extensions);
     if (keyShare && !state.handshakeLogging()->clientKeyShares) {
       std::vector<NamedGroup> shares;
       for (const auto& entry : keyShare->client_shares) {
         shares.push_back(entry.group);
       }
       state.handshakeLogging()->clientKeyShares = std::move(shares);
     }
 
     auto exchangeModes = getExtension<PskKeyExchangeModes>(chlo.extensions);
     if (exchangeModes) {
       state.handshakeLogging()->clientKeyExchangeModes =
           std::move(exchangeModes->modes);
     }
 
     auto clientSigSchemes = getExtension<SignatureAlgorithms>(chlo.extensions);
     if (clientSigSchemes) {
       state.handshakeLogging()->clientSignatureAlgorithms =
           std::move(clientSigSchemes->supported_signature_algorithms);
     }
 
     state.handshakeLogging()->clientSessionIdSent =
         chlo.legacy_session_id && !chlo.legacy_session_id->empty();
     state.handshakeLogging()->clientRandom = chlo.random;
   }
 }

static std::pair<std::shared_ptr<SelfCert>, SignatureScheme> fizz::sm::chooseCert	(	const FizzServerContext &	context,
		const ClientHello &	chlo
	)

static

Definition at line 891 of file ServerProtocol.cpp.

References fizz::ClientHello::extensions, fizz::server::FizzServerContext::getCert(), fizz::handshake_failure, fizz::missing_extension, and sni.

Referenced by getCertificateRequest().

                              {
   const auto& clientSigSchemes =
       getExtension<SignatureAlgorithms>(chlo.extensions);
   if (!clientSigSchemes) {
     throw FizzException("no sig schemes", AlertDescription::missing_extension);
   }
   Optional<std::string> sni;
   auto serverNameList = getExtension<ServerNameList>(chlo.extensions);
   if (serverNameList && !serverNameList->server_name_list.empty()) {
     sni = serverNameList->server_name_list.front()
               .hostname->moveToFbString()
               .toStdString();
   }
 
   auto certAndScheme =
       context.getCert(sni, clientSigSchemes->supported_signature_algorithms);
   if (!certAndScheme) {
     throw FizzException(
         "could not find suitable cert", AlertDescription::handshake_failure);
   }
   return *certAndScheme;
 }

static Buf fizz::sm::doKex	(	const Factory &	factory,
		NamedGroup	group,
		const Buf &	clientShare,
		KeyScheduler &	scheduler
	)

static

Definition at line 659 of file ServerProtocol.cpp.

References fizz::KeyScheduler::deriveHandshakeSecret(), and fizz::Factory::makeKeyExchange().

Referenced by getCertificateRequest().

                              {
   auto kex = factory.makeKeyExchange(group);
   kex->generateKeyPair();
   auto sharedSecret = kex->generateSharedSecret(clientShare->coalesce());
   scheduler.deriveHandshakeSecret(sharedSecret->coalesce());
   return kex->getKeyShare();
 }

static Buf fizz::sm::encodeAndAddBinders	(	ClientHello	chlo,
		const CachedPsk &	psk,
		KeyScheduler &	scheduler,
		HandshakeContext &	handshakeContext
	)

static

Returns the encoded client hello after updating the binder.

Will derive the early secret on the key scheduler and append the client hello to the handshake context.

Definition at line 452 of file ClientProtocol.cpp.

References folly::IOBufQueue::append(), fizz::HandshakeContext::appendToTranscript(), fizz::PskBinder::binder, folly::IOBufQueue::cacheChainLength(), folly::IOBufQueue::chainLength(), fizz::KeyScheduler::deriveEarlySecret(), fizz::encodeExtension(), fizz::encodeHandshake(), fizz::ClientHello::extensions, fizz::External, fizz::ExternalPskBinder, fizz::getBinderLength(), fizz::HandshakeContext::getBlankContext(), fizz::HandshakeContext::getFinishedData(), getPskExtension(), fizz::KeyScheduler::getSecret(), folly::IOBufQueue::move(), folly::gen::move, folly::range(), fizz::ResumptionPskBinder, fizz::client::CachedPsk::secret, folly::IOBufQueue::split(), and fizz::client::CachedPsk::type.

Referenced by getEarlyDataParams(), and getHrrKeyExchangers().

                                         {
   scheduler.deriveEarlySecret(folly::range(psk.secret));
 
   auto binderKey = scheduler.getSecret(
       psk.type == PskType::External ? EarlySecrets::ExternalPskBinder
                                     : EarlySecrets::ResumptionPskBinder,
       handshakeContext.getBlankContext());
 
   auto pskExt = getPskExtension(psk);
   chlo.extensions.push_back(encodeExtension(pskExt));
 
   size_t binderLength = getBinderLength(chlo);
 
   auto preEncoded = encodeHandshake(chlo);
 
   // Add the ClientHello up to the binder list to the transcript.
   {
     folly::IOBufQueue chloQueue(folly::IOBufQueue::cacheChainLength());
     chloQueue.append(std::move(preEncoded));
     auto chloPrefix = chloQueue.split(chloQueue.chainLength() - binderLength);
     handshakeContext.appendToTranscript(chloPrefix);
   }
 
   PskBinder binder;
   binder.binder = handshakeContext.getFinishedData(folly::range(binderKey));
   pskExt.binders.clear();
   pskExt.binders.push_back(std::move(binder));
 
   chlo.extensions.pop_back();
   chlo.extensions.push_back(encodeExtension(std::move(pskExt)));
 
   auto encoded = encodeHandshake(std::move(chlo));
 
   // Add the binder list to the transcript.
   folly::IOBufQueue chloQueue(folly::IOBufQueue::cacheChainLength());
   chloQueue.append(encoded->clone());
   chloQueue.split(chloQueue.chainLength() - binderLength);
   handshakeContext.appendToTranscript(chloQueue.move());
 
   return encoded;
 }

fizz::sm::FIZZ_DECLARE_EVENT_HANDLER	(	ClientTypes	,
		StateEnum::Uninitialized	,
		Event::Connect	,
		StateEnum::ExpectingServerHello
	)

fizz::sm::FIZZ_DECLARE_EVENT_HANDLER	(	ClientTypes	,
		StateEnum::ExpectingServerHello	,
		Event::HelloRetryRequest	,
		StateEnum::ExpectingServerHello
	)

fizz::sm::FIZZ_DECLARE_EVENT_HANDLER	(	ServerTypes	,
		StateEnum::Uninitialized	,
		Event::Accept	,
		StateEnum::ExpectingClientHello
	)

fizz::sm::FIZZ_DECLARE_EVENT_HANDLER	(	ClientTypes	,
		StateEnum::ExpectingServerHello	,
		Event::ServerHello	,
		StateEnum::ExpectingEncryptedExtensions
	)

fizz::sm::FIZZ_DECLARE_EVENT_HANDLER	(	ServerTypes	,
		StateEnum::ExpectingClientHello	,
		Event::ClientHello	,
		StateEnum::ExpectingClientHello	,
		StateEnum::ExpectingCertificate	,
		StateEnum::ExpectingFinished	,
		StateEnum::AcceptingEarlyData	,
		StateEnum::Error
	)

fizz::sm::FIZZ_DECLARE_EVENT_HANDLER	(	ClientTypes	,
		StateEnum::ExpectingServerHello	,
		Event::EarlyAppWrite	,
		StateEnum::Error
	)

fizz::sm::FIZZ_DECLARE_EVENT_HANDLER	(	ClientTypes	,
		StateEnum::ExpectingEncryptedExtensions	,
		Event::EncryptedExtensions	,
		StateEnum::ExpectingCertificate	,
		StateEnum::ExpectingFinished
	)

fizz::sm::FIZZ_DECLARE_EVENT_HANDLER	(	ServerTypes	,
		StateEnum::AcceptingEarlyData	,
		Event::AppData	,
		StateEnum::Error
	)

fizz::sm::FIZZ_DECLARE_EVENT_HANDLER	(	ServerTypes	,
		StateEnum::AcceptingEarlyData	,
		Event::AppWrite	,
		StateEnum::Error
	)

fizz::sm::FIZZ_DECLARE_EVENT_HANDLER	(	ClientTypes	,
		StateEnum::ExpectingEncryptedExtensions	,
		Event::EarlyAppWrite	,
		StateEnum::Error
	)

fizz::sm::FIZZ_DECLARE_EVENT_HANDLER	(	ServerTypes	,
		StateEnum::AcceptingEarlyData	,
		Event::EndOfEarlyData	,
		StateEnum::ExpectingFinished
	)

fizz::sm::FIZZ_DECLARE_EVENT_HANDLER	(	ClientTypes	,
		StateEnum::ExpectingCertificate	,
		Event::CertificateRequest	,
		StateEnum::ExpectingCertificate
	)

fizz::sm::FIZZ_DECLARE_EVENT_HANDLER	(	ClientTypes	,
		StateEnum::ExpectingCertificate	,
		Event::Certificate	,
		StateEnum::ExpectingCertificateVerify
	)

fizz::sm::FIZZ_DECLARE_EVENT_HANDLER	(	ServerTypes	,
		StateEnum::ExpectingCertificate	,
		Event::Certificate	,
		StateEnum::ExpectingCertificateVerify	,
		StateEnum::ExpectingFinished
	)

fizz::sm::FIZZ_DECLARE_EVENT_HANDLER	(	ClientTypes	,
		StateEnum::ExpectingCertificate	,
		Event::CompressedCertificate	,
		StateEnum::ExpectingCertificateVerify
	)

fizz::sm::FIZZ_DECLARE_EVENT_HANDLER	(	ClientTypes	,
		StateEnum::ExpectingCertificate	,
		Event::EarlyAppWrite	,
		StateEnum::Error
	)

fizz::sm::FIZZ_DECLARE_EVENT_HANDLER	(	ServerTypes	,
		StateEnum::ExpectingFinished	,
		Event::AppWrite	,
		StateEnum::Error
	)

fizz::sm::FIZZ_DECLARE_EVENT_HANDLER	(	ClientTypes	,
		StateEnum::ExpectingCertificateVerify	,
		Event::CertificateVerify	,
		StateEnum::ExpectingFinished
	)

fizz::sm::FIZZ_DECLARE_EVENT_HANDLER	(	ServerTypes	,
		StateEnum::ExpectingFinished	,
		Event::Finished	,
		StateEnum::AcceptingData
	)

fizz::sm::FIZZ_DECLARE_EVENT_HANDLER	(	ClientTypes	,
		StateEnum::ExpectingCertificateVerify	,
		Event::EarlyAppWrite	,
		StateEnum::Error
	)

fizz::sm::FIZZ_DECLARE_EVENT_HANDLER	(	ServerTypes	,
		StateEnum::AcceptingData	,
		Event::WriteNewSessionTicket	,
		StateEnum::Error
	)

fizz::sm::FIZZ_DECLARE_EVENT_HANDLER	(	ClientTypes	,
		StateEnum::ExpectingFinished	,
		Event::Finished	,
		StateEnum::Established
	)

fizz::sm::FIZZ_DECLARE_EVENT_HANDLER	(	ServerTypes	,
		StateEnum::AcceptingData	,
		Event::AppData	,
		StateEnum::Error
	)

fizz::sm::FIZZ_DECLARE_EVENT_HANDLER	(	ClientTypes	,
		StateEnum::ExpectingFinished	,
		Event::EarlyAppWrite	,
		StateEnum::Error
	)

fizz::sm::FIZZ_DECLARE_EVENT_HANDLER	(	ServerTypes	,
		StateEnum::AcceptingData	,
		Event::AppWrite	,
		StateEnum::Error
	)

fizz::sm::FIZZ_DECLARE_EVENT_HANDLER	(	ClientTypes	,
		StateEnum::Established	,
		Event::EarlyAppWrite	,
		StateEnum::Error
	)

fizz::sm::FIZZ_DECLARE_EVENT_HANDLER	(	ServerTypes	,
		StateEnum::AcceptingData	,
		Event::KeyUpdate	,
		StateEnum::AcceptingData
	)

fizz::sm::FIZZ_DECLARE_EVENT_HANDLER	(	ClientTypes	,
		StateEnum::Established	,
		Event::NewSessionTicket	,
		StateEnum::Error
	)

fizz::sm::FIZZ_DECLARE_EVENT_HANDLER	(	ClientTypes	,
		StateEnum::Established	,
		Event::AppData	,
		StateEnum::Error
	)

fizz::sm::FIZZ_DECLARE_EVENT_HANDLER	(	ClientTypes	,
		StateEnum::Established	,
		Event::AppWrite	,
		StateEnum::Error
	)

fizz::sm::FIZZ_DECLARE_EVENT_HANDLER	(	ClientTypes	,
		StateEnum::Established	,
		Event::KeyUpdate	,
		StateEnum::Error
	)

static Future<Optional<WriteToSocket> > fizz::sm::generateTicket	(	const State &	state,
		const std::vector< uint8_t > &	resumptionMasterSecret,
		Buf	appToken = `nullptr`
	)

static

Definition at line 1641 of file ServerProtocol.cpp.

                             {
   auto ticketCipher = state.context()->getTicketCipher();
 
   if (!ticketCipher || *state.pskType() == PskType::NotSupported) {
     return folly::none;
   }
 
   Buf ticketNonce;
   Buf resumptionSecret;
   auto realDraftVersion = getRealDraftVersion(*state.version());
   if (realDraftVersion == ProtocolVersion::tls_1_3_20) {
     ticketNonce = nullptr;
     resumptionSecret =
         folly::IOBuf::copyBuffer(folly::range(resumptionMasterSecret));
   } else {
     ticketNonce = folly::IOBuf::create(0);
     resumptionSecret = state.keyScheduler()->getResumptionSecret(
         folly::range(resumptionMasterSecret), ticketNonce->coalesce());
   }
 
   ResumptionState resState;
   resState.version = *state.version();
   resState.cipher = *state.cipher();
   resState.resumptionSecret = std::move(resumptionSecret);
   resState.serverCert = state.serverCert();
   resState.clientCert = state.clientCert();
   resState.alpn = state.alpn();
   resState.ticketAgeAdd = state.context()->getFactory()->makeTicketAgeAdd();
   resState.ticketIssueTime = std::chrono::system_clock::now();
   resState.appToken = std::move(appToken);
 
   auto ticketFuture = ticketCipher->encrypt(std::move(resState));
   return ticketFuture.via(state.executor())
       .thenValue(
           [&state,
            ticketAgeAdd = resState.ticketAgeAdd,
            ticketNonce = std::move(ticketNonce)](
               Optional<std::pair<Buf, std::chrono::seconds>> ticket) mutable
           -> Optional<WriteToSocket> {
             if (!ticket) {
               return folly::none;
             }
             return writeNewSessionTicket(
                 *state.context(),
                 *state.writeRecordLayer(),
                 ticket->second,
                 ticketAgeAdd,
                 std::move(ticketNonce),
                 std::move(ticket->first),
                 *state.version());
           });
 }

template<typename ServerMessage >

static std::pair<ProtocolVersion, CipherSuite> fizz::sm::getAndValidateVersionAndCipher	(	const ServerMessage &	msg,
		const std::vector< ProtocolVersion > &	supportedVersions,
		const std::vector< CipherSuite > &	supportedCiphers
	)

static

Definition at line 689 of file ClientProtocol.cpp.

References fizz::handshake_failure, fizz::illegal_parameter, fizz::protocol_version, fizz::tls_1_2, and fizz::toString().

Referenced by negotiateParameters().

                                                     {
   if (msg.legacy_version != ProtocolVersion::tls_1_2) {
     throw FizzException(
         folly::to<std::string>(
             "received server legacy version ", toString(msg.legacy_version)),
         AlertDescription::protocol_version);
   }
 
   if (msg.legacy_compression_method != 0x00) {
     throw FizzException(
         "compression method not null", AlertDescription::illegal_parameter);
   }
 
   auto supportedVersionsExt =
       getExtension<ServerSupportedVersions>(msg.extensions);
   if (!supportedVersionsExt) {
     throw FizzException(
         "no supported versions in shlo", AlertDescription::protocol_version);
   }
   auto selectedVersion = supportedVersionsExt->selected_version;
   auto selectedCipher = msg.cipher_suite;
 
   if (std::find(
           supportedVersions.begin(),
           supportedVersions.end(),
           selectedVersion) == supportedVersions.end()) {
     throw FizzException(
         "received unsupported server version",
         AlertDescription::protocol_version);
   }
   if (std::find(
           supportedCiphers.begin(), supportedCiphers.end(), selectedCipher) ==
       supportedCiphers.end()) {
     throw FizzException(
         "server choose unsupported cipher suite",
         AlertDescription::handshake_failure);
   }
 
   return std::make_pair(selectedVersion, selectedCipher);
 }

static std::tuple<Buf, folly::Optional<CertificateCompressionAlgorithm> > fizz::sm::getCertificate	(	const std::shared_ptr< const SelfCert > &	serverCert,
		const FizzServerContext &	context,
		const ClientHello &	chlo,
		HandshakeContext &	handshakeContext
	)

static

Definition at line 917 of file ServerProtocol.cpp.

References fizz::HandshakeContext::appendToTranscript(), encodedCertificate, fizz::encodeHandshake(), fizz::ClientHello::extensions, fizz::server::FizzServerContext::getSupportedCompressionAlgorithms(), std::tr1::make_tuple(), folly::gen::move, and fizz::server::negotiate().

Referenced by getCertificateRequest().

                                         {
   // Check for compression support first, and if so, send compressed.
   Buf encodedCertificate;
   folly::Optional<CertificateCompressionAlgorithm> algo;
   auto compAlgos =
       getExtension<CertificateCompressionAlgorithms>(chlo.extensions);
   if (compAlgos && !context.getSupportedCompressionAlgorithms().empty()) {
     algo = negotiate(
         context.getSupportedCompressionAlgorithms(), compAlgos->algorithms);
   }
 
   if (algo) {
     encodedCertificate = encodeHandshake(serverCert->getCompressedCert(*algo));
   } else {
     encodedCertificate = encodeHandshake(serverCert->getCertMessage());
   }
   handshakeContext.appendToTranscript(encodedCertificate);
   return std::make_tuple(std::move(encodedCertificate), std::move(algo));
 }

static Buf fizz::sm::getCertificateRequest	(	const std::vector< SignatureScheme > &	acceptableSigSchemes,
		const CertificateVerifier *const	verifier,
		HandshakeContext &	handshakeContext
	)

static

Definition at line 953 of file ServerProtocol.cpp.

                                         {
   CertificateRequest request;
   SignatureAlgorithms algos;
   algos.supported_signature_algorithms = acceptableSigSchemes;
   request.extensions.push_back(encodeExtension(std::move(algos)));
   if (verifier) {
     auto verifierExtensions = verifier->getCertificateRequestExtensions();
     for (auto& ext : verifierExtensions) {
       request.extensions.push_back(std::move(ext));
     }
   }
   auto encodedCertificateRequest = encodeHandshake(std::move(request));
   handshakeContext.appendToTranscript(encodedCertificateRequest);
   return encodedCertificateRequest;
 }

static Buf fizz::sm::getCertificateVerify	(	SignatureScheme	sigScheme,
		Buf	signature,
		HandshakeContext &	handshakeContext
	)

static

Definition at line 941 of file ServerProtocol.cpp.

References fizz::CertificateVerify::algorithm, fizz::HandshakeContext::appendToTranscript(), fizz::encodeHandshake(), folly::gen::move, fizz::CertificateVerify::signature, and verify().

Referenced by getCertificateRequest().

                                         {
   CertificateVerify verify;
   verify.algorithm = sigScheme;
   verify.signature = std::move(signature);
   auto encodedCertificateVerify = encodeHandshake(std::move(verify));
   handshakeContext.appendToTranscript(encodedCertificateVerify);
   return encodedCertificateVerify;
 }

static std::tuple< folly::Optional<SignatureScheme>, std::shared_ptr<const SelfCert> > fizz::sm::getClientCert	(	const State &	state,
		const std::vector< SignatureScheme > &	schemes
	)

static

Definition at line 1278 of file ClientProtocol.cpp.

References fizz::client::detail::actions(), fizz::CertificateRequest, fizz::client::State::clientAuthRequested(), clientCert, fizz::client::State::context(), fizz::client::ExpectingCertificate, fizz::client::FizzClientContext::getClientCertificate(), fizz::client::FizzClientContext::getSupportedSigSchemes(), fizz::client::State::handshakeContext(), fizz::illegal_parameter, std::tr1::make_tuple(), folly::gen::move, fizz::client::RequestedNoMatch, fizz::client::Sent, and fizz::unexpected_message.

                                                                              {
   folly::Optional<SignatureScheme> selectedScheme;
   auto clientCert = state.context()->getClientCertificate();
   const auto& supportedSchemes = state.context()->getSupportedSigSchemes();
 
   if (clientCert) {
     const auto certSchemes = clientCert->getSigSchemes();
     for (const auto& scheme : supportedSchemes) {
       if (std::find(certSchemes.begin(), certSchemes.end(), scheme) !=
               certSchemes.end() &&
           std::find(schemes.begin(), schemes.end(), scheme) != schemes.end()) {
         selectedScheme = scheme;
         break;
       }
     }
 
     if (!selectedScheme) {
       VLOG(1) << "client cert/context doesn't support any signature algorithms "
               << "specified by the server";
     }
   }
 
   if (!selectedScheme) {
     clientCert = nullptr;
   }
 
   return std::make_tuple(std::move(selectedScheme), std::move(clientCert));
 }

static ClientHello fizz::sm::getClientHello	(	const Factory &	,
		const Random &	random,
		const std::vector< CipherSuite > &	supportedCiphers,
		const std::vector< ProtocolVersion > &	supportedVersions,
		const std::vector< NamedGroup > &	supportedGroups,
		const std::map< NamedGroup, std::unique_ptr< KeyExchange >> &	shares,
		const std::vector< SignatureScheme > &	supportedSigSchemes,
		const std::vector< PskKeyExchangeMode > &	supportedPskModes,
		const folly::Optional< std::string > &	hostname,
		const std::vector< std::string > &	supportedAlpns,
		const std::vector< CertificateCompressionAlgorithm > &	compressionAlgos,
		const Optional< EarlyDataParams > &	earlyDataParams,
		const Buf &	legacySessionId,
		ClientExtensions *	extensions,
		Buf	cookie = `nullptr`
	)

static

Definition at line 333 of file ClientProtocol.cpp.

References fizz::CertificateCompressionAlgorithms::algorithms, alpn, chlo, fizz::ClientHello::cipher_suites, fizz::ClientKeyShare::client_shares, cookie, fizz::Cookie::cookie, folly::IOBuf::copyBuffer(), fizz::encodeExtension(), fizz::ClientHello::extensions, fizz::ClientExtensions::getClientHelloExtensions(), fizz::KeyShareEntry::group, fizz::ServerName::hostname, fizz::KeyShareEntry::key_exchange, fizz::ClientHello::legacy_compression_methods, fizz::ClientHello::legacy_session_id, fizz::ClientHello::legacy_version, fizz::PskKeyExchangeModes::modes, folly::gen::move, fizz::ProtocolName::name, fizz::SupportedGroups::named_group_list, fizz::ProtocolNameList::protocol_name_list, random(), fizz::ClientHello::random, fizz::ServerNameList::server_name_list, folly::pushmi::operators::share, sni, fizz::SignatureAlgorithms::supported_signature_algorithms, fizz::tls_1_2, and fizz::SupportedVersions::versions.

Referenced by getEarlyDataParams(), getHrrKeyExchangers(), and fizz::server::test::TEST_F().

                           {
   ClientHello chlo;
   chlo.legacy_version = ProtocolVersion::tls_1_2;
   chlo.random = random;
   chlo.legacy_session_id = legacySessionId->clone();
   chlo.cipher_suites = supportedCiphers;
   chlo.legacy_compression_methods.push_back(0x00);
 
   SupportedVersions versions;
   versions.versions = supportedVersions;
   chlo.extensions.push_back(encodeExtension(std::move(versions)));
 
   SupportedGroups groups;
   groups.named_group_list = supportedGroups;
   chlo.extensions.push_back(encodeExtension(std::move(groups)));
 
   ClientKeyShare keyShare;
   for (const auto& share : shares) {
     KeyShareEntry entry;
     entry.group = share.first;
     entry.key_exchange = share.second->getKeyShare();
     keyShare.client_shares.push_back(std::move(entry));
   }
   chlo.extensions.push_back(encodeExtension(std::move(keyShare)));
 
   SignatureAlgorithms sigAlgs;
   sigAlgs.supported_signature_algorithms = supportedSigSchemes;
   chlo.extensions.push_back(encodeExtension(std::move(sigAlgs)));
 
   if (hostname) {
     ServerNameList sni;
     ServerName sn;
     sn.hostname = folly::IOBuf::copyBuffer(*hostname);
     sni.server_name_list.push_back(std::move(sn));
     chlo.extensions.push_back(encodeExtension(std::move(sni)));
   }
 
   if (!supportedAlpns.empty()) {
     ProtocolNameList alpn;
     for (const auto& protoName : supportedAlpns) {
       ProtocolName proto;
       proto.name = folly::IOBuf::copyBuffer(protoName);
       alpn.protocol_name_list.push_back(std::move(proto));
     }
     chlo.extensions.push_back(encodeExtension(std::move(alpn)));
   }
 
   if (!supportedPskModes.empty()) {
     PskKeyExchangeModes modes;
     modes.modes = supportedPskModes;
     chlo.extensions.push_back(encodeExtension(std::move(modes)));
   }
 
   if (earlyDataParams) {
     chlo.extensions.push_back(encodeExtension(ClientEarlyData()));
   }
 
   if (cookie) {
     Cookie monster;
     monster.cookie = std::move(cookie);
     chlo.extensions.push_back(encodeExtension(std::move(monster)));
   }
 
   if (!compressionAlgos.empty()) {
     CertificateCompressionAlgorithms algos;
     algos.algorithms = compressionAlgos;
     chlo.extensions.push_back(encodeExtension(std::move(algos)));
   }
 
   if (extensions) {
     auto additionalExtensions = extensions->getClientHelloExtensions();
     for (auto& ext : additionalExtensions) {
       chlo.extensions.push_back(std::move(ext));
     }
   }
 
   return chlo;
 }

static Optional<std::chrono::milliseconds> fizz::sm::getClockSkew	(	const Optional< ResumptionState > &	psk,
		Optional< uint32_t >	obfuscatedAge
	)

static

Definition at line 778 of file ServerProtocol.cpp.

References folly::none, now(), fizz::server::ResumptionState::ticketAgeAdd, and fizz::server::ResumptionState::ticketIssueTime.

Referenced by getCertificateRequest().

                                       {
   if (!psk || !obfuscatedAge) {
     return folly::none;
   }
 
   auto age = std::chrono::milliseconds(
       static_cast<uint32_t>(*obfuscatedAge - psk->ticketAgeAdd));
 
   auto expected = std::chrono::duration_cast<std::chrono::milliseconds>(
       std::chrono::system_clock::now() - psk->ticketIssueTime);
 
   return std::chrono::milliseconds(age - expected);
 }

static Optional<CookieState> fizz::sm::getCookieState	(	const ClientHello &	chlo,
		ProtocolVersion	version,
		CipherSuite	cipher,
		const CookieCipher *	cookieCipher
	)

static

Definition at line 394 of file ServerProtocol.cpp.

References fizz::server::CookieCipher::decrypt(), fizz::decrypt_error, fizz::ClientHello::extensions, futureResState, fizz::handshake_failure, folly::gen::move, folly::none, obfuscatedAge, fizz::protocol_version, pskMode, and fizz::unsupported_extension.

                                       {
   auto cookieExt = getExtension<Cookie>(chlo.extensions);
   if (!cookieExt) {
     return folly::none;
   }
 
   // If the client sent a cookie we can't use we have to consider it a fatal
   // error since we can't reconstruct the handshake transcript.
   if (!cookieCipher) {
     throw FizzException(
         "no cookie cipher", AlertDescription::unsupported_extension);
   }
 
   auto cookieState = cookieCipher->decrypt(std::move(cookieExt->cookie));
 
   if (!cookieState) {
     throw FizzException(
         "could not decrypt cookie", AlertDescription::decrypt_error);
   }
 
   if (cookieState->version != version) {
     throw FizzException(
         "version mismatch with cookie", AlertDescription::protocol_version);
   }
 
   if (cookieState->cipher != cipher) {
     throw FizzException(
         "cipher mismatch with cookie", AlertDescription::handshake_failure);
   }
 
   return cookieState;
 }

static Optional<EarlyDataParams> fizz::sm::getEarlyDataParams	(	const FizzClientContext &	context,
		const Optional< CachedPsk > &	psk
	)

static

Definition at line 498 of file ClientProtocol.cpp.

References fizz::client::detail::actions(), fizz::client::CachedPsk::alpn, fizz::client::EarlyDataParams::alpn, fizz::Attempted, chlo, fizz::client::CachedPsk::cipher, fizz::client::EarlyDataParams::cipher, fizz::client::CachedPsk::clientCert, fizz::client::EarlyDataParams::clientCert, fizz::ClientEarlyTraffic, folly::netops::connect(), fizz::WriteToSocket::contents, context, folly::IOBuf::copyBuffer(), folly::IOBuf::create(), fizz::EarlyData, fizz::client::State::earlyDataParams(), fizz::EarlyExporter, fizz::client::State::earlyWriteRecordLayer(), encodeAndAddBinders(), fizz::encodeHandshake(), getClientHello(), getKeyExchangers(), fizz::client::FizzClientContext::getSendEarlyData(), fizz::client::FizzClientContext::getSupportedAlpns(), fizz::client::CachedPsk::group, fizz::client::CachedPsk::maxEarlyDataSize, fizz::client::ReportEarlyHandshakeSuccess::maxEarlyDataSize, folly::gen::move, folly::none, fizz::NotAttempted, params, fizz::pre_shared_key, random(), folly::range(), fizz::client::CachedPsk::serverCert, fizz::client::EarlyDataParams::serverCert, fizz::Protocol::setAead(), sni, validatePsk(), fizz::client::CachedPsk::version, fizz::client::EarlyDataParams::version, and fizz::detail::write().

Referenced by fizz::client::test::ClientProtocolTest::setupExpectingEncryptedExtensionsEarlySent(), and fizz::client::test::TEST_F().

                                     {
   if (!context.getSendEarlyData()) {
     return folly::none;
   }
 
   if (!psk || psk->maxEarlyDataSize == 0) {
     return folly::none;
   }
 
   if (psk->alpn &&
       std::find(
           context.getSupportedAlpns().begin(),
           context.getSupportedAlpns().end(),
           *psk->alpn) == context.getSupportedAlpns().end()) {
     return folly::none;
   }
 
   EarlyDataParams params;
   params.version = psk->version;
   params.cipher = psk->cipher;
   params.serverCert = psk->serverCert;
   params.clientCert = psk->clientCert;
   params.alpn = psk->alpn;
   return std::move(params);
 }

static Buf fizz::sm::getEncryptedExt	(	HandshakeContext &	handshakeContext,
		const folly::Optional< std::string > &	selectedAlpn,
		EarlyDataType	earlyData,
		std::vector< Extension >	otherExtensions
	)

static

Definition at line 864 of file ServerProtocol.cpp.

References fizz::Accepted, alpn, fizz::HandshakeContext::appendToTranscript(), folly::IOBuf::copyBuffer(), fizz::encodeExtension(), fizz::EncryptedExtensions::extensions, folly::gen::move, fizz::ProtocolName::name, and fizz::ProtocolNameList::protocol_name_list.

Referenced by getCertificateRequest().

                                           {
   EncryptedExtensions encryptedExt;
   if (selectedAlpn) {
     ProtocolNameList alpn;
     ProtocolName protocol;
     protocol.name = folly::IOBuf::copyBuffer(*selectedAlpn);
     alpn.protocol_name_list.push_back(std::move(protocol));
     encryptedExt.extensions.push_back(encodeExtension(std::move(alpn)));
   }
 
   if (earlyData == EarlyDataType::Accepted) {
     encryptedExt.extensions.push_back(encodeExtension(ServerEarlyData()));
   }
 
   for (auto& ext : otherExtensions) {
     encryptedExt.extensions.push_back(std::move(ext));
   }
   auto encodedEncryptedExt =
       encodeHandshake<EncryptedExtensions>(std::move(encryptedExt));
   handshakeContext.appendToTranscript(encodedEncryptedExt);
   return encodedEncryptedExt;
 }

static Buf fizz::sm::getHelloRetryRequest	(	ProtocolVersion	version,
		CipherSuite	cipher,
		NamedGroup	group,
		Buf	legacySessionId,
		HandshakeContext &	handshakeContext
	)

static

Definition at line 671 of file ServerProtocol.cpp.

References fizz::HandshakeContext::appendToTranscript(), cipher, fizz::HelloRetryRequest::cipher_suite, fizz::encodeExtension(), fizz::encodeHandshake(), fizz::HelloRetryRequest::extensions, fizz::getRealDraftVersion(), group, fizz::HelloRetryRequest::legacy_session_id_echo, fizz::HelloRetryRequest::legacy_version, folly::gen::move, fizz::HelloRetryRequestKeyShare::preDraft23, fizz::HelloRetryRequestKeyShare::selected_group, fizz::ServerSupportedVersions::selected_version, fizz::tls_1_2, fizz::tls_1_3_20, fizz::tls_1_3_21, fizz::tls_1_3_22, and version.

Referenced by getCertificateRequest().

                                         {
   Buf encodedHelloRetryRequest;
   auto realVersion = getRealDraftVersion(version);
   if (realVersion == ProtocolVersion::tls_1_3_20 ||
       realVersion == ProtocolVersion::tls_1_3_21) {
     throw std::runtime_error("pre-22 HRR");
   }
 
   HelloRetryRequest hrr;
   hrr.legacy_version = ProtocolVersion::tls_1_2;
   hrr.legacy_session_id_echo = std::move(legacySessionId);
   hrr.cipher_suite = cipher;
   ServerSupportedVersions versionExt;
   versionExt.selected_version = version;
   hrr.extensions.push_back(encodeExtension(std::move(versionExt)));
   HelloRetryRequestKeyShare keyShare;
 
   if (realVersion == ProtocolVersion::tls_1_3_20 ||
       realVersion == ProtocolVersion::tls_1_3_21 ||
       realVersion == ProtocolVersion::tls_1_3_22) {
     keyShare.preDraft23 = true;
   }
 
   keyShare.selected_group = group;
   hrr.extensions.push_back(encodeExtension(std::move(keyShare)));
   encodedHelloRetryRequest = encodeHandshake(std::move(hrr));
 
   handshakeContext.appendToTranscript(encodedHelloRetryRequest);
   return encodedHelloRetryRequest;
 }

static std::map<NamedGroup, std::unique_ptr<KeyExchange> > fizz::sm::getHrrKeyExchangers	(	const Factory &	factory,
		std::map< NamedGroup, std::unique_ptr< KeyExchange >>	previous,
		Optional< NamedGroup >	negotiatedGroup
	)

static

Definition at line 1036 of file ClientProtocol.cpp.

                                           {
   if (negotiatedGroup) {
     if (previous.find(*negotiatedGroup) != previous.end()) {
       throw FizzException(
           "hrr selected already-sent group",
           AlertDescription::illegal_parameter);
     }
     return getKeyExchangers(factory, {*negotiatedGroup});
   } else {
     return previous;
   }
 }

static std::map<NamedGroup, std::unique_ptr<KeyExchange> > fizz::sm::getKeyExchangers	(	const Factory &	factory,
		const std::vector< NamedGroup > &	groups
	)

static

Definition at line 321 of file ClientProtocol.cpp.

References group, fizz::Factory::makeKeyExchange(), and folly::gen::move.

Referenced by getEarlyDataParams(), and getHrrKeyExchangers().

                                          {
   std::map<NamedGroup, std::unique_ptr<KeyExchange>> keyExchangers;
   for (auto group : groups) {
     auto kex = factory.makeKeyExchange(group);
     kex->generateKeyPair();
     keyExchangers.emplace(group, std::move(kex));
   }
   return keyExchangers;
 }

static uint32_t fizz::sm::getMaxEarlyDataSize ( const NewSessionTicket & nst )

static

Definition at line 1661 of file ClientProtocol.cpp.

                                                                  {
   auto earlyData = getExtension<TicketEarlyData>(nst.extensions);
   if (earlyData) {
     return earlyData->max_early_data_size;
   } else {
     return 0;
   }
 }

static ClientPresharedKey fizz::sm::getPskExtension ( const CachedPsk & psk )

static

Definition at line 427 of file ClientProtocol.cpp.

References fizz::PskBinder::binder, fizz::ClientPresharedKey::binders, fizz::client::CachedPsk::cipher, folly::IOBuf::copyBuffer(), count, folly::IOBuf::create(), fizz::getHashFunction(), fizz::getHashSize(), fizz::ClientPresharedKey::identities, folly::gen::move, now(), fizz::PskIdentity::obfuscated_ticket_age, fizz::client::CachedPsk::psk, fizz::PskIdentity::psk_identity, fizz::client::CachedPsk::ticketAgeAdd, and fizz::client::CachedPsk::ticketIssueTime.

Referenced by encodeAndAddBinders().

                                                                 {
   ClientPresharedKey pskExt;
   PskIdentity ident;
   ident.psk_identity = folly::IOBuf::copyBuffer(psk.psk);
   ident.obfuscated_ticket_age =
       std::chrono::duration_cast<std::chrono::milliseconds>(
           std::chrono::system_clock::now() - psk.ticketIssueTime)
           .count();
   ident.obfuscated_ticket_age += psk.ticketAgeAdd;
   pskExt.identities.push_back(std::move(ident));
   PskBinder binder;
   size_t binderSize = getHashSize(getHashFunction(psk.cipher));
   binder.binder = folly::IOBuf::create(binderSize);
   memset(binder.binder->writableData(), 0, binderSize);
   binder.binder->append(binderSize);
   pskExt.binders.push_back(std::move(binder));
   return pskExt;
 }

Future<ReplayCacheResult> fizz::sm::getReplayCacheResult	(	const ClientHello &	chlo,
		bool	zeroRttEnabled,
		ReplayCache *	replayCache
	)

Definition at line 484 of file ServerProtocol.cpp.

References fizz::server::ReplayCache::check(), fizz::ClientHello::extensions, fizz::server::NotChecked, fizz::ClientHello::random, and folly::range().

Referenced by getCertificateRequest().

                               {
   if (!zeroRttEnabled || !replayCache ||
       !getExtension<ClientEarlyData>(chlo.extensions)) {
     return ReplayCacheResult::NotChecked;
   }
 
   return replayCache->check(folly::range(chlo.random));
 }

static ResumptionStateResult fizz::sm::getResumptionState	(	const ClientHello &	chlo,
		const TicketCipher *	ticketCipher,
		const std::vector< PskKeyExchangeMode > &	supportedModes
	)

static

Definition at line 447 of file ServerProtocol.cpp.

References fizz::server::TicketCipher::decrypt(), fizz::ClientHello::extensions, kPskIndex, fizz::missing_extension, fizz::server::negotiate(), folly::none, fizz::NotAttempted, fizz::NotSupported, pskMode, and fizz::Rejected.

Referenced by getCertificateRequest().

                                                          {
   auto psks = getExtension<ClientPresharedKey>(chlo.extensions);
   auto clientModes = getExtension<PskKeyExchangeModes>(chlo.extensions);
   if (psks && !clientModes) {
     throw FizzException("no psk modes", AlertDescription::missing_extension);
   }
 
   Optional<PskKeyExchangeMode> pskMode;
   if (clientModes) {
     pskMode = negotiate(supportedModes, clientModes->modes);
   }
   if (!psks && !pskMode) {
     return ResumptionStateResult(
         std::make_pair(PskType::NotSupported, folly::none));
   } else if (!psks || psks->identities.size() <= kPskIndex) {
     return ResumptionStateResult(
         std::make_pair(PskType::NotAttempted, folly::none));
   } else if (!ticketCipher) {
     VLOG(8) << "No ticket cipher, rejecting PSK.";
     return ResumptionStateResult(
         std::make_pair(PskType::Rejected, folly::none));
   } else if (!pskMode) {
     VLOG(8) << "No psk mode match, rejecting PSK.";
     return ResumptionStateResult(
         std::make_pair(PskType::Rejected, folly::none));
   } else {
     const auto& ident = psks->identities[kPskIndex].psk_identity;
     return ResumptionStateResult(
         ticketCipher->decrypt(ident->clone()),
         pskMode,
         psks->identities[kPskIndex].obfuscated_ticket_age);
   }
 }

static Buf fizz::sm::getServerHello	(	ProtocolVersion	version,
		Random	random,
		CipherSuite	cipher,
		bool	psk,
		Optional< NamedGroup >	group,
		Optional< Buf >	serverShare,
		Buf	legacy_session_id,
		HandshakeContext &	handshakeContext
	)

static

Definition at line 707 of file ServerProtocol.cpp.

References fizz::HandshakeContext::appendToTranscript(), cipher, fizz::ServerHello::cipher_suite, fizz::encodeExtension(), fizz::encodeHandshake(), fizz::ServerHello::extensions, fizz::getRealDraftVersion(), fizz::KeyShareEntry::group, group, fizz::KeyShareEntry::key_exchange, kPskIndex, fizz::ServerHello::legacy_session_id_echo, fizz::ServerHello::legacy_version, folly::gen::move, fizz::ServerKeyShare::preDraft23, fizz::ServerHello::random, fizz::ServerPresharedKey::selected_identity, fizz::ServerSupportedVersions::selected_version, fizz::ServerKeyShare::server_share, fizz::tls_1_2, fizz::tls_1_3_20, fizz::tls_1_3_21, fizz::tls_1_3_22, and version.

Referenced by getCertificateRequest().

                                         {
   ServerHello serverHello;
 
   auto realVersion = getRealDraftVersion(version);
   if (realVersion == ProtocolVersion::tls_1_3_20 ||
       realVersion == ProtocolVersion::tls_1_3_21) {
     serverHello.legacy_version = version;
   } else {
     serverHello.legacy_version = ProtocolVersion::tls_1_2;
     ServerSupportedVersions versionExt;
     versionExt.selected_version = version;
     serverHello.extensions.push_back(encodeExtension(std::move(versionExt)));
     serverHello.legacy_session_id_echo = std::move(legacy_session_id);
   }
 
   serverHello.random = std::move(random);
   serverHello.cipher_suite = cipher;
   if (group) {
     ServerKeyShare serverKeyShare;
     serverKeyShare.server_share.group = *group;
     serverKeyShare.server_share.key_exchange = std::move(*serverShare);
 
     if (realVersion == ProtocolVersion::tls_1_3_20 ||
         realVersion == ProtocolVersion::tls_1_3_21 ||
         realVersion == ProtocolVersion::tls_1_3_22) {
       serverKeyShare.preDraft23 = true;
     }
 
     serverHello.extensions.push_back(
         encodeExtension(std::move(serverKeyShare)));
   }
   if (psk) {
     ServerPresharedKey serverPsk;
     serverPsk.selected_identity = kPskIndex;
     serverHello.extensions.push_back(encodeExtension(std::move(serverPsk)));
   }
   auto encodedServerHello = encodeHandshake(std::move(serverHello));
   handshakeContext.appendToTranscript(encodedServerHello);
   return encodedServerHello;
 }

static MutateState fizz::sm::handleCertMsg	(	const State &	state,
		CertificateMsg	certMsg,
		folly::Optional< CertificateCompressionAlgorithm >	algo
	)

static

Definition at line 1353 of file ClientProtocol.cpp.

                                                          {
   if (!certMsg.certificate_request_context->empty()) {
     throw FizzException(
         "certificate request context must be empty",
         AlertDescription::illegal_parameter);
   }
 
   std::vector<std::shared_ptr<const PeerCert>> serverCerts;
   for (auto& certEntry : certMsg.certificate_list) {
     // We don't request any certificate-related extensions
     if (!certEntry.extensions.empty()) {
       throw FizzException(
           "certificate extensions must be empty",
           AlertDescription::illegal_parameter);
     }
 
     serverCerts.emplace_back(state.context()->getFactory()->makePeerCert(
         std::move(certEntry.cert_data)));
   }
 
   if (serverCerts.empty()) {
     throw FizzException(
         "no certificates received", AlertDescription::illegal_parameter);
   }
 
   ClientAuthType authType =
       state.clientAuthRequested().value_or(ClientAuthType::NotRequested);
 
   return [unverifiedCertChain = std::move(serverCerts),
           authType,
           compAlgo = std::move(algo)](State& newState) mutable {
     newState.unverifiedCertChain() = std::move(unverifiedCertChain);
     newState.clientAuthRequested() = authType;
     newState.serverCertCompAlgo() = std::move(compAlgo);
   };
 }

static Actions fizz::sm::handleEarlyAppWrite	(	const State &	state,
		EarlyAppWrite	appWrite
	)

static

Definition at line 1801 of file ClientProtocol.cpp.

References fizz::Accepted, fizz::client::detail::actions(), fizz::test::appWrite(), fizz::Attempted, fizz::WriteToSocket::callback, fizz::EarlyAppWrite::callback, fizz::AppWrite::callback, fizz::change_cipher_spec, fizz::WriteToSocket::contents, fizz::TLSContent::contentType, fizz::client::State::context(), fizz::TLSContent::data, fizz::EarlyAppWrite::data, fizz::AppWrite::data, fizz::EarlyAppWrite, fizz::client::State::earlyDataType(), fizz::client::State::earlyWriteRecordLayer(), fizz::TLSContent::encryptionLevel, fizz::client::ExpectingCertificate, fizz::client::ExpectingCertificateVerify, fizz::client::ExpectingEncryptedExtensions, fizz::client::ExpectingServerHello, fizz::FakeChangeCipherSpec, fizz::WriteToSocket::flags, fizz::EarlyAppWrite::flags, fizz::AppWrite::flags, fizz::client::FizzClientContext::getCompatibilityMode(), ignoreEarlyAppWrite(), folly::gen::move, folly::none, fizz::NotAttempted, fizz::Plaintext, fizz::Rejected, fizz::client::State::sentCCS(), folly::IOBuf::wrapBuffer(), fizz::detail::write(), fizz::WriteRecordLayer::writeAppData(), and fizz::client::State::writeRecordLayer().

                                                                                {
   switch (*state.earlyDataType()) {
     case EarlyDataType::NotAttempted:
       throw FizzException("invalid early write", folly::none);
     case EarlyDataType::Rejected:
       return ignoreEarlyAppWrite(state, std::move(appWrite));
     case EarlyDataType::Attempted:
     case EarlyDataType::Accepted: {
       WriteToSocket write;
       write.callback = appWrite.callback;
       write.flags = appWrite.flags;
       auto appData =
           state.earlyWriteRecordLayer()->writeAppData(std::move(appWrite.data));
 
       if (!state.sentCCS() && state.context()->getCompatibilityMode()) {
         TLSContent writeCCS;
         writeCCS.data = folly::IOBuf::wrapBuffer(FakeChangeCipherSpec);
         writeCCS.contentType = ContentType::change_cipher_spec;
         writeCCS.encryptionLevel = EncryptionLevel::Plaintext;
         write.contents.emplace_back(std::move(writeCCS));
         write.contents.emplace_back(std::move(appData));
         return actions(
             [](State& newState) { newState.sentCCS() = true; },
             std::move(write));
       } else {
         write.contents.emplace_back(std::move(appData));
         return actions(std::move(write));
       }
     }
   }
   LOG(FATAL) << "Bad EarlyDataType";
 }

static Actions fizz::sm::ignoreEarlyAppWrite	(	const State &	state,
		EarlyAppWrite	write
	)

static

Definition at line 1791 of file ClientProtocol.cpp.

References fizz::client::detail::actions(), fizz::client::State::earlyDataType(), folly::gen::move, folly::none, fizz::Rejected, and fizz::client::ReportEarlyWriteFailed::write.

Referenced by handleEarlyAppWrite().

                                                                             {
   if (*state.earlyDataType() != EarlyDataType::Rejected) {
     throw FizzException("ignoring valid early write", folly::none);
   }
 
   ReportEarlyWriteFailed failedWrite;
   failedWrite.write = std::move(write);
   return actions(std::move(failedWrite));
 }

static Optional<std::string> fizz::sm::negotiateAlpn	(	const ClientHello &	chlo,
		folly::Optional< std::string >	zeroRttAlpn,
		const FizzServerContext &	context
	)

static

Definition at line 756 of file ServerProtocol.cpp.

References fizz::ClientHello::extensions, and fizz::server::FizzServerContext::negotiateAlpn().

Referenced by getCertificateRequest().

                                       {
   auto ext = getExtension<ProtocolNameList>(chlo.extensions);
   std::vector<std::string> clientProtocols;
   if (ext) {
     for (auto& protocol : ext->protocol_name_list) {
       clientProtocols.push_back(protocol.name->moveToFbString().toStdString());
     }
   } else {
     VLOG(6) << "Client did not send ALPN extension";
   }
   auto selected = context.negotiateAlpn(clientProtocols, zeroRttAlpn);
   if (!selected) {
     VLOG(6) << "ALPN mismatch";
   } else {
     VLOG(6) << "ALPN: " << *selected;
   }
   return selected;
 }

static CipherSuite fizz::sm::negotiateCipher	(	const ClientHello &	chlo,
		const std::vector< std::vector< CipherSuite >> &	supportedCiphers
	)

static

Definition at line 514 of file ServerProtocol.cpp.

References cipher, fizz::ClientHello::cipher_suites, fizz::handshake_failure, and fizz::server::negotiate().

Referenced by getCertificateRequest().

                                                                {
   auto cipher = negotiate(supportedCiphers, chlo.cipher_suites);
   if (!cipher) {
     throw FizzException("no cipher match", AlertDescription::handshake_failure);
   }
   return *cipher;
 }

static EarlyDataType fizz::sm::negotiateEarlyDataType	(	bool	acceptEarlyData,
		const ClientHello &	chlo,
		const Optional< ResumptionState > &	psk,
		CipherSuite	cipher,
		Optional< KeyExchangeType >	keyExchangeType,
		const Optional< CookieState > &	cookieState,
		Optional< std::string >	alpn,
		ReplayCacheResult	replayCacheResult,
		Optional< std::chrono::milliseconds >	clockSkew,
		ClockSkewTolerance	clockSkewTolerance,
		const AppTokenValidator *	appTokenValidator
	)

static

Definition at line 794 of file ServerProtocol.cpp.

References fizz::Accepted, fizz::server::ClockSkewTolerance::after, fizz::server::ResumptionState::alpn, fizz::server::ClockSkewTolerance::before, fizz::server::ResumptionState::cipher, fizz::ClientHello::extensions, fizz::HelloRetryRequest, fizz::NotAttempted, fizz::server::NotReplay, fizz::Rejected, and fizz::server::AppTokenValidator::validate().

Referenced by getCertificateRequest().

                                                 {
   if (!getExtension<ClientEarlyData>(chlo.extensions)) {
     return EarlyDataType::NotAttempted;
   }
 
   if (!acceptEarlyData) {
     VLOG(5) << "Rejecting early data: disabled";
     return EarlyDataType::Rejected;
   }
 
   if (!psk) {
     VLOG(5) << "Rejected early data: psk rejected";
     return EarlyDataType::Rejected;
   }
 
   if (psk->cipher != cipher) {
     VLOG(5) << "Rejected early data: cipher mismatch";
     return EarlyDataType::Rejected;
   }
 
   if (psk->alpn != alpn) {
     VLOG(5) << "Rejecting early data: alpn mismatch";
     return EarlyDataType::Rejected;
   }
 
   if (keyExchangeType &&
       *keyExchangeType == KeyExchangeType::HelloRetryRequest) {
     VLOG(5) << "Rejecting early data: HelloRetryRequest";
     return EarlyDataType::Rejected;
   }
 
   if (cookieState) {
     VLOG(5) << "Rejecting early data: Cookie";
     return EarlyDataType::Rejected;
   }
 
   if (replayCacheResult != ReplayCacheResult::NotReplay) {
     VLOG(5) << "Rejecting early data: replay";
     return EarlyDataType::Rejected;
   }
 
   if (!clockSkew || *clockSkew < clockSkewTolerance.before ||
       *clockSkew > clockSkewTolerance.after) {
     VLOG(5) << "Rejecting early data: clock skew clockSkew="
             << (clockSkew ? folly::to<std::string>(clockSkew->count())
                           : "(none)")
             << " toleranceBefore=" << clockSkewTolerance.before.count()
             << " toleranceAfter=" << clockSkewTolerance.after.count();
     return EarlyDataType::Rejected;
   }
 
   if (appTokenValidator && !appTokenValidator->validate(*psk)) {
     VLOG(5) << "Rejecting early data: invalid app token";
     return EarlyDataType::Rejected;
   }
 
   return EarlyDataType::Accepted;
 }

static std::tuple<NamedGroup, Optional<Buf> > fizz::sm::negotiateGroup	(	ProtocolVersion	version,
		const ClientHello &	chlo,
		const std::vector< NamedGroup > &	supportedGroups
	)

static

Definition at line 617 of file ServerProtocol.cpp.

References fizz::ClientHello::extensions, fizz::getRealDraftVersion(), group, fizz::handshake_failure, fizz::illegal_parameter, std::tr1::make_tuple(), fizz::missing_extension, fizz::server::negotiate(), folly::none, folly::pushmi::operators::share, fizz::tls_1_3_20, fizz::tls_1_3_21, fizz::tls_1_3_22, and validateGroups().

Referenced by getCertificateRequest().

                                                   {
   auto groups = getExtension<SupportedGroups>(chlo.extensions);
   if (!groups) {
     throw FizzException("no named groups", AlertDescription::missing_extension);
   }
   auto group = negotiate(supportedGroups, groups->named_group_list);
   if (!group) {
     throw FizzException("no group match", AlertDescription::handshake_failure);
   }
   auto clientShares = getExtension<ClientKeyShare>(chlo.extensions);
   if (!clientShares) {
     throw FizzException(
         "no client shares", AlertDescription::missing_extension);
   }
 
   auto realVersion = getRealDraftVersion(version);
   if (realVersion == ProtocolVersion::tls_1_3_20 ||
       realVersion == ProtocolVersion::tls_1_3_21 ||
       realVersion == ProtocolVersion::tls_1_3_22) {
     if (!clientShares->preDraft23) {
       throw FizzException(
           "post-23 client share", AlertDescription::illegal_parameter);
     }
   } else {
     if (clientShares->preDraft23) {
       throw FizzException(
           "pre-23 client share", AlertDescription::illegal_parameter);
     }
   }
 
   validateGroups(clientShares->client_shares);
   for (const auto& share : clientShares->client_shares) {
     if (share.group == *group) {
       return std::make_tuple(*group, share.key_exchange->clone());
     }
   }
   return std::make_tuple(*group, folly::none);
 }

static auto fizz::sm::negotiateParameters	(	const ServerHello &	shlo,
		const std::vector< ProtocolVersion > &	supportedVersions,
		const std::vector< CipherSuite > &	supportedCiphers,
		const std::map< NamedGroup, std::unique_ptr< KeyExchange >> &	keyExchangers
	)

static

Definition at line 733 of file ClientProtocol.cpp.

References cipher, folly::exchange(), fizz::ServerHello::extensions, getAndValidateVersionAndCipher(), fizz::handshake_failure, std::tr1::make_tuple(), folly::gen::move, and version.

                                                                          {
   ProtocolVersion version;
   CipherSuite cipher;
   std::tie(version, cipher) =
       getAndValidateVersionAndCipher(shlo, supportedVersions, supportedCiphers);
 
   Optional<std::tuple<NamedGroup, Buf, const KeyExchange*>> exchange;
   const auto serverShare = getExtension<ServerKeyShare>(shlo.extensions);
   if (serverShare) {
     auto kex = keyExchangers.find(serverShare->server_share.group);
     if (kex == keyExchangers.end()) {
       throw FizzException(
           "server choose unsupported group",
           AlertDescription::handshake_failure);
     }
     exchange = std::make_tuple(
         serverShare->server_share.group,
         serverShare->server_share.key_exchange->clone(),
         kex->second.get());
   }
 
   return std::make_tuple(version, cipher, std::move(exchange));
 }

static HrrParams fizz::sm::negotiateParameters	(	const HelloRetryRequest &	hrr,
		const std::vector< ProtocolVersion > &	supportedVersions,
		const std::vector< CipherSuite > &	supportedCiphers,
		const std::vector< NamedGroup > &	supportedGroups
	)

static

Definition at line 1011 of file ClientProtocol.cpp.

References fizz::HelloRetryRequest::extensions, getAndValidateVersionAndCipher(), and fizz::handshake_failure.

Referenced by getHrrKeyExchangers(), and negotiatePsk().

                                                   {
   HrrParams negotiated;
   std::tie(negotiated.version, negotiated.cipher) =
       getAndValidateVersionAndCipher(hrr, supportedVersions, supportedCiphers);
 
   auto keyShare = getExtension<HelloRetryRequestKeyShare>(hrr.extensions);
   if (keyShare) {
     if (std::find(
             supportedGroups.begin(),
             supportedGroups.end(),
             keyShare->selected_group) == supportedGroups.end()) {
       throw FizzException(
           "server choose unsupported group in hrr",
           AlertDescription::handshake_failure);
     }
     negotiated.group = keyShare->selected_group;
   }
 
   return negotiated;
 }

static NegotiatedPsk fizz::sm::negotiatePsk	(	const std::vector< PskKeyExchangeMode > &	supportedPskModes,
		const folly::Optional< CachedPsk > &	attemptedPsk,
		const ServerHello &	shlo,
		ProtocolVersion	version,
		CipherSuite	cipher,
		bool	hasExchange
	)

static

Definition at line 794 of file ClientProtocol.cpp.

References fizz::client::detail::actions(), fizz::client::State::attemptedPsk(), fizz::Protocol::checkAllowedExtensions(), fizz::client::CachedPsk::cipher, cipher, fizz::client::CachedPsk::clientCert, clientCert, fizz::ClientHandshakeTraffic, fizz::client::State::context(), folly::IOBuf::copyBuffer(), fizz::client::State::encodedClientHello(), folly::exchange(), fizz::ServerHello::extensions, fizz::KeyExchange::generateSharedSecret(), fizz::client::FizzClientContext::getFactory(), fizz::getHashFunction(), fizz::client::FizzClientContext::getSupportedCiphers(), fizz::client::FizzClientContext::getSupportedPskModes(), fizz::client::FizzClientContext::getSupportedVersions(), group, fizz::Handshake, fizz::handshake_failure, fizz::client::State::handshakeContext(), fizz::ReadRecordLayer::hasUnparsedHandshakeData(), folly::Optional< Value >::hasValue(), fizz::illegal_parameter, fizz::client::State::keyExchangers(), fizz::client::State::keyExchangeType(), fizz::client::State::legacySessionId(), fizz::Factory::makeEncryptedReadRecordLayer(), fizz::Factory::makeEncryptedWriteRecordLayer(), fizz::Factory::makeHandshakeContext(), fizz::Factory::makeKeyScheduler(), mode, folly::gen::move, negotiateParameters(), fizz::None, fizz::NotAttempted, fizz::client::NotRequested, fizz::NotSupported, fizz::OneRtt, fizz::psk_dhe_ke, fizz::psk_ke, pskMode, folly::range(), fizz::client::State::readRecordLayer(), fizz::Rejected, fizz::client::State::requestedExtensions(), scheduler, fizz::client::CachedPsk::serverCert, serverCert, fizz::ServerHandshakeTraffic, fizz::Protocol::setAead(), fizz::client::Stored, fizz::client::CachedPsk::type, fizz::unexpected_message, validateNegotiationConsistency(), fizz::client::CachedPsk::version, and version.

                       {
   auto serverPsk = getExtension<ServerPresharedKey>(shlo.extensions);
   if (!attemptedPsk) {
     if (serverPsk) {
       throw FizzException(
           "server accepted unattempted psk",
           AlertDescription::illegal_parameter);
     } else if (!supportedPskModes.empty()) {
       return NegotiatedPsk(PskType::NotAttempted);
     } else {
       return NegotiatedPsk(PskType::NotSupported);
     }
   } else {
     if (!serverPsk) {
       return NegotiatedPsk(PskType::Rejected);
     }
     if (serverPsk->selected_identity != 0) {
       throw FizzException(
           "server accepted non-0 psk", AlertDescription::illegal_parameter);
     }
 
     if (version != attemptedPsk->version) {
       throw FizzException(
           "different version in psk", AlertDescription::handshake_failure);
     }
     if (getHashFunction(cipher) != getHashFunction(attemptedPsk->cipher)) {
       throw FizzException(
           "incompatible cipher in psk", AlertDescription::handshake_failure);
     }
 
     PskKeyExchangeMode mode = hasExchange ? PskKeyExchangeMode::psk_dhe_ke
                                           : PskKeyExchangeMode::psk_ke;
     if (std::find(supportedPskModes.begin(), supportedPskModes.end(), mode) ==
         supportedPskModes.end()) {
       throw FizzException(
           "server choose unsupported psk mode",
           AlertDescription::handshake_failure);
     }
 
     return NegotiatedPsk(
         attemptedPsk->type,
         mode,
         attemptedPsk->serverCert,
         attemptedPsk->clientCert);
   }
 }

static Optional<ProtocolVersion> fizz::sm::negotiateVersion	(	const ClientHello &	chlo,
		const std::vector< ProtocolVersion > &	versions
	)

static

Definition at line 380 of file ServerProtocol.cpp.

References fizz::ClientHello::extensions, fizz::server::negotiate(), folly::none, and version.

Referenced by getCertificateRequest().

                                                 {
   const auto& clientVersions = getExtension<SupportedVersions>(chlo.extensions);
   if (!clientVersions) {
     return folly::none;
   }
   auto version = negotiate(versions, clientVersions->versions);
   if (!version) {
     return folly::none;
   }
   return version;
 }

static std:: pair<std::unique_ptr<KeyScheduler>, std::unique_ptr<HandshakeContext> > fizz::sm::setupSchedulerAndContext	(	const Factory &	factory,
		CipherSuite	cipher,
		const ClientHello &	chlo,
		const Optional< ResumptionState > &	resState,
		const Optional< CookieState > &	cookieState,
		PskType	pskType,
		std::unique_ptr< HandshakeContext >	handshakeContext,
		ProtocolVersion
	)

static

Definition at line 536 of file ServerProtocol.cpp.

References folly::IOBufQueue::append(), fizz::bad_record_mac, folly::IOBufQueue::cacheChainLength(), folly::IOBufQueue::chainLength(), fizz::server::CookieState::chloHash, fizz::server::CookieState::cipher, cookie, fizz::encodeHandshake(), fizz::CryptoUtils::equal(), fizz::ClientHello::extensions, fizz::External, fizz::ExternalPskBinder, fizz::getBinderLength(), fizz::server::getStatelessHelloRetryRequest(), fizz::server::CookieState::group, fizz::message_hash::hash, fizz::illegal_parameter, kPskIndex, fizz::Factory::makeHandshakeContext(), fizz::Factory::makeKeyScheduler(), folly::IOBufQueue::move(), folly::gen::move, fizz::HandshakeStruct< e, t >::originalEncoding, folly::range(), fizz::ResumptionPskBinder, fizz::server::ResumptionState::resumptionSecret, scheduler, folly::IOBufQueue::split(), and fizz::server::CookieState::version.

Referenced by getCertificateRequest().

                            {
   auto scheduler = factory.makeKeyScheduler(cipher);
 
   if (cookieState) {
     if (handshakeContext) {
       throw FizzException(
           "cookie after statefull hrr", AlertDescription::illegal_parameter);
     }
 
     handshakeContext = factory.makeHandshakeContext(cipher);
 
     message_hash chloHash;
     chloHash.hash = cookieState->chloHash->clone();
     handshakeContext->appendToTranscript(encodeHandshake(std::move(chloHash)));
 
     auto cookie = getExtension<Cookie>(chlo.extensions);
     handshakeContext->appendToTranscript(getStatelessHelloRetryRequest(
         cookieState->version,
         cookieState->cipher,
         cookieState->group,
         std::move(cookie->cookie)));
   } else if (!handshakeContext) {
     handshakeContext = factory.makeHandshakeContext(cipher);
   }
 
   if (resState) {
     scheduler->deriveEarlySecret(resState->resumptionSecret->coalesce());
 
     auto binderKey = scheduler->getSecret(
         pskType == PskType::External ? EarlySecrets::ExternalPskBinder
                                      : EarlySecrets::ResumptionPskBinder,
         handshakeContext->getBlankContext());
 
     folly::IOBufQueue chloQueue(folly::IOBufQueue::cacheChainLength());
     chloQueue.append((*chlo.originalEncoding)->clone());
     auto chloPrefix =
         chloQueue.split(chloQueue.chainLength() - getBinderLength(chlo));
     handshakeContext->appendToTranscript(chloPrefix);
 
     const auto& psks = getExtension<ClientPresharedKey>(chlo.extensions);
     if (!psks || psks->binders.size() <= kPskIndex) {
       throw FizzException("no binders", AlertDescription::illegal_parameter);
     }
     auto expectedBinder =
         handshakeContext->getFinishedData(folly::range(binderKey));
     if (!CryptoUtils::equal(
             expectedBinder->coalesce(),
             psks->binders[kPskIndex].binder->coalesce())) {
       throw FizzException(
           "binder does not match", AlertDescription::bad_record_mac);
     }
 
     handshakeContext->appendToTranscript(chloQueue.move());
     return std::make_pair(std::move(scheduler), std::move(handshakeContext));
   } else {
     handshakeContext->appendToTranscript(*chlo.originalEncoding);
     return std::make_pair(std::move(scheduler), std::move(handshakeContext));
   }
 }

static void fizz::sm::validateAcceptedEarly	(	const State &	state,
		const Optional< std::string > &	alpn
	)

static

Definition at line 1179 of file ClientProtocol.cpp.

                                      {
   const auto& params = state.earlyDataParams();
 
   if (!state.attemptedPsk() || state.pskType() == PskType::Rejected ||
       !params) {
     throw FizzException(
         "early accepted without psk", AlertDescription::illegal_parameter);
   }
 
   if (params->cipher != state.cipher()) {
     throw FizzException(
         "early accepted with different cipher",
         AlertDescription::illegal_parameter);
   }
 
   if (params->alpn != alpn) {
     throw FizzException(
         "early accepted with different alpn",
         AlertDescription::illegal_parameter);
   }
 
   if (!state.earlyWriteRecordLayer()) {
     throw FizzException(
         "no early record layer", AlertDescription::illegal_parameter);
   }
 }

static void fizz::sm::validateClientHello ( const ClientHello & chlo )

static

Definition at line 370 of file ServerProtocol.cpp.

References fizz::Protocol::checkDuplicateExtensions(), fizz::ClientHello::extensions, fizz::illegal_parameter, and fizz::ClientHello::legacy_compression_methods.

Referenced by getCertificateRequest().

                                                          {
   if (chlo.legacy_compression_methods.size() != 1 ||
       chlo.legacy_compression_methods.front() != 0x00) {
     throw FizzException(
         "client compression methods not exactly NULL",
         AlertDescription::illegal_parameter);
   }
   Protocol::checkDuplicateExtensions(chlo.extensions);
 }

static void fizz::sm::validateGroups ( const std::vector< KeyShareEntry > & client_shares )

static

Definition at line 604 of file ServerProtocol.cpp.

References fizz::illegal_parameter, and folly::pushmi::operators::share.

Referenced by negotiateGroup().

                                                                           {
   std::set<NamedGroup> setOfNamedGroups;
 
   for (const auto& share : client_shares) {
     if (setOfNamedGroups.find(share.group) != setOfNamedGroups.end()) {
       throw FizzException(
           "duplicate client key share", AlertDescription::illegal_parameter);
     }
 
     setOfNamedGroups.insert(share.group);
   }
 }

static void fizz::sm::validateNegotiationConsistency	(	const State &	state,
		ProtocolVersion	version,
		CipherSuite	cipher
	)

static

Definition at line 761 of file ClientProtocol.cpp.

References fizz::client::State::cipher(), cipher, fizz::handshake_failure, fizz::client::State::version(), and version.

Referenced by negotiatePsk().

                         {
   if (state.version() && *state.version() != version) {
     throw FizzException(
         "version does not match", AlertDescription::handshake_failure);
   }
   if (state.cipher() && *state.cipher() != cipher) {
     throw FizzException(
         "cipher does not match", AlertDescription::handshake_failure);
   }
 }

static folly::Optional<CachedPsk> fizz::sm::validatePsk	(	const FizzClientContext &	context,
		folly::Optional< CachedPsk >	psk
	)

static

Definition at line 290 of file ClientProtocol.cpp.

References fizz::client::CachedPsk::cipher, fizz::client::FizzClientContext::getSupportedCiphers(), fizz::client::FizzClientContext::getSupportedVersions(), folly::none, now(), fizz::client::CachedPsk::ticketExpirationTime, fizz::toString(), and fizz::client::CachedPsk::version.

Referenced by getEarlyDataParams().

                                   {
   if (!psk) {
     return folly::none;
   }
 
   if (std::chrono::system_clock::now() > psk->ticketExpirationTime) {
     VLOG(1) << "Ignoring expired cached psk";
     return folly::none;
   }
 
   if (std::find(
           context.getSupportedVersions().begin(),
           context.getSupportedVersions().end(),
           psk->version) == context.getSupportedVersions().end()) {
     VLOG(1) << "Ignoring cached psk with protocol version "
             << toString(psk->version);
     return folly::none;
   }
   if (std::find(
           context.getSupportedCiphers().begin(),
           context.getSupportedCiphers().end(),
           psk->cipher) == context.getSupportedCiphers().end()) {
     VLOG(1) << "Ignoring cached psk with cipher " << toString(psk->cipher);
     return folly::none;
   }
 
   return psk;
 }

static bool fizz::sm::validateResumptionState	(	const ResumptionState &	resState,
		PskKeyExchangeMode	,
		ProtocolVersion	version,
		CipherSuite	cipher
	)

static

Definition at line 496 of file ServerProtocol.cpp.

References fizz::server::ResumptionState::cipher, fizz::getHashFunction(), and fizz::server::ResumptionState::version.

Referenced by getCertificateRequest().

                         {
   if (resState.version != version) {
     VLOG(8) << "Protocol version mismatch, rejecting PSK.";
     return false;
   }
 
   if (getHashFunction(resState.cipher) != getHashFunction(cipher)) {
     VLOG(8) << "Hash mismatch, rejecting PSK.";
     return false;
   }
 
   return true;
 }

static WriteToSocket fizz::sm::writeNewSessionTicket	(	const FizzServerContext &	context,
		const WriteRecordLayer &	recordLayer,
		std::chrono::seconds	ticketLifetime,
		uint32_t	ticketAgeAdd,
		Buf	nonce,
		Buf	ticket,
		ProtocolVersion	version
	)

static

Definition at line 1614 of file ServerProtocol.cpp.

References fizz::WriteToSocket::contents, fizz::encodeExtension(), fizz::encodeHandshake(), fizz::NewSessionTicket::extensions, fizz::server::FizzServerContext::getAcceptEarlyData(), fizz::server::FizzServerContext::getMaxEarlyDataSize(), fizz::TicketEarlyData::max_early_data_size, folly::gen::move, nst, fizz::NewSessionTicket::ticket, fizz::NewSessionTicket::ticket_age_add, fizz::NewSessionTicket::ticket_lifetime, fizz::NewSessionTicket::ticket_nonce, and fizz::WriteRecordLayer::writeHandshake().

Referenced by generateTicket().

                              {
   NewSessionTicket nst;
   nst.ticket_lifetime = ticketLifetime.count();
   nst.ticket_age_add = ticketAgeAdd;
   nst.ticket_nonce = std::move(nonce);
   nst.ticket = std::move(ticket);
 
   if (context.getAcceptEarlyData(version)) {
     TicketEarlyData early;
     early.max_early_data_size = context.getMaxEarlyDataSize();
     nst.extensions.push_back(encodeExtension(std::move(early)));
   }
 
   auto encodedNst = encodeHandshake(std::move(nst));
   WriteToSocket nstWrite;
   nstWrite.contents.emplace_back(
       recordLayer.writeHandshake(std::move(encodedNst)));
   return nstWrite;
 }

Classes

Functions

Function Documentation