fizz Namespace Reference

Namespaces
	client
	detail
	extensions
	jni
	server
	sm
	test
	testing
	tool

Classes
struct	Accept
class	Aead
struct	AESGCM128
struct	AESGCM256
struct	AESOCB128
struct	Alert
struct	AppClose
struct	AppData
struct	AppWrite
class	AsyncFizzBase
class	AsyncSelfCert
class	CertDecompressionManager
struct	CertificateAuthorities
struct	CertificateCompressionAlgorithms
class	CertificateCompressor
class	CertificateDecompressor
struct	CertificateEntry
struct	CertificateMsg
struct	CertificateRequest
class	CertificateVerifier
struct	CertificateVerify
class	CertUtils
struct	ChaCha20Poly1305
struct	ClientEarlyData
class	ClientExtensions
struct	ClientHello
struct	ClientKeyShare
struct	ClientPresharedKey
struct	CompressedCertificate
struct	Connect
struct	Cookie
struct	CryptoUtils
class	DefaultCertificateVerifier
struct	DeliverAppData
struct	DistinguishedName
struct	EarlyAppWrite
struct	EncryptedExtensions
class	EncryptedReadRecordLayer
class	EncryptedWriteRecordLayer
struct	EndOfEarlyData
struct	EventType
class	EventVisitor
class	ExportedAuthenticator
class	Exporter
struct	Extension
class	Factory
struct	Finished
class	FizzBase
class	FizzException
class	FizzUtil
class	FizzVerificationException
class	HandshakeContext
class	HandshakeContextImpl
struct	HandshakeStruct
struct	HelloRetryRequest
struct	HelloRetryRequestKeyShare
class	Hkdf
class	HkdfImpl
struct	HkdfLabel
class	Hmac
class	HmacImpl
class	IdentityCert
class	JavaCryptoCertificateVerifier
class	JavaCryptoFactory
class	JavaCryptoPeerCert
class	KeyDerivation
class	KeyDerivationImpl
class	KeyExchange
class	KeyScheduler
struct	KeyShareEntry
struct	KeyUpdate
class	LoggingFactory
class	LoggingKeyScheduler
struct	message_hash
class	MockEncryptedReadRecordLayer
class	MockEncryptedWriteRecordLayer
class	MockKeyDerivation
class	MockKeyExchange
class	MockPlaintextReadRecordLayer
class	MockPlaintextWriteRecordLayer
struct	NewSessionTicket
class	OpenSSLEVPCipher
class	OpenSSLKeyExchange
class	OpenSSLSignature
struct	P256
struct	P384
struct	P521
class	PeerCert
class	PeerCertImpl
class	PlaintextReadRecordLayer
class	PlaintextWriteRecordLayer
class	Protocol
struct	ProtocolName
struct	ProtocolNameList
struct	PskBinder
struct	PskIdentity
struct	PskKeyExchangeModes
struct	RandomGenerator
struct	RandomNumGenerator
class	ReadRecordLayer
struct	ReportError
class	SelfCert
class	SelfCertImpl
struct	ServerEarlyData
class	ServerExtensions
struct	ServerHello
struct	ServerKeyShare
struct	ServerName
struct	ServerNameList
struct	ServerPresharedKey
struct	ServerSupportedVersions
struct	Sha
struct	Sha256
struct	Sha384
struct	SigAlg
struct	SigAlg< SignatureScheme::ecdsa_secp256r1_sha256 >
struct	SigAlg< SignatureScheme::ecdsa_secp384r1_sha384 >
struct	SigAlg< SignatureScheme::ecdsa_secp521r1_sha512 >
struct	SigAlg< SignatureScheme::rsa_pss_sha256 >
struct	SignatureAlgorithms
struct	STACK_OF_X509_deleter
struct	SupportedGroups
struct	SupportedVersions
struct	TicketEarlyData
struct	TLSContent
struct	TLSMessage
struct	TrafficKey
struct	WaitForData
struct	WriteNewSessionTicket
class	WriteRecordLayer
struct	WriteToSocket
class	X25519KeyExchange
class	ZlibCertificateCompressor
class	ZlibCertificateDecompressor

Typedefs
using	P256KeyExchange = detail::OpenSSLECKeyExchange< P256 >
using	P256PublicKeyDecoder = detail::OpenSSLECKeyDecoder< P256 >
using	P256PublicKeyEncoder = detail::OpenSSLECKeyEncoder
using	P384KeyExchange = detail::OpenSSLECKeyExchange< P384 >
using	P384PublicKeyDecoder = detail::OpenSSLECKeyDecoder< P384 >
using	P384PublicKeyEncoder = detail::OpenSSLECKeyEncoder
using	P521KeyExchange = detail::OpenSSLECKeyExchange< P521 >
using	P521PublicKeyDecoder = detail::OpenSSLECKeyDecoder< P521 >
using	P521PublicKeyEncoder = detail::OpenSSLECKeyEncoder
using	Cert = folly::AsyncTransportCertificate
using	Param = boost::variant< ClientHello, ServerHello, EndOfEarlyData, HelloRetryRequest, EncryptedExtensions, CertificateRequest, CompressedCertificate, CertificateMsg, CertificateVerify, Finished, NewSessionTicket, KeyUpdate, Alert, Accept, Connect, AppData, AppWrite, EarlyAppWrite, WriteNewSessionTicket >
using	ContentTypeType = typename std::underlying_type< ContentType >::type
using	ProtocolVersionType = typename std::underlying_type< ProtocolVersion >::type
using	HandshakeTypeType = typename std::underlying_type< HandshakeType >::type
using	Buf = std::unique_ptr< folly::IOBuf >
using	Random = std::array< uint8_t, 32 >

Enumerations
enum	KeyType { KeyType::RSA, KeyType::P256, KeyType::P384, KeyType::P521 }
enum	Direction : uint8_t { Direction::UPSTREAM, Direction::DOWNSTREAM }
enum	VerificationContext { VerificationContext::Client, VerificationContext::Server, VerificationContext::Client, VerificationContext::Server }
enum	CertificateVerifyContext { CertificateVerifyContext::Server, CertificateVerifyContext::Client, CertificateVerifyContext::Authenticator }
enum	VerificationContext { VerificationContext::Client, VerificationContext::Server, VerificationContext::Client, VerificationContext::Server }
enum	Event {   Event::ClientHello, Event::ServerHello, Event::EndOfEarlyData, Event::HelloRetryRequest,   Event::EncryptedExtensions, Event::CertificateRequest, Event::Certificate, Event::CompressedCertificate,   Event::CertificateVerify, Event::Finished, Event::NewSessionTicket, Event::KeyUpdate,   Event::Alert, Event::Accept, Event::Connect, Event::AppData,   Event::EarlyAppWrite, Event::AppWrite, Event::AppClose, Event::WriteNewSessionTicket,   Event::NUM_EVENTS }
enum	EarlySecrets { EarlySecrets::ExternalPskBinder, EarlySecrets::ResumptionPskBinder, EarlySecrets::ClientEarlyTraffic, EarlySecrets::EarlyExporter }
enum	HandshakeSecrets { HandshakeSecrets::ClientHandshakeTraffic, HandshakeSecrets::ServerHandshakeTraffic }
enum	MasterSecrets { MasterSecrets::ExporterMaster, MasterSecrets::ResumptionMaster }
enum	AppTrafficSecrets { AppTrafficSecrets::ClientAppTraffic, AppTrafficSecrets::ServerAppTraffic }
enum	HashFunction { HashFunction::Sha256, HashFunction::Sha384 }
enum	PskType {   PskType::NotSupported, PskType::NotAttempted, PskType::Rejected, PskType::External,   PskType::Resumption }
enum	EncryptionLevel { EncryptionLevel::Plaintext, EncryptionLevel::Handshake, EncryptionLevel::EarlyData, EncryptionLevel::AppTraffic }
enum	KeyExchangeType { KeyExchangeType::None, KeyExchangeType::OneRtt, KeyExchangeType::HelloRetryRequest }
enum	EarlyDataType { EarlyDataType::NotAttempted, EarlyDataType::Attempted, EarlyDataType::Rejected, EarlyDataType::Accepted }
enum	ServerNameType : uint8_t { ServerNameType::host_name = 0 }
enum	ProtocolVersion : uint16_t {   ProtocolVersion::tls_1_0 = 0x0301, ProtocolVersion::tls_1_1 = 0x0302, ProtocolVersion::tls_1_2 = 0x0303, ProtocolVersion::tls_1_3 = 0x0304,   ProtocolVersion::tls_1_3_20 = 0x7f14, ProtocolVersion::tls_1_3_20_fb = 0xfb14, ProtocolVersion::tls_1_3_21 = 0x7f15, ProtocolVersion::tls_1_3_21_fb = 0xfb15,   ProtocolVersion::tls_1_3_22 = 0x7f16, ProtocolVersion::tls_1_3_22_fb = 0xfb16, ProtocolVersion::tls_1_3_23 = 0x7f17, ProtocolVersion::tls_1_3_23_fb = 0xfb17,   ProtocolVersion::tls_1_3_26 = 0x7f1a, ProtocolVersion::tls_1_3_26_fb = 0xfb1a, ProtocolVersion::tls_1_3_28 = 0x7f1c }
enum	ContentType : uint8_t { ContentType::alert = 21, ContentType::handshake = 22, ContentType::application_data = 23, ContentType::change_cipher_spec = 20 }
enum	HandshakeType : uint8_t {   HandshakeType::client_hello = 1, HandshakeType::server_hello = 2, HandshakeType::new_session_ticket = 4, HandshakeType::end_of_early_data = 5,   HandshakeType::hello_retry_request = 6, HandshakeType::encrypted_extensions = 8, HandshakeType::certificate = 11, HandshakeType::certificate_request = 13,   HandshakeType::certificate_verify = 15, HandshakeType::finished = 20, HandshakeType::key_update = 24, HandshakeType::compressed_certificate = 240,   HandshakeType::message_hash = 254 }
enum	ExtensionType : uint16_t {   ExtensionType::server_name = 0, ExtensionType::supported_groups = 10, ExtensionType::signature_algorithms = 13, ExtensionType::application_layer_protocol_negotiation = 16,   ExtensionType::token_binding = 24, ExtensionType::quic_transport_parameters = 26, ExtensionType::key_share_old = 40, ExtensionType::pre_shared_key = 41,   ExtensionType::early_data = 42, ExtensionType::supported_versions = 43, ExtensionType::cookie = 44, ExtensionType::psk_key_exchange_modes = 45,   ExtensionType::certificate_authorities = 47, ExtensionType::post_handshake_auth = 49, ExtensionType::signature_algorithms_cert = 50, ExtensionType::key_share = 51,   ExtensionType::compress_certificate = 0xff02 }
enum	AlertDescription : uint8_t {   AlertDescription::close_notify = 0, AlertDescription::end_of_early_data = 1, AlertDescription::unexpected_message = 10, AlertDescription::bad_record_mac = 20,   AlertDescription::record_overflow = 22, AlertDescription::handshake_failure = 40, AlertDescription::bad_certificate = 42, AlertDescription::unsupported_certificate = 43,   AlertDescription::certificate_revoked = 44, AlertDescription::certificate_expired = 45, AlertDescription::certificate_unknown = 46, AlertDescription::illegal_parameter = 47,   AlertDescription::unknown_ca = 48, AlertDescription::access_denied = 49, AlertDescription::decode_error = 50, AlertDescription::decrypt_error = 51,   AlertDescription::protocol_version = 70, AlertDescription::insufficient_security = 71, AlertDescription::internal_error = 80, AlertDescription::inappropriate_fallback = 86,   AlertDescription::user_canceled = 90, AlertDescription::missing_extension = 109, AlertDescription::unsupported_extension = 110, AlertDescription::certificate_unobtainable = 111,   AlertDescription::unrecognized_name = 112, AlertDescription::bad_certificate_status_response = 113, AlertDescription::bad_certificate_hash_value = 114, AlertDescription::unknown_psk_identity = 115,   AlertDescription::certificate_required = 116 }
enum	CipherSuite : uint16_t { CipherSuite::TLS_AES_128_GCM_SHA256 = 0x1301, CipherSuite::TLS_AES_256_GCM_SHA384 = 0x1302, CipherSuite::TLS_CHACHA20_POLY1305_SHA256 = 0x1303, CipherSuite::TLS_AES_128_OCB_SHA256_EXPERIMENTAL = 0xFF01 }
enum	PskKeyExchangeMode : uint8_t { PskKeyExchangeMode::psk_ke = 0, PskKeyExchangeMode::psk_dhe_ke = 1 }
enum	CertificateCompressionAlgorithm : uint16_t { CertificateCompressionAlgorithm::zlib = 1 }
enum	SignatureScheme : uint16_t {   SignatureScheme::ecdsa_secp256r1_sha256 = 0x0403, SignatureScheme::ecdsa_secp384r1_sha384 = 0x0503, SignatureScheme::ecdsa_secp521r1_sha512 = 0x0603, SignatureScheme::rsa_pss_sha256 = 0x0804,   SignatureScheme::rsa_pss_sha384 = 0x0805, SignatureScheme::rsa_pss_sha512 = 0x0806, SignatureScheme::ed25519 = 0x0807, SignatureScheme::ed448 = 0x0808 }
enum	KeyUpdateRequest : uint8_t { KeyUpdateRequest::update_not_requested = 0, KeyUpdateRequest::update_requested = 1 }
enum	NamedGroup : uint16_t { NamedGroup::secp256r1 = 23, NamedGroup::secp384r1 = 24, NamedGroup::secp521r1 = 25, NamedGroup::x25519 = 29 }

