third-party/fizz/src/fizz/record/Extensions.h

   1 /*
   2  *  Copyright (c) 2018-present, Facebook, Inc.
   3  *  All rights reserved.
   4  *
   5  *  This source code is licensed under the BSD-style license found in the
   6  *  LICENSE file in the root directory of this source tree.
   7  */
   8
   9 #pragma once
  10
  11 #include <fizz/record/Types.h>
  12 #include <folly/Optional.h>
  13
  14 namespace fizz {
  15
  16 struct SignatureAlgorithms {
  17   std::vector<SignatureScheme> supported_signature_algorithms;
  18   static constexpr ExtensionType extension_type =
  19       ExtensionType::signature_algorithms;
  20 };
  21
  22 struct SupportedGroups {
  23   std::vector<NamedGroup> named_group_list;
  24   static constexpr ExtensionType extension_type =
  25       ExtensionType::supported_groups;
  26 };
  27
  28 struct KeyShareEntry {
  29   NamedGroup group;
  30   Buf key_exchange;
  31 };
  32
  33 struct ClientKeyShare {
  34   std::vector<KeyShareEntry> client_shares;
  35   static constexpr ExtensionType extension_type = ExtensionType::key_share;
  36 };
  37
  38 struct ServerKeyShare {
  39   KeyShareEntry server_share;
  40   static constexpr ExtensionType extension_type = ExtensionType::key_share;
  41 };
  42
  43 struct HelloRetryRequestKeyShare {
  44   NamedGroup selected_group;
  45   static constexpr ExtensionType extension_type = ExtensionType::key_share;
  46 };
  47
  48 struct PskIdentity {
  49   Buf psk_identity;
  50   uint32_t obfuscated_ticket_age;
  51 };
  52
  53 struct PskBinder {
  54   Buf binder;
  55 };
  56
  57 struct ClientPresharedKey {
  58   std::vector<PskIdentity> identities;
  59   std::vector<PskBinder> binders;
  60   static constexpr ExtensionType extension_type = ExtensionType::pre_shared_key;
  61 };
  62
  63 struct ServerPresharedKey {
  64   uint16_t selected_identity;
  65   static constexpr ExtensionType extension_type = ExtensionType::pre_shared_key;
  66 };
  67
  68 struct ClientEarlyData {
  69   static constexpr ExtensionType extension_type = ExtensionType::early_data;
  70 };
  71
  72 struct ServerEarlyData {
  73   static constexpr ExtensionType extension_type = ExtensionType::early_data;
  74 };
  75
  76 struct TicketEarlyData {
  77   uint32_t max_early_data_size;
  78   static constexpr ExtensionType extension_type = ExtensionType::early_data;
  79 };
  80
  81 struct Cookie {
  82   Buf cookie;
  83   static constexpr ExtensionType extension_type = ExtensionType::cookie;
  84 };
  85
  86 struct SupportedVersions {
  87   std::vector<ProtocolVersion> versions;
  88   static constexpr ExtensionType extension_type =
  89       ExtensionType::supported_versions;
  90 };
  91
  92 struct ServerSupportedVersions {
  93   ProtocolVersion selected_version;
  94   static constexpr ExtensionType extension_type =
  95       ExtensionType::supported_versions;
  96 };
  97
  98 struct PskKeyExchangeModes {
  99   std::vector<PskKeyExchangeMode> modes;
 100   static constexpr ExtensionType extension_type =
 101       ExtensionType::psk_key_exchange_modes;
 102 };
 103
 104 struct ProtocolName {
 105   Buf name;
 106 };
 107
 108 struct ProtocolNameList {
 109   std::vector<ProtocolName> protocol_name_list;
 110   static constexpr ExtensionType extension_type =
 111       ExtensionType::application_layer_protocol_negotiation;
 112 };
 113
 114 enum class ServerNameType : uint8_t { host_name = 0 };
 115
 116 struct ServerName {
 117   ServerName() {}
 118   explicit ServerName(Buf hostnameIn) : hostname(std::move(hostnameIn)) {}
 119
 120   ServerNameType name_type{ServerNameType::host_name};
 121   Buf hostname;
 122 };
 123
 124 struct ServerNameList {
 125   ServerNameList() {}
 126   explicit ServerNameList(ServerName sn) {
 127     server_name_list.push_back(std::move(sn));
 128   }
 129   std::vector<ServerName> server_name_list;
 130   static constexpr ExtensionType extension_type = ExtensionType::server_name;
 131 };
 132
 133 struct DistinguishedName {
 134   Buf encoded_name;
 135 };
 136
 137 struct CertificateAuthorities {
 138   std::vector<DistinguishedName> authorities;
 139   static constexpr ExtensionType extension_type =
 140       ExtensionType::certificate_authorities;
 141 };
 142
 143 struct CertificateCompressionAlgorithms {
 144   std::vector<CertificateCompressionAlgorithm> algorithms;
 145   static constexpr ExtensionType extension_type =
 146       ExtensionType::compress_certificate;
 147 };
 148
 149 struct EchOuterExtensions {
 150   std::vector<ExtensionType> extensionTypes;
 151   static constexpr ExtensionType extension_type =
 152       ExtensionType::ech_outer_extensions;
 153 };
 154
 155 template <class T>
 156 folly::Optional<T> getExtension(const std::vector<Extension>& extension);
 157 template <class T>
 158 T getExtension(folly::io::Cursor& cursor);
 159
 160 template <class T>
 161 Extension encodeExtension(const T& t);
 162
 163 std::vector<Extension>::const_iterator findExtension(
 164     const std::vector<Extension>& extensions,
 165     ExtensionType type);
 166
 167 size_t getBinderLength(const ClientHello& chlo);
 168 } // namespace fizz
 169
 170 #include <fizz/record/Extensions-inl.h>