blob: 2f8c5c1eb54ee6172390604f05bc163f182197db [file] [log] [blame]
Bence Békybac04052022-04-07 15:44:29 -04001// Copyright (c) 2012 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 "quiche/quic/core/quic_framer.h"
6
7#include <cstddef>
8#include <cstdint>
9#include <limits>
10#include <memory>
11#include <string>
12#include <utility>
13
14#include "absl/base/attributes.h"
15#include "absl/base/macros.h"
16#include "absl/base/optimization.h"
17#include "absl/strings/escaping.h"
18#include "absl/strings/numbers.h"
19#include "absl/strings/str_cat.h"
20#include "absl/strings/str_split.h"
21#include "absl/strings/string_view.h"
22#include "quiche/quic/core/crypto/crypto_framer.h"
23#include "quiche/quic/core/crypto/crypto_handshake.h"
24#include "quiche/quic/core/crypto/crypto_handshake_message.h"
25#include "quiche/quic/core/crypto/crypto_protocol.h"
26#include "quiche/quic/core/crypto/crypto_utils.h"
27#include "quiche/quic/core/crypto/null_decrypter.h"
28#include "quiche/quic/core/crypto/null_encrypter.h"
29#include "quiche/quic/core/crypto/quic_decrypter.h"
30#include "quiche/quic/core/crypto/quic_encrypter.h"
31#include "quiche/quic/core/crypto/quic_random.h"
32#include "quiche/quic/core/frames/quic_ack_frequency_frame.h"
33#include "quiche/quic/core/quic_connection_id.h"
34#include "quiche/quic/core/quic_constants.h"
35#include "quiche/quic/core/quic_data_reader.h"
36#include "quiche/quic/core/quic_data_writer.h"
37#include "quiche/quic/core/quic_error_codes.h"
38#include "quiche/quic/core/quic_packets.h"
39#include "quiche/quic/core/quic_socket_address_coder.h"
40#include "quiche/quic/core/quic_stream_frame_data_producer.h"
41#include "quiche/quic/core/quic_time.h"
42#include "quiche/quic/core/quic_types.h"
43#include "quiche/quic/core/quic_utils.h"
44#include "quiche/quic/core/quic_versions.h"
45#include "quiche/quic/platform/api/quic_bug_tracker.h"
46#include "quiche/quic/platform/api/quic_client_stats.h"
47#include "quiche/quic/platform/api/quic_flag_utils.h"
48#include "quiche/quic/platform/api/quic_flags.h"
49#include "quiche/quic/platform/api/quic_ip_address_family.h"
50#include "quiche/quic/platform/api/quic_logging.h"
51#include "quiche/quic/platform/api/quic_stack_trace.h"
52#include "quiche/common/quiche_text_utils.h"
53
54namespace quic {
55
56namespace {
57
58#define ENDPOINT \
59 (perspective_ == Perspective::IS_SERVER ? "Server: " : "Client: ")
60
61// Number of bits the packet number length bits are shifted from the right
62// edge of the header.
63const uint8_t kPublicHeaderSequenceNumberShift = 4;
64
65// There are two interpretations for the Frame Type byte in the QUIC protocol,
66// resulting in two Frame Types: Special Frame Types and Regular Frame Types.
67//
68// Regular Frame Types use the Frame Type byte simply. Currently defined
69// Regular Frame Types are:
70// Padding : 0b 00000000 (0x00)
71// ResetStream : 0b 00000001 (0x01)
72// ConnectionClose : 0b 00000010 (0x02)
73// GoAway : 0b 00000011 (0x03)
74// WindowUpdate : 0b 00000100 (0x04)
75// Blocked : 0b 00000101 (0x05)
76//
77// Special Frame Types encode both a Frame Type and corresponding flags
78// all in the Frame Type byte. Currently defined Special Frame Types
79// are:
80// Stream : 0b 1xxxxxxx
81// Ack : 0b 01xxxxxx
82//
83// Semantics of the flag bits above (the x bits) depends on the frame type.
84
85// Masks to determine if the frame type is a special use
86// and for specific special frame types.
87const uint8_t kQuicFrameTypeBrokenMask = 0xE0; // 0b 11100000
88const uint8_t kQuicFrameTypeSpecialMask = 0xC0; // 0b 11000000
89const uint8_t kQuicFrameTypeStreamMask = 0x80;
90const uint8_t kQuicFrameTypeAckMask = 0x40;
91static_assert(kQuicFrameTypeSpecialMask ==
92 (kQuicFrameTypeStreamMask | kQuicFrameTypeAckMask),
93 "Invalid kQuicFrameTypeSpecialMask");
94
95// The stream type format is 1FDOOOSS, where
96// F is the fin bit.
97// D is the data length bit (0 or 2 bytes).
98// OO/OOO are the size of the offset.
99// SS is the size of the stream ID.
100// Note that the stream encoding can not be determined by inspection. It can
101// be determined only by knowing the QUIC Version.
102// Stream frame relative shifts and masks for interpreting the stream flags.
103// StreamID may be 1, 2, 3, or 4 bytes.
104const uint8_t kQuicStreamIdShift = 2;
105const uint8_t kQuicStreamIDLengthMask = 0x03;
106
107// Offset may be 0, 2, 4, or 8 bytes.
108const uint8_t kQuicStreamShift = 3;
109const uint8_t kQuicStreamOffsetMask = 0x07;
110
111// Data length may be 0 or 2 bytes.
112const uint8_t kQuicStreamDataLengthShift = 1;
113const uint8_t kQuicStreamDataLengthMask = 0x01;
114
115// Fin bit may be set or not.
116const uint8_t kQuicStreamFinShift = 1;
117const uint8_t kQuicStreamFinMask = 0x01;
118
119// The format is 01M0LLOO, where
120// M if set, there are multiple ack blocks in the frame.
121// LL is the size of the largest ack field.
122// OO is the size of the ack blocks offset field.
123// packet number size shift used in AckFrames.
124const uint8_t kQuicSequenceNumberLengthNumBits = 2;
125const uint8_t kActBlockLengthOffset = 0;
126const uint8_t kLargestAckedOffset = 2;
127
128// Acks may have only one ack block.
129const uint8_t kQuicHasMultipleAckBlocksOffset = 5;
130
131// Timestamps are 4 bytes followed by 2 bytes.
132const uint8_t kQuicNumTimestampsLength = 1;
133const uint8_t kQuicFirstTimestampLength = 4;
134const uint8_t kQuicTimestampLength = 2;
135// Gaps between packet numbers are 1 byte.
136const uint8_t kQuicTimestampPacketNumberGapLength = 1;
137
138// Maximum length of encoded error strings.
139const int kMaxErrorStringLength = 256;
140
141const uint8_t kConnectionIdLengthAdjustment = 3;
142const uint8_t kDestinationConnectionIdLengthMask = 0xF0;
143const uint8_t kSourceConnectionIdLengthMask = 0x0F;
144
145// Returns the absolute value of the difference between |a| and |b|.
146uint64_t Delta(uint64_t a, uint64_t b) {
147 // Since these are unsigned numbers, we can't just return abs(a - b)
148 if (a < b) {
149 return b - a;
150 }
151 return a - b;
152}
153
154uint64_t ClosestTo(uint64_t target, uint64_t a, uint64_t b) {
155 return (Delta(target, a) < Delta(target, b)) ? a : b;
156}
157
158QuicPacketNumberLength ReadSequenceNumberLength(uint8_t flags) {
159 switch (flags & PACKET_FLAGS_8BYTE_PACKET) {
160 case PACKET_FLAGS_8BYTE_PACKET:
161 return PACKET_6BYTE_PACKET_NUMBER;
162 case PACKET_FLAGS_4BYTE_PACKET:
163 return PACKET_4BYTE_PACKET_NUMBER;
164 case PACKET_FLAGS_2BYTE_PACKET:
165 return PACKET_2BYTE_PACKET_NUMBER;
166 case PACKET_FLAGS_1BYTE_PACKET:
167 return PACKET_1BYTE_PACKET_NUMBER;
168 default:
169 QUIC_BUG(quic_bug_10850_1) << "Unreachable case statement.";
170 return PACKET_6BYTE_PACKET_NUMBER;
171 }
172}
173
174QuicPacketNumberLength ReadAckPacketNumberLength(uint8_t flags) {
175 switch (flags & PACKET_FLAGS_8BYTE_PACKET) {
176 case PACKET_FLAGS_8BYTE_PACKET:
177 return PACKET_6BYTE_PACKET_NUMBER;
178 case PACKET_FLAGS_4BYTE_PACKET:
179 return PACKET_4BYTE_PACKET_NUMBER;
180 case PACKET_FLAGS_2BYTE_PACKET:
181 return PACKET_2BYTE_PACKET_NUMBER;
182 case PACKET_FLAGS_1BYTE_PACKET:
183 return PACKET_1BYTE_PACKET_NUMBER;
184 default:
185 QUIC_BUG(quic_bug_10850_2) << "Unreachable case statement.";
186 return PACKET_6BYTE_PACKET_NUMBER;
187 }
188}
189
190uint8_t PacketNumberLengthToOnWireValue(
191 QuicPacketNumberLength packet_number_length) {
192 return packet_number_length - 1;
193}
194
195QuicPacketNumberLength GetShortHeaderPacketNumberLength(uint8_t type) {
196 QUICHE_DCHECK(!(type & FLAGS_LONG_HEADER));
197 return static_cast<QuicPacketNumberLength>((type & 0x03) + 1);
198}
199
200uint8_t LongHeaderTypeToOnWireValue(QuicLongHeaderType type,
201 const ParsedQuicVersion& version) {
202 switch (type) {
203 case INITIAL:
204 return version.UsesV2PacketTypes() ? (1 << 4) : 0;
205 case ZERO_RTT_PROTECTED:
206 return version.UsesV2PacketTypes() ? (2 << 4) : (1 << 4);
207 case HANDSHAKE:
208 return version.UsesV2PacketTypes() ? (3 << 4) : (2 << 4);
209 case RETRY:
210 return version.UsesV2PacketTypes() ? 0 : (3 << 4);
211 case VERSION_NEGOTIATION:
212 return 0xF0; // Value does not matter
213 default:
214 QUIC_BUG(quic_bug_10850_3) << "Invalid long header type: " << type;
215 return 0xFF;
216 }
217}
218
219QuicLongHeaderType GetLongHeaderType(uint8_t type,
220 const ParsedQuicVersion& version) {
221 QUICHE_DCHECK((type & FLAGS_LONG_HEADER));
222 switch ((type & 0x30) >> 4) {
223 case 0:
224 return version.UsesV2PacketTypes() ? RETRY : INITIAL;
225 case 1:
226 return version.UsesV2PacketTypes() ? INITIAL : ZERO_RTT_PROTECTED;
227 case 2:
228 return version.UsesV2PacketTypes() ? ZERO_RTT_PROTECTED : HANDSHAKE;
229 case 3:
230 return version.UsesV2PacketTypes() ? HANDSHAKE : RETRY;
231 default:
232 QUIC_BUG(quic_bug_10850_4) << "Unreachable statement";
233 return INVALID_PACKET_TYPE;
234 }
235}
236
237QuicPacketNumberLength GetLongHeaderPacketNumberLength(uint8_t type) {
238 return static_cast<QuicPacketNumberLength>((type & 0x03) + 1);
239}
240
241// Used to get packet number space before packet gets decrypted.
242PacketNumberSpace GetPacketNumberSpace(const QuicPacketHeader& header) {
243 switch (header.form) {
244 case GOOGLE_QUIC_PACKET:
245 QUIC_BUG(quic_bug_10850_5)
246 << "Try to get packet number space of Google QUIC packet";
247 break;
248 case IETF_QUIC_SHORT_HEADER_PACKET:
249 return APPLICATION_DATA;
250 case IETF_QUIC_LONG_HEADER_PACKET:
251 switch (header.long_packet_type) {
252 case INITIAL:
253 return INITIAL_DATA;
254 case HANDSHAKE:
255 return HANDSHAKE_DATA;
256 case ZERO_RTT_PROTECTED:
257 return APPLICATION_DATA;
258 case VERSION_NEGOTIATION:
259 case RETRY:
260 case INVALID_PACKET_TYPE:
261 QUIC_BUG(quic_bug_10850_6)
262 << "Try to get packet number space of long header type: "
263 << QuicUtils::QuicLongHeaderTypetoString(header.long_packet_type);
264 break;
265 }
266 }
267
268 return NUM_PACKET_NUMBER_SPACES;
269}
270
271EncryptionLevel GetEncryptionLevel(const QuicPacketHeader& header) {
272 switch (header.form) {
273 case GOOGLE_QUIC_PACKET:
274 QUIC_BUG(quic_bug_10850_7)
275 << "Cannot determine EncryptionLevel from Google QUIC header";
276 break;
277 case IETF_QUIC_SHORT_HEADER_PACKET:
278 return ENCRYPTION_FORWARD_SECURE;
279 case IETF_QUIC_LONG_HEADER_PACKET:
280 switch (header.long_packet_type) {
281 case INITIAL:
282 return ENCRYPTION_INITIAL;
283 case HANDSHAKE:
284 return ENCRYPTION_HANDSHAKE;
285 case ZERO_RTT_PROTECTED:
286 return ENCRYPTION_ZERO_RTT;
287 case VERSION_NEGOTIATION:
288 case RETRY:
289 case INVALID_PACKET_TYPE:
290 QUIC_BUG(quic_bug_10850_8)
291 << "No encryption used with type "
292 << QuicUtils::QuicLongHeaderTypetoString(header.long_packet_type);
293 }
294 }
295 return NUM_ENCRYPTION_LEVELS;
296}
297
298absl::string_view TruncateErrorString(absl::string_view error) {
299 if (error.length() <= kMaxErrorStringLength) {
300 return error;
301 }
302 return absl::string_view(error.data(), kMaxErrorStringLength);
303}
304
305size_t TruncatedErrorStringSize(const absl::string_view& error) {
306 if (error.length() < kMaxErrorStringLength) {
307 return error.length();
308 }
309 return kMaxErrorStringLength;
310}
311
312uint8_t GetConnectionIdLengthValue(QuicConnectionIdLength length) {
313 if (length == 0) {
314 return 0;
315 }
316 return static_cast<uint8_t>(length - kConnectionIdLengthAdjustment);
317}
318
319bool IsValidPacketNumberLength(QuicPacketNumberLength packet_number_length) {
320 size_t length = packet_number_length;
321 return length == 1 || length == 2 || length == 4 || length == 6 ||
322 length == 8;
323}
324
325bool IsValidFullPacketNumber(uint64_t full_packet_number,
326 ParsedQuicVersion version) {
327 return full_packet_number > 0 || version.HasIetfQuicFrames();
328}
329
330bool AppendIetfConnectionIds(bool version_flag, bool use_length_prefix,
331 QuicConnectionId destination_connection_id,
332 QuicConnectionId source_connection_id,
333 QuicDataWriter* writer) {
334 if (!version_flag) {
335 return writer->WriteConnectionId(destination_connection_id);
336 }
337
338 if (use_length_prefix) {
339 return writer->WriteLengthPrefixedConnectionId(destination_connection_id) &&
340 writer->WriteLengthPrefixedConnectionId(source_connection_id);
341 }
342
343 // Compute connection ID length byte.
344 uint8_t dcil = GetConnectionIdLengthValue(
345 static_cast<QuicConnectionIdLength>(destination_connection_id.length()));
346 uint8_t scil = GetConnectionIdLengthValue(
347 static_cast<QuicConnectionIdLength>(source_connection_id.length()));
348 uint8_t connection_id_length = dcil << 4 | scil;
349
350 return writer->WriteUInt8(connection_id_length) &&
351 writer->WriteConnectionId(destination_connection_id) &&
352 writer->WriteConnectionId(source_connection_id);
353}
354
355enum class DroppedPacketReason {
356 // General errors
357 INVALID_PUBLIC_HEADER,
358 VERSION_MISMATCH,
359 // Version negotiation packet errors
360 INVALID_VERSION_NEGOTIATION_PACKET,
361 // Public reset packet errors, pre-v44
362 INVALID_PUBLIC_RESET_PACKET,
363 // Data packet errors
364 INVALID_PACKET_NUMBER,
365 INVALID_DIVERSIFICATION_NONCE,
366 DECRYPTION_FAILURE,
367 NUM_REASONS,
368};
369
370void RecordDroppedPacketReason(DroppedPacketReason reason) {
371 QUIC_CLIENT_HISTOGRAM_ENUM("QuicDroppedPacketReason", reason,
372 DroppedPacketReason::NUM_REASONS,
373 "The reason a packet was not processed. Recorded "
374 "each time such a packet is dropped");
375}
376
377PacketHeaderFormat GetIetfPacketHeaderFormat(uint8_t type_byte) {
378 return type_byte & FLAGS_LONG_HEADER ? IETF_QUIC_LONG_HEADER_PACKET
379 : IETF_QUIC_SHORT_HEADER_PACKET;
380}
381
382std::string GenerateErrorString(std::string initial_error_string,
383 QuicErrorCode quic_error_code) {
384 if (quic_error_code == QUIC_IETF_GQUIC_ERROR_MISSING) {
385 // QUIC_IETF_GQUIC_ERROR_MISSING is special -- it means not to encode
386 // the error value in the string.
387 return initial_error_string;
388 }
389 return absl::StrCat(std::to_string(static_cast<unsigned>(quic_error_code)),
390 ":", initial_error_string);
391}
392
393} // namespace
394
395QuicFramer::QuicFramer(const ParsedQuicVersionVector& supported_versions,
396 QuicTime creation_time, Perspective perspective,
397 uint8_t expected_server_connection_id_length)
398 : visitor_(nullptr),
399 error_(QUIC_NO_ERROR),
400 last_serialized_server_connection_id_(EmptyQuicConnectionId()),
401 last_serialized_client_connection_id_(EmptyQuicConnectionId()),
402 version_(ParsedQuicVersion::Unsupported()),
403 supported_versions_(supported_versions),
404 decrypter_level_(ENCRYPTION_INITIAL),
405 alternative_decrypter_level_(NUM_ENCRYPTION_LEVELS),
406 alternative_decrypter_latch_(false),
407 perspective_(perspective),
408 validate_flags_(true),
409 process_timestamps_(false),
410 max_receive_timestamps_per_ack_(std::numeric_limits<uint32_t>::max()),
411 receive_timestamps_exponent_(0),
412 creation_time_(creation_time),
413 last_timestamp_(QuicTime::Delta::Zero()),
414 support_key_update_for_connection_(false),
415 current_key_phase_bit_(false),
416 potential_peer_key_update_attempt_count_(0),
417 first_sending_packet_number_(FirstSendingPacketNumber()),
418 data_producer_(nullptr),
419 infer_packet_header_type_from_version_(perspective ==
420 Perspective::IS_CLIENT),
421 expected_server_connection_id_length_(
422 expected_server_connection_id_length),
423 expected_client_connection_id_length_(0),
424 supports_multiple_packet_number_spaces_(false),
425 last_written_packet_number_length_(0),
426 peer_ack_delay_exponent_(kDefaultAckDelayExponent),
427 local_ack_delay_exponent_(kDefaultAckDelayExponent),
428 current_received_frame_type_(0),
429 previously_received_frame_type_(0) {
430 QUICHE_DCHECK(!supported_versions.empty());
431 version_ = supported_versions_[0];
432 QUICHE_DCHECK(version_.IsKnown())
433 << ParsedQuicVersionVectorToString(supported_versions_);
434}
435
436QuicFramer::~QuicFramer() {}
437
438// static
439size_t QuicFramer::GetMinStreamFrameSize(QuicTransportVersion version,
440 QuicStreamId stream_id,
441 QuicStreamOffset offset,
442 bool last_frame_in_packet,
443 size_t data_length) {
444 if (VersionHasIetfQuicFrames(version)) {
445 return kQuicFrameTypeSize + QuicDataWriter::GetVarInt62Len(stream_id) +
446 (last_frame_in_packet
447 ? 0
448 : QuicDataWriter::GetVarInt62Len(data_length)) +
449 (offset != 0 ? QuicDataWriter::GetVarInt62Len(offset) : 0);
450 }
451 return kQuicFrameTypeSize + GetStreamIdSize(stream_id) +
452 GetStreamOffsetSize(offset) +
453 (last_frame_in_packet ? 0 : kQuicStreamPayloadLengthSize);
454}
455
456// static
457size_t QuicFramer::GetMinCryptoFrameSize(QuicStreamOffset offset,
458 QuicPacketLength data_length) {
459 return kQuicFrameTypeSize + QuicDataWriter::GetVarInt62Len(offset) +
460 QuicDataWriter::GetVarInt62Len(data_length);
461}
462
463// static
464size_t QuicFramer::GetMessageFrameSize(QuicTransportVersion version,
465 bool last_frame_in_packet,
466 QuicByteCount length) {
467 QUIC_BUG_IF(quic_bug_12975_1, !VersionSupportsMessageFrames(version))
468 << "Try to serialize MESSAGE frame in " << version;
469 return kQuicFrameTypeSize +
470 (last_frame_in_packet ? 0 : QuicDataWriter::GetVarInt62Len(length)) +
471 length;
472}
473
474// static
475size_t QuicFramer::GetMinAckFrameSize(
476 QuicTransportVersion version, const QuicAckFrame& ack_frame,
477 uint32_t local_ack_delay_exponent,
478 bool use_ietf_ack_with_receive_timestamp) {
479 if (VersionHasIetfQuicFrames(version)) {
480 // The minimal ack frame consists of the following fields: Largest
481 // Acknowledged, ACK Delay, 0 ACK Block Count, First ACK Block and either 0
482 // Timestamp Range Count or ECN counts.
483 // Type byte + largest acked.
484 size_t min_size =
485 kQuicFrameTypeSize +
486 QuicDataWriter::GetVarInt62Len(LargestAcked(ack_frame).ToUint64());
487 // Ack delay.
488 min_size += QuicDataWriter::GetVarInt62Len(
489 ack_frame.ack_delay_time.ToMicroseconds() >> local_ack_delay_exponent);
490 // 0 ack block count.
491 min_size += QuicDataWriter::GetVarInt62Len(0);
492 // First ack block.
493 min_size += QuicDataWriter::GetVarInt62Len(
494 ack_frame.packets.Empty() ? 0
495 : ack_frame.packets.rbegin()->Length() - 1);
496
497 if (use_ietf_ack_with_receive_timestamp) {
498 // 0 Timestamp Range Count.
499 min_size += QuicDataWriter::GetVarInt62Len(0);
500 } else if (ack_frame.ecn_counters_populated &&
501 (ack_frame.ect_0_count || ack_frame.ect_1_count ||
502 ack_frame.ecn_ce_count)) {
503 // ECN counts.
504 min_size += (QuicDataWriter::GetVarInt62Len(ack_frame.ect_0_count) +
505 QuicDataWriter::GetVarInt62Len(ack_frame.ect_1_count) +
506 QuicDataWriter::GetVarInt62Len(ack_frame.ecn_ce_count));
507 }
508 return min_size;
509 }
510 return kQuicFrameTypeSize +
511 GetMinPacketNumberLength(LargestAcked(ack_frame)) +
512 kQuicDeltaTimeLargestObservedSize + kQuicNumTimestampsSize;
513}
514
515// static
516size_t QuicFramer::GetStopWaitingFrameSize(
517 QuicPacketNumberLength packet_number_length) {
518 size_t min_size = kQuicFrameTypeSize + packet_number_length;
519 return min_size;
520}
521
522// static
523size_t QuicFramer::GetRstStreamFrameSize(QuicTransportVersion version,
524 const QuicRstStreamFrame& frame) {
525 if (VersionHasIetfQuicFrames(version)) {
526 return QuicDataWriter::GetVarInt62Len(frame.stream_id) +
527 QuicDataWriter::GetVarInt62Len(frame.byte_offset) +
528 kQuicFrameTypeSize +
529 QuicDataWriter::GetVarInt62Len(frame.ietf_error_code);
530 }
531 return kQuicFrameTypeSize + kQuicMaxStreamIdSize + kQuicMaxStreamOffsetSize +
532 kQuicErrorCodeSize;
533}
534
535// static
536size_t QuicFramer::GetConnectionCloseFrameSize(
537 QuicTransportVersion version, const QuicConnectionCloseFrame& frame) {
538 if (!VersionHasIetfQuicFrames(version)) {
539 // Not IETF QUIC, return Google QUIC CONNECTION CLOSE frame size.
540 return kQuicFrameTypeSize + kQuicErrorCodeSize +
541 kQuicErrorDetailsLengthSize +
542 TruncatedErrorStringSize(frame.error_details);
543 }
544
545 // Prepend the extra error information to the string and get the result's
546 // length.
547 const size_t truncated_error_string_size = TruncatedErrorStringSize(
548 GenerateErrorString(frame.error_details, frame.quic_error_code));
549
550 const size_t frame_size =
551 truncated_error_string_size +
552 QuicDataWriter::GetVarInt62Len(truncated_error_string_size) +
553 kQuicFrameTypeSize +
554 QuicDataWriter::GetVarInt62Len(frame.wire_error_code);
555 if (frame.close_type == IETF_QUIC_APPLICATION_CONNECTION_CLOSE) {
556 return frame_size;
557 }
558 // The Transport close frame has the transport_close_frame_type, so include
559 // its length.
560 return frame_size +
561 QuicDataWriter::GetVarInt62Len(frame.transport_close_frame_type);
562}
563
564// static
565size_t QuicFramer::GetMinGoAwayFrameSize() {
566 return kQuicFrameTypeSize + kQuicErrorCodeSize + kQuicErrorDetailsLengthSize +
567 kQuicMaxStreamIdSize;
568}
569
570// static
571size_t QuicFramer::GetWindowUpdateFrameSize(
572 QuicTransportVersion version, const QuicWindowUpdateFrame& frame) {
573 if (!VersionHasIetfQuicFrames(version)) {
574 return kQuicFrameTypeSize + kQuicMaxStreamIdSize + kQuicMaxStreamOffsetSize;
575 }
576 if (frame.stream_id == QuicUtils::GetInvalidStreamId(version)) {
577 // Frame would be a MAX DATA frame, which has only a Maximum Data field.
578 return kQuicFrameTypeSize + QuicDataWriter::GetVarInt62Len(frame.max_data);
579 }
580 // Frame would be MAX STREAM DATA, has Maximum Stream Data and Stream ID
581 // fields.
582 return kQuicFrameTypeSize + QuicDataWriter::GetVarInt62Len(frame.max_data) +
583 QuicDataWriter::GetVarInt62Len(frame.stream_id);
584}
585
586// static
587size_t QuicFramer::GetMaxStreamsFrameSize(QuicTransportVersion version,
588 const QuicMaxStreamsFrame& frame) {
589 if (!VersionHasIetfQuicFrames(version)) {
590 QUIC_BUG(quic_bug_10850_9)
591 << "In version " << version
592 << ", which does not support IETF Frames, and tried to serialize "
593 "MaxStreams Frame.";
594 }
595 return kQuicFrameTypeSize +
596 QuicDataWriter::GetVarInt62Len(frame.stream_count);
597}
598
599// static
600size_t QuicFramer::GetStreamsBlockedFrameSize(
601 QuicTransportVersion version, const QuicStreamsBlockedFrame& frame) {
602 if (!VersionHasIetfQuicFrames(version)) {
603 QUIC_BUG(quic_bug_10850_10)
604 << "In version " << version
605 << ", which does not support IETF frames, and tried to serialize "
606 "StreamsBlocked Frame.";
607 }
608
609 return kQuicFrameTypeSize +
610 QuicDataWriter::GetVarInt62Len(frame.stream_count);
611}
612
613// static
614size_t QuicFramer::GetBlockedFrameSize(QuicTransportVersion version,
615 const QuicBlockedFrame& frame) {
616 if (!VersionHasIetfQuicFrames(version)) {
617 return kQuicFrameTypeSize + kQuicMaxStreamIdSize;
618 }
619 if (frame.stream_id == QuicUtils::GetInvalidStreamId(version)) {
620 // return size of IETF QUIC Blocked frame
621 return kQuicFrameTypeSize + QuicDataWriter::GetVarInt62Len(frame.offset);
622 }
623 // return size of IETF QUIC Stream Blocked frame.
624 return kQuicFrameTypeSize + QuicDataWriter::GetVarInt62Len(frame.offset) +
625 QuicDataWriter::GetVarInt62Len(frame.stream_id);
626}
627
628// static
629size_t QuicFramer::GetStopSendingFrameSize(const QuicStopSendingFrame& frame) {
630 return kQuicFrameTypeSize + QuicDataWriter::GetVarInt62Len(frame.stream_id) +
631 QuicDataWriter::GetVarInt62Len(frame.ietf_error_code);
632}
633
634// static
635size_t QuicFramer::GetAckFrequencyFrameSize(
636 const QuicAckFrequencyFrame& frame) {
637 return QuicDataWriter::GetVarInt62Len(IETF_ACK_FREQUENCY) +
638 QuicDataWriter::GetVarInt62Len(frame.sequence_number) +
639 QuicDataWriter::GetVarInt62Len(frame.packet_tolerance) +
640 QuicDataWriter::GetVarInt62Len(frame.max_ack_delay.ToMicroseconds()) +
641 // One byte for encoding boolean
642 1;
643}
644
645// static
646size_t QuicFramer::GetPathChallengeFrameSize(
647 const QuicPathChallengeFrame& frame) {
648 return kQuicFrameTypeSize + sizeof(frame.data_buffer);
649}
650
651// static
652size_t QuicFramer::GetPathResponseFrameSize(
653 const QuicPathResponseFrame& frame) {
654 return kQuicFrameTypeSize + sizeof(frame.data_buffer);
655}
656
657// static
658size_t QuicFramer::GetRetransmittableControlFrameSize(
659 QuicTransportVersion version, const QuicFrame& frame) {
660 switch (frame.type) {
661 case PING_FRAME:
662 // Ping has no payload.
663 return kQuicFrameTypeSize;
664 case RST_STREAM_FRAME:
665 return GetRstStreamFrameSize(version, *frame.rst_stream_frame);
666 case CONNECTION_CLOSE_FRAME:
667 return GetConnectionCloseFrameSize(version,
668 *frame.connection_close_frame);
669 case GOAWAY_FRAME:
670 return GetMinGoAwayFrameSize() +
671 TruncatedErrorStringSize(frame.goaway_frame->reason_phrase);
672 case WINDOW_UPDATE_FRAME:
673 // For IETF QUIC, this could be either a MAX DATA or MAX STREAM DATA.
674 // GetWindowUpdateFrameSize figures this out and returns the correct
675 // length.
676 return GetWindowUpdateFrameSize(version, frame.window_update_frame);
677 case BLOCKED_FRAME:
678 return GetBlockedFrameSize(version, frame.blocked_frame);
679 case NEW_CONNECTION_ID_FRAME:
680 return GetNewConnectionIdFrameSize(*frame.new_connection_id_frame);
681 case RETIRE_CONNECTION_ID_FRAME:
682 return GetRetireConnectionIdFrameSize(*frame.retire_connection_id_frame);
683 case NEW_TOKEN_FRAME:
684 return GetNewTokenFrameSize(*frame.new_token_frame);
685 case MAX_STREAMS_FRAME:
686 return GetMaxStreamsFrameSize(version, frame.max_streams_frame);
687 case STREAMS_BLOCKED_FRAME:
688 return GetStreamsBlockedFrameSize(version, frame.streams_blocked_frame);
689 case PATH_RESPONSE_FRAME:
wubd0152ca2022-04-08 08:26:44 -0700690 return GetPathResponseFrameSize(frame.path_response_frame);
Bence Békybac04052022-04-07 15:44:29 -0400691 case PATH_CHALLENGE_FRAME:
wubd0152ca2022-04-08 08:26:44 -0700692 return GetPathChallengeFrameSize(frame.path_challenge_frame);
Bence Békybac04052022-04-07 15:44:29 -0400693 case STOP_SENDING_FRAME:
694 return GetStopSendingFrameSize(frame.stop_sending_frame);
695 case HANDSHAKE_DONE_FRAME:
696 // HANDSHAKE_DONE has no payload.
697 return kQuicFrameTypeSize;
698 case ACK_FREQUENCY_FRAME:
699 return GetAckFrequencyFrameSize(*frame.ack_frequency_frame);
700 case STREAM_FRAME:
701 case ACK_FRAME:
702 case STOP_WAITING_FRAME:
703 case MTU_DISCOVERY_FRAME:
704 case PADDING_FRAME:
705 case MESSAGE_FRAME:
706 case CRYPTO_FRAME:
707 case NUM_FRAME_TYPES:
708 QUICHE_DCHECK(false);
709 return 0;
710 }
711
712 // Not reachable, but some Chrome compilers can't figure that out. *sigh*
713 QUICHE_DCHECK(false);
714 return 0;
715}
716
717// static
718size_t QuicFramer::GetStreamIdSize(QuicStreamId stream_id) {
719 // Sizes are 1 through 4 bytes.
720 for (int i = 1; i <= 4; ++i) {
721 stream_id >>= 8;
722 if (stream_id == 0) {
723 return i;
724 }
725 }
726 QUIC_BUG(quic_bug_10850_11) << "Failed to determine StreamIDSize.";
727 return 4;
728}
729
730// static
731size_t QuicFramer::GetStreamOffsetSize(QuicStreamOffset offset) {
732 // 0 is a special case.
733 if (offset == 0) {
734 return 0;
735 }
736 // 2 through 8 are the remaining sizes.
737 offset >>= 8;
738 for (int i = 2; i <= 8; ++i) {
739 offset >>= 8;
740 if (offset == 0) {
741 return i;
742 }
743 }
744 QUIC_BUG(quic_bug_10850_12) << "Failed to determine StreamOffsetSize.";
745 return 8;
746}
747
748// static
749size_t QuicFramer::GetNewConnectionIdFrameSize(
750 const QuicNewConnectionIdFrame& frame) {
751 return kQuicFrameTypeSize +
752 QuicDataWriter::GetVarInt62Len(frame.sequence_number) +
753 QuicDataWriter::GetVarInt62Len(frame.retire_prior_to) +
754 kConnectionIdLengthSize + frame.connection_id.length() +
755 sizeof(frame.stateless_reset_token);
756}
757
758// static
759size_t QuicFramer::GetRetireConnectionIdFrameSize(
760 const QuicRetireConnectionIdFrame& frame) {
761 return kQuicFrameTypeSize +
762 QuicDataWriter::GetVarInt62Len(frame.sequence_number);
763}
764
765// static
766size_t QuicFramer::GetNewTokenFrameSize(const QuicNewTokenFrame& frame) {
767 return kQuicFrameTypeSize +
768 QuicDataWriter::GetVarInt62Len(frame.token.length()) +
769 frame.token.length();
770}
771
772// TODO(nharper): Change this method to take a ParsedQuicVersion.
773bool QuicFramer::IsSupportedTransportVersion(
774 const QuicTransportVersion version) const {
775 for (const ParsedQuicVersion& supported_version : supported_versions_) {
776 if (version == supported_version.transport_version) {
777 return true;
778 }
779 }
780 return false;
781}
782
783bool QuicFramer::IsSupportedVersion(const ParsedQuicVersion version) const {
784 for (const ParsedQuicVersion& supported_version : supported_versions_) {
785 if (version == supported_version) {
786 return true;
787 }
788 }
789 return false;
790}
791
792size_t QuicFramer::GetSerializedFrameLength(
793 const QuicFrame& frame, size_t free_bytes, bool first_frame,
794 bool last_frame, QuicPacketNumberLength packet_number_length) {
795 // Prevent a rare crash reported in b/19458523.
796 if (frame.type == ACK_FRAME && frame.ack_frame == nullptr) {
797 QUIC_BUG(quic_bug_10850_13)
798 << "Cannot compute the length of a null ack frame. free_bytes:"
799 << free_bytes << " first_frame:" << first_frame
800 << " last_frame:" << last_frame
801 << " seq num length:" << packet_number_length;
802 set_error(QUIC_INTERNAL_ERROR);
803 visitor_->OnError(this);
804 return 0;
805 }
806 if (frame.type == PADDING_FRAME) {
807 if (frame.padding_frame.num_padding_bytes == -1) {
808 // Full padding to the end of the packet.
809 return free_bytes;
810 } else {
811 // Lite padding.
812 return free_bytes <
813 static_cast<size_t>(frame.padding_frame.num_padding_bytes)
814 ? free_bytes
815 : frame.padding_frame.num_padding_bytes;
816 }
817 }
818
819 size_t frame_len =
820 ComputeFrameLength(frame, last_frame, packet_number_length);
821 if (frame_len <= free_bytes) {
822 // Frame fits within packet. Note that acks may be truncated.
823 return frame_len;
824 }
825 // Only truncate the first frame in a packet, so if subsequent ones go
826 // over, stop including more frames.
827 if (!first_frame) {
828 return 0;
829 }
830 bool can_truncate =
831 frame.type == ACK_FRAME &&
832 free_bytes >=
833 GetMinAckFrameSize(version_.transport_version, *frame.ack_frame,
834 local_ack_delay_exponent_,
835 UseIetfAckWithReceiveTimestamp(*frame.ack_frame));
836 if (can_truncate) {
837 // Truncate the frame so the packet will not exceed kMaxOutgoingPacketSize.
838 // Note that we may not use every byte of the writer in this case.
839 QUIC_DLOG(INFO) << ENDPOINT
840 << "Truncating large frame, free bytes: " << free_bytes;
841 return free_bytes;
842 }
843 return 0;
844}
845
846QuicFramer::AckFrameInfo::AckFrameInfo()
847 : max_block_length(0), first_block_length(0), num_ack_blocks(0) {}
848
849QuicFramer::AckFrameInfo::AckFrameInfo(const AckFrameInfo& other) = default;
850
851QuicFramer::AckFrameInfo::~AckFrameInfo() {}
852
853bool QuicFramer::WriteIetfLongHeaderLength(const QuicPacketHeader& header,
854 QuicDataWriter* writer,
855 size_t length_field_offset,
856 EncryptionLevel level) {
857 if (!QuicVersionHasLongHeaderLengths(transport_version()) ||
858 !header.version_flag || length_field_offset == 0) {
859 return true;
860 }
861 if (writer->length() < length_field_offset ||
862 writer->length() - length_field_offset <
863 kQuicDefaultLongHeaderLengthLength) {
864 set_detailed_error("Invalid length_field_offset.");
865 QUIC_BUG(quic_bug_10850_14) << "Invalid length_field_offset.";
866 return false;
867 }
868 size_t length_to_write = writer->length() - length_field_offset -
869 kQuicDefaultLongHeaderLengthLength;
870 // Add length of auth tag.
871 length_to_write = GetCiphertextSize(level, length_to_write);
872
873 QuicDataWriter length_writer(writer->length() - length_field_offset,
874 writer->data() + length_field_offset);
875 if (!length_writer.WriteVarInt62(length_to_write,
876 kQuicDefaultLongHeaderLengthLength)) {
877 set_detailed_error("Failed to overwrite long header length.");
878 QUIC_BUG(quic_bug_10850_15) << "Failed to overwrite long header length.";
879 return false;
880 }
881 return true;
882}
883
884size_t QuicFramer::BuildDataPacket(const QuicPacketHeader& header,
885 const QuicFrames& frames, char* buffer,
886 size_t packet_length,
887 EncryptionLevel level) {
888 QUIC_BUG_IF(quic_bug_12975_2,
889 header.version_flag && version().HasIetfInvariantHeader() &&
890 header.long_packet_type == RETRY && !frames.empty())
891 << "IETF RETRY packets cannot contain frames " << header;
892 QuicDataWriter writer(packet_length, buffer);
893 size_t length_field_offset = 0;
894 if (!AppendPacketHeader(header, &writer, &length_field_offset)) {
895 QUIC_BUG(quic_bug_10850_16) << "AppendPacketHeader failed";
896 return 0;
897 }
898
899 if (VersionHasIetfQuicFrames(transport_version())) {
900 if (AppendIetfFrames(frames, &writer) == 0) {
901 return 0;
902 }
903 if (!WriteIetfLongHeaderLength(header, &writer, length_field_offset,
904 level)) {
905 return 0;
906 }
907 return writer.length();
908 }
909
910 size_t i = 0;
911 for (const QuicFrame& frame : frames) {
912 // Determine if we should write stream frame length in header.
913 const bool last_frame_in_packet = i == frames.size() - 1;
914 if (!AppendTypeByte(frame, last_frame_in_packet, &writer)) {
915 QUIC_BUG(quic_bug_10850_17) << "AppendTypeByte failed";
916 return 0;
917 }
918
919 switch (frame.type) {
920 case PADDING_FRAME:
921 if (!AppendPaddingFrame(frame.padding_frame, &writer)) {
922 QUIC_BUG(quic_bug_10850_18)
923 << "AppendPaddingFrame of "
924 << frame.padding_frame.num_padding_bytes << " failed";
925 return 0;
926 }
927 break;
928 case STREAM_FRAME:
929 if (!AppendStreamFrame(frame.stream_frame, last_frame_in_packet,
930 &writer)) {
931 QUIC_BUG(quic_bug_10850_19) << "AppendStreamFrame failed";
932 return 0;
933 }
934 break;
935 case ACK_FRAME:
936 if (!AppendAckFrameAndTypeByte(*frame.ack_frame, &writer)) {
937 QUIC_BUG(quic_bug_10850_20)
938 << "AppendAckFrameAndTypeByte failed: " << detailed_error_;
939 return 0;
940 }
941 break;
942 case STOP_WAITING_FRAME:
943 if (!AppendStopWaitingFrame(header, frame.stop_waiting_frame,
944 &writer)) {
945 QUIC_BUG(quic_bug_10850_21) << "AppendStopWaitingFrame failed";
946 return 0;
947 }
948 break;
949 case MTU_DISCOVERY_FRAME:
950 // MTU discovery frames are serialized as ping frames.
951 ABSL_FALLTHROUGH_INTENDED;
952 case PING_FRAME:
953 // Ping has no payload.
954 break;
955 case RST_STREAM_FRAME:
956 if (!AppendRstStreamFrame(*frame.rst_stream_frame, &writer)) {
957 QUIC_BUG(quic_bug_10850_22) << "AppendRstStreamFrame failed";
958 return 0;
959 }
960 break;
961 case CONNECTION_CLOSE_FRAME:
962 if (!AppendConnectionCloseFrame(*frame.connection_close_frame,
963 &writer)) {
964 QUIC_BUG(quic_bug_10850_23) << "AppendConnectionCloseFrame failed";
965 return 0;
966 }
967 break;
968 case GOAWAY_FRAME:
969 if (!AppendGoAwayFrame(*frame.goaway_frame, &writer)) {
970 QUIC_BUG(quic_bug_10850_24) << "AppendGoAwayFrame failed";
971 return 0;
972 }
973 break;
974 case WINDOW_UPDATE_FRAME:
975 if (!AppendWindowUpdateFrame(frame.window_update_frame, &writer)) {
976 QUIC_BUG(quic_bug_10850_25) << "AppendWindowUpdateFrame failed";
977 return 0;
978 }
979 break;
980 case BLOCKED_FRAME:
981 if (!AppendBlockedFrame(frame.blocked_frame, &writer)) {
982 QUIC_BUG(quic_bug_10850_26) << "AppendBlockedFrame failed";
983 return 0;
984 }
985 break;
986 case NEW_CONNECTION_ID_FRAME:
987 set_detailed_error(
988 "Attempt to append NEW_CONNECTION_ID frame and not in IETF QUIC.");
989 return RaiseError(QUIC_INTERNAL_ERROR);
990 case RETIRE_CONNECTION_ID_FRAME:
991 set_detailed_error(
992 "Attempt to append RETIRE_CONNECTION_ID frame and not in IETF "
993 "QUIC.");
994 return RaiseError(QUIC_INTERNAL_ERROR);
995 case NEW_TOKEN_FRAME:
996 set_detailed_error(
997 "Attempt to append NEW_TOKEN_ID frame and not in IETF QUIC.");
998 return RaiseError(QUIC_INTERNAL_ERROR);
999 case MAX_STREAMS_FRAME:
1000 set_detailed_error(
1001 "Attempt to append MAX_STREAMS frame and not in IETF QUIC.");
1002 return RaiseError(QUIC_INTERNAL_ERROR);
1003 case STREAMS_BLOCKED_FRAME:
1004 set_detailed_error(
1005 "Attempt to append STREAMS_BLOCKED frame and not in IETF QUIC.");
1006 return RaiseError(QUIC_INTERNAL_ERROR);
1007 case PATH_RESPONSE_FRAME:
1008 set_detailed_error(
1009 "Attempt to append PATH_RESPONSE frame and not in IETF QUIC.");
1010 return RaiseError(QUIC_INTERNAL_ERROR);
1011 case PATH_CHALLENGE_FRAME:
1012 set_detailed_error(
1013 "Attempt to append PATH_CHALLENGE frame and not in IETF QUIC.");
1014 return RaiseError(QUIC_INTERNAL_ERROR);
1015 case STOP_SENDING_FRAME:
1016 set_detailed_error(
1017 "Attempt to append STOP_SENDING frame and not in IETF QUIC.");
1018 return RaiseError(QUIC_INTERNAL_ERROR);
1019 case MESSAGE_FRAME:
1020 if (!AppendMessageFrameAndTypeByte(*frame.message_frame,
1021 last_frame_in_packet, &writer)) {
1022 QUIC_BUG(quic_bug_10850_27) << "AppendMessageFrame failed";
1023 return 0;
1024 }
1025 break;
1026 case CRYPTO_FRAME:
1027 if (!QuicVersionUsesCryptoFrames(version_.transport_version)) {
1028 set_detailed_error(
1029 "Attempt to append CRYPTO frame in version prior to 47.");
1030 return RaiseError(QUIC_INTERNAL_ERROR);
1031 }
1032 if (!AppendCryptoFrame(*frame.crypto_frame, &writer)) {
1033 QUIC_BUG(quic_bug_10850_28) << "AppendCryptoFrame failed";
1034 return 0;
1035 }
1036 break;
1037 case HANDSHAKE_DONE_FRAME:
1038 // HANDSHAKE_DONE has no payload.
1039 break;
1040 default:
1041 RaiseError(QUIC_INVALID_FRAME_DATA);
1042 QUIC_BUG(quic_bug_10850_29) << "QUIC_INVALID_FRAME_DATA";
1043 return 0;
1044 }
1045 ++i;
1046 }
1047
1048 if (!WriteIetfLongHeaderLength(header, &writer, length_field_offset, level)) {
1049 return 0;
1050 }
1051
1052 return writer.length();
1053}
1054
1055size_t QuicFramer::AppendIetfFrames(const QuicFrames& frames,
1056 QuicDataWriter* writer) {
1057 size_t i = 0;
1058 for (const QuicFrame& frame : frames) {
1059 // Determine if we should write stream frame length in header.
1060 const bool last_frame_in_packet = i == frames.size() - 1;
1061 if (!AppendIetfFrameType(frame, last_frame_in_packet, writer)) {
1062 QUIC_BUG(quic_bug_10850_30)
1063 << "AppendIetfFrameType failed: " << detailed_error();
1064 return 0;
1065 }
1066
1067 switch (frame.type) {
1068 case PADDING_FRAME:
1069 if (!AppendPaddingFrame(frame.padding_frame, writer)) {
1070 QUIC_BUG(quic_bug_10850_31) << "AppendPaddingFrame of "
1071 << frame.padding_frame.num_padding_bytes
1072 << " failed: " << detailed_error();
1073 return 0;
1074 }
1075 break;
1076 case STREAM_FRAME:
1077 if (!AppendStreamFrame(frame.stream_frame, last_frame_in_packet,
1078 writer)) {
1079 QUIC_BUG(quic_bug_10850_32)
1080 << "AppendStreamFrame " << frame.stream_frame
1081 << " failed: " << detailed_error();
1082 return 0;
1083 }
1084 break;
1085 case ACK_FRAME:
1086 if (!AppendIetfAckFrameAndTypeByte(*frame.ack_frame, writer)) {
1087 QUIC_BUG(quic_bug_10850_33)
1088 << "AppendIetfAckFrameAndTypeByte failed: " << detailed_error();
1089 return 0;
1090 }
1091 break;
1092 case STOP_WAITING_FRAME:
1093 set_detailed_error(
1094 "Attempt to append STOP WAITING frame in IETF QUIC.");
1095 RaiseError(QUIC_INTERNAL_ERROR);
1096 QUIC_BUG(quic_bug_10850_34) << detailed_error();
1097 return 0;
1098 case MTU_DISCOVERY_FRAME:
1099 // MTU discovery frames are serialized as ping frames.
1100 ABSL_FALLTHROUGH_INTENDED;
1101 case PING_FRAME:
1102 // Ping has no payload.
1103 break;
1104 case RST_STREAM_FRAME:
1105 if (!AppendRstStreamFrame(*frame.rst_stream_frame, writer)) {
1106 QUIC_BUG(quic_bug_10850_35)
1107 << "AppendRstStreamFrame failed: " << detailed_error();
1108 return 0;
1109 }
1110 break;
1111 case CONNECTION_CLOSE_FRAME:
1112 if (!AppendIetfConnectionCloseFrame(*frame.connection_close_frame,
1113 writer)) {
1114 QUIC_BUG(quic_bug_10850_36)
1115 << "AppendIetfConnectionCloseFrame failed: " << detailed_error();
1116 return 0;
1117 }
1118 break;
1119 case GOAWAY_FRAME:
1120 set_detailed_error("Attempt to append GOAWAY frame in IETF QUIC.");
1121 RaiseError(QUIC_INTERNAL_ERROR);
1122 QUIC_BUG(quic_bug_10850_37) << detailed_error();
1123 return 0;
1124 case WINDOW_UPDATE_FRAME:
1125 // Depending on whether there is a stream ID or not, will be either a
1126 // MAX STREAM DATA frame or a MAX DATA frame.
1127 if (frame.window_update_frame.stream_id ==
1128 QuicUtils::GetInvalidStreamId(transport_version())) {
1129 if (!AppendMaxDataFrame(frame.window_update_frame, writer)) {
1130 QUIC_BUG(quic_bug_10850_38)
1131 << "AppendMaxDataFrame failed: " << detailed_error();
1132 return 0;
1133 }
1134 } else {
1135 if (!AppendMaxStreamDataFrame(frame.window_update_frame, writer)) {
1136 QUIC_BUG(quic_bug_10850_39)
1137 << "AppendMaxStreamDataFrame failed: " << detailed_error();
1138 return 0;
1139 }
1140 }
1141 break;
1142 case BLOCKED_FRAME:
1143 if (!AppendBlockedFrame(frame.blocked_frame, writer)) {
1144 QUIC_BUG(quic_bug_10850_40)
1145 << "AppendBlockedFrame failed: " << detailed_error();
1146 return 0;
1147 }
1148 break;
1149 case MAX_STREAMS_FRAME:
1150 if (!AppendMaxStreamsFrame(frame.max_streams_frame, writer)) {
1151 QUIC_BUG(quic_bug_10850_41)
1152 << "AppendMaxStreamsFrame failed: " << detailed_error();
1153 return 0;
1154 }
1155 break;
1156 case STREAMS_BLOCKED_FRAME:
1157 if (!AppendStreamsBlockedFrame(frame.streams_blocked_frame, writer)) {
1158 QUIC_BUG(quic_bug_10850_42)
1159 << "AppendStreamsBlockedFrame failed: " << detailed_error();
1160 return 0;
1161 }
1162 break;
1163 case NEW_CONNECTION_ID_FRAME:
1164 if (!AppendNewConnectionIdFrame(*frame.new_connection_id_frame,
1165 writer)) {
1166 QUIC_BUG(quic_bug_10850_43)
1167 << "AppendNewConnectionIdFrame failed: " << detailed_error();
1168 return 0;
1169 }
1170 break;
1171 case RETIRE_CONNECTION_ID_FRAME:
1172 if (!AppendRetireConnectionIdFrame(*frame.retire_connection_id_frame,
1173 writer)) {
1174 QUIC_BUG(quic_bug_10850_44)
1175 << "AppendRetireConnectionIdFrame failed: " << detailed_error();
1176 return 0;
1177 }
1178 break;
1179 case NEW_TOKEN_FRAME:
1180 if (!AppendNewTokenFrame(*frame.new_token_frame, writer)) {
1181 QUIC_BUG(quic_bug_10850_45)
1182 << "AppendNewTokenFrame failed: " << detailed_error();
1183 return 0;
1184 }
1185 break;
1186 case STOP_SENDING_FRAME:
1187 if (!AppendStopSendingFrame(frame.stop_sending_frame, writer)) {
1188 QUIC_BUG(quic_bug_10850_46)
1189 << "AppendStopSendingFrame failed: " << detailed_error();
1190 return 0;
1191 }
1192 break;
1193 case PATH_CHALLENGE_FRAME:
wubd0152ca2022-04-08 08:26:44 -07001194 if (!AppendPathChallengeFrame(frame.path_challenge_frame, writer)) {
Bence Békybac04052022-04-07 15:44:29 -04001195 QUIC_BUG(quic_bug_10850_47)
1196 << "AppendPathChallengeFrame failed: " << detailed_error();
1197 return 0;
1198 }
1199 break;
1200 case PATH_RESPONSE_FRAME:
wubd0152ca2022-04-08 08:26:44 -07001201 if (!AppendPathResponseFrame(frame.path_response_frame, writer)) {
Bence Békybac04052022-04-07 15:44:29 -04001202 QUIC_BUG(quic_bug_10850_48)
1203 << "AppendPathResponseFrame failed: " << detailed_error();
1204 return 0;
1205 }
1206 break;
1207 case MESSAGE_FRAME:
1208 if (!AppendMessageFrameAndTypeByte(*frame.message_frame,
1209 last_frame_in_packet, writer)) {
1210 QUIC_BUG(quic_bug_10850_49)
1211 << "AppendMessageFrame failed: " << detailed_error();
1212 return 0;
1213 }
1214 break;
1215 case CRYPTO_FRAME:
1216 if (!AppendCryptoFrame(*frame.crypto_frame, writer)) {
1217 QUIC_BUG(quic_bug_10850_50)
1218 << "AppendCryptoFrame failed: " << detailed_error();
1219 return 0;
1220 }
1221 break;
1222 case HANDSHAKE_DONE_FRAME:
1223 // HANDSHAKE_DONE has no payload.
1224 break;
1225 case ACK_FREQUENCY_FRAME:
1226 if (!AppendAckFrequencyFrame(*frame.ack_frequency_frame, writer)) {
1227 QUIC_BUG(quic_bug_10850_51)
1228 << "AppendAckFrequencyFrame failed: " << detailed_error();
1229 return 0;
1230 }
1231 break;
1232 default:
1233 set_detailed_error("Tried to append unknown frame type.");
1234 RaiseError(QUIC_INVALID_FRAME_DATA);
1235 QUIC_BUG(quic_bug_10850_52)
1236 << "QUIC_INVALID_FRAME_DATA: " << frame.type;
1237 return 0;
1238 }
1239 ++i;
1240 }
1241
1242 return writer->length();
1243}
1244
1245// static
1246std::unique_ptr<QuicEncryptedPacket> QuicFramer::BuildPublicResetPacket(
1247 const QuicPublicResetPacket& packet) {
1248 CryptoHandshakeMessage reset;
1249 reset.set_tag(kPRST);
1250 reset.SetValue(kRNON, packet.nonce_proof);
1251 if (packet.client_address.host().address_family() !=
1252 IpAddressFamily::IP_UNSPEC) {
1253 // packet.client_address is non-empty.
1254 QuicSocketAddressCoder address_coder(packet.client_address);
1255 std::string serialized_address = address_coder.Encode();
1256 if (serialized_address.empty()) {
1257 return nullptr;
1258 }
1259 reset.SetStringPiece(kCADR, serialized_address);
1260 }
1261 if (!packet.endpoint_id.empty()) {
1262 reset.SetStringPiece(kEPID, packet.endpoint_id);
1263 }
1264 const QuicData& reset_serialized = reset.GetSerialized();
1265
1266 size_t len = kPublicFlagsSize + packet.connection_id.length() +
1267 reset_serialized.length();
1268 std::unique_ptr<char[]> buffer(new char[len]);
1269 QuicDataWriter writer(len, buffer.get());
1270
1271 uint8_t flags = static_cast<uint8_t>(PACKET_PUBLIC_FLAGS_RST |
1272 PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID);
1273 // This hack makes post-v33 public reset packet look like pre-v33 packets.
1274 flags |= static_cast<uint8_t>(PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID_OLD);
1275 if (!writer.WriteUInt8(flags)) {
1276 return nullptr;
1277 }
1278
1279 if (!writer.WriteConnectionId(packet.connection_id)) {
1280 return nullptr;
1281 }
1282
1283 if (!writer.WriteBytes(reset_serialized.data(), reset_serialized.length())) {
1284 return nullptr;
1285 }
1286
1287 return std::make_unique<QuicEncryptedPacket>(buffer.release(), len, true);
1288}
1289
1290// static
1291size_t QuicFramer::GetMinStatelessResetPacketLength() {
1292 // 5 bytes (40 bits) = 2 Fixed Bits (01) + 38 Unpredictable bits
1293 return 5 + kStatelessResetTokenLength;
1294}
1295
1296// static
1297std::unique_ptr<QuicEncryptedPacket> QuicFramer::BuildIetfStatelessResetPacket(
1298 QuicConnectionId /*connection_id*/, size_t received_packet_length,
1299 StatelessResetToken stateless_reset_token) {
1300 QUIC_DVLOG(1) << "Building IETF stateless reset packet.";
1301 if (received_packet_length <= GetMinStatelessResetPacketLength()) {
1302 QUICHE_DLOG(ERROR)
1303 << "Tried to build stateless reset packet with received packet "
1304 "length "
1305 << received_packet_length;
1306 return nullptr;
1307 }
1308 // To ensure stateless reset is indistinguishable from a valid packet,
1309 // include the max connection ID length.
1310 size_t len = std::min(received_packet_length - 1,
1311 GetMinStatelessResetPacketLength() + 1 +
1312 kQuicMaxConnectionIdWithLengthPrefixLength);
1313 std::unique_ptr<char[]> buffer(new char[len]);
1314 QuicDataWriter writer(len, buffer.get());
1315 // Append random bytes. This randomness only exists to prevent middleboxes
1316 // from comparing the entire packet to a known value. Therefore it has no
1317 // cryptographic use, and does not need a secure cryptographic pseudo-random
1318 // number generator. It's therefore safe to use WriteInsecureRandomBytes.
1319 if (!writer.WriteInsecureRandomBytes(QuicRandom::GetInstance(),
1320 len - kStatelessResetTokenLength)) {
1321 QUIC_BUG(362045737_2) << "Failed to append random bytes of length: "
1322 << len - kStatelessResetTokenLength;
1323 return nullptr;
1324 }
1325 // Change first 2 fixed bits to 01.
1326 buffer[0] &= ~FLAGS_LONG_HEADER;
1327 buffer[0] |= FLAGS_FIXED_BIT;
1328
1329 // Append stateless reset token.
1330 if (!writer.WriteBytes(&stateless_reset_token,
1331 sizeof(stateless_reset_token))) {
1332 QUIC_BUG(362045737_3) << "Failed to write stateless reset token";
1333 return nullptr;
1334 }
1335 return std::make_unique<QuicEncryptedPacket>(buffer.release(), len,
1336 /*owns_buffer=*/true);
1337}
1338
1339// static
1340std::unique_ptr<QuicEncryptedPacket> QuicFramer::BuildVersionNegotiationPacket(
1341 QuicConnectionId server_connection_id,
1342 QuicConnectionId client_connection_id, bool ietf_quic,
1343 bool use_length_prefix, const ParsedQuicVersionVector& versions) {
1344 QUIC_CODE_COUNT(quic_build_version_negotiation);
1345 if (use_length_prefix) {
1346 QUICHE_DCHECK(ietf_quic);
1347 QUIC_CODE_COUNT(quic_build_version_negotiation_ietf);
1348 } else if (ietf_quic) {
1349 QUIC_CODE_COUNT(quic_build_version_negotiation_old_ietf);
1350 } else {
1351 QUIC_CODE_COUNT(quic_build_version_negotiation_old_gquic);
1352 }
1353 ParsedQuicVersionVector wire_versions = versions;
1354 // Add a version reserved for negotiation as suggested by the
1355 // "Using Reserved Versions" section of draft-ietf-quic-transport.
1356 if (wire_versions.empty()) {
1357 // Ensure that version negotiation packets we send have at least two
1358 // versions. This guarantees that, under all circumstances, all QUIC
1359 // packets we send are at least 14 bytes long.
1360 wire_versions = {QuicVersionReservedForNegotiation(),
1361 QuicVersionReservedForNegotiation()};
1362 } else {
1363 // This is not uniformely distributed but is acceptable since no security
1364 // depends on this randomness.
1365 size_t version_index = 0;
1366 const bool disable_randomness =
1367 GetQuicFlag(FLAGS_quic_disable_version_negotiation_grease_randomness);
1368 if (!disable_randomness) {
1369 version_index =
1370 QuicRandom::GetInstance()->RandUint64() % (wire_versions.size() + 1);
1371 }
1372 wire_versions.insert(wire_versions.begin() + version_index,
1373 QuicVersionReservedForNegotiation());
1374 }
1375 if (ietf_quic) {
1376 return BuildIetfVersionNegotiationPacket(
1377 use_length_prefix, server_connection_id, client_connection_id,
1378 wire_versions);
1379 }
1380
1381 // The GQUIC encoding does not support encoding client connection IDs.
1382 QUICHE_DCHECK(client_connection_id.IsEmpty());
1383 // The GQUIC encoding does not support length-prefixed connection IDs.
1384 QUICHE_DCHECK(!use_length_prefix);
1385
1386 QUICHE_DCHECK(!wire_versions.empty());
1387 size_t len = kPublicFlagsSize + server_connection_id.length() +
1388 wire_versions.size() * kQuicVersionSize;
1389 std::unique_ptr<char[]> buffer(new char[len]);
1390 QuicDataWriter writer(len, buffer.get());
1391
1392 uint8_t flags = static_cast<uint8_t>(
1393 PACKET_PUBLIC_FLAGS_VERSION | PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID |
1394 PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID_OLD);
1395 if (!writer.WriteUInt8(flags)) {
1396 return nullptr;
1397 }
1398
1399 if (!writer.WriteConnectionId(server_connection_id)) {
1400 return nullptr;
1401 }
1402
1403 for (const ParsedQuicVersion& version : wire_versions) {
1404 if (!writer.WriteUInt32(CreateQuicVersionLabel(version))) {
1405 return nullptr;
1406 }
1407 }
1408
1409 return std::make_unique<QuicEncryptedPacket>(buffer.release(), len, true);
1410}
1411
1412// static
1413std::unique_ptr<QuicEncryptedPacket>
1414QuicFramer::BuildIetfVersionNegotiationPacket(
1415 bool use_length_prefix, QuicConnectionId server_connection_id,
1416 QuicConnectionId client_connection_id,
1417 const ParsedQuicVersionVector& versions) {
1418 QUIC_DVLOG(1) << "Building IETF version negotiation packet with"
1419 << (use_length_prefix ? "" : "out")
1420 << " length prefix, server_connection_id "
1421 << server_connection_id << " client_connection_id "
1422 << client_connection_id << " versions "
1423 << ParsedQuicVersionVectorToString(versions);
1424 QUICHE_DCHECK(!versions.empty());
1425 size_t len = kPacketHeaderTypeSize + kConnectionIdLengthSize +
1426 client_connection_id.length() + server_connection_id.length() +
1427 (versions.size() + 1) * kQuicVersionSize;
1428 if (use_length_prefix) {
1429 // When using length-prefixed connection IDs, packets carry two lengths
1430 // instead of one.
1431 len += kConnectionIdLengthSize;
1432 }
1433 std::unique_ptr<char[]> buffer(new char[len]);
1434 QuicDataWriter writer(len, buffer.get());
1435
1436 // TODO(fayang): Randomly select a value for the type.
1437 uint8_t type = static_cast<uint8_t>(FLAGS_LONG_HEADER | FLAGS_FIXED_BIT);
1438 if (!writer.WriteUInt8(type)) {
1439 return nullptr;
1440 }
1441
1442 if (!writer.WriteUInt32(0)) {
1443 return nullptr;
1444 }
1445
1446 if (!AppendIetfConnectionIds(true, use_length_prefix, client_connection_id,
1447 server_connection_id, &writer)) {
1448 return nullptr;
1449 }
1450
1451 for (const ParsedQuicVersion& version : versions) {
1452 if (!writer.WriteUInt32(CreateQuicVersionLabel(version))) {
1453 return nullptr;
1454 }
1455 }
1456
1457 return std::make_unique<QuicEncryptedPacket>(buffer.release(), len, true);
1458}
1459
1460bool QuicFramer::ProcessPacket(const QuicEncryptedPacket& packet) {
1461 QUICHE_DCHECK(!is_processing_packet_) << ENDPOINT << "Nested ProcessPacket";
1462 is_processing_packet_ = true;
1463 bool result = ProcessPacketInternal(packet);
1464 is_processing_packet_ = false;
1465 return result;
1466}
1467
1468bool QuicFramer::ProcessPacketInternal(const QuicEncryptedPacket& packet) {
1469 QuicDataReader reader(packet.data(), packet.length());
1470
1471 bool packet_has_ietf_packet_header = false;
1472 if (infer_packet_header_type_from_version_) {
1473 packet_has_ietf_packet_header = version_.HasIetfInvariantHeader();
1474 } else if (!reader.IsDoneReading()) {
1475 uint8_t type = reader.PeekByte();
1476 packet_has_ietf_packet_header = QuicUtils::IsIetfPacketHeader(type);
1477 }
1478 if (packet_has_ietf_packet_header) {
1479 QUIC_DVLOG(1) << ENDPOINT << "Processing IETF QUIC packet.";
1480 }
1481
1482 visitor_->OnPacket();
1483
1484 QuicPacketHeader header;
1485 if (!ProcessPublicHeader(&reader, packet_has_ietf_packet_header, &header)) {
1486 QUICHE_DCHECK_NE("", detailed_error_);
1487 QUIC_DVLOG(1) << ENDPOINT << "Unable to process public header. Error: "
1488 << detailed_error_;
1489 QUICHE_DCHECK_NE("", detailed_error_);
1490 RecordDroppedPacketReason(DroppedPacketReason::INVALID_PUBLIC_HEADER);
1491 return RaiseError(QUIC_INVALID_PACKET_HEADER);
1492 }
1493
1494 if (!visitor_->OnUnauthenticatedPublicHeader(header)) {
1495 // The visitor suppresses further processing of the packet.
1496 return true;
1497 }
1498
1499 if (IsVersionNegotiation(header, packet_has_ietf_packet_header)) {
1500 if (perspective_ == Perspective::IS_CLIENT) {
1501 QUIC_DVLOG(1) << "Client received version negotiation packet";
1502 return ProcessVersionNegotiationPacket(&reader, header);
1503 } else {
1504 QUIC_DLOG(ERROR) << "Server received version negotiation packet";
1505 set_detailed_error("Server received version negotiation packet.");
1506 return RaiseError(QUIC_INVALID_VERSION_NEGOTIATION_PACKET);
1507 }
1508 }
1509
1510 if (header.version_flag && header.version != version_) {
1511 if (perspective_ == Perspective::IS_SERVER) {
1512 if (!visitor_->OnProtocolVersionMismatch(header.version)) {
1513 RecordDroppedPacketReason(DroppedPacketReason::VERSION_MISMATCH);
1514 return true;
1515 }
1516 } else {
1517 // A client received a packet of a different version but that packet is
1518 // not a version negotiation packet. It is therefore invalid and dropped.
1519 QUIC_DLOG(ERROR) << "Client received unexpected version "
1520 << ParsedQuicVersionToString(header.version)
1521 << " instead of " << ParsedQuicVersionToString(version_);
1522 set_detailed_error("Client received unexpected version.");
1523 return RaiseError(QUIC_PACKET_WRONG_VERSION);
1524 }
1525 }
1526
1527 bool rv;
1528 if (header.long_packet_type == RETRY) {
1529 rv = ProcessRetryPacket(&reader, header);
1530 } else if (header.reset_flag) {
1531 rv = ProcessPublicResetPacket(&reader, header);
1532 } else if (packet.length() <= kMaxIncomingPacketSize) {
1533 // The optimized decryption algorithm implementations run faster when
1534 // operating on aligned memory.
1535 ABSL_CACHELINE_ALIGNED char buffer[kMaxIncomingPacketSize];
1536 if (packet_has_ietf_packet_header) {
1537 rv = ProcessIetfDataPacket(&reader, &header, packet, buffer,
1538 ABSL_ARRAYSIZE(buffer));
1539 } else {
1540 rv = ProcessDataPacket(&reader, &header, packet, buffer,
1541 ABSL_ARRAYSIZE(buffer));
1542 }
1543 } else {
1544 std::unique_ptr<char[]> large_buffer(new char[packet.length()]);
1545 if (packet_has_ietf_packet_header) {
1546 rv = ProcessIetfDataPacket(&reader, &header, packet, large_buffer.get(),
1547 packet.length());
1548 } else {
1549 rv = ProcessDataPacket(&reader, &header, packet, large_buffer.get(),
1550 packet.length());
1551 }
1552 QUIC_BUG_IF(quic_bug_10850_53, rv)
1553 << "QUIC should never successfully process packets larger"
1554 << "than kMaxIncomingPacketSize. packet size:" << packet.length();
1555 }
1556 return rv;
1557}
1558
1559bool QuicFramer::ProcessVersionNegotiationPacket(
1560 QuicDataReader* reader, const QuicPacketHeader& header) {
1561 QUICHE_DCHECK_EQ(Perspective::IS_CLIENT, perspective_);
1562
1563 QuicVersionNegotiationPacket packet(
1564 GetServerConnectionIdAsRecipient(header, perspective_));
1565 // Try reading at least once to raise error if the packet is invalid.
1566 do {
1567 QuicVersionLabel version_label;
1568 if (!ProcessVersionLabel(reader, &version_label)) {
1569 set_detailed_error("Unable to read supported version in negotiation.");
1570 RecordDroppedPacketReason(
1571 DroppedPacketReason::INVALID_VERSION_NEGOTIATION_PACKET);
1572 return RaiseError(QUIC_INVALID_VERSION_NEGOTIATION_PACKET);
1573 }
1574 ParsedQuicVersion parsed_version = ParseQuicVersionLabel(version_label);
1575 if (parsed_version != UnsupportedQuicVersion()) {
1576 packet.versions.push_back(parsed_version);
1577 }
1578 } while (!reader->IsDoneReading());
1579
1580 QUIC_DLOG(INFO) << ENDPOINT << "parsed version negotiation: "
1581 << ParsedQuicVersionVectorToString(packet.versions);
1582
1583 visitor_->OnVersionNegotiationPacket(packet);
1584 return true;
1585}
1586
1587bool QuicFramer::ProcessRetryPacket(QuicDataReader* reader,
1588 const QuicPacketHeader& header) {
1589 QUICHE_DCHECK_EQ(Perspective::IS_CLIENT, perspective_);
1590 if (drop_incoming_retry_packets_) {
1591 QUIC_DLOG(INFO) << "Ignoring received RETRY packet";
1592 return true;
1593 }
1594
1595 if (version_.UsesTls()) {
1596 QUICHE_DCHECK(version_.HasLengthPrefixedConnectionIds()) << version_;
1597 const size_t bytes_remaining = reader->BytesRemaining();
1598 if (bytes_remaining <= kRetryIntegrityTagLength) {
1599 set_detailed_error("Retry packet too short to parse integrity tag.");
1600 return false;
1601 }
1602 const size_t retry_token_length =
1603 bytes_remaining - kRetryIntegrityTagLength;
1604 QUICHE_DCHECK_GT(retry_token_length, 0u);
1605 absl::string_view retry_token;
1606 if (!reader->ReadStringPiece(&retry_token, retry_token_length)) {
1607 set_detailed_error("Failed to read retry token.");
1608 return false;
1609 }
1610 absl::string_view retry_without_tag = reader->PreviouslyReadPayload();
1611 absl::string_view integrity_tag = reader->ReadRemainingPayload();
1612 QUICHE_DCHECK_EQ(integrity_tag.length(), kRetryIntegrityTagLength);
1613 visitor_->OnRetryPacket(EmptyQuicConnectionId(),
1614 header.source_connection_id, retry_token,
1615 integrity_tag, retry_without_tag);
1616 return true;
1617 }
1618
1619 QuicConnectionId original_destination_connection_id;
1620 if (version_.HasLengthPrefixedConnectionIds()) {
1621 // Parse Original Destination Connection ID.
1622 if (!reader->ReadLengthPrefixedConnectionId(
1623 &original_destination_connection_id)) {
1624 set_detailed_error("Unable to read Original Destination ConnectionId.");
1625 return false;
1626 }
1627 } else {
1628 // Parse Original Destination Connection ID Length.
1629 uint8_t odcil = header.type_byte & 0xf;
1630 if (odcil != 0) {
1631 odcil += kConnectionIdLengthAdjustment;
1632 }
1633
1634 // Parse Original Destination Connection ID.
1635 if (!reader->ReadConnectionId(&original_destination_connection_id, odcil)) {
1636 set_detailed_error("Unable to read Original Destination ConnectionId.");
1637 return false;
1638 }
1639 }
1640
1641 if (!QuicUtils::IsConnectionIdValidForVersion(
1642 original_destination_connection_id, transport_version())) {
1643 set_detailed_error(
1644 "Received Original Destination ConnectionId with invalid length.");
1645 return false;
1646 }
1647
1648 absl::string_view retry_token = reader->ReadRemainingPayload();
1649 visitor_->OnRetryPacket(original_destination_connection_id,
1650 header.source_connection_id, retry_token,
1651 /*retry_integrity_tag=*/absl::string_view(),
1652 /*retry_without_tag=*/absl::string_view());
1653 return true;
1654}
1655
1656// Seeks the current packet to check for a coalesced packet at the end.
1657// If the IETF length field only spans part of the outer packet,
1658// then there is a coalesced packet after this one.
1659void QuicFramer::MaybeProcessCoalescedPacket(
1660 const QuicDataReader& encrypted_reader, uint64_t remaining_bytes_length,
1661 const QuicPacketHeader& header) {
1662 if (header.remaining_packet_length >= remaining_bytes_length) {
1663 // There is no coalesced packet.
1664 return;
1665 }
1666
1667 absl::string_view remaining_data = encrypted_reader.PeekRemainingPayload();
1668 QUICHE_DCHECK_EQ(remaining_data.length(), remaining_bytes_length);
1669
1670 const char* coalesced_data =
1671 remaining_data.data() + header.remaining_packet_length;
1672 uint64_t coalesced_data_length =
1673 remaining_bytes_length - header.remaining_packet_length;
1674 QuicDataReader coalesced_reader(coalesced_data, coalesced_data_length);
1675
1676 QuicPacketHeader coalesced_header;
1677 if (!ProcessIetfPacketHeader(&coalesced_reader, &coalesced_header)) {
1678 // Some implementations pad their INITIAL packets by sending random invalid
1679 // data after the INITIAL, and that is allowed by the specification. If we
1680 // fail to parse a subsequent coalesced packet, simply ignore it.
1681 QUIC_DLOG(INFO) << ENDPOINT
1682 << "Failed to parse received coalesced header of length "
1683 << coalesced_data_length
1684 << " with error: " << detailed_error_ << ": "
1685 << absl::BytesToHexString(absl::string_view(
1686 coalesced_data, coalesced_data_length))
1687 << " previous header was " << header;
1688 return;
1689 }
1690
1691 if (coalesced_header.destination_connection_id !=
1692 header.destination_connection_id) {
1693 // Drop coalesced packets with mismatched connection IDs.
1694 QUIC_DLOG(INFO) << ENDPOINT << "Received mismatched coalesced header "
1695 << coalesced_header << " previous header was " << header;
1696 QUIC_CODE_COUNT(
1697 quic_received_coalesced_packets_with_mismatched_connection_id);
1698 return;
1699 }
1700
1701 QuicEncryptedPacket coalesced_packet(coalesced_data, coalesced_data_length,
1702 /*owns_buffer=*/false);
1703 visitor_->OnCoalescedPacket(coalesced_packet);
1704}
1705
1706bool QuicFramer::MaybeProcessIetfLength(QuicDataReader* encrypted_reader,
1707 QuicPacketHeader* header) {
1708 if (!QuicVersionHasLongHeaderLengths(header->version.transport_version) ||
1709 header->form != IETF_QUIC_LONG_HEADER_PACKET ||
1710 (header->long_packet_type != INITIAL &&
1711 header->long_packet_type != HANDSHAKE &&
1712 header->long_packet_type != ZERO_RTT_PROTECTED)) {
1713 return true;
1714 }
1715 header->length_length = encrypted_reader->PeekVarInt62Length();
1716 if (!encrypted_reader->ReadVarInt62(&header->remaining_packet_length)) {
1717 set_detailed_error("Unable to read long header payload length.");
1718 return RaiseError(QUIC_INVALID_PACKET_HEADER);
1719 }
1720 uint64_t remaining_bytes_length = encrypted_reader->BytesRemaining();
1721 if (header->remaining_packet_length > remaining_bytes_length) {
1722 set_detailed_error("Long header payload length longer than packet.");
1723 return RaiseError(QUIC_INVALID_PACKET_HEADER);
1724 }
1725
1726 MaybeProcessCoalescedPacket(*encrypted_reader, remaining_bytes_length,
1727 *header);
1728
1729 if (!encrypted_reader->TruncateRemaining(header->remaining_packet_length)) {
1730 set_detailed_error("Length TruncateRemaining failed.");
1731 QUIC_BUG(quic_bug_10850_54) << "Length TruncateRemaining failed.";
1732 return RaiseError(QUIC_INVALID_PACKET_HEADER);
1733 }
1734 return true;
1735}
1736
1737bool QuicFramer::ProcessIetfDataPacket(QuicDataReader* encrypted_reader,
1738 QuicPacketHeader* header,
1739 const QuicEncryptedPacket& packet,
1740 char* decrypted_buffer,
1741 size_t buffer_length) {
1742 QUICHE_DCHECK_NE(GOOGLE_QUIC_PACKET, header->form);
1743 QUICHE_DCHECK(!header->has_possible_stateless_reset_token);
1744 header->length_length = VARIABLE_LENGTH_INTEGER_LENGTH_0;
1745 header->remaining_packet_length = 0;
1746 if (header->form == IETF_QUIC_SHORT_HEADER_PACKET &&
1747 perspective_ == Perspective::IS_CLIENT) {
1748 // Peek possible stateless reset token. Will only be used on decryption
1749 // failure.
1750 absl::string_view remaining = encrypted_reader->PeekRemainingPayload();
1751 if (remaining.length() >= sizeof(header->possible_stateless_reset_token)) {
1752 header->has_possible_stateless_reset_token = true;
1753 memcpy(&header->possible_stateless_reset_token,
1754 &remaining.data()[remaining.length() -
1755 sizeof(header->possible_stateless_reset_token)],
1756 sizeof(header->possible_stateless_reset_token));
1757 }
1758 }
1759
1760 if (!MaybeProcessIetfLength(encrypted_reader, header)) {
1761 return false;
1762 }
1763
1764 absl::string_view associated_data;
1765 std::vector<char> ad_storage;
1766 QuicPacketNumber base_packet_number;
1767 if (header->form == IETF_QUIC_SHORT_HEADER_PACKET ||
1768 header->long_packet_type != VERSION_NEGOTIATION) {
1769 QUICHE_DCHECK(header->form == IETF_QUIC_SHORT_HEADER_PACKET ||
1770 header->long_packet_type == INITIAL ||
1771 header->long_packet_type == HANDSHAKE ||
1772 header->long_packet_type == ZERO_RTT_PROTECTED);
1773 // Process packet number.
1774 if (supports_multiple_packet_number_spaces_) {
1775 PacketNumberSpace pn_space = GetPacketNumberSpace(*header);
1776 if (pn_space == NUM_PACKET_NUMBER_SPACES) {
1777 return RaiseError(QUIC_INVALID_PACKET_HEADER);
1778 }
1779 base_packet_number = largest_decrypted_packet_numbers_[pn_space];
1780 } else {
1781 base_packet_number = largest_packet_number_;
1782 }
1783 uint64_t full_packet_number;
1784 bool hp_removal_failed = false;
1785 if (version_.HasHeaderProtection()) {
1786 if (!RemoveHeaderProtection(encrypted_reader, packet, header,
1787 &full_packet_number, &ad_storage)) {
1788 hp_removal_failed = true;
1789 }
1790 associated_data = absl::string_view(ad_storage.data(), ad_storage.size());
1791 } else if (!ProcessAndCalculatePacketNumber(
1792 encrypted_reader, header->packet_number_length,
1793 base_packet_number, &full_packet_number)) {
1794 set_detailed_error("Unable to read packet number.");
1795 RecordDroppedPacketReason(DroppedPacketReason::INVALID_PACKET_NUMBER);
1796 return RaiseError(QUIC_INVALID_PACKET_HEADER);
1797 }
1798
1799 if (hp_removal_failed ||
1800 !IsValidFullPacketNumber(full_packet_number, version())) {
1801 if (IsIetfStatelessResetPacket(*header)) {
1802 // This is a stateless reset packet.
1803 QuicIetfStatelessResetPacket packet(
1804 *header, header->possible_stateless_reset_token);
1805 visitor_->OnAuthenticatedIetfStatelessResetPacket(packet);
1806 return true;
1807 }
1808 if (hp_removal_failed) {
1809 const EncryptionLevel decryption_level = GetEncryptionLevel(*header);
1810 const bool has_decryption_key = decrypter_[decryption_level] != nullptr;
1811 visitor_->OnUndecryptablePacket(
1812 QuicEncryptedPacket(encrypted_reader->FullPayload()),
1813 decryption_level, has_decryption_key);
1814 RecordDroppedPacketReason(DroppedPacketReason::DECRYPTION_FAILURE);
1815 set_detailed_error(absl::StrCat(
1816 "Unable to decrypt ", EncryptionLevelToString(decryption_level),
1817 " header protection", has_decryption_key ? "" : " (missing key)",
1818 "."));
1819 return RaiseError(QUIC_DECRYPTION_FAILURE);
1820 }
1821 RecordDroppedPacketReason(DroppedPacketReason::INVALID_PACKET_NUMBER);
1822 set_detailed_error("packet numbers cannot be 0.");
1823 return RaiseError(QUIC_INVALID_PACKET_HEADER);
1824 }
1825 header->packet_number = QuicPacketNumber(full_packet_number);
1826 }
1827
1828 // A nonce should only present in SHLO from the server to the client when
1829 // using QUIC crypto.
1830 if (header->form == IETF_QUIC_LONG_HEADER_PACKET &&
1831 header->long_packet_type == ZERO_RTT_PROTECTED &&
1832 perspective_ == Perspective::IS_CLIENT &&
1833 version_.handshake_protocol == PROTOCOL_QUIC_CRYPTO) {
1834 if (!encrypted_reader->ReadBytes(
1835 reinterpret_cast<uint8_t*>(last_nonce_.data()),
1836 last_nonce_.size())) {
1837 set_detailed_error("Unable to read nonce.");
1838 RecordDroppedPacketReason(
1839 DroppedPacketReason::INVALID_DIVERSIFICATION_NONCE);
1840 return RaiseError(QUIC_INVALID_PACKET_HEADER);
1841 }
1842
1843 header->nonce = &last_nonce_;
1844 } else {
1845 header->nonce = nullptr;
1846 }
1847
1848 if (!visitor_->OnUnauthenticatedHeader(*header)) {
1849 set_detailed_error(
1850 "Visitor asked to stop processing of unauthenticated header.");
1851 return false;
1852 }
1853
1854 absl::string_view encrypted = encrypted_reader->ReadRemainingPayload();
1855 if (!version_.HasHeaderProtection()) {
1856 associated_data = GetAssociatedDataFromEncryptedPacket(
1857 version_.transport_version, packet,
1858 GetIncludedDestinationConnectionIdLength(*header),
1859 GetIncludedSourceConnectionIdLength(*header), header->version_flag,
1860 header->nonce != nullptr, header->packet_number_length,
1861 header->retry_token_length_length, header->retry_token.length(),
1862 header->length_length);
1863 }
1864
1865 size_t decrypted_length = 0;
1866 EncryptionLevel decrypted_level;
1867 if (!DecryptPayload(packet.length(), encrypted, associated_data, *header,
1868 decrypted_buffer, buffer_length, &decrypted_length,
1869 &decrypted_level)) {
1870 if (IsIetfStatelessResetPacket(*header)) {
1871 // This is a stateless reset packet.
1872 QuicIetfStatelessResetPacket packet(
1873 *header, header->possible_stateless_reset_token);
1874 visitor_->OnAuthenticatedIetfStatelessResetPacket(packet);
1875 return true;
1876 }
1877 const EncryptionLevel decryption_level = GetEncryptionLevel(*header);
1878 const bool has_decryption_key = version_.KnowsWhichDecrypterToUse() &&
1879 decrypter_[decryption_level] != nullptr;
1880 visitor_->OnUndecryptablePacket(
1881 QuicEncryptedPacket(encrypted_reader->FullPayload()), decryption_level,
1882 has_decryption_key);
1883 set_detailed_error(absl::StrCat(
1884 "Unable to decrypt ", EncryptionLevelToString(decryption_level),
1885 " payload with reconstructed packet number ",
1886 header->packet_number.ToString(), " (largest decrypted was ",
1887 base_packet_number.ToString(), ")",
1888 has_decryption_key || !version_.KnowsWhichDecrypterToUse()
1889 ? ""
1890 : " (missing key)",
1891 "."));
1892 RecordDroppedPacketReason(DroppedPacketReason::DECRYPTION_FAILURE);
1893 return RaiseError(QUIC_DECRYPTION_FAILURE);
1894 }
1895 QuicDataReader reader(decrypted_buffer, decrypted_length);
1896
1897 // Update the largest packet number after we have decrypted the packet
1898 // so we are confident is not attacker controlled.
1899 if (supports_multiple_packet_number_spaces_) {
1900 largest_decrypted_packet_numbers_[QuicUtils::GetPacketNumberSpace(
1901 decrypted_level)]
1902 .UpdateMax(header->packet_number);
1903 } else {
1904 largest_packet_number_.UpdateMax(header->packet_number);
1905 }
1906
1907 if (!visitor_->OnPacketHeader(*header)) {
1908 RecordDroppedPacketReason(DroppedPacketReason::INVALID_PACKET_NUMBER);
1909 // The visitor suppresses further processing of the packet.
1910 return true;
1911 }
1912
1913 if (packet.length() > kMaxIncomingPacketSize) {
1914 set_detailed_error("Packet too large.");
1915 return RaiseError(QUIC_PACKET_TOO_LARGE);
1916 }
1917
1918 // Handle the payload.
1919 if (VersionHasIetfQuicFrames(version_.transport_version)) {
1920 current_received_frame_type_ = 0;
1921 previously_received_frame_type_ = 0;
1922 if (!ProcessIetfFrameData(&reader, *header, decrypted_level)) {
1923 current_received_frame_type_ = 0;
1924 previously_received_frame_type_ = 0;
1925 QUICHE_DCHECK_NE(QUIC_NO_ERROR,
1926 error_); // ProcessIetfFrameData sets the error.
1927 QUICHE_DCHECK_NE("", detailed_error_);
1928 QUIC_DLOG(WARNING) << ENDPOINT << "Unable to process frame data. Error: "
1929 << detailed_error_;
1930 return false;
1931 }
1932 current_received_frame_type_ = 0;
1933 previously_received_frame_type_ = 0;
1934 } else {
1935 if (!ProcessFrameData(&reader, *header)) {
1936 QUICHE_DCHECK_NE(QUIC_NO_ERROR,
1937 error_); // ProcessFrameData sets the error.
1938 QUICHE_DCHECK_NE("", detailed_error_);
1939 QUIC_DLOG(WARNING) << ENDPOINT << "Unable to process frame data. Error: "
1940 << detailed_error_;
1941 return false;
1942 }
1943 }
1944
1945 visitor_->OnPacketComplete();
1946 return true;
1947}
1948
1949bool QuicFramer::ProcessDataPacket(QuicDataReader* encrypted_reader,
1950 QuicPacketHeader* header,
1951 const QuicEncryptedPacket& packet,
1952 char* decrypted_buffer,
1953 size_t buffer_length) {
1954 if (!ProcessUnauthenticatedHeader(encrypted_reader, header)) {
1955 QUICHE_DCHECK_NE("", detailed_error_);
1956 QUIC_DVLOG(1)
1957 << ENDPOINT
1958 << "Unable to process packet header. Stopping parsing. Error: "
1959 << detailed_error_;
1960 RecordDroppedPacketReason(DroppedPacketReason::INVALID_PACKET_NUMBER);
1961 return false;
1962 }
1963
1964 absl::string_view encrypted = encrypted_reader->ReadRemainingPayload();
1965 absl::string_view associated_data = GetAssociatedDataFromEncryptedPacket(
1966 version_.transport_version, packet,
1967 GetIncludedDestinationConnectionIdLength(*header),
1968 GetIncludedSourceConnectionIdLength(*header), header->version_flag,
1969 header->nonce != nullptr, header->packet_number_length,
1970 header->retry_token_length_length, header->retry_token.length(),
1971 header->length_length);
1972
1973 size_t decrypted_length = 0;
1974 EncryptionLevel decrypted_level;
1975 if (!DecryptPayload(packet.length(), encrypted, associated_data, *header,
1976 decrypted_buffer, buffer_length, &decrypted_length,
1977 &decrypted_level)) {
1978 const EncryptionLevel decryption_level = decrypter_level_;
1979 // This version uses trial decryption so we always report to our visitor
1980 // that we are not certain we have the correct decryption key.
1981 const bool has_decryption_key = false;
1982 visitor_->OnUndecryptablePacket(
1983 QuicEncryptedPacket(encrypted_reader->FullPayload()), decryption_level,
1984 has_decryption_key);
1985 RecordDroppedPacketReason(DroppedPacketReason::DECRYPTION_FAILURE);
1986 set_detailed_error(absl::StrCat("Unable to decrypt ",
1987 EncryptionLevelToString(decryption_level),
1988 " payload."));
1989 return RaiseError(QUIC_DECRYPTION_FAILURE);
1990 }
1991
1992 QuicDataReader reader(decrypted_buffer, decrypted_length);
1993
1994 // Update the largest packet number after we have decrypted the packet
1995 // so we are confident is not attacker controlled.
1996 if (supports_multiple_packet_number_spaces_) {
1997 largest_decrypted_packet_numbers_[QuicUtils::GetPacketNumberSpace(
1998 decrypted_level)]
1999 .UpdateMax(header->packet_number);
2000 } else {
2001 largest_packet_number_.UpdateMax(header->packet_number);
2002 }
2003
2004 if (!visitor_->OnPacketHeader(*header)) {
2005 // The visitor suppresses further processing of the packet.
2006 return true;
2007 }
2008
2009 if (packet.length() > kMaxIncomingPacketSize) {
2010 set_detailed_error("Packet too large.");
2011 return RaiseError(QUIC_PACKET_TOO_LARGE);
2012 }
2013
2014 // Handle the payload.
2015 if (!ProcessFrameData(&reader, *header)) {
2016 QUICHE_DCHECK_NE(QUIC_NO_ERROR,
2017 error_); // ProcessFrameData sets the error.
2018 QUICHE_DCHECK_NE("", detailed_error_);
2019 QUIC_DLOG(WARNING) << ENDPOINT << "Unable to process frame data. Error: "
2020 << detailed_error_;
2021 return false;
2022 }
2023
2024 visitor_->OnPacketComplete();
2025 return true;
2026}
2027
2028bool QuicFramer::ProcessPublicResetPacket(QuicDataReader* reader,
2029 const QuicPacketHeader& header) {
2030 QuicPublicResetPacket packet(
2031 GetServerConnectionIdAsRecipient(header, perspective_));
2032
2033 std::unique_ptr<CryptoHandshakeMessage> reset(
2034 CryptoFramer::ParseMessage(reader->ReadRemainingPayload()));
2035 if (!reset) {
2036 set_detailed_error("Unable to read reset message.");
2037 RecordDroppedPacketReason(DroppedPacketReason::INVALID_PUBLIC_RESET_PACKET);
2038 return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET);
2039 }
2040 if (reset->tag() != kPRST) {
2041 set_detailed_error("Incorrect message tag.");
2042 RecordDroppedPacketReason(DroppedPacketReason::INVALID_PUBLIC_RESET_PACKET);
2043 return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET);
2044 }
2045
2046 if (reset->GetUint64(kRNON, &packet.nonce_proof) != QUIC_NO_ERROR) {
2047 set_detailed_error("Unable to read nonce proof.");
2048 RecordDroppedPacketReason(DroppedPacketReason::INVALID_PUBLIC_RESET_PACKET);
2049 return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET);
2050 }
2051 // TODO(satyamshekhar): validate nonce to protect against DoS.
2052
2053 absl::string_view address;
2054 if (reset->GetStringPiece(kCADR, &address)) {
2055 QuicSocketAddressCoder address_coder;
2056 if (address_coder.Decode(address.data(), address.length())) {
2057 packet.client_address =
2058 QuicSocketAddress(address_coder.ip(), address_coder.port());
2059 }
2060 }
2061
2062 absl::string_view endpoint_id;
2063 if (perspective_ == Perspective::IS_CLIENT &&
2064 reset->GetStringPiece(kEPID, &endpoint_id)) {
2065 packet.endpoint_id = std::string(endpoint_id);
2066 packet.endpoint_id += '\0';
2067 }
2068
2069 visitor_->OnPublicResetPacket(packet);
2070 return true;
2071}
2072
2073bool QuicFramer::IsIetfStatelessResetPacket(
2074 const QuicPacketHeader& header) const {
2075 QUIC_BUG_IF(quic_bug_12975_3, header.has_possible_stateless_reset_token &&
2076 perspective_ != Perspective::IS_CLIENT)
2077 << "has_possible_stateless_reset_token can only be true at client side.";
2078 return header.form == IETF_QUIC_SHORT_HEADER_PACKET &&
2079 header.has_possible_stateless_reset_token &&
2080 visitor_->IsValidStatelessResetToken(
2081 header.possible_stateless_reset_token);
2082}
2083
2084bool QuicFramer::HasEncrypterOfEncryptionLevel(EncryptionLevel level) const {
2085 return encrypter_[level] != nullptr;
2086}
2087
2088bool QuicFramer::HasDecrypterOfEncryptionLevel(EncryptionLevel level) const {
2089 return decrypter_[level] != nullptr;
2090}
2091
2092bool QuicFramer::HasAnEncrypterForSpace(PacketNumberSpace space) const {
2093 switch (space) {
2094 case INITIAL_DATA:
2095 return HasEncrypterOfEncryptionLevel(ENCRYPTION_INITIAL);
2096 case HANDSHAKE_DATA:
2097 return HasEncrypterOfEncryptionLevel(ENCRYPTION_HANDSHAKE);
2098 case APPLICATION_DATA:
2099 return HasEncrypterOfEncryptionLevel(ENCRYPTION_ZERO_RTT) ||
2100 HasEncrypterOfEncryptionLevel(ENCRYPTION_FORWARD_SECURE);
2101 case NUM_PACKET_NUMBER_SPACES:
2102 break;
2103 }
2104 QUIC_BUG(quic_bug_10850_55)
2105 << ENDPOINT
2106 << "Try to send data of space: " << PacketNumberSpaceToString(space);
2107 return false;
2108}
2109
2110EncryptionLevel QuicFramer::GetEncryptionLevelToSendApplicationData() const {
2111 if (!HasAnEncrypterForSpace(APPLICATION_DATA)) {
2112 QUIC_BUG(quic_bug_12975_4)
2113 << "Tried to get encryption level to send application data with no "
2114 "encrypter available.";
2115 return NUM_ENCRYPTION_LEVELS;
2116 }
2117 if (HasEncrypterOfEncryptionLevel(ENCRYPTION_FORWARD_SECURE)) {
2118 return ENCRYPTION_FORWARD_SECURE;
2119 }
2120 QUICHE_DCHECK(HasEncrypterOfEncryptionLevel(ENCRYPTION_ZERO_RTT));
2121 return ENCRYPTION_ZERO_RTT;
2122}
2123
2124bool QuicFramer::AppendPacketHeader(const QuicPacketHeader& header,
2125 QuicDataWriter* writer,
2126 size_t* length_field_offset) {
2127 if (version().HasIetfInvariantHeader()) {
2128 return AppendIetfPacketHeader(header, writer, length_field_offset);
2129 }
2130 QUIC_DVLOG(1) << ENDPOINT << "Appending header: " << header;
2131 uint8_t public_flags = 0;
2132 if (header.reset_flag) {
2133 public_flags |= PACKET_PUBLIC_FLAGS_RST;
2134 }
2135 if (header.version_flag) {
2136 public_flags |= PACKET_PUBLIC_FLAGS_VERSION;
2137 }
2138
2139 public_flags |= GetPacketNumberFlags(header.packet_number_length)
2140 << kPublicHeaderSequenceNumberShift;
2141
2142 if (header.nonce != nullptr) {
2143 QUICHE_DCHECK_EQ(Perspective::IS_SERVER, perspective_);
2144 public_flags |= PACKET_PUBLIC_FLAGS_NONCE;
2145 }
2146
2147 QuicConnectionId server_connection_id =
2148 GetServerConnectionIdAsSender(header, perspective_);
2149 QuicConnectionIdIncluded server_connection_id_included =
2150 GetServerConnectionIdIncludedAsSender(header, perspective_);
2151 QUICHE_DCHECK_EQ(CONNECTION_ID_ABSENT,
2152 GetClientConnectionIdIncludedAsSender(header, perspective_))
2153 << ENDPOINT << ParsedQuicVersionToString(version_)
2154 << " invalid header: " << header;
2155
2156 switch (server_connection_id_included) {
2157 case CONNECTION_ID_ABSENT:
2158 if (!writer->WriteUInt8(public_flags |
2159 PACKET_PUBLIC_FLAGS_0BYTE_CONNECTION_ID)) {
2160 return false;
2161 }
2162 break;
2163 case CONNECTION_ID_PRESENT:
2164 QUIC_BUG_IF(quic_bug_12975_5,
2165 !QuicUtils::IsConnectionIdValidForVersion(
2166 server_connection_id, transport_version()))
2167 << "AppendPacketHeader: attempted to use connection ID "
2168 << server_connection_id << " which is invalid with version "
2169 << version();
2170
2171 public_flags |= PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID;
2172 if (perspective_ == Perspective::IS_CLIENT) {
2173 public_flags |= PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID_OLD;
2174 }
2175 if (!writer->WriteUInt8(public_flags) ||
2176 !writer->WriteConnectionId(server_connection_id)) {
2177 return false;
2178 }
2179 break;
2180 }
2181 last_serialized_server_connection_id_ = server_connection_id;
2182
2183 if (header.version_flag) {
2184 QUICHE_DCHECK_EQ(Perspective::IS_CLIENT, perspective_);
2185 QuicVersionLabel version_label = CreateQuicVersionLabel(version_);
2186 if (!writer->WriteUInt32(version_label)) {
2187 return false;
2188 }
2189
2190 QUIC_DVLOG(1) << ENDPOINT << "label = '"
2191 << QuicVersionLabelToString(version_label) << "'";
2192 }
2193
2194 if (header.nonce != nullptr &&
2195 !writer->WriteBytes(header.nonce, kDiversificationNonceSize)) {
2196 return false;
2197 }
2198
2199 if (!AppendPacketNumber(header.packet_number_length, header.packet_number,
2200 writer)) {
2201 return false;
2202 }
2203
2204 return true;
2205}
2206
2207bool QuicFramer::AppendIetfHeaderTypeByte(const QuicPacketHeader& header,
2208 QuicDataWriter* writer) {
2209 uint8_t type = 0;
2210 if (header.version_flag) {
2211 type = static_cast<uint8_t>(
2212 FLAGS_LONG_HEADER | FLAGS_FIXED_BIT |
2213 LongHeaderTypeToOnWireValue(header.long_packet_type, version_) |
2214 PacketNumberLengthToOnWireValue(header.packet_number_length));
2215 } else {
2216 type = static_cast<uint8_t>(
2217 FLAGS_FIXED_BIT | (current_key_phase_bit_ ? FLAGS_KEY_PHASE_BIT : 0) |
2218 PacketNumberLengthToOnWireValue(header.packet_number_length));
2219 }
2220 return writer->WriteUInt8(type);
2221}
2222
2223bool QuicFramer::AppendIetfPacketHeader(const QuicPacketHeader& header,
2224 QuicDataWriter* writer,
2225 size_t* length_field_offset) {
2226 QUIC_DVLOG(1) << ENDPOINT << "Appending IETF header: " << header;
2227 QuicConnectionId server_connection_id =
2228 GetServerConnectionIdAsSender(header, perspective_);
2229 QUIC_BUG_IF(quic_bug_12975_6, !QuicUtils::IsConnectionIdValidForVersion(
2230 server_connection_id, transport_version()))
2231 << "AppendIetfPacketHeader: attempted to use connection ID "
2232 << server_connection_id << " which is invalid with version " << version();
2233 if (!AppendIetfHeaderTypeByte(header, writer)) {
2234 return false;
2235 }
2236
2237 if (header.version_flag) {
2238 QUICHE_DCHECK_NE(VERSION_NEGOTIATION, header.long_packet_type)
2239 << "QuicFramer::AppendIetfPacketHeader does not support sending "
2240 "version negotiation packets, use "
2241 "QuicFramer::BuildVersionNegotiationPacket instead "
2242 << header;
2243 // Append version for long header.
2244 QuicVersionLabel version_label = CreateQuicVersionLabel(version_);
2245 if (!writer->WriteUInt32(version_label)) {
2246 return false;
2247 }
2248 }
2249
2250 // Append connection ID.
2251 if (!AppendIetfConnectionIds(
2252 header.version_flag, version_.HasLengthPrefixedConnectionIds(),
2253 header.destination_connection_id_included != CONNECTION_ID_ABSENT
2254 ? header.destination_connection_id
2255 : EmptyQuicConnectionId(),
2256 header.source_connection_id_included != CONNECTION_ID_ABSENT
2257 ? header.source_connection_id
2258 : EmptyQuicConnectionId(),
2259 writer)) {
2260 return false;
2261 }
2262
2263 last_serialized_server_connection_id_ = server_connection_id;
2264 if (version_.SupportsClientConnectionIds()) {
2265 last_serialized_client_connection_id_ =
2266 GetClientConnectionIdAsSender(header, perspective_);
2267 }
2268
2269 // TODO(b/141924462) Remove this QUIC_BUG once we do support sending RETRY.
2270 QUIC_BUG_IF(quic_bug_12975_7,
2271 header.version_flag && header.long_packet_type == RETRY)
2272 << "Sending IETF RETRY packets is not currently supported " << header;
2273
2274 if (QuicVersionHasLongHeaderLengths(transport_version()) &&
2275 header.version_flag) {
2276 if (header.long_packet_type == INITIAL) {
2277 QUICHE_DCHECK_NE(VARIABLE_LENGTH_INTEGER_LENGTH_0,
2278 header.retry_token_length_length)
2279 << ENDPOINT << ParsedQuicVersionToString(version_)
2280 << " bad retry token length length in header: " << header;
2281 // Write retry token length.
2282 if (!writer->WriteVarInt62(header.retry_token.length(),
2283 header.retry_token_length_length)) {
2284 return false;
2285 }
2286 // Write retry token.
2287 if (!header.retry_token.empty() &&
2288 !writer->WriteStringPiece(header.retry_token)) {
2289 return false;
2290 }
2291 }
2292 if (length_field_offset != nullptr) {
2293 *length_field_offset = writer->length();
2294 }
2295 // Add fake length to reserve two bytes to add length in later.
2296 writer->WriteVarInt62(256);
2297 } else if (length_field_offset != nullptr) {
2298 *length_field_offset = 0;
2299 }
2300
2301 // Append packet number.
2302 if (!AppendPacketNumber(header.packet_number_length, header.packet_number,
2303 writer)) {
2304 return false;
2305 }
2306 last_written_packet_number_length_ = header.packet_number_length;
2307
2308 if (!header.version_flag) {
2309 return true;
2310 }
2311
2312 if (header.nonce != nullptr) {
2313 QUICHE_DCHECK(header.version_flag);
2314 QUICHE_DCHECK_EQ(ZERO_RTT_PROTECTED, header.long_packet_type);
2315 QUICHE_DCHECK_EQ(Perspective::IS_SERVER, perspective_);
2316 if (!writer->WriteBytes(header.nonce, kDiversificationNonceSize)) {
2317 return false;
2318 }
2319 }
2320
2321 return true;
2322}
2323
2324const QuicTime::Delta QuicFramer::CalculateTimestampFromWire(
2325 uint32_t time_delta_us) {
2326 // The new time_delta might have wrapped to the next epoch, or it
2327 // might have reverse wrapped to the previous epoch, or it might
2328 // remain in the same epoch. Select the time closest to the previous
2329 // time.
2330 //
2331 // epoch_delta is the delta between epochs. A delta is 4 bytes of
2332 // microseconds.
2333 const uint64_t epoch_delta = UINT64_C(1) << 32;
2334 uint64_t epoch = last_timestamp_.ToMicroseconds() & ~(epoch_delta - 1);
2335 // Wrapping is safe here because a wrapped value will not be ClosestTo below.
2336 uint64_t prev_epoch = epoch - epoch_delta;
2337 uint64_t next_epoch = epoch + epoch_delta;
2338
2339 uint64_t time = ClosestTo(
2340 last_timestamp_.ToMicroseconds(), epoch + time_delta_us,
2341 ClosestTo(last_timestamp_.ToMicroseconds(), prev_epoch + time_delta_us,
2342 next_epoch + time_delta_us));
2343
2344 return QuicTime::Delta::FromMicroseconds(time);
2345}
2346
2347uint64_t QuicFramer::CalculatePacketNumberFromWire(
2348 QuicPacketNumberLength packet_number_length,
2349 QuicPacketNumber base_packet_number, uint64_t packet_number) const {
2350 // The new packet number might have wrapped to the next epoch, or
2351 // it might have reverse wrapped to the previous epoch, or it might
2352 // remain in the same epoch. Select the packet number closest to the
2353 // next expected packet number, the previous packet number plus 1.
2354
2355 // epoch_delta is the delta between epochs the packet number was serialized
2356 // with, so the correct value is likely the same epoch as the last sequence
2357 // number or an adjacent epoch.
2358 if (!base_packet_number.IsInitialized()) {
2359 return packet_number;
2360 }
2361 const uint64_t epoch_delta = UINT64_C(1) << (8 * packet_number_length);
2362 uint64_t next_packet_number = base_packet_number.ToUint64() + 1;
2363 uint64_t epoch = base_packet_number.ToUint64() & ~(epoch_delta - 1);
2364 uint64_t prev_epoch = epoch - epoch_delta;
2365 uint64_t next_epoch = epoch + epoch_delta;
2366
2367 return ClosestTo(next_packet_number, epoch + packet_number,
2368 ClosestTo(next_packet_number, prev_epoch + packet_number,
2369 next_epoch + packet_number));
2370}
2371
2372bool QuicFramer::ProcessPublicHeader(QuicDataReader* reader,
2373 bool packet_has_ietf_packet_header,
2374 QuicPacketHeader* header) {
2375 if (packet_has_ietf_packet_header) {
2376 return ProcessIetfPacketHeader(reader, header);
2377 }
2378 uint8_t public_flags;
2379 if (!reader->ReadBytes(&public_flags, 1)) {
2380 set_detailed_error("Unable to read public flags.");
2381 return false;
2382 }
2383
2384 header->reset_flag = (public_flags & PACKET_PUBLIC_FLAGS_RST) != 0;
2385 header->version_flag = (public_flags & PACKET_PUBLIC_FLAGS_VERSION) != 0;
2386
2387 if (validate_flags_ && !header->version_flag &&
2388 public_flags > PACKET_PUBLIC_FLAGS_MAX) {
2389 set_detailed_error("Illegal public flags value.");
2390 return false;
2391 }
2392
2393 if (header->reset_flag && header->version_flag) {
2394 set_detailed_error("Got version flag in reset packet");
2395 return false;
2396 }
2397
2398 QuicConnectionId* header_connection_id = &header->destination_connection_id;
2399 QuicConnectionIdIncluded* header_connection_id_included =
2400 &header->destination_connection_id_included;
2401 if (perspective_ == Perspective::IS_CLIENT) {
2402 header_connection_id = &header->source_connection_id;
2403 header_connection_id_included = &header->source_connection_id_included;
2404 }
2405 switch (public_flags & PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID) {
2406 case PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID:
2407 if (!reader->ReadConnectionId(header_connection_id,
2408 kQuicDefaultConnectionIdLength)) {
2409 set_detailed_error("Unable to read ConnectionId.");
2410 return false;
2411 }
2412 *header_connection_id_included = CONNECTION_ID_PRESENT;
2413 break;
2414 case PACKET_PUBLIC_FLAGS_0BYTE_CONNECTION_ID:
2415 *header_connection_id_included = CONNECTION_ID_ABSENT;
2416 *header_connection_id = last_serialized_server_connection_id_;
2417 break;
2418 }
2419
2420 header->packet_number_length = ReadSequenceNumberLength(
2421 public_flags >> kPublicHeaderSequenceNumberShift);
2422
2423 // Read the version only if the packet is from the client.
2424 // version flag from the server means version negotiation packet.
2425 if (header->version_flag && perspective_ == Perspective::IS_SERVER) {
2426 QuicVersionLabel version_label;
2427 if (!ProcessVersionLabel(reader, &version_label)) {
2428 set_detailed_error("Unable to read protocol version.");
2429 return false;
2430 }
2431 // If the version from the new packet is the same as the version of this
2432 // framer, then the public flags should be set to something we understand.
2433 // If not, this raises an error.
2434 ParsedQuicVersion version = ParseQuicVersionLabel(version_label);
2435 if (version == version_ && public_flags > PACKET_PUBLIC_FLAGS_MAX) {
2436 set_detailed_error("Illegal public flags value.");
2437 return false;
2438 }
2439 header->version = version;
2440 }
2441
2442 // A nonce should only be present in packets from the server to the client,
2443 // which are neither version negotiation nor public reset packets.
2444 if (public_flags & PACKET_PUBLIC_FLAGS_NONCE &&
2445 !(public_flags & PACKET_PUBLIC_FLAGS_VERSION) &&
2446 !(public_flags & PACKET_PUBLIC_FLAGS_RST) &&
2447 // The nonce flag from a client is ignored and is assumed to be an older
2448 // client indicating an eight-byte connection ID.
2449 perspective_ == Perspective::IS_CLIENT) {
2450 if (!reader->ReadBytes(reinterpret_cast<uint8_t*>(last_nonce_.data()),
2451 last_nonce_.size())) {
2452 set_detailed_error("Unable to read nonce.");
2453 return false;
2454 }
2455 header->nonce = &last_nonce_;
2456 } else {
2457 header->nonce = nullptr;
2458 }
2459
2460 return true;
2461}
2462
2463// static
2464QuicPacketNumberLength QuicFramer::GetMinPacketNumberLength(
2465 QuicPacketNumber packet_number) {
2466 QUICHE_DCHECK(packet_number.IsInitialized());
2467 if (packet_number < QuicPacketNumber(1 << (PACKET_1BYTE_PACKET_NUMBER * 8))) {
2468 return PACKET_1BYTE_PACKET_NUMBER;
2469 } else if (packet_number <
2470 QuicPacketNumber(1 << (PACKET_2BYTE_PACKET_NUMBER * 8))) {
2471 return PACKET_2BYTE_PACKET_NUMBER;
2472 } else if (packet_number <
2473 QuicPacketNumber(UINT64_C(1)
2474 << (PACKET_4BYTE_PACKET_NUMBER * 8))) {
2475 return PACKET_4BYTE_PACKET_NUMBER;
2476 } else {
2477 return PACKET_6BYTE_PACKET_NUMBER;
2478 }
2479}
2480
2481// static
2482uint8_t QuicFramer::GetPacketNumberFlags(
2483 QuicPacketNumberLength packet_number_length) {
2484 switch (packet_number_length) {
2485 case PACKET_1BYTE_PACKET_NUMBER:
2486 return PACKET_FLAGS_1BYTE_PACKET;
2487 case PACKET_2BYTE_PACKET_NUMBER:
2488 return PACKET_FLAGS_2BYTE_PACKET;
2489 case PACKET_4BYTE_PACKET_NUMBER:
2490 return PACKET_FLAGS_4BYTE_PACKET;
2491 case PACKET_6BYTE_PACKET_NUMBER:
2492 case PACKET_8BYTE_PACKET_NUMBER:
2493 return PACKET_FLAGS_8BYTE_PACKET;
2494 default:
2495 QUIC_BUG(quic_bug_10850_56) << "Unreachable case statement.";
2496 return PACKET_FLAGS_8BYTE_PACKET;
2497 }
2498}
2499
2500// static
2501QuicFramer::AckFrameInfo QuicFramer::GetAckFrameInfo(
2502 const QuicAckFrame& frame) {
2503 AckFrameInfo new_ack_info;
2504 if (frame.packets.Empty()) {
2505 return new_ack_info;
2506 }
2507 // The first block is the last interval. It isn't encoded with the gap-length
2508 // encoding, so skip it.
2509 new_ack_info.first_block_length = frame.packets.LastIntervalLength();
2510 auto itr = frame.packets.rbegin();
2511 QuicPacketNumber previous_start = itr->min();
2512 new_ack_info.max_block_length = itr->Length();
2513 ++itr;
2514
2515 // Don't do any more work after getting information for 256 ACK blocks; any
2516 // more can't be encoded anyway.
2517 for (; itr != frame.packets.rend() &&
2518 new_ack_info.num_ack_blocks < std::numeric_limits<uint8_t>::max();
2519 previous_start = itr->min(), ++itr) {
2520 const auto& interval = *itr;
2521 const QuicPacketCount total_gap = previous_start - interval.max();
2522 new_ack_info.num_ack_blocks +=
2523 (total_gap + std::numeric_limits<uint8_t>::max() - 1) /
2524 std::numeric_limits<uint8_t>::max();
2525 new_ack_info.max_block_length =
2526 std::max(new_ack_info.max_block_length, interval.Length());
2527 }
2528 return new_ack_info;
2529}
2530
2531bool QuicFramer::ProcessUnauthenticatedHeader(QuicDataReader* encrypted_reader,
2532 QuicPacketHeader* header) {
2533 QuicPacketNumber base_packet_number;
2534 if (supports_multiple_packet_number_spaces_) {
2535 PacketNumberSpace pn_space = GetPacketNumberSpace(*header);
2536 if (pn_space == NUM_PACKET_NUMBER_SPACES) {
2537 set_detailed_error("Unable to determine packet number space.");
2538 return RaiseError(QUIC_INVALID_PACKET_HEADER);
2539 }
2540 base_packet_number = largest_decrypted_packet_numbers_[pn_space];
2541 } else {
2542 base_packet_number = largest_packet_number_;
2543 }
2544 uint64_t full_packet_number;
2545 if (!ProcessAndCalculatePacketNumber(
2546 encrypted_reader, header->packet_number_length, base_packet_number,
2547 &full_packet_number)) {
2548 set_detailed_error("Unable to read packet number.");
2549 return RaiseError(QUIC_INVALID_PACKET_HEADER);
2550 }
2551
2552 if (!IsValidFullPacketNumber(full_packet_number, version())) {
2553 set_detailed_error("packet numbers cannot be 0.");
2554 return RaiseError(QUIC_INVALID_PACKET_HEADER);
2555 }
2556 header->packet_number = QuicPacketNumber(full_packet_number);
2557
2558 if (!visitor_->OnUnauthenticatedHeader(*header)) {
2559 set_detailed_error(
2560 "Visitor asked to stop processing of unauthenticated header.");
2561 return false;
2562 }
2563 // The function we are in is called because the framer believes that it is
2564 // processing a packet that uses the non-IETF (i.e. Google QUIC) packet header
2565 // type. Usually, the framer makes that decision based on the framer's
2566 // version, but when the framer is used with Perspective::IS_SERVER, then
2567 // before version negotiation is complete (specifically, before
2568 // InferPacketHeaderTypeFromVersion is called), this decision is made based on
2569 // the type byte of the packet.
2570 //
2571 // If the framer's version KnowsWhichDecrypterToUse, then that version expects
2572 // to use the IETF packet header type. If that's the case and we're in this
2573 // function, then the packet received is invalid: the framer was expecting an
2574 // IETF packet header and didn't get one.
2575 if (version().KnowsWhichDecrypterToUse()) {
2576 set_detailed_error("Invalid public header type for expected version.");
2577 return RaiseError(QUIC_INVALID_PACKET_HEADER);
2578 }
2579 return true;
2580}
2581
2582bool QuicFramer::ProcessIetfHeaderTypeByte(QuicDataReader* reader,
2583 QuicPacketHeader* header) {
2584 uint8_t type;
2585 if (!reader->ReadBytes(&type, 1)) {
2586 set_detailed_error("Unable to read first byte.");
2587 return false;
2588 }
2589 header->type_byte = type;
2590 // Determine whether this is a long or short header.
2591 header->form = GetIetfPacketHeaderFormat(type);
2592 if (header->form == IETF_QUIC_LONG_HEADER_PACKET) {
2593 // Version is always present in long headers.
2594 header->version_flag = true;
2595 // In versions that do not support client connection IDs, we mark the
2596 // corresponding connection ID as absent.
2597 header->destination_connection_id_included =
2598 (perspective_ == Perspective::IS_SERVER ||
2599 version_.SupportsClientConnectionIds())
2600 ? CONNECTION_ID_PRESENT
2601 : CONNECTION_ID_ABSENT;
2602 header->source_connection_id_included =
2603 (perspective_ == Perspective::IS_CLIENT ||
2604 version_.SupportsClientConnectionIds())
2605 ? CONNECTION_ID_PRESENT
2606 : CONNECTION_ID_ABSENT;
2607 // Read version tag.
2608 QuicVersionLabel version_label;
2609 if (!ProcessVersionLabel(reader, &version_label)) {
2610 set_detailed_error("Unable to read protocol version.");
2611 return false;
2612 }
2613 if (!version_label) {
2614 // Version label is 0 indicating this is a version negotiation packet.
2615 header->long_packet_type = VERSION_NEGOTIATION;
2616 } else {
2617 header->version = ParseQuicVersionLabel(version_label);
2618 if (header->version.IsKnown()) {
2619 if (!(type & FLAGS_FIXED_BIT)) {
2620 set_detailed_error("Fixed bit is 0 in long header.");
2621 return false;
2622 }
2623 header->long_packet_type = GetLongHeaderType(type, header->version);
2624 switch (header->long_packet_type) {
2625 case INVALID_PACKET_TYPE:
2626 set_detailed_error("Illegal long header type value.");
2627 return false;
2628 case RETRY:
2629 if (!version().SupportsRetry()) {
2630 set_detailed_error("RETRY not supported in this version.");
2631 return false;
2632 }
2633 if (perspective_ == Perspective::IS_SERVER) {
2634 set_detailed_error("Client-initiated RETRY is invalid.");
2635 return false;
2636 }
2637 break;
2638 default:
2639 if (!header->version.HasHeaderProtection()) {
2640 header->packet_number_length =
2641 GetLongHeaderPacketNumberLength(type);
2642 }
2643 break;
2644 }
2645 }
2646 }
2647
2648 QUIC_DVLOG(1) << ENDPOINT << "Received IETF long header: "
2649 << QuicUtils::QuicLongHeaderTypetoString(
2650 header->long_packet_type);
2651 return true;
2652 }
2653
2654 QUIC_DVLOG(1) << ENDPOINT << "Received IETF short header";
2655 // Version is not present in short headers.
2656 header->version_flag = false;
2657 // In versions that do not support client connection IDs, the client will not
2658 // receive destination connection IDs.
2659 header->destination_connection_id_included =
2660 (perspective_ == Perspective::IS_SERVER ||
2661 version_.SupportsClientConnectionIds())
2662 ? CONNECTION_ID_PRESENT
2663 : CONNECTION_ID_ABSENT;
2664 header->source_connection_id_included = CONNECTION_ID_ABSENT;
2665 if (!(type & FLAGS_FIXED_BIT)) {
2666 set_detailed_error("Fixed bit is 0 in short header.");
2667 return false;
2668 }
2669 if (!version_.HasHeaderProtection()) {
2670 header->packet_number_length = GetShortHeaderPacketNumberLength(type);
2671 }
2672 QUIC_DVLOG(1) << "packet_number_length = " << header->packet_number_length;
2673 return true;
2674}
2675
2676// static
2677bool QuicFramer::ProcessVersionLabel(QuicDataReader* reader,
2678 QuicVersionLabel* version_label) {
2679 if (!reader->ReadUInt32(version_label)) {
2680 return false;
2681 }
2682 return true;
2683}
2684
2685// static
2686bool QuicFramer::ProcessAndValidateIetfConnectionIdLength(
2687 QuicDataReader* reader, ParsedQuicVersion version, Perspective perspective,
2688 bool should_update_expected_server_connection_id_length,
2689 uint8_t* expected_server_connection_id_length,
2690 uint8_t* destination_connection_id_length,
2691 uint8_t* source_connection_id_length, std::string* detailed_error) {
2692 uint8_t connection_id_lengths_byte;
2693 if (!reader->ReadBytes(&connection_id_lengths_byte, 1)) {
2694 *detailed_error = "Unable to read ConnectionId length.";
2695 return false;
2696 }
2697 uint8_t dcil =
2698 (connection_id_lengths_byte & kDestinationConnectionIdLengthMask) >> 4;
2699 if (dcil != 0) {
2700 dcil += kConnectionIdLengthAdjustment;
2701 }
2702 uint8_t scil = connection_id_lengths_byte & kSourceConnectionIdLengthMask;
2703 if (scil != 0) {
2704 scil += kConnectionIdLengthAdjustment;
2705 }
2706 if (should_update_expected_server_connection_id_length) {
2707 uint8_t server_connection_id_length =
2708 perspective == Perspective::IS_SERVER ? dcil : scil;
2709 if (*expected_server_connection_id_length != server_connection_id_length) {
2710 QUIC_DVLOG(1) << "Updating expected_server_connection_id_length: "
2711 << static_cast<int>(*expected_server_connection_id_length)
2712 << " -> " << static_cast<int>(server_connection_id_length);
2713 *expected_server_connection_id_length = server_connection_id_length;
2714 }
2715 }
2716 if (!should_update_expected_server_connection_id_length &&
2717 (dcil != *destination_connection_id_length ||
2718 scil != *source_connection_id_length) &&
2719 version.IsKnown() && !version.AllowsVariableLengthConnectionIds()) {
2720 QUIC_DVLOG(1) << "dcil: " << static_cast<uint32_t>(dcil)
2721 << ", scil: " << static_cast<uint32_t>(scil);
2722 *detailed_error = "Invalid ConnectionId length.";
2723 return false;
2724 }
2725 *destination_connection_id_length = dcil;
2726 *source_connection_id_length = scil;
2727 return true;
2728}
2729
2730bool QuicFramer::ValidateReceivedConnectionIds(const QuicPacketHeader& header) {
2731 bool skip_server_connection_id_validation =
2732 perspective_ == Perspective::IS_CLIENT &&
2733 header.form == IETF_QUIC_SHORT_HEADER_PACKET;
2734 if (!skip_server_connection_id_validation &&
2735 !QuicUtils::IsConnectionIdValidForVersion(
2736 GetServerConnectionIdAsRecipient(header, perspective_),
2737 transport_version())) {
2738 set_detailed_error("Received server connection ID with invalid length.");
2739 return false;
2740 }
2741
2742 bool skip_client_connection_id_validation =
2743 perspective_ == Perspective::IS_SERVER &&
2744 header.form == IETF_QUIC_SHORT_HEADER_PACKET;
2745 if (!skip_client_connection_id_validation &&
2746 version_.SupportsClientConnectionIds() &&
2747 !QuicUtils::IsConnectionIdValidForVersion(
2748 GetClientConnectionIdAsRecipient(header, perspective_),
2749 transport_version())) {
2750 set_detailed_error("Received client connection ID with invalid length.");
2751 return false;
2752 }
2753 return true;
2754}
2755
2756bool QuicFramer::ProcessIetfPacketHeader(QuicDataReader* reader,
2757 QuicPacketHeader* header) {
2758 if (version_.HasLengthPrefixedConnectionIds()) {
2759 uint8_t expected_destination_connection_id_length =
2760 perspective_ == Perspective::IS_CLIENT
2761 ? expected_client_connection_id_length_
2762 : expected_server_connection_id_length_;
2763 QuicVersionLabel version_label;
2764 bool has_length_prefix;
2765 std::string detailed_error;
2766 QuicErrorCode parse_result = QuicFramer::ParsePublicHeader(
2767 reader, expected_destination_connection_id_length,
2768 version_.HasIetfInvariantHeader(), &header->type_byte, &header->form,
2769 &header->version_flag, &has_length_prefix, &version_label,
2770 &header->version, &header->destination_connection_id,
2771 &header->source_connection_id, &header->long_packet_type,
2772 &header->retry_token_length_length, &header->retry_token,
2773 &detailed_error);
2774 if (parse_result != QUIC_NO_ERROR) {
2775 set_detailed_error(detailed_error);
2776 return false;
2777 }
2778 header->destination_connection_id_included = CONNECTION_ID_PRESENT;
2779 header->source_connection_id_included =
2780 header->version_flag ? CONNECTION_ID_PRESENT : CONNECTION_ID_ABSENT;
2781
2782 if (!ValidateReceivedConnectionIds(*header)) {
2783 return false;
2784 }
2785
2786 if (header->version_flag &&
2787 header->long_packet_type != VERSION_NEGOTIATION &&
2788 !(header->type_byte & FLAGS_FIXED_BIT)) {
2789 set_detailed_error("Fixed bit is 0 in long header.");
2790 return false;
2791 }
2792 if (!header->version_flag && !(header->type_byte & FLAGS_FIXED_BIT)) {
2793 set_detailed_error("Fixed bit is 0 in short header.");
2794 return false;
2795 }
2796 if (!header->version_flag) {
2797 if (!version_.HasHeaderProtection()) {
2798 header->packet_number_length =
2799 GetShortHeaderPacketNumberLength(header->type_byte);
2800 }
2801 return true;
2802 }
2803 if (header->long_packet_type == RETRY) {
2804 if (!version().SupportsRetry()) {
2805 set_detailed_error("RETRY not supported in this version.");
2806 return false;
2807 }
2808 if (perspective_ == Perspective::IS_SERVER) {
2809 set_detailed_error("Client-initiated RETRY is invalid.");
2810 return false;
2811 }
2812 return true;
2813 }
2814 if (header->version.IsKnown() && !header->version.HasHeaderProtection()) {
2815 header->packet_number_length =
2816 GetLongHeaderPacketNumberLength(header->type_byte);
2817 }
2818
2819 return true;
2820 }
2821
2822 if (!ProcessIetfHeaderTypeByte(reader, header)) {
2823 return false;
2824 }
2825
2826 uint8_t destination_connection_id_length =
2827 header->destination_connection_id_included == CONNECTION_ID_PRESENT
2828 ? (perspective_ == Perspective::IS_SERVER
2829 ? expected_server_connection_id_length_
2830 : expected_client_connection_id_length_)
2831 : 0;
2832 uint8_t source_connection_id_length =
2833 header->source_connection_id_included == CONNECTION_ID_PRESENT
2834 ? (perspective_ == Perspective::IS_CLIENT
2835 ? expected_server_connection_id_length_
2836 : expected_client_connection_id_length_)
2837 : 0;
2838 if (header->form == IETF_QUIC_LONG_HEADER_PACKET) {
2839 if (!ProcessAndValidateIetfConnectionIdLength(
2840 reader, header->version, perspective_,
2841 /*should_update_expected_server_connection_id_length=*/false,
2842 &expected_server_connection_id_length_,
2843 &destination_connection_id_length, &source_connection_id_length,
2844 &detailed_error_)) {
2845 return false;
2846 }
2847 }
2848
2849 // Read connection ID.
2850 if (!reader->ReadConnectionId(&header->destination_connection_id,
2851 destination_connection_id_length)) {
2852 set_detailed_error("Unable to read destination connection ID.");
2853 return false;
2854 }
2855
2856 if (!reader->ReadConnectionId(&header->source_connection_id,
2857 source_connection_id_length)) {
2858 set_detailed_error("Unable to read source connection ID.");
2859 return false;
2860 }
2861
2862 if (header->source_connection_id_included == CONNECTION_ID_ABSENT) {
2863 if (!header->source_connection_id.IsEmpty()) {
2864 QUICHE_DCHECK(!version_.SupportsClientConnectionIds());
2865 set_detailed_error("Client connection ID not supported in this version.");
2866 return false;
2867 }
2868 }
2869
2870 return ValidateReceivedConnectionIds(*header);
2871}
2872
2873bool QuicFramer::ProcessAndCalculatePacketNumber(
2874 QuicDataReader* reader, QuicPacketNumberLength packet_number_length,
2875 QuicPacketNumber base_packet_number, uint64_t* packet_number) {
2876 uint64_t wire_packet_number;
2877 if (!reader->ReadBytesToUInt64(packet_number_length, &wire_packet_number)) {
2878 return false;
2879 }
2880
2881 // TODO(ianswett): Explore the usefulness of trying multiple packet numbers
2882 // in case the first guess is incorrect.
2883 *packet_number = CalculatePacketNumberFromWire(
2884 packet_number_length, base_packet_number, wire_packet_number);
2885 return true;
2886}
2887
2888bool QuicFramer::ProcessFrameData(QuicDataReader* reader,
2889 const QuicPacketHeader& header) {
2890 QUICHE_DCHECK(!VersionHasIetfQuicFrames(version_.transport_version))
2891 << "IETF QUIC Framing negotiated but attempting to process frames as "
2892 "non-IETF QUIC.";
2893 if (reader->IsDoneReading()) {
2894 set_detailed_error("Packet has no frames.");
2895 return RaiseError(QUIC_MISSING_PAYLOAD);
2896 }
2897 QUIC_DVLOG(2) << ENDPOINT << "Processing packet with header " << header;
2898 while (!reader->IsDoneReading()) {
2899 uint8_t frame_type;
2900 if (!reader->ReadBytes(&frame_type, 1)) {
2901 set_detailed_error("Unable to read frame type.");
2902 return RaiseError(QUIC_INVALID_FRAME_DATA);
2903 }
2904 const uint8_t special_mask = version_.HasIetfInvariantHeader()
2905 ? kQuicFrameTypeSpecialMask
2906 : kQuicFrameTypeBrokenMask;
2907 if (frame_type & special_mask) {
2908 // Stream Frame
2909 if (frame_type & kQuicFrameTypeStreamMask) {
2910 QuicStreamFrame frame;
2911 if (!ProcessStreamFrame(reader, frame_type, &frame)) {
2912 return RaiseError(QUIC_INVALID_STREAM_DATA);
2913 }
2914 QUIC_DVLOG(2) << ENDPOINT << "Processing stream frame " << frame;
2915 if (!visitor_->OnStreamFrame(frame)) {
2916 QUIC_DVLOG(1) << ENDPOINT
2917 << "Visitor asked to stop further processing.";
2918 // Returning true since there was no parsing error.
2919 return true;
2920 }
2921 continue;
2922 }
2923
2924 // Ack Frame
2925 if (frame_type & kQuicFrameTypeAckMask) {
2926 if (!ProcessAckFrame(reader, frame_type)) {
2927 return RaiseError(QUIC_INVALID_ACK_DATA);
2928 }
2929 QUIC_DVLOG(2) << ENDPOINT << "Processing ACK frame";
2930 continue;
2931 }
2932
2933 // This was a special frame type that did not match any
2934 // of the known ones. Error.
2935 set_detailed_error("Illegal frame type.");
2936 QUIC_DLOG(WARNING) << ENDPOINT << "Illegal frame type: "
2937 << static_cast<int>(frame_type);
2938 return RaiseError(QUIC_INVALID_FRAME_DATA);
2939 }
2940
2941 switch (frame_type) {
2942 case PADDING_FRAME: {
2943 QuicPaddingFrame frame;
2944 ProcessPaddingFrame(reader, &frame);
2945 QUIC_DVLOG(2) << ENDPOINT << "Processing padding frame " << frame;
2946 if (!visitor_->OnPaddingFrame(frame)) {
2947 QUIC_DVLOG(1) << "Visitor asked to stop further processing.";
2948 // Returning true since there was no parsing error.
2949 return true;
2950 }
2951 continue;
2952 }
2953
2954 case RST_STREAM_FRAME: {
2955 QuicRstStreamFrame frame;
2956 if (!ProcessRstStreamFrame(reader, &frame)) {
2957 return RaiseError(QUIC_INVALID_RST_STREAM_DATA);
2958 }
2959 QUIC_DVLOG(2) << ENDPOINT << "Processing reset stream frame " << frame;
2960 if (!visitor_->OnRstStreamFrame(frame)) {
2961 QUIC_DVLOG(1) << "Visitor asked to stop further processing.";
2962 // Returning true since there was no parsing error.
2963 return true;
2964 }
2965 continue;
2966 }
2967
2968 case CONNECTION_CLOSE_FRAME: {
2969 QuicConnectionCloseFrame frame;
2970 if (!ProcessConnectionCloseFrame(reader, &frame)) {
2971 return RaiseError(QUIC_INVALID_CONNECTION_CLOSE_DATA);
2972 }
2973
2974 QUIC_DVLOG(2) << ENDPOINT << "Processing connection close frame "
2975 << frame;
2976 if (!visitor_->OnConnectionCloseFrame(frame)) {
2977 QUIC_DVLOG(1) << ENDPOINT
2978 << "Visitor asked to stop further processing.";
2979 // Returning true since there was no parsing error.
2980 return true;
2981 }
2982 continue;
2983 }
2984
2985 case GOAWAY_FRAME: {
2986 QuicGoAwayFrame goaway_frame;
2987 if (!ProcessGoAwayFrame(reader, &goaway_frame)) {
2988 return RaiseError(QUIC_INVALID_GOAWAY_DATA);
2989 }
2990 QUIC_DVLOG(2) << ENDPOINT << "Processing go away frame "
2991 << goaway_frame;
2992 if (!visitor_->OnGoAwayFrame(goaway_frame)) {
2993 QUIC_DVLOG(1) << ENDPOINT
2994 << "Visitor asked to stop further processing.";
2995 // Returning true since there was no parsing error.
2996 return true;
2997 }
2998 continue;
2999 }
3000
3001 case WINDOW_UPDATE_FRAME: {
3002 QuicWindowUpdateFrame window_update_frame;
3003 if (!ProcessWindowUpdateFrame(reader, &window_update_frame)) {
3004 return RaiseError(QUIC_INVALID_WINDOW_UPDATE_DATA);
3005 }
3006 QUIC_DVLOG(2) << ENDPOINT << "Processing window update frame "
3007 << window_update_frame;
3008 if (!visitor_->OnWindowUpdateFrame(window_update_frame)) {
3009 QUIC_DVLOG(1) << ENDPOINT
3010 << "Visitor asked to stop further processing.";
3011 // Returning true since there was no parsing error.
3012 return true;
3013 }
3014 continue;
3015 }
3016
3017 case BLOCKED_FRAME: {
3018 QuicBlockedFrame blocked_frame;
3019 if (!ProcessBlockedFrame(reader, &blocked_frame)) {
3020 return RaiseError(QUIC_INVALID_BLOCKED_DATA);
3021 }
3022 QUIC_DVLOG(2) << ENDPOINT << "Processing blocked frame "
3023 << blocked_frame;
3024 if (!visitor_->OnBlockedFrame(blocked_frame)) {
3025 QUIC_DVLOG(1) << ENDPOINT
3026 << "Visitor asked to stop further processing.";
3027 // Returning true since there was no parsing error.
3028 return true;
3029 }
3030 continue;
3031 }
3032
3033 case STOP_WAITING_FRAME: {
3034 QuicStopWaitingFrame stop_waiting_frame;
3035 if (!ProcessStopWaitingFrame(reader, header, &stop_waiting_frame)) {
3036 return RaiseError(QUIC_INVALID_STOP_WAITING_DATA);
3037 }
3038 QUIC_DVLOG(2) << ENDPOINT << "Processing stop waiting frame "
3039 << stop_waiting_frame;
3040 if (!visitor_->OnStopWaitingFrame(stop_waiting_frame)) {
3041 QUIC_DVLOG(1) << ENDPOINT
3042 << "Visitor asked to stop further processing.";
3043 // Returning true since there was no parsing error.
3044 return true;
3045 }
3046 continue;
3047 }
3048 case PING_FRAME: {
3049 // Ping has no payload.
3050 QuicPingFrame ping_frame;
3051 if (!visitor_->OnPingFrame(ping_frame)) {
3052 QUIC_DVLOG(1) << ENDPOINT
3053 << "Visitor asked to stop further processing.";
3054 // Returning true since there was no parsing error.
3055 return true;
3056 }
3057 QUIC_DVLOG(2) << ENDPOINT << "Processing ping frame " << ping_frame;
3058 continue;
3059 }
3060 case IETF_EXTENSION_MESSAGE_NO_LENGTH:
3061 ABSL_FALLTHROUGH_INTENDED;
3062 case IETF_EXTENSION_MESSAGE: {
3063 QuicMessageFrame message_frame;
3064 if (!ProcessMessageFrame(reader,
3065 frame_type == IETF_EXTENSION_MESSAGE_NO_LENGTH,
3066 &message_frame)) {
3067 return RaiseError(QUIC_INVALID_MESSAGE_DATA);
3068 }
3069 QUIC_DVLOG(2) << ENDPOINT << "Processing message frame "
3070 << message_frame;
3071 if (!visitor_->OnMessageFrame(message_frame)) {
3072 QUIC_DVLOG(1) << ENDPOINT
3073 << "Visitor asked to stop further processing.";
3074 // Returning true since there was no parsing error.
3075 return true;
3076 }
3077 break;
3078 }
3079 case CRYPTO_FRAME: {
3080 if (!QuicVersionUsesCryptoFrames(version_.transport_version)) {
3081 set_detailed_error("Illegal frame type.");
3082 return RaiseError(QUIC_INVALID_FRAME_DATA);
3083 }
3084 QuicCryptoFrame frame;
3085 if (!ProcessCryptoFrame(reader, GetEncryptionLevel(header), &frame)) {
3086 return RaiseError(QUIC_INVALID_FRAME_DATA);
3087 }
3088 QUIC_DVLOG(2) << ENDPOINT << "Processing crypto frame " << frame;
3089 if (!visitor_->OnCryptoFrame(frame)) {
3090 QUIC_DVLOG(1) << "Visitor asked to stop further processing.";
3091 // Returning true since there was no parsing error.
3092 return true;
3093 }
3094 break;
3095 }
3096 case HANDSHAKE_DONE_FRAME: {
3097 // HANDSHAKE_DONE has no payload.
3098 QuicHandshakeDoneFrame handshake_done_frame;
3099 QUIC_DVLOG(2) << ENDPOINT << "Processing handshake done frame "
3100 << handshake_done_frame;
3101 if (!visitor_->OnHandshakeDoneFrame(handshake_done_frame)) {
3102 QUIC_DVLOG(1) << ENDPOINT
3103 << "Visitor asked to stop further processing.";
3104 // Returning true since there was no parsing error.
3105 return true;
3106 }
3107 break;
3108 }
3109
3110 default:
3111 set_detailed_error("Illegal frame type.");
3112 QUIC_DLOG(WARNING) << ENDPOINT << "Illegal frame type: "
3113 << static_cast<int>(frame_type);
3114 return RaiseError(QUIC_INVALID_FRAME_DATA);
3115 }
3116 }
3117
3118 return true;
3119}
3120
3121// static
3122bool QuicFramer::IsIetfFrameTypeExpectedForEncryptionLevel(
3123 uint64_t frame_type, EncryptionLevel level) {
haoyuewang3d173d52022-04-27 12:20:25 -07003124 // IETF_CRYPTO is allowed for any level here and is separately checked in
3125 // QuicCryptoStream::OnCryptoFrame.
Bence Békybac04052022-04-07 15:44:29 -04003126 switch (level) {
3127 case ENCRYPTION_INITIAL:
3128 case ENCRYPTION_HANDSHAKE:
3129 return frame_type == IETF_CRYPTO || frame_type == IETF_ACK ||
3130 frame_type == IETF_ACK_ECN ||
3131 frame_type == IETF_ACK_RECEIVE_TIMESTAMPS ||
3132 frame_type == IETF_PING || frame_type == IETF_PADDING ||
3133 frame_type == IETF_CONNECTION_CLOSE;
3134 case ENCRYPTION_ZERO_RTT:
3135 return !(frame_type == IETF_ACK || frame_type == IETF_ACK_ECN ||
3136 frame_type == IETF_ACK_RECEIVE_TIMESTAMPS ||
haoyuewang3d173d52022-04-27 12:20:25 -07003137 frame_type == IETF_HANDSHAKE_DONE ||
Bence Békybac04052022-04-07 15:44:29 -04003138 frame_type == IETF_NEW_TOKEN ||
3139 frame_type == IETF_PATH_RESPONSE ||
3140 frame_type == IETF_RETIRE_CONNECTION_ID);
3141 case ENCRYPTION_FORWARD_SECURE:
3142 return true;
3143 default:
3144 QUIC_BUG(quic_bug_10850_57) << "Unknown encryption level: " << level;
3145 }
3146 return false;
3147}
3148
3149bool QuicFramer::ProcessIetfFrameData(QuicDataReader* reader,
3150 const QuicPacketHeader& header,
3151 EncryptionLevel decrypted_level) {
3152 QUICHE_DCHECK(VersionHasIetfQuicFrames(version_.transport_version))
3153 << "Attempt to process frames as IETF frames but version ("
3154 << version_.transport_version << ") does not support IETF Framing.";
3155
3156 if (reader->IsDoneReading()) {
3157 set_detailed_error("Packet has no frames.");
3158 return RaiseError(QUIC_MISSING_PAYLOAD);
3159 }
3160
3161 QUIC_DVLOG(2) << ENDPOINT << "Processing IETF packet with header " << header;
3162 while (!reader->IsDoneReading()) {
3163 uint64_t frame_type;
3164 // Will be the number of bytes into which frame_type was encoded.
3165 size_t encoded_bytes = reader->BytesRemaining();
3166 if (!reader->ReadVarInt62(&frame_type)) {
3167 set_detailed_error("Unable to read frame type.");
3168 return RaiseError(QUIC_INVALID_FRAME_DATA);
3169 }
3170 if (!IsIetfFrameTypeExpectedForEncryptionLevel(frame_type,
3171 decrypted_level)) {
3172 set_detailed_error(absl::StrCat(
3173 "IETF frame type ",
3174 QuicIetfFrameTypeString(static_cast<QuicIetfFrameType>(frame_type)),
3175 " is unexpected at encryption level ",
3176 EncryptionLevelToString(decrypted_level)));
3177 return RaiseError(IETF_QUIC_PROTOCOL_VIOLATION);
3178 }
3179 previously_received_frame_type_ = current_received_frame_type_;
3180 current_received_frame_type_ = frame_type;
3181
3182 // Is now the number of bytes into which the frame type was encoded.
3183 encoded_bytes -= reader->BytesRemaining();
3184
3185 // Check that the frame type is minimally encoded.
3186 if (encoded_bytes !=
3187 static_cast<size_t>(QuicDataWriter::GetVarInt62Len(frame_type))) {
3188 // The frame type was not minimally encoded.
3189 set_detailed_error("Frame type not minimally encoded.");
3190 return RaiseError(IETF_QUIC_PROTOCOL_VIOLATION);
3191 }
3192
3193 if (IS_IETF_STREAM_FRAME(frame_type)) {
3194 QuicStreamFrame frame;
3195 if (!ProcessIetfStreamFrame(reader, frame_type, &frame)) {
3196 return RaiseError(QUIC_INVALID_STREAM_DATA);
3197 }
3198 QUIC_DVLOG(2) << ENDPOINT << "Processing IETF stream frame " << frame;
3199 if (!visitor_->OnStreamFrame(frame)) {
3200 QUIC_DVLOG(1) << ENDPOINT
3201 << "Visitor asked to stop further processing.";
3202 // Returning true since there was no parsing error.
3203 return true;
3204 }
3205 } else {
3206 switch (frame_type) {
3207 case IETF_PADDING: {
3208 QuicPaddingFrame frame;
3209 ProcessPaddingFrame(reader, &frame);
3210 QUIC_DVLOG(2) << ENDPOINT << "Processing IETF padding frame "
3211 << frame;
3212 if (!visitor_->OnPaddingFrame(frame)) {
3213 QUIC_DVLOG(1) << "Visitor asked to stop further processing.";
3214 // Returning true since there was no parsing error.
3215 return true;
3216 }
3217 break;
3218 }
3219 case IETF_RST_STREAM: {
3220 QuicRstStreamFrame frame;
3221 if (!ProcessIetfResetStreamFrame(reader, &frame)) {
3222 return RaiseError(QUIC_INVALID_RST_STREAM_DATA);
3223 }
3224 QUIC_DVLOG(2) << ENDPOINT << "Processing IETF reset stream frame "
3225 << frame;
3226 if (!visitor_->OnRstStreamFrame(frame)) {
3227 QUIC_DVLOG(1) << "Visitor asked to stop further processing.";
3228 // Returning true since there was no parsing error.
3229 return true;
3230 }
3231 break;
3232 }
3233 case IETF_APPLICATION_CLOSE:
3234 case IETF_CONNECTION_CLOSE: {
3235 QuicConnectionCloseFrame frame;
3236 if (!ProcessIetfConnectionCloseFrame(
3237 reader,
3238 (frame_type == IETF_CONNECTION_CLOSE)
3239 ? IETF_QUIC_TRANSPORT_CONNECTION_CLOSE
3240 : IETF_QUIC_APPLICATION_CONNECTION_CLOSE,
3241 &frame)) {
3242 return RaiseError(QUIC_INVALID_CONNECTION_CLOSE_DATA);
3243 }
3244 QUIC_DVLOG(2) << ENDPOINT << "Processing IETF connection close frame "
3245 << frame;
3246 if (!visitor_->OnConnectionCloseFrame(frame)) {
3247 QUIC_DVLOG(1) << "Visitor asked to stop further processing.";
3248 // Returning true since there was no parsing error.
3249 return true;
3250 }
3251 break;
3252 }
3253 case IETF_MAX_DATA: {
3254 QuicWindowUpdateFrame frame;
3255 if (!ProcessMaxDataFrame(reader, &frame)) {
3256 return RaiseError(QUIC_INVALID_MAX_DATA_FRAME_DATA);
3257 }
3258 QUIC_DVLOG(2) << ENDPOINT << "Processing IETF max data frame "
3259 << frame;
3260 if (!visitor_->OnWindowUpdateFrame(frame)) {
3261 QUIC_DVLOG(1) << "Visitor asked to stop further processing.";
3262 // Returning true since there was no parsing error.
3263 return true;
3264 }
3265 break;
3266 }
3267 case IETF_MAX_STREAM_DATA: {
3268 QuicWindowUpdateFrame frame;
3269 if (!ProcessMaxStreamDataFrame(reader, &frame)) {
3270 return RaiseError(QUIC_INVALID_MAX_STREAM_DATA_FRAME_DATA);
3271 }
3272 QUIC_DVLOG(2) << ENDPOINT << "Processing IETF max stream data frame "
3273 << frame;
3274 if (!visitor_->OnWindowUpdateFrame(frame)) {
3275 QUIC_DVLOG(1) << "Visitor asked to stop further processing.";
3276 // Returning true since there was no parsing error.
3277 return true;
3278 }
3279 break;
3280 }
3281 case IETF_MAX_STREAMS_BIDIRECTIONAL:
3282 case IETF_MAX_STREAMS_UNIDIRECTIONAL: {
3283 QuicMaxStreamsFrame frame;
3284 if (!ProcessMaxStreamsFrame(reader, &frame, frame_type)) {
3285 return RaiseError(QUIC_MAX_STREAMS_DATA);
3286 }
3287 QUIC_CODE_COUNT_N(quic_max_streams_received, 1, 2);
3288 QUIC_DVLOG(2) << ENDPOINT << "Processing IETF max streams frame "
3289 << frame;
3290 if (!visitor_->OnMaxStreamsFrame(frame)) {
3291 QUIC_DVLOG(1) << "Visitor asked to stop further processing.";
3292 // Returning true since there was no parsing error.
3293 return true;
3294 }
3295 break;
3296 }
3297 case IETF_PING: {
3298 // Ping has no payload.
3299 QuicPingFrame ping_frame;
3300 QUIC_DVLOG(2) << ENDPOINT << "Processing IETF ping frame "
3301 << ping_frame;
3302 if (!visitor_->OnPingFrame(ping_frame)) {
3303 QUIC_DVLOG(1) << "Visitor asked to stop further processing.";
3304 // Returning true since there was no parsing error.
3305 return true;
3306 }
3307 break;
3308 }
3309 case IETF_DATA_BLOCKED: {
3310 QuicBlockedFrame frame;
3311 if (!ProcessDataBlockedFrame(reader, &frame)) {
3312 return RaiseError(QUIC_INVALID_BLOCKED_DATA);
3313 }
3314 QUIC_DVLOG(2) << ENDPOINT << "Processing IETF blocked frame "
3315 << frame;
3316 if (!visitor_->OnBlockedFrame(frame)) {
3317 QUIC_DVLOG(1) << "Visitor asked to stop further processing.";
3318 // Returning true since there was no parsing error.
3319 return true;
3320 }
3321 break;
3322 }
3323 case IETF_STREAM_DATA_BLOCKED: {
3324 QuicBlockedFrame frame;
3325 if (!ProcessStreamDataBlockedFrame(reader, &frame)) {
3326 return RaiseError(QUIC_INVALID_STREAM_BLOCKED_DATA);
3327 }
3328 QUIC_DVLOG(2) << ENDPOINT << "Processing IETF stream blocked frame "
3329 << frame;
3330 if (!visitor_->OnBlockedFrame(frame)) {
3331 QUIC_DVLOG(1) << "Visitor asked to stop further processing.";
3332 // Returning true since there was no parsing error.
3333 return true;
3334 }
3335 break;
3336 }
3337 case IETF_STREAMS_BLOCKED_UNIDIRECTIONAL:
3338 case IETF_STREAMS_BLOCKED_BIDIRECTIONAL: {
3339 QuicStreamsBlockedFrame frame;
3340 if (!ProcessStreamsBlockedFrame(reader, &frame, frame_type)) {
3341 return RaiseError(QUIC_STREAMS_BLOCKED_DATA);
3342 }
3343 QUIC_DVLOG(2) << ENDPOINT << "Processing IETF streams blocked frame "
3344 << frame;
3345 if (!visitor_->OnStreamsBlockedFrame(frame)) {
3346 QUIC_DVLOG(1) << "Visitor asked to stop further processing.";
3347 // Returning true since there was no parsing error.
3348 return true;
3349 }
3350 break;
3351 }
3352 case IETF_NEW_CONNECTION_ID: {
3353 QuicNewConnectionIdFrame frame;
3354 if (!ProcessNewConnectionIdFrame(reader, &frame)) {
3355 return RaiseError(QUIC_INVALID_NEW_CONNECTION_ID_DATA);
3356 }
3357 QUIC_DVLOG(2) << ENDPOINT
3358 << "Processing IETF new connection ID frame " << frame;
3359 if (!visitor_->OnNewConnectionIdFrame(frame)) {
3360 QUIC_DVLOG(1) << "Visitor asked to stop further processing.";
3361 // Returning true since there was no parsing error.
3362 return true;
3363 }
3364 break;
3365 }
3366 case IETF_RETIRE_CONNECTION_ID: {
3367 QuicRetireConnectionIdFrame frame;
3368 if (!ProcessRetireConnectionIdFrame(reader, &frame)) {
3369 return RaiseError(QUIC_INVALID_RETIRE_CONNECTION_ID_DATA);
3370 }
3371 QUIC_DVLOG(2) << ENDPOINT
3372 << "Processing IETF retire connection ID frame "
3373 << frame;
3374 if (!visitor_->OnRetireConnectionIdFrame(frame)) {
3375 QUIC_DVLOG(1) << "Visitor asked to stop further processing.";
3376 // Returning true since there was no parsing error.
3377 return true;
3378 }
3379 break;
3380 }
3381 case IETF_NEW_TOKEN: {
3382 QuicNewTokenFrame frame;
3383 if (!ProcessNewTokenFrame(reader, &frame)) {
3384 return RaiseError(QUIC_INVALID_NEW_TOKEN);
3385 }
3386 QUIC_DVLOG(2) << ENDPOINT << "Processing IETF new token frame "
3387 << frame;
3388 if (!visitor_->OnNewTokenFrame(frame)) {
3389 QUIC_DVLOG(1) << "Visitor asked to stop further processing.";
3390 // Returning true since there was no parsing error.
3391 return true;
3392 }
3393 break;
3394 }
3395 case IETF_STOP_SENDING: {
3396 QuicStopSendingFrame frame;
3397 if (!ProcessStopSendingFrame(reader, &frame)) {
3398 return RaiseError(QUIC_INVALID_STOP_SENDING_FRAME_DATA);
3399 }
3400 QUIC_DVLOG(2) << ENDPOINT << "Processing IETF stop sending frame "
3401 << frame;
3402 if (!visitor_->OnStopSendingFrame(frame)) {
3403 QUIC_DVLOG(1) << "Visitor asked to stop further processing.";
3404 // Returning true since there was no parsing error.
3405 return true;
3406 }
3407 break;
3408 }
3409 case IETF_ACK_RECEIVE_TIMESTAMPS:
3410 if (!process_timestamps_) {
3411 set_detailed_error("Unsupported frame type.");
3412 QUIC_DLOG(WARNING)
3413 << ENDPOINT << "IETF_ACK_RECEIVE_TIMESTAMPS not supported";
3414 return RaiseError(QUIC_INVALID_FRAME_DATA);
3415 }
3416 ABSL_FALLTHROUGH_INTENDED;
3417 case IETF_ACK_ECN:
3418 case IETF_ACK: {
3419 QuicAckFrame frame;
3420 if (!ProcessIetfAckFrame(reader, frame_type, &frame)) {
3421 return RaiseError(QUIC_INVALID_ACK_DATA);
3422 }
3423 QUIC_DVLOG(2) << ENDPOINT << "Processing IETF ACK frame " << frame;
3424 break;
3425 }
3426 case IETF_PATH_CHALLENGE: {
3427 QuicPathChallengeFrame frame;
3428 if (!ProcessPathChallengeFrame(reader, &frame)) {
3429 return RaiseError(QUIC_INVALID_PATH_CHALLENGE_DATA);
3430 }
3431 QUIC_DVLOG(2) << ENDPOINT << "Processing IETF path challenge frame "
3432 << frame;
3433 if (!visitor_->OnPathChallengeFrame(frame)) {
3434 QUIC_DVLOG(1) << "Visitor asked to stop further processing.";
3435 // Returning true since there was no parsing error.
3436 return true;
3437 }
3438 break;
3439 }
3440 case IETF_PATH_RESPONSE: {
3441 QuicPathResponseFrame frame;
3442 if (!ProcessPathResponseFrame(reader, &frame)) {
3443 return RaiseError(QUIC_INVALID_PATH_RESPONSE_DATA);
3444 }
3445 QUIC_DVLOG(2) << ENDPOINT << "Processing IETF path response frame "
3446 << frame;
3447 if (!visitor_->OnPathResponseFrame(frame)) {
3448 QUIC_DVLOG(1) << "Visitor asked to stop further processing.";
3449 // Returning true since there was no parsing error.
3450 return true;
3451 }
3452 break;
3453 }
3454 case IETF_EXTENSION_MESSAGE_NO_LENGTH_V99:
3455 ABSL_FALLTHROUGH_INTENDED;
3456 case IETF_EXTENSION_MESSAGE_V99: {
3457 QuicMessageFrame message_frame;
3458 if (!ProcessMessageFrame(
3459 reader, frame_type == IETF_EXTENSION_MESSAGE_NO_LENGTH_V99,
3460 &message_frame)) {
3461 return RaiseError(QUIC_INVALID_MESSAGE_DATA);
3462 }
3463 QUIC_DVLOG(2) << ENDPOINT << "Processing IETF message frame "
3464 << message_frame;
3465 if (!visitor_->OnMessageFrame(message_frame)) {
3466 QUIC_DVLOG(1) << ENDPOINT
3467 << "Visitor asked to stop further processing.";
3468 // Returning true since there was no parsing error.
3469 return true;
3470 }
3471 break;
3472 }
3473 case IETF_CRYPTO: {
3474 QuicCryptoFrame frame;
3475 if (!ProcessCryptoFrame(reader, GetEncryptionLevel(header), &frame)) {
3476 return RaiseError(QUIC_INVALID_FRAME_DATA);
3477 }
3478 QUIC_DVLOG(2) << ENDPOINT << "Processing IETF crypto frame " << frame;
3479 if (!visitor_->OnCryptoFrame(frame)) {
3480 QUIC_DVLOG(1) << "Visitor asked to stop further processing.";
3481 // Returning true since there was no parsing error.
3482 return true;
3483 }
3484 break;
3485 }
3486 case IETF_HANDSHAKE_DONE: {
3487 // HANDSHAKE_DONE has no payload.
3488 QuicHandshakeDoneFrame handshake_done_frame;
3489 if (!visitor_->OnHandshakeDoneFrame(handshake_done_frame)) {
3490 QUIC_DVLOG(1) << ENDPOINT
3491 << "Visitor asked to stop further processing.";
3492 // Returning true since there was no parsing error.
3493 return true;
3494 }
3495 QUIC_DVLOG(2) << ENDPOINT << "Processing handshake done frame "
3496 << handshake_done_frame;
3497 break;
3498 }
3499 case IETF_ACK_FREQUENCY: {
3500 QuicAckFrequencyFrame frame;
3501 if (!ProcessAckFrequencyFrame(reader, &frame)) {
3502 return RaiseError(QUIC_INVALID_FRAME_DATA);
3503 }
3504 QUIC_DVLOG(2) << ENDPOINT << "Processing IETF ack frequency frame "
3505 << frame;
3506 if (!visitor_->OnAckFrequencyFrame(frame)) {
3507 QUIC_DVLOG(1) << "Visitor asked to stop further processing.";
3508 // Returning true since there was no parsing error.
3509 return true;
3510 }
3511 break;
3512 }
3513 default:
3514 set_detailed_error("Illegal frame type.");
3515 QUIC_DLOG(WARNING)
3516 << ENDPOINT
3517 << "Illegal frame type: " << static_cast<int>(frame_type);
3518 return RaiseError(QUIC_INVALID_FRAME_DATA);
3519 }
3520 }
3521 }
3522 return true;
3523}
3524
3525namespace {
3526// Create a mask that sets the last |num_bits| to 1 and the rest to 0.
3527inline uint8_t GetMaskFromNumBits(uint8_t num_bits) {
3528 return (1u << num_bits) - 1;
3529}
3530
3531// Extract |num_bits| from |flags| offset by |offset|.
3532uint8_t ExtractBits(uint8_t flags, uint8_t num_bits, uint8_t offset) {
3533 return (flags >> offset) & GetMaskFromNumBits(num_bits);
3534}
3535
3536// Extract the bit at position |offset| from |flags| as a bool.
3537bool ExtractBit(uint8_t flags, uint8_t offset) {
3538 return ((flags >> offset) & GetMaskFromNumBits(1)) != 0;
3539}
3540
3541// Set |num_bits|, offset by |offset| to |val| in |flags|.
3542void SetBits(uint8_t* flags, uint8_t val, uint8_t num_bits, uint8_t offset) {
3543 QUICHE_DCHECK_LE(val, GetMaskFromNumBits(num_bits));
3544 *flags |= val << offset;
3545}
3546
3547// Set the bit at position |offset| to |val| in |flags|.
3548void SetBit(uint8_t* flags, bool val, uint8_t offset) {
3549 SetBits(flags, val ? 1 : 0, 1, offset);
3550}
3551} // namespace
3552
3553bool QuicFramer::ProcessStreamFrame(QuicDataReader* reader, uint8_t frame_type,
3554 QuicStreamFrame* frame) {
3555 uint8_t stream_flags = frame_type;
3556
3557 uint8_t stream_id_length = 0;
3558 uint8_t offset_length = 4;
3559 bool has_data_length = true;
3560 stream_flags &= ~kQuicFrameTypeStreamMask;
3561
3562 // Read from right to left: StreamID, Offset, Data Length, Fin.
3563 stream_id_length = (stream_flags & kQuicStreamIDLengthMask) + 1;
3564 stream_flags >>= kQuicStreamIdShift;
3565
3566 offset_length = (stream_flags & kQuicStreamOffsetMask);
3567 // There is no encoding for 1 byte, only 0 and 2 through 8.
3568 if (offset_length > 0) {
3569 offset_length += 1;
3570 }
3571 stream_flags >>= kQuicStreamShift;
3572
3573 has_data_length =
3574 (stream_flags & kQuicStreamDataLengthMask) == kQuicStreamDataLengthMask;
3575 stream_flags >>= kQuicStreamDataLengthShift;
3576
3577 frame->fin = (stream_flags & kQuicStreamFinMask) == kQuicStreamFinShift;
3578
3579 uint64_t stream_id;
3580 if (!reader->ReadBytesToUInt64(stream_id_length, &stream_id)) {
3581 set_detailed_error("Unable to read stream_id.");
3582 return false;
3583 }
3584 frame->stream_id = static_cast<QuicStreamId>(stream_id);
3585
3586 if (!reader->ReadBytesToUInt64(offset_length, &frame->offset)) {
3587 set_detailed_error("Unable to read offset.");
3588 return false;
3589 }
3590
3591 // TODO(ianswett): Don't use absl::string_view as an intermediary.
3592 absl::string_view data;
3593 if (has_data_length) {
3594 if (!reader->ReadStringPiece16(&data)) {
3595 set_detailed_error("Unable to read frame data.");
3596 return false;
3597 }
3598 } else {
3599 if (!reader->ReadStringPiece(&data, reader->BytesRemaining())) {
3600 set_detailed_error("Unable to read frame data.");
3601 return false;
3602 }
3603 }
3604 frame->data_buffer = data.data();
3605 frame->data_length = static_cast<uint16_t>(data.length());
3606
3607 return true;
3608}
3609
3610bool QuicFramer::ProcessIetfStreamFrame(QuicDataReader* reader,
3611 uint8_t frame_type,
3612 QuicStreamFrame* frame) {
3613 // Read stream id from the frame. It's always present.
3614 if (!ReadUint32FromVarint62(reader, IETF_STREAM, &frame->stream_id)) {
3615 return false;
3616 }
3617
3618 // If we have a data offset, read it. If not, set to 0.
3619 if (frame_type & IETF_STREAM_FRAME_OFF_BIT) {
3620 if (!reader->ReadVarInt62(&frame->offset)) {
3621 set_detailed_error("Unable to read stream data offset.");
3622 return false;
3623 }
3624 } else {
3625 // no offset in the frame, ensure it's 0 in the Frame.
3626 frame->offset = 0;
3627 }
3628
3629 // If we have a data length, read it. If not, set to 0.
3630 if (frame_type & IETF_STREAM_FRAME_LEN_BIT) {
3631 uint64_t length;
3632 if (!reader->ReadVarInt62(&length)) {
3633 set_detailed_error("Unable to read stream data length.");
3634 return false;
3635 }
3636 if (length > std::numeric_limits<decltype(frame->data_length)>::max()) {
3637 set_detailed_error("Stream data length is too large.");
3638 return false;
3639 }
3640 frame->data_length = length;
3641 } else {
3642 // no length in the frame, it is the number of bytes remaining in the
3643 // packet.
3644 frame->data_length = reader->BytesRemaining();
3645 }
3646
3647 if (frame_type & IETF_STREAM_FRAME_FIN_BIT) {
3648 frame->fin = true;
3649 } else {
3650 frame->fin = false;
3651 }
3652
3653 // TODO(ianswett): Don't use absl::string_view as an intermediary.
3654 absl::string_view data;
3655 if (!reader->ReadStringPiece(&data, frame->data_length)) {
3656 set_detailed_error("Unable to read frame data.");
3657 return false;
3658 }
3659 frame->data_buffer = data.data();
3660 QUICHE_DCHECK_EQ(frame->data_length, data.length());
3661
3662 return true;
3663}
3664
3665bool QuicFramer::ProcessCryptoFrame(QuicDataReader* reader,
3666 EncryptionLevel encryption_level,
3667 QuicCryptoFrame* frame) {
3668 frame->level = encryption_level;
3669 if (!reader->ReadVarInt62(&frame->offset)) {
3670 set_detailed_error("Unable to read crypto data offset.");
3671 return false;
3672 }
3673 uint64_t len;
3674 if (!reader->ReadVarInt62(&len) ||
3675 len > std::numeric_limits<QuicPacketLength>::max()) {
3676 set_detailed_error("Invalid data length.");
3677 return false;
3678 }
3679 frame->data_length = len;
3680
3681 // TODO(ianswett): Don't use absl::string_view as an intermediary.
3682 absl::string_view data;
3683 if (!reader->ReadStringPiece(&data, frame->data_length)) {
3684 set_detailed_error("Unable to read frame data.");
3685 return false;
3686 }
3687 frame->data_buffer = data.data();
3688 return true;
3689}
3690
3691bool QuicFramer::ProcessAckFrequencyFrame(QuicDataReader* reader,
3692 QuicAckFrequencyFrame* frame) {
3693 if (!reader->ReadVarInt62(&frame->sequence_number)) {
3694 set_detailed_error("Unable to read sequence number.");
3695 return false;
3696 }
3697
3698 if (!reader->ReadVarInt62(&frame->packet_tolerance)) {
3699 set_detailed_error("Unable to read packet tolerance.");
3700 return false;
3701 }
3702 if (frame->packet_tolerance == 0) {
3703 set_detailed_error("Invalid packet tolerance.");
3704 return false;
3705 }
3706 uint64_t max_ack_delay_us;
3707 if (!reader->ReadVarInt62(&max_ack_delay_us)) {
3708 set_detailed_error("Unable to read max_ack_delay_us.");
3709 return false;
3710 }
3711 constexpr uint64_t kMaxAckDelayUsBound = 1u << 24;
3712 if (max_ack_delay_us > kMaxAckDelayUsBound) {
3713 set_detailed_error("Invalid max_ack_delay_us.");
3714 return false;
3715 }
3716 frame->max_ack_delay = QuicTime::Delta::FromMicroseconds(max_ack_delay_us);
3717
3718 uint8_t ignore_order;
3719 if (!reader->ReadUInt8(&ignore_order)) {
3720 set_detailed_error("Unable to read ignore_order.");
3721 return false;
3722 }
3723 if (ignore_order > 1) {
3724 set_detailed_error("Invalid ignore_order.");
3725 return false;
3726 }
3727 frame->ignore_order = ignore_order;
3728
3729 return true;
3730}
3731
3732bool QuicFramer::ProcessAckFrame(QuicDataReader* reader, uint8_t frame_type) {
3733 const bool has_ack_blocks =
3734 ExtractBit(frame_type, kQuicHasMultipleAckBlocksOffset);
3735 uint8_t num_ack_blocks = 0;
3736 uint8_t num_received_packets = 0;
3737
3738 // Determine the two lengths from the frame type: largest acked length,
3739 // ack block length.
3740 const QuicPacketNumberLength ack_block_length =
3741 ReadAckPacketNumberLength(ExtractBits(
3742 frame_type, kQuicSequenceNumberLengthNumBits, kActBlockLengthOffset));
3743 const QuicPacketNumberLength largest_acked_length =
3744 ReadAckPacketNumberLength(ExtractBits(
3745 frame_type, kQuicSequenceNumberLengthNumBits, kLargestAckedOffset));
3746
3747 uint64_t largest_acked;
3748 if (!reader->ReadBytesToUInt64(largest_acked_length, &largest_acked)) {
3749 set_detailed_error("Unable to read largest acked.");
3750 return false;
3751 }
3752
3753 if (largest_acked < first_sending_packet_number_.ToUint64()) {
3754 // Connection always sends packet starting from kFirstSendingPacketNumber >
3755 // 0, peer has observed an unsent packet.
3756 set_detailed_error("Largest acked is 0.");
3757 return false;
3758 }
3759
3760 uint64_t ack_delay_time_us;
3761 if (!reader->ReadUFloat16(&ack_delay_time_us)) {
3762 set_detailed_error("Unable to read ack delay time.");
3763 return false;
3764 }
3765
3766 if (!visitor_->OnAckFrameStart(
3767 QuicPacketNumber(largest_acked),
3768 ack_delay_time_us == kUFloat16MaxValue
3769 ? QuicTime::Delta::Infinite()
3770 : QuicTime::Delta::FromMicroseconds(ack_delay_time_us))) {
3771 // The visitor suppresses further processing of the packet. Although this is
3772 // not a parsing error, returns false as this is in middle of processing an
3773 // ack frame,
3774 set_detailed_error("Visitor suppresses further processing of ack frame.");
3775 return false;
3776 }
3777
3778 if (has_ack_blocks && !reader->ReadUInt8(&num_ack_blocks)) {
3779 set_detailed_error("Unable to read num of ack blocks.");
3780 return false;
3781 }
3782
3783 uint64_t first_block_length;
3784 if (!reader->ReadBytesToUInt64(ack_block_length, &first_block_length)) {
3785 set_detailed_error("Unable to read first ack block length.");
3786 return false;
3787 }
3788
3789 if (first_block_length == 0) {
3790 set_detailed_error("First block length is zero.");
3791 return false;
3792 }
3793 bool first_ack_block_underflow = first_block_length > largest_acked + 1;
3794 if (first_block_length + first_sending_packet_number_.ToUint64() >
3795 largest_acked + 1) {
3796 first_ack_block_underflow = true;
3797 }
3798 if (first_ack_block_underflow) {
3799 set_detailed_error(absl::StrCat("Underflow with first ack block length ",
3800 first_block_length, " largest acked is ",
3801 largest_acked, ".")
3802 .c_str());
3803 return false;
3804 }
3805
3806 uint64_t first_received = largest_acked + 1 - first_block_length;
3807 if (!visitor_->OnAckRange(QuicPacketNumber(first_received),
3808 QuicPacketNumber(largest_acked + 1))) {
3809 // The visitor suppresses further processing of the packet. Although
3810 // this is not a parsing error, returns false as this is in middle
3811 // of processing an ack frame,
3812 set_detailed_error("Visitor suppresses further processing of ack frame.");
3813 return false;
3814 }
3815
3816 if (num_ack_blocks > 0) {
3817 for (size_t i = 0; i < num_ack_blocks; ++i) {
3818 uint8_t gap = 0;
3819 if (!reader->ReadUInt8(&gap)) {
3820 set_detailed_error("Unable to read gap to next ack block.");
3821 return false;
3822 }
3823 uint64_t current_block_length;
3824 if (!reader->ReadBytesToUInt64(ack_block_length, &current_block_length)) {
3825 set_detailed_error("Unable to ack block length.");
3826 return false;
3827 }
3828 bool ack_block_underflow = first_received < gap + current_block_length;
3829 if (first_received < gap + current_block_length +
3830 first_sending_packet_number_.ToUint64()) {
3831 ack_block_underflow = true;
3832 }
3833 if (ack_block_underflow) {
3834 set_detailed_error(absl::StrCat("Underflow with ack block length ",
3835 current_block_length,
3836 ", end of block is ",
3837 first_received - gap, ".")
3838 .c_str());
3839 return false;
3840 }
3841
3842 first_received -= (gap + current_block_length);
3843 if (current_block_length > 0) {
3844 if (!visitor_->OnAckRange(
3845 QuicPacketNumber(first_received),
3846 QuicPacketNumber(first_received) + current_block_length)) {
3847 // The visitor suppresses further processing of the packet. Although
3848 // this is not a parsing error, returns false as this is in middle
3849 // of processing an ack frame,
3850 set_detailed_error(
3851 "Visitor suppresses further processing of ack frame.");
3852 return false;
3853 }
3854 }
3855 }
3856 }
3857
3858 if (!reader->ReadUInt8(&num_received_packets)) {
3859 set_detailed_error("Unable to read num received packets.");
3860 return false;
3861 }
3862
3863 if (!ProcessTimestampsInAckFrame(num_received_packets,
3864 QuicPacketNumber(largest_acked), reader)) {
3865 return false;
3866 }
3867
3868 // Done processing the ACK frame.
3869 if (!visitor_->OnAckFrameEnd(QuicPacketNumber(first_received))) {
3870 set_detailed_error(
3871 "Error occurs when visitor finishes processing the ACK frame.");
3872 return false;
3873 }
3874
3875 return true;
3876}
3877
3878bool QuicFramer::ProcessTimestampsInAckFrame(uint8_t num_received_packets,
3879 QuicPacketNumber largest_acked,
3880 QuicDataReader* reader) {
3881 if (num_received_packets == 0) {
3882 return true;
3883 }
3884 uint8_t delta_from_largest_observed;
3885 if (!reader->ReadUInt8(&delta_from_largest_observed)) {
3886 set_detailed_error("Unable to read sequence delta in received packets.");
3887 return false;
3888 }
3889
3890 if (largest_acked.ToUint64() <= delta_from_largest_observed) {
3891 set_detailed_error(
3892 absl::StrCat("delta_from_largest_observed too high: ",
3893 delta_from_largest_observed,
3894 ", largest_acked: ", largest_acked.ToUint64())
3895 .c_str());
3896 return false;
3897 }
3898
3899 // Time delta from the framer creation.
3900 uint32_t time_delta_us;
3901 if (!reader->ReadUInt32(&time_delta_us)) {
3902 set_detailed_error("Unable to read time delta in received packets.");
3903 return false;
3904 }
3905
3906 QuicPacketNumber seq_num = largest_acked - delta_from_largest_observed;
3907 if (process_timestamps_) {
3908 last_timestamp_ = CalculateTimestampFromWire(time_delta_us);
3909
3910 visitor_->OnAckTimestamp(seq_num, creation_time_ + last_timestamp_);
3911 }
3912
3913 for (uint8_t i = 1; i < num_received_packets; ++i) {
3914 if (!reader->ReadUInt8(&delta_from_largest_observed)) {
3915 set_detailed_error("Unable to read sequence delta in received packets.");
3916 return false;
3917 }
3918 if (largest_acked.ToUint64() <= delta_from_largest_observed) {
3919 set_detailed_error(
3920 absl::StrCat("delta_from_largest_observed too high: ",
3921 delta_from_largest_observed,
3922 ", largest_acked: ", largest_acked.ToUint64())
3923 .c_str());
3924 return false;
3925 }
3926 seq_num = largest_acked - delta_from_largest_observed;
3927
3928 // Time delta from the previous timestamp.
3929 uint64_t incremental_time_delta_us;
3930 if (!reader->ReadUFloat16(&incremental_time_delta_us)) {
3931 set_detailed_error(
3932 "Unable to read incremental time delta in received packets.");
3933 return false;
3934 }
3935
3936 if (process_timestamps_) {
3937 last_timestamp_ = last_timestamp_ + QuicTime::Delta::FromMicroseconds(
3938 incremental_time_delta_us);
3939 visitor_->OnAckTimestamp(seq_num, creation_time_ + last_timestamp_);
3940 }
3941 }
3942 return true;
3943}
3944
3945bool QuicFramer::ProcessIetfAckFrame(QuicDataReader* reader,
3946 uint64_t frame_type,
3947 QuicAckFrame* ack_frame) {
3948 uint64_t largest_acked;
3949 if (!reader->ReadVarInt62(&largest_acked)) {
3950 set_detailed_error("Unable to read largest acked.");
3951 return false;
3952 }
3953 if (largest_acked < first_sending_packet_number_.ToUint64()) {
3954 // Connection always sends packet starting from kFirstSendingPacketNumber >
3955 // 0, peer has observed an unsent packet.
3956 set_detailed_error("Largest acked is 0.");
3957 return false;
3958 }
3959 ack_frame->largest_acked = static_cast<QuicPacketNumber>(largest_acked);
3960 uint64_t ack_delay_time_in_us;
3961 if (!reader->ReadVarInt62(&ack_delay_time_in_us)) {
3962 set_detailed_error("Unable to read ack delay time.");
3963 return false;
3964 }
3965
3966 if (ack_delay_time_in_us >= (kVarInt62MaxValue >> peer_ack_delay_exponent_)) {
3967 ack_frame->ack_delay_time = QuicTime::Delta::Infinite();
3968 } else {
3969 ack_delay_time_in_us = (ack_delay_time_in_us << peer_ack_delay_exponent_);
3970 ack_frame->ack_delay_time =
3971 QuicTime::Delta::FromMicroseconds(ack_delay_time_in_us);
3972 }
3973 if (!visitor_->OnAckFrameStart(QuicPacketNumber(largest_acked),
3974 ack_frame->ack_delay_time)) {
3975 // The visitor suppresses further processing of the packet. Although this is
3976 // not a parsing error, returns false as this is in middle of processing an
3977 // ACK frame.
3978 set_detailed_error("Visitor suppresses further processing of ACK frame.");
3979 return false;
3980 }
3981
3982 // Get number of ACK blocks from the packet.
3983 uint64_t ack_block_count;
3984 if (!reader->ReadVarInt62(&ack_block_count)) {
3985 set_detailed_error("Unable to read ack block count.");
3986 return false;
3987 }
3988 // There always is a first ACK block, which is the (number of packets being
3989 // acked)-1, up to and including the packet at largest_acked. Therefore if the
3990 // value is 0, then only largest is acked. If it is 1, then largest-1,
3991 // largest] are acked, etc
3992 uint64_t ack_block_value;
3993 if (!reader->ReadVarInt62(&ack_block_value)) {
3994 set_detailed_error("Unable to read first ack block length.");
3995 return false;
3996 }
3997 // Calculate the packets being acked in the first block.
3998 // +1 because AddRange implementation requires [low,high)
3999 uint64_t block_high = largest_acked + 1;
4000 uint64_t block_low = largest_acked - ack_block_value;
4001
4002 // ack_block_value is the number of packets preceding the
4003 // largest_acked packet which are in the block being acked. Thus,
4004 // its maximum value is largest_acked-1. Test this, reporting an
4005 // error if the value is wrong.
4006 if (ack_block_value + first_sending_packet_number_.ToUint64() >
4007 largest_acked) {
4008 set_detailed_error(absl::StrCat("Underflow with first ack block length ",
4009 ack_block_value + 1, " largest acked is ",
4010 largest_acked, ".")
4011 .c_str());
4012 return false;
4013 }
4014
4015 if (!visitor_->OnAckRange(QuicPacketNumber(block_low),
4016 QuicPacketNumber(block_high))) {
4017 // The visitor suppresses further processing of the packet. Although
4018 // this is not a parsing error, returns false as this is in middle
4019 // of processing an ACK frame.
4020 set_detailed_error("Visitor suppresses further processing of ACK frame.");
4021 return false;
4022 }
4023
4024 while (ack_block_count != 0) {
4025 uint64_t gap_block_value;
4026 // Get the sizes of the gap and ack blocks,
4027 if (!reader->ReadVarInt62(&gap_block_value)) {
4028 set_detailed_error("Unable to read gap block value.");
4029 return false;
4030 }
4031 // It's an error if the gap is larger than the space from packet
4032 // number 0 to the start of the block that's just been acked, PLUS
4033 // there must be space for at least 1 packet to be acked. For
4034 // example, if block_low is 10 and gap_block_value is 9, it means
4035 // the gap block is 10 packets long, leaving no room for a packet
4036 // to be acked. Thus, gap_block_value+2 can not be larger than
4037 // block_low.
4038 // The test is written this way to detect wrap-arounds.
4039 if ((gap_block_value + 2) > block_low) {
4040 set_detailed_error(
4041 absl::StrCat("Underflow with gap block length ", gap_block_value + 1,
4042 " previous ack block start is ", block_low, ".")
4043 .c_str());
4044 return false;
4045 }
4046
4047 // Adjust block_high to be the top of the next ack block.
4048 // There is a gap of |gap_block_value| packets between the bottom
4049 // of ack block N and top of block N+1. Note that gap_block_value
4050 // is he size of the gap minus 1 (per the QUIC protocol), and
4051 // block_high is the packet number of the first packet of the gap
4052 // (per the implementation of OnAckRange/AddAckRange, below).
4053 block_high = block_low - 1 - gap_block_value;
4054
4055 if (!reader->ReadVarInt62(&ack_block_value)) {
4056 set_detailed_error("Unable to read ack block value.");
4057 return false;
4058 }
4059 if (ack_block_value + first_sending_packet_number_.ToUint64() >
4060 (block_high - 1)) {
4061 set_detailed_error(
4062 absl::StrCat("Underflow with ack block length ", ack_block_value + 1,
4063 " latest ack block end is ", block_high - 1, ".")
4064 .c_str());
4065 return false;
4066 }
4067 // Calculate the low end of the new nth ack block. The +1 is
4068 // because the encoded value is the blocksize-1.
4069 block_low = block_high - 1 - ack_block_value;
4070 if (!visitor_->OnAckRange(QuicPacketNumber(block_low),
4071 QuicPacketNumber(block_high))) {
4072 // The visitor suppresses further processing of the packet. Although
4073 // this is not a parsing error, returns false as this is in middle
4074 // of processing an ACK frame.
4075 set_detailed_error("Visitor suppresses further processing of ACK frame.");
4076 return false;
4077 }
4078
4079 // Another one done.
4080 ack_block_count--;
4081 }
4082
4083 if (frame_type == IETF_ACK_RECEIVE_TIMESTAMPS) {
4084 QUICHE_DCHECK(process_timestamps_);
4085 if (!ProcessIetfTimestampsInAckFrame(ack_frame->largest_acked, reader)) {
4086 return false;
4087 }
4088 } else if (frame_type == IETF_ACK_ECN) {
4089 ack_frame->ecn_counters_populated = true;
4090 if (!reader->ReadVarInt62(&ack_frame->ect_0_count)) {
4091 set_detailed_error("Unable to read ack ect_0_count.");
4092 return false;
4093 }
4094 if (!reader->ReadVarInt62(&ack_frame->ect_1_count)) {
4095 set_detailed_error("Unable to read ack ect_1_count.");
4096 return false;
4097 }
4098 if (!reader->ReadVarInt62(&ack_frame->ecn_ce_count)) {
4099 set_detailed_error("Unable to read ack ecn_ce_count.");
4100 return false;
4101 }
4102 } else {
4103 ack_frame->ecn_counters_populated = false;
4104 ack_frame->ect_0_count = 0;
4105 ack_frame->ect_1_count = 0;
4106 ack_frame->ecn_ce_count = 0;
4107 }
4108 // TODO(fayang): Report ECN counts to visitor when they are actually used.
4109 if (!visitor_->OnAckFrameEnd(QuicPacketNumber(block_low))) {
4110 set_detailed_error(
4111 "Error occurs when visitor finishes processing the ACK frame.");
4112 return false;
4113 }
4114
4115 return true;
4116}
4117
4118bool QuicFramer::ProcessIetfTimestampsInAckFrame(QuicPacketNumber largest_acked,
4119 QuicDataReader* reader) {
4120 uint64_t timestamp_range_count;
4121 if (!reader->ReadVarInt62(&timestamp_range_count)) {
4122 set_detailed_error("Unable to read receive timestamp range count.");
4123 return false;
4124 }
4125 if (timestamp_range_count == 0) {
4126 return true;
4127 }
4128
4129 QuicPacketNumber packet_number = largest_acked;
4130
4131 // Iterate through all timestamp ranges, each of which represents a block of
4132 // contiguous packets for which receive timestamps are being reported. Each
4133 // range is of the form:
4134 //
4135 // Timestamp Range {
4136 // Gap (i),
4137 // Timestamp Delta Count (i),
4138 // Timestamp Delta (i) ...,
4139 // }
4140 for (uint64_t i = 0; i < timestamp_range_count; i++) {
4141 uint64_t gap;
4142 if (!reader->ReadVarInt62(&gap)) {
4143 set_detailed_error("Unable to read receive timestamp gap.");
4144 return false;
4145 }
4146 if (packet_number.ToUint64() < gap) {
4147 set_detailed_error("Receive timestamp gap too high.");
4148 return false;
4149 }
4150 packet_number = packet_number - gap;
4151 uint64_t timestamp_count;
4152 if (!reader->ReadVarInt62(&timestamp_count)) {
4153 set_detailed_error("Unable to read receive timestamp count.");
4154 return false;
4155 }
4156 if (packet_number.ToUint64() < timestamp_count) {
4157 set_detailed_error("Receive timestamp count too high.");
4158 return false;
4159 }
4160 for (uint64_t j = 0; j < timestamp_count; j++) {
4161 uint64_t timestamp_delta;
4162 if (!reader->ReadVarInt62(&timestamp_delta)) {
4163 set_detailed_error("Unable to read receive timestamp delta.");
4164 return false;
4165 }
4166 // The first timestamp delta is relative to framer creation time; whereas
4167 // subsequent deltas are relative to the previous delta in decreasing
4168 // packet order.
4169 timestamp_delta = timestamp_delta << receive_timestamps_exponent_;
4170 if (i == 0 && j == 0) {
4171 last_timestamp_ = QuicTime::Delta::FromMicroseconds(timestamp_delta);
4172 } else {
4173 last_timestamp_ = last_timestamp_ -
4174 QuicTime::Delta::FromMicroseconds(timestamp_delta);
4175 if (last_timestamp_ < QuicTime::Delta::Zero()) {
4176 set_detailed_error("Receive timestamp delta too high.");
4177 return false;
4178 }
4179 }
4180 visitor_->OnAckTimestamp(packet_number, creation_time_ + last_timestamp_);
4181 packet_number--;
4182 }
4183 packet_number--;
4184 }
4185 return true;
4186}
4187
4188bool QuicFramer::ProcessStopWaitingFrame(QuicDataReader* reader,
4189 const QuicPacketHeader& header,
4190 QuicStopWaitingFrame* stop_waiting) {
4191 uint64_t least_unacked_delta;
4192 if (!reader->ReadBytesToUInt64(header.packet_number_length,
4193 &least_unacked_delta)) {
4194 set_detailed_error("Unable to read least unacked delta.");
4195 return false;
4196 }
4197 if (header.packet_number.ToUint64() <= least_unacked_delta) {
4198 set_detailed_error("Invalid unacked delta.");
4199 return false;
4200 }
4201 stop_waiting->least_unacked = header.packet_number - least_unacked_delta;
4202
4203 return true;
4204}
4205
4206bool QuicFramer::ProcessRstStreamFrame(QuicDataReader* reader,
4207 QuicRstStreamFrame* frame) {
4208 if (!reader->ReadUInt32(&frame->stream_id)) {
4209 set_detailed_error("Unable to read stream_id.");
4210 return false;
4211 }
4212
4213 if (!reader->ReadUInt64(&frame->byte_offset)) {
4214 set_detailed_error("Unable to read rst stream sent byte offset.");
4215 return false;
4216 }
4217
4218 uint32_t error_code;
4219 if (!reader->ReadUInt32(&error_code)) {
4220 set_detailed_error("Unable to read rst stream error code.");
4221 return false;
4222 }
4223
4224 if (error_code >= QUIC_STREAM_LAST_ERROR) {
4225 // Ignore invalid stream error code if any.
4226 error_code = QUIC_STREAM_LAST_ERROR;
4227 }
4228
4229 frame->error_code = static_cast<QuicRstStreamErrorCode>(error_code);
4230
4231 return true;
4232}
4233
4234bool QuicFramer::ProcessConnectionCloseFrame(QuicDataReader* reader,
4235 QuicConnectionCloseFrame* frame) {
4236 uint32_t error_code;
4237 frame->close_type = GOOGLE_QUIC_CONNECTION_CLOSE;
4238
4239 if (!reader->ReadUInt32(&error_code)) {
4240 set_detailed_error("Unable to read connection close error code.");
4241 return false;
4242 }
4243
4244 // For Google QUIC connection closes, |wire_error_code| and |quic_error_code|
4245 // must have the same value.
4246 frame->wire_error_code = error_code;
4247 frame->quic_error_code = static_cast<QuicErrorCode>(error_code);
4248
4249 absl::string_view error_details;
4250 if (!reader->ReadStringPiece16(&error_details)) {
4251 set_detailed_error("Unable to read connection close error details.");
4252 return false;
4253 }
4254 frame->error_details = std::string(error_details);
4255
4256 return true;
4257}
4258
4259bool QuicFramer::ProcessGoAwayFrame(QuicDataReader* reader,
4260 QuicGoAwayFrame* frame) {
4261 uint32_t error_code;
4262 if (!reader->ReadUInt32(&error_code)) {
4263 set_detailed_error("Unable to read go away error code.");
4264 return false;
4265 }
4266
4267 frame->error_code = static_cast<QuicErrorCode>(error_code);
4268
4269 uint32_t stream_id;
4270 if (!reader->ReadUInt32(&stream_id)) {
4271 set_detailed_error("Unable to read last good stream id.");
4272 return false;
4273 }
4274 frame->last_good_stream_id = static_cast<QuicStreamId>(stream_id);
4275
4276 absl::string_view reason_phrase;
4277 if (!reader->ReadStringPiece16(&reason_phrase)) {
4278 set_detailed_error("Unable to read goaway reason.");
4279 return false;
4280 }
4281 frame->reason_phrase = std::string(reason_phrase);
4282
4283 return true;
4284}
4285
4286bool QuicFramer::ProcessWindowUpdateFrame(QuicDataReader* reader,
4287 QuicWindowUpdateFrame* frame) {
4288 if (!reader->ReadUInt32(&frame->stream_id)) {
4289 set_detailed_error("Unable to read stream_id.");
4290 return false;
4291 }
4292
4293 if (!reader->ReadUInt64(&frame->max_data)) {
4294 set_detailed_error("Unable to read window byte_offset.");
4295 return false;
4296 }
4297
4298 return true;
4299}
4300
4301bool QuicFramer::ProcessBlockedFrame(QuicDataReader* reader,
4302 QuicBlockedFrame* frame) {
4303 QUICHE_DCHECK(!VersionHasIetfQuicFrames(version_.transport_version))
4304 << "Attempt to process non-IETF QUIC frames in an IETF QUIC version.";
4305
4306 if (!reader->ReadUInt32(&frame->stream_id)) {
4307 set_detailed_error("Unable to read stream_id.");
4308 return false;
4309 }
4310
4311 return true;
4312}
4313
4314void QuicFramer::ProcessPaddingFrame(QuicDataReader* reader,
4315 QuicPaddingFrame* frame) {
4316 // Type byte has been read.
4317 frame->num_padding_bytes = 1;
4318 uint8_t next_byte;
4319 while (!reader->IsDoneReading() && reader->PeekByte() == 0x00) {
4320 reader->ReadBytes(&next_byte, 1);
4321 QUICHE_DCHECK_EQ(0x00, next_byte);
4322 ++frame->num_padding_bytes;
4323 }
4324}
4325
4326bool QuicFramer::ProcessMessageFrame(QuicDataReader* reader,
4327 bool no_message_length,
4328 QuicMessageFrame* frame) {
4329 if (no_message_length) {
4330 absl::string_view remaining(reader->ReadRemainingPayload());
4331 frame->data = remaining.data();
4332 frame->message_length = remaining.length();
4333 return true;
4334 }
4335
4336 uint64_t message_length;
4337 if (!reader->ReadVarInt62(&message_length)) {
4338 set_detailed_error("Unable to read message length");
4339 return false;
4340 }
4341
4342 absl::string_view message_piece;
4343 if (!reader->ReadStringPiece(&message_piece, message_length)) {
4344 set_detailed_error("Unable to read message data");
4345 return false;
4346 }
4347
4348 frame->data = message_piece.data();
4349 frame->message_length = message_length;
4350
4351 return true;
4352}
4353
4354// static
4355absl::string_view QuicFramer::GetAssociatedDataFromEncryptedPacket(
4356 QuicTransportVersion version, const QuicEncryptedPacket& encrypted,
4357 QuicConnectionIdLength destination_connection_id_length,
4358 QuicConnectionIdLength source_connection_id_length, bool includes_version,
4359 bool includes_diversification_nonce,
4360 QuicPacketNumberLength packet_number_length,
4361 QuicVariableLengthIntegerLength retry_token_length_length,
4362 uint64_t retry_token_length,
4363 QuicVariableLengthIntegerLength length_length) {
4364 // TODO(ianswett): This is identical to QuicData::AssociatedData.
4365 return absl::string_view(
4366 encrypted.data(),
4367 GetStartOfEncryptedData(version, destination_connection_id_length,
4368 source_connection_id_length, includes_version,
4369 includes_diversification_nonce,
4370 packet_number_length, retry_token_length_length,
4371 retry_token_length, length_length));
4372}
4373
4374void QuicFramer::SetDecrypter(EncryptionLevel level,
4375 std::unique_ptr<QuicDecrypter> decrypter) {
4376 QUICHE_DCHECK_EQ(alternative_decrypter_level_, NUM_ENCRYPTION_LEVELS);
4377 QUICHE_DCHECK_GE(level, decrypter_level_);
4378 QUICHE_DCHECK(!version_.KnowsWhichDecrypterToUse());
4379 QUIC_DVLOG(1) << ENDPOINT << "Setting decrypter from level "
4380 << decrypter_level_ << " to " << level;
4381 decrypter_[decrypter_level_] = nullptr;
4382 decrypter_[level] = std::move(decrypter);
4383 decrypter_level_ = level;
4384}
4385
4386void QuicFramer::SetAlternativeDecrypter(
4387 EncryptionLevel level, std::unique_ptr<QuicDecrypter> decrypter,
4388 bool latch_once_used) {
4389 QUICHE_DCHECK_NE(level, decrypter_level_);
4390 QUICHE_DCHECK(!version_.KnowsWhichDecrypterToUse());
4391 QUIC_DVLOG(1) << ENDPOINT << "Setting alternative decrypter from level "
4392 << alternative_decrypter_level_ << " to " << level;
4393 if (alternative_decrypter_level_ != NUM_ENCRYPTION_LEVELS) {
4394 decrypter_[alternative_decrypter_level_] = nullptr;
4395 }
4396 decrypter_[level] = std::move(decrypter);
4397 alternative_decrypter_level_ = level;
4398 alternative_decrypter_latch_ = latch_once_used;
4399}
4400
4401void QuicFramer::InstallDecrypter(EncryptionLevel level,
4402 std::unique_ptr<QuicDecrypter> decrypter) {
4403 QUICHE_DCHECK(version_.KnowsWhichDecrypterToUse());
4404 QUIC_DVLOG(1) << ENDPOINT << "Installing decrypter at level " << level;
4405 decrypter_[level] = std::move(decrypter);
4406}
4407
4408void QuicFramer::RemoveDecrypter(EncryptionLevel level) {
4409 QUICHE_DCHECK(version_.KnowsWhichDecrypterToUse());
4410 QUIC_DVLOG(1) << ENDPOINT << "Removing decrypter at level " << level;
4411 decrypter_[level] = nullptr;
4412}
4413
4414void QuicFramer::SetKeyUpdateSupportForConnection(bool enabled) {
4415 QUIC_DVLOG(1) << ENDPOINT << "SetKeyUpdateSupportForConnection: " << enabled;
4416 support_key_update_for_connection_ = enabled;
4417}
4418
4419void QuicFramer::DiscardPreviousOneRttKeys() {
4420 QUICHE_DCHECK(support_key_update_for_connection_);
4421 QUIC_DVLOG(1) << ENDPOINT << "Discarding previous set of 1-RTT keys";
4422 previous_decrypter_ = nullptr;
4423}
4424
4425bool QuicFramer::DoKeyUpdate(KeyUpdateReason reason) {
4426 QUICHE_DCHECK(support_key_update_for_connection_);
4427 if (!next_decrypter_) {
4428 // If key update is locally initiated, next decrypter might not be created
4429 // yet.
4430 next_decrypter_ = visitor_->AdvanceKeysAndCreateCurrentOneRttDecrypter();
4431 }
4432 std::unique_ptr<QuicEncrypter> next_encrypter =
4433 visitor_->CreateCurrentOneRttEncrypter();
4434 if (!next_decrypter_ || !next_encrypter) {
4435 QUIC_BUG(quic_bug_10850_58) << "Failed to create next crypters";
4436 return false;
4437 }
4438 key_update_performed_ = true;
4439 current_key_phase_bit_ = !current_key_phase_bit_;
4440 QUIC_DLOG(INFO) << ENDPOINT << "DoKeyUpdate: new current_key_phase_bit_="
4441 << current_key_phase_bit_;
4442 current_key_phase_first_received_packet_number_.Clear();
4443 previous_decrypter_ = std::move(decrypter_[ENCRYPTION_FORWARD_SECURE]);
4444 decrypter_[ENCRYPTION_FORWARD_SECURE] = std::move(next_decrypter_);
4445 encrypter_[ENCRYPTION_FORWARD_SECURE] = std::move(next_encrypter);
4446 switch (reason) {
4447 case KeyUpdateReason::kInvalid:
4448 QUIC_CODE_COUNT(quic_key_update_invalid);
4449 break;
4450 case KeyUpdateReason::kRemote:
4451 QUIC_CODE_COUNT(quic_key_update_remote);
4452 break;
4453 case KeyUpdateReason::kLocalForTests:
4454 QUIC_CODE_COUNT(quic_key_update_local_for_tests);
4455 break;
4456 case KeyUpdateReason::kLocalForInteropRunner:
4457 QUIC_CODE_COUNT(quic_key_update_local_for_interop_runner);
4458 break;
4459 case KeyUpdateReason::kLocalAeadConfidentialityLimit:
4460 QUIC_CODE_COUNT(quic_key_update_local_aead_confidentiality_limit);
4461 break;
4462 case KeyUpdateReason::kLocalKeyUpdateLimitOverride:
4463 QUIC_CODE_COUNT(quic_key_update_local_limit_override);
4464 break;
4465 }
4466 visitor_->OnKeyUpdate(reason);
4467 return true;
4468}
4469
4470QuicPacketCount QuicFramer::PotentialPeerKeyUpdateAttemptCount() const {
4471 return potential_peer_key_update_attempt_count_;
4472}
4473
4474const QuicDecrypter* QuicFramer::GetDecrypter(EncryptionLevel level) const {
4475 QUICHE_DCHECK(version_.KnowsWhichDecrypterToUse());
4476 return decrypter_[level].get();
4477}
4478
4479const QuicDecrypter* QuicFramer::decrypter() const {
4480 return decrypter_[decrypter_level_].get();
4481}
4482
4483const QuicDecrypter* QuicFramer::alternative_decrypter() const {
4484 if (alternative_decrypter_level_ == NUM_ENCRYPTION_LEVELS) {
4485 return nullptr;
4486 }
4487 return decrypter_[alternative_decrypter_level_].get();
4488}
4489
4490void QuicFramer::SetEncrypter(EncryptionLevel level,
4491 std::unique_ptr<QuicEncrypter> encrypter) {
4492 QUICHE_DCHECK_GE(level, 0);
4493 QUICHE_DCHECK_LT(level, NUM_ENCRYPTION_LEVELS);
4494 QUIC_DVLOG(1) << ENDPOINT << "Setting encrypter at level " << level;
4495 encrypter_[level] = std::move(encrypter);
4496}
4497
4498void QuicFramer::RemoveEncrypter(EncryptionLevel level) {
4499 QUIC_DVLOG(1) << ENDPOINT << "Removing encrypter of " << level;
4500 encrypter_[level] = nullptr;
4501}
4502
4503void QuicFramer::SetInitialObfuscators(QuicConnectionId connection_id) {
4504 CrypterPair crypters;
4505 CryptoUtils::CreateInitialObfuscators(perspective_, version_, connection_id,
4506 &crypters);
4507 encrypter_[ENCRYPTION_INITIAL] = std::move(crypters.encrypter);
4508 decrypter_[ENCRYPTION_INITIAL] = std::move(crypters.decrypter);
4509}
4510
4511size_t QuicFramer::EncryptInPlace(EncryptionLevel level,
4512 QuicPacketNumber packet_number, size_t ad_len,
4513 size_t total_len, size_t buffer_len,
4514 char* buffer) {
4515 QUICHE_DCHECK(packet_number.IsInitialized());
4516 if (encrypter_[level] == nullptr) {
4517 QUIC_BUG(quic_bug_10850_59)
4518 << ENDPOINT
4519 << "Attempted to encrypt in place without encrypter at level " << level;
4520 RaiseError(QUIC_ENCRYPTION_FAILURE);
4521 return 0;
4522 }
4523
4524 size_t output_length = 0;
4525 if (!encrypter_[level]->EncryptPacket(
4526 packet_number.ToUint64(),
4527 absl::string_view(buffer, ad_len), // Associated data
4528 absl::string_view(buffer + ad_len,
4529 total_len - ad_len), // Plaintext
4530 buffer + ad_len, // Destination buffer
4531 &output_length, buffer_len - ad_len)) {
4532 RaiseError(QUIC_ENCRYPTION_FAILURE);
4533 return 0;
4534 }
4535 if (version_.HasHeaderProtection() &&
4536 !ApplyHeaderProtection(level, buffer, ad_len + output_length, ad_len)) {
4537 QUIC_DLOG(ERROR) << "Applying header protection failed.";
4538 RaiseError(QUIC_ENCRYPTION_FAILURE);
4539 return 0;
4540 }
4541
4542 return ad_len + output_length;
4543}
4544
4545namespace {
4546
4547const size_t kHPSampleLen = 16;
4548
4549constexpr bool IsLongHeader(uint8_t type_byte) {
4550 return (type_byte & FLAGS_LONG_HEADER) != 0;
4551}
4552
4553} // namespace
4554
4555bool QuicFramer::ApplyHeaderProtection(EncryptionLevel level, char* buffer,
4556 size_t buffer_len, size_t ad_len) {
4557 QuicDataReader buffer_reader(buffer, buffer_len);
4558 QuicDataWriter buffer_writer(buffer_len, buffer);
4559 // The sample starts 4 bytes after the start of the packet number.
4560 if (ad_len < last_written_packet_number_length_) {
4561 return false;
4562 }
4563 size_t pn_offset = ad_len - last_written_packet_number_length_;
4564 // Sample the ciphertext and generate the mask to use for header protection.
4565 size_t sample_offset = pn_offset + 4;
4566 QuicDataReader sample_reader(buffer, buffer_len);
4567 absl::string_view sample;
4568 if (!sample_reader.Seek(sample_offset) ||
4569 !sample_reader.ReadStringPiece(&sample, kHPSampleLen)) {
4570 QUIC_BUG(quic_bug_10850_60)
4571 << "Not enough bytes to sample: sample_offset " << sample_offset
4572 << ", sample len: " << kHPSampleLen << ", buffer len: " << buffer_len;
4573 return false;
4574 }
4575
4576 if (encrypter_[level] == nullptr) {
4577 QUIC_BUG(quic_bug_12975_8)
4578 << ENDPOINT
4579 << "Attempted to apply header protection without encrypter at level "
4580 << level << " using " << version_;
4581 return false;
4582 }
4583
4584 std::string mask = encrypter_[level]->GenerateHeaderProtectionMask(sample);
4585 if (mask.empty()) {
4586 QUIC_BUG(quic_bug_10850_61) << "Unable to generate header protection mask.";
4587 return false;
4588 }
4589 QuicDataReader mask_reader(mask.data(), mask.size());
4590
4591 // Apply the mask to the 4 or 5 least significant bits of the first byte.
4592 uint8_t bitmask = 0x1f;
4593 uint8_t type_byte;
4594 if (!buffer_reader.ReadUInt8(&type_byte)) {
4595 return false;
4596 }
4597 QuicLongHeaderType header_type;
4598 if (IsLongHeader(type_byte)) {
4599 bitmask = 0x0f;
4600 header_type = GetLongHeaderType(type_byte, version_);
4601 if (header_type == INVALID_PACKET_TYPE) {
4602 return false;
4603 }
4604 }
4605 uint8_t mask_byte;
4606 if (!mask_reader.ReadUInt8(&mask_byte) ||
4607 !buffer_writer.WriteUInt8(type_byte ^ (mask_byte & bitmask))) {
4608 return false;
4609 }
4610
4611 // Adjust |pn_offset| to account for the diversification nonce.
4612 if (IsLongHeader(type_byte) && header_type == ZERO_RTT_PROTECTED &&
4613 perspective_ == Perspective::IS_SERVER &&
4614 version_.handshake_protocol == PROTOCOL_QUIC_CRYPTO) {
4615 if (pn_offset <= kDiversificationNonceSize) {
4616 QUIC_BUG(quic_bug_10850_62)
4617 << "Expected diversification nonce, but not enough bytes";
4618 return false;
4619 }
4620 pn_offset -= kDiversificationNonceSize;
4621 }
4622 // Advance the reader and writer to the packet number. Both the reader and
4623 // writer have each read/written one byte.
4624 if (!buffer_writer.Seek(pn_offset - 1) ||
4625 !buffer_reader.Seek(pn_offset - 1)) {
4626 return false;
4627 }
4628 // Apply the rest of the mask to the packet number.
4629 for (size_t i = 0; i < last_written_packet_number_length_; ++i) {
4630 uint8_t buffer_byte;
4631 uint8_t mask_byte;
4632 if (!mask_reader.ReadUInt8(&mask_byte) ||
4633 !buffer_reader.ReadUInt8(&buffer_byte) ||
4634 !buffer_writer.WriteUInt8(buffer_byte ^ mask_byte)) {
4635 return false;
4636 }
4637 }
4638 return true;
4639}
4640
4641bool QuicFramer::RemoveHeaderProtection(QuicDataReader* reader,
4642 const QuicEncryptedPacket& packet,
4643 QuicPacketHeader* header,
4644 uint64_t* full_packet_number,
4645 std::vector<char>* associated_data) {
4646 EncryptionLevel expected_decryption_level = GetEncryptionLevel(*header);
4647 QuicDecrypter* decrypter = decrypter_[expected_decryption_level].get();
4648 if (decrypter == nullptr) {
4649 QUIC_DVLOG(1)
4650 << ENDPOINT
4651 << "No decrypter available for removing header protection at level "
4652 << expected_decryption_level;
4653 return false;
4654 }
4655
4656 bool has_diversification_nonce =
4657 header->form == IETF_QUIC_LONG_HEADER_PACKET &&
4658 header->long_packet_type == ZERO_RTT_PROTECTED &&
4659 perspective_ == Perspective::IS_CLIENT &&
4660 version_.handshake_protocol == PROTOCOL_QUIC_CRYPTO;
4661
4662 // Read a sample from the ciphertext and compute the mask to use for header
4663 // protection.
4664 absl::string_view remaining_packet = reader->PeekRemainingPayload();
4665 QuicDataReader sample_reader(remaining_packet);
4666
4667 // The sample starts 4 bytes after the start of the packet number.
4668 absl::string_view pn;
4669 if (!sample_reader.ReadStringPiece(&pn, 4)) {
4670 QUIC_DVLOG(1) << "Not enough data to sample";
4671 return false;
4672 }
4673 if (has_diversification_nonce) {
4674 // In Google QUIC, the diversification nonce comes between the packet number
4675 // and the sample.
4676 if (!sample_reader.Seek(kDiversificationNonceSize)) {
4677 QUIC_DVLOG(1) << "No diversification nonce to skip over";
4678 return false;
4679 }
4680 }
4681 std::string mask = decrypter->GenerateHeaderProtectionMask(&sample_reader);
4682 QuicDataReader mask_reader(mask.data(), mask.size());
4683 if (mask.empty()) {
4684 QUIC_DVLOG(1) << "Failed to compute mask";
4685 return false;
4686 }
4687
4688 // Unmask the rest of the type byte.
4689 uint8_t bitmask = 0x1f;
4690 if (IsLongHeader(header->type_byte)) {
4691 bitmask = 0x0f;
4692 }
4693 uint8_t mask_byte;
4694 if (!mask_reader.ReadUInt8(&mask_byte)) {
4695 QUIC_DVLOG(1) << "No first byte to read from mask";
4696 return false;
4697 }
4698 header->type_byte ^= (mask_byte & bitmask);
4699
4700 // Compute the packet number length.
4701 header->packet_number_length =
4702 static_cast<QuicPacketNumberLength>((header->type_byte & 0x03) + 1);
4703
4704 char pn_buffer[IETF_MAX_PACKET_NUMBER_LENGTH] = {};
4705 QuicDataWriter pn_writer(ABSL_ARRAYSIZE(pn_buffer), pn_buffer);
4706
4707 // Read the (protected) packet number from the reader and unmask the packet
4708 // number.
4709 for (size_t i = 0; i < header->packet_number_length; ++i) {
4710 uint8_t protected_pn_byte, mask_byte;
4711 if (!mask_reader.ReadUInt8(&mask_byte) ||
4712 !reader->ReadUInt8(&protected_pn_byte) ||
4713 !pn_writer.WriteUInt8(protected_pn_byte ^ mask_byte)) {
4714 QUIC_DVLOG(1) << "Failed to unmask packet number";
4715 return false;
4716 }
4717 }
4718 QuicDataReader packet_number_reader(pn_writer.data(), pn_writer.length());
4719 QuicPacketNumber base_packet_number;
4720 if (supports_multiple_packet_number_spaces_) {
4721 PacketNumberSpace pn_space = GetPacketNumberSpace(*header);
4722 if (pn_space == NUM_PACKET_NUMBER_SPACES) {
4723 return false;
4724 }
4725 base_packet_number = largest_decrypted_packet_numbers_[pn_space];
4726 } else {
4727 base_packet_number = largest_packet_number_;
4728 }
4729 if (!ProcessAndCalculatePacketNumber(
4730 &packet_number_reader, header->packet_number_length,
4731 base_packet_number, full_packet_number)) {
4732 return false;
4733 }
4734
4735 // Get the associated data, and apply the same unmasking operations to it.
4736 absl::string_view ad = GetAssociatedDataFromEncryptedPacket(
4737 version_.transport_version, packet,
4738 GetIncludedDestinationConnectionIdLength(*header),
4739 GetIncludedSourceConnectionIdLength(*header), header->version_flag,
4740 has_diversification_nonce, header->packet_number_length,
4741 header->retry_token_length_length, header->retry_token.length(),
4742 header->length_length);
4743 *associated_data = std::vector<char>(ad.begin(), ad.end());
4744 QuicDataWriter ad_writer(associated_data->size(), associated_data->data());
4745
4746 // Apply the unmasked type byte and packet number to |associated_data|.
4747 if (!ad_writer.WriteUInt8(header->type_byte)) {
4748 return false;
4749 }
4750 // Put the packet number at the end of the AD, or if there's a diversification
4751 // nonce, before that (which is at the end of the AD).
4752 size_t seek_len = ad_writer.remaining() - header->packet_number_length;
4753 if (has_diversification_nonce) {
4754 seek_len -= kDiversificationNonceSize;
4755 }
4756 if (!ad_writer.Seek(seek_len) ||
4757 !ad_writer.WriteBytes(pn_writer.data(), pn_writer.length())) {
4758 QUIC_DVLOG(1) << "Failed to apply unmasking operations to AD";
4759 return false;
4760 }
4761
4762 return true;
4763}
4764
4765size_t QuicFramer::EncryptPayload(EncryptionLevel level,
4766 QuicPacketNumber packet_number,
4767 const QuicPacket& packet, char* buffer,
4768 size_t buffer_len) {
4769 QUICHE_DCHECK(packet_number.IsInitialized());
4770 if (encrypter_[level] == nullptr) {
4771 QUIC_BUG(quic_bug_10850_63)
4772 << ENDPOINT << "Attempted to encrypt without encrypter at level "
4773 << level;
4774 RaiseError(QUIC_ENCRYPTION_FAILURE);
4775 return 0;
4776 }
4777
4778 absl::string_view associated_data =
4779 packet.AssociatedData(version_.transport_version);
4780 // Copy in the header, because the encrypter only populates the encrypted
4781 // plaintext content.
4782 const size_t ad_len = associated_data.length();
4783 if (packet.length() < ad_len) {
4784 QUIC_BUG(quic_bug_10850_64)
4785 << ENDPOINT << "packet is shorter than associated data length. version:"
4786 << version() << ", packet length:" << packet.length()
4787 << ", associated data length:" << ad_len;
4788 RaiseError(QUIC_ENCRYPTION_FAILURE);
4789 return 0;
4790 }
4791 memmove(buffer, associated_data.data(), ad_len);
4792 // Encrypt the plaintext into the buffer.
4793 size_t output_length = 0;
4794 if (!encrypter_[level]->EncryptPacket(
4795 packet_number.ToUint64(), associated_data,
4796 packet.Plaintext(version_.transport_version), buffer + ad_len,
4797 &output_length, buffer_len - ad_len)) {
4798 RaiseError(QUIC_ENCRYPTION_FAILURE);
4799 return 0;
4800 }
4801 if (version_.HasHeaderProtection() &&
4802 !ApplyHeaderProtection(level, buffer, ad_len + output_length, ad_len)) {
4803 QUIC_DLOG(ERROR) << "Applying header protection failed.";
4804 RaiseError(QUIC_ENCRYPTION_FAILURE);
4805 return 0;
4806 }
4807
4808 return ad_len + output_length;
4809}
4810
4811size_t QuicFramer::GetCiphertextSize(EncryptionLevel level,
4812 size_t plaintext_size) const {
4813 if (encrypter_[level] == nullptr) {
4814 QUIC_BUG(quic_bug_10850_65)
4815 << ENDPOINT
4816 << "Attempted to get ciphertext size without encrypter at level "
4817 << level << " using " << version_;
4818 return plaintext_size;
4819 }
4820 return encrypter_[level]->GetCiphertextSize(plaintext_size);
4821}
4822
4823size_t QuicFramer::GetMaxPlaintextSize(size_t ciphertext_size) {
4824 // In order to keep the code simple, we don't have the current encryption
4825 // level to hand. Both the NullEncrypter and AES-GCM have a tag length of 12.
4826 size_t min_plaintext_size = ciphertext_size;
4827
4828 for (int i = ENCRYPTION_INITIAL; i < NUM_ENCRYPTION_LEVELS; i++) {
4829 if (encrypter_[i] != nullptr) {
4830 size_t size = encrypter_[i]->GetMaxPlaintextSize(ciphertext_size);
4831 if (size < min_plaintext_size) {
4832 min_plaintext_size = size;
4833 }
4834 }
4835 }
4836
4837 return min_plaintext_size;
4838}
4839
4840QuicPacketCount QuicFramer::GetOneRttEncrypterConfidentialityLimit() const {
4841 if (!encrypter_[ENCRYPTION_FORWARD_SECURE]) {
4842 QUIC_BUG(quic_bug_10850_66) << "1-RTT encrypter not set";
4843 return 0;
4844 }
4845 return encrypter_[ENCRYPTION_FORWARD_SECURE]->GetConfidentialityLimit();
4846}
4847
4848bool QuicFramer::DecryptPayload(size_t udp_packet_length,
4849 absl::string_view encrypted,
4850 absl::string_view associated_data,
4851 const QuicPacketHeader& header,
4852 char* decrypted_buffer, size_t buffer_length,
4853 size_t* decrypted_length,
4854 EncryptionLevel* decrypted_level) {
4855 if (!EncryptionLevelIsValid(decrypter_level_)) {
4856 QUIC_BUG(quic_bug_10850_67)
4857 << "Attempted to decrypt with bad decrypter_level_";
4858 return false;
4859 }
4860 EncryptionLevel level = decrypter_level_;
4861 QuicDecrypter* decrypter = decrypter_[level].get();
4862 QuicDecrypter* alternative_decrypter = nullptr;
4863 bool key_phase_parsed = false;
4864 bool key_phase;
4865 bool attempt_key_update = false;
4866 if (version().KnowsWhichDecrypterToUse()) {
4867 if (header.form == GOOGLE_QUIC_PACKET) {
4868 QUIC_BUG(quic_bug_10850_68)
4869 << "Attempted to decrypt GOOGLE_QUIC_PACKET with a version that "
4870 "knows which decrypter to use";
4871 return false;
4872 }
4873 level = GetEncryptionLevel(header);
4874 if (!EncryptionLevelIsValid(level)) {
4875 QUIC_BUG(quic_bug_10850_69) << "Attempted to decrypt with bad level";
4876 return false;
4877 }
4878 decrypter = decrypter_[level].get();
4879 if (decrypter == nullptr) {
4880 return false;
4881 }
4882 if (level == ENCRYPTION_ZERO_RTT &&
4883 perspective_ == Perspective::IS_CLIENT && header.nonce != nullptr) {
4884 decrypter->SetDiversificationNonce(*header.nonce);
4885 }
4886 if (support_key_update_for_connection_ &&
4887 header.form == IETF_QUIC_SHORT_HEADER_PACKET) {
4888 QUICHE_DCHECK(version().UsesTls());
4889 QUICHE_DCHECK_EQ(level, ENCRYPTION_FORWARD_SECURE);
4890 key_phase = (header.type_byte & FLAGS_KEY_PHASE_BIT) != 0;
4891 key_phase_parsed = true;
4892 QUIC_DVLOG(1) << ENDPOINT << "packet " << header.packet_number
4893 << " received key_phase=" << key_phase
4894 << " current_key_phase_bit_=" << current_key_phase_bit_;
4895 if (key_phase != current_key_phase_bit_) {
4896 if ((current_key_phase_first_received_packet_number_.IsInitialized() &&
4897 header.packet_number >
4898 current_key_phase_first_received_packet_number_) ||
4899 (!current_key_phase_first_received_packet_number_.IsInitialized() &&
4900 !key_update_performed_)) {
4901 if (!next_decrypter_) {
4902 next_decrypter_ =
4903 visitor_->AdvanceKeysAndCreateCurrentOneRttDecrypter();
4904 if (!next_decrypter_) {
4905 QUIC_BUG(quic_bug_10850_70) << "Failed to create next_decrypter";
4906 return false;
4907 }
4908 }
4909 QUIC_DVLOG(1) << ENDPOINT << "packet " << header.packet_number
4910 << " attempt_key_update=true";
4911 attempt_key_update = true;
4912 potential_peer_key_update_attempt_count_++;
4913 decrypter = next_decrypter_.get();
4914 } else {
4915 if (previous_decrypter_) {
4916 QUIC_DVLOG(1) << ENDPOINT
4917 << "trying previous_decrypter_ for packet "
4918 << header.packet_number;
4919 decrypter = previous_decrypter_.get();
4920 } else {
4921 QUIC_DVLOG(1) << ENDPOINT << "dropping packet "
4922 << header.packet_number << " with old key phase";
4923 return false;
4924 }
4925 }
4926 }
4927 }
4928 } else if (alternative_decrypter_level_ != NUM_ENCRYPTION_LEVELS) {
4929 if (!EncryptionLevelIsValid(alternative_decrypter_level_)) {
4930 QUIC_BUG(quic_bug_10850_71)
4931 << "Attempted to decrypt with bad alternative_decrypter_level_";
4932 return false;
4933 }
4934 alternative_decrypter = decrypter_[alternative_decrypter_level_].get();
4935 }
4936
4937 if (decrypter == nullptr) {
4938 QUIC_BUG(quic_bug_10850_72)
4939 << "Attempting to decrypt without decrypter, encryption level:" << level
4940 << " version:" << version();
4941 return false;
4942 }
4943
4944 bool success = decrypter->DecryptPacket(
4945 header.packet_number.ToUint64(), associated_data, encrypted,
4946 decrypted_buffer, decrypted_length, buffer_length);
4947 if (success) {
4948 visitor_->OnDecryptedPacket(udp_packet_length, level);
4949 if (level == ENCRYPTION_ZERO_RTT &&
4950 current_key_phase_first_received_packet_number_.IsInitialized() &&
4951 header.packet_number >
4952 current_key_phase_first_received_packet_number_) {
4953 set_detailed_error(absl::StrCat(
4954 "Decrypted a 0-RTT packet with a packet number ",
4955 header.packet_number.ToString(),
4956 " which is higher than a 1-RTT packet number ",
4957 current_key_phase_first_received_packet_number_.ToString()));
4958 return RaiseError(QUIC_INVALID_0RTT_PACKET_NUMBER_OUT_OF_ORDER);
4959 }
4960 *decrypted_level = level;
4961 potential_peer_key_update_attempt_count_ = 0;
4962 if (attempt_key_update) {
4963 if (!DoKeyUpdate(KeyUpdateReason::kRemote)) {
4964 set_detailed_error("Key update failed due to internal error");
4965 return RaiseError(QUIC_INTERNAL_ERROR);
4966 }
4967 QUICHE_DCHECK_EQ(current_key_phase_bit_, key_phase);
4968 }
4969 if (key_phase_parsed &&
4970 !current_key_phase_first_received_packet_number_.IsInitialized() &&
4971 key_phase == current_key_phase_bit_) {
4972 // Set packet number for current key phase if it hasn't been initialized
4973 // yet. This is set outside of attempt_key_update since the key update
4974 // may have been initiated locally, and in that case we don't know yet
4975 // which packet number from the remote side to use until we receive a
4976 // packet with that phase.
4977 QUIC_DVLOG(1) << ENDPOINT
4978 << "current_key_phase_first_received_packet_number_ = "
4979 << header.packet_number;
4980 current_key_phase_first_received_packet_number_ = header.packet_number;
4981 visitor_->OnDecryptedFirstPacketInKeyPhase();
4982 }
4983 } else if (alternative_decrypter != nullptr) {
4984 if (header.nonce != nullptr) {
4985 QUICHE_DCHECK_EQ(perspective_, Perspective::IS_CLIENT);
4986 alternative_decrypter->SetDiversificationNonce(*header.nonce);
4987 }
4988 bool try_alternative_decryption = true;
4989 if (alternative_decrypter_level_ == ENCRYPTION_ZERO_RTT) {
4990 if (perspective_ == Perspective::IS_CLIENT) {
4991 if (header.nonce == nullptr) {
4992 // Can not use INITIAL decryption without a diversification nonce.
4993 try_alternative_decryption = false;
4994 }
4995 } else {
4996 QUICHE_DCHECK(header.nonce == nullptr);
4997 }
4998 }
4999
5000 if (try_alternative_decryption) {
5001 success = alternative_decrypter->DecryptPacket(
5002 header.packet_number.ToUint64(), associated_data, encrypted,
5003 decrypted_buffer, decrypted_length, buffer_length);
5004 }
5005 if (success) {
5006 visitor_->OnDecryptedPacket(udp_packet_length,
5007 alternative_decrypter_level_);
5008 *decrypted_level = decrypter_level_;
5009 if (alternative_decrypter_latch_) {
5010 if (!EncryptionLevelIsValid(alternative_decrypter_level_)) {
5011 QUIC_BUG(quic_bug_10850_73)
5012 << "Attempted to latch alternate decrypter with bad "
5013 "alternative_decrypter_level_";
5014 return false;
5015 }
5016 // Switch to the alternative decrypter and latch so that we cannot
5017 // switch back.
5018 decrypter_level_ = alternative_decrypter_level_;
5019 alternative_decrypter_level_ = NUM_ENCRYPTION_LEVELS;
5020 } else {
5021 // Switch the alternative decrypter so that we use it first next time.
5022 EncryptionLevel level = alternative_decrypter_level_;
5023 alternative_decrypter_level_ = decrypter_level_;
5024 decrypter_level_ = level;
5025 }
5026 }
5027 }
5028
5029 if (!success) {
5030 QUIC_DVLOG(1) << ENDPOINT << "DecryptPacket failed for: " << header;
5031 return false;
5032 }
5033
5034 return true;
5035}
5036
5037size_t QuicFramer::GetIetfAckFrameSize(const QuicAckFrame& frame) {
5038 // Type byte, largest_acked, and delay_time are straight-forward.
5039 size_t ack_frame_size = kQuicFrameTypeSize;
5040 QuicPacketNumber largest_acked = LargestAcked(frame);
5041 ack_frame_size += QuicDataWriter::GetVarInt62Len(largest_acked.ToUint64());
5042 uint64_t ack_delay_time_us;
5043 ack_delay_time_us = frame.ack_delay_time.ToMicroseconds();
5044 ack_delay_time_us = ack_delay_time_us >> local_ack_delay_exponent_;
5045 ack_frame_size += QuicDataWriter::GetVarInt62Len(ack_delay_time_us);
5046
5047 if (frame.packets.Empty() || frame.packets.Max() != largest_acked) {
5048 QUIC_BUG(quic_bug_10850_74) << "Malformed ack frame";
5049 // ACK frame serialization will fail and connection will be closed.
5050 return ack_frame_size;
5051 }
5052
5053 // Ack block count.
5054 ack_frame_size +=
5055 QuicDataWriter::GetVarInt62Len(frame.packets.NumIntervals() - 1);
5056
5057 // First Ack range.
5058 auto iter = frame.packets.rbegin();
5059 ack_frame_size += QuicDataWriter::GetVarInt62Len(iter->Length() - 1);
5060 QuicPacketNumber previous_smallest = iter->min();
5061 ++iter;
5062
5063 // Ack blocks.
5064 for (; iter != frame.packets.rend(); ++iter) {
5065 const uint64_t gap = previous_smallest - iter->max() - 1;
5066 const uint64_t ack_range = iter->Length() - 1;
5067 ack_frame_size += (QuicDataWriter::GetVarInt62Len(gap) +
5068 QuicDataWriter::GetVarInt62Len(ack_range));
5069 previous_smallest = iter->min();
5070 }
5071
5072 if (UseIetfAckWithReceiveTimestamp(frame)) {
5073 ack_frame_size += GetIetfAckFrameTimestampSize(frame);
5074 } else if (frame.ecn_counters_populated &&
5075 (frame.ect_0_count || frame.ect_1_count || frame.ecn_ce_count)) {
5076 // ECN counts.
5077 ack_frame_size += QuicDataWriter::GetVarInt62Len(frame.ect_0_count);
5078 ack_frame_size += QuicDataWriter::GetVarInt62Len(frame.ect_1_count);
5079 ack_frame_size += QuicDataWriter::GetVarInt62Len(frame.ecn_ce_count);
5080 }
5081
5082 return ack_frame_size;
5083}
5084
5085size_t QuicFramer::GetIetfAckFrameTimestampSize(const QuicAckFrame& ack) {
5086 QUICHE_DCHECK(!ack.received_packet_times.empty());
5087 std::string detailed_error;
5088 absl::InlinedVector<AckTimestampRange, 2> timestamp_ranges =
5089 GetAckTimestampRanges(ack, detailed_error);
5090 if (!detailed_error.empty()) {
5091 return 0;
5092 }
5093
5094 int64_t size =
5095 FrameAckTimestampRanges(ack, timestamp_ranges, /*writer=*/nullptr);
5096 return std::max<int64_t>(0, size);
5097}
5098
5099size_t QuicFramer::GetAckFrameSize(
5100 const QuicAckFrame& ack, QuicPacketNumberLength /*packet_number_length*/) {
5101 QUICHE_DCHECK(!ack.packets.Empty());
5102 size_t ack_size = 0;
5103
5104 if (VersionHasIetfQuicFrames(version_.transport_version)) {
5105 return GetIetfAckFrameSize(ack);
5106 }
5107 AckFrameInfo ack_info = GetAckFrameInfo(ack);
5108 QuicPacketNumberLength ack_block_length =
5109 GetMinPacketNumberLength(QuicPacketNumber(ack_info.max_block_length));
5110
5111 ack_size = GetMinAckFrameSize(version_.transport_version, ack,
5112 local_ack_delay_exponent_,
5113 UseIetfAckWithReceiveTimestamp(ack));
5114 // First ack block length.
5115 ack_size += ack_block_length;
5116 if (ack_info.num_ack_blocks != 0) {
5117 ack_size += kNumberOfAckBlocksSize;
5118 ack_size += std::min(ack_info.num_ack_blocks, kMaxAckBlocks) *
5119 (ack_block_length + PACKET_1BYTE_PACKET_NUMBER);
5120 }
5121
5122 // Include timestamps.
5123 if (process_timestamps_) {
5124 ack_size += GetAckFrameTimeStampSize(ack);
5125 }
5126
5127 return ack_size;
5128}
5129
5130size_t QuicFramer::GetAckFrameTimeStampSize(const QuicAckFrame& ack) {
5131 if (ack.received_packet_times.empty()) {
5132 return 0;
5133 }
5134
5135 return kQuicNumTimestampsLength + kQuicFirstTimestampLength +
5136 (kQuicTimestampLength + kQuicTimestampPacketNumberGapLength) *
5137 (ack.received_packet_times.size() - 1);
5138}
5139
5140size_t QuicFramer::ComputeFrameLength(
5141 const QuicFrame& frame, bool last_frame_in_packet,
5142 QuicPacketNumberLength packet_number_length) {
5143 switch (frame.type) {
5144 case STREAM_FRAME:
5145 return GetMinStreamFrameSize(
5146 version_.transport_version, frame.stream_frame.stream_id,
5147 frame.stream_frame.offset, last_frame_in_packet,
5148 frame.stream_frame.data_length) +
5149 frame.stream_frame.data_length;
5150 case CRYPTO_FRAME:
5151 return GetMinCryptoFrameSize(frame.crypto_frame->offset,
5152 frame.crypto_frame->data_length) +
5153 frame.crypto_frame->data_length;
5154 case ACK_FRAME: {
5155 return GetAckFrameSize(*frame.ack_frame, packet_number_length);
5156 }
5157 case STOP_WAITING_FRAME:
5158 return GetStopWaitingFrameSize(packet_number_length);
5159 case MTU_DISCOVERY_FRAME:
5160 // MTU discovery frames are serialized as ping frames.
5161 return kQuicFrameTypeSize;
5162 case MESSAGE_FRAME:
5163 return GetMessageFrameSize(version_.transport_version,
5164 last_frame_in_packet,
5165 frame.message_frame->message_length);
5166 case PADDING_FRAME:
5167 QUICHE_DCHECK(false);
5168 return 0;
5169 default:
5170 return GetRetransmittableControlFrameSize(version_.transport_version,
5171 frame);
5172 }
5173}
5174
5175bool QuicFramer::AppendTypeByte(const QuicFrame& frame,
5176 bool last_frame_in_packet,
5177 QuicDataWriter* writer) {
5178 if (VersionHasIetfQuicFrames(version_.transport_version)) {
5179 return AppendIetfFrameType(frame, last_frame_in_packet, writer);
5180 }
5181 uint8_t type_byte = 0;
5182 switch (frame.type) {
5183 case STREAM_FRAME:
5184 type_byte =
5185 GetStreamFrameTypeByte(frame.stream_frame, last_frame_in_packet);
5186 break;
5187 case ACK_FRAME:
5188 return true;
5189 case MTU_DISCOVERY_FRAME:
5190 type_byte = static_cast<uint8_t>(PING_FRAME);
5191 break;
5192 case NEW_CONNECTION_ID_FRAME:
5193 set_detailed_error(
5194 "Attempt to append NEW_CONNECTION_ID frame and not in IETF QUIC.");
5195 return RaiseError(QUIC_INTERNAL_ERROR);
5196 case RETIRE_CONNECTION_ID_FRAME:
5197 set_detailed_error(
5198 "Attempt to append RETIRE_CONNECTION_ID frame and not in IETF QUIC.");
5199 return RaiseError(QUIC_INTERNAL_ERROR);
5200 case NEW_TOKEN_FRAME:
5201 set_detailed_error(
5202 "Attempt to append NEW_TOKEN frame and not in IETF QUIC.");
5203 return RaiseError(QUIC_INTERNAL_ERROR);
5204 case MAX_STREAMS_FRAME:
5205 set_detailed_error(
5206 "Attempt to append MAX_STREAMS frame and not in IETF QUIC.");
5207 return RaiseError(QUIC_INTERNAL_ERROR);
5208 case STREAMS_BLOCKED_FRAME:
5209 set_detailed_error(
5210 "Attempt to append STREAMS_BLOCKED frame and not in IETF QUIC.");
5211 return RaiseError(QUIC_INTERNAL_ERROR);
5212 case PATH_RESPONSE_FRAME:
5213 set_detailed_error(
5214 "Attempt to append PATH_RESPONSE frame and not in IETF QUIC.");
5215 return RaiseError(QUIC_INTERNAL_ERROR);
5216 case PATH_CHALLENGE_FRAME:
5217 set_detailed_error(
5218 "Attempt to append PATH_CHALLENGE frame and not in IETF QUIC.");
5219 return RaiseError(QUIC_INTERNAL_ERROR);
5220 case STOP_SENDING_FRAME:
5221 set_detailed_error(
5222 "Attempt to append STOP_SENDING frame and not in IETF QUIC.");
5223 return RaiseError(QUIC_INTERNAL_ERROR);
5224 case MESSAGE_FRAME:
5225 return true;
5226
5227 default:
5228 type_byte = static_cast<uint8_t>(frame.type);
5229 break;
5230 }
5231
5232 return writer->WriteUInt8(type_byte);
5233}
5234
5235bool QuicFramer::AppendIetfFrameType(const QuicFrame& frame,
5236 bool last_frame_in_packet,
5237 QuicDataWriter* writer) {
5238 uint8_t type_byte = 0;
5239 switch (frame.type) {
5240 case PADDING_FRAME:
5241 type_byte = IETF_PADDING;
5242 break;
5243 case RST_STREAM_FRAME:
5244 type_byte = IETF_RST_STREAM;
5245 break;
5246 case CONNECTION_CLOSE_FRAME:
5247 switch (frame.connection_close_frame->close_type) {
5248 case IETF_QUIC_APPLICATION_CONNECTION_CLOSE:
5249 type_byte = IETF_APPLICATION_CLOSE;
5250 break;
5251 case IETF_QUIC_TRANSPORT_CONNECTION_CLOSE:
5252 type_byte = IETF_CONNECTION_CLOSE;
5253 break;
5254 default:
5255 set_detailed_error(absl::StrCat(
5256 "Invalid QuicConnectionCloseFrame type: ",
5257 static_cast<int>(frame.connection_close_frame->close_type)));
5258 return RaiseError(QUIC_INTERNAL_ERROR);
5259 }
5260 break;
5261 case GOAWAY_FRAME:
5262 set_detailed_error(
5263 "Attempt to create non-IETF QUIC GOAWAY frame in IETF QUIC.");
5264 return RaiseError(QUIC_INTERNAL_ERROR);
5265 case WINDOW_UPDATE_FRAME:
5266 // Depending on whether there is a stream ID or not, will be either a
5267 // MAX_STREAM_DATA frame or a MAX_DATA frame.
5268 if (frame.window_update_frame.stream_id ==
5269 QuicUtils::GetInvalidStreamId(transport_version())) {
5270 type_byte = IETF_MAX_DATA;
5271 } else {
5272 type_byte = IETF_MAX_STREAM_DATA;
5273 }
5274 break;
5275 case BLOCKED_FRAME:
5276 if (frame.blocked_frame.stream_id ==
5277 QuicUtils::GetInvalidStreamId(transport_version())) {
5278 type_byte = IETF_DATA_BLOCKED;
5279 } else {
5280 type_byte = IETF_STREAM_DATA_BLOCKED;
5281 }
5282 break;
5283 case STOP_WAITING_FRAME:
5284 set_detailed_error(
5285 "Attempt to append type byte of STOP WAITING frame in IETF QUIC.");
5286 return RaiseError(QUIC_INTERNAL_ERROR);
5287 case PING_FRAME:
5288 type_byte = IETF_PING;
5289 break;
5290 case STREAM_FRAME:
5291 type_byte =
5292 GetStreamFrameTypeByte(frame.stream_frame, last_frame_in_packet);
5293 break;
5294 case ACK_FRAME:
5295 // Do nothing here, AppendIetfAckFrameAndTypeByte() will put the type byte
5296 // in the buffer.
5297 return true;
5298 case MTU_DISCOVERY_FRAME:
5299 // The path MTU discovery frame is encoded as a PING frame on the wire.
5300 type_byte = IETF_PING;
5301 break;
5302 case NEW_CONNECTION_ID_FRAME:
5303 type_byte = IETF_NEW_CONNECTION_ID;
5304 break;
5305 case RETIRE_CONNECTION_ID_FRAME:
5306 type_byte = IETF_RETIRE_CONNECTION_ID;
5307 break;
5308 case NEW_TOKEN_FRAME:
5309 type_byte = IETF_NEW_TOKEN;
5310 break;
5311 case MAX_STREAMS_FRAME:
5312 if (frame.max_streams_frame.unidirectional) {
5313 type_byte = IETF_MAX_STREAMS_UNIDIRECTIONAL;
5314 } else {
5315 type_byte = IETF_MAX_STREAMS_BIDIRECTIONAL;
5316 }
5317 break;
5318 case STREAMS_BLOCKED_FRAME:
5319 if (frame.streams_blocked_frame.unidirectional) {
5320 type_byte = IETF_STREAMS_BLOCKED_UNIDIRECTIONAL;
5321 } else {
5322 type_byte = IETF_STREAMS_BLOCKED_BIDIRECTIONAL;
5323 }
5324 break;
5325 case PATH_RESPONSE_FRAME:
5326 type_byte = IETF_PATH_RESPONSE;
5327 break;
5328 case PATH_CHALLENGE_FRAME:
5329 type_byte = IETF_PATH_CHALLENGE;
5330 break;
5331 case STOP_SENDING_FRAME:
5332 type_byte = IETF_STOP_SENDING;
5333 break;
5334 case MESSAGE_FRAME:
5335 return true;
5336 case CRYPTO_FRAME:
5337 type_byte = IETF_CRYPTO;
5338 break;
5339 case HANDSHAKE_DONE_FRAME:
5340 type_byte = IETF_HANDSHAKE_DONE;
5341 break;
5342 case ACK_FREQUENCY_FRAME:
5343 type_byte = IETF_ACK_FREQUENCY;
5344 break;
5345 default:
5346 QUIC_BUG(quic_bug_10850_75)
5347 << "Attempt to generate a frame type for an unsupported value: "
5348 << frame.type;
5349 return false;
5350 }
5351 return writer->WriteVarInt62(type_byte);
5352}
5353
5354// static
5355bool QuicFramer::AppendPacketNumber(QuicPacketNumberLength packet_number_length,
5356 QuicPacketNumber packet_number,
5357 QuicDataWriter* writer) {
5358 QUICHE_DCHECK(packet_number.IsInitialized());
5359 if (!IsValidPacketNumberLength(packet_number_length)) {
5360 QUIC_BUG(quic_bug_10850_76)
5361 << "Invalid packet_number_length: " << packet_number_length;
5362 return false;
5363 }
5364 return writer->WriteBytesToUInt64(packet_number_length,
5365 packet_number.ToUint64());
5366}
5367
5368// static
5369bool QuicFramer::AppendStreamId(size_t stream_id_length, QuicStreamId stream_id,
5370 QuicDataWriter* writer) {
5371 if (stream_id_length == 0 || stream_id_length > 4) {
5372 QUIC_BUG(quic_bug_10850_77)
5373 << "Invalid stream_id_length: " << stream_id_length;
5374 return false;
5375 }
5376 return writer->WriteBytesToUInt64(stream_id_length, stream_id);
5377}
5378
5379// static
5380bool QuicFramer::AppendStreamOffset(size_t offset_length,
5381 QuicStreamOffset offset,
5382 QuicDataWriter* writer) {
5383 if (offset_length == 1 || offset_length > 8) {
5384 QUIC_BUG(quic_bug_10850_78)
5385 << "Invalid stream_offset_length: " << offset_length;
5386 return false;
5387 }
5388
5389 return writer->WriteBytesToUInt64(offset_length, offset);
5390}
5391
5392// static
5393bool QuicFramer::AppendAckBlock(uint8_t gap,
5394 QuicPacketNumberLength length_length,
5395 uint64_t length, QuicDataWriter* writer) {
5396 if (length == 0) {
5397 if (!IsValidPacketNumberLength(length_length)) {
5398 QUIC_BUG(quic_bug_10850_79)
5399 << "Invalid packet_number_length: " << length_length;
5400 return false;
5401 }
5402 return writer->WriteUInt8(gap) &&
5403 writer->WriteBytesToUInt64(length_length, length);
5404 }
5405 return writer->WriteUInt8(gap) &&
5406 AppendPacketNumber(length_length, QuicPacketNumber(length), writer);
5407}
5408
5409bool QuicFramer::AppendStreamFrame(const QuicStreamFrame& frame,
5410 bool no_stream_frame_length,
5411 QuicDataWriter* writer) {
5412 if (VersionHasIetfQuicFrames(version_.transport_version)) {
5413 return AppendIetfStreamFrame(frame, no_stream_frame_length, writer);
5414 }
5415 if (!AppendStreamId(GetStreamIdSize(frame.stream_id), frame.stream_id,
5416 writer)) {
5417 QUIC_BUG(quic_bug_10850_80) << "Writing stream id size failed.";
5418 return false;
5419 }
5420 if (!AppendStreamOffset(GetStreamOffsetSize(frame.offset), frame.offset,
5421 writer)) {
5422 QUIC_BUG(quic_bug_10850_81) << "Writing offset size failed.";
5423 return false;
5424 }
5425 if (!no_stream_frame_length) {
5426 static_assert(
5427 std::numeric_limits<decltype(frame.data_length)>::max() <=
5428 std::numeric_limits<uint16_t>::max(),
5429 "If frame.data_length can hold more than a uint16_t than we need to "
5430 "check that frame.data_length <= std::numeric_limits<uint16_t>::max()");
5431 if (!writer->WriteUInt16(static_cast<uint16_t>(frame.data_length))) {
5432 QUIC_BUG(quic_bug_10850_82) << "Writing stream frame length failed";
5433 return false;
5434 }
5435 }
5436
5437 if (data_producer_ != nullptr) {
5438 QUICHE_DCHECK_EQ(nullptr, frame.data_buffer);
5439 if (frame.data_length == 0) {
5440 return true;
5441 }
5442 if (data_producer_->WriteStreamData(frame.stream_id, frame.offset,
5443 frame.data_length,
5444 writer) != WRITE_SUCCESS) {
5445 QUIC_BUG(quic_bug_10850_83) << "Writing frame data failed.";
5446 return false;
5447 }
5448 return true;
5449 }
5450
5451 if (!writer->WriteBytes(frame.data_buffer, frame.data_length)) {
5452 QUIC_BUG(quic_bug_10850_84) << "Writing frame data failed.";
5453 return false;
5454 }
5455 return true;
5456}
5457
5458bool QuicFramer::AppendNewTokenFrame(const QuicNewTokenFrame& frame,
5459 QuicDataWriter* writer) {
5460 if (!writer->WriteVarInt62(static_cast<uint64_t>(frame.token.length()))) {
5461 set_detailed_error("Writing token length failed.");
5462 return false;
5463 }
5464 if (!writer->WriteBytes(frame.token.data(), frame.token.length())) {
5465 set_detailed_error("Writing token buffer failed.");
5466 return false;
5467 }
5468 return true;
5469}
5470
5471bool QuicFramer::ProcessNewTokenFrame(QuicDataReader* reader,
5472 QuicNewTokenFrame* frame) {
5473 uint64_t length;
5474 if (!reader->ReadVarInt62(&length)) {
5475 set_detailed_error("Unable to read new token length.");
5476 return false;
5477 }
5478 if (length > kMaxNewTokenTokenLength) {
5479 set_detailed_error("Token length larger than maximum.");
5480 return false;
5481 }
5482
5483 // TODO(ianswett): Don't use absl::string_view as an intermediary.
5484 absl::string_view data;
5485 if (!reader->ReadStringPiece(&data, length)) {
5486 set_detailed_error("Unable to read new token data.");
5487 return false;
5488 }
5489 frame->token = std::string(data);
5490 return true;
5491}
5492
5493// Add a new ietf-format stream frame.
5494// Bits controlling whether there is a frame-length and frame-offset
5495// are in the QuicStreamFrame.
5496bool QuicFramer::AppendIetfStreamFrame(const QuicStreamFrame& frame,
5497 bool last_frame_in_packet,
5498 QuicDataWriter* writer) {
5499 if (!writer->WriteVarInt62(static_cast<uint64_t>(frame.stream_id))) {
5500 set_detailed_error("Writing stream id failed.");
5501 return false;
5502 }
5503
5504 if (frame.offset != 0) {
5505 if (!writer->WriteVarInt62(static_cast<uint64_t>(frame.offset))) {
5506 set_detailed_error("Writing data offset failed.");
5507 return false;
5508 }
5509 }
5510
5511 if (!last_frame_in_packet) {
5512 if (!writer->WriteVarInt62(frame.data_length)) {
5513 set_detailed_error("Writing data length failed.");
5514 return false;
5515 }
5516 }
5517
5518 if (frame.data_length == 0) {
5519 return true;
5520 }
5521 if (data_producer_ == nullptr) {
5522 if (!writer->WriteBytes(frame.data_buffer, frame.data_length)) {
5523 set_detailed_error("Writing frame data failed.");
5524 return false;
5525 }
5526 } else {
5527 QUICHE_DCHECK_EQ(nullptr, frame.data_buffer);
5528
5529 if (data_producer_->WriteStreamData(frame.stream_id, frame.offset,
5530 frame.data_length,
5531 writer) != WRITE_SUCCESS) {
5532 set_detailed_error("Writing frame data from producer failed.");
5533 return false;
5534 }
5535 }
5536 return true;
5537}
5538
5539bool QuicFramer::AppendCryptoFrame(const QuicCryptoFrame& frame,
5540 QuicDataWriter* writer) {
5541 if (!writer->WriteVarInt62(static_cast<uint64_t>(frame.offset))) {
5542 set_detailed_error("Writing data offset failed.");
5543 return false;
5544 }
5545 if (!writer->WriteVarInt62(static_cast<uint64_t>(frame.data_length))) {
5546 set_detailed_error("Writing data length failed.");
5547 return false;
5548 }
5549 if (data_producer_ == nullptr) {
5550 if (frame.data_buffer == nullptr ||
5551 !writer->WriteBytes(frame.data_buffer, frame.data_length)) {
5552 set_detailed_error("Writing frame data failed.");
5553 return false;
5554 }
5555 } else {
5556 QUICHE_DCHECK_EQ(nullptr, frame.data_buffer);
5557 if (!data_producer_->WriteCryptoData(frame.level, frame.offset,
5558 frame.data_length, writer)) {
5559 return false;
5560 }
5561 }
5562 return true;
5563}
5564
5565bool QuicFramer::AppendAckFrequencyFrame(const QuicAckFrequencyFrame& frame,
5566 QuicDataWriter* writer) {
5567 if (!writer->WriteVarInt62(frame.sequence_number)) {
5568 set_detailed_error("Writing sequence number failed.");
5569 return false;
5570 }
5571 if (!writer->WriteVarInt62(frame.packet_tolerance)) {
5572 set_detailed_error("Writing packet tolerance failed.");
5573 return false;
5574 }
5575 if (!writer->WriteVarInt62(
5576 static_cast<uint64_t>(frame.max_ack_delay.ToMicroseconds()))) {
5577 set_detailed_error("Writing max_ack_delay_us failed.");
5578 return false;
5579 }
5580 if (!writer->WriteUInt8(static_cast<uint8_t>(frame.ignore_order))) {
5581 set_detailed_error("Writing ignore_order failed.");
5582 return false;
5583 }
5584
5585 return true;
5586}
5587
5588void QuicFramer::set_version(const ParsedQuicVersion version) {
5589 QUICHE_DCHECK(IsSupportedVersion(version))
5590 << ParsedQuicVersionToString(version);
5591 version_ = version;
5592}
5593
5594bool QuicFramer::AppendAckFrameAndTypeByte(const QuicAckFrame& frame,
5595 QuicDataWriter* writer) {
5596 if (VersionHasIetfQuicFrames(transport_version())) {
5597 return AppendIetfAckFrameAndTypeByte(frame, writer);
5598 }
5599
5600 const AckFrameInfo new_ack_info = GetAckFrameInfo(frame);
5601 QuicPacketNumber largest_acked = LargestAcked(frame);
5602 QuicPacketNumberLength largest_acked_length =
5603 GetMinPacketNumberLength(largest_acked);
5604 QuicPacketNumberLength ack_block_length =
5605 GetMinPacketNumberLength(QuicPacketNumber(new_ack_info.max_block_length));
5606 // Calculate available bytes for timestamps and ack blocks.
5607 int32_t available_timestamp_and_ack_block_bytes =
5608 writer->capacity() - writer->length() - ack_block_length -
5609 GetMinAckFrameSize(version_.transport_version, frame,
5610 local_ack_delay_exponent_,
5611 UseIetfAckWithReceiveTimestamp(frame)) -
5612 (new_ack_info.num_ack_blocks != 0 ? kNumberOfAckBlocksSize : 0);
5613 QUICHE_DCHECK_LE(0, available_timestamp_and_ack_block_bytes);
5614
5615 uint8_t type_byte = 0;
5616 SetBit(&type_byte, new_ack_info.num_ack_blocks != 0,
5617 kQuicHasMultipleAckBlocksOffset);
5618
5619 SetBits(&type_byte, GetPacketNumberFlags(largest_acked_length),
5620 kQuicSequenceNumberLengthNumBits, kLargestAckedOffset);
5621
5622 SetBits(&type_byte, GetPacketNumberFlags(ack_block_length),
5623 kQuicSequenceNumberLengthNumBits, kActBlockLengthOffset);
5624
5625 type_byte |= kQuicFrameTypeAckMask;
5626
5627 if (!writer->WriteUInt8(type_byte)) {
5628 return false;
5629 }
5630
5631 size_t max_num_ack_blocks = available_timestamp_and_ack_block_bytes /
5632 (ack_block_length + PACKET_1BYTE_PACKET_NUMBER);
5633
5634 // Number of ack blocks.
5635 size_t num_ack_blocks =
5636 std::min(new_ack_info.num_ack_blocks, max_num_ack_blocks);
5637 if (num_ack_blocks > std::numeric_limits<uint8_t>::max()) {
5638 num_ack_blocks = std::numeric_limits<uint8_t>::max();
5639 }
5640
5641 // Largest acked.
5642 if (!AppendPacketNumber(largest_acked_length, largest_acked, writer)) {
5643 return false;
5644 }
5645
5646 // Largest acked delta time.
5647 uint64_t ack_delay_time_us = kUFloat16MaxValue;
5648 if (!frame.ack_delay_time.IsInfinite()) {
5649 QUICHE_DCHECK_LE(0u, frame.ack_delay_time.ToMicroseconds());
5650 ack_delay_time_us = frame.ack_delay_time.ToMicroseconds();
5651 }
5652 if (!writer->WriteUFloat16(ack_delay_time_us)) {
5653 return false;
5654 }
5655
5656 if (num_ack_blocks > 0) {
5657 if (!writer->WriteBytes(&num_ack_blocks, 1)) {
5658 return false;
5659 }
5660 }
5661
5662 // First ack block length.
5663 if (!AppendPacketNumber(ack_block_length,
5664 QuicPacketNumber(new_ack_info.first_block_length),
5665 writer)) {
5666 return false;
5667 }
5668
5669 // Ack blocks.
5670 if (num_ack_blocks > 0) {
5671 size_t num_ack_blocks_written = 0;
5672 // Append, in descending order from the largest ACKed packet, a series of
5673 // ACK blocks that represents the successfully acknoweldged packets. Each
5674 // appended gap/block length represents a descending delta from the previous
5675 // block. i.e.:
5676 // |--- length ---|--- gap ---|--- length ---|--- gap ---|--- largest ---|
5677 // For gaps larger than can be represented by a single encoded gap, a 0
5678 // length gap of the maximum is used, i.e.:
5679 // |--- length ---|--- gap ---|- 0 -|--- gap ---|--- largest ---|
5680 auto itr = frame.packets.rbegin();
5681 QuicPacketNumber previous_start = itr->min();
5682 ++itr;
5683
5684 for (;
5685 itr != frame.packets.rend() && num_ack_blocks_written < num_ack_blocks;
5686 previous_start = itr->min(), ++itr) {
5687 const auto& interval = *itr;
5688 const uint64_t total_gap = previous_start - interval.max();
5689 const size_t num_encoded_gaps =
5690 (total_gap + std::numeric_limits<uint8_t>::max() - 1) /
5691 std::numeric_limits<uint8_t>::max();
5692
5693 // Append empty ACK blocks because the gap is longer than a single gap.
5694 for (size_t i = 1;
5695 i < num_encoded_gaps && num_ack_blocks_written < num_ack_blocks;
5696 ++i) {
5697 if (!AppendAckBlock(std::numeric_limits<uint8_t>::max(),
5698 ack_block_length, 0, writer)) {
5699 return false;
5700 }
5701 ++num_ack_blocks_written;
5702 }
5703 if (num_ack_blocks_written >= num_ack_blocks) {
5704 if (QUIC_PREDICT_FALSE(num_ack_blocks_written != num_ack_blocks)) {
5705 QUIC_BUG(quic_bug_10850_85)
5706 << "Wrote " << num_ack_blocks_written << ", expected to write "
5707 << num_ack_blocks;
5708 }
5709 break;
5710 }
5711
5712 const uint8_t last_gap =
5713 total_gap -
5714 (num_encoded_gaps - 1) * std::numeric_limits<uint8_t>::max();
5715 // Append the final ACK block with a non-empty size.
5716 if (!AppendAckBlock(last_gap, ack_block_length, interval.Length(),
5717 writer)) {
5718 return false;
5719 }
5720 ++num_ack_blocks_written;
5721 }
5722 QUICHE_DCHECK_EQ(num_ack_blocks, num_ack_blocks_written);
5723 }
5724 // Timestamps.
5725 // If we don't process timestamps or if we don't have enough available space
5726 // to append all the timestamps, don't append any of them.
5727 if (process_timestamps_ && writer->capacity() - writer->length() >=
5728 GetAckFrameTimeStampSize(frame)) {
5729 if (!AppendTimestampsToAckFrame(frame, writer)) {
5730 return false;
5731 }
5732 } else {
5733 uint8_t num_received_packets = 0;
5734 if (!writer->WriteBytes(&num_received_packets, 1)) {
5735 return false;
5736 }
5737 }
5738
5739 return true;
5740}
5741
5742bool QuicFramer::AppendTimestampsToAckFrame(const QuicAckFrame& frame,
5743 QuicDataWriter* writer) {
5744 QUICHE_DCHECK_GE(std::numeric_limits<uint8_t>::max(),
5745 frame.received_packet_times.size());
5746 // num_received_packets is only 1 byte.
5747 if (frame.received_packet_times.size() >
5748 std::numeric_limits<uint8_t>::max()) {
5749 return false;
5750 }
5751
5752 uint8_t num_received_packets = frame.received_packet_times.size();
5753 if (!writer->WriteBytes(&num_received_packets, 1)) {
5754 return false;
5755 }
5756 if (num_received_packets == 0) {
5757 return true;
5758 }
5759
5760 auto it = frame.received_packet_times.begin();
5761 QuicPacketNumber packet_number = it->first;
5762 uint64_t delta_from_largest_observed = LargestAcked(frame) - packet_number;
5763
5764 QUICHE_DCHECK_GE(std::numeric_limits<uint8_t>::max(),
5765 delta_from_largest_observed);
5766 if (delta_from_largest_observed > std::numeric_limits<uint8_t>::max()) {
5767 return false;
5768 }
5769
5770 if (!writer->WriteUInt8(delta_from_largest_observed)) {
5771 return false;
5772 }
5773
5774 // Use the lowest 4 bytes of the time delta from the creation_time_.
5775 const uint64_t time_epoch_delta_us = UINT64_C(1) << 32;
5776 uint32_t time_delta_us =
5777 static_cast<uint32_t>((it->second - creation_time_).ToMicroseconds() &
5778 (time_epoch_delta_us - 1));
5779 if (!writer->WriteUInt32(time_delta_us)) {
5780 return false;
5781 }
5782
5783 QuicTime prev_time = it->second;
5784
5785 for (++it; it != frame.received_packet_times.end(); ++it) {
5786 packet_number = it->first;
5787 delta_from_largest_observed = LargestAcked(frame) - packet_number;
5788
5789 if (delta_from_largest_observed > std::numeric_limits<uint8_t>::max()) {
5790 return false;
5791 }
5792
5793 if (!writer->WriteUInt8(delta_from_largest_observed)) {
5794 return false;
5795 }
5796
5797 uint64_t frame_time_delta_us = (it->second - prev_time).ToMicroseconds();
5798 prev_time = it->second;
5799 if (!writer->WriteUFloat16(frame_time_delta_us)) {
5800 return false;
5801 }
5802 }
5803 return true;
5804}
5805
5806absl::InlinedVector<QuicFramer::AckTimestampRange, 2>
5807QuicFramer::GetAckTimestampRanges(const QuicAckFrame& frame,
5808 std::string& detailed_error) const {
5809 detailed_error = "";
5810 if (frame.received_packet_times.empty()) {
5811 return {};
5812 }
5813
5814 absl::InlinedVector<AckTimestampRange, 2> timestamp_ranges;
5815
5816 for (size_t r = 0; r < std::min<size_t>(max_receive_timestamps_per_ack_,
5817 frame.received_packet_times.size());
5818 ++r) {
5819 const size_t i = frame.received_packet_times.size() - 1 - r;
5820 const QuicPacketNumber packet_number = frame.received_packet_times[i].first;
5821 const QuicTime receive_timestamp = frame.received_packet_times[i].second;
5822
5823 if (timestamp_ranges.empty()) {
5824 if (receive_timestamp < creation_time_ ||
5825 LargestAcked(frame) < packet_number) {
5826 detailed_error =
5827 "The first packet is either received earlier than framer creation "
5828 "time, or larger than largest acked packet.";
5829 QUIC_BUG(quic_framer_ack_ts_first_packet_bad)
5830 << detailed_error << " receive_timestamp:" << receive_timestamp
5831 << ", framer_creation_time:" << creation_time_
5832 << ", packet_number:" << packet_number
5833 << ", largest_acked:" << LargestAcked(frame);
5834 return {};
5835 }
5836 timestamp_ranges.push_back(AckTimestampRange());
5837 timestamp_ranges.back().gap = LargestAcked(frame) - packet_number;
5838 timestamp_ranges.back().range_begin = i;
5839 timestamp_ranges.back().range_end = i;
5840 continue;
5841 }
5842
5843 const size_t prev_i = timestamp_ranges.back().range_end;
5844 const QuicPacketNumber prev_packet_number =
5845 frame.received_packet_times[prev_i].first;
5846 const QuicTime prev_receive_timestamp =
5847 frame.received_packet_times[prev_i].second;
5848
5849 QUIC_DVLOG(3) << "prev_packet_number:" << prev_packet_number
5850 << ", packet_number:" << packet_number;
5851 if (prev_receive_timestamp < receive_timestamp ||
5852 prev_packet_number <= packet_number) {
5853 detailed_error = "Packet number and/or receive time not in order.";
5854 QUIC_BUG(quic_framer_ack_ts_packet_out_of_order)
5855 << detailed_error << " packet_number:" << packet_number
5856 << ", receive_timestamp:" << receive_timestamp
5857 << ", prev_packet_number:" << prev_packet_number
5858 << ", prev_receive_timestamp:" << prev_receive_timestamp;
5859 return {};
5860 }
5861
5862 if (prev_packet_number == packet_number + 1) {
5863 timestamp_ranges.back().range_end = i;
5864 } else {
5865 timestamp_ranges.push_back(AckTimestampRange());
5866 timestamp_ranges.back().gap = prev_packet_number - 2 - packet_number;
5867 timestamp_ranges.back().range_begin = i;
5868 timestamp_ranges.back().range_end = i;
5869 }
5870 }
5871
5872 return timestamp_ranges;
5873}
5874
5875int64_t QuicFramer::FrameAckTimestampRanges(
5876 const QuicAckFrame& frame,
5877 const absl::InlinedVector<AckTimestampRange, 2>& timestamp_ranges,
5878 QuicDataWriter* writer) const {
5879 int64_t size = 0;
5880 auto maybe_write_var_int62 = [&](uint64_t value) {
5881 size += QuicDataWriter::GetVarInt62Len(value);
5882 if (writer != nullptr && !writer->WriteVarInt62(value)) {
5883 return false;
5884 }
5885 return true;
5886 };
5887
5888 if (!maybe_write_var_int62(timestamp_ranges.size())) {
5889 return -1;
5890 }
5891
5892 // |effective_prev_time| is the exponent-encoded timestamp of the previous
5893 // packet.
5894 absl::optional<QuicTime> effective_prev_time;
5895 for (const AckTimestampRange& range : timestamp_ranges) {
5896 QUIC_DVLOG(3) << "Range: gap:" << range.gap << ", beg:" << range.range_begin
5897 << ", end:" << range.range_end;
5898 if (!maybe_write_var_int62(range.gap)) {
5899 return -1;
5900 }
5901
5902 if (!maybe_write_var_int62(range.range_begin - range.range_end + 1)) {
5903 return -1;
5904 }
5905
5906 for (int64_t i = range.range_begin; i >= range.range_end; --i) {
5907 const QuicTime receive_timestamp = frame.received_packet_times[i].second;
5908 uint64_t time_delta;
5909 if (effective_prev_time.has_value()) {
5910 time_delta =
5911 (*effective_prev_time - receive_timestamp).ToMicroseconds();
5912 QUIC_DVLOG(3) << "time_delta:" << time_delta
5913 << ", exponent:" << receive_timestamps_exponent_
5914 << ", effective_prev_time:" << *effective_prev_time
5915 << ", recv_time:" << receive_timestamp;
5916 time_delta = time_delta >> receive_timestamps_exponent_;
5917 effective_prev_time = effective_prev_time.value() -
5918 QuicTime::Delta::FromMicroseconds(
5919 time_delta << receive_timestamps_exponent_);
5920 } else {
5921 // The first delta is from framer creation to the current receive
5922 // timestamp (forward in time), whereas in the common case subsequent
5923 // deltas move backwards in time.
5924 time_delta = (receive_timestamp - creation_time_).ToMicroseconds();
5925 QUIC_DVLOG(3) << "First time_delta:" << time_delta
5926 << ", exponent:" << receive_timestamps_exponent_
5927 << ", recv_time:" << receive_timestamp
5928 << ", creation_time:" << creation_time_;
5929 // Round up the first exponent-encoded time delta so that the next
5930 // receive timestamp is guaranteed to be decreasing.
5931 time_delta = ((time_delta - 1) >> receive_timestamps_exponent_) + 1;
5932 effective_prev_time =
5933 creation_time_ + QuicTime::Delta::FromMicroseconds(
5934 time_delta << receive_timestamps_exponent_);
5935 }
5936
5937 if (!maybe_write_var_int62(time_delta)) {
5938 return -1;
5939 }
5940 }
5941 }
5942
5943 return size;
5944}
5945
5946bool QuicFramer::AppendIetfTimestampsToAckFrame(const QuicAckFrame& frame,
5947 QuicDataWriter* writer) {
5948 QUICHE_DCHECK(!frame.received_packet_times.empty());
5949 std::string detailed_error;
5950 const absl::InlinedVector<AckTimestampRange, 2> timestamp_ranges =
5951 GetAckTimestampRanges(frame, detailed_error);
5952 if (!detailed_error.empty()) {
5953 set_detailed_error(std::move(detailed_error));
5954 return false;
5955 }
5956
5957 // Compute the size first using a null writer.
5958 int64_t size =
5959 FrameAckTimestampRanges(frame, timestamp_ranges, /*writer=*/nullptr);
5960 if (size > static_cast<int64_t>(writer->capacity() - writer->length())) {
5961 QUIC_DVLOG(1) << "Insufficient room to write IETF ack receive timestamps. "
5962 "size_remain:"
5963 << (writer->capacity() - writer->length())
5964 << ", size_needed:" << size;
5965 // Write a Timestamp Range Count of 0.
5966 return writer->WriteVarInt62(0);
5967 }
5968
5969 return FrameAckTimestampRanges(frame, timestamp_ranges, writer) > 0;
5970}
5971
5972bool QuicFramer::AppendStopWaitingFrame(const QuicPacketHeader& header,
5973 const QuicStopWaitingFrame& frame,
5974 QuicDataWriter* writer) {
5975 QUICHE_DCHECK(!version_.HasIetfInvariantHeader());
5976 QUICHE_DCHECK(frame.least_unacked.IsInitialized());
5977 QUICHE_DCHECK_GE(header.packet_number, frame.least_unacked);
5978 const uint64_t least_unacked_delta =
5979 header.packet_number - frame.least_unacked;
5980 const uint64_t length_shift = header.packet_number_length * 8;
5981
5982 if (least_unacked_delta >> length_shift > 0) {
5983 QUIC_BUG(quic_bug_10850_86)
5984 << "packet_number_length " << header.packet_number_length
5985 << " is too small for least_unacked_delta: " << least_unacked_delta
5986 << " packet_number:" << header.packet_number
5987 << " least_unacked:" << frame.least_unacked
5988 << " version:" << version_.transport_version;
5989 return false;
5990 }
5991 if (least_unacked_delta == 0) {
5992 return writer->WriteBytesToUInt64(header.packet_number_length,
5993 least_unacked_delta);
5994 }
5995 if (!AppendPacketNumber(header.packet_number_length,
5996 QuicPacketNumber(least_unacked_delta), writer)) {
5997 QUIC_BUG(quic_bug_10850_87)
5998 << " seq failed: " << header.packet_number_length;
5999 return false;
6000 }
6001
6002 return true;
6003}
6004
6005bool QuicFramer::AppendIetfAckFrameAndTypeByte(const QuicAckFrame& frame,
6006 QuicDataWriter* writer) {
6007 uint8_t type = IETF_ACK;
6008 uint64_t ecn_size = 0;
6009 if (UseIetfAckWithReceiveTimestamp(frame)) {
6010 type = IETF_ACK_RECEIVE_TIMESTAMPS;
6011 } else if (frame.ecn_counters_populated &&
6012 (frame.ect_0_count || frame.ect_1_count || frame.ecn_ce_count)) {
6013 // Change frame type to ACK_ECN if any ECN count is available.
6014 type = IETF_ACK_ECN;
6015 ecn_size = (QuicDataWriter::GetVarInt62Len(frame.ect_0_count) +
6016 QuicDataWriter::GetVarInt62Len(frame.ect_1_count) +
6017 QuicDataWriter::GetVarInt62Len(frame.ecn_ce_count));
6018 }
6019
6020 if (!writer->WriteVarInt62(type)) {
6021 set_detailed_error("No room for frame-type");
6022 return false;
6023 }
6024
6025 QuicPacketNumber largest_acked = LargestAcked(frame);
6026 if (!writer->WriteVarInt62(largest_acked.ToUint64())) {
6027 set_detailed_error("No room for largest-acked in ack frame");
6028 return false;
6029 }
6030
6031 uint64_t ack_delay_time_us = kVarInt62MaxValue;
6032 if (!frame.ack_delay_time.IsInfinite()) {
6033 QUICHE_DCHECK_LE(0u, frame.ack_delay_time.ToMicroseconds());
6034 ack_delay_time_us = frame.ack_delay_time.ToMicroseconds();
6035 ack_delay_time_us = ack_delay_time_us >> local_ack_delay_exponent_;
6036 }
6037
6038 if (!writer->WriteVarInt62(ack_delay_time_us)) {
6039 set_detailed_error("No room for ack-delay in ack frame");
6040 return false;
6041 }
6042
6043 if (frame.packets.Empty() || frame.packets.Max() != largest_acked) {
6044 QUIC_BUG(quic_bug_10850_88) << "Malformed ack frame: " << frame;
6045 set_detailed_error("Malformed ack frame");
6046 return false;
6047 }
6048
6049 // Latch ack_block_count for potential truncation.
6050 const uint64_t ack_block_count = frame.packets.NumIntervals() - 1;
6051 QuicDataWriter count_writer(QuicDataWriter::GetVarInt62Len(ack_block_count),
6052 writer->data() + writer->length());
6053 if (!writer->WriteVarInt62(ack_block_count)) {
6054 set_detailed_error("No room for ack block count in ack frame");
6055 return false;
6056 }
6057 auto iter = frame.packets.rbegin();
6058 if (!writer->WriteVarInt62(iter->Length() - 1)) {
6059 set_detailed_error("No room for first ack block in ack frame");
6060 return false;
6061 }
6062 QuicPacketNumber previous_smallest = iter->min();
6063 ++iter;
6064 // Append remaining ACK blocks.
6065 uint64_t appended_ack_blocks = 0;
6066 for (; iter != frame.packets.rend(); ++iter) {
6067 const uint64_t gap = previous_smallest - iter->max() - 1;
6068 const uint64_t ack_range = iter->Length() - 1;
6069
6070 if (type == IETF_ACK_RECEIVE_TIMESTAMPS &&
6071 writer->remaining() <
6072 static_cast<size_t>(QuicDataWriter::GetVarInt62Len(gap) +
6073 QuicDataWriter::GetVarInt62Len(ack_range) +
6074 QuicDataWriter::GetVarInt62Len(0))) {
6075 // If we write this ACK range we won't have space for a timestamp range
6076 // count of 0.
6077 break;
6078 } else if (writer->remaining() < ecn_size ||
6079 writer->remaining() - ecn_size <
6080 static_cast<size_t>(
6081 QuicDataWriter::GetVarInt62Len(gap) +
6082 QuicDataWriter::GetVarInt62Len(ack_range))) {
6083 // ACK range does not fit, truncate it.
6084 break;
6085 }
6086 const bool success =
6087 writer->WriteVarInt62(gap) && writer->WriteVarInt62(ack_range);
6088 QUICHE_DCHECK(success);
6089 previous_smallest = iter->min();
6090 ++appended_ack_blocks;
6091 }
6092
6093 if (appended_ack_blocks < ack_block_count) {
6094 // Truncation is needed, rewrite the ack block count.
6095 if (QuicDataWriter::GetVarInt62Len(appended_ack_blocks) !=
6096 QuicDataWriter::GetVarInt62Len(ack_block_count) ||
6097 !count_writer.WriteVarInt62(appended_ack_blocks)) {
6098 // This should never happen as ack_block_count is limited by
6099 // max_ack_ranges_.
6100 QUIC_BUG(quic_bug_10850_89)
6101 << "Ack frame truncation fails. ack_block_count: " << ack_block_count
6102 << ", appended count: " << appended_ack_blocks;
6103 set_detailed_error("ACK frame truncation fails");
6104 return false;
6105 }
6106 QUIC_DLOG(INFO) << ENDPOINT << "ACK ranges get truncated from "
6107 << ack_block_count << " to " << appended_ack_blocks;
6108 }
6109
6110 if (type == IETF_ACK_ECN) {
6111 // Encode the ECN counts.
6112 if (!writer->WriteVarInt62(frame.ect_0_count)) {
6113 set_detailed_error("No room for ect_0_count in ack frame");
6114 return false;
6115 }
6116 if (!writer->WriteVarInt62(frame.ect_1_count)) {
6117 set_detailed_error("No room for ect_1_count in ack frame");
6118 return false;
6119 }
6120 if (!writer->WriteVarInt62(frame.ecn_ce_count)) {
6121 set_detailed_error("No room for ecn_ce_count in ack frame");
6122 return false;
6123 }
6124 }
6125
6126 if (type == IETF_ACK_RECEIVE_TIMESTAMPS) {
6127 if (!AppendIetfTimestampsToAckFrame(frame, writer)) {
6128 return false;
6129 }
6130 }
6131
6132 return true;
6133}
6134
6135bool QuicFramer::AppendRstStreamFrame(const QuicRstStreamFrame& frame,
6136 QuicDataWriter* writer) {
6137 if (VersionHasIetfQuicFrames(version_.transport_version)) {
6138 return AppendIetfResetStreamFrame(frame, writer);
6139 }
6140 if (!writer->WriteUInt32(frame.stream_id)) {
6141 return false;
6142 }
6143
6144 if (!writer->WriteUInt64(frame.byte_offset)) {
6145 return false;
6146 }
6147
6148 uint32_t error_code = static_cast<uint32_t>(frame.error_code);
6149 if (!writer->WriteUInt32(error_code)) {
6150 return false;
6151 }
6152
6153 return true;
6154}
6155
6156bool QuicFramer::AppendConnectionCloseFrame(
6157 const QuicConnectionCloseFrame& frame, QuicDataWriter* writer) {
6158 if (VersionHasIetfQuicFrames(version_.transport_version)) {
6159 return AppendIetfConnectionCloseFrame(frame, writer);
6160 }
6161 uint32_t error_code = static_cast<uint32_t>(frame.wire_error_code);
6162 if (!writer->WriteUInt32(error_code)) {
6163 return false;
6164 }
6165 if (!writer->WriteStringPiece16(TruncateErrorString(frame.error_details))) {
6166 return false;
6167 }
6168 return true;
6169}
6170
6171bool QuicFramer::AppendGoAwayFrame(const QuicGoAwayFrame& frame,
6172 QuicDataWriter* writer) {
6173 uint32_t error_code = static_cast<uint32_t>(frame.error_code);
6174 if (!writer->WriteUInt32(error_code)) {
6175 return false;
6176 }
6177 uint32_t stream_id = static_cast<uint32_t>(frame.last_good_stream_id);
6178 if (!writer->WriteUInt32(stream_id)) {
6179 return false;
6180 }
6181 if (!writer->WriteStringPiece16(TruncateErrorString(frame.reason_phrase))) {
6182 return false;
6183 }
6184 return true;
6185}
6186
6187bool QuicFramer::AppendWindowUpdateFrame(const QuicWindowUpdateFrame& frame,
6188 QuicDataWriter* writer) {
6189 uint32_t stream_id = static_cast<uint32_t>(frame.stream_id);
6190 if (!writer->WriteUInt32(stream_id)) {
6191 return false;
6192 }
6193 if (!writer->WriteUInt64(frame.max_data)) {
6194 return false;
6195 }
6196 return true;
6197}
6198
6199bool QuicFramer::AppendBlockedFrame(const QuicBlockedFrame& frame,
6200 QuicDataWriter* writer) {
6201 if (VersionHasIetfQuicFrames(version_.transport_version)) {
6202 if (frame.stream_id == QuicUtils::GetInvalidStreamId(transport_version())) {
6203 return AppendDataBlockedFrame(frame, writer);
6204 }
6205 return AppendStreamDataBlockedFrame(frame, writer);
6206 }
6207 uint32_t stream_id = static_cast<uint32_t>(frame.stream_id);
6208 if (!writer->WriteUInt32(stream_id)) {
6209 return false;
6210 }
6211 return true;
6212}
6213
6214bool QuicFramer::AppendPaddingFrame(const QuicPaddingFrame& frame,
6215 QuicDataWriter* writer) {
6216 if (frame.num_padding_bytes == 0) {
6217 return false;
6218 }
6219 if (frame.num_padding_bytes < 0) {
6220 QUIC_BUG_IF(quic_bug_12975_9, frame.num_padding_bytes != -1);
6221 writer->WritePadding();
6222 return true;
6223 }
6224 // Please note, num_padding_bytes includes type byte which has been written.
6225 return writer->WritePaddingBytes(frame.num_padding_bytes - 1);
6226}
6227
6228bool QuicFramer::AppendMessageFrameAndTypeByte(const QuicMessageFrame& frame,
6229 bool last_frame_in_packet,
6230 QuicDataWriter* writer) {
6231 uint8_t type_byte;
6232 if (VersionHasIetfQuicFrames(version_.transport_version)) {
6233 type_byte = last_frame_in_packet ? IETF_EXTENSION_MESSAGE_NO_LENGTH_V99
6234 : IETF_EXTENSION_MESSAGE_V99;
6235 } else {
6236 type_byte = last_frame_in_packet ? IETF_EXTENSION_MESSAGE_NO_LENGTH
6237 : IETF_EXTENSION_MESSAGE;
6238 }
6239 if (!writer->WriteUInt8(type_byte)) {
6240 return false;
6241 }
6242 if (!last_frame_in_packet && !writer->WriteVarInt62(frame.message_length)) {
6243 return false;
6244 }
6245 for (const auto& slice : frame.message_data) {
6246 if (!writer->WriteBytes(slice.data(), slice.length())) {
6247 return false;
6248 }
6249 }
6250 return true;
6251}
6252
6253bool QuicFramer::RaiseError(QuicErrorCode error) {
6254 QUIC_DLOG(INFO) << ENDPOINT << "Error: " << QuicErrorCodeToString(error)
6255 << " detail: " << detailed_error_;
6256 set_error(error);
6257 if (visitor_) {
6258 visitor_->OnError(this);
6259 }
6260 return false;
6261}
6262
6263bool QuicFramer::IsVersionNegotiation(
6264 const QuicPacketHeader& header, bool packet_has_ietf_packet_header) const {
6265 if (!packet_has_ietf_packet_header &&
6266 perspective_ == Perspective::IS_CLIENT) {
6267 return header.version_flag;
6268 }
6269 if (header.form == IETF_QUIC_SHORT_HEADER_PACKET) {
6270 return false;
6271 }
6272 return header.long_packet_type == VERSION_NEGOTIATION;
6273}
6274
6275bool QuicFramer::AppendIetfConnectionCloseFrame(
6276 const QuicConnectionCloseFrame& frame, QuicDataWriter* writer) {
6277 if (frame.close_type != IETF_QUIC_TRANSPORT_CONNECTION_CLOSE &&
6278 frame.close_type != IETF_QUIC_APPLICATION_CONNECTION_CLOSE) {
6279 QUIC_BUG(quic_bug_10850_90)
6280 << "Invalid close_type for writing IETF CONNECTION CLOSE.";
6281 set_detailed_error("Invalid close_type for writing IETF CONNECTION CLOSE.");
6282 return false;
6283 }
6284
6285 if (!writer->WriteVarInt62(frame.wire_error_code)) {
6286 set_detailed_error("Can not write connection close frame error code");
6287 return false;
6288 }
6289
6290 if (frame.close_type == IETF_QUIC_TRANSPORT_CONNECTION_CLOSE) {
6291 // Write the frame-type of the frame causing the error only
6292 // if it's a CONNECTION_CLOSE/Transport.
6293 if (!writer->WriteVarInt62(frame.transport_close_frame_type)) {
6294 set_detailed_error("Writing frame type failed.");
6295 return false;
6296 }
6297 }
6298
6299 // There may be additional error information available in the extracted error
6300 // code. Encode the error information in the reason phrase and serialize the
6301 // result.
6302 std::string final_error_string =
6303 GenerateErrorString(frame.error_details, frame.quic_error_code);
6304 if (!writer->WriteStringPieceVarInt62(
6305 TruncateErrorString(final_error_string))) {
6306 set_detailed_error("Can not write connection close phrase");
6307 return false;
6308 }
6309 return true;
6310}
6311
6312bool QuicFramer::ProcessIetfConnectionCloseFrame(
6313 QuicDataReader* reader, QuicConnectionCloseType type,
6314 QuicConnectionCloseFrame* frame) {
6315 frame->close_type = type;
6316
6317 uint64_t error_code;
6318 if (!reader->ReadVarInt62(&error_code)) {
6319 set_detailed_error("Unable to read connection close error code.");
6320 return false;
6321 }
6322
6323 frame->wire_error_code = error_code;
6324
6325 if (type == IETF_QUIC_TRANSPORT_CONNECTION_CLOSE) {
6326 // The frame-type of the frame causing the error is present only
6327 // if it's a CONNECTION_CLOSE/Transport.
6328 if (!reader->ReadVarInt62(&frame->transport_close_frame_type)) {
6329 set_detailed_error("Unable to read connection close frame type.");
6330 return false;
6331 }
6332 }
6333
6334 uint64_t phrase_length;
6335 if (!reader->ReadVarInt62(&phrase_length)) {
6336 set_detailed_error("Unable to read connection close error details.");
6337 return false;
6338 }
6339
6340 absl::string_view phrase;
6341 if (!reader->ReadStringPiece(&phrase, static_cast<size_t>(phrase_length))) {
6342 set_detailed_error("Unable to read connection close error details.");
6343 return false;
6344 }
6345 frame->error_details = std::string(phrase);
6346
6347 // The frame may have an extracted error code in it. Look for it and
6348 // extract it. If it's not present, MaybeExtract will return
6349 // QUIC_IETF_GQUIC_ERROR_MISSING.
6350 MaybeExtractQuicErrorCode(frame);
6351 return true;
6352}
6353
6354// IETF Quic Path Challenge/Response frames.
6355bool QuicFramer::ProcessPathChallengeFrame(QuicDataReader* reader,
6356 QuicPathChallengeFrame* frame) {
6357 if (!reader->ReadBytes(frame->data_buffer.data(),
6358 frame->data_buffer.size())) {
6359 set_detailed_error("Can not read path challenge data.");
6360 return false;
6361 }
6362 return true;
6363}
6364
6365bool QuicFramer::ProcessPathResponseFrame(QuicDataReader* reader,
6366 QuicPathResponseFrame* frame) {
6367 if (!reader->ReadBytes(frame->data_buffer.data(),
6368 frame->data_buffer.size())) {
6369 set_detailed_error("Can not read path response data.");
6370 return false;
6371 }
6372 return true;
6373}
6374
6375bool QuicFramer::AppendPathChallengeFrame(const QuicPathChallengeFrame& frame,
6376 QuicDataWriter* writer) {
6377 if (!writer->WriteBytes(frame.data_buffer.data(), frame.data_buffer.size())) {
6378 set_detailed_error("Writing Path Challenge data failed.");
6379 return false;
6380 }
6381 return true;
6382}
6383
6384bool QuicFramer::AppendPathResponseFrame(const QuicPathResponseFrame& frame,
6385 QuicDataWriter* writer) {
6386 if (!writer->WriteBytes(frame.data_buffer.data(), frame.data_buffer.size())) {
6387 set_detailed_error("Writing Path Response data failed.");
6388 return false;
6389 }
6390 return true;
6391}
6392
6393// Add a new ietf-format stream reset frame.
6394// General format is
6395// stream id
6396// application error code
6397// final offset
6398bool QuicFramer::AppendIetfResetStreamFrame(const QuicRstStreamFrame& frame,
6399 QuicDataWriter* writer) {
6400 if (!writer->WriteVarInt62(static_cast<uint64_t>(frame.stream_id))) {
6401 set_detailed_error("Writing reset-stream stream id failed.");
6402 return false;
6403 }
6404 if (!writer->WriteVarInt62(static_cast<uint64_t>(frame.ietf_error_code))) {
6405 set_detailed_error("Writing reset-stream error code failed.");
6406 return false;
6407 }
6408 if (!writer->WriteVarInt62(static_cast<uint64_t>(frame.byte_offset))) {
6409 set_detailed_error("Writing reset-stream final-offset failed.");
6410 return false;
6411 }
6412 return true;
6413}
6414
6415bool QuicFramer::ProcessIetfResetStreamFrame(QuicDataReader* reader,
6416 QuicRstStreamFrame* frame) {
6417 // Get Stream ID from frame. ReadVarIntStreamID returns false
6418 // if either A) there is a read error or B) the resulting value of
6419 // the Stream ID is larger than the maximum allowed value.
6420 if (!ReadUint32FromVarint62(reader, IETF_RST_STREAM, &frame->stream_id)) {
6421 return false;
6422 }
6423
6424 if (!reader->ReadVarInt62(&frame->ietf_error_code)) {
6425 set_detailed_error("Unable to read rst stream error code.");
6426 return false;
6427 }
6428
6429 frame->error_code =
6430 IetfResetStreamErrorCodeToRstStreamErrorCode(frame->ietf_error_code);
6431
6432 if (!reader->ReadVarInt62(&frame->byte_offset)) {
6433 set_detailed_error("Unable to read rst stream sent byte offset.");
6434 return false;
6435 }
6436 return true;
6437}
6438
6439bool QuicFramer::ProcessStopSendingFrame(
6440 QuicDataReader* reader, QuicStopSendingFrame* stop_sending_frame) {
6441 if (!ReadUint32FromVarint62(reader, IETF_STOP_SENDING,
6442 &stop_sending_frame->stream_id)) {
6443 return false;
6444 }
6445
6446 if (!reader->ReadVarInt62(&stop_sending_frame->ietf_error_code)) {
6447 set_detailed_error("Unable to read stop sending application error code.");
6448 return false;
6449 }
6450
6451 stop_sending_frame->error_code = IetfResetStreamErrorCodeToRstStreamErrorCode(
6452 stop_sending_frame->ietf_error_code);
6453 return true;
6454}
6455
6456bool QuicFramer::AppendStopSendingFrame(
6457 const QuicStopSendingFrame& stop_sending_frame, QuicDataWriter* writer) {
6458 if (!writer->WriteVarInt62(stop_sending_frame.stream_id)) {
6459 set_detailed_error("Can not write stop sending stream id");
6460 return false;
6461 }
6462 if (!writer->WriteVarInt62(
6463 static_cast<uint64_t>(stop_sending_frame.ietf_error_code))) {
6464 set_detailed_error("Can not write application error code");
6465 return false;
6466 }
6467 return true;
6468}
6469
6470// Append/process IETF-Format MAX_DATA Frame
6471bool QuicFramer::AppendMaxDataFrame(const QuicWindowUpdateFrame& frame,
6472 QuicDataWriter* writer) {
6473 if (!writer->WriteVarInt62(frame.max_data)) {
6474 set_detailed_error("Can not write MAX_DATA byte-offset");
6475 return false;
6476 }
6477 return true;
6478}
6479
6480bool QuicFramer::ProcessMaxDataFrame(QuicDataReader* reader,
6481 QuicWindowUpdateFrame* frame) {
6482 frame->stream_id = QuicUtils::GetInvalidStreamId(transport_version());
6483 if (!reader->ReadVarInt62(&frame->max_data)) {
6484 set_detailed_error("Can not read MAX_DATA byte-offset");
6485 return false;
6486 }
6487 return true;
6488}
6489
6490// Append/process IETF-Format MAX_STREAM_DATA Frame
6491bool QuicFramer::AppendMaxStreamDataFrame(const QuicWindowUpdateFrame& frame,
6492 QuicDataWriter* writer) {
6493 if (!writer->WriteVarInt62(frame.stream_id)) {
6494 set_detailed_error("Can not write MAX_STREAM_DATA stream id");
6495 return false;
6496 }
6497 if (!writer->WriteVarInt62(frame.max_data)) {
6498 set_detailed_error("Can not write MAX_STREAM_DATA byte-offset");
6499 return false;
6500 }
6501 return true;
6502}
6503
6504bool QuicFramer::ProcessMaxStreamDataFrame(QuicDataReader* reader,
6505 QuicWindowUpdateFrame* frame) {
6506 if (!ReadUint32FromVarint62(reader, IETF_MAX_STREAM_DATA,
6507 &frame->stream_id)) {
6508 return false;
6509 }
6510 if (!reader->ReadVarInt62(&frame->max_data)) {
6511 set_detailed_error("Can not read MAX_STREAM_DATA byte-count");
6512 return false;
6513 }
6514 return true;
6515}
6516
6517bool QuicFramer::AppendMaxStreamsFrame(const QuicMaxStreamsFrame& frame,
6518 QuicDataWriter* writer) {
6519 if (!writer->WriteVarInt62(frame.stream_count)) {
6520 set_detailed_error("Can not write MAX_STREAMS stream count");
6521 return false;
6522 }
6523 return true;
6524}
6525
6526bool QuicFramer::ProcessMaxStreamsFrame(QuicDataReader* reader,
6527 QuicMaxStreamsFrame* frame,
6528 uint64_t frame_type) {
6529 if (!ReadUint32FromVarint62(reader,
6530 static_cast<QuicIetfFrameType>(frame_type),
6531 &frame->stream_count)) {
6532 return false;
6533 }
6534 frame->unidirectional = (frame_type == IETF_MAX_STREAMS_UNIDIRECTIONAL);
6535 return true;
6536}
6537
6538bool QuicFramer::AppendDataBlockedFrame(const QuicBlockedFrame& frame,
6539 QuicDataWriter* writer) {
6540 if (!writer->WriteVarInt62(frame.offset)) {
6541 set_detailed_error("Can not write blocked offset.");
6542 return false;
6543 }
6544 return true;
6545}
6546
6547bool QuicFramer::ProcessDataBlockedFrame(QuicDataReader* reader,
6548 QuicBlockedFrame* frame) {
6549 // Indicates that it is a BLOCKED frame (as opposed to STREAM_BLOCKED).
6550 frame->stream_id = QuicUtils::GetInvalidStreamId(transport_version());
6551 if (!reader->ReadVarInt62(&frame->offset)) {
6552 set_detailed_error("Can not read blocked offset.");
6553 return false;
6554 }
6555 return true;
6556}
6557
6558bool QuicFramer::AppendStreamDataBlockedFrame(const QuicBlockedFrame& frame,
6559 QuicDataWriter* writer) {
6560 if (!writer->WriteVarInt62(frame.stream_id)) {
6561 set_detailed_error("Can not write stream blocked stream id.");
6562 return false;
6563 }
6564 if (!writer->WriteVarInt62(frame.offset)) {
6565 set_detailed_error("Can not write stream blocked offset.");
6566 return false;
6567 }
6568 return true;
6569}
6570
6571bool QuicFramer::ProcessStreamDataBlockedFrame(QuicDataReader* reader,
6572 QuicBlockedFrame* frame) {
6573 if (!ReadUint32FromVarint62(reader, IETF_STREAM_DATA_BLOCKED,
6574 &frame->stream_id)) {
6575 return false;
6576 }
6577 if (!reader->ReadVarInt62(&frame->offset)) {
6578 set_detailed_error("Can not read stream blocked offset.");
6579 return false;
6580 }
6581 return true;
6582}
6583
6584bool QuicFramer::AppendStreamsBlockedFrame(const QuicStreamsBlockedFrame& frame,
6585 QuicDataWriter* writer) {
6586 if (!writer->WriteVarInt62(frame.stream_count)) {
6587 set_detailed_error("Can not write STREAMS_BLOCKED stream count");
6588 return false;
6589 }
6590 return true;
6591}
6592
6593bool QuicFramer::ProcessStreamsBlockedFrame(QuicDataReader* reader,
6594 QuicStreamsBlockedFrame* frame,
6595 uint64_t frame_type) {
6596 if (!ReadUint32FromVarint62(reader,
6597 static_cast<QuicIetfFrameType>(frame_type),
6598 &frame->stream_count)) {
6599 return false;
6600 }
6601 if (frame->stream_count > QuicUtils::GetMaxStreamCount()) {
6602 // If stream count is such that the resulting stream ID would exceed our
6603 // implementation limit, generate an error.
6604 set_detailed_error(
6605 "STREAMS_BLOCKED stream count exceeds implementation limit.");
6606 return false;
6607 }
6608 frame->unidirectional = (frame_type == IETF_STREAMS_BLOCKED_UNIDIRECTIONAL);
6609 return true;
6610}
6611
6612bool QuicFramer::AppendNewConnectionIdFrame(
6613 const QuicNewConnectionIdFrame& frame, QuicDataWriter* writer) {
6614 if (!writer->WriteVarInt62(frame.sequence_number)) {
6615 set_detailed_error("Can not write New Connection ID sequence number");
6616 return false;
6617 }
6618 if (!writer->WriteVarInt62(frame.retire_prior_to)) {
6619 set_detailed_error("Can not write New Connection ID retire_prior_to");
6620 return false;
6621 }
6622 if (!writer->WriteLengthPrefixedConnectionId(frame.connection_id)) {
6623 set_detailed_error("Can not write New Connection ID frame connection ID");
6624 return false;
6625 }
6626
6627 if (!writer->WriteBytes(
6628 static_cast<const void*>(&frame.stateless_reset_token),
6629 sizeof(frame.stateless_reset_token))) {
6630 set_detailed_error("Can not write New Connection ID Reset Token");
6631 return false;
6632 }
6633 return true;
6634}
6635
6636bool QuicFramer::ProcessNewConnectionIdFrame(QuicDataReader* reader,
6637 QuicNewConnectionIdFrame* frame) {
6638 if (!reader->ReadVarInt62(&frame->sequence_number)) {
6639 set_detailed_error(
6640 "Unable to read new connection ID frame sequence number.");
6641 return false;
6642 }
6643
6644 if (!reader->ReadVarInt62(&frame->retire_prior_to)) {
6645 set_detailed_error(
6646 "Unable to read new connection ID frame retire_prior_to.");
6647 return false;
6648 }
6649 if (frame->retire_prior_to > frame->sequence_number) {
6650 set_detailed_error("Retire_prior_to > sequence_number.");
6651 return false;
6652 }
6653
6654 if (!reader->ReadLengthPrefixedConnectionId(&frame->connection_id)) {
6655 set_detailed_error("Unable to read new connection ID frame connection id.");
6656 return false;
6657 }
6658
6659 if (!QuicUtils::IsConnectionIdValidForVersion(frame->connection_id,
6660 transport_version())) {
6661 set_detailed_error("Invalid new connection ID length for version.");
6662 return false;
6663 }
6664
6665 if (!reader->ReadBytes(&frame->stateless_reset_token,
6666 sizeof(frame->stateless_reset_token))) {
6667 set_detailed_error("Can not read new connection ID frame reset token.");
6668 return false;
6669 }
6670 return true;
6671}
6672
6673bool QuicFramer::AppendRetireConnectionIdFrame(
6674 const QuicRetireConnectionIdFrame& frame, QuicDataWriter* writer) {
6675 if (!writer->WriteVarInt62(frame.sequence_number)) {
6676 set_detailed_error("Can not write Retire Connection ID sequence number");
6677 return false;
6678 }
6679 return true;
6680}
6681
6682bool QuicFramer::ProcessRetireConnectionIdFrame(
6683 QuicDataReader* reader, QuicRetireConnectionIdFrame* frame) {
6684 if (!reader->ReadVarInt62(&frame->sequence_number)) {
6685 set_detailed_error(
6686 "Unable to read retire connection ID frame sequence number.");
6687 return false;
6688 }
6689 return true;
6690}
6691
6692bool QuicFramer::ReadUint32FromVarint62(QuicDataReader* reader,
6693 QuicIetfFrameType type,
6694 QuicStreamId* id) {
6695 uint64_t temp_uint64;
6696 if (!reader->ReadVarInt62(&temp_uint64)) {
6697 set_detailed_error("Unable to read " + QuicIetfFrameTypeString(type) +
6698 " frame stream id/count.");
6699 return false;
6700 }
6701 if (temp_uint64 > kMaxQuicStreamId) {
6702 set_detailed_error("Stream id/count of " + QuicIetfFrameTypeString(type) +
6703 "frame is too large.");
6704 return false;
6705 }
6706 *id = static_cast<uint32_t>(temp_uint64);
6707 return true;
6708}
6709
6710uint8_t QuicFramer::GetStreamFrameTypeByte(const QuicStreamFrame& frame,
6711 bool last_frame_in_packet) const {
6712 if (VersionHasIetfQuicFrames(version_.transport_version)) {
6713 return GetIetfStreamFrameTypeByte(frame, last_frame_in_packet);
6714 }
6715 uint8_t type_byte = 0;
6716 // Fin bit.
6717 type_byte |= frame.fin ? kQuicStreamFinMask : 0;
6718
6719 // Data Length bit.
6720 type_byte <<= kQuicStreamDataLengthShift;
6721 type_byte |= last_frame_in_packet ? 0 : kQuicStreamDataLengthMask;
6722
6723 // Offset 3 bits.
6724 type_byte <<= kQuicStreamShift;
6725 const size_t offset_len = GetStreamOffsetSize(frame.offset);
6726 if (offset_len > 0) {
6727 type_byte |= offset_len - 1;
6728 }
6729
6730 // stream id 2 bits.
6731 type_byte <<= kQuicStreamIdShift;
6732 type_byte |= GetStreamIdSize(frame.stream_id) - 1;
6733 type_byte |= kQuicFrameTypeStreamMask; // Set Stream Frame Type to 1.
6734
6735 return type_byte;
6736}
6737
6738uint8_t QuicFramer::GetIetfStreamFrameTypeByte(
6739 const QuicStreamFrame& frame, bool last_frame_in_packet) const {
6740 QUICHE_DCHECK(VersionHasIetfQuicFrames(version_.transport_version));
6741 uint8_t type_byte = IETF_STREAM;
6742 if (!last_frame_in_packet) {
6743 type_byte |= IETF_STREAM_FRAME_LEN_BIT;
6744 }
6745 if (frame.offset != 0) {
6746 type_byte |= IETF_STREAM_FRAME_OFF_BIT;
6747 }
6748 if (frame.fin) {
6749 type_byte |= IETF_STREAM_FRAME_FIN_BIT;
6750 }
6751 return type_byte;
6752}
6753
6754void QuicFramer::InferPacketHeaderTypeFromVersion() {
6755 // This function should only be called when server connection negotiates the
6756 // version.
6757 QUICHE_DCHECK_EQ(perspective_, Perspective::IS_SERVER);
6758 QUICHE_DCHECK(!infer_packet_header_type_from_version_);
6759 infer_packet_header_type_from_version_ = true;
6760}
6761
6762void QuicFramer::EnableMultiplePacketNumberSpacesSupport() {
6763 if (supports_multiple_packet_number_spaces_) {
6764 QUIC_BUG(quic_bug_10850_91)
6765 << "Multiple packet number spaces has already been enabled";
6766 return;
6767 }
6768 if (largest_packet_number_.IsInitialized()) {
6769 QUIC_BUG(quic_bug_10850_92)
6770 << "Try to enable multiple packet number spaces support after any "
6771 "packet has been received.";
6772 return;
6773 }
6774
6775 supports_multiple_packet_number_spaces_ = true;
6776}
6777
6778// static
6779QuicErrorCode QuicFramer::ParsePublicHeaderDispatcher(
6780 const QuicEncryptedPacket& packet,
6781 uint8_t expected_destination_connection_id_length,
6782 PacketHeaderFormat* format, QuicLongHeaderType* long_packet_type,
6783 bool* version_present, bool* has_length_prefix,
6784 QuicVersionLabel* version_label, ParsedQuicVersion* parsed_version,
6785 QuicConnectionId* destination_connection_id,
6786 QuicConnectionId* source_connection_id,
6787 absl::optional<absl::string_view>* retry_token,
6788 std::string* detailed_error) {
6789 QuicDataReader reader(packet.data(), packet.length());
6790 if (reader.IsDoneReading()) {
6791 *detailed_error = "Unable to read first byte.";
6792 return QUIC_INVALID_PACKET_HEADER;
6793 }
6794 const uint8_t first_byte = reader.PeekByte();
6795 if ((first_byte & FLAGS_LONG_HEADER) == 0 &&
6796 (first_byte & FLAGS_FIXED_BIT) == 0 &&
6797 (first_byte & FLAGS_DEMULTIPLEXING_BIT) == 0) {
6798 // All versions of Google QUIC up to and including Q043 set
6799 // FLAGS_DEMULTIPLEXING_BIT to one on all client-to-server packets. Q044
6800 // and Q045 were never default-enabled in production. All subsequent
6801 // versions of Google QUIC (starting with Q046) require FLAGS_FIXED_BIT to
6802 // be set to one on all packets. All versions of IETF QUIC (since
6803 // draft-ietf-quic-transport-17 which was earlier than the first IETF QUIC
6804 // version that was deployed in production by any implementation) also
6805 // require FLAGS_FIXED_BIT to be set to one on all packets. If a packet
6806 // has the FLAGS_LONG_HEADER bit set to one, it could be a first flight
6807 // from an unknown future version that allows the other two bits to be set
6808 // to zero. Based on this, packets that have all three of those bits set
6809 // to zero are known to be invalid.
6810 *detailed_error = "Invalid flags.";
6811 return QUIC_INVALID_PACKET_HEADER;
6812 }
6813 const bool ietf_format = QuicUtils::IsIetfPacketHeader(first_byte);
6814 uint8_t unused_first_byte;
6815 QuicVariableLengthIntegerLength retry_token_length_length;
6816 absl::string_view maybe_retry_token;
6817 QuicErrorCode error_code = ParsePublicHeader(
6818 &reader, expected_destination_connection_id_length, ietf_format,
6819 &unused_first_byte, format, version_present, has_length_prefix,
6820 version_label, parsed_version, destination_connection_id,
6821 source_connection_id, long_packet_type, &retry_token_length_length,
6822 &maybe_retry_token, detailed_error);
6823 if (retry_token_length_length != VARIABLE_LENGTH_INTEGER_LENGTH_0) {
6824 *retry_token = maybe_retry_token;
6825 } else {
6826 retry_token->reset();
6827 }
6828 return error_code;
6829}
6830
6831// static
6832QuicErrorCode QuicFramer::ParsePublicHeaderGoogleQuic(
6833 QuicDataReader* reader, uint8_t* first_byte, PacketHeaderFormat* format,
6834 bool* version_present, QuicVersionLabel* version_label,
6835 ParsedQuicVersion* parsed_version,
6836 QuicConnectionId* destination_connection_id, std::string* detailed_error) {
6837 *format = GOOGLE_QUIC_PACKET;
6838 *version_present = (*first_byte & PACKET_PUBLIC_FLAGS_VERSION) != 0;
6839 uint8_t destination_connection_id_length = 0;
6840 if ((*first_byte & PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID) != 0) {
6841 destination_connection_id_length = kQuicDefaultConnectionIdLength;
6842 }
6843 if (!reader->ReadConnectionId(destination_connection_id,
6844 destination_connection_id_length)) {
6845 *detailed_error = "Unable to read ConnectionId.";
6846 return QUIC_INVALID_PACKET_HEADER;
6847 }
6848 if (*version_present) {
6849 if (!ProcessVersionLabel(reader, version_label)) {
6850 *detailed_error = "Unable to read protocol version.";
6851 return QUIC_INVALID_PACKET_HEADER;
6852 }
6853 *parsed_version = ParseQuicVersionLabel(*version_label);
6854 }
6855 return QUIC_NO_ERROR;
6856}
6857
6858namespace {
6859
6860const QuicVersionLabel kProxVersionLabel = 0x50524F58; // "PROX"
6861
6862inline bool PacketHasLengthPrefixedConnectionIds(
6863 const QuicDataReader& reader, ParsedQuicVersion parsed_version,
6864 QuicVersionLabel version_label, uint8_t first_byte) {
6865 if (parsed_version.IsKnown()) {
6866 return parsed_version.HasLengthPrefixedConnectionIds();
6867 }
6868
6869 // Received unsupported version, check known old unsupported versions.
6870 if (QuicVersionLabelUses4BitConnectionIdLength(version_label)) {
6871 return false;
6872 }
6873
6874 // Received unknown version, check connection ID length byte.
6875 if (reader.IsDoneReading()) {
6876 // This check is required to safely peek the connection ID length byte.
6877 return true;
6878 }
6879 const uint8_t connection_id_length_byte = reader.PeekByte();
6880
6881 // Check for packets produced by older versions of
6882 // QuicFramer::WriteClientVersionNegotiationProbePacket
6883 if (first_byte == 0xc0 && (connection_id_length_byte & 0x0f) == 0 &&
6884 connection_id_length_byte >= 0x50 && version_label == 0xcabadaba) {
6885 return false;
6886 }
6887
6888 // Check for munged packets with version tag PROX.
6889 if ((connection_id_length_byte & 0x0f) == 0 &&
6890 connection_id_length_byte >= 0x20 && version_label == kProxVersionLabel) {
6891 return false;
6892 }
6893
6894 return true;
6895}
6896
6897inline bool ParseLongHeaderConnectionIds(
6898 QuicDataReader& reader, bool has_length_prefix,
6899 QuicVersionLabel version_label, QuicConnectionId& destination_connection_id,
6900 QuicConnectionId& source_connection_id, std::string& detailed_error) {
6901 if (has_length_prefix) {
6902 if (!reader.ReadLengthPrefixedConnectionId(&destination_connection_id)) {
6903 detailed_error = "Unable to read destination connection ID.";
6904 return false;
6905 }
6906 if (!reader.ReadLengthPrefixedConnectionId(&source_connection_id)) {
6907 if (version_label == kProxVersionLabel) {
6908 // The "PROX" version does not follow the length-prefixed invariants,
6909 // and can therefore attempt to read a payload byte and interpret it
6910 // as the source connection ID length, which could fail to parse.
6911 // In that scenario we keep the source connection ID empty but mark
6912 // parsing as successful.
6913 return true;
6914 }
6915 detailed_error = "Unable to read source connection ID.";
6916 return false;
6917 }
6918 } else {
6919 // Parse connection ID lengths.
6920 uint8_t connection_id_lengths_byte;
6921 if (!reader.ReadUInt8(&connection_id_lengths_byte)) {
6922 detailed_error = "Unable to read connection ID lengths.";
6923 return false;
6924 }
6925 uint8_t destination_connection_id_length =
6926 (connection_id_lengths_byte & kDestinationConnectionIdLengthMask) >> 4;
6927 if (destination_connection_id_length != 0) {
6928 destination_connection_id_length += kConnectionIdLengthAdjustment;
6929 }
6930 uint8_t source_connection_id_length =
6931 connection_id_lengths_byte & kSourceConnectionIdLengthMask;
6932 if (source_connection_id_length != 0) {
6933 source_connection_id_length += kConnectionIdLengthAdjustment;
6934 }
6935
6936 // Read destination connection ID.
6937 if (!reader.ReadConnectionId(&destination_connection_id,
6938 destination_connection_id_length)) {
6939 detailed_error = "Unable to read destination connection ID.";
6940 return false;
6941 }
6942
6943 // Read source connection ID.
6944 if (!reader.ReadConnectionId(&source_connection_id,
6945 source_connection_id_length)) {
6946 detailed_error = "Unable to read source connection ID.";
6947 return false;
6948 }
6949 }
6950 return true;
6951}
6952
6953} // namespace
6954
6955// static
6956QuicErrorCode QuicFramer::ParsePublicHeader(
6957 QuicDataReader* reader, uint8_t expected_destination_connection_id_length,
6958 bool ietf_format, uint8_t* first_byte, PacketHeaderFormat* format,
6959 bool* version_present, bool* has_length_prefix,
6960 QuicVersionLabel* version_label, ParsedQuicVersion* parsed_version,
6961 QuicConnectionId* destination_connection_id,
6962 QuicConnectionId* source_connection_id,
6963 QuicLongHeaderType* long_packet_type,
6964 QuicVariableLengthIntegerLength* retry_token_length_length,
6965 absl::string_view* retry_token, std::string* detailed_error) {
6966 *version_present = false;
6967 *has_length_prefix = false;
6968 *version_label = 0;
6969 *parsed_version = UnsupportedQuicVersion();
6970 *source_connection_id = EmptyQuicConnectionId();
6971 *long_packet_type = INVALID_PACKET_TYPE;
6972 *retry_token_length_length = VARIABLE_LENGTH_INTEGER_LENGTH_0;
6973 *retry_token = absl::string_view();
6974 *detailed_error = "";
6975
6976 if (!reader->ReadUInt8(first_byte)) {
6977 *detailed_error = "Unable to read first byte.";
6978 return QUIC_INVALID_PACKET_HEADER;
6979 }
6980
6981 if (!ietf_format) {
6982 return ParsePublicHeaderGoogleQuic(
6983 reader, first_byte, format, version_present, version_label,
6984 parsed_version, destination_connection_id, detailed_error);
6985 }
6986
6987 *format = GetIetfPacketHeaderFormat(*first_byte);
6988
6989 if (*format == IETF_QUIC_SHORT_HEADER_PACKET) {
6990 // Read destination connection ID using
6991 // expected_destination_connection_id_length to determine its length.
6992 if (!reader->ReadConnectionId(destination_connection_id,
6993 expected_destination_connection_id_length)) {
6994 *detailed_error = "Unable to read destination connection ID.";
6995 return QUIC_INVALID_PACKET_HEADER;
6996 }
6997 return QUIC_NO_ERROR;
6998 }
6999
7000 QUICHE_DCHECK_EQ(IETF_QUIC_LONG_HEADER_PACKET, *format);
7001 *version_present = true;
7002 if (!ProcessVersionLabel(reader, version_label)) {
7003 *detailed_error = "Unable to read protocol version.";
7004 return QUIC_INVALID_PACKET_HEADER;
7005 }
7006
7007 if (*version_label == 0) {
7008 *long_packet_type = VERSION_NEGOTIATION;
7009 }
7010
7011 // Parse version.
7012 *parsed_version = ParseQuicVersionLabel(*version_label);
7013
7014 // Figure out which IETF QUIC invariants this packet follows.
7015 *has_length_prefix = PacketHasLengthPrefixedConnectionIds(
7016 *reader, *parsed_version, *version_label, *first_byte);
7017
7018 // Parse connection IDs.
7019 if (!ParseLongHeaderConnectionIds(*reader, *has_length_prefix, *version_label,
7020 *destination_connection_id,
7021 *source_connection_id, *detailed_error)) {
7022 return QUIC_INVALID_PACKET_HEADER;
7023 }
7024
7025 if (!parsed_version->IsKnown()) {
7026 // Skip parsing of long packet type and retry token for unknown versions.
7027 return QUIC_NO_ERROR;
7028 }
7029
7030 // Parse long packet type.
7031 *long_packet_type = GetLongHeaderType(*first_byte, *parsed_version);
7032
7033 switch (*long_packet_type) {
7034 case INVALID_PACKET_TYPE:
7035 *detailed_error = "Unable to parse long packet type.";
7036 return QUIC_INVALID_PACKET_HEADER;
7037 case INITIAL:
7038 if (!parsed_version->SupportsRetry()) {
7039 // Retry token is only present on initial packets for some versions.
7040 return QUIC_NO_ERROR;
7041 }
7042 break;
7043 default:
7044 return QUIC_NO_ERROR;
7045 }
7046
7047 *retry_token_length_length = reader->PeekVarInt62Length();
7048 uint64_t retry_token_length;
7049 if (!reader->ReadVarInt62(&retry_token_length)) {
7050 *retry_token_length_length = VARIABLE_LENGTH_INTEGER_LENGTH_0;
7051 *detailed_error = "Unable to read retry token length.";
7052 return QUIC_INVALID_PACKET_HEADER;
7053 }
7054
7055 if (!reader->ReadStringPiece(retry_token, retry_token_length)) {
7056 *detailed_error = "Unable to read retry token.";
7057 return QUIC_INVALID_PACKET_HEADER;
7058 }
7059
7060 return QUIC_NO_ERROR;
7061}
7062
7063// static
7064bool QuicFramer::WriteClientVersionNegotiationProbePacket(
7065 char* packet_bytes, QuicByteCount packet_length,
7066 const char* destination_connection_id_bytes,
7067 uint8_t destination_connection_id_length) {
7068 if (packet_bytes == nullptr) {
7069 QUIC_BUG(quic_bug_10850_93) << "Invalid packet_bytes";
7070 return false;
7071 }
7072 if (packet_length < kMinPacketSizeForVersionNegotiation ||
7073 packet_length > 65535) {
7074 QUIC_BUG(quic_bug_10850_94) << "Invalid packet_length";
7075 return false;
7076 }
7077 if (destination_connection_id_length > kQuicMaxConnectionId4BitLength ||
7078 destination_connection_id_length < kQuicDefaultConnectionIdLength) {
7079 QUIC_BUG(quic_bug_10850_95) << "Invalid connection_id_length";
7080 return false;
7081 }
7082 // clang-format off
7083 const unsigned char packet_start_bytes[] = {
7084 // IETF long header with fixed bit set, type initial, all-0 encrypted bits.
7085 0xc0,
7086 // Version, part of the IETF space reserved for negotiation.
7087 // This intentionally differs from QuicVersionReservedForNegotiation()
7088 // to allow differentiating them over the wire.
7089 0xca, 0xba, 0xda, 0xda,
7090 };
7091 // clang-format on
7092 static_assert(sizeof(packet_start_bytes) == 5, "bad packet_start_bytes size");
7093 QuicDataWriter writer(packet_length, packet_bytes);
7094 if (!writer.WriteBytes(packet_start_bytes, sizeof(packet_start_bytes))) {
7095 QUIC_BUG(quic_bug_10850_96) << "Failed to write packet start";
7096 return false;
7097 }
7098
7099 QuicConnectionId destination_connection_id(destination_connection_id_bytes,
7100 destination_connection_id_length);
7101 if (!AppendIetfConnectionIds(
7102 /*version_flag=*/true, /*use_length_prefix=*/true,
7103 destination_connection_id, EmptyQuicConnectionId(), &writer)) {
7104 QUIC_BUG(quic_bug_10850_97) << "Failed to write connection IDs";
7105 return false;
7106 }
7107 // Add 8 bytes of zeroes followed by 8 bytes of ones to ensure that this does
7108 // not parse with any known version. The zeroes make sure that packet numbers,
7109 // retry token lengths and payload lengths are parsed as zero, and if the
7110 // zeroes are treated as padding frames, 0xff is known to not parse as a
7111 // valid frame type.
7112 if (!writer.WriteUInt64(0) ||
7113 !writer.WriteUInt64(std::numeric_limits<uint64_t>::max())) {
7114 QUIC_BUG(quic_bug_10850_98) << "Failed to write 18 bytes";
7115 return false;
7116 }
7117 // Make sure the polite greeting below is padded to a 16-byte boundary to
7118 // make it easier to read in tcpdump.
7119 while (writer.length() % 16 != 0) {
7120 if (!writer.WriteUInt8(0)) {
7121 QUIC_BUG(quic_bug_10850_99) << "Failed to write padding byte";
7122 return false;
7123 }
7124 }
7125 // Add a polite greeting in case a human sees this in tcpdump.
7126 static const char polite_greeting[] =
7127 "This packet only exists to trigger IETF QUIC version negotiation. "
7128 "Please respond with a Version Negotiation packet indicating what "
7129 "versions you support. Thank you and have a nice day.";
7130 if (!writer.WriteBytes(polite_greeting, sizeof(polite_greeting))) {
7131 QUIC_BUG(quic_bug_10850_100) << "Failed to write polite greeting";
7132 return false;
7133 }
7134 // Fill the rest of the packet with zeroes.
7135 writer.WritePadding();
7136 QUICHE_DCHECK_EQ(0u, writer.remaining());
7137 return true;
7138}
7139
7140// static
7141bool QuicFramer::ParseServerVersionNegotiationProbeResponse(
7142 const char* packet_bytes, QuicByteCount packet_length,
7143 char* source_connection_id_bytes, uint8_t* source_connection_id_length_out,
7144 std::string* detailed_error) {
7145 if (detailed_error == nullptr) {
7146 QUIC_BUG(quic_bug_10850_101) << "Invalid error_details";
7147 return false;
7148 }
7149 *detailed_error = "";
7150 if (packet_bytes == nullptr) {
7151 *detailed_error = "Invalid packet_bytes";
7152 return false;
7153 }
7154 if (packet_length < 6) {
7155 *detailed_error = "Invalid packet_length";
7156 return false;
7157 }
7158 if (source_connection_id_bytes == nullptr) {
7159 *detailed_error = "Invalid source_connection_id_bytes";
7160 return false;
7161 }
7162 if (source_connection_id_length_out == nullptr) {
7163 *detailed_error = "Invalid source_connection_id_length_out";
7164 return false;
7165 }
7166 QuicDataReader reader(packet_bytes, packet_length);
7167 uint8_t type_byte = 0;
7168 if (!reader.ReadUInt8(&type_byte)) {
7169 *detailed_error = "Failed to read type byte";
7170 return false;
7171 }
7172 if ((type_byte & 0x80) == 0) {
7173 *detailed_error = "Packet does not have long header";
7174 return false;
7175 }
7176 uint32_t version = 0;
7177 if (!reader.ReadUInt32(&version)) {
7178 *detailed_error = "Failed to read version";
7179 return false;
7180 }
7181 if (version != 0) {
7182 *detailed_error = "Packet is not a version negotiation packet";
7183 return false;
7184 }
7185
7186 QuicConnectionId destination_connection_id, source_connection_id;
7187 if (!reader.ReadLengthPrefixedConnectionId(&destination_connection_id)) {
7188 *detailed_error = "Failed to read destination connection ID";
7189 return false;
7190 }
7191 if (!reader.ReadLengthPrefixedConnectionId(&source_connection_id)) {
7192 *detailed_error = "Failed to read source connection ID";
7193 return false;
7194 }
7195
7196 if (destination_connection_id.length() != 0) {
7197 *detailed_error = "Received unexpected destination connection ID length";
7198 return false;
7199 }
7200 if (*source_connection_id_length_out < source_connection_id.length()) {
7201 *detailed_error =
7202 absl::StrCat("*source_connection_id_length_out too small ",
7203 static_cast<int>(*source_connection_id_length_out), " < ",
7204 static_cast<int>(source_connection_id.length()));
7205 return false;
7206 }
7207
7208 memcpy(source_connection_id_bytes, source_connection_id.data(),
7209 source_connection_id.length());
7210 *source_connection_id_length_out = source_connection_id.length();
7211
7212 return true;
7213}
7214
7215// Look for and parse the error code from the "<quic_error_code>:" text that
7216// may be present at the start of the CONNECTION_CLOSE error details string.
7217// This text, inserted by the peer if it's using Google's QUIC implementation,
7218// contains additional error information that narrows down the exact error. If
7219// the string is not found, or is not properly formed, it returns
7220// ErrorCode::QUIC_IETF_GQUIC_ERROR_MISSING
7221void MaybeExtractQuicErrorCode(QuicConnectionCloseFrame* frame) {
7222 std::vector<absl::string_view> ed = absl::StrSplit(frame->error_details, ':');
7223 uint64_t extracted_error_code;
7224 if (ed.size() < 2 || !quiche::QuicheTextUtils::IsAllDigits(ed[0]) ||
7225 !absl::SimpleAtoi(ed[0], &extracted_error_code)) {
7226 if (frame->close_type == IETF_QUIC_TRANSPORT_CONNECTION_CLOSE &&
7227 frame->wire_error_code == NO_IETF_QUIC_ERROR) {
7228 frame->quic_error_code = QUIC_NO_ERROR;
7229 } else {
7230 frame->quic_error_code = QUIC_IETF_GQUIC_ERROR_MISSING;
7231 }
7232 return;
7233 }
7234 // Return the error code (numeric) and the error details string without the
7235 // error code prefix. Note that Split returns everything up to, but not
7236 // including, the split character, so the length of ed[0] is just the number
7237 // of digits in the error number. In removing the prefix, 1 is added to the
7238 // length to account for the :
7239 absl::string_view x = absl::string_view(frame->error_details);
7240 x.remove_prefix(ed[0].length() + 1);
7241 frame->error_details = std::string(x);
7242 frame->quic_error_code = static_cast<QuicErrorCode>(extracted_error_code);
7243}
7244
7245#undef ENDPOINT // undef for jumbo builds
7246} // namespace quic