Functions
folly::StringPiece	toString (StateEnum state)
folly::StringPiece	toString (ClientAuthType auth)
folly::StringPiece	toString (client::StateEnum)
folly::StringPiece	toString (client::ClientAuthType)
void	trimBytes (IOBuf &buf, folly::MutableByteRange trimmed)
void	XOR (ByteRange first, MutableByteRange second)
template<typename Func >
void	transformBuffer (const folly::IOBuf &in, folly::IOBuf &out, Func func)
template<size_t BlockSize, typename Func >
folly::io::RWPrivateCursor	transformBufferBlocks (const folly::IOBuf &in, folly::IOBuf &out, Func func)
template<>
folly::Optional< TokenBindingParameters >	getExtension (const std::vector< Extension > &extensions)
template<>
Extension	encodeExtension (const TokenBindingParameters &params)
template<>
Buf	encode (TokenBindingMessage &&message)
template<>
TokenBindingMessage	decode (folly::io::Cursor &cursor)
template<>
folly::Optional< extensions::TokenBindingParameters >	getExtension (const std::vector< Extension > &extensions)
template<>
extensions::TokenBindingMessage	decode (folly::io::Cursor &cursor)
template<>
std::vector< SignatureScheme >	CertUtils::getSigSchemes< KeyType::P256 > ()
template<>
std::vector< SignatureScheme >	CertUtils::getSigSchemes< KeyType::P384 > ()
template<>
std::vector< SignatureScheme >	CertUtils::getSigSchemes< KeyType::P521 > ()
template<>
std::vector< SignatureScheme >	CertUtils::getSigSchemes< KeyType::RSA > ()
folly::StringPiece	toString (Event event)
HashFunction	getHashFunction (CipherSuite cipher)
size_t	getHashSize (HashFunction hash)
folly::StringPiece	toString (HashFunction hash)
folly::StringPiece	toString (PskType pskType)
folly::StringPiece	toString (KeyExchangeType kexType)
folly::StringPiece	toString (EarlyDataType earlyDataType)
std::vector< Extension >::const_iterator	findExtension (const std::vector< Extension > &extensions, ExtensionType type)
template<class T >
folly::Optional< T >	getExtension (const std::vector< Extension > &extensions)
template<>
SignatureAlgorithms	getExtension (folly::io::Cursor &cs)
template<>
SupportedGroups	getExtension (folly::io::Cursor &cs)
template<>
folly::Optional< ClientKeyShare >	getExtension (const std::vector< Extension > &extensions)
template<>
ServerKeyShare	getExtension (folly::io::Cursor &cs)
template<>
HelloRetryRequestKeyShare	getExtension (folly::io::Cursor &cs)
template<>
ClientPresharedKey	getExtension (folly::io::Cursor &cs)
template<>
ServerPresharedKey	getExtension (folly::io::Cursor &cs)
template<>
ClientEarlyData	getExtension (folly::io::Cursor &)
template<>
ServerEarlyData	getExtension (folly::io::Cursor &)
template<>
TicketEarlyData	getExtension (folly::io::Cursor &cs)
template<>
Cookie	getExtension (folly::io::Cursor &cs)
template<>
SupportedVersions	getExtension (folly::io::Cursor &cs)
template<>
ServerSupportedVersions	getExtension (folly::io::Cursor &cs)
template<>
PskKeyExchangeModes	getExtension (folly::io::Cursor &cs)
template<>
ProtocolNameList	getExtension (folly::io::Cursor &cs)
template<>
ServerNameList	getExtension (folly::io::Cursor &cs)
template<>
CertificateAuthorities	getExtension (folly::io::Cursor &cs)
template<>
CertificateCompressionAlgorithms	getExtension (folly::io::Cursor &cs)
template<>
Extension	encodeExtension (const SignatureAlgorithms &sig)
template<>
Extension	encodeExtension (const SupportedGroups &groups)
template<>
Extension	encodeExtension (const ClientKeyShare &share)
template<>
Extension	encodeExtension (const ServerKeyShare &share)
template<>
Extension	encodeExtension (const HelloRetryRequestKeyShare &share)
template<>
Extension	encodeExtension (const ClientPresharedKey &share)
template<>
Extension	encodeExtension (const ServerPresharedKey &share)
template<>
Extension	encodeExtension (const ClientEarlyData &)
template<>
Extension	encodeExtension (const ServerEarlyData &)
template<>
Extension	encodeExtension (const TicketEarlyData &early)
template<>
Extension	encodeExtension (const Cookie &cookie)
template<>
Extension	encodeExtension (const SupportedVersions &versions)
template<>
Extension	encodeExtension (const ServerSupportedVersions &versions)
template<>
Extension	encodeExtension (const PskKeyExchangeModes &modes)
template<>
Extension	encodeExtension (const ProtocolNameList &names)
template<>
Extension	encodeExtension (const ServerNameList &names)
template<>
Extension	encodeExtension (const CertificateAuthorities &authorities)
template<>
Extension	encodeExtension (const CertificateCompressionAlgorithms &cca)
size_t	getBinderLength (const ClientHello &chlo)
template<class T >
T	getExtension (folly::io::Cursor &cursor)
template<class T >
Extension	encodeExtension (const T &t)
template<typename T >
static Param	parse (Buf handshakeMsg, Buf original)
template<>
Param	parse< ServerHello > (Buf handshakeMsg, Buf original)
template<typename T >
void	setWriteDefaults (T *obj)
template<>
Buf	encode< ServerHello > (ServerHello &&shlo)
template<>
Buf	encode< HelloRetryRequest > (HelloRetryRequest &&shlo)
template<>
Buf	encode< EndOfEarlyData > (EndOfEarlyData &&)
template<>
Buf	encode< EncryptedExtensions > (EncryptedExtensions &&extensions)
template<>
Buf	encode< CertificateRequest > (CertificateRequest &&cr)
template<>
Buf	encode< const CertificateMsg & > (const CertificateMsg &cert)
template<>
Buf	encode< CertificateMsg & > (CertificateMsg &cert)
template<>
Buf	encode< CertificateMsg > (CertificateMsg &&cert)
template<>
Buf	encode< CompressedCertificate & > (CompressedCertificate &cc)
template<>
Buf	encode< CompressedCertificate > (CompressedCertificate &&cc)
template<>
Buf	encode< CertificateVerify > (CertificateVerify &&certVerify)
template<>
Buf	encode< Alert > (Alert &&alert)
template<>
Buf	encode< const ClientHello & > (const ClientHello &chlo)
template<>
Buf	encode< ClientHello & > (ClientHello &chlo)
template<>
Buf	encode< ClientHello > (ClientHello &&chlo)
template<>
Buf	encode< Finished > (Finished &&fin)
template<>
Buf	encode< NewSessionTicket > (NewSessionTicket &&nst)
Buf	encodeHkdfLabel (HkdfLabel &&label, const std::string &hkdfLabelPrefix)
template<>
Buf	encode< KeyUpdate > (KeyUpdate &&keyUpdate)
template<>
Buf	encode< message_hash > (message_hash &&hash)
template<class T >
Buf	encodeHandshake (T &&handshakeMsg)
template<>
ClientHello	decode (folly::io::Cursor &cursor)
template<>
ServerHello	decode (folly::io::Cursor &cursor)
template<>
EndOfEarlyData	decode (folly::io::Cursor &)
template<>
EncryptedExtensions	decode (folly::io::Cursor &cursor)
template<>
CertificateRequest	decode (folly::io::Cursor &cursor)
template<>
CertificateMsg	decode (folly::io::Cursor &cursor)
template<>
CompressedCertificate	decode (folly::io::Cursor &cursor)
template<>
CertificateVerify	decode (folly::io::Cursor &cursor)
template<>
NewSessionTicket	decode< NewSessionTicket > (folly::io::Cursor &cursor)
template<>
Alert	decode (folly::io::Cursor &cursor)
template<>
Finished	decode< Finished > (std::unique_ptr< folly::IOBuf > &&buf)
template<>
KeyUpdate	decode< KeyUpdate > (folly::io::Cursor &cursor)
template<class T >
T	decode (std::unique_ptr< folly::IOBuf > &&buf)
template<typename T >
std::string	enumToHex (T enumValue)
ProtocolVersion	getRealDraftVersion (ProtocolVersion version)
std::string	toString (ProtocolVersion version)
std::string	toString (ExtensionType extType)
std::string	toString (AlertDescription alertDesc)
std::string	toString (CipherSuite cipher)
std::string	toString (PskKeyExchangeMode pskKeMode)
std::string	toString (SignatureScheme sigScheme)
std::string	toString (NamedGroup group)
std::string	toString (CertificateCompressionAlgorithm algo)
template<class T >
Buf	encode (T &&t)
template<class T >
T	decode (folly::io::Cursor &cursor)
folly::StringPiece	toString (ReplayCacheResult result)
folly::StringPiece	toString (server::ReplayCacheResult)
folly::StringPiece	toString (server::StateEnum state)
std::string	toString (fizz::server::CertificateStorage storage)
static int	passwordCallback (char *password, int size, int, void *data)
template<>
CipherSuite	parse (folly::StringPiece s)
template<>
NamedGroup	parse (folly::StringPiece s)
template<class T >
T	parse (folly::StringPiece s)

Variables
static const uint32_t	kMinReadSize = 1460
static const uint32_t	kMaxReadSize = 4000
static const uint32_t	kMaxBufSize = 64 * 1024
static constexpr uint16_t	kMaxEncryptedRecordSize = 0x4000 + 256
static constexpr size_t	kEncryptedHeaderSize
constexpr uint16_t	kMaxPlaintextRecordSize = 0x4000
constexpr uint16_t	kMinSuggestedRecordSize = 1500
static constexpr size_t	kPlaintextHeaderSize
static constexpr size_t	kHandshakeHeaderSize
constexpr folly::StringPiece	kHkdfLabelPrefix = "tls13 "
constexpr folly::StringPiece	FakeChangeCipherSpec
constexpr size_t	kMaxHandshakeSize = 0x20000

Typedef Documentation

using fizz::Buf = typedef std::unique_ptr<folly::IOBuf>

Definition at line 22 of file Types.h.

typedef folly::AsyncTransportCertificate fizz::Cert

Definition at line 19 of file JavaCryptoPeerCert.h.

typedef typename std::underlying_type< ContentType >::type fizz::ContentTypeType

Definition at line 13 of file EncryptedRecordLayer.cpp.

using fizz::HandshakeTypeType = typedef typename std::underlying_type<HandshakeType>::type

Definition at line 13 of file RecordLayer.cpp.

using fizz::P256KeyExchange = typedef detail::OpenSSLECKeyExchange<P256>

Definition at line 17 of file ECCurveKeyExchange.h.

using fizz::P256PublicKeyDecoder = typedef detail::OpenSSLECKeyDecoder<P256>

Definition at line 18 of file ECCurveKeyExchange.h.

using fizz::P256PublicKeyEncoder = typedef detail::OpenSSLECKeyEncoder

Definition at line 19 of file ECCurveKeyExchange.h.

using fizz::P384KeyExchange = typedef detail::OpenSSLECKeyExchange<P384>

Definition at line 21 of file ECCurveKeyExchange.h.

using fizz::P384PublicKeyDecoder = typedef detail::OpenSSLECKeyDecoder<P384>

Definition at line 22 of file ECCurveKeyExchange.h.

using fizz::P384PublicKeyEncoder = typedef detail::OpenSSLECKeyEncoder

Definition at line 23 of file ECCurveKeyExchange.h.

using fizz::P521KeyExchange = typedef detail::OpenSSLECKeyExchange<P521>

Definition at line 25 of file ECCurveKeyExchange.h.

using fizz::P521PublicKeyDecoder = typedef detail::OpenSSLECKeyDecoder<P521>

Definition at line 26 of file ECCurveKeyExchange.h.

using fizz::P521PublicKeyEncoder = typedef detail::OpenSSLECKeyEncoder

Definition at line 27 of file ECCurveKeyExchange.h.

using fizz::Param = typedef boost::variant< ClientHello, ServerHello, EndOfEarlyData, HelloRetryRequest, EncryptedExtensions, CertificateRequest, CompressedCertificate, CertificateMsg, CertificateVerify, Finished, NewSessionTicket, KeyUpdate, Alert, Accept, Connect, AppData, AppWrite, EarlyAppWrite, WriteNewSessionTicket>

Parameters for each event that will be processed by the state machine.

Definition at line 90 of file Params.h.

typedef typename std::underlying_type< ProtocolVersion >::type fizz::ProtocolVersionType

Definition at line 15 of file EncryptedRecordLayer.cpp.

using fizz::Random = typedef std::array<uint8_t, 32>

Definition at line 184 of file Types.h.

Enumeration Type Documentation

enum fizz::AlertDescription : uint8_t

strong

Enumerator
close_notify
end_of_early_data
unexpected_message
bad_record_mac
record_overflow
handshake_failure
bad_certificate
unsupported_certificate
certificate_revoked
certificate_expired
certificate_unknown
illegal_parameter
unknown_ca
access_denied
decode_error
decrypt_error
protocol_version
insufficient_security
internal_error
inappropriate_fallback
user_canceled
missing_extension
unsupported_extension
certificate_unobtainable
unrecognized_name
bad_certificate_status_response
bad_certificate_hash_value
unknown_psk_identity
certificate_required

Definition at line 119 of file Types.h.

                            : uint8_t {
  close_notify = 0,
  end_of_early_data = 1,
  unexpected_message = 10,
  bad_record_mac = 20,
  record_overflow = 22,
  handshake_failure = 40,
  bad_certificate = 42,
  unsupported_certificate = 43,
  certificate_revoked = 44,
  certificate_expired = 45,
  certificate_unknown = 46,
  illegal_parameter = 47,
  unknown_ca = 48,
  access_denied = 49,
  decode_error = 50,
  decrypt_error = 51,
  protocol_version = 70,
  insufficient_security = 71,
  internal_error = 80,
  inappropriate_fallback = 86,
  user_canceled = 90,
  missing_extension = 109,
  unsupported_extension = 110,
  certificate_unobtainable = 111,
  unrecognized_name = 112,
  bad_certificate_status_response = 113,
  bad_certificate_hash_value = 114,
  unknown_psk_identity = 115,
  certificate_required = 116
};

enum fizz::AppTrafficSecrets

strong

Enumerator
ClientAppTraffic
ServerAppTraffic

Definition at line 28 of file KeyScheduler.h.

{ ClientAppTraffic, ServerAppTraffic };

enum fizz::CertificateCompressionAlgorithm : uint16_t

strong

Enumerator
zlib

Definition at line 167 of file Types.h.

                                           : uint16_t {
  zlib = 1,
};

enum fizz::CertificateVerifyContext

strong

Enumerator
Server
Client
Authenticator

Definition at line 20 of file Certificate.h.

{ Server, Client, Authenticator };

enum fizz::CipherSuite : uint16_t

strong

Enumerator
TLS_AES_128_GCM_SHA256
TLS_AES_256_GCM_SHA384
TLS_CHACHA20_POLY1305_SHA256
TLS_AES_128_OCB_SHA256_EXPERIMENTAL

Definition at line 153 of file Types.h.

                       : uint16_t {
  TLS_AES_128_GCM_SHA256 = 0x1301,
  TLS_AES_256_GCM_SHA384 = 0x1302,
  TLS_CHACHA20_POLY1305_SHA256 = 0x1303,
  // experimental cipher suites
  TLS_AES_128_OCB_SHA256_EXPERIMENTAL = 0xFF01
};

enum fizz::ContentType : uint8_t

strong

Enumerator
alert
handshake
application_data
change_cipher_spec

Definition at line 46 of file Types.h.

                       : uint8_t {
  alert = 21,
  handshake = 22,
  application_data = 23,

  change_cipher_spec = 20,
};

enum fizz::Direction : uint8_t

strong

Enumerator
UPSTREAM
DOWNSTREAM

Definition at line 21 of file ExportedAuthenticator.h.

                     : uint8_t {
  UPSTREAM, // toward the server
  DOWNSTREAM // toward the client
};

enum fizz::EarlyDataType

strong

Enumerator
NotAttempted
Attempted
Rejected
Accepted

Definition at line 33 of file Types.h.

{ NotAttempted, Attempted, Rejected, Accepted };

enum fizz::EarlySecrets

strong

Enumerator
ExternalPskBinder
ResumptionPskBinder
ClientEarlyTraffic
EarlyExporter

Definition at line 17 of file KeyScheduler.h.

                        {
  ExternalPskBinder,
  ResumptionPskBinder,
  ClientEarlyTraffic,
  EarlyExporter
};

enum fizz::EncryptionLevel

strong

Encryption level for the TLS layer.

Enumerator
Plaintext
Handshake
EarlyData
AppTraffic

Definition at line 29 of file Types.h.

{ Plaintext, Handshake, EarlyData, AppTraffic };

enum fizz::Event

strong

Enumerator
ClientHello
ServerHello
EndOfEarlyData
HelloRetryRequest
EncryptedExtensions
CertificateRequest
Certificate
CompressedCertificate
CertificateVerify
Finished
NewSessionTicket
KeyUpdate
Alert
Accept
Connect
AppData
EarlyAppWrite
AppWrite
AppClose
WriteNewSessionTicket
NUM_EVENTS

