fizz::test Namespace Reference

Classes
struct	A1
struct	A2
class	ActionMoveVisitor
class	AsyncFizzBaseTest
class	AuthenticatorTest
struct	BlockWriter
struct	CertAndKey
class	CertDecompressionManagerTest
class	CertTestTyped
struct	CipherParams
class	ConcreteReadRecordLayer
class	ConcreteWriteRecordLayer
class	DefaultCertificateVerifierTest
class	ECDHTest
class	EncryptedRecordTest
struct	ExpectedParameters
class	ExtensionsTest
class	FizzBaseTest
class	HandshakeContextTest
class	HandshakeTest
class	HandshakeTypesTest
struct	HashParams
class	HkdfTest
class	Key
struct	KeyParams
class	KeySchedulerTest
class	LocalTransport
class	MockAead
class	MockAsyncFizzBase
class	MockCert
class	MockCertificateCompressor
class	MockCertificateDecompressor
class	MockCertificateVerifier
class	MockFactory
class	MockHandshakeContext
class	MockKeyScheduler
class	MockPeerCert
class	MockSelfCert
class	OpenSSLEVPCipherTest
struct	P256Test
struct	P384Test
struct	P521Test
struct	Params
class	PlaintextRecordTest
class	ProtocolTest
class	RecordTest
class	RSAPSSTest
struct	RSATest
class	SigSchemeTest
struct	State
class	TestFizzBase
struct	TestMessages
class	TestStateMachine
class	ValidateAuthenticatorTest
class	ZlibCertificateCompressorTest

Typedefs
using	BufCreator = std::function< std::unique_ptr< folly::IOBuf >(size_t len, size_t bufNum)>
using	KeyTypes = ::testing::Types< P256, P384, P521 >
using	Action = boost::variant< A1, A2 >
using	Actions = std::vector< Action >

Enumerations
enum	StateEnum { StateEnum::NotError, StateEnum::Error }

Functions
	TEST (IOBufUtilTest, TrimBytes)
	TEST (IOBufUtilTest, TransformBufferInplace)
std::unique_ptr< IOBuf >	createBuf (size_t len)
	TEST (IOBufUtilTest, TransformBufferWithFragmentedBuffer)
	TEST (IOBufUtilTest, TransformBufferBlocks)
	TEST (IOBufUtilTest, TransformBufferBlocksSplit)
	TEST (IOBufUtilTest, TransformBufferBlocksInputFragmented)
	TEST (IOBufUtilTest, TransformBufferBlocksOutputFragmented)
	TEST (IOBufUtilTest, TransformBufferBlocksInputFragmented2)
	TEST (IOBufUtilTest, TransformBufferBlocksFragmented)
std::unique_ptr< Aead >	getCipher (const CipherParams &params)
std::unique_ptr< IOBuf >	copyBuffer (const folly::IOBuf &buf)
std::unique_ptr< folly::IOBuf >	callEncrypt (std::unique_ptr< Aead > &cipher, const CipherParams &params, std::unique_ptr< IOBuf > plaintext=nullptr, std::unique_ptr< IOBuf > aad=nullptr)
void	callDecrypt (std::unique_ptr< Aead > &cipher, const CipherParams &params, std::unique_ptr< IOBuf > ciphertext=nullptr, std::unique_ptr< IOBuf > aad=nullptr)
	TEST_P (OpenSSLEVPCipherTest, TestEncrypt)
	TEST_P (OpenSSLEVPCipherTest, TestEncryptWithTagRoom)
	TEST_P (OpenSSLEVPCipherTest, TestEncryptReusedCipher)
	TEST_P (OpenSSLEVPCipherTest, TestEncryptChunkedInput)
	TEST_P (OpenSSLEVPCipherTest, TestEncryptChunkedInputWithTagRoomHead)
	TEST_P (OpenSSLEVPCipherTest, TestEncryptChunkedInputWithTagRoomLast)
	TEST_P (OpenSSLEVPCipherTest, TestEncryptChunkedSharedInput)
	TEST_P (OpenSSLEVPCipherTest, TestEncryptChunkedAad)
	TEST_P (OpenSSLEVPCipherTest, TestDecrypt)
	TEST_P (OpenSSLEVPCipherTest, TestDecryptReusedCipher)
	TEST_P (OpenSSLEVPCipherTest, TestDecryptInputTooSmall)
	TEST_P (OpenSSLEVPCipherTest, TestDecryptWithChunkedInput)
	TEST_P (OpenSSLEVPCipherTest, TestDecryptWithChunkedSharedInput)
	TEST_P (OpenSSLEVPCipherTest, TestDecryptWithVeryChunkedInput)
	TEST_P (OpenSSLEVPCipherTest, TestDecryptWithChunkedAad)
	TEST_P (OpenSSLEVPCipherTest, TestTryDecrypt)
	INSTANTIATE_TEST_CASE_P (AESGCM128TestVectors, OpenSSLEVPCipherTest,::testing::Values(CipherParams{"87f6c12b1ae8a9b7efafc65af0f5c994","479e25839c19e0476f95a6f5", 1,"","010015","9d4db5ecd768198892531eebac72cf1d477dd0", true, CipherSuite::TLS_AES_128_GCM_SHA256}, CipherParams{"911dc107aa6eccb6706bdcc37e76a07a","11c7fa13e9499ed042b09e57", 0,"","14000020de15cbc8c62d0e6fef73a6d4e70e5c372c2b94fe08ea40d11166a7e6c967ba9c16","56a21739148c898fe807026a179d59202647a3b1e01267a3883cf5f69fd233f63ff12c1c71b4c8f3d6086affb49621f96b842e1d35", true, CipherSuite::TLS_AES_128_GCM_SHA256}, CipherParams{"a0f49e7076cae6eb25ca23a2da0eaf12","3485d33f22128dff91e47062", 0,"","41424344454617","92fdec5c241e994fb7d889e1b61d1db2b9be6777f5a393", true, CipherSuite::TLS_AES_128_GCM_SHA256}, CipherParams{"fda2a4404670808f4937478b8b6e3fe1","b5f3a3fae1cb25c9dcd73993", 0,"","0800001e001c000a00140012001d00170018001901000101010201030104000000000b0001b9000001b50001b0308201ac30820115a003020102020102300d06092a864886f70d01010b0500300e310c300a06035504031303727361301e170d3136303733303031323335395a170d3236303733303031323335395a300e310c300a0603550403130372736130819f300d06092a864886f70d010101050003818d0030818902818100b4bb498f8279303d980836399b36c6988c0c68de55e1bdb826d3901a2461eafd2de49a91d015abbc9a95137ace6c1af19eaa6af98c7ced43120998e187a80ee0ccb0524b1b018c3e0b63264d449a6d38e22a5fda430846748030530ef0461c8ca9d9efbfae8ea6d1d03e2bd193eff0ab9a8002c47428a6d35a8d88d79f7f1e3f0203010001a31a301830090603551d1304023000300b0603551d0f0404030205a0300d06092a864886f70d01010b05000381810085aad2a0e5b9276b908c65f73a7267170618a54c5f8a7b337d2df7a594365417f2eae8f8a58c8f8172f9319cf36b7fd6c55b80f21a03015156726096fd335e5e67f2dbf102702e608ccae6bec1fc63a42a99be5c3eb7107c3c54e9b9eb2bd5203b1c3b84e0a8b2f759409ba3eac9d91d402dcc0cc8f8961229ac9187b42b4de100000f000084080400804547d6168f2510c550bd949cd2bc631ff134fa10a827ff69b166a6bd95e249ed0daf571592ebbe9ff13de6b03acc218146781f693b5a692b7319d74fd2e53b6a2df0f6785d624f024a44030ca00b869ae81a532b19e47e525ff4a62c51a5889eb565fee268590d8a3ca3c1bc3bd5404e39720ca2eaee308f4e0700761e986389140000209efee03ebffbc0dc23d26d958744c09e3000477eff7ae3148a50e5670013aaaa16","c1e631f81d2af221ebb6a957f58f3ee266272635e67f99a752f0df08adeb33bab8611e55f33d72cf84382461a8bfe0a659ba2dd1873f6fcc707a9841cefc1fb03526b9ca4fe343e5805e95a5c01e56570638a76a4bc8feb07be879f90568617d905fecd5b1619fb8ec4a6628d1bb2bb224c490ff97a6c0e9acd03604bc3a59d86bdab4e084c1c1450f9c9d2afeb172c07234d739868ebd62de2060a8de989414a82920dacd1cac0c6e72ecd7f4018574ceaca6d29f361bc37ee2888b8e302ca9561a9de9163edfa66badd4894884c7b359bcacae5908051b37952e10a45fe73fda126ebd67575f1bed8a992a89474d7dec1eed327824123a414adb66d5ef7d0836ff98c2cdd7fb0781e192bf0c7568bf7d890a51c332879b5037b212d622412ca48e8323817bd6d746eef683845cec4e3ef64b3a18fcce513ea951f3366693a7ff490d09d08ab1f63e13625a545961599c0d9c7a099d1163cad1b9bcf8e917d766b98853ef6877834f891df16be1fcc9c18ea1882ea3f1f4b64358e1b146cebfb3e02e153fdb73af2693f22c6f593fa475380ba6611740ad20e319a654ac5684775236162e8447ed808861bfbda6e18ec97ae090bf703475cfb90fe20a3c55bef6f5eba6e6a1da6a1996b8bde42180608ca2279def8e8153895cc850db6420561c04b5729cc6883436ea02ee07eb9baee2fb3a9e1bbda8730d6b220576e24df70af6928eb865fee8a1d1c0f1818aca68d5002ae4c65b2f49c9e6e21dcf76784adbd0e887a36832ef85beb10587f16c6ffe60d7451059ec7f1014c3efe19e56aedb5ad31a9f29dc4458cfbf0c7070c175dcad46e1675226b47c071aad3172ebd33e45d741cb91253a01a69ae3cc292bce9c03246ac951e45e97ebf04a9d51fab5cf06d9485cce746b1c077be69ad153f1656ef89fc7d1ed8c3e2da7a2", true, CipherSuite::TLS_AES_128_GCM_SHA256}, CipherParams{"a0f49e7076cbe6eb25ca23a2da0eaf12","3485d33f22128dff91e47062", 0,"","41424344454617","92fdec5c241e994fb7d889e1b61d1db2b9be6777f5a393", false, CipherSuite::TLS_AES_128_GCM_SHA256}, CipherParams{"a0f49e7076cae6eb25ca23a2da0eaf12","3485d33f22128dff91e47062", 0,"","41424344454617","92fdec", false, CipherSuite::TLS_AES_128_GCM_SHA256}, CipherParams{"AD7A2BD03EAC835A6F620FDCB506B345","12153524C0895E81B2C28465", 0,"D609B1F056637A0D46DF998D88E52E00B2C2846512153524C0895E81","08000F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F303132333435363738393A0002","701AFA1CC039C0D765128A665DAB69243899BF7318CCDC81C9931DA17FBE8EDD7D17CB8B4C26FC81E3284F2B7FBA713D4F8D55E7D3F06FD5A13C0C29B9D5B880", true, CipherSuite::TLS_AES_128_GCM_SHA256}, CipherParams{"AD7A2BD03EAC835A6F620FDCB506B345","12153524C0895E81B2C28465", 0,"D609B1F056637A1D46DF998D88E52E00B2C2846512153524C0895E81","08000F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F303132333435363738393A0002","701AFA1CC039C0D765128A665DAB69243899BF7318CCDC81C9931DA17FBE8EDD7D17CB8B4C26FC81E3284F2B7FBA713D4F8D55E7D3F06FD5A13C0C29B9D5B880", false, CipherSuite::TLS_AES_128_GCM_SHA256}))
	INSTANTIATE_TEST_CASE_P (AESGCM256TestVectors, OpenSSLEVPCipherTest,::testing::Values(CipherParams{"E3C08A8F06C6E3AD95A70557B23F75483CE33021A9C72B7025666204C69C0B72","12153524C0895E81B2C28465", 0,"D609B1F056637A0D46DF998D88E52E00B2C2846512153524C0895E81","08000F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F303132333435363738393A0002","E2006EB42F5277022D9B19925BC419D7A592666C925FE2EF718EB4E308EFEAA7C5273B394118860A5BE2A97F56AB78365CA597CDBB3EDB8D1A1151EA0AF7B436", true, CipherSuite::TLS_AES_256_GCM_SHA384}, CipherParams{"E3C08A8F06C6E3AD95A70557B23F75483CE33021A9C72B7025666204C69C0B72","12153524C0895E81B2C28465", 0,"D609B1F056637A0D46DF998D88E52E00B2C2846512153524C0895E81","08000F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F303132333435363738393A0002","E2006EB42F5277022D9B19925BC419D7A592666C925FE2EF718EB4E308EFEAA7C5273B394118860A5BE2A97F56AB78365CA597CDBB3EDB8D1A1151EA1AF7B436", false, CipherSuite::TLS_AES_256_GCM_SHA384}))
std::unique_ptr< folly::IOBuf >	defaultCreator (size_t len, size_t)
std::unique_ptr< folly::IOBuf >	toIOBuf (std::string hexData, size_t headroom, size_t tailroom)
std::unique_ptr< IOBuf >	chunkIOBuf (std::unique_ptr< IOBuf > input, size_t chunks, BufCreator creator)
	TYPED_TEST_CASE (Key, KeyTypes)
	TYPED_TEST (Key, GenerateKey)
	TYPED_TEST (Key, SharedSecret)
	TYPED_TEST (Key, ReadFromKey)
	TYPED_TEST (Key, ReadWrongGroup)
	TYPED_TEST (Key, Decode)
	TYPED_TEST (Key, Encode)
	TYPED_TEST (Key, DecodeInvalid)
	TYPED_TEST (Key, DecodeInvalidSmallLength)
int	getNid (const Params &param)
void	setPoint (EcKeyUniquePtr &key, std::string x, std::string y)
EvpPkeyUniquePtr	getKey (const Params &param)
	TEST_P (ECDHTest, TestKeyAgreement)
	INSTANTIATE_TEST_CASE_P (TestVectors, ECDHTest,::testing::Values(Params{"e19007eb245d6995ffa8b3ede1e59193aa6cfaaf4cc1e1d126948610c9b3f44c","758b2f0e79a3d0a94f521ae31dcff50fabd394bb4bbec8fa37d1566f463444e7","b981e686e53e9e9dc2e3f263e810c89b4c271e62392f59ed45ed30ac3a5bfd33","8171000763de347d0eb650dd6fddac2ad48ec122c162d66c3df257aea13192fb","c22ac2ee50e771a93b2b6a42c5e9b76b45a56e0d0011e34aa790283ede61f3d9","0ef754edae5e79c518f1056aa5179cbb6a3a4b7c9654b5048f4259bd2597e57d","5cbea453310285b22f128178bd09b906fde9e660b5a17a7cec809a5a9a1e9287", true, KeyType::P256}, Params{"0ced658b6113979f8d05fd7b305ce0b8d70f45034d021b052cbcb318e0cfd602","acbcb31f5f6798a00f28aa4a634873744768db612925336efca98122a76d1b5e","7dcefeb3ccb530029a8b62e5a7f00c42fc7ebeac8f469c289ea77b6186d661f0","64e23f7a2d279930f1de66b4bc147786b168d059f581268c24f6650362246e63","ba393b401354aa9552c4289b7a55288d97590429a4003913a243081bacf88acf","d089687aa5442684d71b805ea2b36f6c1c783833346dfdd8208768ed2a7e767d","f70e4fc9ba68aafe07be1767620e64dd5e5bb7ab279f0657465cddeb69e36fa9", true, KeyType::P256}, Params{"0ced658b6113979f8d05fd7b305ce0b8d70f45034d021b052cbcb318e0cfd602","758b2f0e79a3d0a94f521ae31dcff50fabd394bb4bbec8fa37d1566f463444e7","b981e686e53e9e9dc2e3f263e810c89b4c271e62392f59ed45ed30ac3a5bfd33","8171000763de347d0eb650dd6fddac2ad48ec122c162d66c3df257aea13192fb","c22ac2ee50e771a93b2b6a42c5e9b76b45a56e0d0011e34aa790283ede61f3d9","0ef754edae5e79c518f1056aa5179cbb6a3a4b7c9654b5048f4259bd2597e57d","5cbea453310285b22f128178bd09b906fde9e660b5a17a7cec809a5a9a1e9287", true, KeyType::P256}, Params{"639ef9ee75a3888617fdd7ed89d62f7398b0eb4f20ccbd35026e150fc937c927","1d2dda4a3735be1f3aedfa8a7bb1410c3867c5d67f55a3dd5376b137352f113d","eca92fb210b1813f51ea2483ff461eb24786afb41f1a00870cf65aab5bbd725e","e062138981049c3b4b964fa5a28569e0142c2c51d6ca0bebdb3270e2ab77fb30","9aa8dd75f7d929b1f5f123aa9f3265be34f771c20bb50deea684a139a10938f8","2b74f503fa7b08db1c76d97c2e571cb91f68a93413daf102c47fee1b8a264d93","9f5f64d76f9bb2f2af24debdd47323d5df9d2b84fc7c7aac1f6d41678adec7de", false, KeyType::P256}, Params{"305dfb4a8850cc59280891147baf457bfe5e2bae984571634a77dc8d3472fa9b","202cb5a224e6c2a84e624094486edf04116c8d68ec1f4a0e0ed9ee090e1a900b","cacf3a5789bb33954be600425d62d9eae5371f90f88167258814213e4a4f4b1a","72cc52808f294b64b6f7233c3d2f5d96cc1d29287320e39e1c151deef0bc14eb","49a768c9a4ca56e374f685dd76a461b1016c59dcded2c8d8cbd9f23ca453831f","b1e3bb9b5f12a3b5ae788535d4554bd8c46e0e6130075e4e437d3854cf8f1c34","c0147c3c2691b450b5edc08b51aea224d9f4359ff67aab6da3146f396dbceaea", false, KeyType::P256}, Params{"0e5c98ff2d2a3aab14ad0067b60dbe64e4f541ab5bed11c5a0c55ae1e60b51ff5faaf377837977d80cbfdc33c2ff542b","d1bf2ac21637d66d6398aac01dcd56ac6f065fb45d1f6f16747bab9e9b01b4630b59b20927aea147355bf41838acb482","4c9e23f1c5a41647d094086bf4ed31708651f21d996c47780688ac10f77deee2e43b5241b6caecd2fd5444bc50472e0e","f865418473e5bf7d2e1bbcd9bd5a9270c003a9dd35e778133ca59fcab4bb64fe24d6800e7047bdd033abc8bfa8db35b5","32b72ab9b558249dcbc6cbade234f58e4f7aa5d3f6420ea99a5f997e8c2a91fb7fd83779d0d2169428683771c745fd1a","c749e02a3719bb56bf1dfc4ba3820309c01ab6e84cb29db7cdd80f127233f5295687f8178f3a8704c1063b84c2ee472f","a781430e6078a179df3f9ee27cd8fdc6188f161b6c4ccc4053ef6c6ca6fc222946883a53c06db08f0a020023ced055aa", true, KeyType::P384}, Params{"925065e50f7eae1319865720ae483de4dba7449dc144c4b50b8e96c4f4fcd9f8b3fbf693262429c91c69d8dd8355fdd8","4c619593e459e4aca7c572834064134d93e8b1b676388b0ff67b893722cf7e8396cd953df38a42e4131dbad29518b2af","dbe261af918baade39070e88f62eabe4ee9d5f2563707271cc566dd7a2380aa4707d15d6eef142a52d75a67429afd0c6","c40c805488115e43279c99797bcbfff8d9922ea9aec471d9ba659590034c3fb739d23661c0aae6e7ada2a1de36eb63a1","a95b7ad4de234e9be8b260313ddb96a404b75b3a7e0f234981f3b189d86ac31bbe3937776c0608024871ef64815784b3","4890ee227219ca5ce34632cbca5732accc2d276fa1b1cc9d14f6b7e4b0f5e116a92cbef743de3e69537e250f27125e82","128934db846099c8d8caa788b0b84bb65bd57b20774ff7f8e7f29939297d72bbc232c5d2b2c8ef1d63e3d75d3908e778", true, KeyType::P384}, Params{"259c53eec19d01d19428f6cc5cd445ab685578c53325f6d2f157bd0328deca4ffb8c21dca891d59e34a807203f7e9a5d","d18832f4cf3013e514b4fb4c42bbeb15708e20ed91b982598deb2d67b37275587fcb35cf214039ec4fd1834d704c1faf","917c49465bef063949957256eddbece762090ef10f8c48566bd71dc0ad9eb3bc00f0b3f6a88d614210804dd633ca6e68","3120ee90dcce02bac90a66d30ad602e94edcce482dbc5245a136df1d0509b04f6ee305fedd290775c71f1631684f5c0a","7a3e0fd767acf409cebe6fe0222974438bccdefb13f0d668b8daad43a6fdbdf46845c45b9594ffd6742a615dd834f1a5","e3cc9f7153b6ffd3b285349996b952905466942d17f6a9685a11318b0c2c72904961d246cbe3ef98903dbbfb0fbe55b0","5c8d476518873208e1c97685c033a1ba6ec279b8674060cc1a99469908604353043bf488109150b9b2f9b3b1440a426c", true, KeyType::P384}, Params{"4e422a76b085ae939a8166afb98e344b9ac30bab610e90b3d7449de0a0de6b88fadb095e4818521bb1473540a7ec73ee","de464ed2129eef42ef23cb1bfad27382293edad91d867b1b8b82a19bd17516daf0a73548787a733d66ca4f4d40b52da1","f07bd6003229de37d6293513cbace59ebc24efb571c065df2bc1465c4570928fd612a59a46805b6adce7fb94e36ad043","f8f6697507aeec09fe024f974e00e67f12a14c130df875732b450b3ae8d2cbbb1fcf46bac9207e89a297352eeade7df5","c1db2e81eca0e5b02e8736ff351aa8e59bdadd1c9c7428faf93493c7b93153ec2c55964a157025ff6ddb4523d8e0a453","98daa370a6610ecf604e38e1e70b7f57657c49908eb15634a3a65a175ca7b8cfe1ad535037928ae95c80107a1e018b3c","d80415977c3ce1737fd574596e981c767ecaf5c70084fae6c2072f0ccecc8bdda54a0bf44357981303a2ecc78b26e97c", false, KeyType::P384}, Params{"4ee6a24b5dca82b215c92cb298d5ac24b77820c7b7e9c8fe4d05d7a297b8f6be40f8d8cf09a4bb238cfdbe05f851c493","1f9af3b14439d4c56b353b5892dd85b6a27053e1d23f5f05ff95ea3fa942eb463e1074b01828a79c865b16fde0fc0f24","01a81aaef502fe84508b054924d90078f68d8d4e9ae5299bd0ea60a97167c549011f4a024e964292d378e82b6874caad","3d715cd0d6490ba5607e7eae2c74361be65de413f10576c1d996658e20c78f8110c70104067922d48303f6ccb1b23f46","2fa7d2ea93945b41c929279a750ded758d9db93d120b5eeda3d9994e36e3381f653d19dcae0eccb1a12153ce4025a62e","04c6e45983485529e9dacba8d609cffaec849f7c5e5cf4a025ce2c0ff9ae6679b4564b9af58fab58c7f92837597b830b","5e77e466aeae9c10ff8d255e07cf0ad9eae50c8a6fd2c7cd889d73d968c423a15c0462b05bf985cbf679a629e380ce80", false, KeyType::P384}, Params{"0000002fef62381162942889a6094a6bb9ac1f4ddf66d9cda9f618232d31b90c50d7da78a47ed91d40cae946898571db972dc294b109815f38feee9eaac0d5f7c3250728","0000004b05ffa025113390797f2736174aa1c784f4dd34e764ee40d40e4d2442677ebea3498086c9473e5c92789cbdb02bb327bbd61d58690f6a83d9ca73bccbde37dec4","0000004da67cffc98070b82af61feba78787efefb13bd810d80ff92304788e49a4e5b634b3565474a8ecb1615d7b1b77a7a27875adb73a8a5d8f3f84e5e8b744cda250b0","00000311a5e520e238141527671a38cb6f776d96a9f82ef70dffa11dc0895f4060f1abbb9ad6fd259e4a7beaf5f7266ea1bb45bcbfebfda2705e5c551e710fb1d745f57e","0000010ba3778cb2cc965834c0a9593adc6a222692656d657fb0d15293edf0ab33762384a96a16fddea7540b7ccbcca46ec4ac9bcf95fdb5aa18e158aab4d91981bd733e","0000018522df93ddd636e5bc94daecdc600fa241686ec18634fd30b7cbdfdc9ffba1166ac08df34a31896f6fad191414929261ebd7187afb72919f8a0c926be37f99c1e5","01a5e4b31be4b1346e53906b6767b1fe94ec1a8a5abc28fb6f01518c056959af3bc9335dddab178b52318cc5512559931b8dc18de0ce810c2c7f15769d7ce70e719c", false, KeyType::P521}, Params{"0000013262b7f4f36de274b2c60e4a812866740e545186953f798ac07b5d74e4f0cc1123a9bfcbf77850e2d856246065c54a2437a2816a7d79d6180a9a6ba17f18df8b65","000001474af758238005238b2fa253c4f9c557de664d64c66d7d88f334555997591ccc242ff3c6d0e34d07fc835aaae024c2bd21f2ba5c0b0a8ac3fdd90e1c479cb8e538","000000a721b04654204ca19064b37a4abf4247413a6d29e9211a0df9d50975c7d8d4654dc04a478455ea24993f0fef5460f189c4729c15fba385fd85ef42ae7610e39450","000001a23de55fb7ad153e7e65d21ad10c77fdf2072b2a5aa116aaf1bc31a345420c1fe8eaccbbcdeb07b73ba2fa706c7498e3a4828f348b00af9df1551780e709a7754c","000000ed7bc3a95ef74dc3a9893a5ec7c9fab723c16dc21b30341c374c25e1334dada7f92d62967f3bca4da70b0a77fa0732dac05a3d19cb04e50b3cd1894549ac1d3c6e","000001c30d23ea4c140aabfba3753ce40c788010342c15c51d2dd6e9b079194e593ba965ea419ef37746f954027fa1b8159ccd3b54aece67451c7e892d6f6e1fb44c548c","01e8ff7a8c57b017f8b8266adab65fe2c417173566087e15c5fc972071cc560ac93908a806468bc44b8312a8a48464886ca0d767db938447387a348f3f56c6463796", true, KeyType::P521}, Params{"000000364b6cc953c841d2e1c8c292fadaa673ea073d150da4cec9c0c6544c92373c6a42a781283bedb080a4de720b99769869019a38023019b9d15c99b2a08a02104cc7","000001abbbcd3912723cbb3147145a12b8f2f40d1fe6484fa831250435ffb8eb751bccdf425e81d8e79518ec84c56bd28763c417f30a16c213abbfd8e5871d93dcb3f0d0","00000237c413a4527ca89dee7c8a5c45fc0207627e3db79353ee506857d68f746ea2c7b4d04ab1c10df56b1a706012f616ec9a5510467c49a56941841a1636f620dc3ac4","000000e04b0e32496f1d43ff48d759dc57d586c6c55efb6460fc1148021afa1943180aea2a1be7721a69ebf9d55585a4d4bdb6ff3e177448568c0b45542eddb936fbd870","00000195a305d23a94794e680b211b8ec4a5c2150a2002afdc4ff5da254c438b5686b12dda72bd8dbb009d07d469c3d664e67da274de7f2e2dc84661d2a054638cf6fc98","000000e56b77c46a997c06da59033e1c57939f6f8513329ebe93dcb00857a8ff850428473d937528e85c15a5fe46df1ffb7aeed4b17f7fc9ad08fb121045e2eea5a316b2","013eeaad91133eb338a4c1f27af66aa7f7614619b6c21c20f0e2d68fca2e9cbaa224104a45aa4dbefcb1e49b7f1a36171a35102d2b7d2ffbade07e600b4a7e28c05c", false, KeyType::P521}, Params{"000001ef093db892daaa05d43e70654bd702d7e177465b00a5ff70a9a072774d7cda3893c181ad1dbb23f8352d3098025406a442c60afaf949dd37ee9c36ee2f785dc693","0000017e817b93e7e3eb95291545afffa2dcd1ff90b97c2b7d9cc7a46511cbdf7a7afe7a2ce126822d08bc71519542743dfece750e18f1e01bb5201e622e2697e5b1faa6","00000025e5e302514ccb15ed84291ba30746b1176f2b080bfa78ef7ce5721fd00d3d717421932d61ad74068c36885a9a0e6537183209a79054fcb8df43b83066f60c47d5","0000004e9f4ebd9f4772df7c003828210d087aa41c0154394428f5f8624536a15c157634c5200de037e46698d4f8484feb164374899b2d9d5e258080dae6b3429c965154","0000021fb91b2abbdd7dee5e2750a1fce602e235a6512b429ab0a3845bd8c8a630d9d35850e0ba78f01c01ffae6ca1a88c93c153a6fdc09f76fae768bdd449e7f6730b68","0000005cb38e5272648f2adcb5ec7a37f3b2135c93a0202f2c822383eae29468392f4baeddabf0acd3bee0cbc1dd540b435d34ecb008408ac093978976741d1afa374c72","01bca2f6325ccf7a6a213b2678ded8ce3e687497c7f7f46a4a06bf3e69dabb745a883d130936c786debf2fe5ef8880f1bb976a79e33b68d30d7356b5a4672e65fcea", false, KeyType::P521}, Params{"0000014199e2e81aa1f98bf0f39d069e720820d0433222f5b8ca26606fe7c4d0cd619b415d2a629674479a6ec6171f05f657a168aad9342e8489a39cf485a396a8400c59","00000070ce983ca6d0a7aa7849bef13e11e3dc1d62e1ddb85b54d4a3c9de5b47a078846f92105304efe4a4e71d7ff91c19a7b4e03fd87c2d8fb70732e274b114a0bf3bd2","0000009f564f73a5c7282556437dc4c2fbdf87d5fcfbaab0feecf1f7a88104f15a7314b083f711bd7b3a2c74b1096fdccdac01e0a35b8fd86d99ba9d64d10e190033c3df","000000c0b19361224245482bbe42110f9aa44f2818b5146710c24b4825a9a3e0a4743fc7983df560bd85d30639bbdb4d7fc0c56a862e0ef349801bef06ed0a9774463e9f","000000231f2c5c2ad3894b81ad2c8942221d06041f37b8d520e926701b9fb38e32833f9b2b99142d0e54baef33c17b2bd0f23ec3e1b08b9a87f65942384e5863607ba65c","0000005e3b734d4207b51259a1fca526161250176eab1364930d7d06259f43e68202962d9bb818a44bf3bf4a385e634a8d52489c58e2c9234670ae9f30668a2f5553c261","01186d749c6b2a215c59df35ef6f2f6ed1745a9b2e15fca225e79faa7c5b9af44821d50765b45c3c66e210ec78d4bccb7f8c44c19cf80f5357938df48e320fa1ed88", true, KeyType::P521}))
	TEST (X25519KeyExchange, KeyExchange)
	TEST (X25519KeyExchange, SmallKeyExchange)
	TEST (ValidateECKey, GoodPrivateKey)
	TEST (ValidateECKey, GoodPubicKey)
	TEST (ValidateECKey, WrongKeyType)
	TEST (ValidateECKey, WrongCurve)
static EvpPkeyUniquePtr	generateKey ()
	TEST_F (RSAPSSTest, TestSignVerify)
	TEST_F (RSAPSSTest, TestVerifyDifferent)
	TEST_F (RSAPSSTest, TestVerifyFailure)
	TEST_P (HkdfTest, TestHkdfSha256Expand)
	INSTANTIATE_TEST_CASE_P (TestVectors, HkdfTest,::testing::Values(HashParams{"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","000102030405060708090a0b0c","f0f1f2f3f4f5f6f7f8f9", 42,"3cb25f25faacd57a90434f64d0362f2a""2d2d0a90cf1a5a4c5db02d56ecc4c5bf""34007208d5b887185865"}, HashParams{"000102030405060708090a0b0c0d0e0f""101112131415161718191a1b1c1d1e1f""202122232425262728292a2b2c2d2e2f""303132333435363738393a3b3c3d3e3f""404142434445464748494a4b4c4d4e4f","606162636465666768696a6b6c6d6e6f""707172737475767778797a7b7c7d7e7f""808182838485868788898a8b8c8d8e8f""909192939495969798999a9b9c9d9e9f""a0a1a2a3a4a5a6a7a8a9aaabacadaeaf","b0b1b2b3b4b5b6b7b8b9babbbcbdbebf""c0c1c2c3c4c5c6c7c8c9cacbcccdcecf""d0d1d2d3d4d5d6d7d8d9dadbdcdddedf""e0e1e2e3e4e5e6e7e8e9eaebecedeeef""f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", 82,"b11e398dc80327a1c8e7f78c596a4934""4f012eda2d4efad8a050cc4c19afa97c""59045a99cac7827271cb41c65e590e09""da3275600c2f09b8367793a9aca3db71""cc30c58179ec3e87c14c01d5c1f3434f""1d87"}, HashParams{"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","","", 42,"8da4e775a563c18f715f802a063c5a31""b8a11f5c5ee1879ec3454e5f3c738d2d""9d201395faa4b61a96c8"}))
	TEST (RandomGeneratorTest, TestRandom)
	TEST (RandomGeneratorTest, TestRandomUInt32)
EvpPkeyUniquePtr	getPrivateKey (StringPiece key)
EvpPkeyUniquePtr	getPublicKey (StringPiece key)
std::unique_ptr< folly::IOBuf >	toIOBuf (folly::StringPiece hexData)
folly::ssl::X509UniquePtr	getCert (folly::StringPiece cert)
std::unique_ptr< folly::IOBuf >	getCertData (folly::StringPiece cert)
void	useMockRandom ()
	TEST (UtilsTest, TestEqualWrongSize)
	TEST (UtilsTest, TestEqual)
	TEST (UtilsTest, TestClean)
	TEST (ExportedAuthenticatorTest, TestAuthenticatorRequest)
	TEST (ExportedAuthenticatorTest, TestEmptyAuthenticatorRequest)
	TEST_F (AuthenticatorTest, TestValidAuthenticator)
	TEST_F (AuthenticatorTest, TestEmptyAuthenticator)
	TEST (ExportedAuthenticatorTest, TestGetContext)
	TEST_F (ValidateAuthenticatorTest, TestValidateValidAuthenticator)
	TEST_F (ValidateAuthenticatorTest, TestValidateEmptyAuthenticator)
	TEST_F (ExtensionsTest, TokenBindingParameters)
	TEST_F (ExtensionsTest, TokenBindingMessageFromChrome)
	TEST_F (ExtensionsTest, TokenBindingMessageSelfCreated)
	TEST (ContextTest, TestAscendingVersionsNotSet)
	TEST (ContextTest, TestShuffledNotSet)
	TEST (ContextTest, TestDoubleNotSet)
	TEST (ContextTest, TestEmptySet)
	TEST (ContextTest, TestSingleSet)
	TEST (ContextTest, TestDescendingVersionsSet)
	TEST (ContextTest, TestDoubleSet)
	TEST (ContextTest, TestDescendingDuplicatesNotSet)
	TEST_F (CertDecompressionManagerTest, TestBasic)
	TEST_F (CertDecompressionManagerTest, TestSameOverwrites)
template<typename T >
static ssl::X509UniquePtr	getCert ()
template<>
ssl::X509UniquePtr	getCert< P256Test > ()
template<>
ssl::X509UniquePtr	getCert< P384Test > ()
template<>
ssl::X509UniquePtr	getCert< P521Test > ()
template<>
ssl::X509UniquePtr	getCert< RSATest > ()
template<typename T >
static ssl::EvpPkeyUniquePtr	getKey ()
template<>
ssl::EvpPkeyUniquePtr	getKey< P256Test > ()
template<>
ssl::EvpPkeyUniquePtr	getKey< P384Test > ()
template<>
ssl::EvpPkeyUniquePtr	getKey< P521Test > ()
template<>
ssl::EvpPkeyUniquePtr	getKey< RSATest > ()
	TYPED_TEST_CASE (CertTestTyped, KeyTypes)
	TEST (CertTest, GetIdentity)
	TEST (CertTest, GetAltIdentity)
	TEST (CertTest, GetCertMessage)
	TEST (CertTest, PrepareSignData)
	TEST (CertTest, MakePeerCertEmpty)
	TEST (CertTest, MakePeerCertJunk)
	TEST (CertTest, PeerCertGetX509)
	TYPED_TEST (CertTestTyped, MatchingCert)
	TYPED_TEST (CertTestTyped, MismatchedCert)
	TYPED_TEST (CertTestTyped, SigSchemes)
	TYPED_TEST (CertTestTyped, TestSignVerify)
	TYPED_TEST (CertTestTyped, TestSignVerifyBitFlip)
	TYPED_TEST (CertTestTyped, TestSignVerifyWrongSize)
	TYPED_TEST (CertTestTyped, TestVerifyWrongScheme)
	TYPED_TEST (CertTestTyped, TestVerifyDecodedCert)
	TEST_F (DefaultCertificateVerifierTest, TestVerifySuccess)
	TEST_F (DefaultCertificateVerifierTest, TestVerifyWithIntermediates)
	TEST_F (DefaultCertificateVerifierTest, TestVerifySelfSignedCert)
	TEST_F (DefaultCertificateVerifierTest, TestVerifySelfSignedCertWithOverride)
	TEST_F (DefaultCertificateVerifierTest, TestVerifyWithIntermediateMissing)
	TEST_F (DefaultCertificateVerifierTest, TestVerifyWithIntermediateMissingWithOverride)
	TEST_F (DefaultCertificateVerifierTest, TestVerifyWithBadIntermediate)
	TEST_F (DefaultCertificateVerifierTest, TestVerifyWithBadRoot)
	TEST (ExporterTest, TestExporterBasic)
static WriteNewSessionTicket	writeNewSessionTicket (const std::string &str)
static AppWrite	appWrite (const std::string &str)
	MATCHER_P (WriteNewSessionTicketMatches, expected,"")
	MATCHER_P (WriteMatches, expected,"")
	TEST_F (FizzBaseTest, TestReadSingle)
	TEST_F (FizzBaseTest, TestReadMulti)
	TEST_F (FizzBaseTest, TestReadNoActions)
	TEST_F (FizzBaseTest, TestWriteNewSessionTicket)
	TEST_F (FizzBaseTest, TestWrite)
	TEST_F (FizzBaseTest, TestEarlyWrite)
	TEST_F (FizzBaseTest, TestWriteMulti)
	TEST_F (FizzBaseTest, TestAppClose)
	TEST_F (FizzBaseTest, TestWriteNewSessionTicketInCallback)
	TEST_F (FizzBaseTest, TestWriteInCallback)
	TEST_F (FizzBaseTest, TestAppCloseInCallback)
	TEST_F (FizzBaseTest, TestWriteThenCloseInCallback)
	TEST_F (FizzBaseTest, TestDeleteInCallback)
	TEST_F (FizzBaseTest, TestStopOnError)
	TEST_F (FizzBaseTest, TestAsyncAction)
	TEST_F (FizzBaseTest, TestAsyncActionDelete)
	TEST_F (FizzBaseTest, TestActionProcessing)
	TEST_F (FizzBaseTest, TestActionProcessingAsync)
	TEST_F (FizzBaseTest, TestErrorPendingEvents)
	TEST_F (FizzBaseTest, EventAfterErrorState)
	TEST_F (FizzBaseTest, TestManyActions)
	TEST_F (HandshakeContextTest, TestHandshakeContextSingle)
	TEST_F (HandshakeContextTest, TestHandshakeContextMultiple)
	TEST_F (HandshakeContextTest, TestFinished)
	TEST_F (HandshakeContextTest, TestEmpty)
	TEST_F (KeySchedulerTest, TestEarly)
	TEST_F (KeySchedulerTest, TestEarlyEcdhe)
	TEST_F (KeySchedulerTest, TestNoEarly)
	TEST_F (KeySchedulerTest, TestKeyUpdate)
	TEST_F (KeySchedulerTest, TestTrafficKey)
	MATCHER_P (BufMatches, expected,"")
	MATCHER_P (RangeMatches, expected,"")
template<typename A , typename B >
void	throwIfNeq (const A &a, const B &b, const std::string &msg)
template<typename A >
void	throwIfNull (const A &a, const std::string &msg)
CertAndKey	createCert (std::string cn, bool ca, CertAndKey *issuer)
std::shared_ptr< PeerCert >	getPeerCert (const CertAndKey &cert)
	TEST_F (ZlibCertificateCompressorTest, TestCompressDecompress)
	TEST_F (ZlibCertificateCompressorTest, TestHugeCompressedCert)
	TEST_F (ZlibCertificateCompressorTest, TestBadMessages)
	TEST_F (EncryptedRecordTest, TestReadEmpty)
	TEST_F (EncryptedRecordTest, TestReadHandshake)
	TEST_F (EncryptedRecordTest, TestReadAlert)
	TEST_F (EncryptedRecordTest, TestReadAppData)
	TEST_F (EncryptedRecordTest, TestReadUnknown)
	TEST_F (EncryptedRecordTest, TestWaitForData)
	TEST_F (EncryptedRecordTest, TestWaitForHeader)
	TEST_F (EncryptedRecordTest, TestMaxSize)
	TEST_F (EncryptedRecordTest, TestOverSize)
	TEST_F (EncryptedRecordTest, TestDataRemaining)
	TEST_F (EncryptedRecordTest, TestPadding)
	TEST_F (EncryptedRecordTest, TestAllPaddingAppData)
	TEST_F (EncryptedRecordTest, TestAllPaddingHandshake)
	TEST_F (EncryptedRecordTest, TestNoContentType)
	TEST_F (EncryptedRecordTest, TestReadSeqNum)
	TEST_F (EncryptedRecordTest, TestSkipAndWait)
	TEST_F (EncryptedRecordTest, TestSkipAndRead)
	TEST_F (EncryptedRecordTest, TestWriteHandshake)
	TEST_F (EncryptedRecordTest, TestWriteAppData)
	TEST_F (EncryptedRecordTest, TestWriteAppDataInPlace)
	TEST_F (EncryptedRecordTest, TestFragmentedWrite)
	TEST_F (EncryptedRecordTest, TestWriteSplittingWholeBuf)
	TEST_F (EncryptedRecordTest, TestWriteSplittingCombineSmall)
	TEST_F (EncryptedRecordTest, TestWriteSeqNum)
	TEST_F (EncryptedRecordTest, TestWriteEmpty)
	TEST_F (EncryptedRecordTest, TestWriteMaxSize)
	TEST_F (EncryptedRecordTest, TestWriteMinSize)
	TEST_F (ExtensionsTest, TestProtocolNameList)
	TEST_F (ExtensionsTest, TestServerNameList)
	TEST_F (ExtensionsTest, TestHelloRetryRequestKeyShare)
	TEST_F (ExtensionsTest, TestClientEarlyData)
	TEST_F (ExtensionsTest, TestServerEarlyData)
	TEST_F (ExtensionsTest, TestTicketEarlyData)
	TEST_F (ExtensionsTest, TestCookie)
	TEST_F (ExtensionsTest, TestCertificateAuthorities)
	TEST_F (ExtensionsTest, TestCertificateCompressionAlgorithms)
	TEST_F (ExtensionsTest, TestBadlyFormedExtension)
	TEST_F (HandshakeTypesTest, ChloEncodeDecode)
	TEST_F (HandshakeTypesTest, SSL3ChloDecode)
	TEST_F (HandshakeTypesTest, ChloDecidePsk)
	TEST_F (HandshakeTypesTest, ChloEncodeCopy)
	TEST_F (HandshakeTypesTest, NstEncodeDecode)
bool	extensionsMatch (const Extension &expected, const Extension &actual)
	TEST_F (HandshakeTypesTest, EncodeAndDecodeSigAlgs)
	TEST_F (HandshakeTypesTest, EncodeAndDecodeClientKeyShare)
	TEST_F (HandshakeTypesTest, EncodeAndDecodeServerHello)
	TEST_F (HandshakeTypesTest, EncodeAndDecodeEndOfEarlyData)
	TEST_F (HandshakeTypesTest, EncodeAndDecodeEncryptedExtensions)
	TEST_F (HandshakeTypesTest, EncodeAndDecodedCertificate)
	TEST_F (HandshakeTypesTest, EncodedAndDecodeCertificateVerify)
	TEST_F (HandshakeTypesTest, EncodedAndDecodeKeyUpdated)
	TEST_F (HandshakeTypesTest, EncodedAndDecodeCertificateRequest)
	TEST_F (HandshakeTypesTest, EncodeAndDecodeCompressedCertificate)
	TEST_F (PlaintextRecordTest, TestReadEmpty)
	TEST_F (PlaintextRecordTest, TestReadHandshake)
	TEST_F (PlaintextRecordTest, TestReadAlert)
	TEST_F (PlaintextRecordTest, TestReadAppData)
	TEST_F (PlaintextRecordTest, TestWaitForData)
	TEST_F (PlaintextRecordTest, TestWaitForHeader)
	TEST_F (PlaintextRecordTest, TestMaxSize)
	TEST_F (PlaintextRecordTest, TestOverSize)
	TEST_F (PlaintextRecordTest, TestEmpty)
	TEST_F (PlaintextRecordTest, TestDataRemaining)
	TEST_F (PlaintextRecordTest, TestSkipAndWait)
	TEST_F (PlaintextRecordTest, TestWaitBeforeSkip)
	TEST_F (PlaintextRecordTest, TestSkipAndRead)
	TEST_F (PlaintextRecordTest, TestWriteHandshake)
	TEST_F (PlaintextRecordTest, TestWriteClientHello)
	TEST_F (PlaintextRecordTest, TestWriteAppData)
	TEST_F (PlaintextRecordTest, TestFragmentedWrite)
	TEST_F (RecordTest, TestNoData)
	TEST_F (RecordTest, TestReadAppData)
	TEST_F (RecordTest, TestAlert)
	TEST_F (RecordTest, TestHandshake)
	TEST_F (RecordTest, TestHandshakeTooLong)
	TEST_F (RecordTest, TestHandshakeFragmentedImmediate)
	TEST_F (RecordTest, TestHandshakeFragmentedDelayed)
	TEST_F (RecordTest, TestHandshakeCoalesced)
	TEST_F (RecordTest, TestHandshakeSpliced)
	TEST_F (RecordTest, TestWriteAppData)
	TEST_F (RecordTest, TestWriteAlert)
	TEST_F (RecordTest, TestWriteHandshake)
	TEST (TestTypes, WriteAndRead24BitsNormal)
	TEST (TestTypes, Write24BitsOverflow)
	TEST (TestTypes, Write24BitsBuffer)
	TEST (TestTypes, Write24BitsBufferOverflow)
	TEST (TestTypes, WriteBuf)
	TEST_F (AsyncFizzBaseTest, TestIsFizz)
	TEST_F (AsyncFizzBaseTest, TestAppBytesWritten)
	TEST_F (AsyncFizzBaseTest, TestAppBytesReceived)
	TEST_F (AsyncFizzBaseTest, TestWrite)
	TEST_F (AsyncFizzBaseTest, TestReadErr)
	TEST_F (AsyncFizzBaseTest, TestReadErrNoCallback)
	TEST_F (AsyncFizzBaseTest, TestReadErrAsync)
	TEST_F (AsyncFizzBaseTest, TestReadEOF)
	TEST_F (AsyncFizzBaseTest, TestReadEOFNoCallback)
	TEST_F (AsyncFizzBaseTest, TestMovableBuffer)
	TEST_F (AsyncFizzBaseTest, TestMovableBufferAsyncCallback)
	TEST_F (AsyncFizzBaseTest, TestReadBufferLarger)
	TEST_F (AsyncFizzBaseTest, TestReadBufferExact)
	TEST_F (AsyncFizzBaseTest, TestReadBufferSmaller)
	TEST_F (AsyncFizzBaseTest, TestReadBufferAsync)
	TEST_F (AsyncFizzBaseTest, TestReadBufferZero)
	TEST_F (AsyncFizzBaseTest, TestReadBufferPause)
	TEST_F (AsyncFizzBaseTest, TestTransportReadBufMovable)
	TEST_F (AsyncFizzBaseTest, TestTransportReadBufMove)
	TEST_F (AsyncFizzBaseTest, TestTransportReadBufAvail)
	TEST_F (AsyncFizzBaseTest, TestTransportReadError)
	TEST_F (AsyncFizzBaseTest, TestTransportReadEOF)
	TEST_F (AsyncFizzBaseTest, TestTransportReadBufPause)
	TEST_F (AsyncFizzBaseTest, TestAppReadBufPause)
	TEST_F (AsyncFizzBaseTest, TestWriteSuccess)
	TEST_F (AsyncFizzBaseTest, TestWriteError)
	TEST_F (AsyncFizzBaseTest, TestHandshakeTimeout)
	TEST_F (AsyncFizzBaseTest, TestAttachEventBase)
	TEST_F (AsyncFizzBaseTest, TestAttachEventBaseWithReadCb)
	TEST_F (HandshakeTest, BasicHandshake)
	TEST_F (HandshakeTest, BasicHandshakeTrickle)
	TEST_F (HandshakeTest, P256)
	TEST_F (HandshakeTest, P384)
	TEST_F (HandshakeTest, P521)
	TEST_F (HandshakeTest, GroupServerPref)
	TEST_F (HandshakeTest, GroupMismatch)
	TEST_F (HandshakeTest, SchemeServerPref)
	TEST_F (HandshakeTest, SchemeMismatch)
	TEST_F (HandshakeTest, HRR)
	TEST_F (HandshakeTest, PskDheKe)
	TEST_F (HandshakeTest, HrrPskDheKe)
	TEST_F (HandshakeTest, HrrPskDheKeWithCache)
	TEST_F (HandshakeTest, HrrIncompatiblePsk)
	TEST_F (HandshakeTest, PskKe)
	TEST_F (HandshakeTest, TestEkmSame)
	TEST_F (HandshakeTest, TestEarlyEkmSame)
	TEST_F (HandshakeTest, TestExtensions)
	TEST_F (HandshakeTest, BasicCertRequest)
	TEST_P (SigSchemeTest, Schemes)
	TEST_F (HandshakeTest, CertRequestPskPreservesIdentity)
	TEST_F (HandshakeTest, CertRequestNoCert)
	TEST_F (HandshakeTest, CertRequestPermitNoCert)
	TEST_F (HandshakeTest, CertRequestBadCert)
	TEST_F (HandshakeTest, BasicCertCompression)
	TEST_F (HandshakeTest, EarlyDataAccepted)
	TEST_F (HandshakeTest, EarlyDataRejected)
	TEST_F (HandshakeTest, EarlyDataRejectedHrr)
	TEST_F (HandshakeTest, EarlyDataRejectedResend)
	TEST_F (HandshakeTest, EarlyDataRejectedDontResend)
	TEST_F (HandshakeTest, EarlyDataTrickleSendAccepted)
	TEST_F (HandshakeTest, EarlyDataTrickleSendRejected)
	TEST_F (HandshakeTest, Compat)
	TEST_F (HandshakeTest, TestCompatHRR)
	TEST_F (HandshakeTest, TestCompatEarly)
	TEST_F (HandshakeTest, TestCompatEarlyRejected)
	TEST_F (HandshakeTest, TestCompatEarlyRejectedHRR)
	TEST_F (HandshakeTest, TestCookie)
	TEST_F (HandshakeTest, TestCookieGroupNegotiate)
	TEST_F (HandshakeTest, TestCookieResume)
	TEST_F (HandshakeTest, TestCookieIncompatiblePsk)
	TEST_F (HandshakeTest, TestCookiePskKe)
	TEST_F (HandshakeTest, TestBadCookie)
	INSTANTIATE_TEST_CASE_P (SignatureSchemes, SigSchemeTest,::testing::Values(SignatureScheme::rsa_pss_sha256, SignatureScheme::ecdsa_secp256r1_sha256, SignatureScheme::ecdsa_secp384r1_sha384, SignatureScheme::ecdsa_secp521r1_sha512))
	TEST (UtilTest, GetAlpnFromNpn)
	TEST (UtilTest, CreateTickerCipher)
	TEST (UtilTest, ReadPKey)
	TEST (UtilTest, ReadChainFile)

Variables
constexpr size_t	kHeadroom = 10
static struct randombytes_implementation	mockRandom
constexpr folly::StringPiece	kP256Key
constexpr folly::StringPiece	kP256PublicKey
constexpr folly::StringPiece	kP256K1Key
constexpr folly::StringPiece	kP256Certificate
constexpr folly::StringPiece	kP384Key
constexpr folly::StringPiece	kP384PublicKey
constexpr folly::StringPiece	kP384Certificate
constexpr folly::StringPiece	kP521Key
constexpr folly::StringPiece	kP521PublicKey
constexpr folly::StringPiece	kP521Certificate
constexpr folly::StringPiece	kRSAKey
constexpr folly::StringPiece	kRSACertificate
constexpr folly::StringPiece	kClientAuthCACert
constexpr folly::StringPiece	kClientAuthClientCert
constexpr folly::StringPiece	kClientAuthClientKey
StringPiece	expected_auth_request
StringPiece	expected_authenticator
StringPiece	expected_cr_context = {"303132333435363738396162636465666768696a"}
StringPiece	expected_cert
StringPiece	expected_empty_authenticator
StringPiece	exporter_master = {"12345678901234567890123456789012"}
StringPiece	label = {"EXPORTER-Token-Binding"}
StringPiece	basic_expected_ekm
constexpr ProtocolVersion	TestProtocolVersion = ProtocolVersion::tls_1_3
static const std::string	exampleCompressedCertificate
static const std::string	tooLargeCompressedCertificate

Typedef Documentation

using fizz::test::Action = typedef boost::variant<A1, A2>

Definition at line 56 of file FizzBaseTest.cpp.

using fizz::test::Actions = typedef std::vector<Action>

Definition at line 57 of file FizzBaseTest.cpp.

using fizz::test::BufCreator = typedef std::function<std::unique_ptr<folly::IOBuf>(size_t len, size_t bufNum)>

Definition at line 20 of file TestUtil.h.

typedef Types< P256Test, P384Test, P521Test, RSATest > fizz::test::KeyTypes

Definition at line 106 of file ECKeyExchangeTest.cpp.

Enumeration Type Documentation

enum fizz::test::StateEnum

strong

Enumerator
NotError
Error

Definition at line 44 of file FizzBaseTest.cpp.

{ NotError, Error };

Function Documentation

static AppWrite fizz::test::appWrite ( const std::string &  str )

static

Definition at line 30 of file FizzBaseTest.cpp.

References folly::IOBuf::copyBuffer(), fizz::AppWrite::data, and fizz::detail::write().

Referenced by fizz::sm::generateTicket(), fizz::sm::getCertificateRequest(), fizz::sm::getMaxEarlyDataSize(), fizz::sm::handleEarlyAppWrite(), and TEST_F().

                                               {
  AppWrite write;
  write.data = IOBuf::copyBuffer(str);
  return write;
}

void fizz::test::callDecrypt	(	std::unique_ptr< Aead > &	cipher,
		const CipherParams &	params,
		std::unique_ptr< IOBuf >	ciphertext = nullptr,
		std::unique_ptr< IOBuf >	aad = nullptr
	)

Definition at line 104 of file OpenSSLEVPCipherTest.cpp.

References fizz::test::CipherParams::aad, fizz::test::CipherParams::ciphertext, copyBuffer(), EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, folly::gen::move, fizz::test::CipherParams::plaintext, fizz::test::CipherParams::seqNum, toIOBuf(), and fizz::test::CipherParams::valid.

Referenced by TEST_P().

                                        {
  if (!ciphertext) {
    ciphertext = toIOBuf(params.ciphertext);
  }
  if (!aad && !params.aad.empty()) {
    aad = toIOBuf(params.aad);
  }
  auto ctCopy = copyBuffer(*ciphertext);
  try {
    auto out = cipher->decrypt(std::move(ciphertext), aad.get(), params.seqNum);
    EXPECT_TRUE(params.valid);
    EXPECT_TRUE(IOBufEqualTo()(toIOBuf(params.plaintext), out));

    EXPECT_EQ(
        out->computeChainDataLength(),
        ctCopy->computeChainDataLength() - cipher->getCipherOverhead());
  } catch (const std::runtime_error&) {
    EXPECT_FALSE(params.valid);
  }
}

std::unique_ptr<folly::IOBuf> fizz::test::callEncrypt	(	std::unique_ptr< Aead > &	cipher,
		const CipherParams &	params,
		std::unique_ptr< IOBuf >	plaintext = nullptr,
		std::unique_ptr< IOBuf >	aad = nullptr
	)

Definition at line 81 of file OpenSSLEVPCipherTest.cpp.

References fizz::test::CipherParams::aad, fizz::test::CipherParams::ciphertext, copyBuffer(), EXPECT_EQ, folly::gen::move, fizz::test::CipherParams::plaintext, fizz::test::CipherParams::seqNum, toIOBuf(), and fizz::test::CipherParams::valid.

Referenced by TEST_P().

                                        {
  if (!plaintext) {
    plaintext = toIOBuf(params.plaintext);
  }

  if (!aad && !params.aad.empty()) {
    aad = toIOBuf(params.aad);
  }
  auto ptCopy = copyBuffer(*plaintext);
  auto out = cipher->encrypt(std::move(plaintext), aad.get(), params.seqNum);
  bool valid = IOBufEqualTo()(toIOBuf(params.ciphertext), out);

  EXPECT_EQ(valid, params.valid);
  EXPECT_EQ(
      out->computeChainDataLength(),
      ptCopy->computeChainDataLength() + cipher->getCipherOverhead());
  return out;
}

std::unique_ptr< folly::IOBuf > fizz::test::chunkIOBuf	(	std::unique_ptr< IOBuf >	input,
		size_t	chunks,
		BufCreator	creator
	)

Definition at line 31 of file TestUtil.cpp.

References folly::gen::chunked(), folly::IOBuf::computeChainDataLength(), folly::IOBuf::countChainElements(), defaultCreator(), folly::chrono::floor(), i, folly::gen::move, folly::IOBuf::prependChain(), fizz::transformBuffer(), and uint8_t.

Referenced by TEST_P().

                                                                          {
  if (!creator) {
    creator = defaultCreator;
  }
  // create IOBuf chunks
  size_t inputLen = input->computeChainDataLength();
  size_t chunkLen = floor((double)inputLen / (double)chunks);
  std::unique_ptr<IOBuf> chunked;

  for (size_t i = 0; i < chunks - 1; ++i) {
    auto buf = creator(chunkLen, i);
    buf->append(chunkLen);
    if (!chunked) {
      chunked = std::move(buf);
    } else {
      chunked->prependChain(std::move(buf));
    }
  }

  size_t remainLen = inputLen - (chunks - 1) * chunkLen;
  auto remain = creator(remainLen, chunks - 1);
  remain->append(remainLen);
  chunked->prependChain(std::move(remain));

  transformBuffer(
      *input, *chunked, [](uint8_t* out, const uint8_t* in, size_t len) {
        memcpy(out, in, len);
      });

  CHECK_EQ(chunks, chunked->countChainElements());
  return chunked;
}

std::unique_ptr<IOBuf> fizz::test::copyBuffer

(

const folly::IOBuf &

buf

)

Definition at line 69 of file OpenSSLEVPCipherTest.cpp.

References folly::IOBuf::copyBuffer(), and folly::IOBuf::prependChain().

Referenced by callDecrypt(), callEncrypt(), folly::IOBuf::copyBuffer(), folly::IOBuf::maybeCopyBuffer(), TEST(), TEST_F(), and folly::IOBuf::wrapBufferAsValue().

                                                       {
  std::unique_ptr<IOBuf> out;
  for (auto r : buf) {
    if (out) {
      out->prependChain(IOBuf::copyBuffer(r));
    } else {
      out = IOBuf::copyBuffer(r);
    }
  }
  return out;
}

std::unique_ptr<IOBuf> fizz::test::createBuf

(

size_t

len

)

Definition at line 59 of file IOBufUtilTest.cpp.

References folly::IOBuf::create().

Referenced by TEST().

                                           {
  auto res = IOBuf::create(len);
  res->append(len);
  return res;
}

CertAndKey fizz::test::createCert	(	std::string	cn,
		bool	ca,
		CertAndKey *	issuer
	)

Definition at line 35 of file Utilities.h.

References fizz::test::CertAndKey::cert, fizz::test::CertAndKey::key, folly::gen::move, name, string, throwIfNeq(), and throwIfNull().

Referenced by fizz::tool::fizzServerCommand(), fizz::server::test::FizzTestServer::FizzTestServer(), fizz::test::DefaultCertificateVerifierTest::SetUp(), and TEST_F().

                                                                 {
  folly::ssl::EvpPkeyUniquePtr pk(EVP_PKEY_new());
  throwIfNull(pk, "private key creation failed");

  folly::ssl::X509UniquePtr crt(X509_new());
  throwIfNull(crt, "cert creation failed");

  folly::ssl::EcGroupUniquePtr grp(
      EC_GROUP_new_by_curve_name(NID_X9_62_prime256v1));
  throwIfNull(grp, "group creation failed");

  EC_GROUP_set_asn1_flag(grp.get(), OPENSSL_EC_NAMED_CURVE);
  EC_GROUP_set_point_conversion_form(grp.get(), POINT_CONVERSION_UNCOMPRESSED);

  throwIfNeq(EC_GROUP_check(grp.get(), nullptr), 1, "group check failed");

  folly::ssl::EcKeyUniquePtr ec(EC_KEY_new());
  throwIfNull(ec, "ec key creation error");

  throwIfNeq(EC_KEY_set_group(ec.get(), grp.get()), 1, "failed to set group");

  throwIfNeq(EC_KEY_generate_key(ec.get()), 1, "ec generation failed");

  throwIfNeq(
      EVP_PKEY_set1_EC_KEY(pk.get(), ec.get()),
      1,
      "private key assignment failed");

  X509_set_version(crt.get(), 2);
  static int serial = 0;
  ASN1_INTEGER_set(X509_get_serialNumber(crt.get()), serial++);
  X509_gmtime_adj(X509_get_notBefore(crt.get()), 0);
  X509_gmtime_adj(X509_get_notAfter(crt.get()), 31536000);

  throwIfNeq(
      X509_set_pubkey(crt.get(), pk.get()), 1, "public key assignment failed");

  X509_NAME* name = X509_get_subject_name(crt.get());
  const std::vector<std::pair<std::string, std::string>> entries{
      {"C", "US"}, {"O", "Facebook, Inc."}, {"CN", cn}};
  for (const auto& entry : entries) {
    throwIfNeq(
        X509_NAME_add_entry_by_txt(
            name,
            entry.first.c_str(),
            MBSTRING_ASC,
            reinterpret_cast<const unsigned char*>(entry.second.c_str()),
            -1,
            -1,
            0),
        1,
        std::string("failed to set name entry: ") + entry.first);
  }

  if (ca) {
    X509V3_CTX ctx;
    X509V3_set_ctx_nodb(&ctx);
    std::array<char, 8> constraint{"CA:TRUE"};
    folly::ssl::X509ExtensionUniquePtr ext(X509V3_EXT_conf_nid(
        nullptr, &ctx, NID_basic_constraints, constraint.data()));
    throwIfNull(ext, "failed to create extension");
    throwIfNeq(
        X509_EXTENSION_set_critical(ext.get(), 1), 1, "failed to set critical");
    throwIfNeq(
        X509_add_ext(crt.get(), ext.get(), -1), 1, "failed to add extension");
  }

  if (issuer) {
    throwIfNeq(
        X509_set_issuer_name(
            crt.get(), X509_get_subject_name(issuer->cert.get())),
        1,
        "failed to set issuer");
    if (X509_sign(crt.get(), issuer->key.get(), EVP_sha256()) == 0) {
      throw std::runtime_error("failed to sign certificate");
    }
  } else {
    throwIfNeq(
        X509_set_issuer_name(crt.get(), name), 1, "failed to set issuer");
    if (X509_sign(crt.get(), pk.get(), EVP_sha256()) == 0) {
      throw std::runtime_error("failed to self-sign certificate");
    }
  }

  return {std::move(crt), std::move(pk)};
}

std::unique_ptr<folly::IOBuf> fizz::test::defaultCreator	(	size_t	len,
		size_t
	)

Definition at line 18 of file TestUtil.cpp.

References folly::IOBuf::create().

Referenced by chunkIOBuf().

                                                             {
  return IOBuf::create(len);
}

bool fizz::test::extensionsMatch	(	const Extension &	expected,
		const Extension &	actual
	)

Definition at line 168 of file HandshakeTypesTest.cpp.

References fizz::Extension::extension_data, and fizz::Extension::extension_type.

Referenced by TEST_F().

                                                                         {
  if (expected.extension_type != actual.extension_type) {
    return false;
  }
  return folly::IOBufEqualTo()(
      *expected.extension_data, *actual.extension_data);
}

static EvpPkeyUniquePtr fizz::test::generateKey ( )

static

Definition at line 26 of file RSAPSSSignatureTest.cpp.

Referenced by TEST_F().

                                      {
  std::unique_ptr<
      EVP_PKEY_CTX,
      folly::static_function_deleter<EVP_PKEY_CTX, &EVP_PKEY_CTX_free>>
      ctx(EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, nullptr));
  EVP_PKEY_keygen_init(ctx.get());
  EVP_PKEY_CTX_set_rsa_keygen_bits(ctx.get(), 2048);
  EVP_PKEY* keyPtr{nullptr};
  EVP_PKEY_keygen(ctx.get(), &keyPtr);
  return EvpPkeyUniquePtr(keyPtr);
}

folly::ssl::X509UniquePtr fizz::test::getCert

(

folly::StringPiece

cert

)

Definition at line 48 of file TestUtil.cpp.

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

Referenced by getCert< P256Test >(), getCert< P384Test >(), getCert< P521Test >(), getCert< RSATest >(), getCertData(), fizz::server::test::ServerProtocolTest::SetUp(), fizz::test::HandshakeTest::SetUp(), TEST(), fizz::server::test::TEST(), fizz::server::test::TEST_F(), and TEST_F().

                                                     {
  BioUniquePtr bio(BIO_new(BIO_s_mem()));
  CHECK(bio);
  CHECK_EQ(BIO_write(bio.get(), cert.data(), cert.size()), cert.size());
  X509UniquePtr x509(PEM_read_bio_X509(bio.get(), nullptr, nullptr, nullptr));
  CHECK(x509);
  return x509;
}

template<typename T >

static ssl::X509UniquePtr fizz::test::getCert ( )

static

Referenced by TEST().

template<>

ssl::X509UniquePtr fizz::test::getCert< P256Test >

(

)

Definition at line 58 of file CertTest.cpp.

References getCert(), and kP256Certificate.

                                     {
  return fizz::test::getCert(kP256Certificate);
}

template<>

ssl::X509UniquePtr fizz::test::getCert< P384Test >

(

)

Definition at line 63 of file CertTest.cpp.

References getCert(), and kP384Certificate.

                                     {
  return fizz::test::getCert(kP384Certificate);
}

template<>

ssl::X509UniquePtr fizz::test::getCert< P521Test >

(

)

Definition at line 68 of file CertTest.cpp.

References getCert(), and kP521Certificate.

                                     {
  return fizz::test::getCert(kP521Certificate);
}

template<>

ssl::X509UniquePtr fizz::test::getCert< RSATest >

(

)

Definition at line 73 of file CertTest.cpp.

References getCert(), getKey(), and kRSACertificate.

                                    {
  return fizz::test::getCert(kRSACertificate);
}

std::unique_ptr< folly::IOBuf > fizz::test::getCertData

(

folly::StringPiece

cert

)

Definition at line 57 of file TestUtil.cpp.

References folly::ssl::OpenSSLCertUtils::derEncode(), and getCert().

                                                             {
  return OpenSSLCertUtils::derEncode(*getCert(cert));
}

std::unique_ptr<Aead> fizz::test::getCipher

(

const CipherParams &

params

)

Definition at line 42 of file OpenSSLEVPCipherTest.cpp.

References fizz::test::CipherParams::cipher, cipher, fizz::TrafficKey::iv, fizz::test::CipherParams::iv, fizz::TrafficKey::key, fizz::test::CipherParams::key, folly::gen::move, and toIOBuf().

Referenced by fizz::test::AsyncFizzBaseTest::getApplicationProtocol(), fizz::test::MockAsyncFizzBase::getApplicationProtocol(), TEST(), and TEST_P().

                                                          {
  std::unique_ptr<Aead> cipher;
  switch (params.cipher) {
    case CipherSuite::TLS_AES_128_GCM_SHA256:
      cipher = std::make_unique<OpenSSLEVPCipher<AESGCM128>>();
      break;
    case CipherSuite::TLS_AES_256_GCM_SHA384:
      cipher = std::make_unique<OpenSSLEVPCipher<AESGCM256>>();
      break;
    case CipherSuite::TLS_CHACHA20_POLY1305_SHA256:
      cipher = std::make_unique<OpenSSLEVPCipher<ChaCha20Poly1305>>();
      break;
    case CipherSuite::TLS_AES_128_OCB_SHA256_EXPERIMENTAL:
      cipher = std::make_unique<OpenSSLEVPCipher<AESOCB128>>();
      break;
    default:
      throw std::runtime_error("Invalid cipher");
  }

  TrafficKey trafficKey;
  trafficKey.key = toIOBuf(params.key);
  trafficKey.iv = toIOBuf(params.iv);
  cipher->setKey(std::move(trafficKey));
  cipher->setEncryptedBufferHeadroom(kHeadroom);
  return cipher;
}

template<typename T >

static ssl::EvpPkeyUniquePtr fizz::test::getKey ( )

static

Definition at line 36 of file EncryptedRecordBench.cpp.

References fizz::TrafficKey::iv, fizz::TrafficKey::key, and toIOBuf().

Referenced by encryptGCM(), getCert< RSATest >(), folly::settings::detail::SettingCore< T >::set(), fizz::testing::TEST_P(), and TEST_P().

                    {
  TrafficKey trafficKey;
  trafficKey.key = toIOBuf("000102030405060708090A0B0C0D0E0F");
  trafficKey.iv = toIOBuf("000102030405060708090A0B");
  return trafficKey;
}

EvpPkeyUniquePtr fizz::test::getKey

(

const Params &

param

)

Definition at line 204 of file ECKeyExchangeTest.cpp.

References getNid(), fizz::test::Params::priv, fizz::test::Params::privX, fizz::test::Params::privY, setPoint(), uint8_t, and folly::unhexlify().

                                             {
  auto privKeyBin = unhexlify(param.priv);
  BIGNUMUniquePtr privateBn(
      BN_bin2bn((uint8_t*)privKeyBin.c_str(), privKeyBin.size(), nullptr));
  EcKeyUniquePtr privateKey(EC_KEY_new_by_curve_name(getNid(param)));
  EC_KEY_set_private_key(privateKey.get(), privateBn.get());
  setPoint(privateKey, param.privX, param.privY);
  EvpPkeyUniquePtr pkeyPrivateKey(EVP_PKEY_new());
  EVP_PKEY_set1_EC_KEY(pkeyPrivateKey.get(), privateKey.get());
  return pkeyPrivateKey;
}

template<>

ssl::EvpPkeyUniquePtr fizz::test::getKey< P256Test >

(

)

Definition at line 81 of file CertTest.cpp.

References getPrivateKey(), and kP256Key.

                                       {
  return getPrivateKey(kP256Key);
}

template<>

ssl::EvpPkeyUniquePtr fizz::test::getKey< P384Test >

(

)

Definition at line 86 of file CertTest.cpp.

References getPrivateKey(), and kP384Key.

                                       {
  return getPrivateKey(kP384Key);
}

template<>

ssl::EvpPkeyUniquePtr fizz::test::getKey< P521Test >

(

)

Definition at line 91 of file CertTest.cpp.

References getPrivateKey(), and kP521Key.

                                       {
  return getPrivateKey(kP521Key);
}

template<>

ssl::EvpPkeyUniquePtr fizz::test::getKey< RSATest >

(

)

Definition at line 96 of file CertTest.cpp.

References getPrivateKey(), and kRSAKey.

                                      {
  return getPrivateKey(kRSAKey);
}

int fizz::test::getNid

(

const Params &

param

)

Definition at line 183 of file ECKeyExchangeTest.cpp.

References fizz::test::Params::key.

Referenced by getKey(), and TEST_P().

                                {
  switch (param.key) {
    case KeyType::P256:
      return P256::curveNid;
    case KeyType::P384:
      return P384::curveNid;
    case KeyType::P521:
      return P521::curveNid;
    default:
      throw std::runtime_error("invalid key type");
  }
}

std::shared_ptr<PeerCert> fizz::test::getPeerCert

(

const CertAndKey &

cert

)

Definition at line 122 of file Utilities.h.

References fizz::test::CertAndKey::cert.

Referenced by fizz::test::MockAsyncFizzBase::MockAsyncFizzBase(), fizz::test::AsyncFizzBaseTest::TearDown(), and TEST_F().

                                                            {
  return std::make_shared<PeerCertImpl<KeyType::P256>>(
      folly::ssl::X509UniquePtr(X509_dup(cert.cert.get())));
}

folly::ssl::EvpPkeyUniquePtr fizz::test::getPrivateKey

(

StringPiece

key

)

Definition at line 21 of file TestUtil.cpp.

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

Referenced by getKey< P256Test >(), getKey< P384Test >(), getKey< P521Test >(), getKey< RSATest >(), fizz::test::HandshakeTest::SetUp(), TEST(), TEST(), TEST_F(), and TYPED_TEST().

                                                {
  BioUniquePtr bio(BIO_new(BIO_s_mem()));
  CHECK(bio);
  CHECK_EQ(BIO_write(bio.get(), key.data(), key.size()), key.size());
  EvpPkeyUniquePtr pkey(
      PEM_read_bio_PrivateKey(bio.get(), nullptr, nullptr, nullptr));
  CHECK(pkey);
  return pkey;
}

folly::ssl::EvpPkeyUniquePtr fizz::test::getPublicKey

(

StringPiece

key

)

Definition at line 31 of file TestUtil.cpp.

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

Referenced by TEST().

                                               {
  BioUniquePtr bio(BIO_new(BIO_s_mem()));
  CHECK(bio);
  CHECK_EQ(BIO_write(bio.get(), key.data(), key.size()), key.size());
  EvpPkeyUniquePtr pkey(
      PEM_read_bio_PUBKEY(bio.get(), nullptr, nullptr, nullptr));
  CHECK(pkey);
  return pkey;
}

fizz::test::INSTANTIATE_TEST_CASE_P	(	TestVectors	,
		HkdfTest	,
		::testing::Values(HashParams{"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","000102030405060708090a0b0c","f0f1f2f3f4f5f6f7f8f9", 42,"3cb25f25faacd57a90434f64d0362f2a""2d2d0a90cf1a5a4c5db02d56ecc4c5bf""34007208d5b887185865"}, HashParams{"000102030405060708090a0b0c0d0e0f""101112131415161718191a1b1c1d1e1f""202122232425262728292a2b2c2d2e2f""303132333435363738393a3b3c3d3e3f""404142434445464748494a4b4c4d4e4f","606162636465666768696a6b6c6d6e6f""707172737475767778797a7b7c7d7e7f""808182838485868788898a8b8c8d8e8f""909192939495969798999a9b9c9d9e9f""a0a1a2a3a4a5a6a7a8a9aaabacadaeaf","b0b1b2b3b4b5b6b7b8b9babbbcbdbebf""c0c1c2c3c4c5c6c7c8c9cacbcccdcecf""d0d1d2d3d4d5d6d7d8d9dadbdcdddedf""e0e1e2e3e4e5e6e7e8e9eaebecedeeef""f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", 82,"b11e398dc80327a1c8e7f78c596a4934""4f012eda2d4efad8a050cc4c19afa97c""59045a99cac7827271cb41c65e590e09""da3275600c2f09b8367793a9aca3db71""cc30c58179ec3e87c14c01d5c1f3434f""1d87"}, HashParams{"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b","","", 42,"8da4e775a563c18f715f802a063c5a31""b8a11f5c5ee1879ec3454e5f3c738d2d""9d201395faa4b61a96c8"})
	)

fizz::test::INSTANTIATE_TEST_CASE_P	(	TestVectors	,
		ECDHTest	,
		::testing::Values(Params{"e19007eb245d6995ffa8b3ede1e59193aa6cfaaf4cc1e1d126948610c9b3f44c","758b2f0e79a3d0a94f521ae31dcff50fabd394bb4bbec8fa37d1566f463444e7","b981e686e53e9e9dc2e3f263e810c89b4c271e62392f59ed45ed30ac3a5bfd33","8171000763de347d0eb650dd6fddac2ad48ec122c162d66c3df257aea13192fb","c22ac2ee50e771a93b2b6a42c5e9b76b45a56e0d0011e34aa790283ede61f3d9","0ef754edae5e79c518f1056aa5179cbb6a3a4b7c9654b5048f4259bd2597e57d","5cbea453310285b22f128178bd09b906fde9e660b5a17a7cec809a5a9a1e9287", true, KeyType::P256}, Params{"0ced658b6113979f8d05fd7b305ce0b8d70f45034d021b052cbcb318e0cfd602","acbcb31f5f6798a00f28aa4a634873744768db612925336efca98122a76d1b5e","7dcefeb3ccb530029a8b62e5a7f00c42fc7ebeac8f469c289ea77b6186d661f0","64e23f7a2d279930f1de66b4bc147786b168d059f581268c24f6650362246e63","ba393b401354aa9552c4289b7a55288d97590429a4003913a243081bacf88acf","d089687aa5442684d71b805ea2b36f6c1c783833346dfdd8208768ed2a7e767d","f70e4fc9ba68aafe07be1767620e64dd5e5bb7ab279f0657465cddeb69e36fa9", true, KeyType::P256}, Params{"0ced658b6113979f8d05fd7b305ce0b8d70f45034d021b052cbcb318e0cfd602","758b2f0e79a3d0a94f521ae31dcff50fabd394bb4bbec8fa37d1566f463444e7","b981e686e53e9e9dc2e3f263e810c89b4c271e62392f59ed45ed30ac3a5bfd33","8171000763de347d0eb650dd6fddac2ad48ec122c162d66c3df257aea13192fb","c22ac2ee50e771a93b2b6a42c5e9b76b45a56e0d0011e34aa790283ede61f3d9","0ef754edae5e79c518f1056aa5179cbb6a3a4b7c9654b5048f4259bd2597e57d","5cbea453310285b22f128178bd09b906fde9e660b5a17a7cec809a5a9a1e9287", true, KeyType::P256}, Params{"639ef9ee75a3888617fdd7ed89d62f7398b0eb4f20ccbd35026e150fc937c927","1d2dda4a3735be1f3aedfa8a7bb1410c3867c5d67f55a3dd5376b137352f113d","eca92fb210b1813f51ea2483ff461eb24786afb41f1a00870cf65aab5bbd725e","e062138981049c3b4b964fa5a28569e0142c2c51d6ca0bebdb3270e2ab77fb30","9aa8dd75f7d929b1f5f123aa9f3265be34f771c20bb50deea684a139a10938f8","2b74f503fa7b08db1c76d97c2e571cb91f68a93413daf102c47fee1b8a264d93","9f5f64d76f9bb2f2af24debdd47323d5df9d2b84fc7c7aac1f6d41678adec7de", false, KeyType::P256}, Params{"305dfb4a8850cc59280891147baf457bfe5e2bae984571634a77dc8d3472fa9b","202cb5a224e6c2a84e624094486edf04116c8d68ec1f4a0e0ed9ee090e1a900b","cacf3a5789bb33954be600425d62d9eae5371f90f88167258814213e4a4f4b1a","72cc52808f294b64b6f7233c3d2f5d96cc1d29287320e39e1c151deef0bc14eb","49a768c9a4ca56e374f685dd76a461b1016c59dcded2c8d8cbd9f23ca453831f","b1e3bb9b5f12a3b5ae788535d4554bd8c46e0e6130075e4e437d3854cf8f1c34","c0147c3c2691b450b5edc08b51aea224d9f4359ff67aab6da3146f396dbceaea", false, KeyType::P256}, Params{"0e5c98ff2d2a3aab14ad0067b60dbe64e4f541ab5bed11c5a0c55ae1e60b51ff5faaf377837977d80cbfdc33c2ff542b","d1bf2ac21637d66d6398aac01dcd56ac6f065fb45d1f6f16747bab9e9b01b4630b59b20927aea147355bf41838acb482","4c9e23f1c5a41647d094086bf4ed31708651f21d996c47780688ac10f77deee2e43b5241b6caecd2fd5444bc50472e0e","f865418473e5bf7d2e1bbcd9bd5a9270c003a9dd35e778133ca59fcab4bb64fe24d6800e7047bdd033abc8bfa8db35b5","32b72ab9b558249dcbc6cbade234f58e4f7aa5d3f6420ea99a5f997e8c2a91fb7fd83779d0d2169428683771c745fd1a","c749e02a3719bb56bf1dfc4ba3820309c01ab6e84cb29db7cdd80f127233f5295687f8178f3a8704c1063b84c2ee472f","a781430e6078a179df3f9ee27cd8fdc6188f161b6c4ccc4053ef6c6ca6fc222946883a53c06db08f0a020023ced055aa", true, KeyType::P384}, Params{"925065e50f7eae1319865720ae483de4dba7449dc144c4b50b8e96c4f4fcd9f8b3fbf693262429c91c69d8dd8355fdd8","4c619593e459e4aca7c572834064134d93e8b1b676388b0ff67b893722cf7e8396cd953df38a42e4131dbad29518b2af","dbe261af918baade39070e88f62eabe4ee9d5f2563707271cc566dd7a2380aa4707d15d6eef142a52d75a67429afd0c6","c40c805488115e43279c99797bcbfff8d9922ea9aec471d9ba659590034c3fb739d23661c0aae6e7ada2a1de36eb63a1","a95b7ad4de234e9be8b260313ddb96a404b75b3a7e0f234981f3b189d86ac31bbe3937776c0608024871ef64815784b3","4890ee227219ca5ce34632cbca5732accc2d276fa1b1cc9d14f6b7e4b0f5e116a92cbef743de3e69537e250f27125e82","128934db846099c8d8caa788b0b84bb65bd57b20774ff7f8e7f29939297d72bbc232c5d2b2c8ef1d63e3d75d3908e778", true, KeyType::P384}, Params{"259c53eec19d01d19428f6cc5cd445ab685578c53325f6d2f157bd0328deca4ffb8c21dca891d59e34a807203f7e9a5d","d18832f4cf3013e514b4fb4c42bbeb15708e20ed91b982598deb2d67b37275587fcb35cf214039ec4fd1834d704c1faf","917c49465bef063949957256eddbece762090ef10f8c48566bd71dc0ad9eb3bc00f0b3f6a88d614210804dd633ca6e68","3120ee90dcce02bac90a66d30ad602e94edcce482dbc5245a136df1d0509b04f6ee305fedd290775c71f1631684f5c0a","7a3e0fd767acf409cebe6fe0222974438bccdefb13f0d668b8daad43a6fdbdf46845c45b9594ffd6742a615dd834f1a5","e3cc9f7153b6ffd3b285349996b952905466942d17f6a9685a11318b0c2c72904961d246cbe3ef98903dbbfb0fbe55b0","5c8d476518873208e1c97685c033a1ba6ec279b8674060cc1a99469908604353043bf488109150b9b2f9b3b1440a426c", true, KeyType::P384}, Params{"4e422a76b085ae939a8166afb98e344b9ac30bab610e90b3d7449de0a0de6b88fadb095e4818521bb1473540a7ec73ee","de464ed2129eef42ef23cb1bfad27382293edad91d867b1b8b82a19bd17516daf0a73548787a733d66ca4f4d40b52da1","f07bd6003229de37d6293513cbace59ebc24efb571c065df2bc1465c4570928fd612a59a46805b6adce7fb94e36ad043","f8f6697507aeec09fe024f974e00e67f12a14c130df875732b450b3ae8d2cbbb1fcf46bac9207e89a297352eeade7df5","c1db2e81eca0e5b02e8736ff351aa8e59bdadd1c9c7428faf93493c7b93153ec2c55964a157025ff6ddb4523d8e0a453","98daa370a6610ecf604e38e1e70b7f57657c49908eb15634a3a65a175ca7b8cfe1ad535037928ae95c80107a1e018b3c","d80415977c3ce1737fd574596e981c767ecaf5c70084fae6c2072f0ccecc8bdda54a0bf44357981303a2ecc78b26e97c", false, KeyType::P384}, Params{"4ee6a24b5dca82b215c92cb298d5ac24b77820c7b7e9c8fe4d05d7a297b8f6be40f8d8cf09a4bb238cfdbe05f851c493","1f9af3b14439d4c56b353b5892dd85b6a27053e1d23f5f05ff95ea3fa942eb463e1074b01828a79c865b16fde0fc0f24","01a81aaef502fe84508b054924d90078f68d8d4e9ae5299bd0ea60a97167c549011f4a024e964292d378e82b6874caad","3d715cd0d6490ba5607e7eae2c74361be65de413f10576c1d996658e20c78f8110c70104067922d48303f6ccb1b23f46","2fa7d2ea93945b41c929279a750ded758d9db93d120b5eeda3d9994e36e3381f653d19dcae0eccb1a12153ce4025a62e","04c6e45983485529e9dacba8d609cffaec849f7c5e5cf4a025ce2c0ff9ae6679b4564b9af58fab58c7f92837597b830b","5e77e466aeae9c10ff8d255e07cf0ad9eae50c8a6fd2c7cd889d73d968c423a15c0462b05bf985cbf679a629e380ce80", false, KeyType::P384}, Params{"0000002fef62381162942889a6094a6bb9ac1f4ddf66d9cda9f618232d31b90c50d7da78a47ed91d40cae946898571db972dc294b109815f38feee9eaac0d5f7c3250728","0000004b05ffa025113390797f2736174aa1c784f4dd34e764ee40d40e4d2442677ebea3498086c9473e5c92789cbdb02bb327bbd61d58690f6a83d9ca73bccbde37dec4","0000004da67cffc98070b82af61feba78787efefb13bd810d80ff92304788e49a4e5b634b3565474a8ecb1615d7b1b77a7a27875adb73a8a5d8f3f84e5e8b744cda250b0","00000311a5e520e238141527671a38cb6f776d96a9f82ef70dffa11dc0895f4060f1abbb9ad6fd259e4a7beaf5f7266ea1bb45bcbfebfda2705e5c551e710fb1d745f57e","0000010ba3778cb2cc965834c0a9593adc6a222692656d657fb0d15293edf0ab33762384a96a16fddea7540b7ccbcca46ec4ac9bcf95fdb5aa18e158aab4d91981bd733e","0000018522df93ddd636e5bc94daecdc600fa241686ec18634fd30b7cbdfdc9ffba1166ac08df34a31896f6fad191414929261ebd7187afb72919f8a0c926be37f99c1e5","01a5e4b31be4b1346e53906b6767b1fe94ec1a8a5abc28fb6f01518c056959af3bc9335dddab178b52318cc5512559931b8dc18de0ce810c2c7f15769d7ce70e719c", false, KeyType::P521}, Params{"0000013262b7f4f36de274b2c60e4a812866740e545186953f798ac07b5d74e4f0cc1123a9bfcbf77850e2d856246065c54a2437a2816a7d79d6180a9a6ba17f18df8b65","000001474af758238005238b2fa253c4f9c557de664d64c66d7d88f334555997591ccc242ff3c6d0e34d07fc835aaae024c2bd21f2ba5c0b0a8ac3fdd90e1c479cb8e538","000000a721b04654204ca19064b37a4abf4247413a6d29e9211a0df9d50975c7d8d4654dc04a478455ea24993f0fef5460f189c4729c15fba385fd85ef42ae7610e39450","000001a23de55fb7ad153e7e65d21ad10c77fdf2072b2a5aa116aaf1bc31a345420c1fe8eaccbbcdeb07b73ba2fa706c7498e3a4828f348b00af9df1551780e709a7754c","000000ed7bc3a95ef74dc3a9893a5ec7c9fab723c16dc21b30341c374c25e1334dada7f92d62967f3bca4da70b0a77fa0732dac05a3d19cb04e50b3cd1894549ac1d3c6e","000001c30d23ea4c140aabfba3753ce40c788010342c15c51d2dd6e9b079194e593ba965ea419ef37746f954027fa1b8159ccd3b54aece67451c7e892d6f6e1fb44c548c","01e8ff7a8c57b017f8b8266adab65fe2c417173566087e15c5fc972071cc560ac93908a806468bc44b8312a8a48464886ca0d767db938447387a348f3f56c6463796", true, KeyType::P521}, Params{"000000364b6cc953c841d2e1c8c292fadaa673ea073d150da4cec9c0c6544c92373c6a42a781283bedb080a4de720b99769869019a38023019b9d15c99b2a08a02104cc7","000001abbbcd3912723cbb3147145a12b8f2f40d1fe6484fa831250435ffb8eb751bccdf425e81d8e79518ec84c56bd28763c417f30a16c213abbfd8e5871d93dcb3f0d0","00000237c413a4527ca89dee7c8a5c45fc0207627e3db79353ee506857d68f746ea2c7b4d04ab1c10df56b1a706012f616ec9a5510467c49a56941841a1636f620dc3ac4","000000e04b0e32496f1d43ff48d759dc57d586c6c55efb6460fc1148021afa1943180aea2a1be7721a69ebf9d55585a4d4bdb6ff3e177448568c0b45542eddb936fbd870","00000195a305d23a94794e680b211b8ec4a5c2150a2002afdc4ff5da254c438b5686b12dda72bd8dbb009d07d469c3d664e67da274de7f2e2dc84661d2a054638cf6fc98","000000e56b77c46a997c06da59033e1c57939f6f8513329ebe93dcb00857a8ff850428473d937528e85c15a5fe46df1ffb7aeed4b17f7fc9ad08fb121045e2eea5a316b2","013eeaad91133eb338a4c1f27af66aa7f7614619b6c21c20f0e2d68fca2e9cbaa224104a45aa4dbefcb1e49b7f1a36171a35102d2b7d2ffbade07e600b4a7e28c05c", false, KeyType::P521}, Params{"000001ef093db892daaa05d43e70654bd702d7e177465b00a5ff70a9a072774d7cda3893c181ad1dbb23f8352d3098025406a442c60afaf949dd37ee9c36ee2f785dc693","0000017e817b93e7e3eb95291545afffa2dcd1ff90b97c2b7d9cc7a46511cbdf7a7afe7a2ce126822d08bc71519542743dfece750e18f1e01bb5201e622e2697e5b1faa6","00000025e5e302514ccb15ed84291ba30746b1176f2b080bfa78ef7ce5721fd00d3d717421932d61ad74068c36885a9a0e6537183209a79054fcb8df43b83066f60c47d5","0000004e9f4ebd9f4772df7c003828210d087aa41c0154394428f5f8624536a15c157634c5200de037e46698d4f8484feb164374899b2d9d5e258080dae6b3429c965154","0000021fb91b2abbdd7dee5e2750a1fce602e235a6512b429ab0a3845bd8c8a630d9d35850e0ba78f01c01ffae6ca1a88c93c153a6fdc09f76fae768bdd449e7f6730b68","0000005cb38e5272648f2adcb5ec7a37f3b2135c93a0202f2c822383eae29468392f4baeddabf0acd3bee0cbc1dd540b435d34ecb008408ac093978976741d1afa374c72","01bca2f6325ccf7a6a213b2678ded8ce3e687497c7f7f46a4a06bf3e69dabb745a883d130936c786debf2fe5ef8880f1bb976a79e33b68d30d7356b5a4672e65fcea", false, KeyType::P521}, Params{"0000014199e2e81aa1f98bf0f39d069e720820d0433222f5b8ca26606fe7c4d0cd619b415d2a629674479a6ec6171f05f657a168aad9342e8489a39cf485a396a8400c59","00000070ce983ca6d0a7aa7849bef13e11e3dc1d62e1ddb85b54d4a3c9de5b47a078846f92105304efe4a4e71d7ff91c19a7b4e03fd87c2d8fb70732e274b114a0bf3bd2","0000009f564f73a5c7282556437dc4c2fbdf87d5fcfbaab0feecf1f7a88104f15a7314b083f711bd7b3a2c74b1096fdccdac01e0a35b8fd86d99ba9d64d10e190033c3df","000000c0b19361224245482bbe42110f9aa44f2818b5146710c24b4825a9a3e0a4743fc7983df560bd85d30639bbdb4d7fc0c56a862e0ef349801bef06ed0a9774463e9f","000000231f2c5c2ad3894b81ad2c8942221d06041f37b8d520e926701b9fb38e32833f9b2b99142d0e54baef33c17b2bd0f23ec3e1b08b9a87f65942384e5863607ba65c","0000005e3b734d4207b51259a1fca526161250176eab1364930d7d06259f43e68202962d9bb818a44bf3bf4a385e634a8d52489c58e2c9234670ae9f30668a2f5553c261","01186d749c6b2a215c59df35ef6f2f6ed1745a9b2e15fca225e79faa7c5b9af44821d50765b45c3c66e210ec78d4bccb7f8c44c19cf80f5357938df48e320fa1ed88", true, KeyType::P521})
	)

Referenced by TEST_P().

fizz::test::INSTANTIATE_TEST_CASE_P	(	AESGCM128TestVectors	,
		OpenSSLEVPCipherTest	,
		::testing::Values(CipherParams{"87f6c12b1ae8a9b7efafc65af0f5c994","479e25839c19e0476f95a6f5", 1,"","010015","9d4db5ecd768198892531eebac72cf1d477dd0", true, CipherSuite::TLS_AES_128_GCM_SHA256}, CipherParams{"911dc107aa6eccb6706bdcc37e76a07a","11c7fa13e9499ed042b09e57", 0,"","14000020de15cbc8c62d0e6fef73a6d4e70e5c372c2b94fe08ea40d11166a7e6c967ba9c16","56a21739148c898fe807026a179d59202647a3b1e01267a3883cf5f69fd233f63ff12c1c71b4c8f3d6086affb49621f96b842e1d35", true, CipherSuite::TLS_AES_128_GCM_SHA256}, CipherParams{"a0f49e7076cae6eb25ca23a2da0eaf12","3485d33f22128dff91e47062", 0,"","41424344454617","92fdec5c241e994fb7d889e1b61d1db2b9be6777f5a393", true, CipherSuite::TLS_AES_128_GCM_SHA256}, CipherParams{"fda2a4404670808f4937478b8b6e3fe1","b5f3a3fae1cb25c9dcd73993", 0,"","0800001e001c000a00140012001d00170018001901000101010201030104000000000b0001b9000001b50001b0308201ac30820115a003020102020102300d06092a864886f70d01010b0500300e310c300a06035504031303727361301e170d3136303733303031323335395a170d3236303733303031323335395a300e310c300a0603550403130372736130819f300d06092a864886f70d010101050003818d0030818902818100b4bb498f8279303d980836399b36c6988c0c68de55e1bdb826d3901a2461eafd2de49a91d015abbc9a95137ace6c1af19eaa6af98c7ced43120998e187a80ee0ccb0524b1b018c3e0b63264d449a6d38e22a5fda430846748030530ef0461c8ca9d9efbfae8ea6d1d03e2bd193eff0ab9a8002c47428a6d35a8d88d79f7f1e3f0203010001a31a301830090603551d1304023000300b0603551d0f0404030205a0300d06092a864886f70d01010b05000381810085aad2a0e5b9276b908c65f73a7267170618a54c5f8a7b337d2df7a594365417f2eae8f8a58c8f8172f9319cf36b7fd6c55b80f21a03015156726096fd335e5e67f2dbf102702e608ccae6bec1fc63a42a99be5c3eb7107c3c54e9b9eb2bd5203b1c3b84e0a8b2f759409ba3eac9d91d402dcc0cc8f8961229ac9187b42b4de100000f000084080400804547d6168f2510c550bd949cd2bc631ff134fa10a827ff69b166a6bd95e249ed0daf571592ebbe9ff13de6b03acc218146781f693b5a692b7319d74fd2e53b6a2df0f6785d624f024a44030ca00b869ae81a532b19e47e525ff4a62c51a5889eb565fee268590d8a3ca3c1bc3bd5404e39720ca2eaee308f4e0700761e986389140000209efee03ebffbc0dc23d26d958744c09e3000477eff7ae3148a50e5670013aaaa16","c1e631f81d2af221ebb6a957f58f3ee266272635e67f99a752f0df08adeb33bab8611e55f33d72cf84382461a8bfe0a659ba2dd1873f6fcc707a9841cefc1fb03526b9ca4fe343e5805e95a5c01e56570638a76a4bc8feb07be879f90568617d905fecd5b1619fb8ec4a6628d1bb2bb224c490ff97a6c0e9acd03604bc3a59d86bdab4e084c1c1450f9c9d2afeb172c07234d739868ebd62de2060a8de989414a82920dacd1cac0c6e72ecd7f4018574ceaca6d29f361bc37ee2888b8e302ca9561a9de9163edfa66badd4894884c7b359bcacae5908051b37952e10a45fe73fda126ebd67575f1bed8a992a89474d7dec1eed327824123a414adb66d5ef7d0836ff98c2cdd7fb0781e192bf0c7568bf7d890a51c332879b5037b212d622412ca48e8323817bd6d746eef683845cec4e3ef64b3a18fcce513ea951f3366693a7ff490d09d08ab1f63e13625a545961599c0d9c7a099d1163cad1b9bcf8e917d766b98853ef6877834f891df16be1fcc9c18ea1882ea3f1f4b64358e1b146cebfb3e02e153fdb73af2693f22c6f593fa475380ba6611740ad20e319a654ac5684775236162e8447ed808861bfbda6e18ec97ae090bf703475cfb90fe20a3c55bef6f5eba6e6a1da6a1996b8bde42180608ca2279def8e8153895cc850db6420561c04b5729cc6883436ea02ee07eb9baee2fb3a9e1bbda8730d6b220576e24df70af6928eb865fee8a1d1c0f1818aca68d5002ae4c65b2f49c9e6e21dcf76784adbd0e887a36832ef85beb10587f16c6ffe60d7451059ec7f1014c3efe19e56aedb5ad31a9f29dc4458cfbf0c7070c175dcad46e1675226b47c071aad3172ebd33e45d741cb91253a01a69ae3cc292bce9c03246ac951e45e97ebf04a9d51fab5cf06d9485cce746b1c077be69ad153f1656ef89fc7d1ed8c3e2da7a2", true, CipherSuite::TLS_AES_128_GCM_SHA256}, CipherParams{"a0f49e7076cbe6eb25ca23a2da0eaf12","3485d33f22128dff91e47062", 0,"","41424344454617","92fdec5c241e994fb7d889e1b61d1db2b9be6777f5a393", false, CipherSuite::TLS_AES_128_GCM_SHA256}, CipherParams{"a0f49e7076cae6eb25ca23a2da0eaf12","3485d33f22128dff91e47062", 0,"","41424344454617","92fdec", false, CipherSuite::TLS_AES_128_GCM_SHA256}, CipherParams{"AD7A2BD03EAC835A6F620FDCB506B345","12153524C0895E81B2C28465", 0,"D609B1F056637A0D46DF998D88E52E00B2C2846512153524C0895E81","08000F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F303132333435363738393A0002","701AFA1CC039C0D765128A665DAB69243899BF7318CCDC81C9931DA17FBE8EDD7D17CB8B4C26FC81E3284F2B7FBA713D4F8D55E7D3F06FD5A13C0C29B9D5B880", true, CipherSuite::TLS_AES_128_GCM_SHA256}, CipherParams{"AD7A2BD03EAC835A6F620FDCB506B345","12153524C0895E81B2C28465", 0,"D609B1F056637A1D46DF998D88E52E00B2C2846512153524C0895E81","08000F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F303132333435363738393A0002","701AFA1CC039C0D765128A665DAB69243899BF7318CCDC81C9931DA17FBE8EDD7D17CB8B4C26FC81E3284F2B7FBA713D4F8D55E7D3F06FD5A13C0C29B9D5B880", false, CipherSuite::TLS_AES_128_GCM_SHA256})
	)

fizz::test::INSTANTIATE_TEST_CASE_P	(	AESGCM256TestVectors	,
		OpenSSLEVPCipherTest	,
		::testing::Values(CipherParams{"E3C08A8F06C6E3AD95A70557B23F75483CE33021A9C72B7025666204C69C0B72","12153524C0895E81B2C28465", 0,"D609B1F056637A0D46DF998D88E52E00B2C2846512153524C0895E81","08000F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F303132333435363738393A0002","E2006EB42F5277022D9B19925BC419D7A592666C925FE2EF718EB4E308EFEAA7C5273B394118860A5BE2A97F56AB78365CA597CDBB3EDB8D1A1151EA0AF7B436", true, CipherSuite::TLS_AES_256_GCM_SHA384}, CipherParams{"E3C08A8F06C6E3AD95A70557B23F75483CE33021A9C72B7025666204C69C0B72","12153524C0895E81B2C28465", 0,"D609B1F056637A0D46DF998D88E52E00B2C2846512153524C0895E81","08000F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F303132333435363738393A0002","E2006EB42F5277022D9B19925BC419D7A592666C925FE2EF718EB4E308EFEAA7C5273B394118860A5BE2A97F56AB78365CA597CDBB3EDB8D1A1151EA1AF7B436", false, CipherSuite::TLS_AES_256_GCM_SHA384})
	)

Referenced by TEST_P().

fizz::test::INSTANTIATE_TEST_CASE_P	(	SignatureSchemes	,
		SigSchemeTest	,
		::testing::Values(SignatureScheme::rsa_pss_sha256, SignatureScheme::ecdsa_secp256r1_sha256, SignatureScheme::ecdsa_secp384r1_sha384, SignatureScheme::ecdsa_secp521r1_sha512)
	)

Referenced by TEST_F().

fizz::test::MATCHER_P	(	BufMatches	,
		expected	,
		""
	)

Definition at line 17 of file Matchers.h.

References folly::IOBuf::copyBuffer().

                                    {
  return folly::IOBufEqualTo()(folly::IOBuf::copyBuffer(expected), arg);
}

fizz::test::MATCHER_P	(	RangeMatches	,
		expected	,
		""
	)

Definition at line 21 of file Matchers.h.

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

                                      {
  folly::StringPiece exp(expected);
  return exp.size() == arg.size() &&
      (exp.size() == 0 || memcmp(exp.data(), arg.data(), exp.size()) == 0);
}

fizz::test::MATCHER_P	(	WriteNewSessionTicketMatches	,
		expected	,
		""
	)

Definition at line 36 of file FizzBaseTest.cpp.

References folly::IOBuf::copyBuffer().

                                                      {
  return IOBufEqualTo()(IOBuf::copyBuffer(expected), arg.appToken);
}

fizz::test::MATCHER_P	(	WriteMatches	,
		expected	,
		""
	)

Definition at line 40 of file FizzBaseTest.cpp.

References folly::IOBuf::copyBuffer().

                                      {
  return IOBufEqualTo()(IOBuf::copyBuffer(expected), arg.data);
}

void fizz::test::setPoint	(	EcKeyUniquePtr &	key,
		std::string	x,
		std::string	y
	)

Definition at line 196 of file ECKeyExchangeTest.cpp.

References uint8_t, and folly::unhexlify().

Referenced by getKey(), and TEST_P().

                                                             {
  auto binX = unhexlify(x);
  auto binY = unhexlify(y);
  BIGNUMUniquePtr numX(BN_bin2bn((uint8_t*)binX.data(), binX.size(), nullptr));
  BIGNUMUniquePtr numY(BN_bin2bn((uint8_t*)binY.data(), binY.size(), nullptr));
  EC_KEY_set_public_key_affine_coordinates(key.get(), numX.get(), numY.get());
}

fizz::test::TEST	(	UtilsTest	,
		TestEqualWrongSize
	)

Definition at line 19 of file UtilsTest.cpp.

References a, b, and EXPECT_FALSE.

                                    {
  StringPiece a{"hi"};
  StringPiece b{"hello"};
  EXPECT_FALSE(CryptoUtils::equal(a, b));
  EXPECT_FALSE(CryptoUtils::equal(b, a));
}

fizz::test::TEST	(	IOBufUtilTest	,
		TrimBytes
	)

Definition at line 19 of file IOBufUtilTest.cpp.

References folly::Range< Iter >::castToConst(), folly::IOBuf::copyBuffer(), folly::IOBuf::create(), folly::eq, EXPECT_EQ, EXPECT_TRUE, and fizz::trimBytes().

                               {
  auto buf = IOBuf::copyBuffer("hello");
  buf->prependChain(IOBuf::copyBuffer("world"));
  buf->prependChain(IOBuf::copyBuffer("I"));
  buf->prependChain(IOBuf::create(0));
  buf->prependChain(IOBuf::copyBuffer("speak"));

  auto expected = IOBuf::copyBuffer("Ispeak");
  auto bufExpected = IOBuf::copyBuffer("helloworld");
  auto bufLen = buf->computeChainDataLength();
  constexpr size_t trimLen = 6;
  std::array<uint8_t, trimLen> trimData;
  folly::MutableByteRange trim(trimData);
  trimBytes(*buf, trim);

  IOBufEqualTo eq;
  EXPECT_EQ(expected->coalesce(), trim.castToConst());
  EXPECT_EQ(bufLen - trimLen, buf->computeChainDataLength());
  EXPECT_TRUE(eq(bufExpected, buf));
}

fizz::test::TEST	(	X25519KeyExchange	,
		KeyExchange
	)

Definition at line 20 of file X25519KeyExchangeTest.cpp.

References fizz::X25519KeyExchange::generateKeyPair(), fizz::X25519KeyExchange::generateSharedSecret(), folly::range(), and folly::unhexlify().

                                     {
  static constexpr StringPiece keyShareHex =
      "c81e57c7485ba417280bc2d48d864afd3966ff77b684bfaf85f418f9b4583347";
  auto keyShare = unhexlify(keyShareHex);
  X25519KeyExchange kex;
  kex.generateKeyPair();
  auto out = kex.generateSharedSecret(folly::range(keyShare));
}

fizz::test::TEST	(	RandomGeneratorTest	,
		TestRandom
	)

Definition at line 20 of file RandomGeneratorTest.cpp.

References EXPECT_EQ, random(), and useMockRandom().

                                      {
  useMockRandom();

  auto random = RandomGenerator<32>().generateRandom();
  std::array<uint8_t, 32> expected;
  expected.fill(0x44);
  EXPECT_EQ(random, expected);
}

fizz::test::TEST	(	ValidateECKey	,
		GoodPrivateKey
	)

Definition at line 22 of file OpenSSLKeyUtilsTest.cpp.

References getPrivateKey(), kP256Key, and fizz::detail::validateECKey().

                                    {
  auto key = getPrivateKey(kP256Key);
  detail::validateECKey(key, NID_X9_62_prime256v1);
}

fizz::test::TEST	(	UtilTest	,
		GetAlpnFromNpn
	)

Definition at line 23 of file FizzUtilTest.cpp.

References folly::test::begin(), folly::test::end(), and EXPECT_EQ.

                               {
  std::list<folly::SSLContext::NextProtocolsItem> npList;
  std::list<std::string> protocolList1{"test", "test2"};
  std::list<std::string> protocolList2{"test3", "test4"};

  npList.push_back(folly::SSLContext::NextProtocolsItem(1, protocolList1));
  {
    std::vector<std::string> expectedList{std::begin(protocolList1),
                                          std::end(protocolList1)};
    EXPECT_EQ(FizzUtil::getAlpnsFromNpnList(npList), expectedList);
  }

  npList.push_back(folly::SSLContext::NextProtocolsItem(2, protocolList2));
  {
    std::vector<std::string> expectedList{std::begin(protocolList2),
                                          std::end(protocolList2)};
    EXPECT_EQ(FizzUtil::getAlpnsFromNpnList(npList), expectedList);
  }
}

fizz::test::TEST	(	ExporterTest	,
		TestExporterBasic
	)

Definition at line 24 of file ExporterTest.cpp.

References fizz::extensions::test::ekm, EXPECT_EQ, and folly::unhexlify().

                                      {
  auto ekm = Exporter::getEkm(
      CipherSuite::TLS_AES_128_GCM_SHA256,
      folly::Range<const char*>(exporter_master),
      label,
      nullptr,
      32);

  EXPECT_EQ(StringPiece(ekm->coalesce()), unhexlify(basic_expected_ekm));
}

fizz::test::TEST	(	UtilsTest	,
		TestEqual
	)

Definition at line 26 of file UtilsTest.cpp.

References a, b, c, EXPECT_FALSE, and EXPECT_TRUE.

                           {
  StringPiece a{"hello!!"};
  StringPiece b{"hello!!"};
  StringPiece c{"goodbye"};
  EXPECT_TRUE(CryptoUtils::equal(a, b));
  EXPECT_FALSE(CryptoUtils::equal(a, c));
}

fizz::test::TEST	(	TestTypes	,
		WriteAndRead24BitsNormal
	)

Definition at line 26 of file TypesTest.cpp.

References folly::IOBuf::create(), EXPECT_EQ, fizz::detail::readBits24(), uint32_t, and fizz::detail::writeBits24().

                                          {
  uint32_t len = 0x102030;
  auto buf = IOBuf::create(3);
  Appender appender(buf.get(), 0);
  detail::writeBits24(len, appender);

  EXPECT_EQ(0x10, buf->data()[0]);
  EXPECT_EQ(0x20, buf->data()[1]);
  EXPECT_EQ(0x30, buf->data()[2]);

  Cursor cursor(buf.get());
  uint32_t actualLength = detail::readBits24(cursor);
  EXPECT_EQ(len, actualLength);
}

fizz::test::TEST	(	ValidateECKey	,
		GoodPubicKey
	)

Definition at line 27 of file OpenSSLKeyUtilsTest.cpp.

References getPublicKey(), kP256PublicKey, and fizz::detail::validateECKey().

                                  {
  auto key = getPublicKey(kP256PublicKey);
  detail::validateECKey(key, NID_X9_62_prime256v1);
}

fizz::test::TEST	(	X25519KeyExchange	,
		SmallKeyExchange
	)

Definition at line 29 of file X25519KeyExchangeTest.cpp.

References EXPECT_THROW, fizz::X25519KeyExchange::generateKeyPair(), fizz::X25519KeyExchange::generateSharedSecret(), folly::range(), and folly::unhexlify().

                                          {
  static constexpr StringPiece keyShareHex = "c81e57c7485ba4";
  auto keyShare = unhexlify(keyShareHex);
  X25519KeyExchange kex;
  kex.generateKeyPair();
  EXPECT_THROW(
      kex.generateSharedSecret(folly::range(keyShare)), std::runtime_error);
}

fizz::test::TEST	(	RandomGeneratorTest	,
		TestRandomUInt32
	)

Definition at line 29 of file RandomGeneratorTest.cpp.

References EXPECT_EQ, random(), and useMockRandom().

                                            {
  useMockRandom();

  auto random = RandomNumGenerator<uint32_t>().generateRandom();
  EXPECT_EQ(random, 0x44444444);
}

fizz::test::TEST	(	ValidateECKey	,
		WrongKeyType
	)

Definition at line 32 of file OpenSSLKeyUtilsTest.cpp.

References EXPECT_THROW, getPrivateKey(), kRSAKey, and fizz::detail::validateECKey().

                                  {
  auto key = getPrivateKey(kRSAKey);
  EXPECT_THROW(
      detail::validateECKey(key, NID_X9_62_prime256v1), std::runtime_error);
}

fizz::test::TEST	(	UtilsTest	,
		TestClean
	)

Definition at line 34 of file UtilsTest.cpp.

References a, EXPECT_EQ, and folly::range().

                           {
  std::array<uint8_t, 8> a{'p', 'a', 's', 's', 'w', 'o', 'r', 'd'};
  CryptoUtils::clean(range(a));
  for (auto byte : a) {
    EXPECT_EQ(byte, 0);
  }
}

fizz::test::TEST	(	ValidateECKey	,
		WrongCurve
	)

Definition at line 38 of file OpenSSLKeyUtilsTest.cpp.

References EXPECT_THROW, getPrivateKey(), kP256Key, and fizz::detail::validateECKey().

                                {
  auto key = getPrivateKey(kP256Key);
  EXPECT_THROW(
      detail::validateECKey(key, NID_X9_62_prime239v3), std::runtime_error);
}

fizz::test::TEST	(	ExportedAuthenticatorTest	,
		TestAuthenticatorRequest
	)

Definition at line 39 of file ExportedAuthenticatorTest.cpp.

References folly::IOBuf::copyBuffer(), EXPECT_EQ, EXPECT_TRUE, folly::hexlify(), folly::gen::move, and folly::unhexlify().

                                                          {
  auto buf = folly::IOBuf::copyBuffer(unhexlify(expected_auth_request));
  folly::io::Cursor cursor(buf.get());
  CertificateRequest cr = decode<CertificateRequest>(cursor);
  EXPECT_EQ(cr.certificate_request_context->computeChainDataLength(), 20);
  EXPECT_EQ(cr.extensions.size(), 1);
  EXPECT_TRUE(getExtension<SignatureAlgorithms>(cr.extensions).hasValue());
  auto encodedAuthRequest = ExportedAuthenticator::getAuthenticatorRequest(
      std::move(cr.certificate_request_context), std::move(cr.extensions));
  EXPECT_EQ(
      expected_auth_request,
      StringPiece(hexlify(encodedAuthRequest->coalesce())));
}

fizz::test::TEST	(	IOBufUtilTest	,
		TransformBufferInplace
	)

Definition at line 40 of file IOBufUtilTest.cpp.

References folly::IOBuf::copyBuffer(), folly::IOBuf::create(), folly::eq, EXPECT_TRUE, fizz::transformBuffer(), and uint8_t.

                                            {
  auto buf = IOBuf::copyBuffer("hello");
  buf->prependChain(IOBuf::copyBuffer("world"));
  buf->prependChain(IOBuf::copyBuffer("I"));
  buf->prependChain(IOBuf::create(0));
  buf->prependChain(IOBuf::copyBuffer("speak"));

  auto expected = IOBuf::create(buf->computeChainDataLength());
  expected->append(buf->computeChainDataLength());
  memset(expected->writableData(), 'w', expected->length());

  transformBuffer(
      *buf, *buf, [](uint8_t* out, const uint8_t* /*in*/, size_t len) {
        memset(out, 'w', len);
      });
  IOBufEqualTo eq;
  EXPECT_TRUE(eq(expected, buf));
}

fizz::test::TEST	(	TestTypes	,
		Write24BitsOverflow
	)

Definition at line 41 of file TypesTest.cpp.

References folly::IOBuf::create(), EXPECT_THROW, uint32_t, and fizz::detail::writeBits24().

                                     {
  uint32_t len = 0x10203040;
  auto buf = IOBuf::create(3);
  Appender appender(buf.get(), 0);
  EXPECT_THROW(detail::writeBits24(len, appender), std::runtime_error);
}

fizz::test::TEST	(	UtilTest	,
		CreateTickerCipher
	)

Definition at line 43 of file FizzUtilTest.cpp.

References cipher, EXPECT_EQ, and folly::gen::move.

                                   {
  auto cipher = FizzUtil::createTicketCipher<server::AES128TicketCipher>(
      std::vector<std::string>(),
      "fakeSecretttttttttttttttttttttttttt",
      std::vector<std::string>(),
      // any number high enough to last the duration of the test should be fine
      std::chrono::seconds(100),
      folly::Optional<std::string>("fakeContext"));
  {
    server::ResumptionState state;
    auto blob = cipher->encrypt(std::move(state)).get();
    EXPECT_EQ(
        std::get<0>(cipher->decrypt(std::move(std::get<0>(*blob))).get()),
        PskType::Resumption);
  }
  {
    auto newCipher = FizzUtil::createTicketCipher<server::AES128TicketCipher>(
        std::vector<std::string>(),
        "fakeSecrettttttttttttttttttttttttt2",
        std::vector<std::string>(),
        std::chrono::seconds(100),
        folly::Optional<std::string>("fakeContext"));
    server::ResumptionState state;
    auto blob = cipher->encrypt(std::move(state)).get();
    EXPECT_EQ(
        std::get<0>(newCipher->decrypt(std::move(std::get<0>(*blob))).get()),
        PskType::Rejected);
  }
}

fizz::test::TEST	(	TestTypes	,
		Write24BitsBuffer
	)

Definition at line 48 of file TypesTest.cpp.

References folly::IOBuf::create(), and EXPECT_EQ.

                                   {
  auto buf = IOBuf::create(0x1020);
  buf->append(0x1020);

  auto out = IOBuf::create(10);
  Appender appender(out.get(), 10);
  detail::writeBuf<detail::bits24>(buf, appender);
  EXPECT_EQ(buf->length() + 3, out->computeChainDataLength());
}

fizz::test::TEST	(	ExportedAuthenticatorTest	,
		TestEmptyAuthenticatorRequest
	)

Definition at line 53 of file ExportedAuthenticatorTest.cpp.

References folly::IOBuf::create(), EXPECT_THROW, and folly::gen::move.

                                                               {
  EXPECT_THROW(
      ExportedAuthenticator::getAuthenticatorRequest(
          nullptr, std::vector<fizz::Extension>()),
      FizzException);
  auto emptyContext = folly::IOBuf::create(0);
  EXPECT_THROW(
      ExportedAuthenticator::getAuthenticatorRequest(
          std::move(emptyContext), std::vector<fizz::Extension>()),
      FizzException);
}

fizz::test::TEST	(	TestTypes	,
		Write24BitsBufferOverflow
	)

Definition at line 58 of file TypesTest.cpp.

References folly::IOBuf::create(), EXPECT_THROW, and max.

                                           {
  auto buf = IOBuf::create(std::numeric_limits<uint32_t>::max());
  buf->append(std::numeric_limits<uint32_t>::max());

  auto out = IOBuf::create(10);
  Appender appender(out.get(), 0);
  EXPECT_THROW(
      detail::writeBuf<detail::bits24>(buf, appender), std::runtime_error);
}

fizz::test::TEST	(	IOBufUtilTest	,
		TransformBufferWithFragmentedBuffer
	)

Definition at line 65 of file IOBufUtilTest.cpp.

References folly::IOBuf::copyBuffer(), folly::IOBuf::create(), createBuf(), folly::eq, EXPECT_TRUE, folly::gen::move, fizz::transformBuffer(), and uint8_t.

                                                         {
  auto buf = IOBuf::copyBuffer("hello");
  buf->prependChain(IOBuf::copyBuffer("world"));
  buf->prependChain(IOBuf::copyBuffer("I"));
  buf->prependChain(IOBuf::create(0));
  buf->prependChain(IOBuf::copyBuffer("speak"));

  // needs to add up to 16
  auto fragmented = createBuf(3);
  auto fragment1 = createBuf(6);
  auto fragment2 = createBuf(0);
  auto fragment3 = createBuf(2);
  auto fragment4 = createBuf(4);
  auto fragment5 = createBuf(1);

  fragmented->prependChain(std::move(fragment1));
  fragmented->prependChain(std::move(fragment2));
  fragmented->prependChain(std::move(fragment3));
  fragmented->prependChain(std::move(fragment4));
  fragmented->prependChain(std::move(fragment5));

  transformBuffer(
      *buf, *fragmented, [](uint8_t* out, const uint8_t* in, size_t len) {
        memcpy(out, in, len);
      });
  IOBufEqualTo eq;
  EXPECT_TRUE(eq(buf, fragmented));
}

fizz::test::TEST	(	TestTypes	,
		WriteBuf
	)

Definition at line 68 of file TypesTest.cpp.

References folly::IOBuf::create(), and EXPECT_EQ.

                          {
  auto buf = IOBuf::create(20);
  buf->append(20);

  auto out1 = IOBuf::create(10);
  Appender appender1(out1.get(), 10);
  detail::writeBuf<uint16_t>(buf, appender1);
  EXPECT_EQ(2 + buf->length(), out1->computeChainDataLength());

  auto out2 = IOBuf::create(10);
  Appender appender2(out2.get(), 10);
  detail::writeBuf<uint64_t>(buf, appender2);
  EXPECT_EQ(8 + buf->length(), out2->computeChainDataLength());
}

fizz::test::TEST	(	UtilTest	,
		ReadPKey
	)

Definition at line 73 of file FizzUtilTest.cpp.

References EXPECT_THROW, kP256Key, folly::test::TemporaryFile::path(), and folly::writeFileAtomic().

                         {
  {
    folly::test::TemporaryFile testFile("test");
    folly::writeFileAtomic(testFile.path().native(), kP256Key);
    FizzUtil::readPrivateKey(testFile.path().native(), "");
  }
  {
    folly::test::TemporaryFile testFile("test");
    folly::writeFileAtomic(
        testFile.path().native(), folly::StringPiece("test"));
    EXPECT_THROW(
        FizzUtil::readPrivateKey(testFile.path().native(), ""),
        std::runtime_error);
  }
}

fizz::test::TEST	(	UtilTest	,
		ReadChainFile
	)

Definition at line 89 of file FizzUtilTest.cpp.

References EXPECT_EQ, EXPECT_THROW, kP256Certificate, kP384Key, folly::test::TemporaryFile::path(), folly::size(), and folly::writeFileAtomic().

                              {
  {
    folly::test::TemporaryFile testFile("test");
    folly::writeFileAtomic(testFile.path().native(), kP256Certificate);
    EXPECT_EQ(FizzUtil::readChainFile(testFile.path().native()).size(), 1);
  }
  {
    folly::test::TemporaryFile testFile("test");
    folly::writeFileAtomic(testFile.path().native(), kP384Key);
    EXPECT_THROW(
        FizzUtil::readChainFile(testFile.path().native()), std::runtime_error);
  }
  {
    EXPECT_THROW(
        FizzUtil::readChainFile("test_file_does_not_exist"),
        std::runtime_error);
  }
}

fizz::test::TEST	(	ContextTest	,
		TestAscendingVersionsNotSet
	)

Definition at line 93 of file TokenBindingTest.cpp.

References EXPECT_EQ, EXPECT_THROW, fizz::extensions::TokenBindingContext::getSupportedVersions(), fizz::extensions::TokenBindingContext::setSupportedVersions(), fizz::extensions::token_binding_0_10, fizz::extensions::token_binding_0_11, and fizz::extensions::token_binding_0_12.

                                               {
  std::vector<TokenBindingProtocolVersion> ascending{
      TokenBindingProtocolVersion::token_binding_0_10,
      TokenBindingProtocolVersion::token_binding_0_11,
      TokenBindingProtocolVersion::token_binding_0_12};
  TokenBindingContext ctx;
  auto before = ctx.getSupportedVersions();
  EXPECT_THROW(ctx.setSupportedVersions(ascending), std::runtime_error);
  auto after = ctx.getSupportedVersions();
  EXPECT_EQ(before, after);
}

fizz::test::TEST	(	ContextTest	,
		TestShuffledNotSet
	)

Definition at line 105 of file TokenBindingTest.cpp.

References EXPECT_EQ, EXPECT_THROW, fizz::extensions::TokenBindingContext::getSupportedVersions(), fizz::extensions::TokenBindingContext::setSupportedVersions(), fizz::extensions::token_binding_0_10, fizz::extensions::token_binding_0_12, and fizz::extensions::token_binding_0_13.

                                      {
  std::vector<TokenBindingProtocolVersion> shuffled{
      TokenBindingProtocolVersion::token_binding_0_10,
      TokenBindingProtocolVersion::token_binding_0_13,
      TokenBindingProtocolVersion::token_binding_0_12};
  TokenBindingContext ctx;
  auto before = ctx.getSupportedVersions();
  EXPECT_THROW(ctx.setSupportedVersions(shuffled), std::runtime_error);
  auto after = ctx.getSupportedVersions();
  EXPECT_EQ(before, after);
}

fizz::test::TEST	(	CertTest	,
		GetIdentity
	)

Definition at line 111 of file CertTest.cpp.

References fizz::certificate, EXPECT_EQ, fizz::SelfCertImpl< T >::getAltIdentities(), getCert(), fizz::SelfCertImpl< T >::getIdentity(), getPrivateKey(), kP256Certificate, kP256Key, and folly::gen::move.

                            {
  auto cert = getCert(kP256Certificate);
  auto key = getPrivateKey(kP256Key);
  std::vector<folly::ssl::X509UniquePtr> certs;
  certs.push_back(std::move(cert));
  SelfCertImpl<KeyType::P256> certificate(std::move(key), std::move(certs));
  EXPECT_EQ(certificate.getIdentity(), "Fizz");
  EXPECT_EQ(certificate.getAltIdentities().size(), 0);
}

fizz::test::TEST	(	ContextTest	,
		TestDoubleNotSet
	)

Definition at line 117 of file TokenBindingTest.cpp.

References EXPECT_EQ, EXPECT_THROW, fizz::extensions::TokenBindingContext::getSupportedVersions(), fizz::extensions::TokenBindingContext::setSupportedVersions(), fizz::extensions::token_binding_0_10, and fizz::extensions::token_binding_0_11.

                                    {
  std::vector<TokenBindingProtocolVersion> two{
      TokenBindingProtocolVersion::token_binding_0_10,
      TokenBindingProtocolVersion::token_binding_0_11};
  TokenBindingContext ctx;
  auto before = ctx.getSupportedVersions();
  EXPECT_THROW(ctx.setSupportedVersions(two), std::runtime_error);
  auto after = ctx.getSupportedVersions();
  EXPECT_EQ(before, after);
}

fizz::test::TEST	(	CertTest	,
		GetAltIdentity
	)

Definition at line 121 of file CertTest.cpp.

References fizz::certificate, EXPECT_EQ, fizz::SelfCertImpl< T >::getAltIdentities(), getCert(), fizz::SelfCertImpl< T >::getIdentity(), getPrivateKey(), kRSACertificate, kRSAKey, and folly::gen::move.

                               {
  auto cert = getCert(kRSACertificate);
  auto key = getPrivateKey(kRSAKey);
  std::vector<folly::ssl::X509UniquePtr> certs;
  certs.push_back(std::move(cert));
  SelfCertImpl<KeyType::RSA> certificate(std::move(key), std::move(certs));
  EXPECT_EQ(certificate.getIdentity(), "Fizz");
  auto alts = certificate.getAltIdentities();
  EXPECT_EQ(alts.size(), 3);
  EXPECT_EQ(alts[0], "*.fizz.com");
  EXPECT_EQ(alts[1], "fizz.com");
  EXPECT_EQ(alts[2], "example.net");
}

fizz::test::TEST	(	ContextTest	,
		TestEmptySet
	)

Definition at line 128 of file TokenBindingTest.cpp.

References folly::empty(), EXPECT_EQ, fizz::extensions::TokenBindingContext::getSupportedVersions(), and fizz::extensions::TokenBindingContext::setSupportedVersions().

                                {
  std::vector<TokenBindingProtocolVersion> empty;
  TokenBindingContext ctx;
  ctx.setSupportedVersions(empty);
  auto after = ctx.getSupportedVersions();
  EXPECT_EQ(empty, after);
}

fizz::test::TEST	(	IOBufUtilTest	,
		TransformBufferBlocks
	)

Definition at line 129 of file IOBufUtilTest.cpp.

References fizz::test::BlockWriter::copy(), folly::IOBuf::copyBuffer(), createBuf(), folly::eq, EXPECT_TRUE, gmock_output_test::output, and uint8_t.

                                           {
  // 2 blocks of size 8
  auto buf = IOBuf::copyBuffer("0000111122223333");
  auto output = createBuf(16);

  BlockWriter writer;
  transformBufferBlocks<8>(
      *buf, *output, [&writer](uint8_t* out, const uint8_t* in, size_t len) {
        return writer.copy(out, in, len);
      });
  IOBufEqualTo eq;
  EXPECT_TRUE(eq(buf, output));
}

fizz::test::TEST	(	CertTest	,
		GetCertMessage
	)

Definition at line 135 of file CertTest.cpp.

References ASSERT_EQ, fizz::certificate, EXPECT_EQ, getCert(), fizz::SelfCertImpl< T >::getCertMessage(), getPrivateKey(), kP256Certificate, kP256Key, and folly::gen::move.

                               {
  auto cert = getCert(kP256Certificate);
  auto key = getPrivateKey(kP256Key);
  std::vector<folly::ssl::X509UniquePtr> certs;
  certs.push_back(std::move(cert));
  SelfCertImpl<KeyType::P256> certificate(std::move(key), std::move(certs));
  auto msg = certificate.getCertMessage();
  ASSERT_EQ(msg.certificate_list.size(), 1);
  auto& firstCertEntry = msg.certificate_list[0];
  auto firstCertData = firstCertEntry.cert_data->coalesce();
  auto firstCertDataPtr = firstCertData.data();
  folly::ssl::X509UniquePtr firstEncodedCert(
      d2i_X509(nullptr, &firstCertDataPtr, firstCertData.size()));
  CHECK(firstEncodedCert);

  auto certCopy = getCert(kP256Certificate);
  EXPECT_EQ(X509_cmp(firstEncodedCert.get(), certCopy.get()), 0);
}

fizz::test::TEST	(	ContextTest	,
		TestSingleSet
	)

Definition at line 136 of file TokenBindingTest.cpp.

References EXPECT_EQ, fizz::extensions::TokenBindingContext::getSupportedVersions(), fizz::extensions::TokenBindingContext::setSupportedVersions(), single, and fizz::extensions::token_binding_0_10.

                                 {
  std::vector<TokenBindingProtocolVersion> single{
      TokenBindingProtocolVersion::token_binding_0_10};
  TokenBindingContext ctx;
  ctx.setSupportedVersions(single);
  auto after = ctx.getSupportedVersions();
  EXPECT_EQ(single, after);
}

fizz::test::TEST	(	ExportedAuthenticatorTest	,
		TestGetContext
	)

Definition at line 138 of file ExportedAuthenticatorTest.cpp.

References folly::IOBuf::copyBuffer(), EXPECT_EQ, folly::hexlify(), folly::gen::move, and folly::unhexlify().

                                                {
  StringPiece authenticator = {
      "0b00020f14303132333435363738396162636465666768696a0001f70001f2308201ee30820195a003020102020900c569eec901ce86d9300a06082a8648ce3d0403023054310b3009060355040613025553310b300906035504080c024e59310b300906035504070c024e59310d300b060355040a0c0446697a7a310d300b060355040b0c0446697a7a310d300b06035504030c0446697a7a301e170d3137303430343138323930395a170d3431313132343138323930395a3054310b3009060355040613025553310b300906035504080c024e59310b300906035504070c024e59310d300b060355040a0c0446697a7a310d300b060355040b0c0446697a7a310d300b06035504030c0446697a7a3059301306072a8648ce3d020106082a8648ce3d030107034200049d87bcaddb65d8dcf6df8b148a9679b5b710db19c95a9badfff13468cb358b4e21d24a5c826112658ebb96d64e2985dfb41c1948334391a4aa81b67837e2dbf0a350304e301d0603551d0e041604143c5b8ba954d9752faf3c8ad6d1a62449dccaa850301f0603551d230418301680143c5b8ba954d9752faf3c8ad6d1a62449dccaa850300c0603551d13040530030101ff300a06082a8648ce3d04030203470030440220349b7d34d7132fb2756576e0bfa36cbe1723337a7a6f5ef9c8d3bf1aa7efa4a5022025c50a91e0aa4272f1f52c3d5583a7d7cee14b178835273a0bd814303e62d71400000f00004a04030046304402204ee36706cefd7b5de1b87eef8a756b1f69365451cae050163e030d7cb7594fbc022040aaadc7770b0404c5deb6fd9d9a2161423fb993a0a5b9e38f2c0e0d9183a52d1400002001dd31f46369c46fe41712e83ae7c46d31fdae816024edbb3b58cc29e2234852"};
  auto buf = folly::IOBuf::copyBuffer(unhexlify(authenticator));
  auto certRequestContext =
      ExportedAuthenticator::getAuthenticatorContext(std::move(buf));
  EXPECT_EQ(
      expected_cr_context,
      StringPiece(hexlify(certRequestContext->coalesce())));
}

fizz::test::TEST	(	IOBufUtilTest	,
		TransformBufferBlocksSplit
	)

Definition at line 143 of file IOBufUtilTest.cpp.

References fizz::test::BlockWriter::copy(), folly::IOBuf::copyBuffer(), createBuf(), folly::eq, EXPECT_TRUE, folly::gen::move, gmock_output_test::output, and uint8_t.

                                                {
  // 1 block of size 8
  auto buf = IOBuf::copyBuffer("0000");
  buf->prependChain(IOBuf::copyBuffer("1111"));
  auto output = createBuf(4);
  auto fragment1 = createBuf(4);
  output->prependChain(std::move(fragment1));

  BlockWriter writer;
  transformBufferBlocks<8>(
      *buf, *output, [&writer](uint8_t* out, const uint8_t* in, size_t len) {
        return writer.copy(out, in, len);
      });
  IOBufEqualTo eq;
  EXPECT_TRUE(eq(buf, output));
}

fizz::test::TEST	(	ContextTest	,
		TestDescendingVersionsSet
	)

Definition at line 145 of file TokenBindingTest.cpp.

References EXPECT_EQ, fizz::extensions::TokenBindingContext::getSupportedVersions(), fizz::extensions::TokenBindingContext::setSupportedVersions(), fizz::extensions::token_binding_0_10, fizz::extensions::token_binding_0_11, and fizz::extensions::token_binding_0_12.

                                             {
  std::vector<TokenBindingProtocolVersion> descending{
      TokenBindingProtocolVersion::token_binding_0_12,
      TokenBindingProtocolVersion::token_binding_0_11,
      TokenBindingProtocolVersion::token_binding_0_10};
  TokenBindingContext ctx;
  ctx.setSupportedVersions(descending);
  auto after = ctx.getSupportedVersions();
  EXPECT_EQ(descending, after);
}

fizz::test::TEST	(	CertTest	,
		PrepareSignData
	)

Definition at line 155 of file CertTest.cpp.

References EXPECT_EQ, folly::hexlify(), folly::range(), and string.

                                {
  std::array<uint8_t, 32> toBeSigned;
  memset(toBeSigned.data(), 1, toBeSigned.size());
  auto out = CertUtils::prepareSignData(
      CertificateVerifyContext::Server, folly::range(toBeSigned));
  auto hex = hexlify(out->moveToFbString());
  std::string expected =
      "2020202020202020202020202020202020202020202020202020202020202020"
      "2020202020202020202020202020202020202020202020202020202020202020"
      "544c5320312e332c207365727665722043657274696669636174655665726966"
      "79"
      "00"
      "0101010101010101010101010101010101010101010101010101010101010101";
  EXPECT_EQ(hex, expected);
}

fizz::test::TEST	(	ContextTest	,
		TestDoubleSet
	)

Definition at line 156 of file TokenBindingTest.cpp.

References EXPECT_EQ, fizz::extensions::TokenBindingContext::getSupportedVersions(), fizz::extensions::TokenBindingContext::setSupportedVersions(), fizz::extensions::token_binding_0_10, and fizz::extensions::token_binding_0_11.

                                 {
  std::vector<TokenBindingProtocolVersion> two{
      TokenBindingProtocolVersion::token_binding_0_11,
      TokenBindingProtocolVersion::token_binding_0_10};
  TokenBindingContext ctx;
  ctx.setSupportedVersions(two);
  auto after = ctx.getSupportedVersions();
  EXPECT_EQ(two, after);
}

fizz::test::TEST	(	IOBufUtilTest	,
		TransformBufferBlocksInputFragmented
	)

Definition at line 160 of file IOBufUtilTest.cpp.

References fizz::test::BlockWriter::copy(), folly::IOBuf::copyBuffer(), folly::IOBuf::create(), folly::eq, EXPECT_TRUE, gmock_output_test::output, and uint8_t.

                                                          {
  // do 3 blocks
  auto buf = IOBuf::copyBuffer("00");
  buf->prependChain(IOBuf::copyBuffer("00"));
  buf->prependChain(IOBuf::copyBuffer("1"));
  buf->prependChain(IOBuf::create(0));
  buf->prependChain(IOBuf::copyBuffer("11122223"));
  buf->prependChain(IOBuf::copyBuffer("33344"));
  buf->prependChain(IOBuf::copyBuffer("44"));
  buf->prependChain(IOBuf::copyBuffer("5555"));

  auto output = IOBuf::create(24);
  output->append(24);

  BlockWriter writer;
  transformBufferBlocks<8>(
      *buf, *output, [&writer](uint8_t* out, const uint8_t* in, size_t len) {
        return writer.copy(out, in, len);
      });
  IOBufEqualTo eq;
  EXPECT_TRUE(eq(buf, output));
}

fizz::test::TEST	(	ContextTest	,
		TestDescendingDuplicatesNotSet
	)

Definition at line 166 of file TokenBindingTest.cpp.

References EXPECT_EQ, EXPECT_THROW, fizz::extensions::TokenBindingContext::getSupportedVersions(), fizz::extensions::TokenBindingContext::setSupportedVersions(), fizz::extensions::token_binding_0_11, and fizz::extensions::token_binding_0_12.

                                                  {
  std::vector<TokenBindingProtocolVersion> duplicate{
      TokenBindingProtocolVersion::token_binding_0_12,
      TokenBindingProtocolVersion::token_binding_0_11,
      TokenBindingProtocolVersion::token_binding_0_11};
  TokenBindingContext ctx;
  auto before = ctx.getSupportedVersions();
  EXPECT_THROW(ctx.setSupportedVersions(duplicate), std::runtime_error);
  auto after = ctx.getSupportedVersions();
  EXPECT_EQ(before, after);
}

fizz::test::TEST	(	CertTest	,
		MakePeerCertEmpty
	)

Definition at line 171 of file CertTest.cpp.

References folly::IOBuf::copyBuffer(), and EXPECT_THROW.

                                  {
  EXPECT_THROW(
      CertUtils::makePeerCert(IOBuf::copyBuffer("")), std::runtime_error);
}

fizz::test::TEST	(	CertTest	,
		MakePeerCertJunk
	)

Definition at line 176 of file CertTest.cpp.

References folly::IOBuf::copyBuffer(), and EXPECT_THROW.

                                 {
  EXPECT_THROW(
      CertUtils::makePeerCert(IOBuf::copyBuffer("blah")), std::runtime_error);
}

fizz::test::TEST	(	CertTest	,
		PeerCertGetX509
	)

Definition at line 181 of file CertTest.cpp.

References EXPECT_NE, getCert(), fizz::PeerCertImpl< T >::getX509(), and kP256Certificate.

                                {
  PeerCertImpl<KeyType::P256> peerCert(getCert(kP256Certificate));
  auto x509 = peerCert.getX509();
  EXPECT_NE(x509.get(), nullptr);
}

fizz::test::TEST	(	IOBufUtilTest	,
		TransformBufferBlocksOutputFragmented
	)

Definition at line 183 of file IOBufUtilTest.cpp.

References fizz::test::BlockWriter::copy(), folly::IOBuf::copyBuffer(), createBuf(), folly::eq, EXPECT_TRUE, gmock_output_test::output, and uint8_t.

                                                           {
  // 3 blocks of 8
  auto buf = IOBuf::copyBuffer("fizzbuzzfizzbuzzfizzbuzz");

  // needs to add up to 24
  auto output = createBuf(3);
  output->prependChain(createBuf(6));
  output->prependChain(createBuf(0));
  output->prependChain(createBuf(2));
  output->prependChain(createBuf(4));
  output->prependChain(createBuf(1));
  output->prependChain(createBuf(1));
  output->prependChain(createBuf(7));

  BlockWriter writer;
  transformBufferBlocks<8>(
      *buf, *output, [&writer](uint8_t* out, const uint8_t* in, size_t len) {
        return writer.copy(out, in, len);
      });
  IOBufEqualTo eq;
  EXPECT_TRUE(eq(buf, output));
}

fizz::test::TEST	(	IOBufUtilTest	,
		TransformBufferBlocksInputFragmented2
	)

Definition at line 206 of file IOBufUtilTest.cpp.

References fizz::test::BlockWriter::copy(), folly::IOBuf::copyBuffer(), createBuf(), folly::eq, EXPECT_TRUE, gmock_output_test::output, and uint8_t.

                                                           {
  auto buf = IOBuf::copyBuffer("1111111122222222");
  auto output = createBuf(10);
  output->prependChain(createBuf(6));
  BlockWriter writer;
  transformBufferBlocks<8>(
      *buf, *output, [&writer](uint8_t* out, const uint8_t* in, size_t len) {
        return writer.copy(out, in, len);
      });
  IOBufEqualTo eq;
  EXPECT_TRUE(eq(buf, output));
}

fizz::test::TEST	(	IOBufUtilTest	,
		TransformBufferBlocksFragmented
	)

Definition at line 219 of file IOBufUtilTest.cpp.

References fizz::test::BlockWriter::copy(), folly::IOBuf::copyBuffer(), folly::IOBuf::create(), createBuf(), folly::eq, EXPECT_TRUE, gmock_output_test::output, and uint8_t.

                                                     {
  auto buf = IOBuf::copyBuffer("00");
  buf->prependChain(IOBuf::copyBuffer("00"));
  buf->prependChain(IOBuf::copyBuffer("1"));
  buf->prependChain(IOBuf::create(0));
  buf->prependChain(IOBuf::copyBuffer("11122223"));
  buf->prependChain(IOBuf::copyBuffer("33344"));
  buf->prependChain(IOBuf::copyBuffer("44"));
  buf->prependChain(IOBuf::copyBuffer("5555"));

  // needs to add up to 24
  auto output = createBuf(3);
  output->prependChain(createBuf(6));
  output->prependChain(createBuf(0));
  output->prependChain(createBuf(2));
  output->prependChain(createBuf(4));
  output->prependChain(createBuf(1));
  output->prependChain(createBuf(1));
  output->prependChain(createBuf(7));

  BlockWriter writer;
  transformBufferBlocks<8>(
      *buf, *output, [&writer](uint8_t* out, const uint8_t* in, size_t len) {
        return writer.copy(out, in, len);
      });
  IOBufEqualTo eq;
  EXPECT_TRUE(eq(buf, output));
}

fizz::test::TEST_F	(	HandshakeContextTest	,
		TestHandshakeContextSingle
	)

Definition at line 22 of file HandshakeContextTest.cpp.

References context, folly::IOBuf::copyBuffer(), fizz::kHkdfLabelPrefix, and folly::Range< Iter >::str().

                                                         {
  HandshakeContextImpl<Sha256> context(kHkdfLabelPrefix.str());
  context.appendToTranscript(folly::IOBuf::copyBuffer("ClientHello"));
  context.getHandshakeContext();
}

fizz::test::TEST_F	(	HandshakeContextTest	,
		TestHandshakeContextMultiple
	)

Definition at line 28 of file HandshakeContextTest.cpp.

References context, folly::IOBuf::copyBuffer(), fizz::kHkdfLabelPrefix, and folly::Range< Iter >::str().

                                                           {
  HandshakeContextImpl<Sha256> context(kHkdfLabelPrefix.str());
  context.appendToTranscript(folly::IOBuf::copyBuffer("ClientHello"));
  context.appendToTranscript(folly::IOBuf::copyBuffer("ServerHello"));
  context.getHandshakeContext();
}

fizz::test::TEST_F	(	ExtensionsTest	,
		TokenBindingParameters
	)

Definition at line 35 of file TokenBindingTest.cpp.

References fizz::extensions::ecdsap256, EXPECT_EQ, folly::gen::move, fizz::extensions::token_binding_0_13, and tokenBinding.

                                               {
  auto exts = getExtensions(tokenBinding);
  auto ext = getExtension<TokenBindingParameters>(exts);

  EXPECT_EQ(ext->version, TokenBindingProtocolVersion::token_binding_0_13);
  EXPECT_EQ(ext->key_parameters_list.size(), 1);
  EXPECT_EQ(ext->key_parameters_list[0], TokenBindingKeyParameters::ecdsap256);

  checkEncode(std::move(*ext), tokenBinding);
}

fizz::test::TEST_F	(	HandshakeContextTest	,
		TestFinished
	)

Definition at line 35 of file HandshakeContextTest.cpp.

References context, folly::IOBuf::copyBuffer(), fizz::kHkdfLabelPrefix, folly::range(), and folly::Range< Iter >::str().

                                           {
  HandshakeContextImpl<Sha256> context(kHkdfLabelPrefix.str());
  context.appendToTranscript(folly::IOBuf::copyBuffer("ClientHello"));
  std::vector<uint8_t> baseKey(Sha256::HashLen);
  context.getFinishedData(range(baseKey));
}

fizz::test::TEST_F	(	ExtensionsTest	,
		TestProtocolNameList
	)

Definition at line 36 of file ExtensionsTest.cpp.

References alpn, EXPECT_EQ, and folly::gen::move.

                                             {
  auto exts = getExtensions(alpn);
  auto ext = getExtension<ProtocolNameList>(exts);

  EXPECT_EQ(ext->protocol_name_list.size(), 3);
  EXPECT_EQ(
      StringPiece(ext->protocol_name_list[0].name->coalesce()),
      StringPiece("h2"));
  EXPECT_EQ(
      StringPiece(ext->protocol_name_list[1].name->coalesce()),
      StringPiece("spdy/3.1"));
  EXPECT_EQ(
      StringPiece(ext->protocol_name_list[2].name->coalesce()),
      StringPiece("http/1.1"));

  checkEncode(std::move(*ext), alpn);
}

fizz::test::TEST_F	(	KeySchedulerTest	,
		TestEarly
	)

Definition at line 38 of file KeySchedulerTest.cpp.

References testing::_, and EXPECT_CALL.

                                    {
  StringPiece psk{"psk"};
  EXPECT_CALL(*kd_, hkdfExtract(_, _));
  ks_->deriveEarlySecret(psk);
  EXPECT_CALL(*kd_, deriveSecret(_, _, _)).Times(4);
  ks_->getSecret(EarlySecrets::ExternalPskBinder, transcript_);
  ks_->getSecret(EarlySecrets::ResumptionPskBinder, transcript_);
  ks_->getSecret(EarlySecrets::ResumptionPskBinder, transcript_);
  ks_->getSecret(EarlySecrets::EarlyExporter, transcript_);

  EXPECT_CALL(*kd_, deriveSecret(_, _, _)).Times(1);
  EXPECT_CALL(*kd_, hkdfExtract(_, _));
  ks_->deriveHandshakeSecret();
  EXPECT_CALL(*kd_, deriveSecret(_, _, _)).Times(2);
  ks_->getSecret(HandshakeSecrets::ClientHandshakeTraffic, transcript_);
  ks_->getSecret(HandshakeSecrets::ServerHandshakeTraffic, transcript_);

  EXPECT_CALL(*kd_, deriveSecret(_, _, _)).Times(1);
  EXPECT_CALL(*kd_, hkdfExtract(_, _));
  ks_->deriveMasterSecret();
  EXPECT_CALL(*kd_, deriveSecret(_, _, _)).Times(2);
  ks_->getSecret(MasterSecrets::ExporterMaster, transcript_);
  ks_->getSecret(MasterSecrets::ResumptionMaster, transcript_);

  EXPECT_CALL(*kd_, deriveSecret(_, _, _)).Times(2);
  ks_->deriveAppTrafficSecrets(transcript_);
  ks_->getSecret(AppTrafficSecrets::ClientAppTraffic);
  ks_->getSecret(AppTrafficSecrets::ServerAppTraffic);
}

fizz::test::TEST_F	(	RSAPSSTest	,
		TestSignVerify
	)

Definition at line 38 of file RSAPSSSignatureTest.cpp.

References generateKey(), fizz::OpenSSLSignature< T >::setKey(), folly::sig, fizz::OpenSSLSignature< T >::sign(), and fizz::OpenSSLSignature< T >::verify().

                                   {
  OpenSSLSignature<KeyType::RSA> rsa;
  rsa.setKey(generateKey());
  static constexpr StringPiece msg{"message"};
  auto sig = rsa.sign<SignatureScheme::rsa_pss_sha256>(msg);
  rsa.verify<SignatureScheme::rsa_pss_sha256>(msg, sig->coalesce());
}

fizz::test::TEST_F	(	HandshakeContextTest	,
		TestEmpty
	)

Definition at line 42 of file HandshakeContextTest.cpp.

References context, fizz::kHkdfLabelPrefix, folly::range(), and folly::Range< Iter >::str().

                                        {
  HandshakeContextImpl<Sha256> context(kHkdfLabelPrefix.str());
  context.getHandshakeContext();
  std::array<uint8_t, Sha256::HashLen> key{4};
  context.getFinishedData(folly::range(key));
}

fizz::test::TEST_F	(	CertDecompressionManagerTest	,
		TestBasic
	)

Definition at line 43 of file CertDecompressionManagerTest.cpp.

References EXPECT_EQ.

                                                {
  auto decomp1 = makeMockDecompressor(1);
  auto decomp2 = makeMockDecompressor(2);

  manager_->setDecompressors(
      {std::static_pointer_cast<CertificateDecompressor>(decomp1),
       std::static_pointer_cast<CertificateDecompressor>(decomp2)});

  auto supported = manager_->getSupportedAlgorithms();
  EXPECT_EQ(supported.size(), 2);
  EXPECT_EQ(supported[0], toAlgo(1));
  EXPECT_EQ(supported[1], toAlgo(2));
  auto fetchedDecomp1 = manager_->getDecompressor(toAlgo(1));
  auto fetchedDecomp2 = manager_->getDecompressor(toAlgo(2));
  auto invalidDecomp = manager_->getDecompressor(toAlgo(3));
  EXPECT_EQ(decomp1, fetchedDecomp1);
  EXPECT_EQ(decomp2, fetchedDecomp2);
  EXPECT_EQ(invalidDecomp, nullptr);
}

fizz::test::TEST_F	(	ExtensionsTest	,
		TokenBindingMessageFromChrome
	)

Definition at line 46 of file TokenBindingTest.cpp.

References fizz::extensions::ecdsap256, fizz::encode(), EXPECT_EQ, EXPECT_TRUE, folly::gen::move, fizz::extensions::provided_token_binding, and tokenBindingMessage.

                                                      {
  auto buf = getBuf(tokenBindingMessage);
  auto message = decode<TokenBindingMessage>(std::move(buf));
  EXPECT_EQ(message.tokenbindings.size(), 1);
  auto& tokenbinding = message.tokenbindings.front();
  EXPECT_EQ(
      tokenbinding.tokenbinding_type, TokenBindingType::provided_token_binding);
  auto& id = tokenbinding.tokenbindingid;
  EXPECT_EQ(id.key_parameters, TokenBindingKeyParameters::ecdsap256);

  // 32 * 2 for the key + 1 for size of point
  EXPECT_EQ(id.key->computeChainDataLength(), 65);

  // No extensions
  EXPECT_EQ(tokenbinding.extensions->computeChainDataLength(), 0);

  // 32 * 2 for the signature with this algorithm
  EXPECT_EQ(tokenbinding.signature->computeChainDataLength(), 64);
  auto encodedBuf = encode(std::move(message));
  EXPECT_TRUE(folly::IOBufEqualTo()(encodedBuf, buf));
}

fizz::test::TEST_F	(	RSAPSSTest	,
		TestVerifyDifferent
	)

Definition at line 46 of file RSAPSSSignatureTest.cpp.

References EXPECT_THROW, generateKey(), fizz::OpenSSLSignature< T >::setKey(), folly::sig, fizz::OpenSSLSignature< T >::sign(), and fizz::OpenSSLSignature< T >::verify().

                                        {
  OpenSSLSignature<KeyType::RSA> rsa;
  rsa.setKey(generateKey());
  static constexpr StringPiece msg1{"message"};
  static constexpr StringPiece msg2{"somethingelse"};
  auto sig = rsa.sign<SignatureScheme::rsa_pss_sha256>(msg1);
  EXPECT_THROW(
      rsa.verify<SignatureScheme::rsa_pss_sha256>(msg2, sig->coalesce()),
      std::runtime_error);
}

fizz::test::TEST_F	(	PlaintextRecordTest	,
		TestReadEmpty
	)

Definition at line 49 of file PlaintextRecordTest.cpp.

References EXPECT_FALSE.

                                           {
  EXPECT_FALSE(read_.read(queue_).hasValue());
}

fizz::test::TEST_F	(	DefaultCertificateVerifierTest	,
		TestVerifySuccess
	)

Definition at line 50 of file DefaultCertificateVerifierTest.cpp.

References getPeerCert(), and verifier_.

                                                          {
  verifier_->verify({getPeerCert(leafCertAndKey_)});
}

fizz::test::TEST_F	(	PlaintextRecordTest	,
		TestReadHandshake
	)

Definition at line 53 of file PlaintextRecordTest.cpp.

References EXPECT_EQ, and EXPECT_TRUE.

                                               {
  addToQueue("16030100050123456789");
  auto msg = read_.read(queue_);
  EXPECT_EQ(msg->type, ContentType::handshake);
  expectSame(msg->fragment, "0123456789");
  EXPECT_TRUE(queue_.empty());
}

fizz::test::TEST_F	(	ExtensionsTest	,
		TestServerNameList
	)

Definition at line 54 of file ExtensionsTest.cpp.

References EXPECT_EQ, folly::gen::move, and sni.

                                           {
  auto exts = getExtensions(sni);
  auto ext = getExtension<ServerNameList>(exts);

  EXPECT_EQ(ext->server_name_list.size(), 1);
  EXPECT_EQ(ext->server_name_list[0].name_type, ServerNameType::host_name);
  EXPECT_EQ(
      StringPiece(ext->server_name_list[0].hostname->coalesce()),
      StringPiece("www.facebook.com"));

  checkEncode(std::move(*ext), sni);
}

fizz::test::TEST_F	(	DefaultCertificateVerifierTest	,
		TestVerifyWithIntermediates
	)

Definition at line 54 of file DefaultCertificateVerifierTest.cpp.

References createCert(), getPeerCert(), and verifier_.

                                                                    {
  auto subauth = createCert("subauth", true, &rootCertAndKey_);
  auto subleaf = createCert("subleaf", false, &subauth);
  verifier_->verify({getPeerCert(subleaf), getPeerCert(subauth)});
}

fizz::test::TEST_F	(	RSAPSSTest	,
		TestVerifyFailure
	)

Definition at line 57 of file RSAPSSSignatureTest.cpp.

References EXPECT_THROW, generateKey(), fizz::OpenSSLSignature< T >::setKey(), folly::sig, fizz::OpenSSLSignature< T >::sign(), and fizz::OpenSSLSignature< T >::verify().

                                      {
  OpenSSLSignature<KeyType::RSA> rsa;
  rsa.setKey(generateKey());
  static constexpr StringPiece msg{"message"};
  auto sig = rsa.sign<SignatureScheme::rsa_pss_sha256>(msg);
  sig->writableData()[1] ^= 0x2;
  EXPECT_THROW(
      rsa.verify<SignatureScheme::rsa_pss_sha256>(msg, sig->coalesce()),
      std::runtime_error);
}

fizz::test::TEST_F	(	RecordTest	,
		TestNoData
	)

Definition at line 59 of file RecordTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_FALSE, testing::InvokeWithoutArgs(), folly::none, and fizz::detail::read().

                               {
  EXPECT_CALL(read_, read(_)).WillOnce(InvokeWithoutArgs([]() {
    return none;
  }));
  EXPECT_FALSE(read_.readEvent(queue_).hasValue());
}

fizz::test::TEST_F	(	DefaultCertificateVerifierTest	,
		TestVerifySelfSignedCert
	)

Definition at line 60 of file DefaultCertificateVerifierTest.cpp.

References createCert(), EXPECT_THROW, and verifier_.

                                                                 {
  auto selfsigned = createCert("self", false, nullptr);
  EXPECT_THROW(
      verifier_->verify({getPeerCert(selfsigned)}), std::runtime_error);
}

fizz::test::TEST_F	(	PlaintextRecordTest	,
		TestReadAlert
	)

Definition at line 61 of file PlaintextRecordTest.cpp.

References EXPECT_EQ, and EXPECT_TRUE.

                                           {
  addToQueue("15030100050123456789");
  auto msg = read_.read(queue_);
  EXPECT_EQ(msg->type, ContentType::alert);
  expectSame(msg->fragment, "0123456789");
  EXPECT_TRUE(queue_.empty());
}

fizz::test::TEST_F	(	EncryptedRecordTest	,
		TestReadEmpty
	)

Definition at line 62 of file EncryptedRecordTest.cpp.

References EXPECT_FALSE.

                                           {
  EXPECT_FALSE(read_.read(queue_).hasValue());
}

fizz::test::TEST_F	(	CertDecompressionManagerTest	,
		TestSameOverwrites
	)

Definition at line 63 of file CertDecompressionManagerTest.cpp.

References EXPECT_EQ, and EXPECT_NE.

                                                         {
  auto decomp1 = makeMockDecompressor(1);
  auto decomp2 = makeMockDecompressor(1);
  auto decomp3 = makeMockDecompressor(2);

  manager_->setDecompressors(
      {std::static_pointer_cast<CertificateDecompressor>(decomp1),
       std::static_pointer_cast<CertificateDecompressor>(decomp2),
       std::static_pointer_cast<CertificateDecompressor>(decomp3)});

  auto supported = manager_->getSupportedAlgorithms();
  EXPECT_EQ(supported.size(), 2);
  EXPECT_EQ(supported[0], toAlgo(1));
  EXPECT_EQ(supported[1], toAlgo(2));
  auto fetchedDecomp1 = manager_->getDecompressor(toAlgo(1));
  auto fetchedDecomp2 = manager_->getDecompressor(toAlgo(2));
  EXPECT_EQ(decomp2, fetchedDecomp1);
  EXPECT_NE(decomp1, fetchedDecomp1);
  EXPECT_EQ(decomp3, fetchedDecomp2);
}

fizz::test::TEST_F	(	EncryptedRecordTest	,
		TestReadHandshake
	)

Definition at line 66 of file EncryptedRecordTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, testing::Invoke(), and uint64_t.

                                               {
  addToQueue("17030100050123456789");
  EXPECT_CALL(*readAead_, _decrypt(_, _, 0))
      .WillOnce(Invoke([](std::unique_ptr<IOBuf>& buf, const IOBuf*, uint64_t) {
        expectSame(buf, "0123456789");
        return getBuf("abcdef16");
      }));
  auto msg = read_.read(queue_);
  EXPECT_EQ(msg->type, ContentType::handshake);
  expectSame(msg->fragment, "abcdef");
  EXPECT_TRUE(queue_.empty());
}

fizz::test::TEST_F	(	RecordTest	,
		TestReadAppData
	)

Definition at line 66 of file RecordTest.cpp.

References testing::_, folly::IOBuf::copyBuffer(), EXPECT_CALL, EXPECT_TRUE, testing::InvokeWithoutArgs(), and fizz::detail::read().

                                    {
  EXPECT_CALL(read_, read(_)).WillOnce(InvokeWithoutArgs([]() {
    return TLSMessage{ContentType::application_data, IOBuf::copyBuffer("hi")};
  }));
  auto param = read_.readEvent(queue_);
  auto& appData = boost::get<AppData>(*param);
  EXPECT_TRUE(eq_(appData.data, IOBuf::copyBuffer("hi")));
}

fizz::test::TEST_F	(	DefaultCertificateVerifierTest	,
		TestVerifySelfSignedCertWithOverride
	)

Definition at line 66 of file DefaultCertificateVerifierTest.cpp.

References createCert(), getPeerCert(), and verifier_.

                                                                             {
  auto selfsigned = createCert("self", false, nullptr);
  verifier_->setCustomVerifyCallback(
      &DefaultCertificateVerifierTest::allowSelfSignedLeafCertCallback);
  // Will not throw because the override allows for this type of error.
  verifier_->verify({getPeerCert(selfsigned)});
}

fizz::test::TEST_F	(	ExtensionsTest	,
		TestHelloRetryRequestKeyShare
	)

Definition at line 67 of file ExtensionsTest.cpp.

References EXPECT_EQ, helloRetryRequestKeyShare, and folly::gen::move.

                                                      {
  auto exts = getExtensions(helloRetryRequestKeyShare);
  auto ext = getExtension<HelloRetryRequestKeyShare>(exts);

  EXPECT_EQ(ext->selected_group, NamedGroup::secp256r1);

  checkEncode(std::move(*ext), helloRetryRequestKeyShare);
}

fizz::test::TEST_F	(	KeySchedulerTest	,
		TestEarlyEcdhe
	)

Definition at line 68 of file KeySchedulerTest.cpp.

References testing::_, and EXPECT_CALL.

                                         {
  StringPiece psk{"psk"};
  EXPECT_CALL(*kd_, hkdfExtract(_, _));
  ks_->deriveEarlySecret(psk);
  EXPECT_CALL(*kd_, deriveSecret(_, _, _)).Times(4);
  ks_->getSecret(EarlySecrets::ExternalPskBinder, transcript_);
  ks_->getSecret(EarlySecrets::ResumptionPskBinder, transcript_);
  ks_->getSecret(EarlySecrets::ResumptionPskBinder, transcript_);
  ks_->getSecret(EarlySecrets::EarlyExporter, transcript_);

  StringPiece ecdhe{"ecdhe"};
  EXPECT_CALL(*kd_, deriveSecret(_, _, _)).Times(1);
  EXPECT_CALL(*kd_, hkdfExtract(_, _));
  ks_->deriveHandshakeSecret(ecdhe);
  EXPECT_CALL(*kd_, deriveSecret(_, _, _)).Times(2);
  ks_->getSecret(HandshakeSecrets::ClientHandshakeTraffic, transcript_);
  ks_->getSecret(HandshakeSecrets::ServerHandshakeTraffic, transcript_);

  EXPECT_CALL(*kd_, deriveSecret(_, _, _)).Times(1);
  EXPECT_CALL(*kd_, hkdfExtract(_, _));
  ks_->deriveMasterSecret();
  EXPECT_CALL(*kd_, deriveSecret(_, _, _)).Times(2);
  ks_->getSecret(MasterSecrets::ExporterMaster, transcript_);
  ks_->getSecret(MasterSecrets::ResumptionMaster, transcript_);

  EXPECT_CALL(*kd_, deriveSecret(_, _, _)).Times(2);
  ks_->deriveAppTrafficSecrets(transcript_);
  ks_->getSecret(AppTrafficSecrets::ClientAppTraffic);
  ks_->getSecret(AppTrafficSecrets::ServerAppTraffic);
}

fizz::test::TEST_F	(	ExtensionsTest	,
		TokenBindingMessageSelfCreated
	)

Definition at line 68 of file TokenBindingTest.cpp.

References folly::IOBuf::create(), fizz::encode(), EXPECT_EQ, fizz::extensions::TokenBinding::extensions, fizz::extensions::TokenBindingID::key_parameters, message, folly::gen::move, fizz::extensions::referred_token_binding, fizz::extensions::rsa2048_pkcs1_5, fizz::extensions::TokenBinding::signature, tokenBinding, fizz::extensions::TokenBinding::tokenbinding_type, fizz::extensions::TokenBinding::tokenbindingid, and fizz::extensions::TokenBindingMessage::tokenbindings.

                                                       {
  TokenBindingMessage message;
  TokenBinding tokenBinding;
  tokenBinding.tokenbinding_type = TokenBindingType::referred_token_binding;
  TokenBindingID id;
  id.key_parameters = TokenBindingKeyParameters::rsa2048_pkcs1_5;
  id.key = folly::IOBuf::create(10);
  tokenBinding.tokenbindingid = std::move(id);
  tokenBinding.signature = folly::IOBuf::create(10);
  tokenBinding.extensions = folly::IOBuf::create(10);
  message.tokenbindings.push_back(std::move(tokenBinding));

  auto encoded = encode(std::move(message));
  auto decoded = decode<TokenBindingMessage>(std::move(encoded));

  EXPECT_EQ(decoded.tokenbindings.size(), 1);
  auto& decodedTokenBinding = message.tokenbindings.front();
  auto& decodedId = decodedTokenBinding.tokenbindingid;
  EXPECT_EQ(
      decodedTokenBinding.tokenbinding_type,
      TokenBindingType::referred_token_binding);
  EXPECT_EQ(
      decodedId.key_parameters, TokenBindingKeyParameters::rsa2048_pkcs1_5);
}

fizz::test::TEST_F	(	PlaintextRecordTest	,
		TestReadAppData
	)

Definition at line 69 of file PlaintextRecordTest.cpp.

References EXPECT_ANY_THROW.

                                             {
  addToQueue("17030100050123456789");
  EXPECT_ANY_THROW(read_.read(queue_));
}

fizz::test::TEST_F	(	PlaintextRecordTest	,
		TestWaitForData
	)

Definition at line 74 of file PlaintextRecordTest.cpp.

References EXPECT_EQ, and EXPECT_FALSE.

                                             {
  addToQueue("160301000512345678");
  EXPECT_FALSE(read_.read(queue_).hasValue());
  EXPECT_EQ(queue_.chainLength(), 9);
}

fizz::test::TEST_F	(	DefaultCertificateVerifierTest	,
		TestVerifyWithIntermediateMissing
	)

Definition at line 74 of file DefaultCertificateVerifierTest.cpp.

References createCert(), EXPECT_THROW, and verifier_.

                                                                          {
  auto subauth = createCert("subauth", true, &rootCertAndKey_);
  auto subleaf = createCert("subleaf", false, &subauth);
  EXPECT_THROW(verifier_->verify({getPeerCert(subleaf)}), std::runtime_error);
}

fizz::test::TEST_F	(	RecordTest	,
		TestAlert
	)

Definition at line 75 of file RecordTest.cpp.

References testing::_, EXPECT_CALL, testing::InvokeWithoutArgs(), and fizz::detail::read().

                              {
  EXPECT_CALL(read_, read(_)).WillOnce(InvokeWithoutArgs([]() {
    return TLSMessage{ContentType::alert, getBuf("0202")};
  }));
  auto param = read_.readEvent(queue_);
  boost::get<Alert>(*param);
}

fizz::test::TEST_F	(	ExtensionsTest	,
		TestClientEarlyData
	)

Definition at line 76 of file ExtensionsTest.cpp.

References clientEarlyData, and folly::gen::move.

                                            {
  auto exts = getExtensions(clientEarlyData);
  auto ext = getExtension<ClientEarlyData>(exts);
  checkEncode(std::move(*ext), clientEarlyData);
}

fizz::test::TEST_F	(	EncryptedRecordTest	,
		TestReadAlert
	)

Definition at line 79 of file EncryptedRecordTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, testing::Invoke(), and uint64_t.

                                           {
  addToQueue("17030100050123456789");
  EXPECT_CALL(*readAead_, _decrypt(_, _, 0))
      .WillOnce(Invoke([](std::unique_ptr<IOBuf>& buf, const IOBuf*, uint64_t) {
        expectSame(buf, "0123456789");
        return getBuf("020215");
      }));
  auto msg = read_.read(queue_);
  EXPECT_EQ(msg->type, ContentType::alert);
  expectSame(msg->fragment, "0202");
  EXPECT_TRUE(queue_.empty());
}

fizz::test::TEST_F	(	PlaintextRecordTest	,
		TestWaitForHeader
	)

Definition at line 80 of file PlaintextRecordTest.cpp.

References EXPECT_EQ, and EXPECT_FALSE.

                                               {
  addToQueue("16030102");
  EXPECT_FALSE(read_.read(queue_).hasValue());
  EXPECT_EQ(queue_.chainLength(), 4);
}

fizz::test::TEST_F	(	DefaultCertificateVerifierTest	,
		TestVerifyWithIntermediateMissingWithOverride
	)

Definition at line 80 of file DefaultCertificateVerifierTest.cpp.

References createCert(), EXPECT_THROW, and verifier_.

                                                   {
  auto subauth = createCert("subauth", true, &rootCertAndKey_);
  auto subleaf = createCert("subleaf", false, &subauth);
  verifier_->setCustomVerifyCallback(
      &DefaultCertificateVerifierTest::allowSelfSignedLeafCertCallback);
  // The override is irrelevant to the error here. So exception is expected.
  EXPECT_THROW(verifier_->verify({getPeerCert(subleaf)}), std::runtime_error);
}

fizz::test::TEST_F	(	ExtensionsTest	,
		TestServerEarlyData
	)

Definition at line 82 of file ExtensionsTest.cpp.

References folly::gen::move, and serverEarlyData.

                                            {
  auto exts = getExtensions(serverEarlyData);
  auto ext = getExtension<ServerEarlyData>(exts);
  checkEncode(std::move(*ext), serverEarlyData);
}

fizz::test::TEST_F	(	RecordTest	,
		TestHandshake
	)

Definition at line 83 of file RecordTest.cpp.

References testing::_, EXPECT_CALL, fizz::finished, testing::InvokeWithoutArgs(), and fizz::detail::read().

                                  {
  EXPECT_CALL(read_, read(_)).WillOnce(InvokeWithoutArgs([]() {
    return TLSMessage{ContentType::handshake, getBuf("140000023232")};
  }));
  auto param = read_.readEvent(queue_);
  auto& finished = boost::get<Finished>(*param);
  expectSame(finished.verify_data, "3232");
  expectSame(*finished.originalEncoding, "140000023232");
}

fizz::test::TEST_F	(	PlaintextRecordTest	,
		TestMaxSize
	)

Definition at line 86 of file PlaintextRecordTest.cpp.

References EXPECT_EQ, and EXPECT_FALSE.

                                         {
  addToQueue("1603014000");
  EXPECT_FALSE(read_.read(queue_).hasValue());
  EXPECT_EQ(queue_.chainLength(), 5);
}

fizz::test::TEST_F	(	ExtensionsTest	,
		TestTicketEarlyData
	)

Definition at line 88 of file ExtensionsTest.cpp.

References EXPECT_EQ, folly::gen::move, and ticketEarlyData.

                                            {
  auto exts = getExtensions(ticketEarlyData);
  auto ext = getExtension<TicketEarlyData>(exts);
  EXPECT_EQ(ext->max_early_data_size, 5);
  checkEncode(std::move(*ext), ticketEarlyData);
}

fizz::test::TEST_F	(	DefaultCertificateVerifierTest	,
		TestVerifyWithBadIntermediate
	)

Definition at line 91 of file DefaultCertificateVerifierTest.cpp.

References createCert(), EXPECT_THROW, and verifier_.

                                                                      {
  auto subauth = createCert("badsubauth", false, &rootCertAndKey_);
  auto subleaf = createCert("badsubleaf", false, &subauth);
  EXPECT_THROW(verifier_->verify({getPeerCert(subleaf)}), std::runtime_error);
}

fizz::test::TEST_F	(	EncryptedRecordTest	,
		TestReadAppData
	)

Definition at line 92 of file EncryptedRecordTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, testing::Invoke(), and uint64_t.

                                             {
  addToQueue("17030100050123456789");
  EXPECT_CALL(*readAead_, _decrypt(_, _, 0))
      .WillOnce(Invoke([](std::unique_ptr<IOBuf>& buf, const IOBuf*, uint64_t) {
        expectSame(buf, "0123456789");
        return getBuf("1234abcd17");
      }));
  auto msg = read_.read(queue_);
  EXPECT_EQ(msg->type, ContentType::application_data);
  expectSame(msg->fragment, "1234abcd");
  EXPECT_TRUE(queue_.empty());
}

fizz::test::TEST_F	(	PlaintextRecordTest	,
		TestOverSize
	)

Definition at line 92 of file PlaintextRecordTest.cpp.

References EXPECT_ANY_THROW.

                                          {
  addToQueue("1603014001");
  EXPECT_ANY_THROW(read_.read(queue_));
}

fizz::test::TEST_F	(	RecordTest	,
		TestHandshakeTooLong
	)

Definition at line 93 of file RecordTest.cpp.

References testing::_, EXPECT_ANY_THROW, EXPECT_CALL, testing::InvokeWithoutArgs(), and fizz::detail::read().

                                         {
  EXPECT_CALL(read_, read(_)).WillOnce(InvokeWithoutArgs([]() {
    return TLSMessage{ContentType::handshake, getBuf("14400000")};
  }));
  EXPECT_ANY_THROW(read_.readEvent(queue_));
}

fizz::test::TEST_F	(	AuthenticatorTest	,
		TestValidAuthenticator
	)

Definition at line 94 of file ExportedAuthenticatorTest.cpp.

References testing::_, folly::IOBuf::copyBuffer(), EXPECT_CALL, EXPECT_EQ, folly::hexlify(), testing::InvokeWithoutArgs(), folly::gen::move, and testing::Return().

                                                  {
  auto mockCert = std::make_shared<MockSelfCert>();
  EXPECT_CALL(*mockCert, _getCertMessage(_)).WillOnce(InvokeWithoutArgs([]() {
    return TestMessages::certificate();
  }));
  EXPECT_CALL(*mockCert, getSigSchemes())
      .WillOnce(Return(std::vector<SignatureScheme>(
          1, SignatureScheme::ecdsa_secp256r1_sha256)));
  EXPECT_CALL(*mockCert, sign(_, CertificateVerifyContext::Authenticator, _))
      .WillOnce(
          InvokeWithoutArgs([]() { return IOBuf::copyBuffer("signature"); }));

  auto reencodedAuthenticator = ExportedAuthenticator::makeAuthenticator(
      deriver_,
      schemes_,
      *mockCert,
      std::move(authrequest_),
      std::move(handshakeContext_),
      std::move(finishedKey_),
      CertificateVerifyContext::Authenticator);
  EXPECT_EQ(
      expected_authenticator,
      (StringPiece(hexlify(reencodedAuthenticator->coalesce()))));
}

fizz::test::TEST_F	(	ExtensionsTest	,
		TestCookie
	)

Definition at line 95 of file ExtensionsTest.cpp.

References cookie, EXPECT_EQ, and folly::gen::move.

                                   {
  auto exts = getExtensions(cookie);
  auto ext = getExtension<Cookie>(exts);

  EXPECT_EQ(StringPiece(ext->cookie->coalesce()), StringPiece("cookie"));

  checkEncode(std::move(*ext), cookie);
}

fizz::test::TEST_F	(	PlaintextRecordTest	,
		TestEmpty
	)

Definition at line 97 of file PlaintextRecordTest.cpp.

References EXPECT_ANY_THROW.

                                       {
  addToQueue("1603010000aa");
  EXPECT_ANY_THROW(read_.read(queue_));
}

fizz::test::TEST_F	(	DefaultCertificateVerifierTest	,
		TestVerifyWithBadRoot
	)

Definition at line 97 of file DefaultCertificateVerifierTest.cpp.

References createCert(), EXPECT_THROW, and verifier_.

                                                              {
  auto newroot = createCert("root2", true, nullptr);
  auto subauth = createCert("subauth2", true, &newroot);
  auto subleaf = createCert("leaf2", false, &subauth);
  EXPECT_THROW(
      verifier_->verify({getPeerCert(subleaf), getPeerCert(subauth)}),
      std::runtime_error);
}

fizz::test::TEST_F	(	KeySchedulerTest	,
		TestNoEarly
	)

Definition at line 99 of file KeySchedulerTest.cpp.

References testing::_, and EXPECT_CALL.

                                      {
  StringPiece ecdhe{"ecdhe"};
  EXPECT_CALL(*kd_, deriveSecret(_, _, _)).Times(1);
  EXPECT_CALL(*kd_, hkdfExtract(_, _)).Times(2);
  ks_->deriveHandshakeSecret(ecdhe);
  EXPECT_CALL(*kd_, deriveSecret(_, _, _)).Times(2);
  ks_->getSecret(HandshakeSecrets::ClientHandshakeTraffic, transcript_);
  ks_->getSecret(HandshakeSecrets::ServerHandshakeTraffic, transcript_);

  EXPECT_CALL(*kd_, deriveSecret(_, _, _)).Times(1);
  EXPECT_CALL(*kd_, hkdfExtract(_, _));
  ks_->deriveMasterSecret();
  EXPECT_CALL(*kd_, deriveSecret(_, _, _)).Times(2);
  ks_->getSecret(MasterSecrets::ExporterMaster, transcript_);
  ks_->getSecret(MasterSecrets::ResumptionMaster, transcript_);

  EXPECT_CALL(*kd_, deriveSecret(_, _, _)).Times(2);
  ks_->deriveAppTrafficSecrets(transcript_);
  ks_->getSecret(AppTrafficSecrets::ClientAppTraffic);
  ks_->getSecret(AppTrafficSecrets::ServerAppTraffic);
}

fizz::test::TEST_F	(	RecordTest	,
		TestHandshakeFragmentedImmediate
	)

Definition at line 100 of file RecordTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_FALSE, fizz::finished, testing::InvokeWithoutArgs(), and fizz::detail::read().

                                                     {
  EXPECT_CALL(read_, read(_))
      .WillOnce(InvokeWithoutArgs([]() {
        return TLSMessage{ContentType::handshake, getBuf("14000008aabbccdd")};
      }))
      .WillOnce(InvokeWithoutArgs([]() {
        return TLSMessage{ContentType::handshake, getBuf("11223344")};
      }));
  auto param = read_.readEvent(queue_);
  EXPECT_FALSE(read_.hasUnparsedHandshakeData());
  auto& finished = boost::get<Finished>(*param);
  expectSame(finished.verify_data, "aabbccdd11223344");
}

fizz::test::TEST_F	(	PlaintextRecordTest	,
		TestDataRemaining
	)

Definition at line 102 of file PlaintextRecordTest.cpp.

References EXPECT_EQ.

                                               {
  addToQueue("16030100050123456789160301");
  auto msg = read_.read(queue_);
  EXPECT_EQ(msg->type, ContentType::handshake);
  expectSame(msg->fragment, "0123456789");
  EXPECT_EQ(queue_.chainLength(), 3);
  expectSame(queue_.move(), "160301");
}

fizz::test::TEST_F	(	ExtensionsTest	,
		TestCertificateAuthorities
	)

Definition at line 104 of file ExtensionsTest.cpp.

References authorities, EXPECT_EQ, and folly::gen::move.

                                                   {
  auto exts = getExtensions(authorities);
  auto ext = getExtension<CertificateAuthorities>(exts);

  EXPECT_EQ(ext->authorities.size(), 2);
  EXPECT_EQ(
      StringPiece(ext->authorities[0].encoded_name->coalesce()),
      StringPiece("CN=Liminality, OU=Fizz, O=Facebook, C=US"));
  EXPECT_EQ(
      StringPiece(ext->authorities[1].encoded_name->coalesce()),
      StringPiece("CN=Eternity, OU=Fizz, O=Facebook, C=US"));

  checkEncode(std::move(*ext), authorities);
}

fizz::test::TEST_F	(	EncryptedRecordTest	,
		TestReadUnknown
	)

Definition at line 105 of file EncryptedRecordTest.cpp.

References testing::_, EXPECT_ANY_THROW, EXPECT_CALL, testing::Invoke(), and uint64_t.

                                             {
  addToQueue("17030100050123456789");
  EXPECT_CALL(*readAead_, _decrypt(_, _, 0))
      .WillOnce(Invoke([](std::unique_ptr<IOBuf>& buf, const IOBuf*, uint64_t) {
        expectSame(buf, "0123456789");
        return getBuf("1234abcd20");
      }));
  EXPECT_ANY_THROW(read_.read(queue_));
}

fizz::test::TEST_F	(	HandshakeTypesTest	,
		ChloEncodeDecode
	)

Definition at line 106 of file HandshakeTypesTest.cpp.

References ASSERT_EQ, ASSERT_FALSE, ASSERT_TRUE, chlo, EXPECT_EQ, and folly::gen::move.

                                             {
  auto clientHello = decodeHex<ClientHello>(chlo);

  auto sigAlgs = getExtension<SignatureAlgorithms>(clientHello.extensions);
  ASSERT_TRUE(sigAlgs);
  const auto& schemes = sigAlgs->supported_signature_algorithms;
  ASSERT_EQ(11, schemes.size());
  ASSERT_FALSE(
      schemes.end() ==
      std::find(
          schemes.begin(),
          schemes.end(),
          SignatureScheme::ecdsa_secp256r1_sha256));

  auto groups = getExtension<SupportedGroups>(clientHello.extensions);
  const auto& groupNames = groups->named_group_list;
  ASSERT_EQ(3, groupNames.size());
  ASSERT_FALSE(
      groupNames.end() ==
      std::find(groupNames.begin(), groupNames.end(), NamedGroup::secp256r1));

  auto clientShares = getExtension<ClientKeyShare>(clientHello.extensions);
  ASSERT_TRUE(clientShares);
  ASSERT_EQ(2, clientShares->client_shares.size());

  ASSERT_FALSE(getExtension<ClientPresharedKey>(clientHello.extensions));
  ASSERT_FALSE(getExtension<ClientEarlyData>(clientHello.extensions));
  ASSERT_FALSE(getExtension<Cookie>(clientHello.extensions));

  auto reencoded = encodeHex(std::move(clientHello));
  EXPECT_EQ(chlo, reencoded);
}

fizz::test::TEST_F	(	PlaintextRecordTest	,
		TestSkipAndWait
	)

Definition at line 111 of file PlaintextRecordTest.cpp.

References EXPECT_FALSE, and EXPECT_TRUE.

                                             {
  read_.setSkipEncryptedRecords(true);
  addToQueue("17030100050123456789");
  EXPECT_FALSE(read_.read(queue_).hasValue());
  EXPECT_TRUE(queue_.empty());
}

fizz::test::TEST_F	(	RecordTest	,
		TestHandshakeFragmentedDelayed
	)

Definition at line 114 of file RecordTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_FALSE, EXPECT_TRUE, fizz::finished, testing::InvokeWithoutArgs(), folly::none, and fizz::detail::read().

                                                   {
  EXPECT_CALL(read_, read(_))
      .WillOnce(InvokeWithoutArgs([]() {
        return TLSMessage{ContentType::handshake, getBuf("14000008aabbccdd")};
      }))
      .WillOnce(InvokeWithoutArgs([]() { return folly::none; }));
  EXPECT_FALSE(read_.readEvent(queue_).hasValue());
  EXPECT_TRUE(read_.hasUnparsedHandshakeData());
  EXPECT_CALL(read_, read(_)).WillOnce(InvokeWithoutArgs([]() {
    return TLSMessage{ContentType::handshake, getBuf("11223344")};
  }));
  auto param = read_.readEvent(queue_);
  auto& finished = boost::get<Finished>(*param);
  expectSame(finished.verify_data, "aabbccdd11223344");
}

fizz::test::TEST_F	(	EncryptedRecordTest	,
		TestWaitForData
	)

Definition at line 115 of file EncryptedRecordTest.cpp.

References EXPECT_EQ, and EXPECT_FALSE.

                                             {
  addToQueue("1703010010012345");
  EXPECT_FALSE(read_.read(queue_).hasValue());
  EXPECT_EQ(queue_.chainLength(), 8);
}

fizz::test::TEST_F	(	PlaintextRecordTest	,
		TestWaitBeforeSkip
	)

Definition at line 118 of file PlaintextRecordTest.cpp.

References EXPECT_FALSE.

                                                {
  read_.setSkipEncryptedRecords(true);
  addToQueue("170301000501234567");
  EXPECT_FALSE(read_.read(queue_).hasValue());
  expectSame(queue_.move(), "170301000501234567");
}

fizz::test::TEST_F	(	AsyncFizzBaseTest	,
		TestIsFizz
	)

Definition at line 119 of file AsyncFizzBaseTest.cpp.

References EXPECT_EQ.

                                      {
  EXPECT_EQ(getSecurityProtocol(), "Fizz");
}

fizz::test::TEST_F	(	AuthenticatorTest	,
		TestEmptyAuthenticator
	)

Definition at line 119 of file ExportedAuthenticatorTest.cpp.

References EXPECT_CALL, EXPECT_EQ, folly::hexlify(), folly::gen::move, and testing::Return().

                                                  {
  auto mockCert = std::make_shared<MockSelfCert>();
  EXPECT_CALL(*mockCert, getSigSchemes())
      .WillOnce(Return(std::vector<SignatureScheme>(
          1, SignatureScheme::ecdsa_secp256r1_sha256)));
  schemes_.clear();
  auto reencodedAuthenticator = ExportedAuthenticator::makeAuthenticator(
      deriver_,
      schemes_,
      *mockCert,
      std::move(authrequest_),
      std::move(handshakeContext_),
      std::move(finishedKey_),
      CertificateVerifyContext::Authenticator);
  EXPECT_EQ(
      expected_empty_authenticator,
      StringPiece(hexlify(reencodedAuthenticator->coalesce())));
}

fizz::test::TEST_F	(	ExtensionsTest	,
		TestCertificateCompressionAlgorithms
	)

Definition at line 119 of file ExtensionsTest.cpp.

References certCompressionAlgorithms, EXPECT_EQ, and folly::gen::move.

                                                             {
  auto exts = getExtensions(certCompressionAlgorithms);
  auto ext = getExtension<CertificateCompressionAlgorithms>(exts);

  EXPECT_EQ(ext->algorithms.size(), 1);
  EXPECT_EQ(ext->algorithms[0], CertificateCompressionAlgorithm::zlib);
  checkEncode(std::move(*ext), certCompressionAlgorithms);
}

fizz::test::TEST_F	(	KeySchedulerTest	,
		TestKeyUpdate
	)

Definition at line 121 of file KeySchedulerTest.cpp.

References testing::_, EXPECT_CALL, and EXPECT_EQ.

                                        {
  StringPiece ecdhe{"ecdhe"};
  ks_->deriveHandshakeSecret(ecdhe);
  ks_->deriveMasterSecret();
  ks_->deriveAppTrafficSecrets(transcript_);

  EXPECT_CALL(*kd_, _expandLabel(_, _, _, _));
  EXPECT_EQ(ks_->clientKeyUpdate(), 1);
  EXPECT_CALL(*kd_, _expandLabel(_, _, _, _));
  EXPECT_EQ(ks_->clientKeyUpdate(), 2);

  EXPECT_CALL(*kd_, _expandLabel(_, _, _, _));
  EXPECT_EQ(ks_->serverKeyUpdate(), 1);
  EXPECT_CALL(*kd_, _expandLabel(_, _, _, _));
  EXPECT_EQ(ks_->serverKeyUpdate(), 2);
}

fizz::test::TEST_F	(	EncryptedRecordTest	,
		TestWaitForHeader
	)

Definition at line 121 of file EncryptedRecordTest.cpp.

References EXPECT_EQ, and EXPECT_FALSE.

                                               {
  addToQueue("16030102");
  EXPECT_FALSE(read_.read(queue_).hasValue());
  EXPECT_EQ(queue_.chainLength(), 4);
}

fizz::test::TEST_F	(	AsyncFizzBaseTest	,
		TestAppBytesWritten
	)

Definition at line 123 of file AsyncFizzBaseTest.cpp.

References folly::IOBuf::copyBuffer(), EXPECT_EQ, and folly::gen::move.

                                               {
  EXPECT_EQ(getAppBytesWritten(), 0);

  auto four = IOBuf::copyBuffer("4444");
  writeChain(nullptr, std::move(four));
  EXPECT_EQ(getAppBytesWritten(), 4);

  auto eight = IOBuf::copyBuffer("88888888");
  auto two = IOBuf::copyBuffer("22");
  eight->prependChain(std::move(two));
  writeChain(nullptr, std::move(eight));
  EXPECT_EQ(getAppBytesWritten(), 14);
}

fizz::test::TEST_F	(	PlaintextRecordTest	,
		TestSkipAndRead
	)

Definition at line 125 of file PlaintextRecordTest.cpp.

References EXPECT_EQ, and EXPECT_TRUE.

                                             {
  read_.setSkipEncryptedRecords(true);
  addToQueue("170301000501234567891703010005012345678916030100050123456789");
  auto msg = read_.read(queue_);
  EXPECT_EQ(msg->type, ContentType::handshake);
  expectSame(msg->fragment, "0123456789");
  EXPECT_TRUE(queue_.empty());
}

fizz::test::TEST_F	(	EncryptedRecordTest	,
		TestMaxSize
	)

Definition at line 127 of file EncryptedRecordTest.cpp.

References EXPECT_EQ, and EXPECT_FALSE.

                                         {
  addToQueue("1603014100");
  EXPECT_FALSE(read_.read(queue_).hasValue());
  EXPECT_EQ(queue_.chainLength(), 5);
}

fizz::test::TEST_F	(	ExtensionsTest	,
		TestBadlyFormedExtension
	)

Definition at line 128 of file ExtensionsTest.cpp.

References EXPECT_THROW, fizz::Extension::extension_data, fizz::Extension::extension_type, folly::gen::move, and sni.

                                                 {
  auto buf = getBuf(sni);
  buf->reserve(0, 1);
  buf->append(1);
  std::vector<Extension> exts;
  Extension ext;
  ext.extension_type = ExtensionType::server_name;
  ext.extension_data = std::move(buf);
  exts.push_back(std::move(ext));
  EXPECT_THROW(getExtension<ServerNameList>(exts), std::runtime_error);
}

fizz::test::TEST_F	(	RecordTest	,
		TestHandshakeCoalesced
	)

Definition at line 130 of file RecordTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_FALSE, EXPECT_TRUE, fizz::finished, testing::InvokeWithoutArgs(), and fizz::detail::read().

                                           {
  EXPECT_CALL(read_, read(_)).WillOnce(InvokeWithoutArgs([]() {
    return TLSMessage{ContentType::handshake,
                      getBuf("14000002aabb14000002ccdd")};
  }));
  auto param = read_.readEvent(queue_);
  auto& finished = boost::get<Finished>(*param);
  expectSame(finished.verify_data, "aabb");
  EXPECT_TRUE(read_.hasUnparsedHandshakeData());
  param = read_.readEvent(queue_);
  auto& finished2 = boost::get<Finished>(*param);
  expectSame(finished2.verify_data, "ccdd");
  EXPECT_FALSE(read_.hasUnparsedHandshakeData());
}

fizz::test::TEST_F	(	EncryptedRecordTest	,
		TestOverSize
	)

Definition at line 133 of file EncryptedRecordTest.cpp.

References EXPECT_ANY_THROW.

                                          {
  addToQueue("1603015000");
  EXPECT_ANY_THROW(read_.read(queue_));
}

fizz::test::TEST_F	(	PlaintextRecordTest	,
		TestWriteHandshake
	)

Definition at line 134 of file PlaintextRecordTest.cpp.

References folly::gen::move.

                                                {
  TLSMessage msg{ContentType::handshake, getBuf("1234567890")};
  auto buf = write_.write(std::move(msg));
  expectSame(buf.data, "16030300051234567890");
}

fizz::test::TEST_F	(	AsyncFizzBaseTest	,
		TestAppBytesReceived
	)

Definition at line 137 of file AsyncFizzBaseTest.cpp.

References folly::IOBuf::copyBuffer(), EXPECT_EQ, and folly::gen::move.

                                                {
  EXPECT_EQ(getAppBytesReceived(), 0);

  auto four = IOBuf::copyBuffer("4444");
  deliverAppData(std::move(four));
  EXPECT_EQ(getAppBytesReceived(), 4);

  auto eight = IOBuf::copyBuffer("88888888");
  auto two = IOBuf::copyBuffer("22");
  eight->prependChain(std::move(two));
  deliverAppData(std::move(eight));
  EXPECT_EQ(getAppBytesReceived(), 14);
}

fizz::test::TEST_F	(	KeySchedulerTest	,
		TestTrafficKey
	)

Definition at line 138 of file KeySchedulerTest.cpp.

References testing::_, and EXPECT_CALL.

                                         {
  EXPECT_CALL(*kd_, _expandLabel(_, _, _, _)).Times(2);
  StringPiece trafficSecret{"secret"};
  ks_->getTrafficKey(trafficSecret, 10, 10);
}

fizz::test::TEST_F	(	EncryptedRecordTest	,
		TestDataRemaining
	)

Definition at line 138 of file EncryptedRecordTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_EQ, testing::Invoke(), and uint64_t.

                                               {
  addToQueue("17030100050123456789aa");
  EXPECT_CALL(*readAead_, _decrypt(_, _, 0))
      .WillOnce(Invoke([](std::unique_ptr<IOBuf>& buf, const IOBuf*, uint64_t) {
        expectSame(buf, "0123456789");
        return getBuf("abcdef16");
      }));
  read_.read(queue_);
  EXPECT_EQ(queue_.chainLength(), 1);
}

fizz::test::TEST_F	(	HandshakeTypesTest	,
		SSL3ChloDecode
	)

Definition at line 139 of file HandshakeTypesTest.cpp.

References EXPECT_TRUE, and ssl3chlo.

                                           {
  auto clientHello = decodeHex<ClientHello>(ssl3chlo);
  EXPECT_TRUE(clientHello.extensions.empty());
}

fizz::test::TEST_F	(	PlaintextRecordTest	,
		TestWriteClientHello
	)

Definition at line 140 of file PlaintextRecordTest.cpp.

                                                  {
  auto buf = write_.writeInitialClientHello(getBuf("1234567890"));
  expectSame(buf.data, "16030100051234567890");
}

fizz::test::TEST_F	(	HandshakeTypesTest	,
		ChloDecidePsk
	)

Definition at line 144 of file HandshakeTypesTest.cpp.

References chloPsk, EXPECT_EQ, and fizz::getBinderLength().

                                          {
  auto clientHello = decodeHex<ClientHello>(chloPsk);

  EXPECT_EQ(35, getBinderLength(clientHello));
}

fizz::test::TEST_F	(	RecordTest	,
		TestHandshakeSpliced
	)

Definition at line 145 of file RecordTest.cpp.

References testing::_, folly::IOBuf::copyBuffer(), EXPECT_ANY_THROW, EXPECT_CALL, testing::InvokeWithoutArgs(), and fizz::detail::read().

                                         {
  EXPECT_CALL(read_, read(_))
      .WillOnce(InvokeWithoutArgs([]() {
        return TLSMessage{ContentType::handshake, getBuf("01000010abcd")};
      }))
      .WillOnce(InvokeWithoutArgs([]() {
        return TLSMessage{ContentType::application_data,
                          IOBuf::copyBuffer("hi")};
      }));
  EXPECT_ANY_THROW(read_.readEvent(queue_));
}

fizz::test::TEST_F	(	PlaintextRecordTest	,
		TestWriteAppData
	)

Definition at line 145 of file PlaintextRecordTest.cpp.

References EXPECT_ANY_THROW, and folly::gen::move.

                                              {
  TLSMessage msg{ContentType::application_data};
  EXPECT_ANY_THROW(write_.write(std::move(msg)));
}

fizz::test::TEST_F	(	FizzBaseTest	,
		TestReadSingle
	)

Definition at line 149 of file FizzBaseTest.cpp.

References testing::_, EXPECT_CALL, testing::Invoke(), and testing::InvokeWithoutArgs().

                                     {
  EXPECT_CALL(*TestStateMachine::instance, processSocketData(_, _))
      .WillOnce(InvokeWithoutArgs([]() { return Actions{A1()}; }));
  EXPECT_CALL(testFizz_->visitor_, a1()).WillOnce(Invoke([this]() {
    testFizz_->waitForData();
  }));
  testFizz_->newTransportData();
}

fizz::test::TEST_F	(	EncryptedRecordTest	,
		TestPadding
	)

Definition at line 149 of file EncryptedRecordTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, testing::Invoke(), and uint64_t.

                                         {
  addToQueue("17030100050123456789");
  EXPECT_CALL(*readAead_, _decrypt(_, _, 0))
      .WillOnce(Invoke([](std::unique_ptr<IOBuf>& buf, const IOBuf*, uint64_t) {
        expectSame(buf, "0123456789");
        return getBuf("1234abcd17000000");
      }));
  auto msg = read_.read(queue_);
  EXPECT_EQ(msg->type, ContentType::application_data);
  expectSame(msg->fragment, "1234abcd");
  EXPECT_TRUE(queue_.empty());
}

fizz::test::TEST_F	(	HandshakeTypesTest	,
		ChloEncodeCopy
	)

Definition at line 150 of file HandshakeTypesTest.cpp.

References chlo, and EXPECT_EQ.

                                           {
  auto clientHello = decodeHex<ClientHello>(chlo);
  EXPECT_EQ(encodeHex(clientHello), chlo);
  EXPECT_EQ(encodeHex(clientHello), chlo);
}

fizz::test::TEST_F	(	PlaintextRecordTest	,
		TestFragmentedWrite
	)

Definition at line 150 of file PlaintextRecordTest.cpp.

References folly::IOBuf::create(), folly::eq, EXPECT_TRUE, folly::gen::move, and fizz::detail::write().

                                                 {
  TLSMessage msg{ContentType::handshake, IOBuf::create(0)};
  auto buf = IOBuf::create(0x4010);
  buf->append(0x4010);
  memset(buf->writableData(), 0x1, buf->length());
  msg.fragment->prependChain(std::move(buf));
  auto write = write_.write(std::move(msg));

  TLSMessage msg1{ContentType::handshake, IOBuf::create(0)};
  buf = IOBuf::create(0x4000);
  buf->append(0x4000);
  memset(buf->writableData(), 0x1, buf->length());
  msg1.fragment->prependChain(std::move(buf));
  auto write1 = write_.write(std::move(msg1));

  TLSMessage msg2{ContentType::handshake, IOBuf::create(0)};
  buf = IOBuf::create(0x10);
  buf->append(0x10);
  memset(buf->writableData(), 0x1, buf->length());
  msg2.fragment->prependChain(std::move(buf));
  auto write2 = write_.write(std::move(msg2));

  write1.data->prependChain(std::move(write2.data));
  IOBufEqualTo eq;
  EXPECT_TRUE(eq(write.data, write1.data));
}

fizz::test::TEST_F	(	AsyncFizzBaseTest	,
		TestWrite
	)

Definition at line 151 of file AsyncFizzBaseTest.cpp.

References testing::_, folly::IOBuf::copyBuffer(), EXPECT_CALL, and folly::gen::move.

                                     {
  auto buf = IOBuf::copyBuffer("buf");

  EXPECT_CALL(*this, writeAppDataInternal(_, _, _));
  writeChain(nullptr, std::move(buf));
}

fizz::test::TEST_F	(	HandshakeTypesTest	,
		NstEncodeDecode
	)

Definition at line 156 of file HandshakeTypesTest.cpp.

References folly::Range< Iter >::empty(), EXPECT_EQ, EXPECT_TRUE, folly::gen::move, nst, and ticket.

                                            {
  auto ticket = decodeHex<NewSessionTicket>(nst);

  EXPECT_EQ(ticket.ticket_lifetime, 0x0002a300);
  EXPECT_EQ(ticket.ticket_age_add, 0xd0a8dc29);
  EXPECT_TRUE(ticket.ticket_nonce->empty());
  EXPECT_EQ(ticket.ticket->computeChainDataLength(), 146);

  auto reencoded = encodeHex(std::move(ticket));
  EXPECT_EQ(nst, reencoded);
}

fizz::test::TEST_F	(	RecordTest	,
		TestWriteAppData
	)

Definition at line 157 of file RecordTest.cpp.

References testing::_, fizz::TLSContent::contentType, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, fizz::TLSContent::encryptionLevel, EXPECT_CALL, EXPECT_EQ, testing::Invoke(), and fizz::TLSMessage::type.

                                     {
  EXPECT_CALL(write_, _write(_)).WillOnce(Invoke([&](TLSMessage& msg) {
    TLSContent content;
    content.contentType = msg.type;
    content.encryptionLevel = write_.getEncryptionLevel();
    content.data = nullptr;
    EXPECT_EQ(msg.type, ContentType::application_data);
    return content;
  }));
  write_.writeAppData(IOBuf::copyBuffer("hi"));
}

fizz::test::TEST_F	(	AsyncFizzBaseTest	,
		TestReadErr
	)

Definition at line 158 of file AsyncFizzBaseTest.cpp.

References testing::_, folly::netops::close(), EXPECT_CALL, EXPECT_EQ, and socket_.

                                       {
  setReadCB(&readCallback_);

  EXPECT_CALL(readCallback_, readErr_(_));
  EXPECT_CALL(*socket_, close());
  deliverError(ase_);
  EXPECT_EQ(getReadCallback(), nullptr);
}

fizz::test::TEST_F	(	FizzBaseTest	,
		TestReadMulti
	)

Definition at line 158 of file FizzBaseTest.cpp.

References testing::_, EXPECT_CALL, testing::Invoke(), testing::InvokeWithoutArgs(), and s_.

                                    {
  EXPECT_CALL(*TestStateMachine::instance, processSocketData(_, _))
      .InSequence(s_)
      .WillOnce(InvokeWithoutArgs([]() {
        return Actions{A1(), A2(), A1()};
      }));
  EXPECT_CALL(testFizz_->visitor_, a1()).InSequence(s_);
  EXPECT_CALL(testFizz_->visitor_, a2()).InSequence(s_);
  EXPECT_CALL(testFizz_->visitor_, a1()).InSequence(s_);
  EXPECT_CALL(*TestStateMachine::instance, processSocketData(_, _))
      .InSequence(s_)
      .WillOnce(InvokeWithoutArgs([]() { return Actions{A2()}; }));
  EXPECT_CALL(testFizz_->visitor_, a2()).InSequence(s_);
  EXPECT_CALL(*TestStateMachine::instance, processSocketData(_, _))
      .InSequence(s_)
      .WillOnce(InvokeWithoutArgs([]() { return Actions{A1()}; }));
  EXPECT_CALL(testFizz_->visitor_, a1())
      .InSequence(s_)
      .WillOnce(Invoke([this]() { testFizz_->waitForData(); }));
  testFizz_->newTransportData();
}

fizz::test::TEST_F	(	EncryptedRecordTest	,
		TestAllPaddingAppData
	)

Definition at line 162 of file EncryptedRecordTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, testing::Invoke(), and uint64_t.

                                                   {
  addToQueue("17030100050123456789");
  EXPECT_CALL(*readAead_, _decrypt(_, _, 0))
      .WillOnce(Invoke([](std::unique_ptr<IOBuf>& buf, const IOBuf*, uint64_t) {
        expectSame(buf, "0123456789");
        return getBuf("17000000");
      }));
  auto msg = read_.read(queue_);
  EXPECT_EQ(msg->type, ContentType::application_data);
  EXPECT_TRUE(msg->fragment->empty());
  EXPECT_TRUE(queue_.empty());
}

fizz::test::TEST_F	(	AsyncFizzBaseTest	,
		TestReadErrNoCallback
	)

Definition at line 167 of file AsyncFizzBaseTest.cpp.

References folly::netops::close(), EXPECT_CALL, and socket_.

                                                 {
  EXPECT_CALL(*socket_, close());
  deliverError(ase_);
}

fizz::test::TEST_F	(	RecordTest	,
		TestWriteAlert
	)

Definition at line 169 of file RecordTest.cpp.

References testing::_, fizz::TLSContent::contentType, fizz::TLSContent::data, fizz::TLSContent::encryptionLevel, EXPECT_CALL, EXPECT_EQ, testing::Invoke(), and fizz::TLSMessage::type.

                                   {
  EXPECT_CALL(write_, _write(_)).WillOnce(Invoke([&](TLSMessage& msg) {
    EXPECT_EQ(msg.type, ContentType::alert);
    TLSContent content;
    content.contentType = msg.type;
    content.encryptionLevel = write_.getEncryptionLevel();
    content.data = nullptr;
    return content;
  }));
  write_.writeAlert(Alert());
}

fizz::test::TEST_F	(	ValidateAuthenticatorTest	,
		TestValidateValidAuthenticator
	)

Definition at line 170 of file ExportedAuthenticatorTest.cpp.

References fizz::certificate, folly::IOBuf::copyBuffer(), EXPECT_EQ, EXPECT_TRUE, getCert(), getPrivateKey(), folly::hexlify(), kP256Certificate, kP256Key, folly::gen::move, and folly::unhexlify().

                                                                  {
  auto cert = fizz::test::getCert(kP256Certificate);
  auto key = fizz::test::getPrivateKey(kP256Key);
  std::vector<folly::ssl::X509UniquePtr> certs;
  certs.push_back(std::move(cert));
  SelfCertImpl<KeyType::P256> certificate(std::move(key), std::move(certs));
  auto authenticatorRequest = folly::IOBuf::copyBuffer(unhexlify(authrequest_));
  auto handshakeContext =
      folly::IOBuf::copyBuffer(unhexlify(handshakeContext_));
  auto finishedMacKey = folly::IOBuf::copyBuffer(unhexlify(finishedKey_));
  auto authenticator = ExportedAuthenticator::makeAuthenticator(
      deriver_,
      schemes_,
      certificate,
      std::move(authenticatorRequest),
      std::move(handshakeContext),
      std::move(finishedMacKey),
      CertificateVerifyContext::Authenticator);

  authenticatorRequest = folly::IOBuf::copyBuffer(unhexlify(authrequest_));
  handshakeContext = folly::IOBuf::copyBuffer(unhexlify(handshakeContext_));
  finishedMacKey = folly::IOBuf::copyBuffer(unhexlify(finishedKey_));
  auto decodedCerts = ExportedAuthenticator::validate(
      deriver_,
      std::move(authenticatorRequest),
      std::move(authenticator),
      std::move(handshakeContext),
      std::move(finishedMacKey),
      CertificateVerifyContext::Authenticator);
  EXPECT_TRUE(decodedCerts.hasValue());
  EXPECT_EQ((*decodedCerts).size(), 1);
  EXPECT_EQ(
      expected_cert,
      StringPiece(hexlify(((*decodedCerts)[0].cert_data)->coalesce())));
}

fizz::test::TEST_F	(	AsyncFizzBaseTest	,
		TestReadErrAsync
	)

Definition at line 172 of file AsyncFizzBaseTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_EQ, ON_CALL, and testing::Return().

                                            {
  ON_CALL(*this, good()).WillByDefault(Return(false));
  deliverError(ase_);

  EXPECT_CALL(readCallback_, readErr_(_));
  setReadCB(&readCallback_);
  EXPECT_EQ(getReadCallback(), nullptr);
}

fizz::test::TEST_F	(	EncryptedRecordTest	,
		TestAllPaddingHandshake
	)

Definition at line 175 of file EncryptedRecordTest.cpp.

References testing::_, EXPECT_ANY_THROW, EXPECT_CALL, testing::Invoke(), and uint64_t.

                                                     {
  addToQueue("17030100050123456789");
  EXPECT_CALL(*readAead_, _decrypt(_, _, 0))
      .WillOnce(Invoke([](std::unique_ptr<IOBuf>& buf, const IOBuf*, uint64_t) {
        expectSame(buf, "0123456789");
        return getBuf("16000000");
      }));
  EXPECT_ANY_THROW(read_.read(queue_));
}

fizz::test::TEST_F	(	HandshakeTypesTest	,
		EncodeAndDecodeSigAlgs
	)

Definition at line 176 of file HandshakeTypesTest.cpp.

References ASSERT_TRUE, chlo, fizz::encodeExtension(), EXPECT_TRUE, extensionsMatch(), and fizz::findExtension().

                                                   {
  auto clientHello = decodeHex<ClientHello>(chlo);
  auto sigAlgs = getExtension<SignatureAlgorithms>(clientHello.extensions);
  ASSERT_TRUE(sigAlgs);
  auto ext = encodeExtension(*sigAlgs);
  auto original = findExtension(
      clientHello.extensions, ExtensionType::signature_algorithms);
  EXPECT_TRUE(extensionsMatch(*original, ext));
}

fizz::test::TEST_F	(	FizzBaseTest	,
		TestReadNoActions
	)

Definition at line 180 of file FizzBaseTest.cpp.

References testing::_, EXPECT_CALL, testing::Invoke(), testing::InvokeWithoutArgs(), and s_.

                                        {
  EXPECT_CALL(*TestStateMachine::instance, processSocketData(_, _))
      .InSequence(s_)
      .WillOnce(InvokeWithoutArgs([]() { return Actions{}; }));
  EXPECT_CALL(*TestStateMachine::instance, processSocketData(_, _))
      .InSequence(s_)
      .WillOnce(InvokeWithoutArgs([]() { return Actions{A1()}; }));
  EXPECT_CALL(testFizz_->visitor_, a1())
      .InSequence(s_)
      .WillOnce(Invoke([this]() { testFizz_->waitForData(); }));
  testFizz_->newTransportData();
}

fizz::test::TEST_F	(	AsyncFizzBaseTest	,
		TestReadEOF
	)

Definition at line 181 of file AsyncFizzBaseTest.cpp.

References EXPECT_CALL, and EXPECT_EQ.

                                       {
  setReadCB(&readCallback_);

  EXPECT_CALL(readCallback_, readEOF_());
  deliverError(eof_);
  EXPECT_EQ(getReadCallback(), nullptr);
}

fizz::test::TEST_F	(	RecordTest	,
		TestWriteHandshake
	)

Definition at line 181 of file RecordTest.cpp.

References testing::_, fizz::TLSContent::contentType, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, fizz::TLSContent::encryptionLevel, EXPECT_CALL, EXPECT_EQ, testing::Invoke(), and fizz::TLSMessage::type.

                                       {
  EXPECT_CALL(write_, _write(_)).WillOnce(Invoke([&](TLSMessage& msg) {
    EXPECT_EQ(msg.type, ContentType::handshake);
    TLSContent content;
    content.contentType = msg.type;
    content.encryptionLevel = write_.getEncryptionLevel();
    content.data = nullptr;
    return content;
  }));
  write_.writeHandshake(IOBuf::copyBuffer("msg1"), IOBuf::copyBuffer("msg2"));
}

fizz::test::TEST_F	(	EncryptedRecordTest	,
		TestNoContentType
	)

Definition at line 185 of file EncryptedRecordTest.cpp.

References testing::_, EXPECT_ANY_THROW, EXPECT_CALL, testing::Invoke(), and uint64_t.

                                               {
  addToQueue("17030100050123456789");
  EXPECT_CALL(*readAead_, _decrypt(_, _, 0))
      .WillOnce(Invoke([](std::unique_ptr<IOBuf>& buf, const IOBuf*, uint64_t) {
        expectSame(buf, "0123456789");
        return getBuf("00000000");
      }));
  EXPECT_ANY_THROW(read_.read(queue_));
}

fizz::test::TEST_F	(	HandshakeTypesTest	,
		EncodeAndDecodeClientKeyShare
	)

Definition at line 186 of file HandshakeTypesTest.cpp.

References ASSERT_TRUE, chlo, fizz::encodeExtension(), EXPECT_TRUE, extensionsMatch(), fizz::findExtension(), and folly::pushmi::operators::share.

                                                          {
  auto clientHello = decodeHex<ClientHello>(chlo);
  auto share = getExtension<ClientKeyShare>(clientHello.extensions);
  ASSERT_TRUE(share);
  auto ext = encodeExtension(*share);
  auto original =
      findExtension(clientHello.extensions, ExtensionType::key_share);
  EXPECT_TRUE(extensionsMatch(*original, ext));
}

fizz::test::TEST_F	(	AsyncFizzBaseTest	,
		TestReadEOFNoCallback
	)

Definition at line 189 of file AsyncFizzBaseTest.cpp.

                                                 {
  deliverError(eof_);
}

fizz::test::TEST_F	(	FizzBaseTest	,
		TestWriteNewSessionTicket
	)

Definition at line 193 of file FizzBaseTest.cpp.

References testing::_, EXPECT_CALL, and testing::InvokeWithoutArgs().

                                                {
  EXPECT_CALL(*TestStateMachine::instance, processWriteNewSessionTicket_(_, _))
      .WillOnce(InvokeWithoutArgs([]() { return Actions{A1()}; }));
  EXPECT_CALL(testFizz_->visitor_, a1());
  testFizz_->writeNewSessionTicket(WriteNewSessionTicket());
}

fizz::test::TEST_F	(	AsyncFizzBaseTest	,
		TestMovableBuffer
	)

Definition at line 193 of file AsyncFizzBaseTest.cpp.

References folly::IOBuf::copyBuffer(), EXPECT_CALL, and testing::Return().

                                             {
  EXPECT_CALL(readCallback_, isBufferMovable_()).WillRepeatedly(Return(true));

  setReadCB(&readCallback_);

  auto buf = IOBuf::copyBuffer("buf");
  EXPECT_CALL(readCallback_, readBufferAvailable_(BufMatches(buf.get())));
  deliverAppData(buf->clone());

  auto buf2 = IOBuf::copyBuffer("buf2");
  EXPECT_CALL(readCallback_, readBufferAvailable_(BufMatches(buf2.get())));
  deliverAppData(buf2->clone());
}

fizz::test::TEST_F	(	EncryptedRecordTest	,
		TestReadSeqNum
	)

Definition at line 195 of file EncryptedRecordTest.cpp.

References testing::_, EXPECT_CALL, i, testing::Invoke(), and uint64_t.

                                            {
  for (int i = 0; i < 10; i++) {
    addToQueue("17030100050123456789");
    EXPECT_CALL(*readAead_, _decrypt(_, _, i))
        .WillOnce(
            Invoke([](std::unique_ptr<IOBuf>& buf, const IOBuf*, uint64_t) {
              expectSame(buf, "0123456789");
              return getBuf("1234abcd17");
            }));
    read_.read(queue_);
  }
}

fizz::test::TEST_F	(	HandshakeTypesTest	,
		EncodeAndDecodeServerHello
	)

Definition at line 196 of file HandshakeTypesTest.cpp.

References encodedShlo, EXPECT_EQ, EXPECT_TRUE, and folly::gen::move.

                                                       {
  auto shlo = decodeHex<ServerHello>(encodedShlo);
  EXPECT_EQ(shlo.legacy_version, ProtocolVersion::tls_1_2);
  EXPECT_EQ(shlo.random.front(), 0x9f);
  EXPECT_EQ(shlo.random.back(), 0x5b);
  EXPECT_EQ(shlo.cipher_suite, CipherSuite::TLS_AES_128_GCM_SHA256);
  EXPECT_EQ(shlo.extensions.size(), 2);
  EXPECT_TRUE(getExtension<ServerKeyShare>(shlo.extensions).hasValue());
  EXPECT_TRUE(
      getExtension<ServerSupportedVersions>(shlo.extensions).hasValue());
  auto reencoded = encodeHex(std::move(shlo));
  EXPECT_EQ(reencoded, encodedShlo);
}

fizz::test::TEST_F	(	FizzBaseTest	,
		TestWrite
	)

Definition at line 200 of file FizzBaseTest.cpp.

References testing::_, EXPECT_CALL, and testing::InvokeWithoutArgs().

                                {
  EXPECT_CALL(*TestStateMachine::instance, processAppWrite_(_, _))
      .WillOnce(InvokeWithoutArgs([]() { return Actions{A1()}; }));
  EXPECT_CALL(testFizz_->visitor_, a1());
  testFizz_->appWrite(AppWrite());
}

fizz::test::TEST_F	(	ValidateAuthenticatorTest	,
		TestValidateEmptyAuthenticator
	)

Definition at line 206 of file ExportedAuthenticatorTest.cpp.

References fizz::certificate, folly::IOBuf::copyBuffer(), EXPECT_EQ, EXPECT_TRUE, getCert(), getPrivateKey(), kP256Certificate, kP256Key, folly::gen::move, and folly::unhexlify().

                                                                  {
  auto cert = fizz::test::getCert(kP256Certificate);
  auto key = fizz::test::getPrivateKey(kP256Key);
  std::vector<folly::ssl::X509UniquePtr> certs;
  certs.push_back(std::move(cert));
  SelfCertImpl<KeyType::P256> certificate(std::move(key), std::move(certs));
  schemes_.clear();
  auto authenticatorRequest = folly::IOBuf::copyBuffer(unhexlify(authrequest_));
  auto handshakeContext =
      folly::IOBuf::copyBuffer(unhexlify(handshakeContext_));
  auto finishedMacKey = folly::IOBuf::copyBuffer(unhexlify(finishedKey_));
  auto authenticator = ExportedAuthenticator::makeAuthenticator(
      deriver_,
      schemes_,
      certificate,
      std::move(authenticatorRequest),
      std::move(handshakeContext),
      std::move(finishedMacKey),
      CertificateVerifyContext::Authenticator);

  authenticatorRequest = folly::IOBuf::copyBuffer(unhexlify(authrequest_));
  handshakeContext = folly::IOBuf::copyBuffer(unhexlify(handshakeContext_));
  finishedMacKey = folly::IOBuf::copyBuffer(unhexlify(finishedKey_));
  auto decodedCerts = ExportedAuthenticator::validate(
      deriver_,
      std::move(authenticatorRequest),
      std::move(authenticator),
      std::move(handshakeContext),
      std::move(finishedMacKey),
      CertificateVerifyContext::Authenticator);
  EXPECT_TRUE(decodedCerts.hasValue());
  EXPECT_EQ((*decodedCerts).size(), 0);
}

fizz::test::TEST_F	(	AsyncFizzBaseTest	,
		TestMovableBufferAsyncCallback
	)

Definition at line 207 of file AsyncFizzBaseTest.cpp.

References folly::IOBuf::copyBuffer(), EXPECT_CALL, folly::gen::move, and testing::Return().

                                                          {
  EXPECT_CALL(readCallback_, isBufferMovable_()).WillRepeatedly(Return(true));

  auto buf = IOBuf::copyBuffer("buf");
  deliverAppData(std::move(buf));

  auto buf2 = IOBuf::copyBuffer("buf2");
  deliverAppData(std::move(buf2));

  auto expected = IOBuf::copyBuffer("bufbuf2");
  EXPECT_CALL(readCallback_, readBufferAvailable_(BufMatches(expected.get())));
  setReadCB(&readCallback_);

  auto buf3 = IOBuf::copyBuffer("buf3");
  EXPECT_CALL(readCallback_, readBufferAvailable_(BufMatches(buf3.get())));
  deliverAppData(buf3->clone());
}

fizz::test::TEST_F	(	FizzBaseTest	,
		TestEarlyWrite
	)

Definition at line 207 of file FizzBaseTest.cpp.

References testing::_, EXPECT_CALL, and testing::InvokeWithoutArgs().

                                     {
  EXPECT_CALL(*TestStateMachine::instance, processEarlyAppWrite_(_, _))
      .WillOnce(InvokeWithoutArgs([]() { return Actions{A1()}; }));
  EXPECT_CALL(testFizz_->visitor_, a1());
  testFizz_->earlyAppWrite(EarlyAppWrite());
}

fizz::test::TEST_F	(	EncryptedRecordTest	,
		TestSkipAndWait
	)

Definition at line 208 of file EncryptedRecordTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_FALSE, EXPECT_TRUE, testing::Invoke(), folly::none, and uint64_t.

                                             {
  read_.setSkipFailedDecryption(true);
  addToQueue("17030100050123456789");
  EXPECT_CALL(*readAead_, _tryDecrypt(_, _, 0))
      .WillOnce(
          Invoke([](std::unique_ptr<IOBuf>& /*buf*/, const IOBuf*, uint64_t) {
            return folly::none;
          }));
  EXPECT_FALSE(read_.read(queue_).hasValue());
  EXPECT_TRUE(queue_.empty());
}

fizz::test::TEST_F	(	HandshakeTypesTest	,
		EncodeAndDecodeEndOfEarlyData
	)

Definition at line 210 of file HandshakeTypesTest.cpp.

References encodedEoed, EXPECT_EQ, and folly::gen::move.

                                                          {
  auto eoed = decodeHex<EndOfEarlyData>(encodedEoed);
  auto reencoded = encodeHex(std::move(eoed));
  EXPECT_EQ(reencoded, encodedEoed);
}

fizz::test::TEST_F	(	FizzBaseTest	,
		TestWriteMulti
	)

Definition at line 214 of file FizzBaseTest.cpp.

References testing::_, appWrite(), EXPECT_CALL, and testing::InvokeWithoutArgs().

                                     {
  EXPECT_CALL(
      *TestStateMachine::instance, processAppWrite_(_, WriteMatches("write1")))
      .WillOnce(InvokeWithoutArgs([]() { return Actions{A1()}; }));
  EXPECT_CALL(testFizz_->visitor_, a1());
  testFizz_->appWrite(appWrite("write1"));
  EXPECT_CALL(
      *TestStateMachine::instance, processAppWrite_(_, WriteMatches("write2")))
      .WillOnce(InvokeWithoutArgs([]() { return Actions{A2()}; }));
  EXPECT_CALL(testFizz_->visitor_, a2());
  testFizz_->appWrite(appWrite("write2"));
}

fizz::test::TEST_F	(	ZlibCertificateCompressorTest	,
		TestCompressDecompress
	)

Definition at line 214 of file ZlibCertificateCompressorTest.cpp.

References fizz::CertificateAuthorities::authorities, folly::IOBuf::copyBuffer(), createCert(), encode(), fizz::DistinguishedName::encoded_name, fizz::encodeExtension(), EXPECT_EQ, EXPECT_TRUE, and folly::gen::move.

                                                              {
  auto certAndKey = createCert("fizz-selfsigned", false, nullptr);
  std::vector<folly::ssl::X509UniquePtr> certs;
  certs.push_back(std::move(certAndKey.cert));
  auto cert =
      CertUtils::makeSelfCert(std::move(certs), std::move(certAndKey.key));
  auto certMsg = cert->getCertMessage();

  // Add extension
  CertificateAuthorities auth;
  DistinguishedName dn;
  dn.encoded_name = IOBuf::copyBuffer("DistinguishedName");
  auth.authorities.push_back(std::move(dn));
  certMsg.certificate_list[0].extensions.push_back(encodeExtension(auth));

  auto compressedCertMsg = compressor_->compress(certMsg);
  EXPECT_EQ(compressedCertMsg.algorithm, CertificateCompressionAlgorithm::zlib);

  auto decompressedCertMsg = decompressor_->decompress(compressedCertMsg);
  EXPECT_TRUE(decompressedCertMsg.certificate_request_context->empty());
  EXPECT_EQ(decompressedCertMsg.certificate_list.size(), 1);
  auto& certEntry = decompressedCertMsg.certificate_list.at(0);
  EXPECT_EQ(certEntry.extensions.size(), 1);
  auto decompressedPeer = CertUtils::makePeerCert(certEntry.cert_data->clone());
  EXPECT_EQ(decompressedPeer->getIdentity(), cert->getIdentity());

  EXPECT_TRUE(IOBufEqualTo()(encode(certMsg), encode(decompressedCertMsg)));
}

fizz::test::TEST_F	(	HandshakeTypesTest	,
		EncodeAndDecodeEncryptedExtensions
	)

Definition at line 216 of file HandshakeTypesTest.cpp.

References encodedEncryptedExtensions, EXPECT_EQ, EXPECT_TRUE, and folly::gen::move.

                                                               {
  auto ee = decodeHex<EncryptedExtensions>(encodedEncryptedExtensions);
  EXPECT_EQ(ee.extensions.size(), 2);
  EXPECT_TRUE(getExtension<SupportedGroups>(ee.extensions).hasValue());
  auto reencoded = encodeHex(std::move(ee));
  EXPECT_EQ(reencoded, encodedEncryptedExtensions);
}

fizz::test::TEST_F	(	EncryptedRecordTest	,
		TestSkipAndRead
	)

Definition at line 220 of file EncryptedRecordTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, testing::Invoke(), folly::none, s, and uint64_t.

                                             {
  Sequence s;
  read_.setSkipFailedDecryption(true);
  addToQueue("1703010005012345678917030100050123456789170301000501234567aa");
  EXPECT_CALL(*readAead_, _tryDecrypt(_, _, 0))
      .InSequence(s)
      .WillOnce(
          Invoke([](std::unique_ptr<IOBuf>& /*buf*/, const IOBuf*, uint64_t) {
            return folly::none;
          }));
  EXPECT_CALL(*readAead_, _tryDecrypt(_, _, 0))
      .InSequence(s)
      .WillOnce(Invoke([](std::unique_ptr<IOBuf>& buf, const IOBuf*, uint64_t) {
        expectSame(buf, "0123456789");
        return getBuf("1234abcd17");
      }));
  auto msg = read_.read(queue_);
  EXPECT_EQ(msg->type, ContentType::application_data);
  expectSame(msg->fragment, "1234abcd");
  EXPECT_EQ(queue_.chainLength(), 10);
  EXPECT_CALL(*readAead_, _decrypt(_, _, 1))
      .InSequence(s)
      .WillOnce(Invoke([](std::unique_ptr<IOBuf>& buf, const IOBuf*, uint64_t) {
        expectSame(buf, "01234567aa");
        return getBuf("1234abaa17");
      }));
  msg = read_.read(queue_);
  EXPECT_EQ(msg->type, ContentType::application_data);
  expectSame(msg->fragment, "1234abaa");
  EXPECT_TRUE(queue_.empty());
}

fizz::test::TEST_F	(	HandshakeTypesTest	,
		EncodeAndDecodedCertificate
	)

Definition at line 224 of file HandshakeTypesTest.cpp.

References encodedCertificate, EXPECT_EQ, EXPECT_TRUE, and folly::gen::move.

                                                        {
  auto cert = decodeHex<CertificateMsg>(encodedCertificate);
  EXPECT_EQ(cert.certificate_request_context->computeChainDataLength(), 0);
  EXPECT_EQ(cert.certificate_list.size(), 1);
  EXPECT_EQ(cert.certificate_list[0].cert_data->computeChainDataLength(), 432);
  EXPECT_TRUE(cert.certificate_list[0].extensions.empty());
  auto reencoded = encodeHex(std::move(cert));
  EXPECT_EQ(reencoded, encodedCertificate);
}

fizz::test::TEST_F	(	AsyncFizzBaseTest	,
		TestReadBufferLarger
	)

Definition at line 225 of file AsyncFizzBaseTest.cpp.

References folly::IOBuf::copyBuffer(), EXPECT_CALL, folly::gen::move, and testing::Return().

                                                {
  EXPECT_CALL(readCallback_, isBufferMovable_()).WillRepeatedly(Return(false));

  setReadCB(&readCallback_);

  auto buf = IOBuf::copyBuffer("sup");
  expectReadBufRequest(20);
  expectReadData("sup");
  deliverAppData(std::move(buf));
}

fizz::test::TEST_F	(	FizzBaseTest	,
		TestAppClose
	)

Definition at line 227 of file FizzBaseTest.cpp.

References testing::_, EXPECT_CALL, and testing::InvokeWithoutArgs().

                                   {
  EXPECT_CALL(*TestStateMachine::instance, processAppClose(_))
      .WillOnce(InvokeWithoutArgs([]() { return Actions{A1()}; }));
  EXPECT_CALL(testFizz_->visitor_, a1());
  testFizz_->appClose();
}

fizz::test::TEST_F	(	FizzBaseTest	,
		TestWriteNewSessionTicketInCallback
	)

Definition at line 234 of file FizzBaseTest.cpp.

References testing::_, appWrite(), EXPECT_CALL, testing::Invoke(), testing::InvokeWithoutArgs(), s_, and writeNewSessionTicket().

                                                          {
  EXPECT_CALL(*TestStateMachine::instance, processSocketData(_, _))
      .InSequence(s_)
      .WillOnce(InvokeWithoutArgs([]() { return Actions{A1()}; }));
  EXPECT_CALL(testFizz_->visitor_, a1())
      .InSequence(s_)
      .WillOnce(Invoke([this]() {
        testFizz_->waitForData();
        testFizz_->writeNewSessionTicket(writeNewSessionTicket("appToken"));
      }));
  EXPECT_CALL(
      *TestStateMachine::instance,
      processWriteNewSessionTicket_(
          _, WriteNewSessionTicketMatches("appToken")))
      .InSequence(s_)
      .WillOnce(InvokeWithoutArgs([]() { return Actions{A2()}; }));
  EXPECT_CALL(testFizz_->visitor_, a2())
      .InSequence(s_)
      .WillOnce(Invoke([this]() { testFizz_->appWrite(appWrite("write")); }));
  EXPECT_CALL(
      *TestStateMachine::instance, processAppWrite_(_, WriteMatches("write")))
      .InSequence(s_)
      .WillOnce(InvokeWithoutArgs([]() { return Actions{}; }));
  testFizz_->newTransportData();
}

fizz::test::TEST_F	(	HandshakeTypesTest	,
		EncodedAndDecodeCertificateVerify
	)

Definition at line 234 of file HandshakeTypesTest.cpp.

References encodedCertVerify, EXPECT_EQ, folly::gen::move, and verify().

                                                              {
  auto verify = decodeHex<CertificateVerify>(encodedCertVerify);
  EXPECT_EQ(verify.algorithm, SignatureScheme::rsa_pss_sha256);
  EXPECT_EQ(verify.signature->computeChainDataLength(), 128);
  auto reencoded = encodeHex(std::move(verify));
  EXPECT_EQ(reencoded, encodedCertVerify);
}

fizz::test::TEST_F	(	AsyncFizzBaseTest	,
		TestReadBufferExact
	)

Definition at line 236 of file AsyncFizzBaseTest.cpp.

References folly::IOBuf::copyBuffer(), EXPECT_CALL, folly::gen::move, and testing::Return().

                                               {
  EXPECT_CALL(readCallback_, isBufferMovable_()).WillRepeatedly(Return(false));

  setReadCB(&readCallback_);

  auto buf = IOBuf::copyBuffer("sup");
  expectReadBufRequest(3);
  expectReadData("sup");
  deliverAppData(std::move(buf));
}

fizz::test::TEST_F	(	HandshakeTypesTest	,
		EncodedAndDecodeKeyUpdated
	)

Definition at line 242 of file HandshakeTypesTest.cpp.

References encodedKeyUpdate, EXPECT_EQ, and folly::gen::move.

                                                       {
  auto keyUpdate = decodeHex<KeyUpdate>(encodedKeyUpdate);
  EXPECT_EQ(keyUpdate.request_update, KeyUpdateRequest::update_not_requested);
  auto reencoded = encodeHex(std::move(keyUpdate));
  EXPECT_EQ(reencoded, encodedKeyUpdate);
}

fizz::test::TEST_F	(	ZlibCertificateCompressorTest	,
		TestHugeCompressedCert
	)

Definition at line 243 of file ZlibCertificateCompressorTest.cpp.

References cc, EXPECT_THAT, FAIL, testing::HasSubstr(), and tooLargeCompressedCertificate.

                                                              {
  auto cc = decodeHex<CompressedCertificate>(tooLargeCompressedCertificate);

  try {
    decompressor_->decompress(cc);
    FAIL() << "Decompressor decompressed excessively large cert";
  } catch (const std::exception& e) {
    EXPECT_THAT(
        e.what(), HasSubstr("exceeds maximum certificate message size"));
  }

  // Lie about size, should still error.
  cc.uncompressed_length = 64;

  try {
    decompressor_->decompress(cc);
    FAIL() << "Decompressor decompressed cert erroneously";
  } catch (const std::exception& e) {
    EXPECT_THAT(e.what(), HasSubstr("uncompressed length given is too small"));
  }
}

fizz::test::TEST_F	(	AsyncFizzBaseTest	,
		TestReadBufferSmaller
	)

Definition at line 247 of file AsyncFizzBaseTest.cpp.

References folly::IOBuf::copyBuffer(), EXPECT_CALL, folly::gen::move, and testing::Return().

                                                 {
  EXPECT_CALL(readCallback_, isBufferMovable_()).WillRepeatedly(Return(false));

  setReadCB(&readCallback_);

  auto buf = IOBuf::copyBuffer("hello");
  expectReadBufRequest(3);
  expectReadData("hel");
  expectReadBufRequest(3);
  expectReadData("lo");
  deliverAppData(std::move(buf));
}

fizz::test::TEST_F	(	HandshakeTypesTest	,
		EncodedAndDecodeCertificateRequest
	)

Definition at line 249 of file HandshakeTypesTest.cpp.

References encodedCertRequest, EXPECT_EQ, EXPECT_TRUE, and folly::gen::move.

                                                               {
  auto cr = decodeHex<CertificateRequest>(encodedCertRequest);
  EXPECT_TRUE(cr.certificate_request_context->empty());
  EXPECT_EQ(cr.extensions.size(), 1);
  EXPECT_TRUE(getExtension<SignatureAlgorithms>(cr.extensions).hasValue());
  auto reencoded = encodeHex(std::move(cr));
  EXPECT_EQ(reencoded, encodedCertRequest);
}

fizz::test::TEST_F	(	EncryptedRecordTest	,
		TestWriteHandshake
	)

Definition at line 252 of file EncryptedRecordTest.cpp.

References testing::_, EXPECT_CALL, testing::Invoke(), folly::gen::move, and uint64_t.

                                                {
  TLSMessage msg{ContentType::handshake, getBuf("1234567890")};
  EXPECT_CALL(*writeAead_, _encrypt(_, _, 0))
      .WillOnce(Invoke([](std::unique_ptr<IOBuf>& buf, const IOBuf*, uint64_t) {
        expectSame(buf, "123456789016");
        return getBuf("abcd1234abcd");
      }));
  auto buf = write_.write(std::move(msg));
  expectSame(buf.data, "1703030006abcd1234abcd");
}

fizz::test::TEST_F	(	HandshakeTypesTest	,
		EncodeAndDecodeCompressedCertificate
	)

Definition at line 258 of file HandshakeTypesTest.cpp.

References cc, encodedCompressedCertificate, EXPECT_EQ, and folly::gen::move.

                                                                 {
  auto cc = decodeHex<CompressedCertificate>(encodedCompressedCertificate);
  EXPECT_EQ(cc.algorithm, CertificateCompressionAlgorithm::zlib);
  EXPECT_EQ(cc.uncompressed_length, 0x00face);
  EXPECT_EQ(
      StringPiece(cc.compressed_certificate_message->coalesce()),
      StringPiece("foobarbaz"));
  auto reencoded = encodeHex(std::move(cc));
  EXPECT_EQ(reencoded, encodedCompressedCertificate);
}

fizz::test::TEST_F	(	AsyncFizzBaseTest	,
		TestReadBufferAsync
	)

Definition at line 260 of file AsyncFizzBaseTest.cpp.

References folly::IOBuf::copyBuffer(), EXPECT_CALL, folly::gen::move, and testing::Return().

                                               {
  EXPECT_CALL(readCallback_, isBufferMovable_()).WillRepeatedly(Return(false));

  auto buf1 = IOBuf::copyBuffer("buf1");
  deliverAppData(std::move(buf1));
  auto buf2 = IOBuf::copyBuffer("buf2");
  deliverAppData(std::move(buf2));

  expectReadBufRequest(20);
  expectReadData("buf1buf2");
  setReadCB(&readCallback_);

  auto buf3 = IOBuf::copyBuffer("buf3");
  expectReadBufRequest(20);
  expectReadData("buf3");
  deliverAppData(std::move(buf3));
}

fizz::test::TEST_F	(	FizzBaseTest	,
		TestWriteInCallback
	)

Definition at line 260 of file FizzBaseTest.cpp.

References testing::_, appWrite(), EXPECT_CALL, testing::Invoke(), testing::InvokeWithoutArgs(), and s_.

                                          {
  EXPECT_CALL(
      *TestStateMachine::instance, processAppWrite_(_, WriteMatches("write1")))
      .InSequence(s_)
      .WillOnce(InvokeWithoutArgs([]() { return Actions{A1()}; }));
  EXPECT_CALL(testFizz_->visitor_, a1())
      .InSequence(s_)
      .WillOnce(Invoke([this]() {
        testFizz_->appWrite(appWrite("write2"));
        testFizz_->appWrite(appWrite("write3"));
      }));
  EXPECT_CALL(
      *TestStateMachine::instance, processAppWrite_(_, WriteMatches("write2")))
      .InSequence(s_)
      .WillOnce(InvokeWithoutArgs([]() { return Actions{A2()}; }));
  EXPECT_CALL(testFizz_->visitor_, a2())
      .InSequence(s_)
      .WillOnce(Invoke([this]() { testFizz_->appWrite(appWrite("write4")); }));
  EXPECT_CALL(
      *TestStateMachine::instance, processAppWrite_(_, WriteMatches("write3")))
      .InSequence(s_)
      .WillOnce(InvokeWithoutArgs([]() { return Actions{}; }));
  EXPECT_CALL(
      *TestStateMachine::instance, processAppWrite_(_, WriteMatches("write4")))
      .InSequence(s_)
      .WillOnce(InvokeWithoutArgs([]() { return Actions{}; }));
  testFizz_->appWrite(appWrite("write1"));
}

fizz::test::TEST_F	(	EncryptedRecordTest	,
		TestWriteAppData
	)

Definition at line 263 of file EncryptedRecordTest.cpp.

References testing::_, EXPECT_CALL, testing::Invoke(), folly::gen::move, and uint64_t.

                                              {
  TLSMessage msg{ContentType::application_data, getBuf("1234567890")};
  EXPECT_CALL(*writeAead_, _encrypt(_, _, 0))
      .WillOnce(Invoke([](std::unique_ptr<IOBuf>& buf, const IOBuf*, uint64_t) {
        expectSame(buf, "123456789017");
        return getBuf("abcd1234abcd");
      }));
  auto buf = write_.write(std::move(msg));
  expectSame(buf.data, "1703030006abcd1234abcd");
}

fizz::test::TEST_F	(	ZlibCertificateCompressorTest	,
		TestBadMessages
	)

Definition at line 265 of file ZlibCertificateCompressorTest.cpp.

References exampleCompressedCertificate, EXPECT_THAT, FAIL, and testing::HasSubstr().

                                                       {
  auto compressedCert =
      decodeHex<CompressedCertificate>(exampleCompressedCertificate);
  auto actual = compressedCert.uncompressed_length;

  // Lie about having a larger cert.
  compressedCert.uncompressed_length = actual + 1;
  try {
    decompressor_->decompress(compressedCert);
    FAIL() << "Decompressor decompressed cert erroneously";
  } catch (const std::exception& e) {
    EXPECT_THAT(e.what(), HasSubstr("Uncompressed length incorrect"));
  }

  // Truncate length
  compressedCert.uncompressed_length = actual - 1;
  try {
    decompressor_->decompress(compressedCert);
    FAIL() << "Decompressor decompressed cert erroneously";
  } catch (const std::exception& e) {
    EXPECT_THAT(e.what(), HasSubstr("uncompressed length given is too small"));
  }

  // Bad algorithm value
  compressedCert.uncompressed_length = actual;
  compressedCert.algorithm = (CertificateCompressionAlgorithm)0xdead;
  try {
    decompressor_->decompress(compressedCert);
    FAIL() << "Decompressor decompressed cert erroneously";
  } catch (const std::exception& e) {
    EXPECT_THAT(e.what(), HasSubstr("non-zlib algorithm"));
  }
}

fizz::test::TEST_F	(	EncryptedRecordTest	,
		TestWriteAppDataInPlace
	)

Definition at line 274 of file EncryptedRecordTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_FALSE, testing::Invoke(), folly::IOBuf::isChained(), folly::gen::move, and uint64_t.

                                                     {
  TLSMessage msg{ContentType::application_data, getBuf("1234567890", 5, 17)};
  EXPECT_CALL(*writeAead_, _encrypt(_, _, 0))
      .WillOnce(Invoke([](std::unique_ptr<IOBuf>& buf, const IOBuf*, uint64_t) {
        // footer should have been written w/o chaining
        EXPECT_FALSE(buf->isChained());
        expectSame(buf, "123456789017");
        // we need to return room for the header
        return getBuf("abcd1234abcd", 5, 0);
      }));
  auto buf = write_.write(std::move(msg));
  EXPECT_FALSE(buf.data->isChained());
  expectSame(buf.data, "1703030006abcd1234abcd");
}

fizz::test::TEST_F	(	AsyncFizzBaseTest	,
		TestReadBufferZero
	)

Definition at line 278 of file AsyncFizzBaseTest.cpp.

References testing::_, folly::netops::close(), folly::IOBuf::copyBuffer(), EXPECT_CALL, folly::gen::move, testing::Return(), and socket_.

                                              {
  EXPECT_CALL(readCallback_, isBufferMovable_()).WillRepeatedly(Return(false));

  setReadCB(&readCallback_);

  auto buf = IOBuf::copyBuffer("hello");
  expectReadBufRequest(0);
  EXPECT_CALL(readCallback_, readErr_(_));
  EXPECT_CALL(*socket_, close());
  deliverAppData(std::move(buf));
}

fizz::test::TEST_F	(	EncryptedRecordTest	,
		TestFragmentedWrite
	)

Definition at line 289 of file EncryptedRecordTest.cpp.

References testing::_, folly::IOBuf::create(), EXPECT_CALL, testing::Invoke(), folly::gen::move, s, and uint64_t.

                                                 {
  TLSMessage msg{ContentType::application_data, IOBuf::create(0x4a00)};
  msg.fragment->append(0x4a00);
  memset(msg.fragment->writableData(), 0x1, msg.fragment->length());

  Sequence s;
  EXPECT_CALL(*writeAead_, _encrypt(_, _, 0))
      .InSequence(s)
      .WillOnce(
          Invoke([](std::unique_ptr<IOBuf>& /*buf*/, const IOBuf*, uint64_t) {
            return getBuf("aaaa");
          }));
  EXPECT_CALL(*writeAead_, _encrypt(_, _, 1))
      .InSequence(s)
      .WillOnce(
          Invoke([](std::unique_ptr<IOBuf>& /*buf*/, const IOBuf*, uint64_t) {
            return getBuf("bbbb");
          }));
  auto outBuf = write_.write(std::move(msg));
  expectSame(outBuf.data, "1703034001aaaa1703030a01bbbb");
}

fizz::test::TEST_F	(	FizzBaseTest	,
		TestAppCloseInCallback
	)

Definition at line 289 of file FizzBaseTest.cpp.

References testing::_, EXPECT_CALL, testing::Invoke(), testing::InvokeWithoutArgs(), and s_.

                                             {
  EXPECT_CALL(*TestStateMachine::instance, processSocketData(_, _))
      .InSequence(s_)
      .WillOnce(InvokeWithoutArgs([]() { return Actions{A1()}; }));
  EXPECT_CALL(testFizz_->visitor_, a1())
      .InSequence(s_)
      .WillOnce(Invoke([this]() { testFizz_->appClose(); }));
  EXPECT_CALL(*TestStateMachine::instance, processSocketData(_, _))
      .InSequence(s_)
      .WillOnce(InvokeWithoutArgs([]() { return Actions{A2()}; }));
  EXPECT_CALL(testFizz_->visitor_, a2())
      .InSequence(s_)
      .WillOnce(Invoke([this]() { testFizz_->waitForData(); }));
  EXPECT_CALL(*TestStateMachine::instance, processAppClose(_))
      .InSequence(s_)
      .WillOnce(InvokeWithoutArgs([]() { return Actions{}; }));
  testFizz_->newTransportData();
}

fizz::test::TEST_F	(	AsyncFizzBaseTest	,
		TestReadBufferPause
	)

Definition at line 290 of file AsyncFizzBaseTest.cpp.

References folly::IOBuf::copyBuffer(), EXPECT_CALL, EXPECT_TRUE, testing::Invoke(), folly::gen::move, readBuf_, and testing::Return().

                                               {
  EXPECT_CALL(readCallback_, isBufferMovable_()).WillRepeatedly(Return(false));

  setReadCB(&readCallback_);

  auto buf = IOBuf::copyBuffer("hello");
  expectReadBufRequest(3);
  EXPECT_CALL(readCallback_, readDataAvailable_(3))
      .InSequence(readBufSeq_)
      .WillOnce(Invoke([this](size_t len) {
        EXPECT_TRUE(std::memcmp(readBuf_.data(), "hel", len) == 0);
        this->setReadCB(nullptr);
      }));
  deliverAppData(std::move(buf));

  expectReadBufRequest(20);
  expectReadData("lo");
  setReadCB(&readCallback_);
}

fizz::test::TEST_F	(	FizzBaseTest	,
		TestWriteThenCloseInCallback
	)

Definition at line 308 of file FizzBaseTest.cpp.

References testing::_, appWrite(), EXPECT_CALL, testing::Invoke(), testing::InvokeWithoutArgs(), and s_.

                                                   {
  EXPECT_CALL(
      *TestStateMachine::instance, processAppWrite_(_, WriteMatches("write1")))
      .InSequence(s_)
      .WillOnce(InvokeWithoutArgs([]() { return Actions{A1()}; }));
  EXPECT_CALL(testFizz_->visitor_, a1())
      .InSequence(s_)
      .WillOnce(Invoke([this]() {
        testFizz_->appWrite(appWrite("write2"));
        testFizz_->appClose();
      }));
  EXPECT_CALL(
      *TestStateMachine::instance, processAppWrite_(_, WriteMatches("write2")))
      .InSequence(s_)
      .WillOnce(InvokeWithoutArgs([]() { return Actions{}; }));
  EXPECT_CALL(*TestStateMachine::instance, processAppClose(_))
      .InSequence(s_)
      .WillOnce(InvokeWithoutArgs([]() { return Actions{}; }));
  testFizz_->appWrite(appWrite("write1"));
}

fizz::test::TEST_F	(	AsyncFizzBaseTest	,
		TestTransportReadBufMovable
	)

Definition at line 310 of file AsyncFizzBaseTest.cpp.

References EXPECT_TRUE.

                                                       {
  expectTransportReadCallback();
  startTransportReads();
  EXPECT_TRUE(transportReadCallback_->isBufferMovable());
}

fizz::test::TEST_F	(	EncryptedRecordTest	,
		TestWriteSplittingWholeBuf
	)

Definition at line 311 of file EncryptedRecordTest.cpp.

References testing::_, folly::IOBuf::copyBuffer(), folly::IOBuf::create(), EXPECT_CALL, testing::Invoke(), folly::gen::move, s, and uint64_t.

                                                        {
  TLSMessage msg{ContentType::application_data, IOBuf::create(2000)};
  msg.fragment->append(2000);
  memset(msg.fragment->writableData(), 0x1, msg.fragment->length());
  msg.fragment->prependChain(IOBuf::copyBuffer("moredata"));

  Sequence s;
  EXPECT_CALL(*writeAead_, _encrypt(_, _, _))
      .Times(2)
      .WillRepeatedly(
          Invoke([](std::unique_ptr<IOBuf>& /*buf*/, const IOBuf*, uint64_t) {
            return getBuf("aaaa");
          }));
  write_.write(std::move(msg));
}

fizz::test::TEST_F	(	AsyncFizzBaseTest	,
		TestTransportReadBufMove
	)

Definition at line 316 of file AsyncFizzBaseTest.cpp.

References folly::IOBuf::copyBuffer(), folly::eq, EXPECT_CALL, and EXPECT_TRUE.

                                                    {
  IOBufEqualTo eq;
  expectTransportReadCallback();
  startTransportReads();

  auto buf = IOBuf::copyBuffer("hello");
  EXPECT_CALL(*this, transportDataAvailable());
  transportReadCallback_->readBufferAvailable(buf->clone());
  EXPECT_TRUE(eq(*buf, *transportReadBuf_.front()));

  EXPECT_CALL(*this, transportDataAvailable());
  transportReadCallback_->readBufferAvailable(IOBuf::copyBuffer("world"));
  EXPECT_TRUE(eq(*IOBuf::copyBuffer("helloworld"), *transportReadBuf_.front()));
}

fizz::test::TEST_F	(	EncryptedRecordTest	,
		TestWriteSplittingCombineSmall
	)

Definition at line 327 of file EncryptedRecordTest.cpp.

References testing::_, folly::IOBuf::copyBuffer(), folly::IOBuf::create(), EXPECT_CALL, testing::Invoke(), folly::gen::move, s, and uint64_t.

                                                            {
  TLSMessage msg{ContentType::application_data, IOBuf::create(500)};
  msg.fragment->append(500);
  memset(msg.fragment->writableData(), 0x1, msg.fragment->length());
  msg.fragment->prependChain(IOBuf::copyBuffer("moredata"));

  Sequence s;
  EXPECT_CALL(*writeAead_, _encrypt(_, _, _))
      .Times(1)
      .WillRepeatedly(
          Invoke([](std::unique_ptr<IOBuf>& /*buf*/, const IOBuf*, uint64_t) {
            return getBuf("aaaa");
          }));
  write_.write(std::move(msg));
}

fizz::test::TEST_F	(	FizzBaseTest	,
		TestDeleteInCallback
	)

Definition at line 329 of file FizzBaseTest.cpp.

References testing::_, EXPECT_CALL, testing::Invoke(), testing::InvokeWithoutArgs(), ptr, and s_.

                                           {
  EXPECT_CALL(*TestStateMachine::instance, processSocketData(_, _))
      .InSequence(s_)
      .WillOnce(InvokeWithoutArgs([]() { return Actions{A1()}; }));
  EXPECT_CALL(testFizz_->visitor_, a1())
      .InSequence(s_)
      .WillOnce(Invoke([this]() { testFizz_.reset(); }));
  EXPECT_CALL(*TestStateMachine::instance, processSocketData(_, _))
      .InSequence(s_)
      .WillOnce(InvokeWithoutArgs([]() { return Actions{A2()}; }));
  EXPECT_CALL(testFizz_->visitor_, a2())
      .InSequence(s_)
      .WillOnce(Invoke([ptr = testFizz_.get()]() { ptr->waitForData(); }));
  testFizz_->newTransportData();
}

fizz::test::TEST_F	(	AsyncFizzBaseTest	,
		TestTransportReadBufAvail
	)

Definition at line 331 of file AsyncFizzBaseTest.cpp.

References folly::IOBuf::copyBuffer(), folly::eq, EXPECT_CALL, EXPECT_GE, EXPECT_LE, and EXPECT_TRUE.

                                                     {
  void* buf;
  size_t len;
  IOBufEqualTo eq;
  expectTransportReadCallback();
  startTransportReads();

  EXPECT_CALL(*this, transportDataAvailable());
  transportReadCallback_->getReadBuffer(&buf, &len);
  // Make sure the buffer is a reasonable size.
  EXPECT_GE(len, 128);
  EXPECT_LE(len, 1024 * 64);
  std::memcpy(buf, "hello", 5);
  transportReadCallback_->readDataAvailable(5);
  EXPECT_TRUE(eq(*IOBuf::copyBuffer("hello"), *transportReadBuf_.front()));

  EXPECT_CALL(*this, transportDataAvailable());
  transportReadCallback_->getReadBuffer(&buf, &len);
  std::memcpy(buf, "goodbye", 7);
  transportReadCallback_->readDataAvailable(7);
  EXPECT_TRUE(
      eq(*IOBuf::copyBuffer("hellogoodbye"), *transportReadBuf_.front()));
}

fizz::test::TEST_F	(	EncryptedRecordTest	,
		TestWriteSeqNum
	)

Definition at line 343 of file EncryptedRecordTest.cpp.

References testing::_, EXPECT_CALL, i, testing::Invoke(), folly::gen::move, and uint64_t.

                                             {
  for (int i = 0; i < 10; i++) {
    TLSMessage msg{ContentType::application_data, getBuf("1234567890")};
    EXPECT_CALL(*writeAead_, _encrypt(_, _, i))
        .WillOnce(
            Invoke([](std::unique_ptr<IOBuf>& buf, const IOBuf*, uint64_t) {
              expectSame(buf, "123456789017");
              return getBuf("abcd1234abcd");
            }));
    write_.write(std::move(msg));
  }
}

fizz::test::TEST_F	(	FizzBaseTest	,
		TestStopOnError
	)

Definition at line 345 of file FizzBaseTest.cpp.

References testing::_, Error, EXPECT_CALL, EXPECT_FALSE, EXPECT_TRUE, testing::Invoke(), testing::InvokeWithoutArgs(), and s_.

                                      {
  EXPECT_CALL(*TestStateMachine::instance, processSocketData(_, _))
      .InSequence(s_)
      .WillOnce(InvokeWithoutArgs([]() { return Actions{A1()}; }));
  EXPECT_CALL(testFizz_->visitor_, a1())
      .InSequence(s_)
      .WillOnce(
          Invoke([this]() { testFizz_->state_.state_ = StateEnum::Error; }));
  EXPECT_FALSE(testFizz_->inErrorState());
  testFizz_->newTransportData();
  EXPECT_TRUE(testFizz_->inErrorState());
}

fizz::test::TEST_F	(	AsyncFizzBaseTest	,
		TestTransportReadError
	)

Definition at line 355 of file AsyncFizzBaseTest.cpp.

References testing::_, and EXPECT_CALL.

                                                  {
  expectTransportReadCallback();
  startTransportReads();

  EXPECT_CALL(*this, transportError(_));
  transportReadCallback_->readErr(ase_);
}

fizz::test::TEST_F	(	EncryptedRecordTest	,
		TestWriteEmpty
	)

Definition at line 356 of file EncryptedRecordTest.cpp.

References folly::IOBuf::create(), EXPECT_TRUE, and folly::gen::move.

                                            {
  TLSMessage msg{ContentType::application_data, folly::IOBuf::create(0)};
  auto outBuf = write_.write(std::move(msg));
  EXPECT_TRUE(outBuf.data->empty());
}

fizz::test::TEST_F	(	FizzBaseTest	,
		TestAsyncAction
	)

Definition at line 358 of file FizzBaseTest.cpp.

References testing::_, appWrite(), EXPECT_CALL, folly::Promise< T >::getFuture(), testing::InvokeWithoutArgs(), and folly::Promise< T >::setValue().

                                      {
  Promise<Actions> p;
  EXPECT_CALL(
      *TestStateMachine::instance, processAppWrite_(_, WriteMatches("write1")))
      .WillOnce(InvokeWithoutArgs([&p]() { return p.getFuture(); }));
  testFizz_->appWrite(appWrite("write1"));
  testFizz_->appWrite(appWrite("write2"));
  EXPECT_CALL(
      *TestStateMachine::instance, processAppWrite_(_, WriteMatches("write2")))
      .WillOnce(InvokeWithoutArgs([]() { return Actions{}; }));
  p.setValue(Actions{});
}

fizz::test::TEST_F	(	EncryptedRecordTest	,
		TestWriteMaxSize
	)

Definition at line 362 of file EncryptedRecordTest.cpp.

References testing::_, folly::IOBuf::create(), EXPECT_CALL, testing::Invoke(), folly::gen::move, s, and uint64_t.

                                              {
  write_.setMaxRecord(1900);

  TLSMessage msg{ContentType::application_data, IOBuf::create(2000)};
  msg.fragment->append(2000);
  memset(msg.fragment->writableData(), 0x1, msg.fragment->length());

  Sequence s;
  EXPECT_CALL(*writeAead_, _encrypt(_, _, _))
      .Times(2)
      .WillRepeatedly(
          Invoke([](std::unique_ptr<IOBuf>& /*buf*/, const IOBuf*, uint64_t) {
            return getBuf("aaaa");
          }));
  write_.write(std::move(msg));
}

fizz::test::TEST_F	(	AsyncFizzBaseTest	,
		TestTransportReadEOF
	)

Definition at line 363 of file AsyncFizzBaseTest.cpp.

References testing::_, folly::AsyncSocketException::END_OF_FILE, EXPECT_CALL, EXPECT_EQ, folly::AsyncSocketException::getType(), and testing::Invoke().

                                                {
  expectTransportReadCallback();
  startTransportReads();

  EXPECT_CALL(*this, transportError(_))
      .WillOnce(Invoke([](const AsyncSocketException& ex) {
        EXPECT_EQ(ex.getType(), AsyncSocketException::END_OF_FILE);
      }));
  transportReadCallback_->readEOF();
}

fizz::test::TEST_F	(	FizzBaseTest	,
		TestAsyncActionDelete
	)

Definition at line 371 of file FizzBaseTest.cpp.

References testing::_, appWrite(), EXPECT_CALL, folly::Promise< T >::getFuture(), testing::InvokeWithoutArgs(), and folly::Promise< T >::setValue().

                                            {
  Promise<Actions> p;
  EXPECT_CALL(
      *TestStateMachine::instance, processAppWrite_(_, WriteMatches("write1")))
      .WillOnce(InvokeWithoutArgs([&p]() { return p.getFuture(); }));
  testFizz_->appWrite(appWrite("write1"));
  testFizz_->appWrite(appWrite("write2"));
  testFizz_.reset();
  EXPECT_CALL(
      *TestStateMachine::instance, processAppWrite_(_, WriteMatches("write2")))
      .WillOnce(InvokeWithoutArgs([]() { return Actions{}; }));
  p.setValue(Actions{});
}

fizz::test::TEST_F	(	AsyncFizzBaseTest	,
		TestTransportReadBufPause
	)

Definition at line 374 of file AsyncFizzBaseTest.cpp.

References folly::IOBuf::create(), EXPECT_CALL, EXPECT_EQ, EXPECT_NE, and folly::gen::move.

                                                     {
  expectTransportReadCallback();
  startTransportReads();

  auto bigBuf = IOBuf::create(1024 * 1024);
  bigBuf->append(1024 * 1024);
  expectTransportReadCallback();
  EXPECT_CALL(*this, transportDataAvailable());
  transportReadCallback_->readBufferAvailable(std::move(bigBuf));
  EXPECT_EQ(transportReadCallback_, nullptr);

  expectTransportReadCallback();
  setReadCB(&readCallback_);
  EXPECT_NE(transportReadCallback_, nullptr);
}

fizz::test::TEST_F	(	EncryptedRecordTest	,
		TestWriteMinSize
	)

Definition at line 379 of file EncryptedRecordTest.cpp.

References testing::_, folly::IOBuf::computeChainDataLength(), folly::IOBuf::create(), EXPECT_CALL, EXPECT_EQ, testing::Invoke(), folly::gen::move, cpp.ast::next(), s, and uint64_t.

                                              {
  write_.setMinDesiredRecord(1700);
  TLSMessage msg{ContentType::application_data, IOBuf::create(1000)};
  msg.fragment->append(1000);
  memset(msg.fragment->writableData(), 0x1, msg.fragment->length());
  auto next = IOBuf::create(1000);
  next->append(1000);
  memset(next->writableData(), 0x2, next->length());
  msg.fragment->prependChain(std::move(next));

  Sequence s;
  EXPECT_CALL(*writeAead_, _encrypt(_, _, _))
      .WillOnce(Invoke([](std::unique_ptr<IOBuf>& buf, const IOBuf*, uint64_t) {
        // one byte for footer
        EXPECT_EQ(buf->computeChainDataLength(), 1701);
        return getBuf("aaaa");
      }))
      .WillOnce(Invoke([](std::unique_ptr<IOBuf>& buf, const IOBuf*, uint64_t) {
        // one byte for footer
        EXPECT_EQ(buf->computeChainDataLength(), 301);
        return getBuf("bbbb");
      }));
  write_.write(std::move(msg));
}

fizz::test::TEST_F	(	FizzBaseTest	,
		TestActionProcessing
	)

Definition at line 385 of file FizzBaseTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_FALSE, EXPECT_TRUE, and testing::InvokeWithoutArgs().

                                           {
  EXPECT_CALL(*TestStateMachine::instance, processAppClose(_))
      .WillOnce(InvokeWithoutArgs([this]() {
        EXPECT_TRUE(testFizz_->actionProcessing());
        return Actions{};
      }));
  EXPECT_FALSE(testFizz_->actionProcessing());
  testFizz_->appClose();
  EXPECT_FALSE(testFizz_->actionProcessing());
}

fizz::test::TEST_F	(	AsyncFizzBaseTest	,
		TestAppReadBufPause
	)

Definition at line 390 of file AsyncFizzBaseTest.cpp.

References testing::_, folly::IOBuf::create(), EXPECT_CALL, EXPECT_EQ, EXPECT_NE, folly::gen::move, and testing::Return().

                                               {
  EXPECT_CALL(readCallback_, isBufferMovable_()).WillRepeatedly(Return(true));
  expectTransportReadCallback();
  startTransportReads();

  auto bigBuf = IOBuf::create(1024 * 1024);
  bigBuf->append(1024 * 1024);
  expectTransportReadCallback();
  deliverAppData(std::move(bigBuf));
  EXPECT_EQ(transportReadCallback_, nullptr);

  expectTransportReadCallback();
  EXPECT_CALL(readCallback_, readBufferAvailable_(_));
  setReadCB(&readCallback_);
  EXPECT_NE(transportReadCallback_, nullptr);
}

fizz::test::TEST_F	(	HandshakeTest	,
		BasicHandshake
	)

Definition at line 394 of file HandshakeTest.cpp.

                                      {
  expectSuccess();
  doHandshake();
  verifyParameters();
  sendAppData();
}

fizz::test::TEST_F	(	FizzBaseTest	,
		TestActionProcessingAsync
	)

Definition at line 396 of file FizzBaseTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_FALSE, EXPECT_TRUE, folly::Promise< T >::getFuture(), testing::InvokeWithoutArgs(), and folly::Promise< T >::setValue().

                                                {
  Promise<Actions> p;
  EXPECT_CALL(*TestStateMachine::instance, processAppClose(_))
      .WillOnce(InvokeWithoutArgs([this, &p]() {
        EXPECT_TRUE(testFizz_->actionProcessing());
        return p.getFuture();
      }));
  EXPECT_FALSE(testFizz_->actionProcessing());
  testFizz_->appClose();
  EXPECT_TRUE(testFizz_->actionProcessing());
  p.setValue(Actions{});
  EXPECT_FALSE(testFizz_->actionProcessing());
}

fizz::test::TEST_F	(	HandshakeTest	,
		BasicHandshakeTrickle
	)

Definition at line 401 of file HandshakeTest.cpp.

                                             {
  clientTransport_->setTrickle(true);
  serverTransport_->setTrickle(true);
  expectSuccess();
  doHandshake();
  verifyParameters();
  sendAppData();
}

fizz::test::TEST_F	(	AsyncFizzBaseTest	,
		TestWriteSuccess
	)

Definition at line 407 of file AsyncFizzBaseTest.cpp.

References folly::AsyncWriter::WriteCallback::writeSuccess().

                                            {
  AsyncTransportWrapper::WriteCallback* writeCallback = this;
  writeCallback->writeSuccess();
}

fizz::test::TEST_F	(	FizzBaseTest	,
		TestErrorPendingEvents
	)

Definition at line 410 of file FizzBaseTest.cpp.

References testing::_, appWrite(), fizz::EarlyAppWrite::callback, EXPECT_CALL, EXPECT_FALSE, EXPECT_TRUE, testing::Invoke(), testing::InvokeWithoutArgs(), folly::gen::move, and folly::AsyncSocketException::UNKNOWN.

                                             {
  EXPECT_CALL(
      *TestStateMachine::instance, processAppWrite_(_, WriteMatches("write1")))
      .WillOnce(InvokeWithoutArgs([]() { return Actions{A1()}; }));
  EXPECT_CALL(testFizz_->visitor_, a1()).WillOnce(Invoke([this]() {
    testFizz_->appWrite(appWrite("write2"));
    EarlyAppWrite earlyWrite;
    earlyWrite.callback = &earlyWriteCallback_;
    testFizz_->earlyAppWrite(std::move(earlyWrite));
    auto w3 = appWrite("write3");
    w3.callback = &writeCallback_;
    testFizz_->appWrite(std::move(w3));
    testFizz_->appWrite(appWrite("write4"));
    testFizz_->appClose();
  }));
  EXPECT_CALL(
      *TestStateMachine::instance, processAppWrite_(_, WriteMatches("write2")))
      .WillOnce(InvokeWithoutArgs([this]() {
        testFizz_->moveToErrorState(
            AsyncSocketException{AsyncSocketException::UNKNOWN, "unit test"});
        return Actions{};
      }));
  EXPECT_CALL(earlyWriteCallback_, writeErr_(0, _));
  EXPECT_CALL(writeCallback_, writeErr_(0, _));
  EXPECT_FALSE(testFizz_->inErrorState());
  testFizz_->appWrite(appWrite("write1"));
  EXPECT_TRUE(testFizz_->inErrorState());
}

fizz::test::TEST_F	(	HandshakeTest	,
		P256
	)

Definition at line 410 of file HandshakeTest.cpp.

References clientContext_.

                            {
  clientContext_->setSupportedGroups(
      {NamedGroup::x25519, NamedGroup::secp256r1});
  clientContext_->setDefaultShares({NamedGroup::x25519, NamedGroup::secp256r1});
  serverContext_->setSupportedGroups({NamedGroup::secp256r1});
  expected_.group = NamedGroup::secp256r1;

  expectSuccess();
  doHandshake();
  verifyParameters();
  sendAppData();
}

fizz::test::TEST_F	(	AsyncFizzBaseTest	,
		TestWriteError
	)

Definition at line 412 of file AsyncFizzBaseTest.cpp.

References testing::_, EXPECT_CALL, and folly::AsyncWriter::WriteCallback::writeErr().

                                          {
  AsyncTransportWrapper::WriteCallback* writeCallback = this;
  EXPECT_CALL(*this, transportError(_));
  writeCallback->writeErr(0, ase_);
}

fizz::test::TEST_F	(	AsyncFizzBaseTest	,
		TestHandshakeTimeout
	)

Definition at line 418 of file AsyncFizzBaseTest.cpp.

References testing::_, testing::DoAll(), EXPECT_CALL, EXPECT_EQ, folly::AsyncSocketException::getType(), testing::Invoke(), ON_CALL, testing::Return(), folly::AsyncSocketException::TIMED_OUT, folly::detail::timeout, and folly::AsyncTimeout::timeoutExpired().

                                                {
  MockTimeoutManager manager;
  ON_CALL(manager, isInTimeoutManagerThread()).WillByDefault(Return(true));
  attachTimeoutManager(&manager);
  AsyncTimeout* timeout;

  EXPECT_CALL(manager, scheduleTimeout(_, std::chrono::milliseconds(2)))
      .WillOnce(DoAll(SaveArg<0>(&timeout), Return(true)));
  startHandshakeTimeout(std::chrono::milliseconds(2));

  EXPECT_CALL(*this, transportError(_))
      .WillOnce(Invoke([](const AsyncSocketException& ex) {
        EXPECT_EQ(ex.getType(), AsyncSocketException::TIMED_OUT);
      }));
  timeout->timeoutExpired();
}

fizz::test::TEST_F	(	HandshakeTest	,
		P384
	)

Definition at line 423 of file HandshakeTest.cpp.

References clientContext_.

                            {
  clientContext_->setSupportedGroups(
      {NamedGroup::x25519, NamedGroup::secp384r1});
  clientContext_->setDefaultShares({NamedGroup::x25519, NamedGroup::secp384r1});
  serverContext_->setSupportedGroups({NamedGroup::secp384r1});
  expected_.group = NamedGroup::secp384r1;

  expectSuccess();
  doHandshake();
  verifyParameters();
  sendAppData();
}

fizz::test::TEST_F	(	AsyncFizzBaseTest	,
		TestAttachEventBase
	)

Definition at line 435 of file AsyncFizzBaseTest.cpp.

References EXPECT_CALL, ON_CALL, testing::Return(), s, and socket_.

                                               {
  EventBase evb;
  expectTransportReadCallback();
  startTransportReads();
  ON_CALL(*socket_, good()).WillByDefault(Return(true));
  Sequence s;

  EXPECT_CALL(*socket_, setReadCB(nullptr)).InSequence(s);
  EXPECT_CALL(*socket_, detachEventBase()).InSequence(s);
  detachEventBase();

  EXPECT_CALL(*socket_, attachEventBase(&evb)).InSequence(s);
  EXPECT_CALL(*socket_, setReadCB(transportReadCallback_)).InSequence(s);
  attachEventBase(&evb);
}

fizz::test::TEST_F	(	HandshakeTest	,
		P521
	)

Definition at line 436 of file HandshakeTest.cpp.

References clientContext_.

                            {
  clientContext_->setSupportedGroups(
      {NamedGroup::x25519, NamedGroup::secp521r1});
  clientContext_->setDefaultShares({NamedGroup::x25519, NamedGroup::secp521r1});
  serverContext_->setSupportedGroups({NamedGroup::secp521r1});
  expected_.group = NamedGroup::secp521r1;

  expectSuccess();
  doHandshake();
  verifyParameters();
  sendAppData();
}

fizz::test::TEST_F	(	FizzBaseTest	,
		EventAfterErrorState
	)

Definition at line 439 of file FizzBaseTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_FALSE, EXPECT_TRUE, testing::InvokeWithoutArgs(), and folly::AsyncSocketException::UNKNOWN.

                                           {
  EXPECT_CALL(*TestStateMachine::instance, processSocketData(_, _))
      .WillOnce(InvokeWithoutArgs([this]() {
        testFizz_->moveToErrorState(
            AsyncSocketException{AsyncSocketException::UNKNOWN, "unit test"});
        return Actions{};
      }));
  EXPECT_FALSE(testFizz_->inErrorState());
  testFizz_->newTransportData();
  EXPECT_TRUE(testFizz_->inErrorState());
}

fizz::test::TEST_F	(	HandshakeTest	,
		GroupServerPref
	)

Definition at line 449 of file HandshakeTest.cpp.

References clientContext_.

                                       {
  clientContext_->setSupportedGroups(
      {NamedGroup::secp256r1, NamedGroup::x25519});
  clientContext_->setDefaultShares({NamedGroup::secp256r1, NamedGroup::x25519});
  serverContext_->setSupportedGroups(
      {NamedGroup::x25519, NamedGroup::secp256r1});
  expected_.group = NamedGroup::x25519;

  expectSuccess();
  doHandshake();
  verifyParameters();
  sendAppData();
}

fizz::test::TEST_F	(	FizzBaseTest	,
		TestManyActions
	)

Definition at line 451 of file FizzBaseTest.cpp.

References testing::_, EXPECT_CALL, i, and testing::InvokeWithoutArgs().

                                      {
  size_t i = 0;
  EXPECT_CALL(*TestStateMachine::instance, processSocketData(_, _))
      .WillRepeatedly(InvokeWithoutArgs([this, &i]() {
        if (++i == 10000) {
          testFizz_->waitForData();
        }
        return Actions{};
      }));
  testFizz_->newTransportData();
}

fizz::test::TEST_F	(	AsyncFizzBaseTest	,
		TestAttachEventBaseWithReadCb
	)

Definition at line 451 of file AsyncFizzBaseTest.cpp.

References EXPECT_CALL, ON_CALL, testing::Return(), s, and socket_.

                                                         {
  EventBase evb;
  expectTransportReadCallback();
  startTransportReads();
  ON_CALL(*socket_, good()).WillByDefault(Return(false));
  Sequence s;

  EXPECT_CALL(*socket_, setReadCB(nullptr)).InSequence(s);
  EXPECT_CALL(*socket_, detachEventBase()).InSequence(s);
  detachEventBase();

  expectTransportReadCallback();
  setReadCB(&readCallback_);
  EXPECT_CALL(*socket_, attachEventBase(&evb)).InSequence(s);
  EXPECT_CALL(*socket_, setReadCB(transportReadCallback_)).InSequence(s);
  attachEventBase(&evb);
}

fizz::test::TEST_F	(	HandshakeTest	,
		GroupMismatch
	)

Definition at line 463 of file HandshakeTest.cpp.

References clientContext_.

                                     {
  clientContext_->setSupportedGroups({NamedGroup::secp256r1});
  clientContext_->setDefaultShares({NamedGroup::secp256r1});
  serverContext_->setSupportedGroups({NamedGroup::x25519});

  expectError("alert: handshake_failure", "no group match");
  doHandshake();
}

fizz::test::TEST_F	(	HandshakeTest	,
		SchemeServerPref
	)

Definition at line 472 of file HandshakeTest.cpp.

References clientContext_.

                                        {
  clientContext_->setSupportedSigSchemes(
      {SignatureScheme::ecdsa_secp256r1_sha256,
       SignatureScheme::rsa_pss_sha256});
  serverContext_->setSupportedSigSchemes(
      {SignatureScheme::rsa_pss_sha256,
       SignatureScheme::ecdsa_secp256r1_sha256});
  expected_.scheme = SignatureScheme::rsa_pss_sha256;

  expectSuccess();
  doHandshake();
  verifyParameters();
  sendAppData();
}

fizz::test::TEST_F	(	HandshakeTest	,
		SchemeMismatch
	)

Definition at line 487 of file HandshakeTest.cpp.

References clientContext_.

                                      {
  clientContext_->setSupportedSigSchemes(
      {SignatureScheme::ecdsa_secp256r1_sha256});
  serverContext_->setSupportedSigSchemes({SignatureScheme::rsa_pss_sha256});

  // The server will try using its RSA cert anyway, so it will be the client
  // that actually rejects that.
  expectError("unsupported sig scheme", "alert: illegal_parameter");
  doHandshake();
}

fizz::test::TEST_F	(	HandshakeTest	,
		HRR
	)

Definition at line 498 of file HandshakeTest.cpp.

References clientContext_.

                           {
  clientContext_->setDefaultShares({});
  expected_.clientKexType = expected_.serverKexType =
      KeyExchangeType::HelloRetryRequest;

  expectSuccess();
  doHandshake();
  verifyParameters();
  sendAppData();
}

fizz::test::TEST_F	(	HandshakeTest	,
		PskDheKe
	)

Definition at line 509 of file HandshakeTest.cpp.

                                {
  setupResume();

  expectSuccess();
  doHandshake();
  verifyParameters();
  sendAppData();
}

fizz::test::TEST_F	(	HandshakeTest	,
		HrrPskDheKe
	)

Definition at line 518 of file HandshakeTest.cpp.

References clientContext_.

                                   {
  clientContext_->setDefaultShares({});
  expected_.clientKexType = expected_.serverKexType =
      KeyExchangeType::HelloRetryRequest;
  setupResumeWithHRR();
  expectSuccess();
  doHandshake();
  verifyParameters();
  sendAppData();
}

fizz::test::TEST_F	(	HandshakeTest	,
		HrrPskDheKeWithCache
	)

Definition at line 529 of file HandshakeTest.cpp.

References clientContext_.

                                            {
  clientContext_->setDefaultShares({});
  expected_.clientKexType = expected_.serverKexType =
      KeyExchangeType::HelloRetryRequest;
  setupResume();

  // OneRtt as the first round should have cached the group
  expected_.clientKexType = expected_.serverKexType = KeyExchangeType::OneRtt;
  expectSuccess();
  doHandshake();
  verifyParameters();
  sendAppData();
}

fizz::test::TEST_F	(	HandshakeTest	,
		HrrIncompatiblePsk
	)

Definition at line 543 of file HandshakeTest.cpp.

                                          {
  expectSuccess();
  doHandshake();
  verifyParameters();
  resetTransports();

  serverContext_->setSupportedGroups({NamedGroup::secp256r1});
  serverContext_->setSupportedCiphers({{CipherSuite::TLS_AES_256_GCM_SHA384}});
  expected_.group = NamedGroup::secp256r1;
  expected_.cipher = CipherSuite::TLS_AES_256_GCM_SHA384;
  expected_.clientKexType = expected_.serverKexType =
      KeyExchangeType::HelloRetryRequest;

  expectSuccess();
  doHandshake();
  verifyParameters();
  sendAppData();
}

fizz::test::TEST_F	(	HandshakeTest	,
		PskKe
	)

Definition at line 562 of file HandshakeTest.cpp.

References clientContext_, folly::none, and folly::test::TEST_F().

                             {
  serverContext_->setSupportedPskModes({PskKeyExchangeMode::psk_ke});
  setupResume();

  expected_.group = none;
  expected_.pskMode = PskKeyExchangeMode::psk_ke;
  expected_.clientKexType = expected_.serverKexType = KeyExchangeType::None;

  expectSuccess();
  doHandshake();
  verifyParameters();
  sendAppData();
}

fizz::test::TEST_F	(	HandshakeTest	,
		TestEkmSame
	)

Definition at line 597 of file HandshakeTest.cpp.

References EXPECT_THROW, and EXPECT_TRUE.

                                   {
  expectSuccess();
  doHandshake();
  auto clientEkm = client_->getEkm("EXPORTER-Some-Label", nullptr, 32);
  auto serverEkm = server_->getEkm("EXPORTER-Some-Label", nullptr, 32);
  EXPECT_TRUE(IOBufEqualTo()(clientEkm, serverEkm));
  EXPECT_THROW(
      client_->getEarlyEkm("EXPORTER-Some-Label", nullptr, 32), std::exception);
  EXPECT_THROW(
      server_->getEarlyEkm("EXPORTER-Some-Label", nullptr, 32), std::exception);
}

fizz::test::TEST_F	(	HandshakeTest	,
		TestEarlyEkmSame
	)

Definition at line 609 of file HandshakeTest.cpp.

References clientContext_, and EXPECT_TRUE.

                                        {
  clientContext_->setSendEarlyData(true);
  setupResume();

  expectSuccess();
  doHandshake();
  auto clientEkm = client_->getEarlyEkm("EXPORTER-Some-Label", nullptr, 32);
  auto serverEkm = server_->getEarlyEkm("EXPORTER-Some-Label", nullptr, 32);
  EXPECT_TRUE(IOBufEqualTo()(clientEkm, serverEkm));
}

fizz::test::TEST_F	(	HandshakeTest	,
		TestExtensions
	)

Definition at line 620 of file HandshakeTest.cpp.

References context, EXPECT_EQ, and EXPECT_TRUE.

                                      {
  auto context = std::make_shared<TokenBindingContext>();
  auto clientTokBind = std::make_shared<TokenBindingClientExtension>(context);
  auto serverTokBind = std::make_shared<TokenBindingServerExtension>(context);
  clientExtensions_ = clientTokBind;
  serverExtensions_ = serverTokBind;
  resetTransports();
  doHandshake();
  EXPECT_TRUE(clientTokBind->getNegotiatedKeyParam().hasValue());
  EXPECT_TRUE(clientTokBind->getVersion().hasValue());
  EXPECT_TRUE(serverTokBind->getNegotiatedKeyParam().hasValue());
  EXPECT_EQ(
      *clientTokBind->getNegotiatedKeyParam(),
      TokenBindingKeyParameters::ecdsap256);
  EXPECT_EQ(
      *clientTokBind->getVersion(),
      TokenBindingProtocolVersion::token_binding_0_14);
  EXPECT_EQ(
      *serverTokBind->getNegotiatedKeyParam(),
      TokenBindingKeyParameters::ecdsap256);
}

fizz::test::TEST_F	(	HandshakeTest	,
		BasicCertRequest
	)

Definition at line 642 of file HandshakeTest.cpp.

References getCert(), and kClientAuthClientCert.

                                        {
  expectSuccess();
  serverContext_->setClientAuthMode(ClientAuthMode::Required);
  expected_.clientCert = std::make_shared<PeerCertImpl<KeyType::RSA>>(
      getCert(kClientAuthClientCert));
  doHandshake();
  verifyParameters();
  sendAppData();
}

fizz::test::TEST_F	(	HandshakeTest	,
		CertRequestPskPreservesIdentity
	)

Definition at line 664 of file HandshakeTest.cpp.

References getCert(), and kClientAuthClientCert.

                                                       {
  serverContext_->setClientAuthMode(ClientAuthMode::Required);
  expected_.clientCert = std::make_shared<PeerCertImpl<KeyType::RSA>>(
      getCert(kClientAuthClientCert));
  setupResume();

  expectSuccess();
  doHandshake();
  verifyParameters();
  sendAppData();
}

fizz::test::TEST_F	(	HandshakeTest	,
		CertRequestNoCert
	)

Definition at line 676 of file HandshakeTest.cpp.

References clientContext_.

                                         {
  serverContext_->setClientAuthMode(ClientAuthMode::Required);
  clientContext_->setClientCertificate(nullptr);
  expectServerError(
      "alert: certificate_required", "certificate requested but none received");
  doHandshake();
}

fizz::test::TEST_F	(	HandshakeTest	,
		CertRequestPermitNoCert
	)

Definition at line 684 of file HandshakeTest.cpp.

References clientContext_.

                                               {
  serverContext_->setClientAuthMode(ClientAuthMode::Optional);
  clientContext_->setClientCertificate(nullptr);
  expectSuccess();
  doHandshake();
  verifyParameters();
  sendAppData();
}

fizz::test::TEST_F	(	HandshakeTest	,
		CertRequestBadCert
	)

Definition at line 693 of file HandshakeTest.cpp.

References clientContext_, createCert(), and folly::gen::move.

                                          {
  serverContext_->setClientAuthMode(ClientAuthMode::Required);
  auto badCert = createCert("foo", false, nullptr);
  std::vector<folly::ssl::X509UniquePtr> certVec;
  certVec.emplace_back(std::move(badCert.cert));
  clientContext_->setClientCertificate(
      std::make_shared<SelfCertImpl<KeyType::P256>>(
          std::move(badCert.key), std::move(certVec)));
  expectServerError("alert: bad_certificate", "client certificate failure");
  doHandshake();
}

fizz::test::TEST_F	(	HandshakeTest	,
		BasicCertCompression
	)

Definition at line 705 of file HandshakeTest.cpp.

References clientContext_.

                                            {
  expectSuccess();
  auto decompressor = std::make_shared<ZlibCertificateDecompressor>();
  auto decompressionMgr = std::make_shared<CertDecompressionManager>();
  decompressionMgr->setDecompressors(
      {std::static_pointer_cast<CertificateDecompressor>(decompressor)});
  clientContext_->setCertDecompressionManager(decompressionMgr);
  serverContext_->setSupportedCompressionAlgorithms(
      {CertificateCompressionAlgorithm::zlib});
  expected_.serverCertCompAlgo = CertificateCompressionAlgorithm::zlib;
  doHandshake();
  verifyParameters();
  sendAppData();
}

fizz::test::TEST_F	(	HandshakeTest	,
		EarlyDataAccepted
	)

Definition at line 720 of file HandshakeTest.cpp.

References clientContext_.

                                         {
  clientContext_->setSendEarlyData(true);
  setupResume();

  expected_.pskType = PskType::Resumption;
  expected_.earlyDataType = EarlyDataType::Accepted;

  expectClientSuccess();
  doClientHandshake();
  verifyEarlyParameters();
  clientWrite("early");

  expectReplaySafety();
  expectServerSuccess();
  expectServerRead("early");
  doServerHandshake();
  verifyParameters();
  sendAppData();
}

fizz::test::TEST_F	(	HandshakeTest	,
		EarlyDataRejected
	)

Definition at line 740 of file HandshakeTest.cpp.

References clientContext_.

                                         {
  clientContext_->setSendEarlyData(true);
  setupResume();

  serverContext_->setEarlyDataSettings(false, {}, nullptr);
  expected_.pskType = PskType::Resumption;
  expected_.earlyDataType = EarlyDataType::Rejected;

  expectClientSuccess();
  doClientHandshake();
  verifyEarlyParameters();
  clientWrite("early");

  expectEarlyDataRejectError();
  expectServerSuccess();
  doServerHandshake();
  verifyParameters();
}

fizz::test::TEST_F	(	HandshakeTest	,
		EarlyDataRejectedHrr
	)

Definition at line 759 of file HandshakeTest.cpp.

References clientContext_.

                                            {
  clientContext_->setSendEarlyData(true);
  setupResume();

  serverContext_->setSupportedGroups({NamedGroup::secp256r1});
  expected_.pskType = PskType::Resumption;
  expected_.earlyDataType = EarlyDataType::Rejected;
  expected_.clientKexType = expected_.serverKexType =
      KeyExchangeType::HelloRetryRequest;
  expected_.group = NamedGroup::secp256r1;

  expectClientSuccess();
  doClientHandshake();
  verifyEarlyParameters();
  clientWrite("early");

  expectEarlyDataRejectError();
  expectServerSuccess();
  doServerHandshake();
  verifyParameters();
}

fizz::test::TEST_F	(	HandshakeTest	,
		EarlyDataRejectedResend
	)

Definition at line 781 of file HandshakeTest.cpp.

References clientContext_.

                                               {
  clientContext_->setSendEarlyData(true);
  setupResume();

  serverContext_->setEarlyDataSettings(false, {}, nullptr);
  client_->setEarlyDataRejectionPolicy(
      EarlyDataRejectionPolicy::AutomaticResend);
  expected_.pskType = PskType::Resumption;
  expected_.earlyDataType = EarlyDataType::Rejected;

  expectClientSuccess();
  doClientHandshake();
  verifyEarlyParameters();
  clientWrite("early");

  expectReplaySafety();
  expectServerRead("early");
  expectServerSuccess();
  doServerHandshake();
  verifyParameters();
  sendAppData();
}

fizz::test::TEST_F	(	HandshakeTest	,
		EarlyDataRejectedDontResend
	)

Definition at line 804 of file HandshakeTest.cpp.

References clientContext_, and folly::none.

                                                   {
  clientContext_->setSendEarlyData(true);
  clientContext_->setSupportedAlpns({"h2"});
  serverContext_->setSupportedAlpns({"h2"});
  expected_.alpn = "h2";
  setupResume();

  serverContext_->setSupportedAlpns({});
  client_->setEarlyDataRejectionPolicy(
      EarlyDataRejectionPolicy::AutomaticResend);

  expectClientSuccess();
  doClientHandshake();
  verifyEarlyParameters();
  clientWrite("early");

  expected_.earlyDataType = EarlyDataType::Rejected;
  expected_.alpn = none;

  expectEarlyDataRejectError();
  expectServerSuccess();
  doServerHandshake();
  verifyParameters();

  expected_.pskType = PskType::NotAttempted;
  expected_.pskMode = none;
  expected_.scheme = SignatureScheme::ecdsa_secp256r1_sha256;
  expected_.earlyDataType = EarlyDataType::NotAttempted;

  resetTransports();
  expectSuccess();
  doHandshake();
  verifyParameters();
  sendAppData();
}

fizz::test::TEST_F	(	HandshakeTest	,
		EarlyDataTrickleSendAccepted
	)

Definition at line 840 of file HandshakeTest.cpp.

References clientContext_.

                                                    {
  clientContext_->setSendEarlyData(true);
  setupResume();

  clientTransport_->setTrickle(true, [this]() { clientWrite("e"); });
  expected_.pskType = PskType::Resumption;
  expected_.earlyDataType = EarlyDataType::Accepted;

  expectClientSuccess();
  doClientHandshake();
  verifyEarlyParameters();

  expectReplaySafety();
  expectServerSuccess();
  doServerHandshake();
  verifyParameters();
}

fizz::test::TEST_F	(	HandshakeTest	,
		EarlyDataTrickleSendRejected
	)

Definition at line 858 of file HandshakeTest.cpp.

References clientContext_, getCert(), kClientAuthClientCert, and folly::none.

                                                    {
  clientContext_->setSendEarlyData(true);
  setupResume();

  clientTransport_->setTrickle(true, [this]() { clientWrite("e"); });
  serverContext_->setClientAuthMode(ClientAuthMode::Required);
  serverContext_->setTicketCipher(nullptr);

  expectClientSuccess();
  doClientHandshake();
  verifyEarlyParameters();

  expected_.pskType = PskType::Rejected;
  expected_.pskMode = none;
  expected_.earlyDataType = EarlyDataType::Rejected;
  expected_.scheme = SignatureScheme::ecdsa_secp256r1_sha256;
  expected_.clientCert = std::make_shared<PeerCertImpl<KeyType::RSA>>(
      getCert(kClientAuthClientCert));

  expectEarlyDataRejectError();
  expectServerSuccess();
  doServerHandshake();
  verifyParameters();
}

fizz::test::TEST_F	(	HandshakeTest	,
		Compat
	)

Definition at line 883 of file HandshakeTest.cpp.

References clientContext_.

                              {
  clientContext_->setCompatibilityMode(true);
  expectSuccess();
  doHandshake();
  verifyParameters();
  sendAppData();
}

fizz::test::TEST_F	(	HandshakeTest	,
		TestCompatHRR
	)

Definition at line 891 of file HandshakeTest.cpp.

References clientContext_.

                                     {
  clientContext_->setCompatibilityMode(true);
  clientContext_->setDefaultShares({});
  expected_.clientKexType = expected_.serverKexType =
      KeyExchangeType::HelloRetryRequest;

  expectSuccess();
  doHandshake();
  verifyParameters();
  sendAppData();
}

fizz::test::TEST_F	(	HandshakeTest	,
		TestCompatEarly
	)

Definition at line 903 of file HandshakeTest.cpp.

References clientContext_.

                                       {
  clientContext_->setCompatibilityMode(true);
  clientContext_->setSendEarlyData(true);
  setupResume();

  expected_.pskType = PskType::Resumption;
  expected_.earlyDataType = EarlyDataType::Accepted;

  expectClientSuccess();
  doClientHandshake();
  verifyEarlyParameters();

  expectReplaySafety();
  expectServerSuccess();
  doServerHandshake();
  verifyParameters();
  sendAppData();
}

fizz::test::TEST_F	(	HandshakeTest	,
		TestCompatEarlyRejected
	)

Definition at line 922 of file HandshakeTest.cpp.

References clientContext_.

                                               {
  clientContext_->setCompatibilityMode(true);
  clientContext_->setSendEarlyData(true);
  setupResume();

  serverContext_->setEarlyDataSettings(false, {}, nullptr);
  expected_.pskType = PskType::Resumption;
  expected_.earlyDataType = EarlyDataType::Rejected;

  expectClientSuccess();
  doClientHandshake();
  verifyEarlyParameters();
  clientWrite("early");

  expectEarlyDataRejectError();
  expectServerSuccess();
  doServerHandshake();
  verifyParameters();
}

fizz::test::TEST_F	(	HandshakeTest	,
		TestCompatEarlyRejectedHRR
	)

Definition at line 942 of file HandshakeTest.cpp.

References clientContext_.

                                                  {
  clientContext_->setCompatibilityMode(true);
  clientContext_->setSendEarlyData(true);
  setupResume();

  serverContext_->setSupportedGroups({NamedGroup::secp256r1});
  expected_.pskType = PskType::Resumption;
  expected_.earlyDataType = EarlyDataType::Rejected;
  expected_.clientKexType = expected_.serverKexType =
      KeyExchangeType::HelloRetryRequest;
  expected_.group = NamedGroup::secp256r1;

  expectClientSuccess();
  doClientHandshake();
  verifyEarlyParameters();
  clientWrite("early");

  expectEarlyDataRejectError();
  expectServerSuccess();
  doServerHandshake();
  verifyParameters();
}

fizz::test::TEST_F	(	HandshakeTest	,
		TestCookie
	)

Definition at line 965 of file HandshakeTest.cpp.

                                  {
  expected_.clientKexType = KeyExchangeType::HelloRetryRequest;

  expectSuccess();
  resetTransportsAndDoCookieHandshake();
  verifyParameters();
  sendAppData();
}

fizz::test::TEST_F	(	HandshakeTest	,
		TestCookieGroupNegotiate
	)

Definition at line 974 of file HandshakeTest.cpp.

References clientContext_.

                                                {
  clientContext_->setDefaultShares({});
  expected_.clientKexType = KeyExchangeType::HelloRetryRequest;

  expectSuccess();
  resetTransportsAndDoCookieHandshake();
  verifyParameters();
  sendAppData();
}

fizz::test::TEST_F	(	HandshakeTest	,
		TestCookieResume
	)

Definition at line 984 of file HandshakeTest.cpp.

                                        {
  setupResume();

  expected_.clientKexType = KeyExchangeType::HelloRetryRequest;

  expectSuccess();
  resetTransportsAndDoCookieHandshake();
  verifyParameters();
  sendAppData();
}

fizz::test::TEST_F	(	HandshakeTest	,
		TestCookieIncompatiblePsk
	)

Definition at line 995 of file HandshakeTest.cpp.

                                                 {
  expectSuccess();
  doHandshake();
  verifyParameters();

  serverContext_->setSupportedCiphers({{CipherSuite::TLS_AES_256_GCM_SHA384}});
  expected_.cipher = CipherSuite::TLS_AES_256_GCM_SHA384;
  expected_.clientKexType = KeyExchangeType::HelloRetryRequest;

  expectSuccess();
  resetTransportsAndDoCookieHandshake();
  verifyParameters();
  sendAppData();
}

fizz::test::TEST_F	(	HandshakeTest	,
		TestCookiePskKe
	)

Definition at line 1010 of file HandshakeTest.cpp.

References folly::none.

                                       {
  serverContext_->setSupportedPskModes({PskKeyExchangeMode::psk_ke});
  setupResume();

  expected_.group = none;
  expected_.pskMode = PskKeyExchangeMode::psk_ke;
  expected_.clientKexType = KeyExchangeType::None;
  expected_.serverKexType = KeyExchangeType::None;

  expectSuccess();
  resetTransportsAndDoCookieHandshake();
  verifyParameters();
  sendAppData();
}

fizz::test::TEST_F	(	HandshakeTest	,
		TestBadCookie
	)

Definition at line 1025 of file HandshakeTest.cpp.

References INSTANTIATE_TEST_CASE_P(), and folly::range().

                                     {
  expectError("decrypt_error", "could not decrypt cookie");
  resetTransportsAndStartCookieHandshake();

  auto cookieSeed = RandomGenerator<32>().generateRandom();
  cookieCipher_->setCookieSecrets({{range(cookieSeed)}});

  doServerHandshake();
}

fizz::test::TEST_P	(	HkdfTest	,
		TestHkdfSha256Expand
	)

Definition at line 31 of file HkdfTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, deadlock::info(), testing::INSTANTIATE_TEST_CASE_P(), and toIOBuf().

                                       {
  auto ikm = toIOBuf(GetParam().ikm);
  auto salt = toIOBuf(GetParam().salt);
  auto info = toIOBuf(GetParam().info);
  size_t outputBytes = GetParam().outputBytes;
  auto expectedOkm = toIOBuf(GetParam().okm);
  CHECK_EQ(outputBytes, expectedOkm->length());

  auto actualOkm = HkdfImpl<Sha256>().hkdf(
      ikm->coalesce(), salt->coalesce(), *info, outputBytes);
  EXPECT_FALSE(actualOkm->isChained());
  EXPECT_EQ(outputBytes, actualOkm->length());
  EXPECT_FALSE(memcmp(actualOkm->data(), expectedOkm->data(), outputBytes));
}

fizz::test::TEST_P	(	OpenSSLEVPCipherTest	,
		TestEncrypt
	)

Definition at line 129 of file OpenSSLEVPCipherTest.cpp.

References callEncrypt(), cipher, EXPECT_EQ, and getCipher().

                                          {
  auto cipher = getCipher(GetParam());
  auto out = callEncrypt(cipher, GetParam());
  EXPECT_EQ(out->headroom(), 0);
}

fizz::test::TEST_P	(	OpenSSLEVPCipherTest	,
		TestEncryptWithTagRoom
	)

Definition at line 135 of file OpenSSLEVPCipherTest.cpp.

References callEncrypt(), cipher, EXPECT_FALSE, getCipher(), folly::gen::move, and toIOBuf().

                                                     {
  auto cipher = getCipher(GetParam());
  auto input = toIOBuf(GetParam().plaintext, 0, cipher->getCipherOverhead());
  auto out = callEncrypt(cipher, GetParam(), std::move(input));
  EXPECT_FALSE(out->isChained());
}

fizz::test::TEST_P	(	OpenSSLEVPCipherTest	,
		TestEncryptReusedCipher
	)

Definition at line 142 of file OpenSSLEVPCipherTest.cpp.

References callEncrypt(), cipher, getCipher(), and params.

                                                      {
  auto cipher = getCipher(GetParam());
  auto params = GetParam();
  callEncrypt(cipher, params);
  callEncrypt(cipher, GetParam());
}

fizz::test::TEST_P	(	OpenSSLEVPCipherTest	,
		TestEncryptChunkedInput
	)

Definition at line 149 of file OpenSSLEVPCipherTest.cpp.

References callEncrypt(), chunkIOBuf(), cipher, getCipher(), folly::gen::move, and toIOBuf().

                                                      {
  auto cipher = getCipher(GetParam());
  auto input = toIOBuf(GetParam().plaintext);
  auto chunkedInput = chunkIOBuf(std::move(input), 3);
  callEncrypt(cipher, GetParam(), std::move(chunkedInput));
}

fizz::test::TEST_P	(	OpenSSLEVPCipherTest	,
		TestEncryptChunkedInputWithTagRoomHead
	)

Definition at line 156 of file OpenSSLEVPCipherTest.cpp.

References callEncrypt(), chunkIOBuf(), cipher, folly::IOBuf::create(), EXPECT_GE, getCipher(), folly::gen::move, and toIOBuf().

                                                                     {
  auto cipher = getCipher(GetParam());
  auto input = toIOBuf(GetParam().plaintext);
  auto overhead = cipher->getCipherOverhead();
  auto creator = [overhead](size_t len, size_t num) {
    if (num == 0) {
      // create a buffer w/ room for the tag
      auto result = IOBuf::create(len + overhead);
      result->reserve(0, overhead);
      return result;
    }
    return IOBuf::create(len);
  };
  auto chunkedInput = chunkIOBuf(std::move(input), 3, creator);
  auto out = callEncrypt(cipher, GetParam(), std::move(chunkedInput));
  // even though the head element has tailroom, we don't use it since it's
  // the last element that needs to have it for copying tag in directly
  EXPECT_GE(out->tailroom(), overhead);
}

fizz::test::TEST_P	(	OpenSSLEVPCipherTest	,
		TestEncryptChunkedInputWithTagRoomLast
	)

Definition at line 176 of file OpenSSLEVPCipherTest.cpp.

References callEncrypt(), chunkIOBuf(), chunks, cipher, folly::IOBuf::create(), EXPECT_EQ, getCipher(), folly::gen::move, and toIOBuf().

                                                                     {
  auto cipher = getCipher(GetParam());
  auto input = toIOBuf(GetParam().plaintext);
  auto overhead = cipher->getCipherOverhead();
  size_t chunks = 3;
  auto creator = [=](size_t len, size_t num) {
    if (num == chunks - 1) {
      // create a buffer w/ room for the tag
      auto result = IOBuf::create(len + overhead);
      result->reserve(0, overhead);
      return result;
    }
    return IOBuf::create(len);
  };
  auto chunkedInput = chunkIOBuf(std::move(input), chunks, creator);
  auto lastTailRoom = chunkedInput->prev()->tailroom();
  auto numElements = chunkedInput->countChainElements();
  auto out = callEncrypt(cipher, GetParam(), std::move(chunkedInput));
  // we expect the last element in the chain to have tailroom - overhead
  // left
  EXPECT_EQ(out->prev()->tailroom(), lastTailRoom - overhead);
  EXPECT_EQ(out->countChainElements(), numElements);
}

fizz::test::TEST_P	(	OpenSSLEVPCipherTest	,
		TestEncryptChunkedSharedInput
	)

Definition at line 200 of file OpenSSLEVPCipherTest.cpp.

References callEncrypt(), chunkIOBuf(), cipher, EXPECT_EQ, EXPECT_FALSE, getCipher(), kHeadroom, folly::gen::move, and toIOBuf().

                                                            {
  auto cipher = getCipher(GetParam());
  auto input = toIOBuf(GetParam().plaintext);
  auto chunkedInput = chunkIOBuf(std::move(input), 3);
  auto out = callEncrypt(cipher, GetParam(), chunkedInput->clone());
  // we expect headroom of record size and a single buffer in the
  // the chain
  EXPECT_EQ(out->headroom(), kHeadroom);
  EXPECT_FALSE(out->isChained());
}

fizz::test::TEST_P	(	OpenSSLEVPCipherTest	,
		TestEncryptChunkedAad
	)

Definition at line 211 of file OpenSSLEVPCipherTest.cpp.

References callEncrypt(), chunkIOBuf(), cipher, getCipher(), folly::gen::move, and toIOBuf().

                                                    {
  auto cipher = getCipher(GetParam());
  auto aad = toIOBuf(GetParam().aad);
  auto chunkedAad = chunkIOBuf(std::move(aad), 3);
  callEncrypt(cipher, GetParam(), nullptr, std::move(chunkedAad));
}

fizz::test::TEST_P	(	ECDHTest	,
		TestKeyAgreement
	)

Definition at line 216 of file ECKeyExchangeTest.cpp.

References ASSERT_EQ, ASSERT_TRUE, EXPECT_EQ, EXPECT_FALSE, EXPECT_NE, fizz::detail::OpenSSLECKeyExchange< T >::generateSharedSecret(), getKey(), getNid(), folly::hexlify(), INSTANTIATE_TEST_CASE_P(), folly::gen::move, folly::IOBuf::moveToFbString(), setPoint(), fizz::detail::OpenSSLECKeyExchange< T >::setPrivateKey(), and folly::detail::success.

                                   {
  try {
    auto privateKey = getKey(GetParam());
    ASSERT_TRUE(privateKey);
    // Create the peer key
    EcKeyUniquePtr peerKey(EC_KEY_new_by_curve_name(getNid(GetParam())));
    setPoint(peerKey, GetParam().peerX, GetParam().peerY);

    EvpPkeyUniquePtr pkeyPeerKey(EVP_PKEY_new());
    ASSERT_EQ(1, EVP_PKEY_set1_EC_KEY(pkeyPeerKey.get(), peerKey.get()));
    std::unique_ptr<folly::IOBuf> shared;
    switch (GetParam().key) {
      case KeyType::P256: {
        P256KeyExchange kex;
        kex.setPrivateKey(std::move(privateKey));
        shared = kex.generateSharedSecret(pkeyPeerKey);
        break;
      }
      case KeyType::P384: {
        P384KeyExchange kex;
        kex.setPrivateKey(std::move(privateKey));
        shared = kex.generateSharedSecret(pkeyPeerKey);
        break;
      }
      case KeyType::P521: {
        P521KeyExchange kex;
        kex.setPrivateKey(std::move(privateKey));
        shared = kex.generateSharedSecret(pkeyPeerKey);
        break;
      }
      default:
        throw std::runtime_error("unknown key type");
    }

    ASSERT_TRUE(shared);
    auto sharedString = shared->moveToFbString();
    auto hexShared = hexlify(sharedString);
    if (GetParam().success) {
      EXPECT_EQ(GetParam().shared, hexShared);
    } else {
      EXPECT_NE(GetParam().shared, hexShared);
    }
  } catch (const std::runtime_error& ex) {
    EXPECT_FALSE(GetParam().success) << ex.what();
  }
}

fizz::test::TEST_P	(	OpenSSLEVPCipherTest	,
		TestDecrypt
	)

Definition at line 218 of file OpenSSLEVPCipherTest.cpp.

References callDecrypt(), cipher, and getCipher().

                                          {
  auto cipher = getCipher(GetParam());
  callDecrypt(cipher, GetParam());
}

fizz::test::TEST_P	(	OpenSSLEVPCipherTest	,
		TestDecryptReusedCipher
	)

Definition at line 223 of file OpenSSLEVPCipherTest.cpp.

References callDecrypt(), cipher, getCipher(), and params.

                                                      {
  auto cipher = getCipher(GetParam());
  auto params = GetParam();
  callDecrypt(cipher, params);
  callDecrypt(cipher, GetParam());
}

fizz::test::TEST_P	(	OpenSSLEVPCipherTest	,
		TestDecryptInputTooSmall
	)

Definition at line 230 of file OpenSSLEVPCipherTest.cpp.

References callDecrypt(), cipher, folly::IOBuf::copyBuffer(), getCipher(), and folly::gen::move.

                                                       {
  auto cipher = getCipher(GetParam());
  auto in = IOBuf::copyBuffer("in");
  auto paramsCopy = GetParam();
  paramsCopy.valid = false;
  callDecrypt(cipher, paramsCopy, std::move(in));
}

fizz::test::TEST_P	(	OpenSSLEVPCipherTest	,
		TestDecryptWithChunkedInput
	)

Definition at line 238 of file OpenSSLEVPCipherTest.cpp.

References callDecrypt(), chunkIOBuf(), cipher, getCipher(), folly::gen::move, gmock_output_test::output, and toIOBuf().

                                                          {
  auto cipher = getCipher(GetParam());
  auto output = toIOBuf(GetParam().ciphertext);
  auto chunkedOutput = chunkIOBuf(std::move(output), 3);
  callDecrypt(cipher, GetParam(), std::move(chunkedOutput));
}

fizz::test::TEST_P	(	OpenSSLEVPCipherTest	,
		TestDecryptWithChunkedSharedInput
	)

Definition at line 245 of file OpenSSLEVPCipherTest.cpp.

References callDecrypt(), chunkIOBuf(), cipher, getCipher(), folly::gen::move, gmock_output_test::output, and toIOBuf().

                                                                {
  auto cipher = getCipher(GetParam());
  auto output = toIOBuf(GetParam().ciphertext);
  auto chunkedOutput = chunkIOBuf(std::move(output), 3);
  callDecrypt(cipher, GetParam(), chunkedOutput->clone());
}

fizz::test::TEST_P	(	OpenSSLEVPCipherTest	,
		TestDecryptWithVeryChunkedInput
	)

Definition at line 252 of file OpenSSLEVPCipherTest.cpp.

References callDecrypt(), chunkIOBuf(), cipher, getCipher(), folly::gen::move, gmock_output_test::output, and toIOBuf().

                                                              {
  auto cipher = getCipher(GetParam());
  auto output = toIOBuf(GetParam().ciphertext);
  auto chunkedOutput = chunkIOBuf(std::move(output), 30);
  callDecrypt(cipher, GetParam(), std::move(chunkedOutput));
}

fizz::test::TEST_P	(	OpenSSLEVPCipherTest	,
		TestDecryptWithChunkedAad
	)

Definition at line 259 of file OpenSSLEVPCipherTest.cpp.

References callDecrypt(), chunkIOBuf(), cipher, getCipher(), folly::gen::move, and toIOBuf().

                                                        {
  auto cipher = getCipher(GetParam());
  auto aad = toIOBuf(GetParam().aad);
  auto chunkedAad = chunkIOBuf(std::move(aad), 3);
  callDecrypt(cipher, GetParam(), nullptr, std::move(chunkedAad));
}

fizz::test::TEST_P	(	OpenSSLEVPCipherTest	,
		TestTryDecrypt
	)

Definition at line 266 of file OpenSSLEVPCipherTest.cpp.

References cipher, EXPECT_FALSE, EXPECT_TRUE, getCipher(), INSTANTIATE_TEST_CASE_P(), and toIOBuf().

                                             {
  auto cipher = getCipher(GetParam());
  auto out = cipher->tryDecrypt(
      toIOBuf(GetParam().ciphertext),
      toIOBuf(GetParam().aad).get(),
      GetParam().seqNum);
  if (out) {
    EXPECT_TRUE(GetParam().valid);
    EXPECT_TRUE(IOBufEqualTo()(toIOBuf(GetParam().plaintext), *out));
  } else {
    EXPECT_FALSE(GetParam().valid);
  }
}

fizz::test::TEST_P	(	SigSchemeTest	,
		Schemes
	)

Definition at line 652 of file HandshakeTest.cpp.

References clientContext_.

                               {
  SignatureScheme scheme = GetParam();
  clientContext_->setSupportedSigSchemes({scheme});
  serverContext_->setSupportedSigSchemes({scheme});
  expected_.scheme = scheme;

  expectSuccess();
  doHandshake();
  verifyParameters();
  sendAppData();
}

template<typename A , typename B >

void fizz::test::throwIfNeq	(	const A &	a,
		const B &	b,
		const std::string &	msg
	)

Definition at line 22 of file Utilities.h.

Referenced by createCert().

                                                              {
  if (a != b) {
    throw std::runtime_error(msg);
  }
}

template<typename A >

void fizz::test::throwIfNull	(	const A &	a,
		const std::string &	msg
	)

Definition at line 29 of file Utilities.h.

Referenced by createCert().

                                                   {
  if (a == nullptr) {
    throw std::runtime_error(msg);
  }
}

std::unique_ptr< folly::IOBuf > fizz::test::toIOBuf	(	std::string	hexData,
		size_t	headroom,
		size_t	tailroom
	)

Definition at line 24 of file TestUtil.cpp.

References folly::IOBuf::copyBuffer(), string, and folly::unhexlify().

Referenced by fizz::server::test::AeadTicketCipherTest::setTicketSecrets(), fizz::server::test::AeadCookieCipherTest::SetUp(), fizz::server::test::TEST(), and fizz::server::test::TEST_F().

                                                             {
  std::string out;
  CHECK(folly::unhexlify(hexData, out));
  return folly::IOBuf::copyBuffer(out, headroom, tailroom);
}

std::unique_ptr< folly::IOBuf > fizz::test::toIOBuf

(

folly::StringPiece

hexData

)

Definition at line 42 of file TestUtil.cpp.

References folly::IOBuf::copyBuffer(), string, and folly::unhexlify().

                                                            {
  std::string out;
  CHECK(folly::unhexlify(hexData, out));
  return folly::IOBuf::copyBuffer(out);
}

fizz::test::TYPED_TEST	(	Key	,
		GenerateKey
	)

Definition at line 109 of file ECKeyExchangeTest.cpp.

                             {
  typename TestFixture::KeyExch kex;
  kex.generateKeyPair();
}

fizz::test::TYPED_TEST	(	Key	,
		SharedSecret
	)

Definition at line 114 of file ECKeyExchangeTest.cpp.

References EXPECT_TRUE.

                              {
  typename TestFixture::KeyExch kex;
  kex.generateKeyPair();
  auto shared = kex.generateSharedSecret(kex.getKey());
  EXPECT_TRUE(shared);
}

fizz::test::TYPED_TEST	(	Key	,
		ReadFromKey
	)

Definition at line 121 of file ECKeyExchangeTest.cpp.

References EXPECT_TRUE, getPrivateKey(), and folly::gen::move.

                             {
  typename TestFixture::KeyExch kex;
  auto pkey = getPrivateKey(this->getKeyParams().privateKey);
  kex.setPrivateKey(std::move(pkey));

  auto pkey2 = getPrivateKey(this->getKeyParams().privateKey);
  typename TestFixture::KeyExch kex2;
  kex2.setPrivateKey(std::move(pkey2));
  auto shared = kex.generateSharedSecret(kex2.getKey());
  EXPECT_TRUE(shared);
}

fizz::test::TYPED_TEST	(	Key	,
		ReadWrongGroup
	)

Definition at line 133 of file ECKeyExchangeTest.cpp.

References EXPECT_THROW, getPrivateKey(), and folly::gen::move.

                                {
  auto pkey = getPrivateKey(this->getKeyParams().invalidPrivateKey);
  typename TestFixture::KeyExch kex;
  EXPECT_THROW(kex.setPrivateKey(std::move(pkey)), std::runtime_error);
}

fizz::test::TYPED_TEST	(	Key	,
		Decode
	)

Definition at line 139 of file ECKeyExchangeTest.cpp.

References fizz::decode(), EXPECT_TRUE, folly::range(), string, and folly::unhexlify().

                        {
  std::string out = unhexlify(this->getKeyParams().encodedShare);
  auto pub = detail::OpenSSLECKeyDecoder<TypeParam>::decode(range(out));
  EXPECT_TRUE(pub);
}

fizz::test::TYPED_TEST	(	Key	,
		Encode
	)

Definition at line 145 of file ECKeyExchangeTest.cpp.

References fizz::decode(), encode(), EXPECT_EQ, EXPECT_TRUE, folly::range(), string, and folly::unhexlify().

                        {
  std::string out = unhexlify(this->getKeyParams().encodedShare);
  auto pub = detail::OpenSSLECKeyDecoder<TypeParam>::decode(range(out));
  EXPECT_TRUE(pub);
  auto encoded = detail::OpenSSLECKeyEncoder::encode(pub);

  auto encodedStr = encoded->moveToFbString();
  EXPECT_EQ(encodedStr, out);
}

fizz::test::TYPED_TEST	(	Key	,
		DecodeInvalid
	)

Definition at line 155 of file ECKeyExchangeTest.cpp.

References EXPECT_THROW, folly::range(), string, and folly::unhexlify().

                               {
  std::string out = unhexlify(this->getKeyParams().invalidEncodedShare);
  EXPECT_THROW(
      detail::OpenSSLECKeyDecoder<TypeParam>::decode(range(out)),
      std::runtime_error);
}

fizz::test::TYPED_TEST	(	Key	,
		DecodeInvalidSmallLength
	)

Definition at line 162 of file ECKeyExchangeTest.cpp.

References EXPECT_THROW, folly::range(), string, and folly::unhexlify().

                                          {
  std::string out = unhexlify(this->getKeyParams().tooSmallEncodedShare);
  EXPECT_THROW(
      detail::OpenSSLECKeyDecoder<TypeParam>::decode(range(out)),
      std::runtime_error);
}

fizz::test::TYPED_TEST	(	CertTestTyped	,
		MatchingCert
	)

Definition at line 187 of file CertTest.cpp.

References fizz::certificate, and folly::gen::move.

                                        {
  std::vector<folly::ssl::X509UniquePtr> certs;
  certs.push_back(getCert<TypeParam>());
  SelfCertImpl<TypeParam::Type> certificate(
      getKey<TypeParam>(), std::move(certs));
}

fizz::test::TYPED_TEST	(	CertTestTyped	,
		MismatchedCert
	)

Definition at line 194 of file CertTest.cpp.

References fizz::certificate, EXPECT_THROW, and folly::gen::move.

                                          {
  std::vector<folly::ssl::X509UniquePtr> certs;
  certs.push_back(getCert<TypeParam>());
  EXPECT_THROW(
      SelfCertImpl<TypeParam::Type> certificate(
          getKey<typename TypeParam::Invalid>(), std::move(certs)),
      std::runtime_error);
}

fizz::test::TYPED_TEST	(	CertTestTyped	,
		SigSchemes
	)

Definition at line 203 of file CertTest.cpp.

References fizz::certificate, EXPECT_EQ, fizz::SelfCertImpl< T >::getSigSchemes(), and folly::gen::move.

                                      {
  std::vector<folly::ssl::X509UniquePtr> certs;
  certs.push_back(getCert<TypeParam>());
  SelfCertImpl<TypeParam::Type> certificate(
      getKey<TypeParam>(), std::move(certs));

  std::vector<SignatureScheme> expected{TypeParam::Scheme};
  EXPECT_EQ(certificate.getSigSchemes(), expected);
}

fizz::test::TYPED_TEST	(	CertTestTyped	,
		TestSignVerify
	)

Definition at line 213 of file CertTest.cpp.

References folly::gen::move, folly::sig, fizz::SelfCertImpl< T >::sign(), and fizz::PeerCertImpl< T >::verify().

                                          {
  PeerCertImpl<TypeParam::Type> peerCert(getCert<TypeParam>());
  std::vector<folly::ssl::X509UniquePtr> certs;
  certs.push_back(getCert<TypeParam>());
  SelfCertImpl<TypeParam::Type> selfCert(getKey<TypeParam>(), std::move(certs));

  StringPiece tbs{"ToBeSigned"};
  auto sig =
      selfCert.sign(TypeParam::Scheme, CertificateVerifyContext::Server, tbs);
  peerCert.verify(
      TypeParam::Scheme,
      CertificateVerifyContext::Server,
      tbs,
      sig->coalesce());
}

fizz::test::TYPED_TEST	(	CertTestTyped	,
		TestSignVerifyBitFlip
	)

Definition at line 229 of file CertTest.cpp.

References EXPECT_THROW, folly::gen::move, folly::sig, fizz::SelfCertImpl< T >::sign(), and fizz::PeerCertImpl< T >::verify().

                                                 {
  PeerCertImpl<TypeParam::Type> peerCert(getCert<TypeParam>());
  std::vector<folly::ssl::X509UniquePtr> certs;
  certs.push_back(getCert<TypeParam>());
  SelfCertImpl<TypeParam::Type> selfCert(getKey<TypeParam>(), std::move(certs));

  StringPiece tbs{"ToBeSigned"};
  auto sig =
      selfCert.sign(TypeParam::Scheme, CertificateVerifyContext::Server, tbs);
  sig->writableData()[1] ^= 0x20;
  EXPECT_THROW(
      peerCert.verify(
          TypeParam::Scheme,
          CertificateVerifyContext::Server,
          tbs,
          sig->coalesce()),
      std::runtime_error);
}

fizz::test::TYPED_TEST	(	CertTestTyped	,
		TestSignVerifyWrongSize
	)

Definition at line 248 of file CertTest.cpp.

References folly::IOBuf::copyBuffer(), EXPECT_THROW, folly::gen::move, folly::sig, fizz::SelfCertImpl< T >::sign(), and fizz::PeerCertImpl< T >::verify().

                                                   {
  PeerCertImpl<TypeParam::Type> peerCert(getCert<TypeParam>());
  std::vector<folly::ssl::X509UniquePtr> certs;
  certs.push_back(getCert<TypeParam>());
  SelfCertImpl<TypeParam::Type> selfCert(getKey<TypeParam>(), std::move(certs));

  StringPiece tbs{"ToBeSigned"};
  auto sig =
      selfCert.sign(TypeParam::Scheme, CertificateVerifyContext::Server, tbs);
  sig->prependChain(IOBuf::copyBuffer("x"));
  EXPECT_THROW(
      peerCert.verify(
          TypeParam::Scheme,
          CertificateVerifyContext::Server,
          tbs,
          sig->coalesce()),
      std::runtime_error);
}

fizz::test::TYPED_TEST	(	CertTestTyped	,
		TestVerifyWrongScheme
	)

Definition at line 267 of file CertTest.cpp.

References EXPECT_THROW, folly::gen::move, folly::sig, fizz::SelfCertImpl< T >::sign(), and fizz::PeerCertImpl< T >::verify().

                                                 {
  PeerCertImpl<TypeParam::Type> peerCert(getCert<TypeParam>());
  std::vector<folly::ssl::X509UniquePtr> certs;
  certs.push_back(getCert<TypeParam>());
  SelfCertImpl<TypeParam::Type> selfCert(getKey<TypeParam>(), std::move(certs));

  StringPiece tbs{"ToBeSigned"};
  auto sig =
      selfCert.sign(TypeParam::Scheme, CertificateVerifyContext::Server, tbs);
  EXPECT_THROW(
      peerCert.verify(
          TypeParam::Invalid::Scheme,
          CertificateVerifyContext::Server,
          tbs,
          sig->coalesce()),
      std::runtime_error);
}

fizz::test::TYPED_TEST	(	CertTestTyped	,
		TestVerifyDecodedCert
	)

Definition at line 285 of file CertTest.cpp.

References folly::gen::move, folly::sig, and fizz::SelfCertImpl< T >::sign().

                                                 {
  std::vector<folly::ssl::X509UniquePtr> certs;
  certs.push_back(getCert<TypeParam>());
  auto msg = CertUtils::getCertMessage(certs, nullptr);
  SelfCertImpl<TypeParam::Type> selfCert(getKey<TypeParam>(), std::move(certs));

  auto peerCert = CertUtils::makePeerCert(
      std::move(msg.certificate_list.front().cert_data));

  StringPiece tbs{"ToBeSigned"};
  auto sig =
      selfCert.sign(TypeParam::Scheme, CertificateVerifyContext::Server, tbs);
  peerCert->verify(
      TypeParam::Scheme,
      CertificateVerifyContext::Server,
      tbs,
      sig->coalesce());
}

fizz::test::TYPED_TEST_CASE	(	Key	,
		KeyTypes
	)

fizz::test::TYPED_TEST_CASE	(	CertTestTyped	,
		KeyTypes
	)

void fizz::test::useMockRandom

(

)

Definition at line 69 of file TestUtil.cpp.

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

                     {
  randombytes_set_implementation(&mockRandom);
}

static WriteNewSessionTicket fizz::test::writeNewSessionTicket ( const std::string &  str )

static

Definition at line 24 of file FizzBaseTest.cpp.

References fizz::WriteNewSessionTicket::appToken, folly::IOBuf::copyBuffer(), and fizz::detail::write().

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

                                                                         {
  WriteNewSessionTicket write;
  write.appToken = IOBuf::copyBuffer(str);
  return write;
}

Variable Documentation

StringPiece fizz::test::basic_expected_ekm

Initial value:

= {
    "55549d2d280d8507823a80c2ee69530e5dcc6a04e86f1bae1ef23a86337341a8"}

Definition at line 21 of file ExporterTest.cpp.

const std::string fizz::test::exampleCompressedCertificate

static

Definition at line 23 of file ZlibCertificateCompressorTest.cpp.

Referenced by TEST_F().

StringPiece fizz::test::expected_auth_request

Initial value:

= {
    "14303132333435363738396162636465666768696a000a000d0006000404030804"}

Definition at line 29 of file ExportedAuthenticatorTest.cpp.

StringPiece fizz::test::expected_authenticator

Initial value:

= {
    "0b000004000000000f00000d040300097369676e617475726514000020b523548c421b05f7f3c33276fbdd5266ba2df103796d7d483368259860a648f2"}

Definition at line 31 of file ExportedAuthenticatorTest.cpp.

StringPiece fizz::test::expected_cert

Initial value:

= {
    "308201ee30820195a003020102020900c569eec901ce86d9300a06082a8648ce3d0403023054310b3009060355040613025553310b300906035504080c024e59310b300906035504070c024e59310d300b060355040a0c0446697a7a310d300b060355040b0c0446697a7a310d300b06035504030c0446697a7a301e170d3137303430343138323930395a170d3431313132343138323930395a3054310b3009060355040613025553310b300906035504080c024e59310b300906035504070c024e59310d300b060355040a0c0446697a7a310d300b060355040b0c0446697a7a310d300b06035504030c0446697a7a3059301306072a8648ce3d020106082a8648ce3d030107034200049d87bcaddb65d8dcf6df8b148a9679b5b710db19c95a9badfff13468cb358b4e21d24a5c826112658ebb96d64e2985dfb41c1948334391a4aa81b67837e2dbf0a350304e301d0603551d0e041604143c5b8ba954d9752faf3c8ad6d1a62449dccaa850301f0603551d230418301680143c5b8ba954d9752faf3c8ad6d1a62449dccaa850300c0603551d13040530030101ff300a06082a8648ce3d04030203470030440220349b7d34d7132fb2756576e0bfa36cbe1723337a7a6f5ef9c8d3bf1aa7efa4a5022025c50a91e0aa4272f1f52c3d5583a7d7cee14b178835273a0bd814303e62d714"}

Definition at line 34 of file ExportedAuthenticatorTest.cpp.

StringPiece fizz::test::expected_cr_context = {"303132333435363738396162636465666768696a"}

Definition at line 33 of file ExportedAuthenticatorTest.cpp.

StringPiece fizz::test::expected_empty_authenticator

Initial value:

= {
    "1400002011fae4bcdf4673b6dfb276d886c4cd1c5b0920da961643f062d1d4a6062115b1"}

Definition at line 36 of file ExportedAuthenticatorTest.cpp.

StringPiece fizz::test::exporter_master = {"12345678901234567890123456789012"}

Definition at line 19 of file ExporterTest.cpp.

constexpr folly::StringPiece fizz::test::kClientAuthCACert

Definition at line 183 of file TestUtil.h.

Referenced by fizz::test::HandshakeTest::SetUp().

constexpr folly::StringPiece fizz::test::kClientAuthClientCert

Initial value:

= R"(
-----BEGIN CERTIFICATE-----
MIIErzCCApegAwIBAgICEAAwDQYJKoZIhvcNAQELBQAwGjELMAkGA1UEBhMCVVMx
CzAJBgNVBAgMAkNBMCAXDTE3MDkwMTIxMDU1MloYDzIxMTcwODA4MjEwNTUyWjBj
MQswCQYDVQQGEwJVUzELMAkGA1UECAwCQ0ExDTALBgNVBAsMBEZpenoxFDASBgNV
BAMMC0ZpenogQ2xpZW50MSIwIAYJKoZIhvcNAQkBFhNmaXp6Y2xpZW50QGZpenou
Y29tMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAzU4RuUU3QjX9rMeC
aVYPX1G8ITkGkvRW1Fbo5P9Irmw/uOeXnTKFtJ3h+r+omA607aqymHfjk1uDtxwH
2GI1VEIYce1u+qYSiLdfWUOQ1za5abeGhT/PJSONVg02maaMZmxSi5L7f/9x5B5B
fIecgurN+7W381ENyp06akg3CSAtNITL1+Au8wOh4woAJ1qKcgrhHeSG5qOqe2cw
vkcfy1Pahmp5sQtebI+1VaLXSW2XS4i/59oM7jfWAs2ZZW2EYrT3z0q3bEiL9OVz
Qjumv5fi9kJR7Pol/Q3p0MD4/8TPA6eEFf9FYPoguF6f2RKvN7uqCjIhH9r679Na
UBQcZQIDAQABo4GzMIGwMAkGA1UdEwQCMAAwEQYJYIZIAYb4QgEBBAQDAgWgMCEG
CWCGSAGG+EIBDQQUFhJDbGllbnQgQ2VydGlmaWNhdGUwHQYDVR0OBBYEFE/TN4DI
NrYzGanBqw9MD+gmmkkDMB8GA1UdIwQYMBaAFB8apflC6AhWupoL10Q0yzKxfl4Z
MA4GA1UdDwEB/wQEAwIF4DAdBgNVHSUEFjAUBggrBgEFBQcDAgYIKwYBBQUHAwQw
DQYJKoZIhvcNAQELBQADggIBAHBGcdKXTFQoZOWdt/XR3B3tLJDPoo9anFc+w+/C
tNMUCOT1/ILdDtjkXQ9+U6czkgOQbcUzUkUF9sfPJ2aBf95azvU51xXH19CPyLc2
H59CHdUUGD1CiJ8H/EH1kjb6sBIX17OvYYYj47qT1us2ZM45w86zhLZkmDkIcdMy
A9ZhNtQDk/oWGE1Q6YV2CT78RSNke8RqNe7XrDIJh9ZOGyfYqXuDsdGE8md0nCAC
kqWje0HeHkWTJTkdNLSp6DNpXmMyUg8wjcOvj3dTNOEtqqTAHx8wzL9YlCsUTLot
HGXpVhMv2X+GMKQsXTBVUVrWaFj6x4owXmRK8le315AgpsIGhTqFlGLpbs7dCm6T
upufJ6ZoY4gLxcwPD691PQznjqC45j4Zi+KxY8ptsIVJbcK9kbcBIb/T7HnQHCOI
vTUQFPPhST0fRhpsiOGaJxPOn6Ht8lSf3A1vS+TfD4E5cyojZzXe2H7ao3sCB4a4
X8tTiQTUHQVFNQqiPsErBOX1ybr1uwRFcX+uIwiVtcxRi5otMZNIFpulvmwb517R
NprWAWb0X4RYqPoTNW/OGk421nI0Bc5Rhi4+6RO93BrkPY0HHDnge7LB5A7WynbG
8gdVGTDuTniJ7Z4xIz6/YMxEM8F+BCQzq1f/2dnlSfEgIk2AdsW1verYIfc6xwqr
V1Xd
-----END CERTIFICATE-----
)"

Definition at line 216 of file TestUtil.h.

Referenced by fizz::test::HandshakeTest::SetUp(), and TEST_F().

constexpr folly::StringPiece fizz::test::kClientAuthClientKey

Initial value:

= R"(
-----BEGIN RSA PRIVATE KEY-----
MIIEpAIBAAKCAQEAzU4RuUU3QjX9rMeCaVYPX1G8ITkGkvRW1Fbo5P9Irmw/uOeX
nTKFtJ3h+r+omA607aqymHfjk1uDtxwH2GI1VEIYce1u+qYSiLdfWUOQ1za5abeG
hT/PJSONVg02maaMZmxSi5L7f/9x5B5BfIecgurN+7W381ENyp06akg3CSAtNITL
1+Au8wOh4woAJ1qKcgrhHeSG5qOqe2cwvkcfy1Pahmp5sQtebI+1VaLXSW2XS4i/
59oM7jfWAs2ZZW2EYrT3z0q3bEiL9OVzQjumv5fi9kJR7Pol/Q3p0MD4/8TPA6eE
Ff9FYPoguF6f2RKvN7uqCjIhH9r679NaUBQcZQIDAQABAoIBABJURPrQdiWAIny5
dygmWcr9xhkFOVQHYnUkqThAnmGMIohEjOGo8Az3B4TWdZvVvEt3sOgx0+yFABZp
9z1XT0GNgRcyxnS0PPVdwbJ7eMPuC9GnY+gjkT/Uk7q6BUTkfKZsR1ZUsgV0bdua
4+fVR6Dci7VMPPcJJn0PWnbAqcEzqBUI3+HqUpx1LACqbMYtlTpFxHO811ycbTkB
SJMlEvzH5Ry5gptJur7kepyA4o6hz9C/KPjuCcjXUwjGDggqQJkj6ulUdQIZek8R
9ckeHETrQiuSnUngJbgG83kHVGISdX9kgqVfo+t2cIsEGO9KJOQ4HNL9iXvh+Coj
Hsc1ZKECgYEA/Ian9dD27mkgYz5z1oO4R2t0Hjr18tI5WUd4Smc6sDAX0xjBsVui
sBm0apE+QvgHrD+JWxrBDTB1SZmfgd9OjjCveILo8eUTk91jYgOov9+GLpL+k2rY
dsBdsLu+x9+w6d+N+ySVRJU4MfweEYrah13IV+nr+gLd7/uxpsP2owkCgYEA0CEc
SCUBHkoa4O4/jkn3yBXnGq1SSaLA9LCQXhLlfWUd7nZAX3dNjXAS7JE5QtOt1C7p
7Fg7fS/dEYD6VyGmscq9yJL7xKD0zx1nKlr5ZhCGTZM6QXvmSRDRf06Ne+z7Gxhf
oDmM8vclHu5z7J7aYnb7BPwTBz4W/IKqyKptuX0CgYEAvEBGBeJ5stF764ArKseX
IObh8YdSwmolhoDZE95QyfeQSzYxbt45Mb532Nnd6F6umaHj657OO97cELoNRuwJ
y8ZPiS9OKMX1Ck4IQJEpw6AGj8HVNmB4bk6Jia7sUmRXpoGZfpePD0mOUvT4FWvF
7RPkvmUMHZz1hmnDzeZYfsECgYBFrD/eetzD+gTDdZ47ENHs3kAuMwVP9zbm8tBx
XZwLfTUm5dko3DRO+8yp+veTQm93j3jpkKPhhYtY17d2QaKe9ALSSToVGdi6GNq3
WBsTKsb64yVmVIbDwOiQ2IgOi0eIS4F/jqR7lXaMw0B1Xrw2qCPiCEyKaSOixk9L
u5ndtQKBgQC0CLFhehVr4AOx65l9VGNW9lx8XlUXTMaElv6DKqQhTOGIe48pzHkQ
VxjmpoOD8HC2xqb+HfofiwVTR5Q1khz/BqcjdrT8TRxFD4bKjVePOxyrIcTiGJzx
V0495bcyl/ghl1VyoKOzjcc1pMQCLUaj4MmbSmW0A9wxP1eVPTOhEg==
-----END RSA PRIVATE KEY-----
)"

Definition at line 247 of file TestUtil.h.

Referenced by fizz::test::HandshakeTest::SetUp().

constexpr size_t fizz::test::kHeadroom = 10

Definition at line 38 of file OpenSSLEVPCipherTest.cpp.

Referenced by TEST_P().

constexpr folly::StringPiece fizz::test::kP256Certificate

Initial value:

= R"(
-----BEGIN CERTIFICATE-----
MIIB7jCCAZWgAwIBAgIJAMVp7skBzobZMAoGCCqGSM49BAMCMFQxCzAJBgNVBAYT
AlVTMQswCQYDVQQIDAJOWTELMAkGA1UEBwwCTlkxDTALBgNVBAoMBEZpenoxDTAL
BgNVBAsMBEZpenoxDTALBgNVBAMMBEZpenowHhcNMTcwNDA0MTgyOTA5WhcNNDEx
MTI0MTgyOTA5WjBUMQswCQYDVQQGEwJVUzELMAkGA1UECAwCTlkxCzAJBgNVBAcM
Ak5ZMQ0wCwYDVQQKDARGaXp6MQ0wCwYDVQQLDARGaXp6MQ0wCwYDVQQDDARGaXp6
MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEnYe8rdtl2Nz234sUipZ5tbcQ2xnJ
Wput//E0aMs1i04h0kpcgmESZY67ltZOKYXftBwZSDNDkaSqgbZ4N+Lb8KNQME4w
HQYDVR0OBBYEFDxbi6lU2XUvrzyK1tGmJEncyqhQMB8GA1UdIwQYMBaAFDxbi6lU
2XUvrzyK1tGmJEncyqhQMAwGA1UdEwQFMAMBAf8wCgYIKoZIzj0EAwIDRwAwRAIg
NJt9NNcTL7J1ZXbgv6NsvhcjM3p6b175yNO/GqfvpKUCICXFCpHgqkJy8fUsPVWD
p9fO4UsXiDUnOgvYFDA+YtcU
-----END CERTIFICATE-----
)"

Definition at line 41 of file TestUtil.h.

Referenced by getCert< P256Test >(), fizz::test::HandshakeTest::SetUp(), TEST(), TEST(), and TEST_F().

constexpr folly::StringPiece fizz::test::kP256K1Key

Initial value:

= R"(
-----BEGIN EC PRIVATE KEY-----
MHQCAQEEIO/faBJKYzuLCTg58AIyWbeu2c6VVuPToCrINFj4y8wToAcGBSuBBAAK
oUQDQgAEW5bWEQR9xaAT0Zaev8QmA/lzz1a9+z1cphweKH8ynBYmWiWivaqGcVAU
Lt/SKc3HlcKGQhblkaGHEt3pCQeZUA==
-----END EC PRIVATE KEY-----
)"

Definition at line 33 of file TestUtil.h.

Referenced by fizz::test::Key< T >::getKeyParams().

constexpr folly::StringPiece fizz::test::kP256Key

Initial value:

= R"(
-----BEGIN EC PRIVATE KEY-----
MHcCAQEEIHMPeLV/nP/gkcgU2weiXl198mEX8RbFjPRoXuGcpxMXoAoGCCqGSM49
AwEHoUQDQgAEnYe8rdtl2Nz234sUipZ5tbcQ2xnJWput//E0aMs1i04h0kpcgmES
ZY67ltZOKYXftBwZSDNDkaSqgbZ4N+Lb8A==
-----END EC PRIVATE KEY-----
)"

Definition at line 18 of file TestUtil.h.

Referenced by getKey< P256Test >(), fizz::test::Key< T >::getKeyParams(), fizz::test::HandshakeTest::SetUp(), TEST(), TEST(), and TEST_F().

constexpr folly::StringPiece fizz::test::kP256PublicKey

Initial value:

= R"(
-----BEGIN PUBLIC KEY-----
MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEnYe8rdtl2Nz234sUipZ5tbcQ2xnJ
Wput//E0aMs1i04h0kpcgmESZY67ltZOKYXftBwZSDNDkaSqgbZ4N+Lb8A==
-----END PUBLIC KEY-----
)"

Definition at line 26 of file TestUtil.h.

Referenced by TEST().

constexpr folly::StringPiece fizz::test::kP384Certificate

Initial value:

= R"(
-----BEGIN CERTIFICATE-----
MIICJzCCAaygAwIBAgIJAOzjkDsjaGgLMAoGCCqGSM49BAMCMFExCzAJBgNVBAYT
AlVTMRUwEwYDVQQHDAxEZWZhdWx0IENpdHkxHDAaBgNVBAoME0RlZmF1bHQgQ29t
cGFueSBMdGQxDTALBgNVBAMMBGZpenowHhcNMTgwNzI3MjIwNTE2WhcNMTgwODI2
MjIwNTE2WjBRMQswCQYDVQQGEwJVUzEVMBMGA1UEBwwMRGVmYXVsdCBDaXR5MRww
GgYDVQQKDBNEZWZhdWx0IENvbXBhbnkgTHRkMQ0wCwYDVQQDDARmaXp6MHYwEAYH
KoZIzj0CAQYFK4EEACIDYgAEgRBBliu6yYWesqoZpHUuVzlJ0/HriryxMcFnTnUG
H14XtqJHJO63Mmjtgv09K/yT24jKu/jJ2p5MFHn/25pUtSKZCu9AHBqwBKof3w4m
qoaSylhgrW9s+Oo7uV2+y4Kjo1AwTjAdBgNVHQ4EFgQUn8WNTodJ81ytFl+3BWKI
I9X784wwHwYDVR0jBBgwFoAUn8WNTodJ81ytFl+3BWKII9X784wwDAYDVR0TBAUw
AwEB/zAKBggqhkjOPQQDAgNpADBmAjEA6S4jXP5fruwrmszizG854snSHl5LVEuQ
8F6RIEsOnWSbKBBoteaSXwA6Tv+jYZnmAjEA8YU0LnO+eA75Aku0mPDQsVJOjCvX
OMc6lsBbEEu0yLF89FcMYbxH2JCRxa528qd+
-----END CERTIFICATE-----
)"

Definition at line 74 of file TestUtil.h.

Referenced by getCert< P384Test >(), and fizz::test::HandshakeTest::SetUp().

constexpr folly::StringPiece fizz::test::kP384Key

Initial value:

= R"(
-----BEGIN EC PRIVATE KEY-----
MIGkAgEBBDCq2Al9+ZmWvvKXeKF4x+P0D3BvbFD9uxxgixjp2pVrGiQeybNLsmgz
aCjz+ETbBEKgBwYFK4EEACKhZANiAASBEEGWK7rJhZ6yqhmkdS5XOUnT8euKvLEx
wWdOdQYfXhe2okck7rcyaO2C/T0r/JPbiMq7+MnankwUef/bmlS1IpkK70AcGrAE
qh/fDiaqhpLKWGCtb2z46ju5Xb7LgqM=
-----END EC PRIVATE KEY-----
)"

Definition at line 57 of file TestUtil.h.

Referenced by getKey< P384Test >(), fizz::test::Key< T >::getKeyParams(), fizz::test::HandshakeTest::SetUp(), and TEST().

constexpr folly::StringPiece fizz::test::kP384PublicKey

Initial value:

= R"(
-----BEGIN PUBLIC KEY-----
MHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEgRBBliu6yYWesqoZpHUuVzlJ0/Hriryx
McFnTnUGH14XtqJHJO63Mmjtgv09K/yT24jKu/jJ2p5MFHn/25pUtSKZCu9AHBqw
BKof3w4mqoaSylhgrW9s+Oo7uV2+y4Kj
-----END PUBLIC KEY-----
)"

Definition at line 66 of file TestUtil.h.

constexpr folly::StringPiece fizz::test::kP521Certificate

Initial value:

= R"(
-----BEGIN CERTIFICATE-----
MIICcTCCAdKgAwIBAgIJAMaW6GnzHQdaMAoGCCqGSM49BAMCMFExCzAJBgNVBAYT
AlhYMRUwEwYDVQQHDAxEZWZhdWx0IENpdHkxHDAaBgNVBAoME0RlZmF1bHQgQ29t
cGFueSBMdGQxDTALBgNVBAMMBGZpenowHhcNMTgwNzI3MjIwNjI2WhcNMTgwODI2
MjIwNjI2WjBRMQswCQYDVQQGEwJYWDEVMBMGA1UEBwwMRGVmYXVsdCBDaXR5MRww
GgYDVQQKDBNEZWZhdWx0IENvbXBhbnkgTHRkMQ0wCwYDVQQDDARmaXp6MIGbMBAG
ByqGSM49AgEGBSuBBAAjA4GGAAQBp21bDEL1V+QYv5grNW6QP5N7nVMMyoJQ4HyY
ygMpOViy+o2iD5xOn3aE3z6HK0cNrFNoaXtmTOTGdz/riGJwe18BQ0GC65YqOqin
B8hoyqbt7mLdhFYXLvC9c4+sOrsE6HvT6eqcG9CfhyCplMYWLLQlRvhuMo3pMDh+
jswsaOxBvPKjUDBOMB0GA1UdDgQWBBRqn91E64NUNowqgdlYhJCerng6bTAfBgNV
HSMEGDAWgBRqn91E64NUNowqgdlYhJCerng6bTAMBgNVHRMEBTADAQH/MAoGCCqG
SM49BAMCA4GMADCBiAJCAaCZdl3sxO15gKzpODf/y591WTtaXWEz5MdlHP2y3m1X
4ae1xJMdmB6Qw5/bYHAus9GCwLx37WxaMxYcSG2mfIaGAkIBnIE2i1fX3LZCfkKx
SR7JD8cautCXMGtmivUW8TItC72Gt8DWD1hVfR9OnjnuKFotlVZ1FF/HbG2Hwa4/
Skcvpq0=
-----END CERTIFICATE-----
)"

Definition at line 110 of file TestUtil.h.

Referenced by getCert< P521Test >(), and fizz::test::HandshakeTest::SetUp().

constexpr folly::StringPiece fizz::test::kP521Key

Initial value:

= R"(
-----BEGIN EC PRIVATE KEY-----
MIHcAgEBBEIBPYFDNkfM6VuyQKVaQigvLTeKXcPWr4qMLHtN4V81QZLIE9HJvL29
hbqwRG/kw2XM8ZQSnsqd1XTevQSfEPK45+CgBwYFK4EEACOhgYkDgYYABAGnbVsM
QvVX5Bi/mCs1bpA/k3udUwzKglDgfJjKAyk5WLL6jaIPnE6fdoTfPocrRw2sU2hp
e2ZM5MZ3P+uIYnB7XwFDQYLrlio6qKcHyGjKpu3uYt2EVhcu8L1zj6w6uwToe9Pp
6pwb0J+HIKmUxhYstCVG+G4yjekwOH6OzCxo7EG88g==
-----END EC PRIVATE KEY-----
)"

Definition at line 91 of file TestUtil.h.

Referenced by getKey< P521Test >(), fizz::test::Key< T >::getKeyParams(), and fizz::test::HandshakeTest::SetUp().

constexpr folly::StringPiece fizz::test::kP521PublicKey

Initial value:

= R"(
-----BEGIN PUBLIC KEY-----
MIGbMBAGByqGSM49AgEGBSuBBAAjA4GGAAQBp21bDEL1V+QYv5grNW6QP5N7nVMM
yoJQ4HyYygMpOViy+o2iD5xOn3aE3z6HK0cNrFNoaXtmTOTGdz/riGJwe18BQ0GC
65YqOqinB8hoyqbt7mLdhFYXLvC9c4+sOrsE6HvT6eqcG9CfhyCplMYWLLQlRvhu
Mo3pMDh+jswsaOxBvPI=
-----END PUBLIC KEY-----
)"

Definition at line 101 of file TestUtil.h.

constexpr folly::StringPiece fizz::test::kRSACertificate

Initial value:

= R"(
-----BEGIN CERTIFICATE-----
MIIDYTCCAkmgAwIBAgIJAMNCCDasHKJvMA0GCSqGSIb3DQEBCwUAMEsxCzAJBgNV
BAYTAlVTMQswCQYDVQQIDAJOWTERMA8GA1UEBwwITmV3IFlvcmsxDTALBgNVBAsM
BEZpenoxDTALBgNVBAMMBEZpenowHhcNMTYxMjI5MDYyNDE4WhcNNDEwODIwMDYy
NDE4WjBLMQswCQYDVQQGEwJVUzELMAkGA1UECAwCTlkxETAPBgNVBAcMCE5ldyBZ
b3JrMQ0wCwYDVQQLDARGaXp6MQ0wCwYDVQQDDARGaXp6MIIBIjANBgkqhkiG9w0B
AQEFAAOCAQ8AMIIBCgKCAQEAxWSZkGZoflV+hnNKZVuCUr0eOedYtFIEU16mARPP
3KPqHFrcEXudA5/46hoogfSb2WYqEaCeltY3GiPG+WPdhhDEi5h4hImvL+g/iTU7
LLmIhmkx4hKzAYx012012Hxy7pvEJJy6S7wEcJj0AxNsWFo8SysIfO5Rw57CTHol
xwcbuCsfq6Cca3PE0gc9UXZ2KaTJNuph8gWPDdio8Au5YnYpvIYy0QXt6eUFAH8h
uNRBOUK+XHng+/zAIXQAtGJEW/rx/vKDUWm0nzZKlIUXPIdCSMCTO6qj+UFvypd0
SN4PXW/6DUJeGi3bXFql9XF8ysy6ZgheHKsvgPDlSkOO5QIDAQABo0gwRjAJBgNV
HRMEAjAAMAsGA1UdDwQEAwIF4DAsBgNVHREEJTAjggoqLmZpenouY29tgghmaXp6
LmNvbYILZXhhbXBsZS5uZXQwDQYJKoZIhvcNAQELBQADggEBAIpIvwxxSJrLGW8I
rz4PpKLoeKetLCW3HYVrrMF8nGLKwlzeWLa0BpQN638DuDLOsaGZX0OshsOsPCc9
FWub8Vdu5pA1zuDLS03aL2F4DBMyvKvDmqa0+Jsj+SuIk054oF1Q4jvx9VE0JBmx
1FfHZ5Ug+f8DLWYvLMN6G9P6YYzoENn589oa//JHYWDoJimt2IB80R1k47gIvGde
W4CnlNH1jYO1/mr1yVHNrpdkOab2ItdEycdTw8zi/QOGRhFevjcR+p6c+NKr2/OS
iv9+LfvbaFlvdxkkKGr3mrsb2EgzB1LiSHTllA+yS88QzxcSRhzSeSg/bvL+xsWT
xcGg1w0=
-----END CERTIFICATE-----
)"

Definition at line 159 of file TestUtil.h.

Referenced by getCert< RSATest >(), fizz::test::HandshakeTest::SetUp(), fizz::server::test::TEST(), and TEST().

constexpr folly::StringPiece fizz::test::kRSAKey

Initial value:

= R"(
-----BEGIN RSA PRIVATE KEY-----
MIIEowIBAAKCAQEAxWSZkGZoflV+hnNKZVuCUr0eOedYtFIEU16mARPP3KPqHFrc
EXudA5/46hoogfSb2WYqEaCeltY3GiPG+WPdhhDEi5h4hImvL+g/iTU7LLmIhmkx
4hKzAYx012012Hxy7pvEJJy6S7wEcJj0AxNsWFo8SysIfO5Rw57CTHolxwcbuCsf
q6Cca3PE0gc9UXZ2KaTJNuph8gWPDdio8Au5YnYpvIYy0QXt6eUFAH8huNRBOUK+
XHng+/zAIXQAtGJEW/rx/vKDUWm0nzZKlIUXPIdCSMCTO6qj+UFvypd0SN4PXW/6
DUJeGi3bXFql9XF8ysy6ZgheHKsvgPDlSkOO5QIDAQABAoIBAH36IE+aLCJEqgVg
2yAo8NmhPQMzdNdQaNZUV5nkbQqhyi3ihwTZYXIIzLGLlEKsPDLZEwxA+DXH7U7P
epN7esuvM+DrpC7iOF5Y2QPWZze6CTnPNTjVOk1IuOEsH+tUMX27B8leBT+EdUjv
NPwpj0IsBMLsafRhnOk+Dz8Dzcxgyee6r0bGy4f7LZ4/e/mQzR2y5IrePmpRJH/8
NF6OfLpAxrVb57VVDaKEGjR0i0xOR8/nuNKgUVeAzkFNytJl5oxzHR3qHBg/mYmQ
Y4eu0tCZcczennWm06jt6P3qCD7xGtlj8RwFZeQ7UAwaHAPDd60LDb2Kt7WO87OY
wWYz2ZkCgYEA/hKBLyJsgvsGL25jTrcqdChJURiBl+KGQj3giSNy+WgHnQuSpX/G
6s46tgvuLpWzS3E4eX/ymdjWPe0S0N8ZVUAzr5Ne4/EdDTPmaZsLXEsJ+19YRfLY
/E9v0ao4Rliwk0lC4ieeNY79PKZ4XBP5eNg9c7T2dHFEadJHvB13P2sCgYEAxuQB
LShZzOPoN967I9VOkwYLrf5k0LdgKmuDgzFo7Y9WMiqy0GdcfsiPunde+HHXmRDE
k1Am14w3NQLQlLYs9QTUBHYVllPmpkLqozFauGNw5hHcq7YZtfZqIZLL0aueZhDt
aV/nNDMYTqgclJbpMEtQ6itLonLX1htJS0LGju8CgYAUIdE8s+SXSF7IGV4jGZ5y
j9Kna2Kxb1CmJRMKqtVsb9LSnd0j4gkYB/lc/XsFE/WeD72i2wGVMTpgs81e4Z63
Q5wU2H+XXj6oEim6yn9O8985nOd4u3J4I68/lNZatKJhOVfkZbFCmy7zxFkbKrYE
3lWYOomg1mzOWcw3WrpdOwKBgBzQtdbsDK6hqmhFzckwQ1ULwC9yNvsCRl1+/CvK
wdABP1S/WO7WutDnj+NNHiZSoBDeHAzXxPjfqLP2d2/EQRkynOEUlqYT+8vE0Cfa
o7EpPxcmKVl7ZZg2XkQE96CmA6n3892bdmzapj/nHVTt1FUZ5Fw475lWmCy+AU11
HD1jAoGBAOIA6kfwN6Z3mWRuivfruzk50NeqV2Xsmaa+Sk18n0Cz2cOynUWNl7qX
/8ZTeGj9UFARNbQ5aM+gRzgEPigpAiWK3qoedBfEUjKUyDZlfWlDu8Ds8T+HvZ0i
h8YfdM73KnIU0O8s+bvCkg/sFvqDmQ9ocdTSo1aVkNY4avhSgstK
-----END RSA PRIVATE KEY-----
)"

Definition at line 129 of file TestUtil.h.

Referenced by getKey< RSATest >(), fizz::test::HandshakeTest::SetUp(), and TEST().

StringPiece fizz::test::label = {"EXPORTER-Token-Binding"}

Definition at line 20 of file ExporterTest.cpp.

Referenced by fizz::KeyDerivationImpl< Hash >::blankHash(), fizz::encodeHkdfLabel(), fizz::FizzBase< FizzServer< ActionMoveVisitor, SM >, ActionMoveVisitor, SM >::FizzBase(), proxygen::HTTPSession::getCertAuthSettingVal(), fizz::server::FizzServer< ActionMoveVisitor, SM >::getEarlyEkm(), fizz::client::FizzClient< ActionMoveVisitor, SM >::getEarlyEkm(), fizz::FizzBase< Derived, ActionMoveVisitor, StateMachine >::getEkm(), fizz::KeyScheduler::getSecret(), fizz::server::AsyncFizzServerT< fizz::server::test::MockServerStateMachineInstance >::getState(), fizz::client::AsyncFizzClientT< fizz::client::test::MockClientStateMachineInstance >::getState(), fizz::CertUtils::prepareSignData(), fizz::testing::TEST_P(), and proxygen::HTTPSession::verifyCertAuthSetting().

struct randombytes_implementation fizz::test::mockRandom

static

Initial value:

= {
    []() { return "test"; }, 
    []() { return (uint32_t)0x44444444; }, 
    nullptr, 
    nullptr, 
    [](void* const buf, const size_t size) { memset(buf, 0x44, size); }, 
    nullptr}

Definition at line 61 of file TestUtil.cpp.

constexpr ProtocolVersion fizz::test::TestProtocolVersion = ProtocolVersion::tls_1_3

Definition at line 22 of file ProtocolTest.h.

Referenced by fizz::test::TestMessages::clientHello(), fizz::server::test::ServerProtocolTest::expectCookie(), fizz::client::test::ClientProtocolTest::getEarlyDataParams(), fizz::test::TestMessages::helloRetryRequest(), fizz::test::TestMessages::serverHello(), fizz::server::test::ServerProtocolTest::setUpAcceptingData(), fizz::server::test::ServerProtocolTest::setUpAcceptingEarlyData(), fizz::server::test::ServerProtocolTest::setUpExpectingCertificate(), fizz::server::test::ServerProtocolTest::setUpExpectingCertificateVerify(), fizz::server::test::ServerProtocolTest::setUpExpectingClientHelloRetry(), fizz::client::test::ClientProtocolTest::setupExpectingEncryptedExtensions(), fizz::server::test::ServerProtocolTest::setUpExpectingFinished(), fizz::client::test::ClientProtocolTest::setupExpectingFinished(), fizz::client::test::ClientProtocolTest::setupExpectingServerHelloAfterHrr(), fizz::server::test::TEST_F(), and fizz::client::test::TEST_F().

const std::string fizz::test::tooLargeCompressedCertificate

static

Definition at line 57 of file ZlibCertificateCompressorTest.cpp.

Referenced by TEST_F().