1 // Copyright (c) 2018 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/http/http_decoder.h"
6
7 #include <memory>
8 #include <string>
9 #include <utility>
10
11 #include "absl/base/macros.h"
12 #include "absl/strings/escaping.h"
13 #include "absl/strings/str_cat.h"
14 #include "absl/strings/string_view.h"
15 #include "quiche/quic/core/http/http_encoder.h"
16 #include "quiche/quic/core/http/http_frames.h"
17 #include "quiche/quic/core/quic_data_writer.h"
18 #include "quiche/quic/core/quic_versions.h"
19 #include "quiche/quic/platform/api/quic_expect_bug.h"
20 #include "quiche/quic/platform/api/quic_flags.h"
21 #include "quiche/quic/platform/api/quic_test.h"
22 #include "quiche/quic/test_tools/quic_test_utils.h"
23
24 using ::testing::_;
25 using ::testing::AnyNumber;
26 using ::testing::Eq;
27 using ::testing::InSequence;
28 using ::testing::Return;
29
30 namespace quic {
31 namespace test {
32
33 class HttpDecoderPeer {
34 public:
current_frame_type(HttpDecoder * decoder)35 static uint64_t current_frame_type(HttpDecoder* decoder) {
36 return decoder->current_frame_type_;
37 }
38 };
39
40 namespace {
41
42 class HttpDecoderTest : public QuicTest {
43 public:
HttpDecoderTest()44 HttpDecoderTest() : decoder_(&visitor_) {
45 ON_CALL(visitor_, OnMaxPushIdFrame()).WillByDefault(Return(true));
46 ON_CALL(visitor_, OnGoAwayFrame(_)).WillByDefault(Return(true));
47 ON_CALL(visitor_, OnSettingsFrameStart(_)).WillByDefault(Return(true));
48 ON_CALL(visitor_, OnSettingsFrame(_)).WillByDefault(Return(true));
49 ON_CALL(visitor_, OnDataFrameStart(_, _)).WillByDefault(Return(true));
50 ON_CALL(visitor_, OnDataFramePayload(_)).WillByDefault(Return(true));
51 ON_CALL(visitor_, OnDataFrameEnd()).WillByDefault(Return(true));
52 ON_CALL(visitor_, OnHeadersFrameStart(_, _)).WillByDefault(Return(true));
53 ON_CALL(visitor_, OnHeadersFramePayload(_)).WillByDefault(Return(true));
54 ON_CALL(visitor_, OnHeadersFrameEnd()).WillByDefault(Return(true));
55 ON_CALL(visitor_, OnPriorityUpdateFrameStart(_))
56 .WillByDefault(Return(true));
57 ON_CALL(visitor_, OnPriorityUpdateFrame(_)).WillByDefault(Return(true));
58 ON_CALL(visitor_, OnAcceptChFrameStart(_)).WillByDefault(Return(true));
59 ON_CALL(visitor_, OnAcceptChFrame(_)).WillByDefault(Return(true));
60 ON_CALL(visitor_, OnMetadataFrameStart(_, _)).WillByDefault(Return(true));
61 ON_CALL(visitor_, OnMetadataFramePayload(_)).WillByDefault(Return(true));
62 ON_CALL(visitor_, OnMetadataFrameEnd()).WillByDefault(Return(true));
63 ON_CALL(visitor_, OnUnknownFrameStart(_, _, _)).WillByDefault(Return(true));
64 ON_CALL(visitor_, OnUnknownFramePayload(_)).WillByDefault(Return(true));
65 ON_CALL(visitor_, OnUnknownFrameEnd()).WillByDefault(Return(true));
66 }
67 ~HttpDecoderTest() override = default;
68
current_frame_type()69 uint64_t current_frame_type() {
70 return HttpDecoderPeer::current_frame_type(&decoder_);
71 }
72
73 // Process |input| in a single call to HttpDecoder::ProcessInput().
ProcessInput(absl::string_view input)74 QuicByteCount ProcessInput(absl::string_view input) {
75 return decoder_.ProcessInput(input.data(), input.size());
76 }
77
78 // Feed |input| to |decoder_| one character at a time,
79 // verifying that each character gets processed.
ProcessInputCharByChar(absl::string_view input)80 void ProcessInputCharByChar(absl::string_view input) {
81 for (char c : input) {
82 EXPECT_EQ(1u, decoder_.ProcessInput(&c, 1));
83 }
84 }
85
86 // Append garbage to |input|, then process it in a single call to
87 // HttpDecoder::ProcessInput(). Verify that garbage is not read.
ProcessInputWithGarbageAppended(absl::string_view input)88 QuicByteCount ProcessInputWithGarbageAppended(absl::string_view input) {
89 std::string input_with_garbage_appended = absl::StrCat(input, "blahblah");
90 QuicByteCount processed_bytes = ProcessInput(input_with_garbage_appended);
91
92 // Guaranteed by HttpDecoder::ProcessInput() contract.
93 QUICHE_DCHECK_LE(processed_bytes, input_with_garbage_appended.size());
94
95 // Caller should set up visitor to pause decoding
96 // before HttpDecoder would read garbage.
97 EXPECT_LE(processed_bytes, input.size());
98
99 return processed_bytes;
100 }
101
102 testing::StrictMock<MockHttpDecoderVisitor> visitor_;
103 HttpDecoder decoder_;
104 };
105
TEST_F(HttpDecoderTest,InitialState)106 TEST_F(HttpDecoderTest, InitialState) {
107 EXPECT_THAT(decoder_.error(), IsQuicNoError());
108 EXPECT_EQ("", decoder_.error_detail());
109 }
110
TEST_F(HttpDecoderTest,UnknownFrame)111 TEST_F(HttpDecoderTest, UnknownFrame) {
112 std::unique_ptr<char[]> input;
113
114 const QuicByteCount payload_lengths[] = {0, 14, 100};
115 const uint64_t frame_types[] = {
116 0x21, 0x40, 0x5f, 0x7e, 0x9d, // some reserved frame types
117 0x6f, 0x14 // some unknown, not reserved frame types
118 };
119
120 for (auto payload_length : payload_lengths) {
121 std::string data(payload_length, 'a');
122
123 for (auto frame_type : frame_types) {
124 const QuicByteCount total_length =
125 QuicDataWriter::GetVarInt62Len(frame_type) +
126 QuicDataWriter::GetVarInt62Len(payload_length) + payload_length;
127 input = std::make_unique<char[]>(total_length);
128
129 QuicDataWriter writer(total_length, input.get());
130 writer.WriteVarInt62(frame_type);
131 writer.WriteVarInt62(payload_length);
132 const QuicByteCount header_length = writer.length();
133 if (payload_length > 0) {
134 writer.WriteStringPiece(data);
135 }
136
137 EXPECT_CALL(visitor_, OnUnknownFrameStart(frame_type, header_length,
138 payload_length));
139 if (payload_length > 0) {
140 EXPECT_CALL(visitor_, OnUnknownFramePayload(Eq(data)));
141 }
142 EXPECT_CALL(visitor_, OnUnknownFrameEnd());
143
144 EXPECT_EQ(total_length, decoder_.ProcessInput(input.get(), total_length));
145
146 EXPECT_THAT(decoder_.error(), IsQuicNoError());
147 ASSERT_EQ("", decoder_.error_detail());
148 EXPECT_EQ(frame_type, current_frame_type());
149 }
150 }
151 }
152
TEST_F(HttpDecoderTest,CancelPush)153 TEST_F(HttpDecoderTest, CancelPush) {
154 InSequence s;
155 std::string input;
156 ASSERT_TRUE(
157 absl::HexStringToBytes("03" // type (CANCEL_PUSH)
158 "01" // length
159 "01", // Push Id
160 &input));
161
162 EXPECT_CALL(visitor_, OnError(&decoder_));
163 EXPECT_EQ(1u, ProcessInput(input));
164 EXPECT_THAT(decoder_.error(), IsError(QUIC_HTTP_FRAME_ERROR));
165 EXPECT_EQ("CANCEL_PUSH frame received.", decoder_.error_detail());
166 }
167
TEST_F(HttpDecoderTest,PushPromiseFrame)168 TEST_F(HttpDecoderTest, PushPromiseFrame) {
169 InSequence s;
170 std::string push_promise_bytes;
171 ASSERT_TRUE(
172 absl::HexStringToBytes("05" // type (PUSH PROMISE)
173 "08" // length
174 "1f", // push id 31
175 &push_promise_bytes));
176 std::string input = absl::StrCat(push_promise_bytes,
177 "Headers"); // headers
178
179 EXPECT_CALL(visitor_, OnError(&decoder_));
180 EXPECT_EQ(1u, ProcessInput(input));
181 EXPECT_THAT(decoder_.error(), IsError(QUIC_HTTP_FRAME_ERROR));
182 EXPECT_EQ("PUSH_PROMISE frame received.", decoder_.error_detail());
183 }
184
TEST_F(HttpDecoderTest,MaxPushId)185 TEST_F(HttpDecoderTest, MaxPushId) {
186 InSequence s;
187 std::string input;
188 ASSERT_TRUE(
189 absl::HexStringToBytes("0D" // type (MAX_PUSH_ID)
190 "01" // length
191 "01", // Push Id
192 &input));
193
194 // Visitor pauses processing.
195 EXPECT_CALL(visitor_, OnMaxPushIdFrame()).WillOnce(Return(false));
196 EXPECT_EQ(input.size(), ProcessInputWithGarbageAppended(input));
197 EXPECT_THAT(decoder_.error(), IsQuicNoError());
198 EXPECT_EQ("", decoder_.error_detail());
199
200 // Process the full frame.
201 EXPECT_CALL(visitor_, OnMaxPushIdFrame());
202 EXPECT_EQ(input.size(), ProcessInput(input));
203 EXPECT_THAT(decoder_.error(), IsQuicNoError());
204 EXPECT_EQ("", decoder_.error_detail());
205
206 // Process the frame incrementally.
207 EXPECT_CALL(visitor_, OnMaxPushIdFrame());
208 ProcessInputCharByChar(input);
209 EXPECT_THAT(decoder_.error(), IsQuicNoError());
210 EXPECT_EQ("", decoder_.error_detail());
211 }
212
TEST_F(HttpDecoderTest,SettingsFrame)213 TEST_F(HttpDecoderTest, SettingsFrame) {
214 InSequence s;
215 std::string input;
216 ASSERT_TRUE(absl::HexStringToBytes(
217 "04" // type (SETTINGS)
218 "07" // length
219 "01" // identifier (SETTINGS_QPACK_MAX_TABLE_CAPACITY)
220 "02" // content
221 "06" // identifier (SETTINGS_MAX_HEADER_LIST_SIZE)
222 "05" // content
223 "4100" // identifier, encoded on 2 bytes (0x40), value is 256 (0x100)
224 "04", // content
225 &input));
226
227 SettingsFrame frame;
228 frame.values[1] = 2;
229 frame.values[6] = 5;
230 frame.values[256] = 4;
231
232 // Visitor pauses processing.
233 absl::string_view remaining_input(input);
234 EXPECT_CALL(visitor_, OnSettingsFrameStart(2)).WillOnce(Return(false));
235 QuicByteCount processed_bytes =
236 ProcessInputWithGarbageAppended(remaining_input);
237 EXPECT_EQ(2u, processed_bytes);
238 remaining_input = remaining_input.substr(processed_bytes);
239
240 EXPECT_CALL(visitor_, OnSettingsFrame(frame)).WillOnce(Return(false));
241 processed_bytes = ProcessInputWithGarbageAppended(remaining_input);
242 EXPECT_EQ(remaining_input.size(), processed_bytes);
243 EXPECT_THAT(decoder_.error(), IsQuicNoError());
244 EXPECT_EQ("", decoder_.error_detail());
245
246 // Process the full frame.
247 EXPECT_CALL(visitor_, OnSettingsFrameStart(2));
248 EXPECT_CALL(visitor_, OnSettingsFrame(frame));
249 EXPECT_EQ(input.size(), ProcessInput(input));
250 EXPECT_THAT(decoder_.error(), IsQuicNoError());
251 EXPECT_EQ("", decoder_.error_detail());
252
253 // Process the frame incrementally.
254 EXPECT_CALL(visitor_, OnSettingsFrameStart(2));
255 EXPECT_CALL(visitor_, OnSettingsFrame(frame));
256 ProcessInputCharByChar(input);
257 EXPECT_THAT(decoder_.error(), IsQuicNoError());
258 EXPECT_EQ("", decoder_.error_detail());
259 }
260
TEST_F(HttpDecoderTest,CorruptSettingsFrame)261 TEST_F(HttpDecoderTest, CorruptSettingsFrame) {
262 const char* const kPayload =
263 "\x42\x11" // two-byte id
264 "\x80\x22\x33\x44" // four-byte value
265 "\x58\x39" // two-byte id
266 "\xf0\x22\x33\x44\x55\x66\x77\x88"; // eight-byte value
267 struct {
268 size_t payload_length;
269 const char* const error_message;
270 } kTestData[] = {
271 {1, "Unable to read setting identifier."},
272 {5, "Unable to read setting value."},
273 {7, "Unable to read setting identifier."},
274 {12, "Unable to read setting value."},
275 };
276
277 for (const auto& test_data : kTestData) {
278 std::string input;
279 input.push_back(4u); // type SETTINGS
280 input.push_back(test_data.payload_length);
281 const size_t header_length = input.size();
282 input.append(kPayload, test_data.payload_length);
283
284 HttpDecoder decoder(&visitor_);
285 EXPECT_CALL(visitor_, OnSettingsFrameStart(header_length));
286 EXPECT_CALL(visitor_, OnError(&decoder));
287
288 QuicByteCount processed_bytes =
289 decoder.ProcessInput(input.data(), input.size());
290 EXPECT_EQ(input.size(), processed_bytes);
291 EXPECT_THAT(decoder.error(), IsError(QUIC_HTTP_FRAME_ERROR));
292 EXPECT_EQ(test_data.error_message, decoder.error_detail());
293 }
294 }
295
TEST_F(HttpDecoderTest,DuplicateSettingsIdentifier)296 TEST_F(HttpDecoderTest, DuplicateSettingsIdentifier) {
297 std::string input;
298 ASSERT_TRUE(
299 absl::HexStringToBytes("04" // type (SETTINGS)
300 "04" // length
301 "01" // identifier
302 "01" // content
303 "01" // identifier
304 "02", // content
305 &input));
306
307 EXPECT_CALL(visitor_, OnSettingsFrameStart(2));
308 EXPECT_CALL(visitor_, OnError(&decoder_));
309
310 EXPECT_EQ(input.size(), ProcessInput(input));
311
312 EXPECT_THAT(decoder_.error(),
313 IsError(QUIC_HTTP_DUPLICATE_SETTING_IDENTIFIER));
314 EXPECT_EQ("Duplicate setting identifier.", decoder_.error_detail());
315 }
316
TEST_F(HttpDecoderTest,DataFrame)317 TEST_F(HttpDecoderTest, DataFrame) {
318 InSequence s;
319 std::string type_and_length_bytes;
320 ASSERT_TRUE(
321 absl::HexStringToBytes("00" // type (DATA)
322 "05", // length
323 &type_and_length_bytes));
324 std::string input = absl::StrCat(type_and_length_bytes,
325 "Data!"); // data
326
327 // Visitor pauses processing.
328 EXPECT_CALL(visitor_, OnDataFrameStart(2, 5)).WillOnce(Return(false));
329 absl::string_view remaining_input(input);
330 QuicByteCount processed_bytes =
331 ProcessInputWithGarbageAppended(remaining_input);
332 EXPECT_EQ(2u, processed_bytes);
333 remaining_input = remaining_input.substr(processed_bytes);
334
335 EXPECT_CALL(visitor_, OnDataFramePayload(absl::string_view("Data!")))
336 .WillOnce(Return(false));
337 processed_bytes = ProcessInputWithGarbageAppended(remaining_input);
338 EXPECT_EQ(remaining_input.size(), processed_bytes);
339
340 EXPECT_CALL(visitor_, OnDataFrameEnd()).WillOnce(Return(false));
341 EXPECT_EQ(0u, ProcessInputWithGarbageAppended(""));
342 EXPECT_THAT(decoder_.error(), IsQuicNoError());
343 EXPECT_EQ("", decoder_.error_detail());
344
345 // Process the full frame.
346 EXPECT_CALL(visitor_, OnDataFrameStart(2, 5));
347 EXPECT_CALL(visitor_, OnDataFramePayload(absl::string_view("Data!")));
348 EXPECT_CALL(visitor_, OnDataFrameEnd());
349 EXPECT_EQ(input.size(), ProcessInput(input));
350 EXPECT_THAT(decoder_.error(), IsQuicNoError());
351 EXPECT_EQ("", decoder_.error_detail());
352
353 // Process the frame incrementally.
354 EXPECT_CALL(visitor_, OnDataFrameStart(2, 5));
355 EXPECT_CALL(visitor_, OnDataFramePayload(absl::string_view("D")));
356 EXPECT_CALL(visitor_, OnDataFramePayload(absl::string_view("a")));
357 EXPECT_CALL(visitor_, OnDataFramePayload(absl::string_view("t")));
358 EXPECT_CALL(visitor_, OnDataFramePayload(absl::string_view("a")));
359 EXPECT_CALL(visitor_, OnDataFramePayload(absl::string_view("!")));
360 EXPECT_CALL(visitor_, OnDataFrameEnd());
361 ProcessInputCharByChar(input);
362 EXPECT_THAT(decoder_.error(), IsQuicNoError());
363 EXPECT_EQ("", decoder_.error_detail());
364 }
365
TEST_F(HttpDecoderTest,FrameHeaderPartialDelivery)366 TEST_F(HttpDecoderTest, FrameHeaderPartialDelivery) {
367 InSequence s;
368 // A large input that will occupy more than 1 byte in the length field.
369 std::string input(2048, 'x');
370 quiche::QuicheBuffer header = HttpEncoder::SerializeDataFrameHeader(
371 input.length(), quiche::SimpleBufferAllocator::Get());
372 // Partially send only 1 byte of the header to process.
373 EXPECT_EQ(1u, decoder_.ProcessInput(header.data(), 1));
374 EXPECT_THAT(decoder_.error(), IsQuicNoError());
375 EXPECT_EQ("", decoder_.error_detail());
376
377 // Send the rest of the header.
378 EXPECT_CALL(visitor_, OnDataFrameStart(3, input.length()));
379 EXPECT_EQ(header.size() - 1,
380 decoder_.ProcessInput(header.data() + 1, header.size() - 1));
381 EXPECT_THAT(decoder_.error(), IsQuicNoError());
382 EXPECT_EQ("", decoder_.error_detail());
383
384 // Send data.
385 EXPECT_CALL(visitor_, OnDataFramePayload(absl::string_view(input)));
386 EXPECT_CALL(visitor_, OnDataFrameEnd());
387 EXPECT_EQ(2048u, decoder_.ProcessInput(input.data(), 2048));
388 EXPECT_THAT(decoder_.error(), IsQuicNoError());
389 EXPECT_EQ("", decoder_.error_detail());
390 }
391
TEST_F(HttpDecoderTest,PartialDeliveryOfLargeFrameType)392 TEST_F(HttpDecoderTest, PartialDeliveryOfLargeFrameType) {
393 // Use a reserved type that takes four bytes as a varint.
394 const uint64_t frame_type = 0x1f * 0x222 + 0x21;
395 const QuicByteCount payload_length = 0;
396 const QuicByteCount header_length =
397 QuicDataWriter::GetVarInt62Len(frame_type) +
398 QuicDataWriter::GetVarInt62Len(payload_length);
399
400 auto input = std::make_unique<char[]>(header_length);
401 QuicDataWriter writer(header_length, input.get());
402 writer.WriteVarInt62(frame_type);
403 writer.WriteVarInt62(payload_length);
404
405 EXPECT_CALL(visitor_,
406 OnUnknownFrameStart(frame_type, header_length, payload_length));
407 EXPECT_CALL(visitor_, OnUnknownFrameEnd());
408
409 auto raw_input = input.get();
410 for (uint64_t i = 0; i < header_length; ++i) {
411 char c = raw_input[i];
412 EXPECT_EQ(1u, decoder_.ProcessInput(&c, 1));
413 }
414
415 EXPECT_THAT(decoder_.error(), IsQuicNoError());
416 EXPECT_EQ("", decoder_.error_detail());
417 EXPECT_EQ(frame_type, current_frame_type());
418 }
419
TEST_F(HttpDecoderTest,GoAway)420 TEST_F(HttpDecoderTest, GoAway) {
421 InSequence s;
422 std::string input;
423 ASSERT_TRUE(
424 absl::HexStringToBytes("07" // type (GOAWAY)
425 "01" // length
426 "01", // ID
427 &input));
428
429 // Visitor pauses processing.
430 EXPECT_CALL(visitor_, OnGoAwayFrame(GoAwayFrame({1})))
431 .WillOnce(Return(false));
432 EXPECT_EQ(input.size(), ProcessInputWithGarbageAppended(input));
433 EXPECT_THAT(decoder_.error(), IsQuicNoError());
434 EXPECT_EQ("", decoder_.error_detail());
435
436 // Process the full frame.
437 EXPECT_CALL(visitor_, OnGoAwayFrame(GoAwayFrame({1})));
438 EXPECT_EQ(input.size(), ProcessInput(input));
439 EXPECT_THAT(decoder_.error(), IsQuicNoError());
440 EXPECT_EQ("", decoder_.error_detail());
441
442 // Process the frame incrementally.
443 EXPECT_CALL(visitor_, OnGoAwayFrame(GoAwayFrame({1})));
444 ProcessInputCharByChar(input);
445 EXPECT_THAT(decoder_.error(), IsQuicNoError());
446 EXPECT_EQ("", decoder_.error_detail());
447 }
448
TEST_F(HttpDecoderTest,HeadersFrame)449 TEST_F(HttpDecoderTest, HeadersFrame) {
450 InSequence s;
451 std::string type_and_length_bytes;
452 ASSERT_TRUE(
453 absl::HexStringToBytes("01" // type (HEADERS)
454 "07", // length
455 &type_and_length_bytes));
456 std::string input = absl::StrCat(type_and_length_bytes,
457 "Headers"); // headers
458
459 // Visitor pauses processing.
460 EXPECT_CALL(visitor_, OnHeadersFrameStart(2, 7)).WillOnce(Return(false));
461 absl::string_view remaining_input(input);
462 QuicByteCount processed_bytes =
463 ProcessInputWithGarbageAppended(remaining_input);
464 EXPECT_EQ(2u, processed_bytes);
465 remaining_input = remaining_input.substr(processed_bytes);
466
467 EXPECT_CALL(visitor_, OnHeadersFramePayload(absl::string_view("Headers")))
468 .WillOnce(Return(false));
469 processed_bytes = ProcessInputWithGarbageAppended(remaining_input);
470 EXPECT_EQ(remaining_input.size(), processed_bytes);
471
472 EXPECT_CALL(visitor_, OnHeadersFrameEnd()).WillOnce(Return(false));
473 EXPECT_EQ(0u, ProcessInputWithGarbageAppended(""));
474 EXPECT_THAT(decoder_.error(), IsQuicNoError());
475 EXPECT_EQ("", decoder_.error_detail());
476
477 // Process the full frame.
478 EXPECT_CALL(visitor_, OnHeadersFrameStart(2, 7));
479 EXPECT_CALL(visitor_, OnHeadersFramePayload(absl::string_view("Headers")));
480 EXPECT_CALL(visitor_, OnHeadersFrameEnd());
481 EXPECT_EQ(input.size(), ProcessInput(input));
482 EXPECT_THAT(decoder_.error(), IsQuicNoError());
483 EXPECT_EQ("", decoder_.error_detail());
484
485 // Process the frame incrementally.
486 EXPECT_CALL(visitor_, OnHeadersFrameStart(2, 7));
487 EXPECT_CALL(visitor_, OnHeadersFramePayload(absl::string_view("H")));
488 EXPECT_CALL(visitor_, OnHeadersFramePayload(absl::string_view("e")));
489 EXPECT_CALL(visitor_, OnHeadersFramePayload(absl::string_view("a")));
490 EXPECT_CALL(visitor_, OnHeadersFramePayload(absl::string_view("d")));
491 EXPECT_CALL(visitor_, OnHeadersFramePayload(absl::string_view("e")));
492 EXPECT_CALL(visitor_, OnHeadersFramePayload(absl::string_view("r")));
493 EXPECT_CALL(visitor_, OnHeadersFramePayload(absl::string_view("s")));
494 EXPECT_CALL(visitor_, OnHeadersFrameEnd());
495 ProcessInputCharByChar(input);
496 EXPECT_THAT(decoder_.error(), IsQuicNoError());
497 EXPECT_EQ("", decoder_.error_detail());
498 }
499
TEST_F(HttpDecoderTest,MetadataFrame)500 TEST_F(HttpDecoderTest, MetadataFrame) {
501 if (!GetQuicReloadableFlag(quic_enable_http3_metadata_decoding)) {
502 return;
503 }
504 InSequence s;
505 std::string type_and_length_bytes;
506 ASSERT_TRUE(
507 absl::HexStringToBytes("404d" // 2 byte type (METADATA)
508 "08", // length
509 &type_and_length_bytes));
510 std::string input = absl::StrCat(type_and_length_bytes,
511 "Metadata"); // headers
512
513 // Visitor pauses processing.
514 EXPECT_CALL(visitor_, OnMetadataFrameStart(3, 8)).WillOnce(Return(false));
515 absl::string_view remaining_input(input);
516 QuicByteCount processed_bytes =
517 ProcessInputWithGarbageAppended(remaining_input);
518 EXPECT_EQ(3u, processed_bytes);
519 remaining_input = remaining_input.substr(processed_bytes);
520
521 EXPECT_CALL(visitor_, OnMetadataFramePayload(absl::string_view("Metadata")))
522 .WillOnce(Return(false));
523 processed_bytes = ProcessInputWithGarbageAppended(remaining_input);
524 EXPECT_EQ(remaining_input.size(), processed_bytes);
525
526 EXPECT_CALL(visitor_, OnMetadataFrameEnd()).WillOnce(Return(false));
527 EXPECT_EQ(0u, ProcessInputWithGarbageAppended(""));
528 EXPECT_THAT(decoder_.error(), IsQuicNoError());
529 EXPECT_EQ("", decoder_.error_detail());
530
531 // Process the full frame.
532 EXPECT_CALL(visitor_, OnMetadataFrameStart(3, 8));
533 EXPECT_CALL(visitor_, OnMetadataFramePayload(absl::string_view("Metadata")));
534 EXPECT_CALL(visitor_, OnMetadataFrameEnd());
535 EXPECT_EQ(input.size(), ProcessInput(input));
536 EXPECT_THAT(decoder_.error(), IsQuicNoError());
537 EXPECT_EQ("", decoder_.error_detail());
538
539 // Process the frame incrementally.
540 EXPECT_CALL(visitor_, OnMetadataFrameStart(3, 8));
541 EXPECT_CALL(visitor_, OnMetadataFramePayload(absl::string_view("M")));
542 EXPECT_CALL(visitor_, OnMetadataFramePayload(absl::string_view("e")));
543 EXPECT_CALL(visitor_, OnMetadataFramePayload(absl::string_view("t")));
544 EXPECT_CALL(visitor_, OnMetadataFramePayload(absl::string_view("a")));
545 EXPECT_CALL(visitor_, OnMetadataFramePayload(absl::string_view("d")));
546 EXPECT_CALL(visitor_, OnMetadataFramePayload(absl::string_view("a")));
547 EXPECT_CALL(visitor_, OnMetadataFramePayload(absl::string_view("t")));
548 EXPECT_CALL(visitor_, OnMetadataFramePayload(absl::string_view("a")));
549 EXPECT_CALL(visitor_, OnMetadataFrameEnd());
550 ProcessInputCharByChar(input);
551 EXPECT_THAT(decoder_.error(), IsQuicNoError());
552 EXPECT_EQ("", decoder_.error_detail());
553 }
554
TEST_F(HttpDecoderTest,EmptyDataFrame)555 TEST_F(HttpDecoderTest, EmptyDataFrame) {
556 InSequence s;
557 std::string input;
558 ASSERT_TRUE(
559 absl::HexStringToBytes("00" // type (DATA)
560 "00", // length
561 &input));
562
563 // Visitor pauses processing.
564 EXPECT_CALL(visitor_, OnDataFrameStart(2, 0)).WillOnce(Return(false));
565 EXPECT_EQ(input.size(), ProcessInputWithGarbageAppended(input));
566
567 EXPECT_CALL(visitor_, OnDataFrameEnd()).WillOnce(Return(false));
568 EXPECT_EQ(0u, ProcessInputWithGarbageAppended(""));
569 EXPECT_THAT(decoder_.error(), IsQuicNoError());
570 EXPECT_EQ("", decoder_.error_detail());
571
572 // Process the full frame.
573 EXPECT_CALL(visitor_, OnDataFrameStart(2, 0));
574 EXPECT_CALL(visitor_, OnDataFrameEnd());
575 EXPECT_EQ(input.size(), ProcessInput(input));
576 EXPECT_THAT(decoder_.error(), IsQuicNoError());
577 EXPECT_EQ("", decoder_.error_detail());
578
579 // Process the frame incrementally.
580 EXPECT_CALL(visitor_, OnDataFrameStart(2, 0));
581 EXPECT_CALL(visitor_, OnDataFrameEnd());
582 ProcessInputCharByChar(input);
583 EXPECT_THAT(decoder_.error(), IsQuicNoError());
584 EXPECT_EQ("", decoder_.error_detail());
585 }
586
TEST_F(HttpDecoderTest,EmptyHeadersFrame)587 TEST_F(HttpDecoderTest, EmptyHeadersFrame) {
588 InSequence s;
589 std::string input;
590 ASSERT_TRUE(
591 absl::HexStringToBytes("01" // type (HEADERS)
592 "00", // length
593 &input));
594
595 // Visitor pauses processing.
596 EXPECT_CALL(visitor_, OnHeadersFrameStart(2, 0)).WillOnce(Return(false));
597 EXPECT_EQ(input.size(), ProcessInputWithGarbageAppended(input));
598
599 EXPECT_CALL(visitor_, OnHeadersFrameEnd()).WillOnce(Return(false));
600 EXPECT_EQ(0u, ProcessInputWithGarbageAppended(""));
601 EXPECT_THAT(decoder_.error(), IsQuicNoError());
602 EXPECT_EQ("", decoder_.error_detail());
603
604 // Process the full frame.
605 EXPECT_CALL(visitor_, OnHeadersFrameStart(2, 0));
606 EXPECT_CALL(visitor_, OnHeadersFrameEnd());
607 EXPECT_EQ(input.size(), ProcessInput(input));
608 EXPECT_THAT(decoder_.error(), IsQuicNoError());
609 EXPECT_EQ("", decoder_.error_detail());
610
611 // Process the frame incrementally.
612 EXPECT_CALL(visitor_, OnHeadersFrameStart(2, 0));
613 EXPECT_CALL(visitor_, OnHeadersFrameEnd());
614 ProcessInputCharByChar(input);
615 EXPECT_THAT(decoder_.error(), IsQuicNoError());
616 EXPECT_EQ("", decoder_.error_detail());
617 }
618
TEST_F(HttpDecoderTest,GoawayWithOverlyLargePayload)619 TEST_F(HttpDecoderTest, GoawayWithOverlyLargePayload) {
620 std::string input;
621 ASSERT_TRUE(absl::HexStringToBytes(
622 "07" // type (GOAWAY)
623 "10", // length exceeding the maximum possible length for GOAWAY frame
624 &input));
625 // Process all data at once.
626 EXPECT_CALL(visitor_, OnError(&decoder_));
627 EXPECT_EQ(2u, ProcessInput(input));
628 EXPECT_THAT(decoder_.error(), IsError(QUIC_HTTP_FRAME_TOO_LARGE));
629 EXPECT_EQ("Frame is too large.", decoder_.error_detail());
630 }
631
TEST_F(HttpDecoderTest,MaxPushIdWithOverlyLargePayload)632 TEST_F(HttpDecoderTest, MaxPushIdWithOverlyLargePayload) {
633 std::string input;
634 ASSERT_TRUE(
635 absl::HexStringToBytes("0d" // type (MAX_PUSH_ID)
636 "10", // length exceeding the maximum possible
637 // length for MAX_PUSH_ID frame
638 &input));
639 // Process all data at once.
640 EXPECT_CALL(visitor_, OnError(&decoder_));
641 EXPECT_EQ(2u, ProcessInput(input));
642 EXPECT_THAT(decoder_.error(), IsError(QUIC_HTTP_FRAME_TOO_LARGE));
643 EXPECT_EQ("Frame is too large.", decoder_.error_detail());
644 }
645
TEST_F(HttpDecoderTest,FrameWithOverlyLargePayload)646 TEST_F(HttpDecoderTest, FrameWithOverlyLargePayload) {
647 // Regression test for b/193919867: Ensure that reading frames with incredibly
648 // large payload lengths does not lead to allocating unbounded memory.
649 constexpr size_t max_input_length =
650 /*max frame type varint length*/ sizeof(uint64_t) +
651 /*max frame length varint length*/ sizeof(uint64_t) +
652 /*one byte of payload*/ sizeof(uint8_t);
653 char input[max_input_length];
654 for (uint64_t frame_type = 0; frame_type < 1025; frame_type++) {
655 ::testing::NiceMock<MockHttpDecoderVisitor> visitor;
656 HttpDecoder decoder(&visitor);
657 QuicDataWriter writer(max_input_length, input);
658 ASSERT_TRUE(writer.WriteVarInt62(frame_type)); // frame type.
659 ASSERT_TRUE(
660 writer.WriteVarInt62(quiche::kVarInt62MaxValue)); // frame length.
661 ASSERT_TRUE(writer.WriteUInt8(0x00)); // one byte of payload.
662 EXPECT_NE(decoder.ProcessInput(input, writer.length()), 0u) << frame_type;
663 }
664 }
665
TEST_F(HttpDecoderTest,MalformedSettingsFrame)666 TEST_F(HttpDecoderTest, MalformedSettingsFrame) {
667 char input[30];
668 QuicDataWriter writer(30, input);
669 // Write type SETTINGS.
670 writer.WriteUInt8(0x04);
671 // Write length.
672 writer.WriteVarInt62(2048 * 1024);
673
674 writer.WriteStringPiece("Malformed payload");
675 EXPECT_CALL(visitor_, OnError(&decoder_));
676 EXPECT_EQ(5u, decoder_.ProcessInput(input, ABSL_ARRAYSIZE(input)));
677 EXPECT_THAT(decoder_.error(), IsError(QUIC_HTTP_FRAME_TOO_LARGE));
678 EXPECT_EQ("Frame is too large.", decoder_.error_detail());
679 }
680
TEST_F(HttpDecoderTest,Http2Frame)681 TEST_F(HttpDecoderTest, Http2Frame) {
682 std::string input;
683 ASSERT_TRUE(absl::HexStringToBytes(
684 "06" // PING in HTTP/2 but not supported in HTTP/3.
685 "05" // length
686 "15", // random payload
687 &input));
688
689 // Process the full frame.
690 EXPECT_CALL(visitor_, OnError(&decoder_));
691 EXPECT_EQ(1u, ProcessInput(input));
692 EXPECT_THAT(decoder_.error(), IsError(QUIC_HTTP_RECEIVE_SPDY_FRAME));
693 EXPECT_EQ("HTTP/2 frame received in a HTTP/3 connection: 6",
694 decoder_.error_detail());
695 }
696
TEST_F(HttpDecoderTest,HeadersPausedThenData)697 TEST_F(HttpDecoderTest, HeadersPausedThenData) {
698 InSequence s;
699 std::string headers_type_and_length_bytes;
700 ASSERT_TRUE(
701 absl::HexStringToBytes("01" // type (HEADERS)
702 "07", // length,
703 &headers_type_and_length_bytes));
704 std::string headers = absl::StrCat(headers_type_and_length_bytes, "Headers");
705 std::string data_type_and_length_bytes;
706 ASSERT_TRUE(
707 absl::HexStringToBytes("00" // type (DATA)
708 "05", // length
709 &data_type_and_length_bytes));
710 std::string data = absl::StrCat(data_type_and_length_bytes, "Data!");
711 std::string input = absl::StrCat(headers, data);
712
713 // Visitor pauses processing, maybe because header decompression is blocked.
714 EXPECT_CALL(visitor_, OnHeadersFrameStart(2, 7));
715 EXPECT_CALL(visitor_, OnHeadersFramePayload(absl::string_view("Headers")));
716 EXPECT_CALL(visitor_, OnHeadersFrameEnd()).WillOnce(Return(false));
717 absl::string_view remaining_input(input);
718 QuicByteCount processed_bytes =
719 ProcessInputWithGarbageAppended(remaining_input);
720 EXPECT_EQ(9u, processed_bytes);
721 remaining_input = remaining_input.substr(processed_bytes);
722
723 // Process DATA frame.
724 EXPECT_CALL(visitor_, OnDataFrameStart(2, 5));
725 EXPECT_CALL(visitor_, OnDataFramePayload(absl::string_view("Data!")));
726 EXPECT_CALL(visitor_, OnDataFrameEnd());
727
728 processed_bytes = ProcessInput(remaining_input);
729 EXPECT_EQ(remaining_input.size(), processed_bytes);
730
731 EXPECT_THAT(decoder_.error(), IsQuicNoError());
732 EXPECT_EQ("", decoder_.error_detail());
733 }
734
TEST_F(HttpDecoderTest,CorruptFrame)735 TEST_F(HttpDecoderTest, CorruptFrame) {
736 InSequence s;
737
738 struct {
739 const char* const input;
740 const char* const error_message;
741 } kTestData[] = {{"\x0D" // type (MAX_PUSH_ID)
742 "\x01" // length
743 "\x40", // first byte of two-byte varint push id
744 "Unable to read MAX_PUSH_ID push_id."},
745 {"\x0D" // type (MAX_PUSH_ID)
746 "\x04" // length
747 "\x05" // valid push id
748 "foo", // superfluous data
749 "Superfluous data in MAX_PUSH_ID frame."},
750 {"\x07" // type (GOAWAY)
751 "\x01" // length
752 "\x40", // first byte of two-byte varint stream id
753 "Unable to read GOAWAY ID."},
754 {"\x07" // type (GOAWAY)
755 "\x04" // length
756 "\x05" // valid stream id
757 "foo", // superfluous data
758 "Superfluous data in GOAWAY frame."},
759 {"\x40\x89" // type (ACCEPT_CH)
760 "\x01" // length
761 "\x40", // first byte of two-byte varint origin length
762 "Unable to read ACCEPT_CH origin."},
763 {"\x40\x89" // type (ACCEPT_CH)
764 "\x01" // length
765 "\x05", // valid origin length but no origin string
766 "Unable to read ACCEPT_CH origin."},
767 {"\x40\x89" // type (ACCEPT_CH)
768 "\x04" // length
769 "\x05" // valid origin length
770 "foo", // payload ends before origin ends
771 "Unable to read ACCEPT_CH origin."},
772 {"\x40\x89" // type (ACCEPT_CH)
773 "\x04" // length
774 "\x03" // valid origin length
775 "foo", // payload ends at end of origin: no value
776 "Unable to read ACCEPT_CH value."},
777 {"\x40\x89" // type (ACCEPT_CH)
778 "\x05" // length
779 "\x03" // valid origin length
780 "foo" // payload ends at end of origin: no value
781 "\x40", // first byte of two-byte varint value length
782 "Unable to read ACCEPT_CH value."},
783 {"\x40\x89" // type (ACCEPT_CH)
784 "\x08" // length
785 "\x03" // valid origin length
786 "foo" // origin
787 "\x05" // valid value length
788 "bar", // payload ends before value ends
789 "Unable to read ACCEPT_CH value."}};
790
791 for (const auto& test_data : kTestData) {
792 {
793 HttpDecoder decoder(&visitor_);
794 EXPECT_CALL(visitor_, OnAcceptChFrameStart(_)).Times(AnyNumber());
795 EXPECT_CALL(visitor_, OnError(&decoder));
796
797 absl::string_view input(test_data.input);
798 decoder.ProcessInput(input.data(), input.size());
799 EXPECT_THAT(decoder.error(), IsError(QUIC_HTTP_FRAME_ERROR));
800 EXPECT_EQ(test_data.error_message, decoder.error_detail());
801 }
802 {
803 HttpDecoder decoder(&visitor_);
804 EXPECT_CALL(visitor_, OnAcceptChFrameStart(_)).Times(AnyNumber());
805 EXPECT_CALL(visitor_, OnError(&decoder));
806
807 absl::string_view input(test_data.input);
808 for (auto c : input) {
809 decoder.ProcessInput(&c, 1);
810 }
811 EXPECT_THAT(decoder.error(), IsError(QUIC_HTTP_FRAME_ERROR));
812 EXPECT_EQ(test_data.error_message, decoder.error_detail());
813 }
814 }
815 }
816
TEST_F(HttpDecoderTest,EmptySettingsFrame)817 TEST_F(HttpDecoderTest, EmptySettingsFrame) {
818 std::string input;
819 ASSERT_TRUE(
820 absl::HexStringToBytes("04" // type (SETTINGS)
821 "00", // frame length
822 &input));
823
824 EXPECT_CALL(visitor_, OnSettingsFrameStart(2));
825
826 SettingsFrame empty_frame;
827 EXPECT_CALL(visitor_, OnSettingsFrame(empty_frame));
828
829 EXPECT_EQ(input.size(), ProcessInput(input));
830 EXPECT_THAT(decoder_.error(), IsQuicNoError());
831 EXPECT_EQ("", decoder_.error_detail());
832 }
833
TEST_F(HttpDecoderTest,EmptyGoAwayFrame)834 TEST_F(HttpDecoderTest, EmptyGoAwayFrame) {
835 std::string input;
836 ASSERT_TRUE(
837 absl::HexStringToBytes("07" // type (GOAWAY)
838 "00", // frame length
839 &input));
840
841 EXPECT_CALL(visitor_, OnError(&decoder_));
842 EXPECT_EQ(input.size(), ProcessInput(input));
843 EXPECT_THAT(decoder_.error(), IsError(QUIC_HTTP_FRAME_ERROR));
844 EXPECT_EQ("Unable to read GOAWAY ID.", decoder_.error_detail());
845 }
846
TEST_F(HttpDecoderTest,EmptyMaxPushIdFrame)847 TEST_F(HttpDecoderTest, EmptyMaxPushIdFrame) {
848 std::string input;
849 ASSERT_TRUE(
850 absl::HexStringToBytes("0d" // type (MAX_PUSH_ID)
851 "00", // frame length
852 &input));
853
854 EXPECT_CALL(visitor_, OnError(&decoder_));
855 EXPECT_EQ(input.size(), ProcessInput(input));
856 EXPECT_THAT(decoder_.error(), IsError(QUIC_HTTP_FRAME_ERROR));
857 EXPECT_EQ("Unable to read MAX_PUSH_ID push_id.", decoder_.error_detail());
858 }
859
TEST_F(HttpDecoderTest,LargeStreamIdInGoAway)860 TEST_F(HttpDecoderTest, LargeStreamIdInGoAway) {
861 GoAwayFrame frame;
862 frame.id = 1ull << 60;
863 std::string goaway = HttpEncoder::SerializeGoAwayFrame(frame);
864 EXPECT_CALL(visitor_, OnGoAwayFrame(frame));
865 EXPECT_GT(goaway.length(), 0u);
866 EXPECT_EQ(goaway.length(),
867 decoder_.ProcessInput(goaway.data(), goaway.length()));
868 EXPECT_THAT(decoder_.error(), IsQuicNoError());
869 EXPECT_EQ("", decoder_.error_detail());
870 }
871
872 // Old PRIORITY_UPDATE frame is parsed as unknown frame.
TEST_F(HttpDecoderTest,ObsoletePriorityUpdateFrame)873 TEST_F(HttpDecoderTest, ObsoletePriorityUpdateFrame) {
874 const QuicByteCount header_length = 2;
875 const QuicByteCount payload_length = 3;
876 InSequence s;
877 std::string input;
878 ASSERT_TRUE(
879 absl::HexStringToBytes("0f" // type (obsolete PRIORITY_UPDATE)
880 "03" // length
881 "666f6f", // payload "foo"
882 &input));
883
884 // Process frame as a whole.
885 EXPECT_CALL(visitor_,
886 OnUnknownFrameStart(0x0f, header_length, payload_length));
887 EXPECT_CALL(visitor_, OnUnknownFramePayload(Eq("foo")));
888 EXPECT_CALL(visitor_, OnUnknownFrameEnd()).WillOnce(Return(false));
889
890 EXPECT_EQ(header_length + payload_length,
891 ProcessInputWithGarbageAppended(input));
892 EXPECT_THAT(decoder_.error(), IsQuicNoError());
893 EXPECT_EQ("", decoder_.error_detail());
894
895 // Process frame byte by byte.
896 EXPECT_CALL(visitor_,
897 OnUnknownFrameStart(0x0f, header_length, payload_length));
898 EXPECT_CALL(visitor_, OnUnknownFramePayload(Eq("f")));
899 EXPECT_CALL(visitor_, OnUnknownFramePayload(Eq("o")));
900 EXPECT_CALL(visitor_, OnUnknownFramePayload(Eq("o")));
901 EXPECT_CALL(visitor_, OnUnknownFrameEnd());
902
903 ProcessInputCharByChar(input);
904 EXPECT_THAT(decoder_.error(), IsQuicNoError());
905 EXPECT_EQ("", decoder_.error_detail());
906 }
907
TEST_F(HttpDecoderTest,PriorityUpdateFrame)908 TEST_F(HttpDecoderTest, PriorityUpdateFrame) {
909 InSequence s;
910 std::string input1;
911 ASSERT_TRUE(
912 absl::HexStringToBytes("800f0700" // type (PRIORITY_UPDATE)
913 "01" // length
914 "03", // prioritized element id
915 &input1));
916
917 PriorityUpdateFrame priority_update1;
918 priority_update1.prioritized_element_id = 0x03;
919
920 // Visitor pauses processing.
921 EXPECT_CALL(visitor_, OnPriorityUpdateFrameStart(5)).WillOnce(Return(false));
922 absl::string_view remaining_input(input1);
923 QuicByteCount processed_bytes =
924 ProcessInputWithGarbageAppended(remaining_input);
925 EXPECT_EQ(5u, processed_bytes);
926 remaining_input = remaining_input.substr(processed_bytes);
927
928 EXPECT_CALL(visitor_, OnPriorityUpdateFrame(priority_update1))
929 .WillOnce(Return(false));
930 processed_bytes = ProcessInputWithGarbageAppended(remaining_input);
931 EXPECT_EQ(remaining_input.size(), processed_bytes);
932 EXPECT_THAT(decoder_.error(), IsQuicNoError());
933 EXPECT_EQ("", decoder_.error_detail());
934
935 // Process the full frame.
936 EXPECT_CALL(visitor_, OnPriorityUpdateFrameStart(5));
937 EXPECT_CALL(visitor_, OnPriorityUpdateFrame(priority_update1));
938 EXPECT_EQ(input1.size(), ProcessInput(input1));
939 EXPECT_THAT(decoder_.error(), IsQuicNoError());
940 EXPECT_EQ("", decoder_.error_detail());
941
942 // Process the frame incrementally.
943 EXPECT_CALL(visitor_, OnPriorityUpdateFrameStart(5));
944 EXPECT_CALL(visitor_, OnPriorityUpdateFrame(priority_update1));
945 ProcessInputCharByChar(input1);
946 EXPECT_THAT(decoder_.error(), IsQuicNoError());
947 EXPECT_EQ("", decoder_.error_detail());
948
949 std::string input2;
950 ASSERT_TRUE(
951 absl::HexStringToBytes("800f0700" // type (PRIORITY_UPDATE)
952 "04" // length
953 "05" // prioritized element id
954 "666f6f", // priority field value: "foo"
955 &input2));
956
957 PriorityUpdateFrame priority_update2;
958 priority_update2.prioritized_element_id = 0x05;
959 priority_update2.priority_field_value = "foo";
960
961 // Visitor pauses processing.
962 EXPECT_CALL(visitor_, OnPriorityUpdateFrameStart(5)).WillOnce(Return(false));
963 remaining_input = input2;
964 processed_bytes = ProcessInputWithGarbageAppended(remaining_input);
965 EXPECT_EQ(5u, processed_bytes);
966 remaining_input = remaining_input.substr(processed_bytes);
967
968 EXPECT_CALL(visitor_, OnPriorityUpdateFrame(priority_update2))
969 .WillOnce(Return(false));
970 processed_bytes = ProcessInputWithGarbageAppended(remaining_input);
971 EXPECT_EQ(remaining_input.size(), processed_bytes);
972 EXPECT_THAT(decoder_.error(), IsQuicNoError());
973 EXPECT_EQ("", decoder_.error_detail());
974
975 // Process the full frame.
976 EXPECT_CALL(visitor_, OnPriorityUpdateFrameStart(5));
977 EXPECT_CALL(visitor_, OnPriorityUpdateFrame(priority_update2));
978 EXPECT_EQ(input2.size(), ProcessInput(input2));
979 EXPECT_THAT(decoder_.error(), IsQuicNoError());
980 EXPECT_EQ("", decoder_.error_detail());
981
982 // Process the frame incrementally.
983 EXPECT_CALL(visitor_, OnPriorityUpdateFrameStart(5));
984 EXPECT_CALL(visitor_, OnPriorityUpdateFrame(priority_update2));
985 ProcessInputCharByChar(input2);
986 EXPECT_THAT(decoder_.error(), IsQuicNoError());
987 EXPECT_EQ("", decoder_.error_detail());
988 }
989
TEST_F(HttpDecoderTest,CorruptPriorityUpdateFrame)990 TEST_F(HttpDecoderTest, CorruptPriorityUpdateFrame) {
991 std::string payload;
992 ASSERT_TRUE(absl::HexStringToBytes("4005", // prioritized element id
993 &payload));
994 struct {
995 size_t payload_length;
996 const char* const error_message;
997 } kTestData[] = {
998 {0, "Unable to read prioritized element id."},
999 {1, "Unable to read prioritized element id."},
1000 };
1001
1002 for (const auto& test_data : kTestData) {
1003 std::string input;
1004 ASSERT_TRUE(absl::HexStringToBytes("800f0700", // type PRIORITY_UPDATE
1005 &input));
1006 input.push_back(test_data.payload_length);
1007 size_t header_length = input.size();
1008 input.append(payload.data(), test_data.payload_length);
1009
1010 HttpDecoder decoder(&visitor_);
1011 EXPECT_CALL(visitor_, OnPriorityUpdateFrameStart(header_length));
1012 EXPECT_CALL(visitor_, OnError(&decoder));
1013
1014 QuicByteCount processed_bytes =
1015 decoder.ProcessInput(input.data(), input.size());
1016 EXPECT_EQ(input.size(), processed_bytes);
1017 EXPECT_THAT(decoder.error(), IsError(QUIC_HTTP_FRAME_ERROR));
1018 EXPECT_EQ(test_data.error_message, decoder.error_detail());
1019 }
1020 }
1021
TEST_F(HttpDecoderTest,AcceptChFrame)1022 TEST_F(HttpDecoderTest, AcceptChFrame) {
1023 InSequence s;
1024 std::string input1;
1025 ASSERT_TRUE(
1026 absl::HexStringToBytes("4089" // type (ACCEPT_CH)
1027 "00", // length
1028 &input1));
1029
1030 AcceptChFrame accept_ch1;
1031
1032 // Visitor pauses processing.
1033 EXPECT_CALL(visitor_, OnAcceptChFrameStart(3)).WillOnce(Return(false));
1034 absl::string_view remaining_input(input1);
1035 QuicByteCount processed_bytes =
1036 ProcessInputWithGarbageAppended(remaining_input);
1037 EXPECT_EQ(3u, processed_bytes);
1038 remaining_input = remaining_input.substr(processed_bytes);
1039
1040 EXPECT_CALL(visitor_, OnAcceptChFrame(accept_ch1)).WillOnce(Return(false));
1041 processed_bytes = ProcessInputWithGarbageAppended(remaining_input);
1042 EXPECT_EQ(remaining_input.size(), processed_bytes);
1043 EXPECT_THAT(decoder_.error(), IsQuicNoError());
1044 EXPECT_EQ("", decoder_.error_detail());
1045
1046 // Process the full frame.
1047 EXPECT_CALL(visitor_, OnAcceptChFrameStart(3));
1048 EXPECT_CALL(visitor_, OnAcceptChFrame(accept_ch1));
1049 EXPECT_EQ(input1.size(), ProcessInput(input1));
1050 EXPECT_THAT(decoder_.error(), IsQuicNoError());
1051 EXPECT_EQ("", decoder_.error_detail());
1052
1053 // Process the frame incrementally.
1054 EXPECT_CALL(visitor_, OnAcceptChFrameStart(3));
1055 EXPECT_CALL(visitor_, OnAcceptChFrame(accept_ch1));
1056 ProcessInputCharByChar(input1);
1057 EXPECT_THAT(decoder_.error(), IsQuicNoError());
1058 EXPECT_EQ("", decoder_.error_detail());
1059
1060 std::string input2;
1061 ASSERT_TRUE(
1062 absl::HexStringToBytes("4089" // type (ACCEPT_CH)
1063 "08" // length
1064 "03" // length of origin
1065 "666f6f" // origin "foo"
1066 "03" // length of value
1067 "626172", // value "bar"
1068 &input2));
1069
1070 AcceptChFrame accept_ch2;
1071 accept_ch2.entries.push_back({"foo", "bar"});
1072
1073 // Visitor pauses processing.
1074 EXPECT_CALL(visitor_, OnAcceptChFrameStart(3)).WillOnce(Return(false));
1075 remaining_input = input2;
1076 processed_bytes = ProcessInputWithGarbageAppended(remaining_input);
1077 EXPECT_EQ(3u, processed_bytes);
1078 remaining_input = remaining_input.substr(processed_bytes);
1079
1080 EXPECT_CALL(visitor_, OnAcceptChFrame(accept_ch2)).WillOnce(Return(false));
1081 processed_bytes = ProcessInputWithGarbageAppended(remaining_input);
1082 EXPECT_EQ(remaining_input.size(), processed_bytes);
1083 EXPECT_THAT(decoder_.error(), IsQuicNoError());
1084 EXPECT_EQ("", decoder_.error_detail());
1085
1086 // Process the full frame.
1087 EXPECT_CALL(visitor_, OnAcceptChFrameStart(3));
1088 EXPECT_CALL(visitor_, OnAcceptChFrame(accept_ch2));
1089 EXPECT_EQ(input2.size(), ProcessInput(input2));
1090 EXPECT_THAT(decoder_.error(), IsQuicNoError());
1091 EXPECT_EQ("", decoder_.error_detail());
1092
1093 // Process the frame incrementally.
1094 EXPECT_CALL(visitor_, OnAcceptChFrameStart(3));
1095 EXPECT_CALL(visitor_, OnAcceptChFrame(accept_ch2));
1096 ProcessInputCharByChar(input2);
1097 EXPECT_THAT(decoder_.error(), IsQuicNoError());
1098 EXPECT_EQ("", decoder_.error_detail());
1099 }
1100
TEST_F(HttpDecoderTest,WebTransportStreamDisabled)1101 TEST_F(HttpDecoderTest, WebTransportStreamDisabled) {
1102 InSequence s;
1103
1104 // Unknown frame of type 0x41 and length 0x104.
1105 std::string input;
1106 ASSERT_TRUE(absl::HexStringToBytes("40414104", &input));
1107 EXPECT_CALL(visitor_, OnUnknownFrameStart(0x41, input.size(), 0x104));
1108 EXPECT_EQ(ProcessInput(input), input.size());
1109 }
1110
TEST(HttpDecoderTestNoFixture,WebTransportStream)1111 TEST(HttpDecoderTestNoFixture, WebTransportStream) {
1112 testing::StrictMock<MockHttpDecoderVisitor> visitor;
1113 HttpDecoder decoder(&visitor);
1114 decoder.EnableWebTransportStreamParsing();
1115
1116 // WebTransport stream for session ID 0x104, with four bytes of extra data.
1117 std::string input;
1118 ASSERT_TRUE(absl::HexStringToBytes("40414104ffffffff", &input));
1119 EXPECT_CALL(visitor, OnWebTransportStreamFrameType(4, 0x104));
1120 QuicByteCount bytes = decoder.ProcessInput(input.data(), input.size());
1121 EXPECT_EQ(bytes, 4u);
1122 }
1123
TEST(HttpDecoderTestNoFixture,WebTransportStreamError)1124 TEST(HttpDecoderTestNoFixture, WebTransportStreamError) {
1125 testing::StrictMock<MockHttpDecoderVisitor> visitor;
1126 HttpDecoder decoder(&visitor);
1127 decoder.EnableWebTransportStreamParsing();
1128
1129 std::string input;
1130 ASSERT_TRUE(absl::HexStringToBytes("404100", &input));
1131 EXPECT_CALL(visitor, OnWebTransportStreamFrameType(_, _));
1132 decoder.ProcessInput(input.data(), input.size());
1133
1134 EXPECT_QUIC_BUG(
1135 {
1136 EXPECT_CALL(visitor, OnError(_));
1137 decoder.ProcessInput(input.data(), input.size());
1138 },
1139 "HttpDecoder called after an indefinite-length frame");
1140 }
1141
TEST_F(HttpDecoderTest,DecodeSettings)1142 TEST_F(HttpDecoderTest, DecodeSettings) {
1143 std::string input;
1144 ASSERT_TRUE(absl::HexStringToBytes(
1145 "04" // type (SETTINGS)
1146 "07" // length
1147 "01" // identifier (SETTINGS_QPACK_MAX_TABLE_CAPACITY)
1148 "02" // content
1149 "06" // identifier (SETTINGS_MAX_HEADER_LIST_SIZE)
1150 "05" // content
1151 "4100" // identifier, encoded on 2 bytes (0x40), value is 256 (0x100)
1152 "04", // content
1153 &input));
1154
1155 SettingsFrame frame;
1156 frame.values[1] = 2;
1157 frame.values[6] = 5;
1158 frame.values[256] = 4;
1159
1160 SettingsFrame out;
1161 EXPECT_TRUE(HttpDecoder::DecodeSettings(input.data(), input.size(), &out));
1162 EXPECT_EQ(frame, out);
1163
1164 // non-settings frame.
1165 ASSERT_TRUE(
1166 absl::HexStringToBytes("0D" // type (MAX_PUSH_ID)
1167 "01" // length
1168 "01", // Push Id
1169 &input));
1170
1171 EXPECT_FALSE(HttpDecoder::DecodeSettings(input.data(), input.size(), &out));
1172
1173 // Corrupt SETTINGS.
1174 ASSERT_TRUE(absl::HexStringToBytes(
1175 "04" // type (SETTINGS)
1176 "01" // length
1177 "42", // First byte of setting identifier, indicating a 2-byte varint62.
1178 &input));
1179
1180 EXPECT_FALSE(HttpDecoder::DecodeSettings(input.data(), input.size(), &out));
1181 }
1182
1183 } // namespace
1184 } // namespace test
1185 } // namespace quic
1186