Definition at line 15 of file Events.h.

                 {
  ClientHello,
  ServerHello,
  EndOfEarlyData,
  HelloRetryRequest,
  EncryptedExtensions,
  CertificateRequest,
  Certificate,
  CompressedCertificate,
  CertificateVerify,
  Finished,
  NewSessionTicket,
  KeyUpdate,
  Alert,
  Accept,
  Connect,
  AppData,
  EarlyAppWrite,
  AppWrite,
  AppClose,
  WriteNewSessionTicket,
  NUM_EVENTS
};

enum fizz::ExtensionType : uint16_t

strong

Enumerator
server_name
supported_groups
signature_algorithms
application_layer_protocol_negotiation
token_binding
quic_transport_parameters
key_share_old
pre_shared_key
early_data
supported_versions
cookie
psk_key_exchange_modes
certificate_authorities
post_handshake_auth
signature_algorithms_cert
key_share
compress_certificate

Definition at line 95 of file Types.h.

                         : uint16_t {
  server_name = 0,
  supported_groups = 10,
  signature_algorithms = 13,
  application_layer_protocol_negotiation = 16,
  token_binding = 24,
  quic_transport_parameters = 26,
  key_share_old = 40,
  pre_shared_key = 41,
  early_data = 42,
  supported_versions = 43,
  cookie = 44,
  psk_key_exchange_modes = 45,
  certificate_authorities = 47,
  post_handshake_auth = 49,
  signature_algorithms_cert = 50,
  key_share = 51,

  // alternate_server_name = 0xfb00,
  compress_certificate = 0xff02,
};

enum fizz::HandshakeSecrets

strong

Enumerator
ClientHandshakeTraffic
ServerHandshakeTraffic

Definition at line 24 of file KeyScheduler.h.

{ ClientHandshakeTraffic, ServerHandshakeTraffic };

enum fizz::HandshakeType : uint8_t

strong

Enumerator
client_hello
server_hello
new_session_ticket
end_of_early_data
hello_retry_request
encrypted_extensions
certificate
certificate_request
certificate_verify
finished
key_update
compressed_certificate
message_hash

Definition at line 62 of file Types.h.

                         : uint8_t {
  client_hello = 1,
  server_hello = 2,
  new_session_ticket = 4,
  end_of_early_data = 5,
  hello_retry_request = 6,
  encrypted_extensions = 8,
  certificate = 11,
  certificate_request = 13,
  certificate_verify = 15,
  finished = 20,
  key_update = 24,
  compressed_certificate = 240,
  message_hash = 254
};

enum fizz::HashFunction

strong

Enumerator
Sha256
Sha384

Definition at line 16 of file Types.h.

{ Sha256, Sha384 };

enum fizz::KeyExchangeType

strong

Enumerator
None
OneRtt
HelloRetryRequest

Definition at line 31 of file Types.h.

{ None, OneRtt, HelloRetryRequest };

enum fizz::KeyType

strong

Enumerator
RSA
P256
P384
P521

Definition at line 17 of file Signature.h.

{ RSA, P256, P384, P521 };

enum fizz::KeyUpdateRequest : uint8_t

strong

Enumerator
update_not_requested
update_requested

Definition at line 292 of file Types.h.

                            : uint8_t {
  update_not_requested = 0,
  update_requested = 1
};

enum fizz::MasterSecrets

strong

Enumerator
ExporterMaster
ResumptionMaster

Definition at line 26 of file KeyScheduler.h.

{ ExporterMaster, ResumptionMaster };

enum fizz::NamedGroup : uint16_t

strong

Enumerator
secp256r1
secp384r1
secp521r1
x25519

Definition at line 302 of file Types.h.

                      : uint16_t {
  secp256r1 = 23,
  secp384r1 = 24,
  secp521r1 = 25,
  x25519 = 29
};

enum fizz::ProtocolVersion : uint16_t

strong

Enumerator
tls_1_0
tls_1_1
tls_1_2
tls_1_3
tls_1_3_20
tls_1_3_20_fb
tls_1_3_21
tls_1_3_21_fb
tls_1_3_22
tls_1_3_22_fb
tls_1_3_23
tls_1_3_23_fb
tls_1_3_26
tls_1_3_26_fb
tls_1_3_28

Definition at line 24 of file Types.h.

                           : uint16_t {
  tls_1_0 = 0x0301,
  tls_1_1 = 0x0302,
  tls_1_2 = 0x0303,
  tls_1_3 = 0x0304,
  tls_1_3_20 = 0x7f14,
  tls_1_3_20_fb = 0xfb14,
  tls_1_3_21 = 0x7f15,
  tls_1_3_21_fb = 0xfb15,
  tls_1_3_22 = 0x7f16,
  tls_1_3_22_fb = 0xfb16,
  tls_1_3_23 = 0x7f17,
  tls_1_3_23_fb = 0xfb17,
  tls_1_3_26 = 0x7f1a,
  tls_1_3_26_fb = 0xfb1a,
  tls_1_3_28 = 0x7f1c,
};

enum fizz::PskKeyExchangeMode : uint8_t

strong

Enumerator
psk_ke
psk_dhe_ke

Definition at line 163 of file Types.h.

: uint8_t { psk_ke = 0, psk_dhe_ke = 1 };

enum fizz::PskType

strong

Enumerator
NotSupported
NotAttempted
Rejected
External
Resumption

Definition at line 18 of file Types.h.

                   {
  NotSupported,
  NotAttempted,
  Rejected,
  External,
  Resumption
};

enum fizz::ServerNameType : uint8_t

strong

Enumerator
host_name

Definition at line 120 of file Extensions.h.

: uint8_t { host_name = 0 };

enum fizz::SignatureScheme : uint16_t

strong

Enumerator
ecdsa_secp256r1_sha256
ecdsa_secp384r1_sha384
ecdsa_secp521r1_sha512
rsa_pss_sha256
rsa_pss_sha384
rsa_pss_sha512
ed25519
ed448

Definition at line 257 of file Types.h.

                           : uint16_t {
  ecdsa_secp256r1_sha256 = 0x0403,
  ecdsa_secp384r1_sha384 = 0x0503,
  ecdsa_secp521r1_sha512 = 0x0603,
  rsa_pss_sha256 = 0x0804,
  rsa_pss_sha384 = 0x0805,
  rsa_pss_sha512 = 0x0806,
  ed25519 = 0x0807,
  ed448 = 0x0808,
};

enum fizz::VerificationContext

strong

Which context we are verifying in (ie client context means we are a client verifying server certificates).

Enumerator
Client
Server
Client
Server

Definition at line 19 of file DefaultCertificateVerifier.h.

{ Client, Server };

enum fizz::VerificationContext

strong

Which context we are verifying in (ie client context means we are a client verifying server certificates).

Enumerator
Client
Server
Client
Server

Definition at line 19 of file JavaCryptoCertificateVerifier.h.

{ Client, Server };

Function Documentation

template<>

std::vector<SignatureScheme> fizz::CertUtils::getSigSchemes< KeyType::P256 > ( )

inline

Definition at line 17 of file Certificate-inl.h.

References ecdsa_secp256r1_sha256.

                                                                        {
  return {SignatureScheme::ecdsa_secp256r1_sha256};
}

template<>

std::vector<SignatureScheme> fizz::CertUtils::getSigSchemes< KeyType::P384 > ( )

inline

Definition at line 22 of file Certificate-inl.h.

References ecdsa_secp384r1_sha384.

                                                                        {
  return {SignatureScheme::ecdsa_secp384r1_sha384};
}

template<>

std::vector<SignatureScheme> fizz::CertUtils::getSigSchemes< KeyType::P521 > ( )

inline

Definition at line 27 of file Certificate-inl.h.

References ecdsa_secp521r1_sha512.

                                                                        {
  return {SignatureScheme::ecdsa_secp521r1_sha512};
}

template<>

std::vector<SignatureScheme> fizz::CertUtils::getSigSchemes< KeyType::RSA > ( )

inline

Definition at line 32 of file Certificate-inl.h.

References rsa_pss_sha256.

                                                                       {
  return {SignatureScheme::rsa_pss_sha256};
}

template<>

extensions::TokenBindingMessage fizz::decode ( folly::io::Cursor &  cursor )

inline

Definition at line 132 of file Types.cpp.

                                                  {
  TokenBindingMessage message;
  detail::readVector<uint16_t>(message.tokenbindings, cursor);
  return message;
}

template<>

TokenBindingMessage fizz::decode

(

folly::io::Cursor &

cursor

)

Definition at line 132 of file Types.cpp.

Referenced by folly::AtomicStruct< folly::IndexedMemPool::TaggedPtr, Atom >::compare_exchange_strong(), folly::AtomicStruct< folly::IndexedMemPool::TaggedPtr, Atom >::compare_exchange_weak(), proxygen::compress::CompressionSimulator::decodePacket(), fizz::server::AeadTicketCipher< AeadType, CodecType, HkdfType >::decrypt(), folly::AtomicStruct< folly::IndexedMemPool::TaggedPtr, Atom >::exchange(), isLowercase(), folly::AtomicStruct< folly::IndexedMemPool::TaggedPtr, Atom >::load(), folly::AtomicStruct< T, Atom >::operator T(), folly::AtomicStruct< folly::IndexedMemPool::TaggedPtr, Atom >::operator=(), TEST(), fizz::server::test::TEST(), TEST_F(), fizz::test::TYPED_TEST(), folly::json_pointer::unescape(), proxygen::Base64::urlDecode(), and proxygen::huffman::HuffTree::~HuffTree().

                                                  {
  TokenBindingMessage message;
  detail::readVector<uint16_t>(message.tokenbindings, cursor);
  return message;
}

template<class T >

T fizz::decode ( folly::io::Cursor &  cursor )

inline

Definition at line 132 of file Types.cpp.

References alert, fizz::CompressedCertificate::algorithm, fizz::CertificateVerify::algorithm, cc, fizz::CertificateMsg::certificate_list, fizz::CertificateMsg::certificate_request_context, fizz::CertificateRequest::certificate_request_context, chlo, fizz::ServerHello::cipher_suite, fizz::ClientHello::cipher_suites, fizz::CompressedCertificate::compressed_certificate_message, fizz::Alert::description, fizz::ClientHello::extensions, fizz::ServerHello::extensions, fizz::EncryptedExtensions::extensions, fizz::CertificateRequest::extensions, folly::io::detail::CursorBase< Derived, BufType >::isAtEnd(), fizz::ServerHello::legacy_compression_method, fizz::ClientHello::legacy_compression_methods, fizz::ClientHello::legacy_session_id, fizz::ServerHello::legacy_session_id_echo, fizz::ClientHello::legacy_version, fizz::ServerHello::legacy_version, fizz::Alert::level, message, fizz::ClientHello::random, fizz::ServerHello::random, fizz::detail::read(), fizz::detail::readBits24(), fizz::CertificateVerify::signature, fizz::extensions::TokenBindingMessage::tokenbindings, and fizz::CompressedCertificate::uncompressed_length.

Referenced by folly::AtomicStruct< folly::IndexedMemPool::TaggedPtr, Atom >::compare_exchange_strong(), folly::AtomicStruct< folly::IndexedMemPool::TaggedPtr, Atom >::compare_exchange_weak(), proxygen::compress::CompressionSimulator::decodePacket(), fizz::server::AeadTicketCipher< AeadType, CodecType, HkdfType >::decrypt(), folly::AtomicStruct< folly::IndexedMemPool::TaggedPtr, Atom >::exchange(), isLowercase(), folly::AtomicStruct< folly::IndexedMemPool::TaggedPtr, Atom >::load(), folly::AtomicStruct< T, Atom >::operator T(), folly::AtomicStruct< folly::IndexedMemPool::TaggedPtr, Atom >::operator=(), TEST(), fizz::server::test::TEST(), TEST_F(), fizz::test::TYPED_TEST(), folly::json_pointer::unescape(), proxygen::Base64::urlDecode(), and proxygen::huffman::HuffTree::~HuffTree().

                                                  {
  TokenBindingMessage message;
  detail::readVector<uint16_t>(message.tokenbindings, cursor);
  return message;
}

template<>

ClientHello fizz::decode ( folly::io::Cursor &  cursor )

inline

Definition at line 527 of file Types-inl.h.

References chlo, fizz::ClientHello::cipher_suites, fizz::ClientHello::extensions, folly::io::detail::CursorBase< Derived, BufType >::isAtEnd(), fizz::ClientHello::legacy_compression_methods, fizz::ClientHello::legacy_session_id, fizz::ClientHello::legacy_version, fizz::ClientHello::random, and fizz::detail::read().

                                                 {
  ClientHello chlo;
  detail::read(chlo.legacy_version, cursor);
  detail::read(chlo.random, cursor);
  detail::readBuf<uint8_t>(chlo.legacy_session_id, cursor);
  detail::readVector<uint16_t>(chlo.cipher_suites, cursor);
  detail::readVector<uint8_t>(chlo.legacy_compression_methods, cursor);
  // Before TLS 1.3 clients could omit the extensions section entirely. If we're
  // already at the end of the client hello we won't try and read extensions so
  // that this isn't treated as a parse error.
  if (!cursor.isAtEnd()) {
    detail::readVector<uint16_t>(chlo.extensions, cursor);
  }
  return chlo;
}

template<>

ServerHello fizz::decode ( folly::io::Cursor &  cursor )

inline

Definition at line 544 of file Types-inl.h.

References fizz::ServerHello::cipher_suite, fizz::ServerHello::extensions, fizz::ServerHello::legacy_compression_method, fizz::ServerHello::legacy_session_id_echo, fizz::ServerHello::legacy_version, fizz::ServerHello::random, and fizz::detail::read().

                                                 {
  ServerHello shlo;
  detail::read(shlo.legacy_version, cursor);
  detail::read(shlo.random, cursor);
  detail::readBuf<uint8_t>(shlo.legacy_session_id_echo, cursor);
  detail::read(shlo.cipher_suite, cursor);
  detail::read(shlo.legacy_compression_method, cursor);
  detail::readVector<uint16_t>(shlo.extensions, cursor);
  return shlo;
}

template<>

EndOfEarlyData fizz::decode ( folly::io::Cursor &  )

inline

Definition at line 556 of file Types-inl.h.

                                             {
  return EndOfEarlyData();
}

template<>

EncryptedExtensions fizz::decode ( folly::io::Cursor &  cursor )

inline

Definition at line 561 of file Types-inl.h.

References fizz::EncryptedExtensions::extensions.

                                                         {
  EncryptedExtensions ee;
  detail::readVector<uint16_t>(ee.extensions, cursor);
  return ee;
}

template<>

CertificateRequest fizz::decode ( folly::io::Cursor &  cursor )

inline

Definition at line 568 of file Types-inl.h.

References fizz::CertificateRequest::certificate_request_context, and fizz::CertificateRequest::extensions.

                                                        {
  CertificateRequest cr;
  detail::readBuf<uint8_t>(cr.certificate_request_context, cursor);
  detail::readVector<uint16_t>(cr.extensions, cursor);
  return cr;
}

template<>

CertificateMsg fizz::decode ( folly::io::Cursor &  cursor )

inline

Definition at line 576 of file Types-inl.h.

References fizz::CertificateMsg::certificate_list, and fizz::CertificateMsg::certificate_request_context.

                                                    {
  CertificateMsg cert;
  detail::readBuf<uint8_t>(cert.certificate_request_context, cursor);
  detail::readVector<detail::bits24>(cert.certificate_list, cursor);
  return cert;
}

template<>

CompressedCertificate fizz::decode ( folly::io::Cursor &  cursor )

inline

Definition at line 584 of file Types-inl.h.

