18 static constexpr
size_t size = 3;
24 size_t getSize(
const typename std::enable_if<
34 return sizeof(N) + buf->computeChainDataLength();
44 return Sizer<T>().
template getSize<T>(t);
73 const typename std::enable_if<
78 appender.
writeBE<UT>(
static_cast<UT
>(in));
83 const typename std::enable_if<
95 const uint32_t UINT24_MAX = 0xFFFFFF;
96 if (value > UINT24_MAX) {
97 throw std::runtime_error(
"Overflow 24 bit type");
103 static_assert(
sizeof(
T) > 3,
"Type is too short");
104 checkWithin24bits<T>(len);
113 Writer<T>().
template write<T>(in, appender);
116 template <
class N,
class T>
121 for (
const auto&
t : data) {
122 len += getSize<T>(
t);
125 out.
writeBE<N>(folly::to<N>(len));
126 for (
const auto&
t : data) {
137 for (
const auto&
t : data) {
138 len += getSize<T>(
t);
142 for (
const auto&
t : data) {
148 template <
class N,
class T>
156 out.
writeBE<N>(folly::to<N>(0));
159 out.
writeBE<N>(folly::to<N>(buf->computeChainDataLength()));
161 size_t chainElements = buf->countChainElements();
162 for (
size_t i = 0;
i < chainElements; ++
i) {
174 out.
push(random.data(), random.size());
186 size_t chainElements = buf->countChainElements();
187 for (
size_t i = 0;
i < chainElements; ++
i) {
188 out.
push(current->data(), current->length());
189 current = current->next();
198 extension.extension_type));
199 writeBuf<uint16_t>(extension.extension_data, out);
206 writeBuf<detail::bits24>(entry.cert_data, out);
207 writeVector<uint16_t>(entry.extensions, out);
214 cursor.
pull(addr + offset, 3);
221 auto len = cursor.
readBE<N>();
222 cursor.
clone(buf, len);
223 return sizeof(N) + len;
229 cursor.clone(buf, len);
237 typename std::enable_if<
242 out =
static_cast<U
>(cursor.
readBE<UT>());
248 typename std::enable_if<
259 return Reader<T>().
template read<T>(out, cursor);
262 template <
class N,
class T>
265 auto len = cursor.
readBE<N>();
267 throw std::out_of_range(
"Not enough data");
271 while (consumed < len) {
273 consumed +=
read(*out.rbegin(), cursor);
275 if (consumed != len) {
276 throw std::runtime_error(
"Invalid data length supplied");
278 return len +
sizeof(N);
287 throw std::out_of_range(
"Not enough data");
291 while (consumed < len) {
293 consumed +=
read(*out.rbegin(), cursor);
295 if (consumed != len) {
296 throw std::runtime_error(
"Invalid data length supplied");
302 template <
class N,
class T>
311 cursor.
pull(out.data(), out.size());
332 len += readVector<uint16_t>(entry.
extensions, cursor);
345 if (shlo.legacy_session_id_echo) {
346 detail::writeBuf<uint8_t>(shlo.legacy_session_id_echo, appender);
349 if (shlo.legacy_session_id_echo) {
352 detail::writeVector<uint16_t>(shlo.extensions, appender);
363 detail::writeBuf<uint8_t>(shlo.legacy_session_id_echo, appender);
366 detail::writeVector<uint16_t>(shlo.extensions, appender);
379 detail::writeVector<uint16_t>(extensions.extensions, appender);
387 detail::writeBuf<uint8_t>(cr.certificate_request_context, appender);
388 detail::writeVector<uint16_t>(cr.extensions, appender);
396 detail::writeBuf<uint8_t>(cert.certificate_request_context, appender);
397 detail::writeVector<detail::bits24>(cert.certificate_list, appender);
417 detail::writeBuf<detail::bits24>(
cc.compressed_certificate_message, appender);
431 detail::writeBuf<uint16_t>(certVerify.signature, appender);
452 detail::writeBuf<uint8_t>(
chlo.legacy_session_id, appender);
453 detail::writeVector<uint16_t>(
chlo.cipher_suites, appender);
454 detail::writeVector<uint8_t>(
chlo.legacy_compression_methods, appender);
455 detail::writeVector<uint16_t>(
chlo.extensions, appender);
480 if (
nst.ticket_nonce) {
481 detail::writeBuf<uint8_t>(
nst.ticket_nonce, appender);
483 detail::writeBuf<uint16_t>(
nst.ticket, appender);
484 detail::writeVector<uint16_t>(
nst.extensions, appender);
492 folly::to<std::string>(hkdfLabelPrefix,
label.label));
496 detail::writeBuf<uint8_t>(labelBuf, appender);
497 detail::writeBuf<uint8_t>(
label.hash_value, appender);
516 auto body =
encode(std::forward<T>(handshakeMsg));
519 constexpr
auto handshakeType = std::remove_reference<T>::type::handshake_type;
538 detail::readVector<uint16_t>(chlo.
extensions, cursor);
551 detail::readVector<uint16_t>(shlo.
extensions, cursor);
563 detail::readVector<uint16_t>(ee.
extensions, cursor);
571 detail::readVector<uint16_t>(cr.
extensions, cursor);
596 detail::readBuf<uint16_t>(certVerify.
signature, cursor);
606 detail::readBuf<uint16_t>(nst.
ticket, cursor);
607 detail::readVector<uint16_t>(nst.
extensions, cursor);
634 T decode(std::unique_ptr<folly::IOBuf>&& buf) {
636 auto decoded = decode<T>(cursor);
638 if (!cursor.isAtEnd()) {
639 throw std::runtime_error(
"didn't read entire message");
645 template <
typename T>
650 reinterpret_cast<const uint8_t*>(&
value),
sizeof(
value)));
std::vector< Extension > extensions
Buf encodeHandshake(T &&handshakeMsg)
void writeVector(const std::vector< T > &data, folly::io::Appender &out)
Integral2 random(Integral1 low, Integral2 up)
KeyUpdateRequest request_update
Buf encode< const ClientHello & >(const ClientHello &chlo)
size_t read(CertificateEntry &entry, folly::io::Cursor &cursor)
size_t readBuf(Buf &buf, folly::io::Cursor &cursor)
KeyUpdate decode< KeyUpdate >(folly::io::Cursor &cursor)
CertificateCompressionAlgorithm algorithm
void write(const Random &random, folly::io::Appender &out)
Buf encode< ServerHello >(ServerHello &&shlo)
void write(const T &in, folly::io::Appender &appender)
std::vector< Extension > extensions
static constexpr Random HrrRandom
Buf encode< HelloRetryRequest >(HelloRetryRequest &&shlo)
size_t readVector(std::vector< T > &out, folly::io::Cursor &cursor)
Buf encode< Finished >(Finished &&fin)
static const std::string chlo
uint8_t legacy_compression_method
static std::unique_ptr< IOBuf > create(std::size_t capacity)
Buf encode< CertificateRequest >(CertificateRequest &&cr)
AlertDescription description
void clone(std::unique_ptr< folly::IOBuf > &buf, size_t len)
Buf encodeHkdfLabel(HkdfLabel &&label, const std::string &hkdfLabelPrefix)
TokenBindingMessage decode(folly::io::Cursor &cursor)
Buf encode< CertificateVerify >(CertificateVerify &&certVerify)
constexpr detail::Map< Move > move
std::string enumToHex(T enumValue)
Finished decode< Finished >(std::unique_ptr< folly::IOBuf > &&buf)
constexpr size_type size() const
size_t readVector(std::vector< T > &out, folly::io::Cursor &cursor)
uint32_t uncompressed_length
void push(const uint8_t *buf, size_t len)
size_t getBufSize(const Buf &buf)
Buf legacy_session_id_echo
Buf encode< EncryptedExtensions >(EncryptedExtensions &&extensions)
The non test part of the code is expected to have failures gtest_output_test_ cc
ProtocolVersion legacy_version
void checkWithin24bits(const typename std::enable_if< std::is_integral< T >::value &&!std::is_signed< T >::value, T >::type &value)
void write< CertificateEntry >(const CertificateEntry &entry, folly::io::Appender &out)
std::vector< Extension > extensions
Buf certificate_request_context
void writeBuf< bits24 >(const Buf &buf, folly::io::Appender &out)
void pull(void *buf, size_t len)
Buf certificate_request_context
Buf encode< NewSessionTicket >(NewSessionTicket &&nst)
std::vector< CertificateEntry > certificate_list
size_t readBuf< bits24 >(Buf &buf, folly::io::Cursor &cursor)
size_t read(Random &out, folly::io::Cursor &cursor)
size_t getSize(const typename std::enable_if< (std::is_enum< T >::value||std::is_unsigned< T >::value)&&std::is_same< U, T >::value, T >::type &)
void writeBuf(const Buf &buf, folly::io::Appender &out)
size_t getSize(const CertificateEntry &entry)
Buf encode< ClientHello >(ClientHello &&chlo)
Buf encode< EndOfEarlyData >(EndOfEarlyData &&)
size_t read(T &out, folly::io::Cursor &cursor)
std::vector< Extension > extensions
void writeBits24(T len, folly::io::Appender &out)
size_t getSize(const T &t)
void writeVector(const std::vector< T > &data, folly::io::Appender &out)
std::vector< Extension > extensions
size_t read(typename std::enable_if< std::is_enum< T >::value &&std::is_same< U, T >::value, T >::type &out, folly::io::Cursor &cursor)
void write< Extension >(const Extension &extension, folly::io::Appender &out)
std::array< uint8_t, 32 > Random
static const char *const value
std::vector< CipherSuite > cipher_suites
void write(const typename std::enable_if< std::is_unsigned< T >::value &&std::is_same< U, T >::value, T >::type &in, folly::io::Appender &appender)
Buf encode< ClientHello & >(ClientHello &chlo)
Buf encode< CompressedCertificate >(CompressedCertificate &&cc)
SignatureScheme algorithm
Buf encode< CertificateMsg & >(CertificateMsg &cert)
uint32_t readBits24(folly::io::Cursor &cursor)
Buf encode< CertificateMsg >(CertificateMsg &&cert)
void writeVector(const std::vector< T > &data, folly::io::Appender &out)
std::vector< Extension > extensions
Buf encode(TokenBindingMessage &&message)
Buf encode< message_hash >(message_hash &&hash)
static const std::string nst
ExtensionType extension_type
std::unique_ptr< folly::IOBuf > Buf
Buf encode< CompressedCertificate & >(CompressedCertificate &cc)
Buf encode< KeyUpdate >(KeyUpdate &&keyUpdate)
size_t getSize(const Extension &proto)
Buf encode< const CertificateMsg & >(const CertificateMsg &cert)
size_t read(Extension &extension, folly::io::Cursor &cursor)
size_t getBufSize< bits24 >(const Buf &buf)
std::vector< uint8_t > legacy_compression_methods
size_t read(typename std::enable_if< std::is_unsigned< T >::value &&std::is_same< U, T >::value, T >::type &out, folly::io::Cursor &cursor)
Buf encode< Alert >(Alert &&alert)
bool hexlify(const InputString &input, OutputString &output, bool append_output)
static std::unique_ptr< IOBuf > copyBuffer(const void *buf, std::size_t size, std::size_t headroom=0, std::size_t minTailroom=0)
static constexpr size_t size
Buf compressed_certificate_message
static constexpr uint64_t data[1]
ThreadPoolListHook * addr
size_t readVector(std::vector< T > &out, folly::io::Cursor &cursor)
size_t totalLength() const
ProtocolVersion legacy_version
NewSessionTicket decode< NewSessionTicket >(folly::io::Cursor &cursor)
void write(const typename std::enable_if< std::is_enum< T >::value &&std::is_same< U, T >::value, T >::type &in, folly::io::Appender &appender)