QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 1 | // Copyright (c) 2016 The Chromium Authors. All rights reserved. |
| 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
| 5 | #include "net/third_party/quiche/src/quic/core/chlo_extractor.h" |
| 6 | |
| 7 | #include "net/third_party/quiche/src/quic/core/crypto/crypto_framer.h" |
nharper | 55fa613 | 2019-05-07 19:37:21 -0700 | [diff] [blame] | 8 | #include "net/third_party/quiche/src/quic/core/crypto/crypto_handshake.h" |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 9 | #include "net/third_party/quiche/src/quic/core/crypto/crypto_handshake_message.h" |
| 10 | #include "net/third_party/quiche/src/quic/core/crypto/crypto_protocol.h" |
nharper | 55fa613 | 2019-05-07 19:37:21 -0700 | [diff] [blame] | 11 | #include "net/third_party/quiche/src/quic/core/crypto/crypto_utils.h" |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 12 | #include "net/third_party/quiche/src/quic/core/crypto/quic_decrypter.h" |
| 13 | #include "net/third_party/quiche/src/quic/core/crypto/quic_encrypter.h" |
| 14 | #include "net/third_party/quiche/src/quic/core/quic_framer.h" |
| 15 | #include "net/third_party/quiche/src/quic/core/quic_utils.h" |
dmcardle | cf0bfcf | 2019-12-13 08:08:21 -0800 | [diff] [blame] | 16 | #include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h" |
| 17 | #include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h" |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 18 | |
| 19 | namespace quic { |
| 20 | |
| 21 | namespace { |
| 22 | |
| 23 | class ChloFramerVisitor : public QuicFramerVisitorInterface, |
| 24 | public CryptoFramerVisitorInterface { |
| 25 | public: |
| 26 | ChloFramerVisitor(QuicFramer* framer, |
| 27 | const QuicTagVector& create_session_tag_indicators, |
| 28 | ChloExtractor::Delegate* delegate); |
| 29 | |
| 30 | ~ChloFramerVisitor() override = default; |
| 31 | |
| 32 | // QuicFramerVisitorInterface implementation |
dschinazi | 17d4242 | 2019-06-18 16:35:07 -0700 | [diff] [blame] | 33 | void OnError(QuicFramer* /*framer*/) override {} |
fayang | 8aba1ff | 2019-06-21 12:00:54 -0700 | [diff] [blame] | 34 | bool OnProtocolVersionMismatch(ParsedQuicVersion version) override; |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 35 | void OnPacket() override {} |
dschinazi | 17d4242 | 2019-06-18 16:35:07 -0700 | [diff] [blame] | 36 | void OnPublicResetPacket(const QuicPublicResetPacket& /*packet*/) override {} |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 37 | void OnVersionNegotiationPacket( |
dschinazi | 17d4242 | 2019-06-18 16:35:07 -0700 | [diff] [blame] | 38 | const QuicVersionNegotiationPacket& /*packet*/) override {} |
| 39 | void OnRetryPacket(QuicConnectionId /*original_connection_id*/, |
| 40 | QuicConnectionId /*new_connection_id*/, |
dmcardle | cf0bfcf | 2019-12-13 08:08:21 -0800 | [diff] [blame] | 41 | quiche::QuicheStringPiece /*retry_token*/) override {} |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 42 | bool OnUnauthenticatedPublicHeader(const QuicPacketHeader& header) override; |
| 43 | bool OnUnauthenticatedHeader(const QuicPacketHeader& header) override; |
dschinazi | 17d4242 | 2019-06-18 16:35:07 -0700 | [diff] [blame] | 44 | void OnDecryptedPacket(EncryptionLevel /*level*/) override {} |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 45 | bool OnPacketHeader(const QuicPacketHeader& header) override; |
| 46 | void OnCoalescedPacket(const QuicEncryptedPacket& packet) override; |
dschinazi | 4b5a68a | 2019-08-15 15:45:36 -0700 | [diff] [blame] | 47 | void OnUndecryptablePacket(const QuicEncryptedPacket& packet, |
| 48 | EncryptionLevel decryption_level, |
| 49 | bool has_decryption_key) override; |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 50 | bool OnStreamFrame(const QuicStreamFrame& frame) override; |
| 51 | bool OnCryptoFrame(const QuicCryptoFrame& frame) override; |
| 52 | bool OnAckFrameStart(QuicPacketNumber largest_acked, |
| 53 | QuicTime::Delta ack_delay_time) override; |
| 54 | bool OnAckRange(QuicPacketNumber start, QuicPacketNumber end) override; |
| 55 | bool OnAckTimestamp(QuicPacketNumber packet_number, |
| 56 | QuicTime timestamp) override; |
| 57 | bool OnAckFrameEnd(QuicPacketNumber start) override; |
| 58 | bool OnStopWaitingFrame(const QuicStopWaitingFrame& frame) override; |
| 59 | bool OnPingFrame(const QuicPingFrame& frame) override; |
| 60 | bool OnRstStreamFrame(const QuicRstStreamFrame& frame) override; |
| 61 | bool OnConnectionCloseFrame(const QuicConnectionCloseFrame& frame) override; |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 62 | bool OnNewConnectionIdFrame(const QuicNewConnectionIdFrame& frame) override; |
| 63 | bool OnRetireConnectionIdFrame( |
| 64 | const QuicRetireConnectionIdFrame& frame) override; |
| 65 | bool OnNewTokenFrame(const QuicNewTokenFrame& frame) override; |
| 66 | bool OnStopSendingFrame(const QuicStopSendingFrame& frame) override; |
| 67 | bool OnPathChallengeFrame(const QuicPathChallengeFrame& frame) override; |
| 68 | bool OnPathResponseFrame(const QuicPathResponseFrame& frame) override; |
| 69 | bool OnGoAwayFrame(const QuicGoAwayFrame& frame) override; |
fkastenholz | 3c4eabf | 2019-04-22 07:49:59 -0700 | [diff] [blame] | 70 | bool OnMaxStreamsFrame(const QuicMaxStreamsFrame& frame) override; |
| 71 | bool OnStreamsBlockedFrame(const QuicStreamsBlockedFrame& frame) override; |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 72 | bool OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) override; |
| 73 | bool OnBlockedFrame(const QuicBlockedFrame& frame) override; |
| 74 | bool OnPaddingFrame(const QuicPaddingFrame& frame) override; |
| 75 | bool OnMessageFrame(const QuicMessageFrame& frame) override; |
fayang | 0106294 | 2020-01-22 07:23:23 -0800 | [diff] [blame^] | 76 | bool OnHandshakeDoneFrame(const QuicHandshakeDoneFrame& frame) override; |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 77 | void OnPacketComplete() override {} |
| 78 | bool IsValidStatelessResetToken(QuicUint128 token) const override; |
| 79 | void OnAuthenticatedIetfStatelessResetPacket( |
dschinazi | 17d4242 | 2019-06-18 16:35:07 -0700 | [diff] [blame] | 80 | const QuicIetfStatelessResetPacket& /*packet*/) override {} |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 81 | |
| 82 | // CryptoFramerVisitorInterface implementation. |
| 83 | void OnError(CryptoFramer* framer) override; |
| 84 | void OnHandshakeMessage(const CryptoHandshakeMessage& message) override; |
| 85 | |
| 86 | // Shared implementation between OnStreamFrame and OnCryptoFrame. |
dmcardle | cf0bfcf | 2019-12-13 08:08:21 -0800 | [diff] [blame] | 87 | bool OnHandshakeData(quiche::QuicheStringPiece data); |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 88 | |
| 89 | bool found_chlo() { return found_chlo_; } |
| 90 | bool chlo_contains_tags() { return chlo_contains_tags_; } |
| 91 | |
| 92 | private: |
| 93 | QuicFramer* framer_; |
| 94 | const QuicTagVector& create_session_tag_indicators_; |
| 95 | ChloExtractor::Delegate* delegate_; |
| 96 | bool found_chlo_; |
| 97 | bool chlo_contains_tags_; |
| 98 | QuicConnectionId connection_id_; |
| 99 | }; |
| 100 | |
| 101 | ChloFramerVisitor::ChloFramerVisitor( |
| 102 | QuicFramer* framer, |
| 103 | const QuicTagVector& create_session_tag_indicators, |
| 104 | ChloExtractor::Delegate* delegate) |
| 105 | : framer_(framer), |
| 106 | create_session_tag_indicators_(create_session_tag_indicators), |
| 107 | delegate_(delegate), |
| 108 | found_chlo_(false), |
| 109 | chlo_contains_tags_(false), |
| 110 | connection_id_(EmptyQuicConnectionId()) {} |
| 111 | |
fayang | 8aba1ff | 2019-06-21 12:00:54 -0700 | [diff] [blame] | 112 | bool ChloFramerVisitor::OnProtocolVersionMismatch(ParsedQuicVersion version) { |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 113 | if (!framer_->IsSupportedVersion(version)) { |
| 114 | return false; |
| 115 | } |
| 116 | framer_->set_version(version); |
| 117 | return true; |
| 118 | } |
| 119 | |
| 120 | bool ChloFramerVisitor::OnUnauthenticatedPublicHeader( |
| 121 | const QuicPacketHeader& header) { |
| 122 | connection_id_ = header.destination_connection_id; |
nharper | 55fa613 | 2019-05-07 19:37:21 -0700 | [diff] [blame] | 123 | // QuicFramer creates a NullEncrypter and NullDecrypter at level |
nharper | 4a5a76c | 2019-09-13 13:44:37 -0700 | [diff] [blame] | 124 | // ENCRYPTION_INITIAL. While those are the correct ones to use with some |
| 125 | // versions of QUIC, others use the IETF-style initial crypters, so those need |
| 126 | // to be created and installed. |
| 127 | framer_->SetInitialObfuscators(header.destination_connection_id); |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 128 | return true; |
| 129 | } |
| 130 | bool ChloFramerVisitor::OnUnauthenticatedHeader( |
dschinazi | 17d4242 | 2019-06-18 16:35:07 -0700 | [diff] [blame] | 131 | const QuicPacketHeader& /*header*/) { |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 132 | return true; |
| 133 | } |
dschinazi | 17d4242 | 2019-06-18 16:35:07 -0700 | [diff] [blame] | 134 | bool ChloFramerVisitor::OnPacketHeader(const QuicPacketHeader& /*header*/) { |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 135 | return true; |
| 136 | } |
dschinazi | 4b5a68a | 2019-08-15 15:45:36 -0700 | [diff] [blame] | 137 | |
dschinazi | 17d4242 | 2019-06-18 16:35:07 -0700 | [diff] [blame] | 138 | void ChloFramerVisitor::OnCoalescedPacket( |
| 139 | const QuicEncryptedPacket& /*packet*/) {} |
dschinazi | 4b5a68a | 2019-08-15 15:45:36 -0700 | [diff] [blame] | 140 | |
| 141 | void ChloFramerVisitor::OnUndecryptablePacket( |
| 142 | const QuicEncryptedPacket& /*packet*/, |
| 143 | EncryptionLevel /*decryption_level*/, |
| 144 | bool /*has_decryption_key*/) {} |
| 145 | |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 146 | bool ChloFramerVisitor::OnStreamFrame(const QuicStreamFrame& frame) { |
QUICHE team | ea74008 | 2019-03-11 17:58:43 -0700 | [diff] [blame] | 147 | if (QuicVersionUsesCryptoFrames(framer_->transport_version())) { |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 148 | // CHLO will be sent in CRYPTO frames in v47 and above. |
| 149 | return false; |
| 150 | } |
dmcardle | cf0bfcf | 2019-12-13 08:08:21 -0800 | [diff] [blame] | 151 | quiche::QuicheStringPiece data(frame.data_buffer, frame.data_length); |
nharper | 46833c3 | 2019-05-15 21:33:05 -0700 | [diff] [blame] | 152 | if (QuicUtils::IsCryptoStreamId(framer_->transport_version(), |
| 153 | frame.stream_id) && |
dmcardle | cf0bfcf | 2019-12-13 08:08:21 -0800 | [diff] [blame] | 154 | frame.offset == 0 && quiche::QuicheTextUtils::StartsWith(data, "CHLO")) { |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 155 | return OnHandshakeData(data); |
| 156 | } |
| 157 | return true; |
| 158 | } |
| 159 | |
| 160 | bool ChloFramerVisitor::OnCryptoFrame(const QuicCryptoFrame& frame) { |
QUICHE team | ea74008 | 2019-03-11 17:58:43 -0700 | [diff] [blame] | 161 | if (!QuicVersionUsesCryptoFrames(framer_->transport_version())) { |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 162 | // CHLO will be in stream frames before v47. |
| 163 | return false; |
| 164 | } |
dmcardle | cf0bfcf | 2019-12-13 08:08:21 -0800 | [diff] [blame] | 165 | quiche::QuicheStringPiece data(frame.data_buffer, frame.data_length); |
| 166 | if (frame.offset == 0 && quiche::QuicheTextUtils::StartsWith(data, "CHLO")) { |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 167 | return OnHandshakeData(data); |
| 168 | } |
| 169 | return true; |
| 170 | } |
| 171 | |
dmcardle | cf0bfcf | 2019-12-13 08:08:21 -0800 | [diff] [blame] | 172 | bool ChloFramerVisitor::OnHandshakeData(quiche::QuicheStringPiece data) { |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 173 | CryptoFramer crypto_framer; |
| 174 | crypto_framer.set_visitor(this); |
| 175 | if (!crypto_framer.ProcessInput(data)) { |
| 176 | return false; |
| 177 | } |
| 178 | // Interrogate the crypto framer and see if there are any |
| 179 | // intersecting tags between what we saw in the maybe-CHLO and the |
| 180 | // indicator set. |
| 181 | for (const QuicTag tag : create_session_tag_indicators_) { |
| 182 | if (crypto_framer.HasTag(tag)) { |
| 183 | chlo_contains_tags_ = true; |
| 184 | } |
| 185 | } |
| 186 | if (chlo_contains_tags_ && delegate_) { |
| 187 | // Unfortunately, because this is a partial CHLO, |
| 188 | // OnHandshakeMessage was never called, so the ALPN was never |
| 189 | // extracted. Fake it up a bit and send it to the delegate so that |
| 190 | // the correct dispatch can happen. |
| 191 | crypto_framer.ForceHandshake(); |
| 192 | } |
| 193 | |
| 194 | return true; |
| 195 | } |
| 196 | |
| 197 | bool ChloFramerVisitor::OnAckFrameStart(QuicPacketNumber /*largest_acked*/, |
| 198 | QuicTime::Delta /*ack_delay_time*/) { |
| 199 | return true; |
| 200 | } |
| 201 | |
| 202 | bool ChloFramerVisitor::OnAckRange(QuicPacketNumber /*start*/, |
| 203 | QuicPacketNumber /*end*/) { |
| 204 | return true; |
| 205 | } |
| 206 | |
| 207 | bool ChloFramerVisitor::OnAckTimestamp(QuicPacketNumber /*packet_number*/, |
| 208 | QuicTime /*timestamp*/) { |
| 209 | return true; |
| 210 | } |
| 211 | |
| 212 | bool ChloFramerVisitor::OnAckFrameEnd(QuicPacketNumber /*start*/) { |
| 213 | return true; |
| 214 | } |
| 215 | |
dschinazi | 17d4242 | 2019-06-18 16:35:07 -0700 | [diff] [blame] | 216 | bool ChloFramerVisitor::OnStopWaitingFrame( |
| 217 | const QuicStopWaitingFrame& /*frame*/) { |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 218 | return true; |
| 219 | } |
| 220 | |
dschinazi | 17d4242 | 2019-06-18 16:35:07 -0700 | [diff] [blame] | 221 | bool ChloFramerVisitor::OnPingFrame(const QuicPingFrame& /*frame*/) { |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 222 | return true; |
| 223 | } |
| 224 | |
dschinazi | 17d4242 | 2019-06-18 16:35:07 -0700 | [diff] [blame] | 225 | bool ChloFramerVisitor::OnRstStreamFrame(const QuicRstStreamFrame& /*frame*/) { |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 226 | return true; |
| 227 | } |
| 228 | |
| 229 | bool ChloFramerVisitor::OnConnectionCloseFrame( |
dschinazi | 17d4242 | 2019-06-18 16:35:07 -0700 | [diff] [blame] | 230 | const QuicConnectionCloseFrame& /*frame*/) { |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 231 | return true; |
| 232 | } |
| 233 | |
dschinazi | 17d4242 | 2019-06-18 16:35:07 -0700 | [diff] [blame] | 234 | bool ChloFramerVisitor::OnStopSendingFrame( |
| 235 | const QuicStopSendingFrame& /*frame*/) { |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 236 | return true; |
| 237 | } |
| 238 | |
| 239 | bool ChloFramerVisitor::OnPathChallengeFrame( |
dschinazi | 17d4242 | 2019-06-18 16:35:07 -0700 | [diff] [blame] | 240 | const QuicPathChallengeFrame& /*frame*/) { |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 241 | return true; |
| 242 | } |
| 243 | |
| 244 | bool ChloFramerVisitor::OnPathResponseFrame( |
dschinazi | 17d4242 | 2019-06-18 16:35:07 -0700 | [diff] [blame] | 245 | const QuicPathResponseFrame& /*frame*/) { |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 246 | return true; |
| 247 | } |
| 248 | |
dschinazi | 17d4242 | 2019-06-18 16:35:07 -0700 | [diff] [blame] | 249 | bool ChloFramerVisitor::OnGoAwayFrame(const QuicGoAwayFrame& /*frame*/) { |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 250 | return true; |
| 251 | } |
| 252 | |
| 253 | bool ChloFramerVisitor::OnWindowUpdateFrame( |
dschinazi | 17d4242 | 2019-06-18 16:35:07 -0700 | [diff] [blame] | 254 | const QuicWindowUpdateFrame& /*frame*/) { |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 255 | return true; |
| 256 | } |
| 257 | |
dschinazi | 17d4242 | 2019-06-18 16:35:07 -0700 | [diff] [blame] | 258 | bool ChloFramerVisitor::OnBlockedFrame(const QuicBlockedFrame& /*frame*/) { |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 259 | return true; |
| 260 | } |
| 261 | |
| 262 | bool ChloFramerVisitor::OnNewConnectionIdFrame( |
dschinazi | 17d4242 | 2019-06-18 16:35:07 -0700 | [diff] [blame] | 263 | const QuicNewConnectionIdFrame& /*frame*/) { |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 264 | return true; |
| 265 | } |
| 266 | |
| 267 | bool ChloFramerVisitor::OnRetireConnectionIdFrame( |
dschinazi | 17d4242 | 2019-06-18 16:35:07 -0700 | [diff] [blame] | 268 | const QuicRetireConnectionIdFrame& /*frame*/) { |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 269 | return true; |
| 270 | } |
| 271 | |
dschinazi | 17d4242 | 2019-06-18 16:35:07 -0700 | [diff] [blame] | 272 | bool ChloFramerVisitor::OnNewTokenFrame(const QuicNewTokenFrame& /*frame*/) { |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 273 | return true; |
| 274 | } |
| 275 | |
dschinazi | 17d4242 | 2019-06-18 16:35:07 -0700 | [diff] [blame] | 276 | bool ChloFramerVisitor::OnPaddingFrame(const QuicPaddingFrame& /*frame*/) { |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 277 | return true; |
| 278 | } |
| 279 | |
dschinazi | 17d4242 | 2019-06-18 16:35:07 -0700 | [diff] [blame] | 280 | bool ChloFramerVisitor::OnMessageFrame(const QuicMessageFrame& /*frame*/) { |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 281 | return true; |
| 282 | } |
| 283 | |
fayang | 0106294 | 2020-01-22 07:23:23 -0800 | [diff] [blame^] | 284 | bool ChloFramerVisitor::OnHandshakeDoneFrame( |
| 285 | const QuicHandshakeDoneFrame& /*frame*/) { |
| 286 | return true; |
| 287 | } |
| 288 | |
dschinazi | 17d4242 | 2019-06-18 16:35:07 -0700 | [diff] [blame] | 289 | bool ChloFramerVisitor::IsValidStatelessResetToken( |
| 290 | QuicUint128 /*token*/) const { |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 291 | return false; |
| 292 | } |
| 293 | |
dschinazi | 17d4242 | 2019-06-18 16:35:07 -0700 | [diff] [blame] | 294 | bool ChloFramerVisitor::OnMaxStreamsFrame( |
| 295 | const QuicMaxStreamsFrame& /*frame*/) { |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 296 | return true; |
| 297 | } |
| 298 | |
fkastenholz | 3c4eabf | 2019-04-22 07:49:59 -0700 | [diff] [blame] | 299 | bool ChloFramerVisitor::OnStreamsBlockedFrame( |
dschinazi | 17d4242 | 2019-06-18 16:35:07 -0700 | [diff] [blame] | 300 | const QuicStreamsBlockedFrame& /*frame*/) { |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 301 | return true; |
| 302 | } |
| 303 | |
dschinazi | 17d4242 | 2019-06-18 16:35:07 -0700 | [diff] [blame] | 304 | void ChloFramerVisitor::OnError(CryptoFramer* /*framer*/) {} |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 305 | |
| 306 | void ChloFramerVisitor::OnHandshakeMessage( |
| 307 | const CryptoHandshakeMessage& message) { |
| 308 | if (delegate_ != nullptr) { |
| 309 | delegate_->OnChlo(framer_->transport_version(), connection_id_, message); |
| 310 | } |
| 311 | found_chlo_ = true; |
| 312 | } |
| 313 | |
| 314 | } // namespace |
| 315 | |
| 316 | // static |
| 317 | bool ChloExtractor::Extract(const QuicEncryptedPacket& packet, |
dschinazi | 4fd8cb1 | 2019-09-09 16:31:06 -0700 | [diff] [blame] | 318 | ParsedQuicVersion version, |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 319 | const QuicTagVector& create_session_tag_indicators, |
| 320 | Delegate* delegate, |
| 321 | uint8_t connection_id_length) { |
dschinazi | 4fd8cb1 | 2019-09-09 16:31:06 -0700 | [diff] [blame] | 322 | QUIC_DVLOG(1) << "Extracting CHLO using version " << version; |
| 323 | QuicFramer framer({version}, QuicTime::Zero(), Perspective::IS_SERVER, |
QUICHE team | a6ef0a6 | 2019-03-07 20:34:33 -0500 | [diff] [blame] | 324 | connection_id_length); |
| 325 | ChloFramerVisitor visitor(&framer, create_session_tag_indicators, delegate); |
| 326 | framer.set_visitor(&visitor); |
| 327 | if (!framer.ProcessPacket(packet)) { |
| 328 | return false; |
| 329 | } |
| 330 | return visitor.found_chlo() || visitor.chlo_contains_tags(); |
| 331 | } |
| 332 | |
| 333 | } // namespace quic |