References fizz::CompressedCertificate::algorithm, cc, fizz::CompressedCertificate::compressed_certificate_message, fizz::detail::read(), fizz::detail::readBits24(), and fizz::CompressedCertificate::uncompressed_length.

                                                           {
  CompressedCertificate cc;
  detail::read(cc.algorithm, cursor);
  cc.uncompressed_length = detail::readBits24(cursor);
  detail::readBuf<detail::bits24>(cc.compressed_certificate_message, cursor);
  return cc;
}

template<>

CertificateVerify fizz::decode ( folly::io::Cursor &  cursor )

inline

Definition at line 593 of file Types-inl.h.

References fizz::CertificateVerify::algorithm, fizz::detail::read(), and fizz::CertificateVerify::signature.

                                                       {
  CertificateVerify certVerify;
  detail::read(certVerify.algorithm, cursor);
  detail::readBuf<uint16_t>(certVerify.signature, cursor);
  return certVerify;
}

template<>

Alert fizz::decode ( folly::io::Cursor &  cursor )

inline

Definition at line 612 of file Types-inl.h.

References alert, fizz::Alert::description, fizz::Alert::level, message, fizz::detail::read(), and fizz::extensions::TokenBindingMessage::tokenbindings.

                                           {
  Alert alert;
  detail::read(alert.level, cursor);
  detail::read(alert.description, cursor);
  return alert;
}

template<class T >

T fizz::decode

(

std::unique_ptr< folly::IOBuf > &&

buf

)

Definition at line 634 of file Types-inl.h.

                                          {
  folly::io::Cursor cursor(buf.get());
  auto decoded = decode<T>(cursor);

  if (!cursor.isAtEnd()) {
    throw std::runtime_error("didn't read entire message");
  }

  return decoded;
}

template<>

Finished fizz::decode< Finished > ( std::unique_ptr< folly::IOBuf > &&  buf )

inline

Definition at line 620 of file Types-inl.h.

References folly::gen::move, and fizz::Finished::verify_data.

                                                                  {
  Finished fin;
  fin.verify_data = std::move(buf);
  return fin;
}

template<>

KeyUpdate fizz::decode< KeyUpdate > ( folly::io::Cursor &  cursor )

inline

Definition at line 627 of file Types-inl.h.

References fizz::detail::read(), and fizz::KeyUpdate::request_update.

                                                          {
  KeyUpdate update;
  detail::read(update.request_update, cursor);
  return update;
}

template<>

NewSessionTicket fizz::decode< NewSessionTicket > ( folly::io::Cursor &  cursor )

inline

Definition at line 601 of file Types-inl.h.

References fizz::NewSessionTicket::extensions, nst, fizz::detail::read(), fizz::NewSessionTicket::ticket, fizz::NewSessionTicket::ticket_age_add, fizz::NewSessionTicket::ticket_lifetime, and fizz::NewSessionTicket::ticket_nonce.

                                                                        {
  NewSessionTicket nst;
  detail::read(nst.ticket_lifetime, cursor);
  detail::read(nst.ticket_age_add, cursor);
  detail::readBuf<uint8_t>(nst.ticket_nonce, cursor);
  detail::readBuf<uint16_t>(nst.ticket, cursor);
  detail::readVector<uint16_t>(nst.extensions, cursor);
  return nst;
}

template<>

Buf fizz::encode

(

TokenBindingMessage &&

message

)

Definition at line 124 of file Types.cpp.

References folly::IOBuf::create().

Referenced by fizz::ZlibCertificateCompressor::compress(), encodeHandshake(), fizz::test::ProtocolTest< ClientTypes, Actions >::expectError(), fizz::test::TEST_F(), fizz::server::test::TEST_F(), and fizz::WriteRecordLayer::writeAlert().

                                          {
  auto buf = folly::IOBuf::create(20);
  folly::io::Appender appender(buf.get(), 20);
  detail::writeVector<uint16_t>(message.tokenbindings, appender);
  return buf;
}

template<class T >

Buf fizz::encode

(

T &&

t

)

template<>

Buf fizz::encode< Alert > ( Alert &&  alert )

inline

Definition at line 436 of file Types-inl.h.

References alert, folly::IOBuf::create(), and fizz::detail::write().

                                        {
  auto buf = folly::IOBuf::create(2);
  folly::io::Appender appender(buf.get(), 2);
  detail::write(alert.level, appender);
  detail::write(alert.description, appender);
  return buf;
}

template<>

Buf fizz::encode< CertificateMsg & > ( CertificateMsg &  cert )

inline

Definition at line 402 of file Types-inl.h.

References encode< const CertificateMsg & >().

Referenced by encode< CertificateMsg >().

                                                         {
  return encode<const CertificateMsg&>(cert);
}

template<>

Buf fizz::encode< CertificateMsg > ( CertificateMsg &&  cert )

inline

Definition at line 407 of file Types-inl.h.

References encode< CertificateMsg & >().

                                                         {
  return encode<CertificateMsg&>(cert);
}

template<>

Buf fizz::encode< CertificateRequest > ( CertificateRequest &&  cr )

inline

Definition at line 384 of file Types-inl.h.

References folly::IOBuf::create().

Referenced by fizz::ExportedAuthenticator::getAuthenticatorRequest(), and fizz::test::AuthenticatorTest::SetUp().

                                                               {
  auto buf = folly::IOBuf::create(20);
  folly::io::Appender appender(buf.get(), 20);
  detail::writeBuf<uint8_t>(cr.certificate_request_context, appender);
  detail::writeVector<uint16_t>(cr.extensions, appender);
  return buf;
}

template<>

Buf fizz::encode< CertificateVerify > ( CertificateVerify &&  certVerify )

inline

Definition at line 427 of file Types-inl.h.

References folly::IOBuf::create(), and fizz::detail::write().

                                                                     {
  auto buf = folly::IOBuf::create(20);
  folly::io::Appender appender(buf.get(), 20);
  detail::write(certVerify.algorithm, appender);
  detail::writeBuf<uint16_t>(certVerify.signature, appender);
  return buf;
}

template<>

Buf fizz::encode< ClientHello & > ( ClientHello &  chlo )

inline

Definition at line 460 of file Types-inl.h.

References chlo, and encode< const ClientHello & >().

Referenced by encode< ClientHello >().

                                                   {
  return encode<const ClientHello&>(chlo);
}

template<>

Buf fizz::encode< ClientHello > ( ClientHello &&  chlo )

inline

Definition at line 465 of file Types-inl.h.

References chlo, and encode< ClientHello & >().

                                                   {
  return encode<ClientHello&>(chlo);
}

template<>

Buf fizz::encode< CompressedCertificate & > ( CompressedCertificate &  cc )

inline

Definition at line 412 of file Types-inl.h.

References cc, folly::IOBuf::create(), fizz::detail::write(), and fizz::detail::writeBits24().

Referenced by encode< CompressedCertificate >().

                                                                     {
  auto buf = folly::IOBuf::create(20);
  folly::io::Appender appender(buf.get(), 20);
  detail::write(cc.algorithm, appender);
  detail::writeBits24(cc.uncompressed_length, appender);
  detail::writeBuf<detail::bits24>(cc.compressed_certificate_message, appender);
  return buf;
}

template<>

Buf fizz::encode< CompressedCertificate > ( CompressedCertificate &&  cc )

inline

Definition at line 422 of file Types-inl.h.

References cc, and encode< CompressedCertificate & >().

                                                                     {
  return encode<CompressedCertificate&>(cc);
}

template<>

Buf fizz::encode< const CertificateMsg & > ( const CertificateMsg &  cert )

inline

Definition at line 393 of file Types-inl.h.

References folly::IOBuf::create().

Referenced by encode< CertificateMsg & >().

                                                                     {
  auto buf = folly::IOBuf::create(20);
  folly::io::Appender appender(buf.get(), 20);
  detail::writeBuf<uint8_t>(cert.certificate_request_context, appender);
  detail::writeVector<detail::bits24>(cert.certificate_list, appender);
  return buf;
}

template<>

Buf fizz::encode< const ClientHello & > ( const ClientHello &  chlo )

inline

Definition at line 445 of file Types-inl.h.

References chlo, folly::IOBuf::create(), uint8_t, and fizz::detail::write().

Referenced by encode< ClientHello & >().

                                                               {
  auto buf = folly::IOBuf::create(
      sizeof(ProtocolVersion) + sizeof(Random) + sizeof(uint8_t) +
      sizeof(CipherSuite) * chlo.cipher_suites.size() + sizeof(uint8_t) + 20);
  folly::io::Appender appender(buf.get(), 20);
  detail::write(chlo.legacy_version, appender);
  detail::write(chlo.random, appender);
  detail::writeBuf<uint8_t>(chlo.legacy_session_id, appender);
  detail::writeVector<uint16_t>(chlo.cipher_suites, appender);
  detail::writeVector<uint8_t>(chlo.legacy_compression_methods, appender);
  detail::writeVector<uint16_t>(chlo.extensions, appender);
  return buf;
}

template<>

Buf fizz::encode< EncryptedExtensions > ( EncryptedExtensions &&  extensions )

inline

Definition at line 376 of file Types-inl.h.

References folly::IOBuf::create().

                                                                         {
  auto buf = folly::IOBuf::create(20);
  folly::io::Appender appender(buf.get(), 20);
  detail::writeVector<uint16_t>(extensions.extensions, appender);
  return buf;
}

template<>

Buf fizz::encode< EndOfEarlyData > ( EndOfEarlyData &&  )

inline

Definition at line 371 of file Types-inl.h.

References folly::IOBuf::create().

                                                    {
  return folly::IOBuf::create(0);
}

template<>

Buf fizz::encode< Finished > ( Finished &&  fin )

inline

Definition at line 470 of file Types-inl.h.

References folly::gen::move.

                                            {
  return std::move(fin.verify_data);
}

template<>

Buf fizz::encode< HelloRetryRequest > ( HelloRetryRequest &&  shlo )

inline

Definition at line 357 of file Types-inl.h.

References folly::IOBuf::create(), fizz::HelloRetryRequest::HrrRandom, and fizz::detail::write().

                                                               {
  auto buf = folly::IOBuf::create(
      sizeof(ProtocolVersion) + sizeof(Random) + sizeof(CipherSuite) + 20);
  folly::io::Appender appender(buf.get(), 20);
  detail::write(shlo.legacy_version, appender);
  detail::write(HelloRetryRequest::HrrRandom, appender);
  detail::writeBuf<uint8_t>(shlo.legacy_session_id_echo, appender);
  detail::write(shlo.cipher_suite, appender);
  detail::write(shlo.legacy_compression_method, appender);
  detail::writeVector<uint16_t>(shlo.extensions, appender);
  return buf;
}

template<>

Buf fizz::encode< KeyUpdate > ( KeyUpdate &&  keyUpdate )

inline

Definition at line 502 of file Types-inl.h.

References folly::IOBuf::create(), and fizz::detail::write().

                                                    {
  auto buf = folly::IOBuf::create(20);
  folly::io::Appender appender(buf.get(), 20);
  detail::write(keyUpdate.request_update, appender);
  return buf;
}

template<>

Buf fizz::encode< message_hash > ( message_hash &&  hash )

inline

Definition at line 510 of file Types-inl.h.

References folly::gen::move.

                                                     {
  return std::move(hash.hash);
}

template<>

Buf fizz::encode< NewSessionTicket > ( NewSessionTicket &&  nst )

inline

Definition at line 475 of file Types-inl.h.

References folly::IOBuf::create(), nst, and fizz::detail::write().

                                                            {
  auto buf = folly::IOBuf::create(20);
  folly::io::Appender appender(buf.get(), 20);
  detail::write(nst.ticket_lifetime, appender);
  detail::write(nst.ticket_age_add, appender);
  if (nst.ticket_nonce) {
    detail::writeBuf<uint8_t>(nst.ticket_nonce, appender);
  }
  detail::writeBuf<uint16_t>(nst.ticket, appender);
  detail::writeVector<uint16_t>(nst.extensions, appender);
  return buf;
}

template<>

Buf fizz::encode< ServerHello > ( ServerHello &&  shlo )

inline

Definition at line 339 of file Types-inl.h.

References folly::IOBuf::create(), and fizz::detail::write().

                                                   {
  auto buf = folly::IOBuf::create(
      sizeof(ProtocolVersion) + sizeof(Random) + sizeof(CipherSuite) + 20);
  folly::io::Appender appender(buf.get(), 20);
  detail::write(shlo.legacy_version, appender);
  detail::write(shlo.random, appender);
  if (shlo.legacy_session_id_echo) {
    detail::writeBuf<uint8_t>(shlo.legacy_session_id_echo, appender);
  }
  detail::write(shlo.cipher_suite, appender);
  if (shlo.legacy_session_id_echo) {
    detail::write(shlo.legacy_compression_method, appender);
  }
  detail::writeVector<uint16_t>(shlo.extensions, appender);
  return buf;
}

template<>

Extension fizz::encodeExtension

(

const TokenBindingParameters &

params

)

Definition at line 113 of file Types.cpp.

References folly::IOBuf::create(), fizz::Extension::extension_data, fizz::Extension::extension_type, fizz::extensions::TokenBindingParameters::key_parameters_list, token_binding, fizz::extensions::TokenBindingParameters::version, and fizz::detail::write().

Referenced by fizz::test::TestMessages::addPsk(), fizz::test::TestMessages::certificateRequest(), fizz::test::ExtensionsTest::checkEncode(), fizz::test::TestMessages::clientHello(), fizz::test::TestMessages::clientHelloPskEarly(), fizz::sm::encodeAndAddBinders(), fizz::test::TestMessages::encryptedExt(), fizz::test::TestMessages::encryptedExtEarly(), fizz::sm::getCertificateRequest(), fizz::JavaCryptoCertificateVerifier::getCertificateRequestExtensions(), fizz::DefaultCertificateVerifier::getCertificateRequestExtensions(), fizz::server::test::AeadCookieCipherTest::getClientHello(), fizz::sm::getClientHello(), fizz::extensions::TokenBindingClientExtension::getClientHelloExtensions(), fizz::sm::getEncryptedExt(), fizz::extensions::TokenBindingServerExtension::getExtensions(), fizz::sm::getHelloRetryRequest(), fizz::sm::getServerHello(), fizz::server::getStatelessHelloRetryRequest(), fizz::test::TestMessages::helloRetryRequest(), fizz::test::TestMessages::serverHello(), fizz::test::TestMessages::serverHelloPsk(), fizz::test::AuthenticatorTest::SetUp(), fizz::extensions::test::TokenBindingClientExtensionTest::setUpServerHelloExtensions(), fizz::extensions::test::TokenBindingServerExtensionTest::setUpTokenBindingWithParameters(), TEST(), fizz::test::TEST_F(), fizz::server::test::TEST_F(), fizz::client::test::TEST_F(), TEST_F(), and fizz::sm::writeNewSessionTicket().

                                                                {
  Extension ext;
  ext.extension_type = ExtensionType::token_binding;
  ext.extension_data = folly::IOBuf::create(0);
  folly::io::Appender appender(ext.extension_data.get(), 10);
  detail::write(params.version, appender);
  detail::writeVector<uint8_t>(params.key_parameters_list, appender);
  return ext;
}

template<class T >

Extension fizz::encodeExtension

(

const T &

t

)

template<>

Extension fizz::encodeExtension ( const SignatureAlgorithms &  sig )

inline

Definition at line 175 of file Extensions-inl.h.

References folly::IOBuf::create(), fizz::Extension::extension_data, fizz::Extension::extension_type, signature_algorithms, and fizz::SignatureAlgorithms::supported_signature_algorithms.

                                                                 {
  Extension ext;
  ext.extension_type = ExtensionType::signature_algorithms;
  ext.extension_data = folly::IOBuf::create(0);
  folly::io::Appender appender(ext.extension_data.get(), 10);
  detail::writeVector<uint16_t>(sig.supported_signature_algorithms, appender);
  return ext;
}

template<>

Extension fizz::encodeExtension ( const SupportedGroups &  groups )

inline

Definition at line 185 of file Extensions-inl.h.

References folly::IOBuf::create(), fizz::Extension::extension_data, fizz::Extension::extension_type, fizz::SupportedGroups::named_group_list, and supported_groups.

                                                                {
  Extension ext;
  ext.extension_type = ExtensionType::supported_groups;
  ext.extension_data = folly::IOBuf::create(0);
  folly::io::Appender appender(ext.extension_data.get(), 10);
  detail::writeVector<uint16_t>(groups.named_group_list, appender);
  return ext;
}

template<>

Extension fizz::encodeExtension ( const ClientKeyShare &  share )

inline

Definition at line 195 of file Extensions-inl.h.

References fizz::ClientKeyShare::client_shares, folly::IOBuf::create(), fizz::Extension::extension_data, fizz::Extension::extension_type, key_share, key_share_old, and fizz::ClientKeyShare::preDraft23.

                                                              {
  Extension ext;
  ext.extension_type = share.preDraft23 ? ExtensionType::key_share_old
                                        : ExtensionType::key_share;
  ext.extension_data = folly::IOBuf::create(0);
  folly::io::Appender appender(ext.extension_data.get(), 10);
  detail::writeVector<uint16_t>(share.client_shares, appender);
  return ext;
}

template<>

Extension fizz::encodeExtension ( const ServerKeyShare &  share )

inline

Definition at line 206 of file Extensions-inl.h.

References folly::IOBuf::create(), fizz::Extension::extension_data, fizz::Extension::extension_type, key_share, key_share_old, fizz::ServerKeyShare::preDraft23, fizz::ServerKeyShare::server_share, and fizz::detail::write().

                                                              {
  Extension ext;
  ext.extension_type = share.preDraft23 ? ExtensionType::key_share_old
                                        : ExtensionType::key_share;
  ext.extension_data = folly::IOBuf::create(0);
  folly::io::Appender appender(ext.extension_data.get(), 10);
  detail::write(share.server_share, appender);
  return ext;
}

template<>

Extension fizz::encodeExtension ( const HelloRetryRequestKeyShare &  share )

inline

Definition at line 217 of file Extensions-inl.h.

References folly::IOBuf::create(), fizz::Extension::extension_data, fizz::Extension::extension_type, key_share, key_share_old, fizz::HelloRetryRequestKeyShare::preDraft23, fizz::HelloRetryRequestKeyShare::selected_group, and fizz::detail::write().

                                                                         {
  Extension ext;
  ext.extension_type = share.preDraft23 ? ExtensionType::key_share_old
                                        : ExtensionType::key_share;
  ext.extension_data = folly::IOBuf::create(0);
  folly::io::Appender appender(ext.extension_data.get(), 10);
  detail::write(share.selected_group, appender);
  return ext;
}

template<>

Extension fizz::encodeExtension ( const ClientPresharedKey &  share )

inline

Definition at line 228 of file Extensions-inl.h.

References fizz::ClientPresharedKey::binders, folly::IOBuf::create(), fizz::Extension::extension_data, fizz::Extension::extension_type, fizz::ClientPresharedKey::identities, and pre_shared_key.

                                                                  {
  Extension ext;
  ext.extension_type = ExtensionType::pre_shared_key;
  ext.extension_data = folly::IOBuf::create(0);
  folly::io::Appender appender(ext.extension_data.get(), 10);
  detail::writeVector<uint16_t>(share.identities, appender);
  detail::writeVector<uint16_t>(share.binders, appender);
  return ext;
}

template<>

Extension fizz::encodeExtension ( const ServerPresharedKey &  share )

inline

Definition at line 239 of file Extensions-inl.h.

References folly::IOBuf::create(), fizz::Extension::extension_data, fizz::Extension::extension_type, pre_shared_key, fizz::ServerPresharedKey::selected_identity, and fizz::detail::write().

                                                                  {
  Extension ext;
  ext.extension_type = ExtensionType::pre_shared_key;
  ext.extension_data = folly::IOBuf::create(0);
  folly::io::Appender appender(ext.extension_data.get(), 10);
  detail::write(share.selected_identity, appender);
  return ext;
}

template<>

Extension fizz::encodeExtension ( const ClientEarlyData &  )

inline

Definition at line 249 of file Extensions-inl.h.

References folly::IOBuf::create(), early_data, fizz::Extension::extension_data, and fizz::Extension::extension_type.

                                                         {
  Extension ext;
  ext.extension_type = ExtensionType::early_data;
  ext.extension_data = folly::IOBuf::create(0);
  return ext;
}

template<>

Extension fizz::encodeExtension ( const ServerEarlyData &  )

inline

Definition at line 257 of file Extensions-inl.h.

References folly::IOBuf::create(), early_data, fizz::Extension::extension_data, and fizz::Extension::extension_type.

                                                         {
  Extension ext;
  ext.extension_type = ExtensionType::early_data;
  ext.extension_data = folly::IOBuf::create(0);
  return ext;
}

template<>

Extension fizz::encodeExtension ( const TicketEarlyData &  early )

inline

Definition at line 265 of file Extensions-inl.h.

References folly::IOBuf::create(), early_data, fizz::Extension::extension_data, fizz::Extension::extension_type, fizz::TicketEarlyData::max_early_data_size, and fizz::detail::write().

                                                               {
  Extension ext;
  ext.extension_type = ExtensionType::early_data;
  ext.extension_data = folly::IOBuf::create(0);
  folly::io::Appender appender(ext.extension_data.get(), 10);
  detail::write(early.max_early_data_size, appender);
  return ext;
}

template<>

Extension fizz::encodeExtension ( const Cookie &  cookie )

inline

Definition at line 275 of file Extensions-inl.h.

References fizz::Cookie::cookie, cookie, folly::IOBuf::create(), fizz::Extension::extension_data, and fizz::Extension::extension_type.

                                                       {
  Extension ext;
  ext.extension_type = ExtensionType::cookie;
  ext.extension_data = folly::IOBuf::create(0);
  folly::io::Appender appender(ext.extension_data.get(), 10);
  detail::writeBuf<uint16_t>(cookie.cookie, appender);
  return ext;
}

template<>

Extension fizz::encodeExtension ( const SupportedVersions &  versions )

inline

Definition at line 285 of file Extensions-inl.h.

References folly::IOBuf::create(), fizz::Extension::extension_data, fizz::Extension::extension_type, supported_versions, and fizz::SupportedVersions::versions.

                                                                    {
  Extension ext;
  ext.extension_type = ExtensionType::supported_versions;
  ext.extension_data = folly::IOBuf::create(0);
  folly::io::Appender appender(ext.extension_data.get(), 10);
  detail::writeVector<uint8_t>(versions.versions, appender);
  return ext;
}

template<>

Extension fizz::encodeExtension ( const ServerSupportedVersions &  versions )

inline

Definition at line 295 of file Extensions-inl.h.

References folly::IOBuf::create(), fizz::Extension::extension_data, fizz::Extension::extension_type, fizz::ServerSupportedVersions::selected_version, supported_versions, and fizz::detail::write().

                                                                          {
  Extension ext;
  ext.extension_type = ExtensionType::supported_versions;
  ext.extension_data = folly::IOBuf::create(0);
  folly::io::Appender appender(ext.extension_data.get(), 10);
  detail::write(versions.selected_version, appender);
  return ext;
}

template<>

Extension fizz::encodeExtension ( const PskKeyExchangeModes &  modes )

inline

Definition at line 305 of file Extensions-inl.h.

References folly::IOBuf::create(), fizz::Extension::extension_data, fizz::Extension::extension_type, fizz::PskKeyExchangeModes::modes, and psk_key_exchange_modes.

                                                                   {
  Extension ext;
  ext.extension_type = ExtensionType::psk_key_exchange_modes;
  ext.extension_data = folly::IOBuf::create(0);
  folly::io::Appender appender(ext.extension_data.get(), 10);
  detail::writeVector<uint8_t>(modes.modes, appender);
  return ext;
}

template<>

Extension fizz::encodeExtension ( const ProtocolNameList &  names )

inline

Definition at line 315 of file Extensions-inl.h.

References application_layer_protocol_negotiation, folly::IOBuf::create(), fizz::Extension::extension_data, fizz::Extension::extension_type, and fizz::ProtocolNameList::protocol_name_list.

                                                                {
  Extension ext;
  ext.extension_type = ExtensionType::application_layer_protocol_negotiation;
  ext.extension_data = folly::IOBuf::create(0);
  folly::io::Appender appender(ext.extension_data.get(), 10);
  detail::writeVector<uint16_t>(names.protocol_name_list, appender);
  return ext;
}

template<>

Extension fizz::encodeExtension ( const ServerNameList &  names )

inline

Definition at line 325 of file Extensions-inl.h.

References folly::IOBuf::create(), fizz::Extension::extension_data, fizz::Extension::extension_type, server_name, and fizz::ServerNameList::server_name_list.

                                                              {
  Extension ext;
  ext.extension_type = ExtensionType::server_name;
  ext.extension_data = folly::IOBuf::create(0);
  folly::io::Appender appender(ext.extension_data.get(), 10);
  detail::writeVector<uint16_t>(names.server_name_list, appender);
  return ext;
}

template<>

Extension fizz::encodeExtension ( const CertificateAuthorities &  authorities )

inline

Definition at line 335 of file Extensions-inl.h.

References fizz::CertificateAuthorities::authorities, certificate_authorities, folly::IOBuf::create(), fizz::Extension::extension_data, and fizz::Extension::extension_type.

                                                                            {
  Extension ext;
  ext.extension_type = ExtensionType::certificate_authorities;
  ext.extension_data = folly::IOBuf::create(0);
  folly::io::Appender appender(ext.extension_data.get(), 10);
  detail::writeVector<uint16_t>(authorities.authorities, appender);
  return ext;
}

template<>

Extension fizz::encodeExtension ( const CertificateCompressionAlgorithms &  cca )

inline

Definition at line 345 of file Extensions-inl.h.

References fizz::CertificateCompressionAlgorithms::algorithms, compress_certificate, folly::IOBuf::create(), fizz::Extension::extension_data, and fizz::Extension::extension_type.

                                                                              {
  Extension ext;
  ext.extension_type = ExtensionType::compress_certificate;
  ext.extension_data = folly::IOBuf::create(0);
  folly::io::Appender appender(ext.extension_data.get(), 10);
  detail::writeVector<uint8_t>(cca.algorithms, appender);
  return ext;
}

template<class T >

Buf fizz::encodeHandshake

(

T &&

handshakeMsg

)

Definition at line 515 of file Types-inl.h.

References folly::IOBuf::create(), encode(), folly::gen::move, fizz::detail::bits24::size, fizz::detail::write(), and fizz::detail::writeBits24().

Referenced by fizz::client::test::ClientProtocolTest::doFinishedFlow(), fizz::sm::encodeAndAddBinders(), fizz::sm::getCertificate(), fizz::sm::getCertificateRequest(), fizz::sm::getCertificateVerify(), fizz::server::test::AeadCookieCipherTest::getClientHello(), fizz::sm::getEarlyDataParams(), fizz::detail::getEmptyAuthenticator(), fizz::server::test::ServerProtocolTest::getEncryptedHandshakeWrite(), fizz::Protocol::getFinished(), fizz::sm::getHelloRetryRequest(), fizz::sm::getHrrKeyExchangers(), fizz::Protocol::getKeyUpdated(), fizz::sm::getServerHello(), fizz::server::getStatelessHelloRetryRequest(), fizz::sm::handleCertMsg(), fizz::ExportedAuthenticator::makeAuthenticator(), fizz::sm::setupSchedulerAndContext(), fizz::client::test::TEST_F(), fizz::server::test::TEST_F(), fizz::ExportedAuthenticator::validate(), and fizz::sm::writeNewSessionTicket().

                                      {
  auto body = encode(std::forward<T>(handshakeMsg));
  auto buf = folly::IOBuf::create(sizeof(HandshakeType) + detail::bits24::size);
  folly::io::Appender appender(buf.get(), 0);
  constexpr auto handshakeType = std::remove_reference<T>::type::handshake_type;
  detail::write(handshakeType, appender);
  detail::writeBits24(body->computeChainDataLength(), appender);
  buf->prependChain(std::move(body));
  return buf;
}

Buf fizz::encodeHkdfLabel ( HkdfLabel &&  label, const std::string &  hkdfLabelPrefix  )

inline

Definition at line 488 of file Types-inl.h.

References folly::IOBuf::copyBuffer(), folly::IOBuf::create(), fizz::test::label, folly::Range< Iter >::size(), and fizz::detail::write().

Referenced by fizz::KeyDerivationImpl< Hash >::expandLabel().

                                      {
  auto labelBuf = folly::IOBuf::copyBuffer(
      folly::to<std::string>(hkdfLabelPrefix, label.label));
  auto buf = folly::IOBuf::create(sizeof(label.length) + label.label.size());
  folly::io::Appender appender(buf.get(), 20);
  detail::write(label.length, appender);
  detail::writeBuf<uint8_t>(labelBuf, appender);
  detail::writeBuf<uint8_t>(label.hash_value, appender);
  return buf;
}

template<typename T >

std::string fizz::enumToHex

(

T

enumValue

)

Definition at line 646 of file Types-inl.h.

References folly::Endian::big(), folly::hexlify(), type, and value.

Referenced by fizz::extensions::toString(), and toString().

                                 {
  auto value = folly::Endian::big(
      static_cast<typename std::underlying_type<T>::type>(enumValue));
  return folly::hexlify(folly::ByteRange(
      reinterpret_cast<const uint8_t*>(&value), sizeof(value)));
}

std::vector< Extension >::const_iterator fizz::findExtension ( const std::vector< Extension > &  extensions, ExtensionType  type  )

inline

Definition at line 15 of file Extensions-inl.h.

Referenced by getExtension(), fizz::test::TestMessages::removeExtension(), fizz::test::TEST_F(), and fizz::client::test::TEST_F().

                        {
  for (auto it = extensions.begin(); it != extensions.end(); ++it) {
    if (it->extension_type == type) {
      return it;
    }
  }
  return extensions.end();
}

size_t fizz::getBinderLength ( const ClientHello &  chlo )

inline

Definition at line 354 of file Extensions-inl.h.

References decode_error, fizz::ClientHello::extensions, pre_shared_key, fizz::detail::read(), and uint16_t.

Referenced by fizz::sm::encodeAndAddBinders(), fizz::sm::setupSchedulerAndContext(), and fizz::test::TEST_F().

                                                       {
  if (chlo.extensions.empty() ||
      chlo.extensions.back().extension_type != ExtensionType::pre_shared_key) {
    throw FizzException(
        "psk not at end of client hello", AlertDescription::decode_error);
  }
  folly::io::Cursor cursor(chlo.extensions.back().extension_data.get());
  uint16_t identitiesLen;
  detail::read(identitiesLen, cursor);
  cursor.skip(identitiesLen);
  uint16_t binderLen;
  detail::read(binderLen, cursor);
  if (cursor.totalLength() != binderLen) {
    throw FizzException(
        "malformed binder length", AlertDescription::decode_error);
  }
  return sizeof(binderLen) + binderLen;
}

template<class T >

folly::Optional< T > fizz::getExtension ( const std::vector< Extension > &  extensions )

inline

Definition at line 27 of file Extensions-inl.h.

References findExtension(), and folly::none.

                                            {
  auto it = findExtension(extensions, T::extension_type);
  if (it == extensions.end()) {
    return folly::none;
  }
  folly::io::Cursor cs{it->extension_data.get()};
  auto ret = getExtension<T>(cs);
  if (!cs.isAtEnd()) {
    throw std::runtime_error("didn't read entire extension");
  }
  return ret;
}

template<>

SignatureAlgorithms fizz::getExtension ( folly::io::Cursor &  cs )

inline

Definition at line 42 of file Extensions-inl.h.

                                                           {
  SignatureAlgorithms sigs;
  detail::readVector<uint16_t>(sigs.supported_signature_algorithms, cs);
  return sigs;
}

template<>

SupportedGroups fizz::getExtension ( folly::io::Cursor &  cs )

inline

Definition at line 49 of file Extensions-inl.h.

References fizz::SupportedGroups::named_group_list.

                                                       {
  SupportedGroups groups;
  detail::readVector<uint16_t>(groups.named_group_list, cs);
  return groups;
}

template<>

folly::Optional< ClientKeyShare > fizz::getExtension ( const std::vector< Extension > &  extensions )

inline

Definition at line 56 of file Extensions-inl.h.

References fizz::ClientKeyShare::client_shares, findExtension(), fizz::extensions::TokenBindingParameters::key_parameters_list, key_share, key_share_old, folly::gen::move, folly::none, params, fizz::ClientKeyShare::preDraft23, fizz::detail::read(), folly::pushmi::operators::share, token_binding, and fizz::extensions::TokenBindingParameters::version.

                                            {
  ClientKeyShare share;
  auto it = findExtension(extensions, ExtensionType::key_share);
  if (it == extensions.end()) {
    it = findExtension(extensions, ExtensionType::key_share_old);
    if (it == extensions.end()) {
      return folly::none;
    }
    share.preDraft23 = true;
  }
  folly::io::Cursor cs{it->extension_data.get()};
  detail::readVector<uint16_t>(share.client_shares, cs);
  return std::move(share);
}

template<>

folly::Optional<extensions::TokenBindingParameters> fizz::getExtension ( const std::vector< Extension > &  extensions )

inline

Definition at line 99 of file Types.cpp.

References fizz::ClientKeyShare::client_shares, findExtension(), fizz::extensions::TokenBindingParameters::key_parameters_list, key_share, key_share_old, folly::gen::move, folly::none, params, fizz::ClientKeyShare::preDraft23, fizz::detail::read(), folly::pushmi::operators::share, token_binding, and fizz::extensions::TokenBindingParameters::version.

                                            {
  auto it = findExtension(extensions, ExtensionType::token_binding);
  if (it == extensions.end()) {
    return folly::none;
  }
  TokenBindingParameters params;
  folly::io::Cursor cursor(it->extension_data.get());
  detail::read(params.version, cursor);
  detail::readVector<uint8_t>(params.key_parameters_list, cursor);
  return std::move(params);
}

template<>

ServerKeyShare fizz::getExtension ( folly::io::Cursor &  cs )

inline

Definition at line 73 of file Extensions-inl.h.

References fizz::detail::read(), fizz::ServerKeyShare::server_share, and folly::pushmi::operators::share.

                                                      {
  ServerKeyShare share;
  detail::read(share.server_share, cs);
  return share;
}

template<>

HelloRetryRequestKeyShare fizz::getExtension ( folly::io::Cursor &  cs )

inline

Definition at line 80 of file Extensions-inl.h.

References fizz::detail::read(), fizz::HelloRetryRequestKeyShare::selected_group, and folly::pushmi::operators::share.

                                                                 {
  HelloRetryRequestKeyShare share;
  detail::read(share.selected_group, cs);
  return share;
}

template<>

ClientPresharedKey fizz::getExtension ( folly::io::Cursor &  cs )

inline

Definition at line 87 of file Extensions-inl.h.

References fizz::ClientPresharedKey::binders, fizz::ClientPresharedKey::identities, and folly::pushmi::operators::share.

                                                          {
  ClientPresharedKey share;
  detail::readVector<uint16_t>(share.identities, cs);
  detail::readVector<uint16_t>(share.binders, cs);
  return share;
}

template<>

ServerPresharedKey fizz::getExtension ( folly::io::Cursor &  cs )

inline

Definition at line 95 of file Extensions-inl.h.

References fizz::detail::read(), fizz::ServerPresharedKey::selected_identity, and folly::pushmi::operators::share.

                                                          {
  ServerPresharedKey share;
  detail::read(share.selected_identity, cs);
  return share;
}

template<>

folly::Optional<TokenBindingParameters> fizz::getExtension

(

const std::vector< Extension > &

extensions

)

Definition at line 99 of file Types.cpp.

                                            {
  auto it = findExtension(extensions, ExtensionType::token_binding);
  if (it == extensions.end()) {
    return folly::none;
  }
  TokenBindingParameters params;
  folly::io::Cursor cursor(it->extension_data.get());
  detail::read(params.version, cursor);
  detail::readVector<uint8_t>(params.key_parameters_list, cursor);
  return std::move(params);
}

template<>

ClientEarlyData fizz::getExtension ( folly::io::Cursor &  )

inline

Definition at line 102 of file Extensions-inl.h.

                                                      {
  return ClientEarlyData();
}

template<>

ServerEarlyData fizz::getExtension ( folly::io::Cursor &  )

inline

Definition at line 107 of file Extensions-inl.h.

                                                      {
  return ServerEarlyData();
}

template<>

TicketEarlyData fizz::getExtension ( folly::io::Cursor &  cs )

inline

Definition at line 112 of file Extensions-inl.h.

References fizz::TicketEarlyData::max_early_data_size, and fizz::detail::read().

                                                       {
  TicketEarlyData early;
  detail::read(early.max_early_data_size, cs);
  return early;
}

template<>

Cookie fizz::getExtension ( folly::io::Cursor &  cs )

inline

Definition at line 119 of file Extensions-inl.h.

References cookie, and fizz::Cookie::cookie.

                                              {
  Cookie cookie;
  detail::readBuf<uint16_t>(cookie.cookie, cs);
  return cookie;
}

template<>

SupportedVersions fizz::getExtension ( folly::io::Cursor &  cs )

inline

Definition at line 126 of file Extensions-inl.h.

References fizz::SupportedVersions::versions.

                                                         {
  SupportedVersions versions;
  detail::readVector<uint8_t>(versions.versions, cs);
  return versions;
}

template<>

ServerSupportedVersions fizz::getExtension ( folly::io::Cursor &  cs )

inline

Definition at line 133 of file Extensions-inl.h.

References fizz::detail::read(), and fizz::ServerSupportedVersions::selected_version.

                                                               {
  ServerSupportedVersions versions;
  detail::read(versions.selected_version, cs);
  return versions;
}

template<>

PskKeyExchangeModes fizz::getExtension ( folly::io::Cursor &  cs )

inline

Definition at line 140 of file Extensions-inl.h.

References fizz::PskKeyExchangeModes::modes.

                                                           {
  PskKeyExchangeModes modes;
  detail::readVector<uint8_t>(modes.modes, cs);
  return modes;
}

template<>

ProtocolNameList fizz::getExtension ( folly::io::Cursor &  cs )

inline

Definition at line 147 of file Extensions-inl.h.

References fizz::ProtocolNameList::protocol_name_list.

                                                        {
  ProtocolNameList names;
  detail::readVector<uint16_t>(names.protocol_name_list, cs);
  return names;
}

template<class T >

T fizz::getExtension ( folly::io::Cursor &  cursor )

inline

Definition at line 42 of file Extensions-inl.h.

References fizz::CertificateCompressionAlgorithms::algorithms, authorities, fizz::CertificateAuthorities::authorities, fizz::ClientPresharedKey::binders, cookie, fizz::Cookie::cookie, fizz::ClientPresharedKey::identities, fizz::TicketEarlyData::max_early_data_size, fizz::PskKeyExchangeModes::modes, fizz::SupportedGroups::named_group_list, fizz::ProtocolNameList::protocol_name_list, fizz::detail::read(), fizz::HelloRetryRequestKeyShare::selected_group, fizz::ServerPresharedKey::selected_identity, fizz::ServerSupportedVersions::selected_version, fizz::ServerNameList::server_name_list, fizz::ServerKeyShare::server_share, folly::pushmi::operators::share, fizz::SignatureAlgorithms::supported_signature_algorithms, and fizz::SupportedVersions::versions.

                                                           {
  SignatureAlgorithms sigs;
  detail::readVector<uint16_t>(sigs.supported_signature_algorithms, cs);
  return sigs;
}

template<>

ServerNameList fizz::getExtension ( folly::io::Cursor &  cs )

inline

Definition at line 154 of file Extensions-inl.h.

References fizz::ServerNameList::server_name_list.

                                                      {
  ServerNameList names;
  detail::readVector<uint16_t>(names.server_name_list, cs);
  return names;
}

template<>

CertificateAuthorities fizz::getExtension ( folly::io::Cursor &  cs )

inline

Definition at line 161 of file Extensions-inl.h.

References authorities, and fizz::CertificateAuthorities::authorities.

                                                              {
  CertificateAuthorities authorities;
  detail::readVector<uint16_t>(authorities.authorities, cs);
  return authorities;
}

template<>

CertificateCompressionAlgorithms fizz::getExtension ( folly::io::Cursor &  cs )

inline

Definition at line 168 of file Extensions-inl.h.

References fizz::CertificateCompressionAlgorithms::algorithms, and fizz::SignatureAlgorithms::supported_signature_algorithms.

                                                                        {
  CertificateCompressionAlgorithms cca;
  detail::readVector<uint8_t>(cca.algorithms, cs);
  return cca;
}

HashFunction fizz::getHashFunction

(

CipherSuite

cipher

)

Definition at line 13 of file Types.cpp.

References Sha256, Sha384, TLS_AES_128_GCM_SHA256, TLS_AES_128_OCB_SHA256_EXPERIMENTAL, TLS_AES_256_GCM_SHA384, and TLS_CHACHA20_POLY1305_SHA256.

Referenced by fizz::sm::getHrrKeyExchangers(), fizz::sm::getPskExtension(), fizz::sm::negotiatePsk(), and fizz::sm::validateResumptionState().

                                                 {
  switch (cipher) {
    case CipherSuite::TLS_AES_128_GCM_SHA256:
    case CipherSuite::TLS_AES_128_OCB_SHA256_EXPERIMENTAL:
    case CipherSuite::TLS_CHACHA20_POLY1305_SHA256:
      return HashFunction::Sha256;
    case CipherSuite::TLS_AES_256_GCM_SHA384:
      return HashFunction::Sha384;
  }
  throw std::runtime_error("unknown cipher suite");
}

size_t fizz::getHashSize

(

HashFunction

hash

)

Definition at line 25 of file Types.cpp.

References Sha256, and Sha384.

Referenced by fizz::sm::getPskExtension().

                                      {
  switch (hash) {
    case HashFunction::Sha256:
      return 32;
    case HashFunction::Sha384:
      return 48;
  }
  throw std::runtime_error("unknown hash function");
}

ProtocolVersion fizz::getRealDraftVersion

(

ProtocolVersion

version

)

Definition at line 16 of file Types.cpp.

References tls_1_3, tls_1_3_20, tls_1_3_20_fb, tls_1_3_21, tls_1_3_21_fb, tls_1_3_22, tls_1_3_22_fb, tls_1_3_23, tls_1_3_23_fb, tls_1_3_26, tls_1_3_26_fb, tls_1_3_28, and toString().

Referenced by fizz::sm::generateTicket(), fizz::sm::getCertificateRequest(), fizz::sm::getHelloRetryRequest(), fizz::sm::getServerHello(), fizz::sm::negotiateGroup(), fizz::EncryptedReadRecordLayer::setProtocolVersion(), and fizz::WriteRecordLayer::setProtocolVersion().

                                                             {
  switch (version) {
    case ProtocolVersion::tls_1_3:
      return ProtocolVersion::tls_1_3;
    case ProtocolVersion::tls_1_3_20:
    case ProtocolVersion::tls_1_3_20_fb:
      return ProtocolVersion::tls_1_3_20;
    case ProtocolVersion::tls_1_3_21:
    case ProtocolVersion::tls_1_3_21_fb:
      return ProtocolVersion::tls_1_3_21;
    case ProtocolVersion::tls_1_3_22:
    case ProtocolVersion::tls_1_3_22_fb:
      return ProtocolVersion::tls_1_3_22;
    case ProtocolVersion::tls_1_3_23:
    case ProtocolVersion::tls_1_3_23_fb:
      return ProtocolVersion::tls_1_3_23;
    case ProtocolVersion::tls_1_3_26:
    case ProtocolVersion::tls_1_3_26_fb:
      return ProtocolVersion::tls_1_3_26;
    case ProtocolVersion::tls_1_3_28:
      return ProtocolVersion::tls_1_3_28;
    default:
      throw std::runtime_error(folly::to<std::string>(
          "getRealDraftVersion() called with ", toString(version)));
  }
}

template<>

CipherSuite fizz::parse ( folly::StringPiece  s )

inline

Definition at line 6 of file Parse-inl.h.

                                             {
  static const std::map<folly::StringPiece, CipherSuite> stringToCiphers = {
      {"TLS_AES_128_GCM_SHA256", CipherSuite::TLS_AES_128_GCM_SHA256},
      {"TLS_AES_256_GCM_SHA384", CipherSuite::TLS_AES_256_GCM_SHA384},
      {"TLS_CHACHA20_POLY1305_SHA256",
       CipherSuite::TLS_CHACHA20_POLY1305_SHA256},
      {"TLS_AES_128_OCB_SHA256_EXPERIMENTAL",
       CipherSuite::TLS_AES_128_OCB_SHA256_EXPERIMENTAL}};

  auto location = stringToCiphers.find(s);
  if (location != stringToCiphers.end()) {
    return location->second;
  }

  throw std::runtime_error(folly::to<std::string>("Unknown cipher suite: ", s));
}

template<class T >

T fizz::parse ( folly::StringPiece  s )

inline

Definition at line 6 of file Parse-inl.h.

References secp256r1, TLS_AES_128_GCM_SHA256, TLS_AES_128_OCB_SHA256_EXPERIMENTAL, TLS_AES_256_GCM_SHA384, TLS_CHACHA20_POLY1305_SHA256, and x25519.

                                             {
  static const std::map<folly::StringPiece, CipherSuite> stringToCiphers = {
      {"TLS_AES_128_GCM_SHA256", CipherSuite::TLS_AES_128_GCM_SHA256},
      {"TLS_AES_256_GCM_SHA384", CipherSuite::TLS_AES_256_GCM_SHA384},
      {"TLS_CHACHA20_POLY1305_SHA256",
       CipherSuite::TLS_CHACHA20_POLY1305_SHA256},
      {"TLS_AES_128_OCB_SHA256_EXPERIMENTAL",
       CipherSuite::TLS_AES_128_OCB_SHA256_EXPERIMENTAL}};

  auto location = stringToCiphers.find(s);
  if (location != stringToCiphers.end()) {
    return location->second;
  }

  throw std::runtime_error(folly::to<std::string>("Unknown cipher suite: ", s));
}

template<>

NamedGroup fizz::parse ( folly::StringPiece  s )

inline

Definition at line 24 of file Parse-inl.h.

References secp256r1, TLS_AES_128_GCM_SHA256, TLS_AES_128_OCB_SHA256_EXPERIMENTAL, TLS_AES_256_GCM_SHA384, TLS_CHACHA20_POLY1305_SHA256, and x25519.

                                            {
  static const std::map<folly::StringPiece, NamedGroup> stringToGroups = {
      {"secp256r1", NamedGroup::secp256r1}, {"x25519", NamedGroup::x25519}};

  auto location = stringToGroups.find(s);
  if (location != stringToGroups.end()) {
    return location->second;
  }

  throw std::runtime_error(folly::to<std::string>("Unknown named group: ", s));
}

template<typename T >

static Param fizz::parse ( Buf  handshakeMsg, Buf  original  )

static

Definition at line 68 of file RecordLayer.cpp.

References folly::gen::move.

                                                   {
  auto msg = decode<T>(std::move(handshakeMsg));
  msg.originalEncoding = std::move(original);
  return std::move(msg);
}

template<>

Param fizz::parse< ServerHello >	(	Buf	handshakeMsg,
		Buf	original
	)

Definition at line 75 of file RecordLayer.cpp.

References fizz::HelloRetryRequest::cipher_suite, fizz::HelloRetryRequest::extensions, fizz::HelloRetryRequest::HrrRandom, fizz::HelloRetryRequest::legacy_compression_method, fizz::HelloRetryRequest::legacy_session_id_echo, fizz::HelloRetryRequest::legacy_version, folly::gen::move, and fizz::HandshakeStruct< e, t >::originalEncoding.

Referenced by fizz::ReadRecordLayer::decodeHandshakeMessage().

                                                         {
  auto shlo = decode<ServerHello>(std::move(handshakeMsg));
  if (shlo.random == HelloRetryRequest::HrrRandom) {
    HelloRetryRequest hrr;
    hrr.legacy_version = shlo.legacy_version;
    hrr.legacy_session_id_echo = std::move(shlo.legacy_session_id_echo);
    hrr.cipher_suite = shlo.cipher_suite;
    hrr.legacy_compression_method = shlo.legacy_compression_method;
    hrr.extensions = std::move(shlo.extensions);

    hrr.originalEncoding = std::move(original);
    return std::move(hrr);
  } else {
    shlo.originalEncoding = std::move(original);
    return std::move(shlo);
  }
}

static int fizz::passwordCallback ( char *  password, int  size, int  , void *  data  )

static

Definition at line 19 of file FizzUtil.cpp.

References data, min, folly::size(), and string.

Referenced by fizz::FizzUtil::decryptPrivateKey(), and folly::SSLContext::passwordCollector().

                                                                       {
  if (!password || !data || size < 1) {
    LOG(ERROR) << "invalid password buffer, size is " << size;
    return 0;
  }
  std::string userPassword;
  static_cast<folly::PasswordInFile*>(data)->getPassword(userPassword, size);
  if (userPassword.empty()) {
    LOG(ERROR) << "empty private key password";
    return 0;
  }
  auto length = std::min(static_cast<int>(userPassword.size()), size - 1);
  memcpy(password, userPassword.data(), length);
  password[length] = '\0';
  return length;
}

template<typename T >

void fizz::setWriteDefaults

(

T *

obj

)

Definition at line 21 of file Mocks.h.

References testing::_, fizz::TLSContent::contentType, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, fizz::TLSContent::encryptionLevel, fizz::TLSMessage::fragment, testing::Invoke(), folly::gen::move, ON_CALL, and fizz::TLSMessage::type.

Referenced by fizz::MockPlaintextWriteRecordLayer::setDefaults(), and fizz::MockEncryptedWriteRecordLayer::setDefaults().

                              {
  ON_CALL(*obj, _write(_)).WillByDefault(Invoke([obj](TLSMessage& msg) {
    TLSContent content;
    content.contentType = msg.type;
    content.encryptionLevel = obj->getEncryptionLevel();

    if (msg.type == ContentType::application_data) {
      content.data = folly::IOBuf::copyBuffer("appdata");
    } else if (msg.type == ContentType::handshake) {
      content.data = folly::IOBuf::copyBuffer("handshake");
    } else if (msg.type == ContentType::alert) {
      auto buf = folly::IOBuf::copyBuffer("alert");
      buf->prependChain(std::move(msg.fragment));
      buf->coalesce();
      content.data = std::move(buf);
    } else {
      content.data = std::unique_ptr<folly::IOBuf>();
    }
    return content;
  }));
}

std::string fizz::toString

(

fizz::server::CertificateStorage

storage

)

Definition at line 12 of file TicketCodec.cpp.

References None.

                                                         {
  using fizz::server::CertificateStorage;
  switch (storage) {
    case CertificateStorage::None:
      return "None";
    case CertificateStorage::X509:
      return "X509";
    case CertificateStorage::IdentityOnly:
      return "IdentityOnly";
    default:
      return "Unknown storage";
  }
}

folly::StringPiece fizz::toString

(

Event

event

)

Definition at line 12 of file Events.cpp.

References Accept, Alert, AppClose, AppData, AppWrite, Certificate, CertificateRequest, CertificateVerify, ClientHello, CompressedCertificate, Connect, EarlyAppWrite, EncryptedExtensions, EndOfEarlyData, Finished, HelloRetryRequest, KeyUpdate, NewSessionTicket, NUM_EVENTS, ServerHello, and WriteNewSessionTicket.

                                       {
  switch (event) {
    case Event::ClientHello:
      return "ClientHello";
    case Event::ServerHello:
      return "ServerHello";
    case Event::EndOfEarlyData:
      return "EndOfEarlyData";
    case Event::HelloRetryRequest:
      return "HelloRetryRequest";
    case Event::EncryptedExtensions:
      return "EncryptedExtensions";
    case Event::CertificateRequest:
      return "CertificateRequest";
    case Event::Certificate:
      return "Certificate";
    case Event::CompressedCertificate:
      return "CompressedCertificate";
    case Event::CertificateVerify:
      return "CertificateVerify";
    case Event::Finished:
      return "Finished";
    case Event::NewSessionTicket:
      return "NewSessionTicket";
    case Event::KeyUpdate:
      return "KeyUpdate";
    case Event::Alert:
      return "Alert";
    case Event::Accept:
      return "Accept";
    case Event::Connect:
      return "Connect";
    case Event::AppData:
      return "AppData";
    case Event::EarlyAppWrite:
      return "EarlyAppWrite";
    case Event::AppWrite:
      return "AppWrite";
    case Event::AppClose:
      return "AppClose";
    case Event::WriteNewSessionTicket:
      return "WriteNewSessionTicket";
    case Event::NUM_EVENTS:
      return "Invalid event NUM_EVENTS";
  }
  return "Unknown event";
}

folly::StringPiece fizz::toString

(

ReplayCacheResult

result

)

Definition at line 15 of file ReplayCache.cpp.

References fizz::server::DefinitelyReplay, fizz::server::MaybeReplay, fizz::server::NotChecked, and fizz::server::NotReplay.

                                                    {
  switch (result) {
    case ReplayCacheResult::NotChecked:
      return "NotChecked";
    case ReplayCacheResult::NotReplay:
      return "NotReplay";
    case ReplayCacheResult::MaybeReplay:
      return "MaybeReplay";
    case ReplayCacheResult::DefinitelyReplay:
      return "DefinitelyReplay";
  }
  return "Invalid ReplayCacheResult";
}

folly::StringPiece fizz::toString

(

StateEnum

state

)

Definition at line 16 of file State.cpp.

References Error.

Referenced by fizz::Protocol::checkAllowedExtensions(), fizz::ZlibCertificateDecompressor::decompress(), folly::CustomLogFormatter::formatMessage(), fizz::sm::generateTicket(), fizz::sm::getAndValidateVersionAndCipher(), fizz::sm::getCertificateRequest(), fizz::CertDecompressionManager::getDecompressor(), fizz::EncryptedReadRecordLayer::getDecryptedBuf(), getRealDraftVersion(), fizz::sm::handleCertMsg(), fizz::server::detail::handleInvalidEvent(), fizz::client::detail::handleInvalidEvent(), fizz::server::operator<<(), fizz::client::operator<<(), fizz::ReadRecordLayer::readEvent(), TEST(), fizz::sm::EventHandlerBase< SM, state, event >::Transition(), fizz::sm::validatePsk(), and fizz::extensions::Validator::validateTokenBinding().

                                           {
  switch (state) {
    case StateEnum::Uninitialized:
      return "Uninitialized";
    case StateEnum::ExpectingServerHello:
      return "ExpectingServerHello";
    case StateEnum::ExpectingEncryptedExtensions:
      return "ExpectingEncryptedExtensions";
    case StateEnum::ExpectingCertificate:
      return "ExpectingCertificate";
    case StateEnum::ExpectingCertificateVerify:
      return "ExpectingCertificateVerify";
    case StateEnum::ExpectingFinished:
      return "ExpectingFinished";
    case StateEnum::Established:
      return "Established";
    case StateEnum::Error:
      return "Error";
    case StateEnum::NUM_STATES:
      return "Invalid state NUM_STATES";
  }
  return "Invalid state";
}

folly::StringPiece fizz::toString

(

server::ReplayCacheResult

)

folly::StringPiece fizz::toString

(

HashFunction

hash

)

Definition at line 35 of file Types.cpp.

References Sha256, and Sha384.

                                             {
  switch (hash) {
    case HashFunction::Sha256:
      return "Sha256";
    case HashFunction::Sha384:
      return "Sha384";
  }
  return "Invalid HashFunction";
}

folly::StringPiece fizz::toString

(

ClientAuthType

auth

)

Definition at line 40 of file State.cpp.

                                               {
  switch (auth) {
    case ClientAuthType::NotRequested:
      return "NotRequested";
    case ClientAuthType::Sent:
      return "Sent";
    case ClientAuthType::RequestedNoMatch:
      return "RequestedNoMatch";
    case ClientAuthType::Stored:
      return "Stored";
  }
  return "Invalid client auth type";
}

std::string fizz::toString

(

ProtocolVersion

version

)

Definition at line 43 of file Types.cpp.

References enumToHex(), tls_1_0, tls_1_1, tls_1_2, tls_1_3, tls_1_3_20, tls_1_3_20_fb, tls_1_3_21, tls_1_3_21_fb, tls_1_3_22, tls_1_3_22_fb, tls_1_3_23, tls_1_3_23_fb, tls_1_3_26, tls_1_3_26_fb, and tls_1_3_28.

                                            {
  switch (version) {
    case ProtocolVersion::tls_1_0:
      return "TLSv1.0";
    case ProtocolVersion::tls_1_1:
      return "TLSv1.1";
    case ProtocolVersion::tls_1_2:
      return "TLSv1.2";
    case ProtocolVersion::tls_1_3:
      return "TLSv1.3";
    case ProtocolVersion::tls_1_3_20:
      return "TLSv1.3-draft-20";
    case ProtocolVersion::tls_1_3_20_fb:
      return "TLSv1.3-draft-20-fb";
    case ProtocolVersion::tls_1_3_21:
      return "TLSv1.3-draft-21";
    case ProtocolVersion::tls_1_3_21_fb:
      return "TLSv1.3-draft-21-fb";
    case ProtocolVersion::tls_1_3_22:
      return "TLSv1.3-draft-22";
    case ProtocolVersion::tls_1_3_22_fb:
      return "TLSv1.3-draft-22-fb";
    case ProtocolVersion::tls_1_3_23:
      return "TLSv1.3-draft-23";
    case ProtocolVersion::tls_1_3_23_fb:
      return "TLSv1.3-draft-23-fb";
    case ProtocolVersion::tls_1_3_26:
      return "TLSv1.3-draft-26";
    case ProtocolVersion::tls_1_3_26_fb:
      return "TLSv1.3-draft-26-fb";
    case ProtocolVersion::tls_1_3_28:
      return "TLSv1.3-draft-28";
  }
  return enumToHex(version);
}

folly::StringPiece fizz::toString

(

PskType

pskType

)

Definition at line 45 of file Types.cpp.

References External, NotAttempted, NotSupported, Rejected, and Resumption.

                                           {
  switch (pskType) {
    case PskType::NotSupported:
      return "NotSupported";
    case PskType::NotAttempted:
      return "NotAttempted";
    case PskType::Rejected:
      return "Rejected";
    case PskType::External:
      return "External";
    case PskType::Resumption:
      return "Resumption";
  }
  return "Invalid PskType";
}

folly::StringPiece fizz::toString

(

KeyExchangeType

kexType

)

Definition at line 61 of file Types.cpp.

References HelloRetryRequest, None, and OneRtt.

                                                   {
  switch (kexType) {
    case KeyExchangeType::None:
      return "None";
    case KeyExchangeType::OneRtt:
      return "OneRtt";
    case KeyExchangeType::HelloRetryRequest:
      return "HelloRetryRequest";
  }
  return "Invalid kex type";
}

folly::StringPiece fizz::toString

(

EarlyDataType

earlyDataType

)

Definition at line 73 of file Types.cpp.

References Accepted, Attempted, NotAttempted, and Rejected.

                                                       {
  switch (earlyDataType) {
    case EarlyDataType::NotAttempted:
      return "NotAttempted";
    case EarlyDataType::Attempted:
      return "Attempted";
    case EarlyDataType::Rejected:
      return "Rejected";
    case EarlyDataType::Accepted:
      return "Accepted";
  }
  return "Invalid EarlyDataType";
}

std::string fizz::toString

(

ExtensionType

extType

)

Definition at line 79 of file Types.cpp.

References application_layer_protocol_negotiation, certificate_authorities, compress_certificate, cookie, early_data, enumToHex(), key_share, key_share_old, post_handshake_auth, pre_shared_key, psk_key_exchange_modes, quic_transport_parameters, server_name, signature_algorithms, signature_algorithms_cert, supported_groups, supported_versions, and token_binding.

                                          {
  switch (extType) {
    case ExtensionType::server_name:
      return "server_name";
    case ExtensionType::supported_groups:
      return "supported_groups";
    case ExtensionType::signature_algorithms:
      return "signature_algorithms";
    case ExtensionType::application_layer_protocol_negotiation:
      return "application_layer_protocol_negotiation";
    case ExtensionType::token_binding:
      return "token_binding";
    case ExtensionType::quic_transport_parameters:
      return "quic_transport_parameters";
    case ExtensionType::key_share_old:
      return "key_share_old";
    case ExtensionType::pre_shared_key:
      return "pre_shared_key";
    case ExtensionType::early_data:
      return "early_data";
    case ExtensionType::supported_versions:
      return "supported_version";
    case ExtensionType::cookie:
      return "cookie";
    case ExtensionType::psk_key_exchange_modes:
      return "psk_key_exchange_modes";
    case ExtensionType::certificate_authorities:
      return "certificate_authorities";
    case ExtensionType::post_handshake_auth:
      return "post_handshake_auth";
    case ExtensionType::signature_algorithms_cert:
      return "signature_algorithms_cert";
    case ExtensionType::key_share:
      return "key_share";
    case ExtensionType::compress_certificate:
      return "compress_certificate";
  }
  return enumToHex(extType);
}

std::string fizz::toString

(

AlertDescription

alertDesc

)

Definition at line 119 of file Types.cpp.

References access_denied, bad_certificate, bad_certificate_hash_value, bad_certificate_status_response, bad_record_mac, certificate_expired, certificate_required, certificate_revoked, certificate_unknown, certificate_unobtainable, close_notify, decode_error, decrypt_error, end_of_early_data, enumToHex(), handshake_failure, illegal_parameter, inappropriate_fallback, insufficient_security, internal_error, missing_extension, protocol_version, record_overflow, unexpected_message, unknown_ca, unknown_psk_identity, unrecognized_name, unsupported_certificate, unsupported_extension, and user_canceled.

                                               {
  switch (alertDesc) {
    case AlertDescription::close_notify:
      return "close_notify";
    case AlertDescription::end_of_early_data:
      return "end_of_early_data";
    case AlertDescription::unexpected_message:
      return "unexpected_message";
    case AlertDescription::bad_record_mac:
      return "bad_record_mac";
    case AlertDescription::record_overflow:
      return "record_overflow";
    case AlertDescription::handshake_failure:
      return "handshake_failure";
    case AlertDescription::bad_certificate:
      return "bad_certificate";
    case AlertDescription::unsupported_certificate:
      return "unsupported_certificate";
    case AlertDescription::certificate_revoked:
      return "certificate_revoked";
    case AlertDescription::certificate_expired:
      return "certificate_expired";
    case AlertDescription::certificate_unknown:
      return "certificate_unknown";
    case AlertDescription::illegal_parameter:
      return "illegal_parameter";
    case AlertDescription::unknown_ca:
      return "unknown_ca";
    case AlertDescription::access_denied:
      return "access_denied";
    case AlertDescription::decode_error:
      return "decode_error";
    case AlertDescription::decrypt_error:
      return "decrypt_error";
    case AlertDescription::protocol_version:
      return "protocol_version";
    case AlertDescription::insufficient_security:
      return "insufficient_security";
    case AlertDescription::internal_error:
      return "internal_error";
    case AlertDescription::inappropriate_fallback:
      return "inappropriate_fallback";
    case AlertDescription::user_canceled:
      return "user_canceled";
    case AlertDescription::missing_extension:
      return "missing_extension";
    case AlertDescription::unsupported_extension:
      return "unsupported_extension";
    case AlertDescription::certificate_unobtainable:
      return "certificate_unobtainable";
    case AlertDescription::unrecognized_name:
      return "unrecognized_name";
    case AlertDescription::bad_certificate_status_response:
      return "bad_certificate_status_response";
    case AlertDescription::bad_certificate_hash_value:
      return "bad_certificate_hash_value";
    case AlertDescription::unknown_psk_identity:
      return "unknown_psk_identity";
    case AlertDescription::certificate_required:
      return "certificate_required";
  }
  return enumToHex(alertDesc);
}

std::string fizz::toString

(

CipherSuite

cipher

)

Definition at line 183 of file Types.cpp.

References enumToHex(), TLS_AES_128_GCM_SHA256, TLS_AES_128_OCB_SHA256_EXPERIMENTAL, TLS_AES_256_GCM_SHA384, and TLS_CHACHA20_POLY1305_SHA256.

                                       {
  switch (cipher) {
    case CipherSuite::TLS_AES_128_GCM_SHA256:
      return "TLS_AES_128_GCM_SHA256";
    case CipherSuite::TLS_AES_256_GCM_SHA384:
      return "TLS_AES_256_GCM_SHA384";
    case CipherSuite::TLS_CHACHA20_POLY1305_SHA256:
      return "TLS_CHACHA20_POLY1305_SHA256";
    case CipherSuite::TLS_AES_128_OCB_SHA256_EXPERIMENTAL:
      return "TLS_AES_128_OCB_SHA256_EXPERIMENTAL";
  }
  return enumToHex(cipher);
}

std::string fizz::toString

(

PskKeyExchangeMode

pskKeMode

)

Definition at line 197 of file Types.cpp.

References enumToHex(), psk_dhe_ke, and psk_ke.

                                                 {
  switch (pskKeMode) {
    case PskKeyExchangeMode::psk_ke:
      return "psk_ke";
    case PskKeyExchangeMode::psk_dhe_ke:
      return "psk_dhe_ke";
  }
  return enumToHex(pskKeMode);
}

std::string fizz::toString

(

SignatureScheme

sigScheme

)

Definition at line 207 of file Types.cpp.

References ecdsa_secp256r1_sha256, ecdsa_secp384r1_sha384, ecdsa_secp521r1_sha512, ed25519, ed448, enumToHex(), rsa_pss_sha256, rsa_pss_sha384, and rsa_pss_sha512.

                                              {
  switch (sigScheme) {
    case SignatureScheme::ecdsa_secp256r1_sha256:
      return "ecdsa_secp256r1_sha256";
    case SignatureScheme::ecdsa_secp384r1_sha384:
      return "ecdsa_secp384r1_sha384";
    case SignatureScheme::ecdsa_secp521r1_sha512:
      return "ecdsa_secp521r1_sha512";
    case SignatureScheme::rsa_pss_sha256:
      return "rsa_pss_sha256";
    case SignatureScheme::rsa_pss_sha384:
      return "rsa_pss_sha384";
    case SignatureScheme::rsa_pss_sha512:
      return "rsa_pss_sha512";
    case SignatureScheme::ed25519:
      return "ed25519";
    case SignatureScheme::ed448:
      return "ed448";
  }
  return enumToHex(sigScheme);
}

std::string fizz::toString

(

NamedGroup

group

)

Definition at line 229 of file Types.cpp.

References enumToHex(), secp256r1, secp384r1, secp521r1, and x25519.

                                     {
  switch (group) {
    case NamedGroup::secp256r1:
      return "secp256r1";
    case NamedGroup::secp384r1:
      return "secp384r1";
    case NamedGroup::secp521r1:
      return "secp521r1";
    case NamedGroup::x25519:
      return "x25519";
  }
  return enumToHex(group);
}

std::string fizz::toString

(

CertificateCompressionAlgorithm

algo

)

Definition at line 243 of file Types.cpp.

References enumToHex(), and zlib.

                                                         {
  switch (algo) {
    case CertificateCompressionAlgorithm::zlib:
      return "zlib";
  }
  return enumToHex(algo);
}

folly::StringPiece fizz::toString

(

server::StateEnum

state

)

folly::StringPiece fizz::toString

(

client::StateEnum

)

folly::StringPiece fizz::toString

(

client::ClientAuthType

)

template<typename Func >

void fizz::transformBuffer	(	const folly::IOBuf &	in,
		folly::IOBuf &	out,
		Func	func
	)

Useful when we need to run a function that performs some operation on an IOBuf and then stores the result in another IOBuf. We assume that the caller ensures that out size >= in size. Apart from that you can pass in chained buffers for output or input buffers or even the same buffer. In the case you pass the same buffer, the Func needs to make sure it can safely deal with this case.

Definition at line 38 of file IOBufUtil.h.

References current, folly::IOBuf::length(), min, folly::IOBuf::next(), and folly::IOBuf::writableData().

Referenced by fizz::test::chunkIOBuf(), fizz::detail::decFunc(), fizz::detail::encFunc(), and fizz::test::TEST().

                                                                       {
  folly::IOBuf* currentOut = &out;
  size_t offset = 0;

  for (auto current : in) {
    size_t currentLength = current.size();

    while (currentLength != 0) {
      size_t selected = std::min(
          static_cast<size_t>(currentOut->length() - offset), currentLength);
      func(
          currentOut->writableData() + offset,
          current.data() + (current.size() - currentLength),
          selected);
      currentLength -= selected;
      offset += selected;
      if (offset == currentOut->length()) {
        offset = 0;
        currentOut = currentOut->next();
      }
    }
  }
}

template<size_t BlockSize, typename Func >

folly::io::RWPrivateCursor fizz::transformBufferBlocks	(	const folly::IOBuf &	in,
		folly::IOBuf &	out,
		Func	func
	)

Useful when we need to run a function that performs operations in chunks and transforms data from in -> out, regardless of whether in or out is chained. We assume out size >= in size.

func is expected to take data from some input buffer, do some operation on it and then place the result of the operation into an output buffer. It only should write to output in blocks of size BlockSize. Data from the input buffer must be internally buffered by func if it can not write a full block to output.

Definition at line 75 of file IOBufUtil.h.

References folly::io::detail::CursorBase< Derived, BufType >::isAtEnd(), min, gmock_output_test::output, folly::io::detail::CursorBase< Derived, BufType >::peekBytes(), folly::io::detail::Writable< Derived >::push(), folly::Range< Iter >::size(), folly::io::detail::CursorBase< Derived, BufType >::skip(), and folly::io::RWCursor< access >::writableData().

                                                                        {
  size_t internallyBuffered = 0;
  folly::io::RWPrivateCursor output(&out);
  folly::io::Cursor input(&in);

  // block to handle writes along output buffer boundaries
  std::array<uint8_t, BlockSize> blockBuffer = {};

  // ensure buffers are fine
  while (!input.isAtEnd()) {
    auto inputRange = input.peekBytes();
    auto inputLen = inputRange.size();
    auto outputLen = output.peekBytes().size();
    if (inputLen + internallyBuffered < BlockSize) {
      // input doesn't have enough - we can call func and it should
      // internally buffer.
      // This should be safe to just internally buffer since we took into
      // account what was existing in the internal buffer already
      auto numWritten = func(blockBuffer.data(), inputRange.data(), inputLen);
      DCHECK_EQ(numWritten, 0) << "expected buffering. wrote " << numWritten;
      // only update input offsets
      internallyBuffered += inputLen;
      input.skip(inputLen);
    } else if (outputLen < BlockSize) {
      // we have at least a block to write from input + internal buffer, so
      // output didn't have enough room in this case
      // copy a block from input in temp and then push onto output
      auto numWritten = func(
          blockBuffer.data(),
          inputRange.data(),
          // only provide it the amount needed for one block
          BlockSize - internallyBuffered);
      DCHECK_EQ(numWritten, BlockSize)
          << "did not write full block bs=" << BlockSize
          << " wrote=" << numWritten;

      // push the block onto output
      output.push(blockBuffer.data(), BlockSize);

      // advance input
      input.skip(BlockSize - internallyBuffered);
      internallyBuffered = 0;
    } else {
      // we have at least one block that can be written from input to output
      // calculate shared bytes while taking into account internal buffer
      auto numSharedBytes = std::min(outputLen, inputLen + internallyBuffered);

      // this is the number we can safely (and expect) to write to output
      auto numBlockBytes = numSharedBytes - (numSharedBytes % BlockSize);

      // try to grab as much from input - we can grab up to BlockSize - 1 more
      auto maxToTake = (numBlockBytes - internallyBuffered) + (BlockSize - 1);
      auto numToTake = std::min(inputLen, maxToTake);
      auto numWritten =
          func(output.writableData(), inputRange.data(), numToTake);

      DCHECK_EQ(numWritten, numBlockBytes);

      // advance cursors
      input.skip(numToTake);
      output.skip(numWritten);
      // recalculate internal buffer state
      internallyBuffered = (internallyBuffered + numToTake) % BlockSize;
    }
  }
  return output;
}

void fizz::trimBytes	(	folly::IOBuf &	buf,
		folly::MutableByteRange	trimmed
	)

Trims trimmed.size() bytes at the end of a chained IOBuf and fills in trimmed.

Definition at line 15 of file IOBufUtil.cpp.

References folly::Range< Iter >::begin(), folly::IOBuf::countChainElements(), current, folly::IOBuf::data(), i, folly::IOBuf::length(), min, folly::IOBuf::prev(), folly::Range< Iter >::size(), and folly::IOBuf::trimEnd().

Referenced by fizz::detail::evpDecrypt(), and fizz::test::TEST().

                                                          {
  auto trim = trimmed.size();
  size_t currentTrim = trim;
  IOBuf* current = buf.prev();
  size_t chainElements = buf.countChainElements();
  for (size_t i = 0; i < chainElements && currentTrim != 0; ++i) {
    size_t toTrim =
        std::min(currentTrim, static_cast<size_t>(current->length()));
    memcpy(
        trimmed.begin() + (currentTrim - toTrim),
        current->data() + (current->length() - toTrim),
        toTrim);
    current->trimEnd(toTrim);
    currentTrim -= toTrim;
    current = current->prev();
  }
}

void fizz::XOR	(	folly::ByteRange	first,
		folly::MutableByteRange	second
	)

XOR first and second and store the result in second.

Definition at line 33 of file IOBufUtil.cpp.

References i, and folly::Range< Iter >::size().

Referenced by fizz::OpenSSLEVPCipher< EVPImpl >::createIV().

                                                   {
  CHECK_EQ(first.size(), second.size());
  for (size_t i = 0; i < first.size(); ++i) {
    second[i] ^= first[i];
  }
};

Variable Documentation

constexpr folly::StringPiece fizz::FakeChangeCipherSpec

Initial value:

{"\x14\x03\x03\x00\x01\x01",
                                                  6}

Definition at line 59 of file Types.h.

Referenced by fizz::sm::getCertificateRequest(), fizz::sm::getHrrKeyExchangers(), fizz::sm::handleCertMsg(), and fizz::sm::handleEarlyAppWrite().

constexpr size_t fizz::kEncryptedHeaderSize

static

Initial value:

=
    sizeof(ContentType) + sizeof(ProtocolVersion) + sizeof(uint16_t)

Definition at line 18 of file EncryptedRecordLayer.cpp.

Referenced by fizz::EncryptedWriteRecordLayer::write().

constexpr size_t fizz::kHandshakeHeaderSize

static

Initial value:

=
    sizeof(HandshakeType) + detail::bits24::size

Definition at line 15 of file RecordLayer.cpp.

constexpr folly::StringPiece fizz::kHkdfLabelPrefix = "tls13 "

Definition at line 20 of file Types.h.

Referenced by fizz::Factory::getHkdfPrefix(), fizz::testing::TEST(), fizz::test::TEST_F(), and fizz::testing::TEST_P().

const uint32_t fizz::kMaxBufSize = 64 * 1024

static

Buffer size above which we should unset our read callback to apply back pressure on the transport.

Definition at line 28 of file AsyncFizzBase.cpp.

Referenced by fizz::AsyncFizzBase::checkBufLen().

constexpr uint16_t fizz::kMaxEncryptedRecordSize = 0x4000 + 256

static

Definition at line 17 of file EncryptedRecordLayer.cpp.

constexpr size_t fizz::kMaxHandshakeSize = 0x20000

Definition at line 78 of file Types.h.

Referenced by fizz::ReadRecordLayer::decodeHandshakeMessage(), and fizz::ZlibCertificateDecompressor::decompress().

static constexpr uint16_t fizz::kMaxPlaintextRecordSize = 0x4000

Definition at line 17 of file EncryptedRecordLayer.h.

const uint32_t fizz::kMaxReadSize = 4000

static

Definition at line 22 of file AsyncFizzBase.cpp.

Referenced by ProxyService::ProxyHandler::getReadBuffer().

const uint32_t fizz::kMinReadSize = 1460

static

Min and max read buffer sizes when using non-mo

Definition at line 21 of file AsyncFizzBase.cpp.

Referenced by ProxyService::ProxyHandler::getReadBuffer(), and proxygen::HTTPSession::getReadBuffer().

constexpr uint16_t fizz::kMinSuggestedRecordSize = 1500

Definition at line 18 of file EncryptedRecordLayer.h.

constexpr size_t fizz::kPlaintextHeaderSize

static

Initial value:

=
    sizeof(ContentType) + sizeof(ProtocolVersion) + sizeof(uint16_t)

Definition at line 20 of file PlaintextRecordLayer.cpp.

Referenced by fizz::PlaintextWriteRecordLayer::write().