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/crypto/transport_parameters.h"
6
7 #include <cstring>
8 #include <string>
9 #include <utility>
10
11 #include "absl/base/macros.h"
12 #include "absl/strings/escaping.h"
13 #include "absl/strings/string_view.h"
14 #include "quiche/quic/core/crypto/crypto_protocol.h"
15 #include "quiche/quic/core/quic_connection_id.h"
16 #include "quiche/quic/core/quic_tag.h"
17 #include "quiche/quic/core/quic_types.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_ip_address.h"
21 #include "quiche/quic/platform/api/quic_test.h"
22 #include "quiche/quic/test_tools/quic_test_utils.h"
23
24 namespace quic {
25 namespace test {
26 namespace {
27
28 const QuicVersionLabel kFakeVersionLabel = 0x01234567;
29 const QuicVersionLabel kFakeVersionLabel2 = 0x89ABCDEF;
30 const uint64_t kFakeIdleTimeoutMilliseconds = 12012;
31 const uint64_t kFakeInitialMaxData = 101;
32 const uint64_t kFakeInitialMaxStreamDataBidiLocal = 2001;
33 const uint64_t kFakeInitialMaxStreamDataBidiRemote = 2002;
34 const uint64_t kFakeInitialMaxStreamDataUni = 3000;
35 const uint64_t kFakeInitialMaxStreamsBidi = 21;
36 const uint64_t kFakeInitialMaxStreamsUni = 22;
37 const bool kFakeDisableMigration = true;
38 const uint64_t kFakeInitialRoundTripTime = 53;
39 const uint8_t kFakePreferredStatelessResetTokenData[16] = {
40 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
41 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F};
42
43 const auto kCustomParameter1 =
44 static_cast<TransportParameters::TransportParameterId>(0xffcd);
45 const char* kCustomParameter1Value = "foo";
46 const auto kCustomParameter2 =
47 static_cast<TransportParameters::TransportParameterId>(0xff34);
48 const char* kCustomParameter2Value = "bar";
49
50 const char kFakeGoogleHandshakeMessage[] =
51 "01000106030392655f5230270d4964a4f99b15bbad220736d972aea97bf9ac494ead62e6";
52
CreateFakeOriginalDestinationConnectionId()53 QuicConnectionId CreateFakeOriginalDestinationConnectionId() {
54 return TestConnectionId(0x1337);
55 }
56
CreateFakeInitialSourceConnectionId()57 QuicConnectionId CreateFakeInitialSourceConnectionId() {
58 return TestConnectionId(0x2345);
59 }
60
CreateFakeRetrySourceConnectionId()61 QuicConnectionId CreateFakeRetrySourceConnectionId() {
62 return TestConnectionId(0x9876);
63 }
64
CreateFakePreferredConnectionId()65 QuicConnectionId CreateFakePreferredConnectionId() {
66 return TestConnectionId(0xBEEF);
67 }
68
CreateFakePreferredStatelessResetToken()69 std::vector<uint8_t> CreateFakePreferredStatelessResetToken() {
70 return std::vector<uint8_t>(
71 kFakePreferredStatelessResetTokenData,
72 kFakePreferredStatelessResetTokenData +
73 sizeof(kFakePreferredStatelessResetTokenData));
74 }
75
CreateFakeV4SocketAddress()76 QuicSocketAddress CreateFakeV4SocketAddress() {
77 QuicIpAddress ipv4_address;
78 if (!ipv4_address.FromString("65.66.67.68")) { // 0x41, 0x42, 0x43, 0x44
79 QUIC_LOG(FATAL) << "Failed to create IPv4 address";
80 return QuicSocketAddress();
81 }
82 return QuicSocketAddress(ipv4_address, 0x4884);
83 }
84
CreateFakeV6SocketAddress()85 QuicSocketAddress CreateFakeV6SocketAddress() {
86 QuicIpAddress ipv6_address;
87 if (!ipv6_address.FromString("6061:6263:6465:6667:6869:6A6B:6C6D:6E6F")) {
88 QUIC_LOG(FATAL) << "Failed to create IPv6 address";
89 return QuicSocketAddress();
90 }
91 return QuicSocketAddress(ipv6_address, 0x6336);
92 }
93
94 std::unique_ptr<TransportParameters::PreferredAddress>
CreateFakePreferredAddress()95 CreateFakePreferredAddress() {
96 TransportParameters::PreferredAddress preferred_address;
97 preferred_address.ipv4_socket_address = CreateFakeV4SocketAddress();
98 preferred_address.ipv6_socket_address = CreateFakeV6SocketAddress();
99 preferred_address.connection_id = CreateFakePreferredConnectionId();
100 preferred_address.stateless_reset_token =
101 CreateFakePreferredStatelessResetToken();
102 return std::make_unique<TransportParameters::PreferredAddress>(
103 preferred_address);
104 }
105
106 TransportParameters::LegacyVersionInformation
CreateFakeLegacyVersionInformationClient()107 CreateFakeLegacyVersionInformationClient() {
108 TransportParameters::LegacyVersionInformation legacy_version_information;
109 legacy_version_information.version = kFakeVersionLabel;
110 return legacy_version_information;
111 }
112
113 TransportParameters::LegacyVersionInformation
CreateFakeLegacyVersionInformationServer()114 CreateFakeLegacyVersionInformationServer() {
115 TransportParameters::LegacyVersionInformation legacy_version_information =
116 CreateFakeLegacyVersionInformationClient();
117 legacy_version_information.supported_versions.push_back(kFakeVersionLabel);
118 legacy_version_information.supported_versions.push_back(kFakeVersionLabel2);
119 return legacy_version_information;
120 }
121
CreateFakeVersionInformation()122 TransportParameters::VersionInformation CreateFakeVersionInformation() {
123 TransportParameters::VersionInformation version_information;
124 version_information.chosen_version = kFakeVersionLabel;
125 version_information.other_versions.push_back(kFakeVersionLabel);
126 version_information.other_versions.push_back(kFakeVersionLabel2);
127 return version_information;
128 }
129
CreateFakeGoogleConnectionOptions()130 QuicTagVector CreateFakeGoogleConnectionOptions() {
131 return {kALPN, MakeQuicTag('E', 'F', 'G', 0x00),
132 MakeQuicTag('H', 'I', 'J', 0xff)};
133 }
134
RemoveGreaseParameters(TransportParameters * params)135 void RemoveGreaseParameters(TransportParameters* params) {
136 std::vector<TransportParameters::TransportParameterId> grease_params;
137 for (const auto& kv : params->custom_parameters) {
138 if (kv.first % 31 == 27) {
139 grease_params.push_back(kv.first);
140 }
141 }
142 EXPECT_EQ(grease_params.size(), 1u);
143 for (TransportParameters::TransportParameterId param_id : grease_params) {
144 params->custom_parameters.erase(param_id);
145 }
146 // Remove all GREASE versions from version_information.other_versions.
147 if (params->version_information.has_value()) {
148 QuicVersionLabelVector& other_versions =
149 params->version_information.value().other_versions;
150 for (auto it = other_versions.begin(); it != other_versions.end();) {
151 if ((*it & 0x0f0f0f0f) == 0x0a0a0a0a) {
152 it = other_versions.erase(it);
153 } else {
154 ++it;
155 }
156 }
157 }
158 }
159
160 } // namespace
161
162 class TransportParametersTest : public QuicTestWithParam<ParsedQuicVersion> {
163 protected:
TransportParametersTest()164 TransportParametersTest() : version_(GetParam()) {}
165
166 ParsedQuicVersion version_;
167 };
168
169 INSTANTIATE_TEST_SUITE_P(TransportParametersTests, TransportParametersTest,
170 ::testing::ValuesIn(AllSupportedVersionsWithTls()),
171 ::testing::PrintToStringParamName());
172
TEST_P(TransportParametersTest,Comparator)173 TEST_P(TransportParametersTest, Comparator) {
174 TransportParameters orig_params;
175 TransportParameters new_params;
176 // Test comparison on primitive members.
177 orig_params.perspective = Perspective::IS_CLIENT;
178 new_params.perspective = Perspective::IS_SERVER;
179 EXPECT_NE(orig_params, new_params);
180 EXPECT_FALSE(orig_params == new_params);
181 EXPECT_TRUE(orig_params != new_params);
182 new_params.perspective = Perspective::IS_CLIENT;
183 orig_params.legacy_version_information =
184 CreateFakeLegacyVersionInformationClient();
185 new_params.legacy_version_information =
186 CreateFakeLegacyVersionInformationClient();
187 orig_params.version_information = CreateFakeVersionInformation();
188 new_params.version_information = CreateFakeVersionInformation();
189 orig_params.disable_active_migration = true;
190 new_params.disable_active_migration = true;
191 EXPECT_EQ(orig_params, new_params);
192 EXPECT_TRUE(orig_params == new_params);
193 EXPECT_FALSE(orig_params != new_params);
194
195 // Test comparison on vectors.
196 orig_params.legacy_version_information.value().supported_versions.push_back(
197 kFakeVersionLabel);
198 new_params.legacy_version_information.value().supported_versions.push_back(
199 kFakeVersionLabel2);
200 EXPECT_NE(orig_params, new_params);
201 EXPECT_FALSE(orig_params == new_params);
202 EXPECT_TRUE(orig_params != new_params);
203 new_params.legacy_version_information.value().supported_versions.pop_back();
204 new_params.legacy_version_information.value().supported_versions.push_back(
205 kFakeVersionLabel);
206 orig_params.stateless_reset_token = CreateStatelessResetTokenForTest();
207 new_params.stateless_reset_token = CreateStatelessResetTokenForTest();
208 EXPECT_EQ(orig_params, new_params);
209 EXPECT_TRUE(orig_params == new_params);
210 EXPECT_FALSE(orig_params != new_params);
211
212 // Test comparison on IntegerParameters.
213 orig_params.max_udp_payload_size.set_value(kMaxPacketSizeForTest);
214 new_params.max_udp_payload_size.set_value(kMaxPacketSizeForTest + 1);
215 EXPECT_NE(orig_params, new_params);
216 EXPECT_FALSE(orig_params == new_params);
217 EXPECT_TRUE(orig_params != new_params);
218 new_params.max_udp_payload_size.set_value(kMaxPacketSizeForTest);
219 EXPECT_EQ(orig_params, new_params);
220 EXPECT_TRUE(orig_params == new_params);
221 EXPECT_FALSE(orig_params != new_params);
222
223 // Test comparison on PreferredAddress
224 orig_params.preferred_address = CreateFakePreferredAddress();
225 EXPECT_NE(orig_params, new_params);
226 EXPECT_FALSE(orig_params == new_params);
227 EXPECT_TRUE(orig_params != new_params);
228 new_params.preferred_address = CreateFakePreferredAddress();
229 EXPECT_EQ(orig_params, new_params);
230 EXPECT_TRUE(orig_params == new_params);
231 EXPECT_FALSE(orig_params != new_params);
232
233 // Test comparison on CustomMap
234 orig_params.custom_parameters[kCustomParameter1] = kCustomParameter1Value;
235 orig_params.custom_parameters[kCustomParameter2] = kCustomParameter2Value;
236
237 new_params.custom_parameters[kCustomParameter2] = kCustomParameter2Value;
238 new_params.custom_parameters[kCustomParameter1] = kCustomParameter1Value;
239 EXPECT_EQ(orig_params, new_params);
240 EXPECT_TRUE(orig_params == new_params);
241 EXPECT_FALSE(orig_params != new_params);
242
243 // Test comparison on connection IDs.
244 orig_params.initial_source_connection_id =
245 CreateFakeInitialSourceConnectionId();
246 new_params.initial_source_connection_id = std::nullopt;
247 EXPECT_NE(orig_params, new_params);
248 EXPECT_FALSE(orig_params == new_params);
249 EXPECT_TRUE(orig_params != new_params);
250 new_params.initial_source_connection_id = TestConnectionId(0xbadbad);
251 EXPECT_NE(orig_params, new_params);
252 EXPECT_FALSE(orig_params == new_params);
253 EXPECT_TRUE(orig_params != new_params);
254 new_params.initial_source_connection_id =
255 CreateFakeInitialSourceConnectionId();
256 EXPECT_EQ(orig_params, new_params);
257 EXPECT_TRUE(orig_params == new_params);
258 EXPECT_FALSE(orig_params != new_params);
259 }
260
TEST_P(TransportParametersTest,CopyConstructor)261 TEST_P(TransportParametersTest, CopyConstructor) {
262 TransportParameters orig_params;
263 orig_params.perspective = Perspective::IS_CLIENT;
264 orig_params.legacy_version_information =
265 CreateFakeLegacyVersionInformationClient();
266 orig_params.version_information = CreateFakeVersionInformation();
267 orig_params.original_destination_connection_id =
268 CreateFakeOriginalDestinationConnectionId();
269 orig_params.max_idle_timeout_ms.set_value(kFakeIdleTimeoutMilliseconds);
270 orig_params.stateless_reset_token = CreateStatelessResetTokenForTest();
271 orig_params.max_udp_payload_size.set_value(kMaxPacketSizeForTest);
272 orig_params.initial_max_data.set_value(kFakeInitialMaxData);
273 orig_params.initial_max_stream_data_bidi_local.set_value(
274 kFakeInitialMaxStreamDataBidiLocal);
275 orig_params.initial_max_stream_data_bidi_remote.set_value(
276 kFakeInitialMaxStreamDataBidiRemote);
277 orig_params.initial_max_stream_data_uni.set_value(
278 kFakeInitialMaxStreamDataUni);
279 orig_params.initial_max_streams_bidi.set_value(kFakeInitialMaxStreamsBidi);
280 orig_params.initial_max_streams_uni.set_value(kFakeInitialMaxStreamsUni);
281 orig_params.ack_delay_exponent.set_value(kAckDelayExponentForTest);
282 orig_params.max_ack_delay.set_value(kMaxAckDelayForTest);
283 orig_params.min_ack_delay_us.set_value(kMinAckDelayUsForTest);
284 orig_params.disable_active_migration = kFakeDisableMigration;
285 orig_params.preferred_address = CreateFakePreferredAddress();
286 orig_params.active_connection_id_limit.set_value(
287 kActiveConnectionIdLimitForTest);
288 orig_params.initial_source_connection_id =
289 CreateFakeInitialSourceConnectionId();
290 orig_params.retry_source_connection_id = CreateFakeRetrySourceConnectionId();
291 orig_params.initial_round_trip_time_us.set_value(kFakeInitialRoundTripTime);
292 std::string google_handshake_message;
293 ASSERT_TRUE(absl::HexStringToBytes(kFakeGoogleHandshakeMessage,
294 &google_handshake_message));
295 orig_params.google_handshake_message = std::move(google_handshake_message);
296 orig_params.google_connection_options = CreateFakeGoogleConnectionOptions();
297 orig_params.custom_parameters[kCustomParameter1] = kCustomParameter1Value;
298 orig_params.custom_parameters[kCustomParameter2] = kCustomParameter2Value;
299
300 TransportParameters new_params(orig_params);
301 EXPECT_EQ(new_params, orig_params);
302 }
303
TEST_P(TransportParametersTest,RoundTripClient)304 TEST_P(TransportParametersTest, RoundTripClient) {
305 TransportParameters orig_params;
306 orig_params.perspective = Perspective::IS_CLIENT;
307 orig_params.legacy_version_information =
308 CreateFakeLegacyVersionInformationClient();
309 orig_params.version_information = CreateFakeVersionInformation();
310 orig_params.max_idle_timeout_ms.set_value(kFakeIdleTimeoutMilliseconds);
311 orig_params.max_udp_payload_size.set_value(kMaxPacketSizeForTest);
312 orig_params.initial_max_data.set_value(kFakeInitialMaxData);
313 orig_params.initial_max_stream_data_bidi_local.set_value(
314 kFakeInitialMaxStreamDataBidiLocal);
315 orig_params.initial_max_stream_data_bidi_remote.set_value(
316 kFakeInitialMaxStreamDataBidiRemote);
317 orig_params.initial_max_stream_data_uni.set_value(
318 kFakeInitialMaxStreamDataUni);
319 orig_params.initial_max_streams_bidi.set_value(kFakeInitialMaxStreamsBidi);
320 orig_params.initial_max_streams_uni.set_value(kFakeInitialMaxStreamsUni);
321 orig_params.ack_delay_exponent.set_value(kAckDelayExponentForTest);
322 orig_params.max_ack_delay.set_value(kMaxAckDelayForTest);
323 orig_params.min_ack_delay_us.set_value(kMinAckDelayUsForTest);
324 orig_params.disable_active_migration = kFakeDisableMigration;
325 orig_params.active_connection_id_limit.set_value(
326 kActiveConnectionIdLimitForTest);
327 orig_params.initial_source_connection_id =
328 CreateFakeInitialSourceConnectionId();
329 orig_params.initial_round_trip_time_us.set_value(kFakeInitialRoundTripTime);
330 std::string google_handshake_message;
331 ASSERT_TRUE(absl::HexStringToBytes(kFakeGoogleHandshakeMessage,
332 &google_handshake_message));
333 orig_params.google_handshake_message = std::move(google_handshake_message);
334 orig_params.google_connection_options = CreateFakeGoogleConnectionOptions();
335 orig_params.custom_parameters[kCustomParameter1] = kCustomParameter1Value;
336 orig_params.custom_parameters[kCustomParameter2] = kCustomParameter2Value;
337
338 std::vector<uint8_t> serialized;
339 ASSERT_TRUE(SerializeTransportParameters(orig_params, &serialized));
340
341 TransportParameters new_params;
342 std::string error_details;
343 ASSERT_TRUE(ParseTransportParameters(version_, Perspective::IS_CLIENT,
344 serialized.data(), serialized.size(),
345 &new_params, &error_details))
346 << error_details;
347 EXPECT_TRUE(error_details.empty());
348 RemoveGreaseParameters(&new_params);
349 EXPECT_EQ(new_params, orig_params);
350 }
351
TEST_P(TransportParametersTest,RoundTripServer)352 TEST_P(TransportParametersTest, RoundTripServer) {
353 TransportParameters orig_params;
354 orig_params.perspective = Perspective::IS_SERVER;
355 orig_params.legacy_version_information =
356 CreateFakeLegacyVersionInformationServer();
357 orig_params.version_information = CreateFakeVersionInformation();
358 orig_params.original_destination_connection_id =
359 CreateFakeOriginalDestinationConnectionId();
360 orig_params.max_idle_timeout_ms.set_value(kFakeIdleTimeoutMilliseconds);
361 orig_params.stateless_reset_token = CreateStatelessResetTokenForTest();
362 orig_params.max_udp_payload_size.set_value(kMaxPacketSizeForTest);
363 orig_params.initial_max_data.set_value(kFakeInitialMaxData);
364 orig_params.initial_max_stream_data_bidi_local.set_value(
365 kFakeInitialMaxStreamDataBidiLocal);
366 orig_params.initial_max_stream_data_bidi_remote.set_value(
367 kFakeInitialMaxStreamDataBidiRemote);
368 orig_params.initial_max_stream_data_uni.set_value(
369 kFakeInitialMaxStreamDataUni);
370 orig_params.initial_max_streams_bidi.set_value(kFakeInitialMaxStreamsBidi);
371 orig_params.initial_max_streams_uni.set_value(kFakeInitialMaxStreamsUni);
372 orig_params.ack_delay_exponent.set_value(kAckDelayExponentForTest);
373 orig_params.max_ack_delay.set_value(kMaxAckDelayForTest);
374 orig_params.min_ack_delay_us.set_value(kMinAckDelayUsForTest);
375 orig_params.disable_active_migration = kFakeDisableMigration;
376 orig_params.preferred_address = CreateFakePreferredAddress();
377 orig_params.active_connection_id_limit.set_value(
378 kActiveConnectionIdLimitForTest);
379 orig_params.initial_source_connection_id =
380 CreateFakeInitialSourceConnectionId();
381 orig_params.retry_source_connection_id = CreateFakeRetrySourceConnectionId();
382 orig_params.google_connection_options = CreateFakeGoogleConnectionOptions();
383
384 std::vector<uint8_t> serialized;
385 ASSERT_TRUE(SerializeTransportParameters(orig_params, &serialized));
386
387 TransportParameters new_params;
388 std::string error_details;
389 ASSERT_TRUE(ParseTransportParameters(version_, Perspective::IS_SERVER,
390 serialized.data(), serialized.size(),
391 &new_params, &error_details))
392 << error_details;
393 EXPECT_TRUE(error_details.empty());
394 RemoveGreaseParameters(&new_params);
395 EXPECT_EQ(new_params, orig_params);
396 }
397
TEST_P(TransportParametersTest,AreValid)398 TEST_P(TransportParametersTest, AreValid) {
399 {
400 TransportParameters params;
401 std::string error_details;
402 params.perspective = Perspective::IS_CLIENT;
403 EXPECT_TRUE(params.AreValid(&error_details));
404 EXPECT_TRUE(error_details.empty());
405 }
406 {
407 TransportParameters params;
408 std::string error_details;
409 params.perspective = Perspective::IS_CLIENT;
410 EXPECT_TRUE(params.AreValid(&error_details));
411 EXPECT_TRUE(error_details.empty());
412 params.max_idle_timeout_ms.set_value(kFakeIdleTimeoutMilliseconds);
413 EXPECT_TRUE(params.AreValid(&error_details));
414 EXPECT_TRUE(error_details.empty());
415 params.max_idle_timeout_ms.set_value(601000);
416 EXPECT_TRUE(params.AreValid(&error_details));
417 EXPECT_TRUE(error_details.empty());
418 }
419 {
420 TransportParameters params;
421 std::string error_details;
422 params.perspective = Perspective::IS_CLIENT;
423 EXPECT_TRUE(params.AreValid(&error_details));
424 EXPECT_TRUE(error_details.empty());
425 params.max_udp_payload_size.set_value(1200);
426 EXPECT_TRUE(params.AreValid(&error_details));
427 EXPECT_TRUE(error_details.empty());
428 params.max_udp_payload_size.set_value(65535);
429 EXPECT_TRUE(params.AreValid(&error_details));
430 EXPECT_TRUE(error_details.empty());
431 params.max_udp_payload_size.set_value(9999999);
432 EXPECT_TRUE(params.AreValid(&error_details));
433 EXPECT_TRUE(error_details.empty());
434 params.max_udp_payload_size.set_value(0);
435 error_details = "";
436 EXPECT_FALSE(params.AreValid(&error_details));
437 EXPECT_EQ(error_details,
438 "Invalid transport parameters [Client max_udp_payload_size 0 "
439 "(Invalid)]");
440 params.max_udp_payload_size.set_value(1199);
441 error_details = "";
442 EXPECT_FALSE(params.AreValid(&error_details));
443 EXPECT_EQ(error_details,
444 "Invalid transport parameters [Client max_udp_payload_size 1199 "
445 "(Invalid)]");
446 }
447 {
448 TransportParameters params;
449 std::string error_details;
450 params.perspective = Perspective::IS_CLIENT;
451 EXPECT_TRUE(params.AreValid(&error_details));
452 EXPECT_TRUE(error_details.empty());
453 params.ack_delay_exponent.set_value(0);
454 EXPECT_TRUE(params.AreValid(&error_details));
455 EXPECT_TRUE(error_details.empty());
456 params.ack_delay_exponent.set_value(20);
457 EXPECT_TRUE(params.AreValid(&error_details));
458 EXPECT_TRUE(error_details.empty());
459 params.ack_delay_exponent.set_value(21);
460 EXPECT_FALSE(params.AreValid(&error_details));
461 EXPECT_EQ(error_details,
462 "Invalid transport parameters [Client ack_delay_exponent 21 "
463 "(Invalid)]");
464 }
465 {
466 TransportParameters params;
467 std::string error_details;
468 params.perspective = Perspective::IS_CLIENT;
469 EXPECT_TRUE(params.AreValid(&error_details));
470 EXPECT_TRUE(error_details.empty());
471 params.active_connection_id_limit.set_value(2);
472 EXPECT_TRUE(params.AreValid(&error_details));
473 EXPECT_TRUE(error_details.empty());
474 params.active_connection_id_limit.set_value(999999);
475 EXPECT_TRUE(params.AreValid(&error_details));
476 EXPECT_TRUE(error_details.empty());
477 params.active_connection_id_limit.set_value(1);
478 EXPECT_FALSE(params.AreValid(&error_details));
479 EXPECT_EQ(error_details,
480 "Invalid transport parameters [Client active_connection_id_limit"
481 " 1 (Invalid)]");
482 params.active_connection_id_limit.set_value(0);
483 EXPECT_FALSE(params.AreValid(&error_details));
484 EXPECT_EQ(error_details,
485 "Invalid transport parameters [Client active_connection_id_limit"
486 " 0 (Invalid)]");
487 }
488 }
489
TEST_P(TransportParametersTest,NoClientParamsWithStatelessResetToken)490 TEST_P(TransportParametersTest, NoClientParamsWithStatelessResetToken) {
491 TransportParameters orig_params;
492 orig_params.perspective = Perspective::IS_CLIENT;
493 orig_params.legacy_version_information =
494 CreateFakeLegacyVersionInformationClient();
495 orig_params.max_idle_timeout_ms.set_value(kFakeIdleTimeoutMilliseconds);
496 orig_params.stateless_reset_token = CreateStatelessResetTokenForTest();
497 orig_params.max_udp_payload_size.set_value(kMaxPacketSizeForTest);
498
499 std::vector<uint8_t> out;
500 EXPECT_QUIC_BUG(
501 EXPECT_FALSE(SerializeTransportParameters(orig_params, &out)),
502 "Not serializing invalid transport parameters: Client cannot send "
503 "stateless reset token");
504 }
505
TEST_P(TransportParametersTest,ParseClientParams)506 TEST_P(TransportParametersTest, ParseClientParams) {
507 // clang-format off
508 const uint8_t kClientParams[] = {
509 // max_idle_timeout
510 0x01, // parameter id
511 0x02, // length
512 0x6e, 0xec, // value
513 // max_udp_payload_size
514 0x03, // parameter id
515 0x02, // length
516 0x63, 0x29, // value
517 // initial_max_data
518 0x04, // parameter id
519 0x02, // length
520 0x40, 0x65, // value
521 // initial_max_stream_data_bidi_local
522 0x05, // parameter id
523 0x02, // length
524 0x47, 0xD1, // value
525 // initial_max_stream_data_bidi_remote
526 0x06, // parameter id
527 0x02, // length
528 0x47, 0xD2, // value
529 // initial_max_stream_data_uni
530 0x07, // parameter id
531 0x02, // length
532 0x4B, 0xB8, // value
533 // initial_max_streams_bidi
534 0x08, // parameter id
535 0x01, // length
536 0x15, // value
537 // initial_max_streams_uni
538 0x09, // parameter id
539 0x01, // length
540 0x16, // value
541 // ack_delay_exponent
542 0x0a, // parameter id
543 0x01, // length
544 0x0a, // value
545 // max_ack_delay
546 0x0b, // parameter id
547 0x01, // length
548 0x33, // value
549 // min_ack_delay_us
550 0x80, 0x00, 0xde, 0x1a, // parameter id
551 0x02, // length
552 0x43, 0xe8, // value
553 // disable_active_migration
554 0x0c, // parameter id
555 0x00, // length
556 // active_connection_id_limit
557 0x0e, // parameter id
558 0x01, // length
559 0x34, // value
560 // initial_source_connection_id
561 0x0f, // parameter id
562 0x08, // length
563 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23, 0x45,
564 // google_handshake_message
565 0x66, 0xab, // parameter id
566 0x24, // length
567 0x01, 0x00, 0x01, 0x06, 0x03, 0x03, 0x92, 0x65, 0x5f, 0x52, 0x30, 0x27,
568 0x0d, 0x49, 0x64, 0xa4, 0xf9, 0x9b, 0x15, 0xbb, 0xad, 0x22, 0x07, 0x36,
569 0xd9, 0x72, 0xae, 0xa9, 0x7b, 0xf9, 0xac, 0x49, 0x4e, 0xad, 0x62, 0xe6,
570 // initial_round_trip_time_us
571 0x71, 0x27, // parameter id
572 0x01, // length
573 0x35, // value
574 // google_connection_options
575 0x71, 0x28, // parameter id
576 0x0c, // length
577 'A', 'L', 'P', 'N', // value
578 'E', 'F', 'G', 0x00,
579 'H', 'I', 'J', 0xff,
580 // Google version extension
581 0x80, 0x00, 0x47, 0x52, // parameter id
582 0x04, // length
583 0x01, 0x23, 0x45, 0x67, // initial version
584 // version_information
585 0x80, 0xFF, 0x73, 0xDB, // parameter id
586 0x0C, // length
587 0x01, 0x23, 0x45, 0x67, // chosen version
588 0x01, 0x23, 0x45, 0x67, // other version 1
589 0x89, 0xab, 0xcd, 0xef, // other version 2
590 };
591 // clang-format on
592 const uint8_t* client_params =
593 reinterpret_cast<const uint8_t*>(kClientParams);
594 size_t client_params_length = ABSL_ARRAYSIZE(kClientParams);
595 TransportParameters new_params;
596 std::string error_details;
597 ASSERT_TRUE(ParseTransportParameters(version_, Perspective::IS_CLIENT,
598 client_params, client_params_length,
599 &new_params, &error_details))
600 << error_details;
601 EXPECT_TRUE(error_details.empty());
602 EXPECT_EQ(Perspective::IS_CLIENT, new_params.perspective);
603 ASSERT_TRUE(new_params.legacy_version_information.has_value());
604 EXPECT_EQ(kFakeVersionLabel,
605 new_params.legacy_version_information.value().version);
606 EXPECT_TRUE(
607 new_params.legacy_version_information.value().supported_versions.empty());
608 ASSERT_TRUE(new_params.version_information.has_value());
609 EXPECT_EQ(new_params.version_information.value(),
610 CreateFakeVersionInformation());
611 EXPECT_FALSE(new_params.original_destination_connection_id.has_value());
612 EXPECT_EQ(kFakeIdleTimeoutMilliseconds,
613 new_params.max_idle_timeout_ms.value());
614 EXPECT_TRUE(new_params.stateless_reset_token.empty());
615 EXPECT_EQ(kMaxPacketSizeForTest, new_params.max_udp_payload_size.value());
616 EXPECT_EQ(kFakeInitialMaxData, new_params.initial_max_data.value());
617 EXPECT_EQ(kFakeInitialMaxStreamDataBidiLocal,
618 new_params.initial_max_stream_data_bidi_local.value());
619 EXPECT_EQ(kFakeInitialMaxStreamDataBidiRemote,
620 new_params.initial_max_stream_data_bidi_remote.value());
621 EXPECT_EQ(kFakeInitialMaxStreamDataUni,
622 new_params.initial_max_stream_data_uni.value());
623 EXPECT_EQ(kFakeInitialMaxStreamsBidi,
624 new_params.initial_max_streams_bidi.value());
625 EXPECT_EQ(kFakeInitialMaxStreamsUni,
626 new_params.initial_max_streams_uni.value());
627 EXPECT_EQ(kAckDelayExponentForTest, new_params.ack_delay_exponent.value());
628 EXPECT_EQ(kMaxAckDelayForTest, new_params.max_ack_delay.value());
629 EXPECT_EQ(kMinAckDelayUsForTest, new_params.min_ack_delay_us.value());
630 EXPECT_EQ(kFakeDisableMigration, new_params.disable_active_migration);
631 EXPECT_EQ(kActiveConnectionIdLimitForTest,
632 new_params.active_connection_id_limit.value());
633 ASSERT_TRUE(new_params.initial_source_connection_id.has_value());
634 EXPECT_EQ(CreateFakeInitialSourceConnectionId(),
635 new_params.initial_source_connection_id.value());
636 EXPECT_FALSE(new_params.retry_source_connection_id.has_value());
637 EXPECT_EQ(kFakeInitialRoundTripTime,
638 new_params.initial_round_trip_time_us.value());
639 ASSERT_TRUE(new_params.google_connection_options.has_value());
640 EXPECT_EQ(CreateFakeGoogleConnectionOptions(),
641 new_params.google_connection_options.value());
642 std::string expected_google_handshake_message;
643 ASSERT_TRUE(absl::HexStringToBytes(kFakeGoogleHandshakeMessage,
644 &expected_google_handshake_message));
645 EXPECT_EQ(expected_google_handshake_message,
646 new_params.google_handshake_message);
647 }
648
TEST_P(TransportParametersTest,ParseClientParamsFailsWithFullStatelessResetToken)649 TEST_P(TransportParametersTest,
650 ParseClientParamsFailsWithFullStatelessResetToken) {
651 // clang-format off
652 const uint8_t kClientParamsWithFullToken[] = {
653 // max_idle_timeout
654 0x01, // parameter id
655 0x02, // length
656 0x6e, 0xec, // value
657 // stateless_reset_token
658 0x02, // parameter id
659 0x10, // length
660 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
661 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F,
662 // max_udp_payload_size
663 0x03, // parameter id
664 0x02, // length
665 0x63, 0x29, // value
666 // initial_max_data
667 0x04, // parameter id
668 0x02, // length
669 0x40, 0x65, // value
670 };
671 // clang-format on
672 const uint8_t* client_params =
673 reinterpret_cast<const uint8_t*>(kClientParamsWithFullToken);
674 size_t client_params_length = ABSL_ARRAYSIZE(kClientParamsWithFullToken);
675 TransportParameters out_params;
676 std::string error_details;
677 EXPECT_FALSE(ParseTransportParameters(version_, Perspective::IS_CLIENT,
678 client_params, client_params_length,
679 &out_params, &error_details));
680 EXPECT_EQ(error_details, "Client cannot send stateless reset token");
681 }
682
TEST_P(TransportParametersTest,ParseClientParamsFailsWithEmptyStatelessResetToken)683 TEST_P(TransportParametersTest,
684 ParseClientParamsFailsWithEmptyStatelessResetToken) {
685 // clang-format off
686 const uint8_t kClientParamsWithEmptyToken[] = {
687 // max_idle_timeout
688 0x01, // parameter id
689 0x02, // length
690 0x6e, 0xec, // value
691 // stateless_reset_token
692 0x02, // parameter id
693 0x00, // length
694 // max_udp_payload_size
695 0x03, // parameter id
696 0x02, // length
697 0x63, 0x29, // value
698 // initial_max_data
699 0x04, // parameter id
700 0x02, // length
701 0x40, 0x65, // value
702 };
703 // clang-format on
704 const uint8_t* client_params =
705 reinterpret_cast<const uint8_t*>(kClientParamsWithEmptyToken);
706 size_t client_params_length = ABSL_ARRAYSIZE(kClientParamsWithEmptyToken);
707 TransportParameters out_params;
708 std::string error_details;
709 EXPECT_FALSE(ParseTransportParameters(version_, Perspective::IS_CLIENT,
710 client_params, client_params_length,
711 &out_params, &error_details));
712 EXPECT_EQ(error_details,
713 "Received stateless_reset_token of invalid length 0");
714 }
715
TEST_P(TransportParametersTest,ParseClientParametersRepeated)716 TEST_P(TransportParametersTest, ParseClientParametersRepeated) {
717 // clang-format off
718 const uint8_t kClientParamsRepeated[] = {
719 // max_idle_timeout
720 0x01, // parameter id
721 0x02, // length
722 0x6e, 0xec, // value
723 // max_udp_payload_size
724 0x03, // parameter id
725 0x02, // length
726 0x63, 0x29, // value
727 // max_idle_timeout (repeated)
728 0x01, // parameter id
729 0x02, // length
730 0x6e, 0xec, // value
731 };
732 // clang-format on
733 const uint8_t* client_params =
734 reinterpret_cast<const uint8_t*>(kClientParamsRepeated);
735 size_t client_params_length = ABSL_ARRAYSIZE(kClientParamsRepeated);
736 TransportParameters out_params;
737 std::string error_details;
738 EXPECT_FALSE(ParseTransportParameters(version_, Perspective::IS_CLIENT,
739 client_params, client_params_length,
740 &out_params, &error_details));
741 EXPECT_EQ(error_details, "Received a second max_idle_timeout");
742 }
743
TEST_P(TransportParametersTest,ParseServerParams)744 TEST_P(TransportParametersTest, ParseServerParams) {
745 // clang-format off
746 const uint8_t kServerParams[] = {
747 // original_destination_connection_id
748 0x00, // parameter id
749 0x08, // length
750 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0x37,
751 // max_idle_timeout
752 0x01, // parameter id
753 0x02, // length
754 0x6e, 0xec, // value
755 // stateless_reset_token
756 0x02, // parameter id
757 0x10, // length
758 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
759 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F,
760 // max_udp_payload_size
761 0x03, // parameter id
762 0x02, // length
763 0x63, 0x29, // value
764 // initial_max_data
765 0x04, // parameter id
766 0x02, // length
767 0x40, 0x65, // value
768 // initial_max_stream_data_bidi_local
769 0x05, // parameter id
770 0x02, // length
771 0x47, 0xD1, // value
772 // initial_max_stream_data_bidi_remote
773 0x06, // parameter id
774 0x02, // length
775 0x47, 0xD2, // value
776 // initial_max_stream_data_uni
777 0x07, // parameter id
778 0x02, // length
779 0x4B, 0xB8, // value
780 // initial_max_streams_bidi
781 0x08, // parameter id
782 0x01, // length
783 0x15, // value
784 // initial_max_streams_uni
785 0x09, // parameter id
786 0x01, // length
787 0x16, // value
788 // ack_delay_exponent
789 0x0a, // parameter id
790 0x01, // length
791 0x0a, // value
792 // max_ack_delay
793 0x0b, // parameter id
794 0x01, // length
795 0x33, // value
796 // min_ack_delay_us
797 0x80, 0x00, 0xde, 0x1a, // parameter id
798 0x02, // length
799 0x43, 0xe8, // value
800 // disable_active_migration
801 0x0c, // parameter id
802 0x00, // length
803 // preferred_address
804 0x0d, // parameter id
805 0x31, // length
806 0x41, 0x42, 0x43, 0x44, // IPv4 address
807 0x48, 0x84, // IPv4 port
808 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, // IPv6 address
809 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
810 0x63, 0x36, // IPv6 port
811 0x08, // connection ID length
812 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xBE, 0xEF, // connection ID
813 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, // stateless reset token
814 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F,
815 // active_connection_id_limit
816 0x0e, // parameter id
817 0x01, // length
818 0x34, // value
819 // initial_source_connection_id
820 0x0f, // parameter id
821 0x08, // length
822 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23, 0x45,
823 // retry_source_connection_id
824 0x10, // parameter id
825 0x08, // length
826 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x98, 0x76,
827 // google_connection_options
828 0x71, 0x28, // parameter id
829 0x0c, // length
830 'A', 'L', 'P', 'N', // value
831 'E', 'F', 'G', 0x00,
832 'H', 'I', 'J', 0xff,
833 // Google version extension
834 0x80, 0x00, 0x47, 0x52, // parameter id
835 0x0d, // length
836 0x01, 0x23, 0x45, 0x67, // negotiated_version
837 0x08, // length of supported versions array
838 0x01, 0x23, 0x45, 0x67,
839 0x89, 0xab, 0xcd, 0xef,
840 // version_information
841 0x80, 0xFF, 0x73, 0xDB, // parameter id
842 0x0C, // length
843 0x01, 0x23, 0x45, 0x67, // chosen version
844 0x01, 0x23, 0x45, 0x67, // other version 1
845 0x89, 0xab, 0xcd, 0xef, // other version 2
846 };
847 // clang-format on
848 const uint8_t* server_params =
849 reinterpret_cast<const uint8_t*>(kServerParams);
850 size_t server_params_length = ABSL_ARRAYSIZE(kServerParams);
851 TransportParameters new_params;
852 std::string error_details;
853 ASSERT_TRUE(ParseTransportParameters(version_, Perspective::IS_SERVER,
854 server_params, server_params_length,
855 &new_params, &error_details))
856 << error_details;
857 EXPECT_TRUE(error_details.empty());
858 EXPECT_EQ(Perspective::IS_SERVER, new_params.perspective);
859 ASSERT_TRUE(new_params.legacy_version_information.has_value());
860 EXPECT_EQ(kFakeVersionLabel,
861 new_params.legacy_version_information.value().version);
862 ASSERT_EQ(
863 2u,
864 new_params.legacy_version_information.value().supported_versions.size());
865 EXPECT_EQ(
866 kFakeVersionLabel,
867 new_params.legacy_version_information.value().supported_versions[0]);
868 EXPECT_EQ(
869 kFakeVersionLabel2,
870 new_params.legacy_version_information.value().supported_versions[1]);
871 ASSERT_TRUE(new_params.version_information.has_value());
872 EXPECT_EQ(new_params.version_information.value(),
873 CreateFakeVersionInformation());
874 ASSERT_TRUE(new_params.original_destination_connection_id.has_value());
875 EXPECT_EQ(CreateFakeOriginalDestinationConnectionId(),
876 new_params.original_destination_connection_id.value());
877 EXPECT_EQ(kFakeIdleTimeoutMilliseconds,
878 new_params.max_idle_timeout_ms.value());
879 EXPECT_EQ(CreateStatelessResetTokenForTest(),
880 new_params.stateless_reset_token);
881 EXPECT_EQ(kMaxPacketSizeForTest, new_params.max_udp_payload_size.value());
882 EXPECT_EQ(kFakeInitialMaxData, new_params.initial_max_data.value());
883 EXPECT_EQ(kFakeInitialMaxStreamDataBidiLocal,
884 new_params.initial_max_stream_data_bidi_local.value());
885 EXPECT_EQ(kFakeInitialMaxStreamDataBidiRemote,
886 new_params.initial_max_stream_data_bidi_remote.value());
887 EXPECT_EQ(kFakeInitialMaxStreamDataUni,
888 new_params.initial_max_stream_data_uni.value());
889 EXPECT_EQ(kFakeInitialMaxStreamsBidi,
890 new_params.initial_max_streams_bidi.value());
891 EXPECT_EQ(kFakeInitialMaxStreamsUni,
892 new_params.initial_max_streams_uni.value());
893 EXPECT_EQ(kAckDelayExponentForTest, new_params.ack_delay_exponent.value());
894 EXPECT_EQ(kMaxAckDelayForTest, new_params.max_ack_delay.value());
895 EXPECT_EQ(kMinAckDelayUsForTest, new_params.min_ack_delay_us.value());
896 EXPECT_EQ(kFakeDisableMigration, new_params.disable_active_migration);
897 ASSERT_NE(nullptr, new_params.preferred_address.get());
898 EXPECT_EQ(CreateFakeV4SocketAddress(),
899 new_params.preferred_address->ipv4_socket_address);
900 EXPECT_EQ(CreateFakeV6SocketAddress(),
901 new_params.preferred_address->ipv6_socket_address);
902 EXPECT_EQ(CreateFakePreferredConnectionId(),
903 new_params.preferred_address->connection_id);
904 EXPECT_EQ(CreateFakePreferredStatelessResetToken(),
905 new_params.preferred_address->stateless_reset_token);
906 EXPECT_EQ(kActiveConnectionIdLimitForTest,
907 new_params.active_connection_id_limit.value());
908 ASSERT_TRUE(new_params.initial_source_connection_id.has_value());
909 EXPECT_EQ(CreateFakeInitialSourceConnectionId(),
910 new_params.initial_source_connection_id.value());
911 ASSERT_TRUE(new_params.retry_source_connection_id.has_value());
912 EXPECT_EQ(CreateFakeRetrySourceConnectionId(),
913 new_params.retry_source_connection_id.value());
914 ASSERT_TRUE(new_params.google_connection_options.has_value());
915 EXPECT_EQ(CreateFakeGoogleConnectionOptions(),
916 new_params.google_connection_options.value());
917 }
918
TEST_P(TransportParametersTest,ParseServerParametersRepeated)919 TEST_P(TransportParametersTest, ParseServerParametersRepeated) {
920 // clang-format off
921 const uint8_t kServerParamsRepeated[] = {
922 // original_destination_connection_id
923 0x00, // parameter id
924 0x08, // length
925 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0x37,
926 // max_idle_timeout
927 0x01, // parameter id
928 0x02, // length
929 0x6e, 0xec, // value
930 // stateless_reset_token
931 0x02, // parameter id
932 0x10, // length
933 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
934 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
935 // max_idle_timeout (repeated)
936 0x01, // parameter id
937 0x02, // length
938 0x6e, 0xec, // value
939 };
940 // clang-format on
941 const uint8_t* server_params =
942 reinterpret_cast<const uint8_t*>(kServerParamsRepeated);
943 size_t server_params_length = ABSL_ARRAYSIZE(kServerParamsRepeated);
944 TransportParameters out_params;
945 std::string error_details;
946 EXPECT_FALSE(ParseTransportParameters(version_, Perspective::IS_SERVER,
947 server_params, server_params_length,
948 &out_params, &error_details));
949 EXPECT_EQ(error_details, "Received a second max_idle_timeout");
950 }
951
TEST_P(TransportParametersTest,ParseServerParametersEmptyOriginalConnectionId)952 TEST_P(TransportParametersTest,
953 ParseServerParametersEmptyOriginalConnectionId) {
954 // clang-format off
955 const uint8_t kServerParamsEmptyOriginalConnectionId[] = {
956 // original_destination_connection_id
957 0x00, // parameter id
958 0x00, // length
959 // max_idle_timeout
960 0x01, // parameter id
961 0x02, // length
962 0x6e, 0xec, // value
963 // stateless_reset_token
964 0x02, // parameter id
965 0x10, // length
966 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
967 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
968 };
969 // clang-format on
970 const uint8_t* server_params =
971 reinterpret_cast<const uint8_t*>(kServerParamsEmptyOriginalConnectionId);
972 size_t server_params_length =
973 ABSL_ARRAYSIZE(kServerParamsEmptyOriginalConnectionId);
974 TransportParameters out_params;
975 std::string error_details;
976 ASSERT_TRUE(ParseTransportParameters(version_, Perspective::IS_SERVER,
977 server_params, server_params_length,
978 &out_params, &error_details))
979 << error_details;
980 ASSERT_TRUE(out_params.original_destination_connection_id.has_value());
981 EXPECT_EQ(out_params.original_destination_connection_id.value(),
982 EmptyQuicConnectionId());
983 }
984
TEST_P(TransportParametersTest,VeryLongCustomParameter)985 TEST_P(TransportParametersTest, VeryLongCustomParameter) {
986 // Ensure we can handle a 70KB custom parameter on both send and receive.
987 std::string custom_value(70000, '?');
988 TransportParameters orig_params;
989 orig_params.perspective = Perspective::IS_CLIENT;
990 orig_params.legacy_version_information =
991 CreateFakeLegacyVersionInformationClient();
992 orig_params.custom_parameters[kCustomParameter1] = custom_value;
993
994 std::vector<uint8_t> serialized;
995 ASSERT_TRUE(SerializeTransportParameters(orig_params, &serialized));
996
997 TransportParameters new_params;
998 std::string error_details;
999 ASSERT_TRUE(ParseTransportParameters(version_, Perspective::IS_CLIENT,
1000 serialized.data(), serialized.size(),
1001 &new_params, &error_details))
1002 << error_details;
1003 EXPECT_TRUE(error_details.empty());
1004 RemoveGreaseParameters(&new_params);
1005 EXPECT_EQ(new_params, orig_params);
1006 }
1007
TEST_P(TransportParametersTest,SerializationOrderIsRandom)1008 TEST_P(TransportParametersTest, SerializationOrderIsRandom) {
1009 TransportParameters orig_params;
1010 orig_params.perspective = Perspective::IS_CLIENT;
1011 orig_params.legacy_version_information =
1012 CreateFakeLegacyVersionInformationClient();
1013 orig_params.max_idle_timeout_ms.set_value(kFakeIdleTimeoutMilliseconds);
1014 orig_params.max_udp_payload_size.set_value(kMaxPacketSizeForTest);
1015 orig_params.initial_max_data.set_value(kFakeInitialMaxData);
1016 orig_params.initial_max_stream_data_bidi_local.set_value(
1017 kFakeInitialMaxStreamDataBidiLocal);
1018 orig_params.initial_max_stream_data_bidi_remote.set_value(
1019 kFakeInitialMaxStreamDataBidiRemote);
1020 orig_params.initial_max_stream_data_uni.set_value(
1021 kFakeInitialMaxStreamDataUni);
1022 orig_params.initial_max_streams_bidi.set_value(kFakeInitialMaxStreamsBidi);
1023 orig_params.initial_max_streams_uni.set_value(kFakeInitialMaxStreamsUni);
1024 orig_params.ack_delay_exponent.set_value(kAckDelayExponentForTest);
1025 orig_params.max_ack_delay.set_value(kMaxAckDelayForTest);
1026 orig_params.min_ack_delay_us.set_value(kMinAckDelayUsForTest);
1027 orig_params.disable_active_migration = kFakeDisableMigration;
1028 orig_params.active_connection_id_limit.set_value(
1029 kActiveConnectionIdLimitForTest);
1030 orig_params.initial_source_connection_id =
1031 CreateFakeInitialSourceConnectionId();
1032 orig_params.initial_round_trip_time_us.set_value(kFakeInitialRoundTripTime);
1033 orig_params.google_connection_options = CreateFakeGoogleConnectionOptions();
1034 orig_params.custom_parameters[kCustomParameter1] = kCustomParameter1Value;
1035 orig_params.custom_parameters[kCustomParameter2] = kCustomParameter2Value;
1036
1037 std::vector<uint8_t> first_serialized;
1038 ASSERT_TRUE(SerializeTransportParameters(orig_params, &first_serialized));
1039 // Test that a subsequent serialization is different from the first.
1040 // Run in a loop to avoid a failure in the unlikely event that randomization
1041 // produces the same result multiple times.
1042 for (int i = 0; i < 1000; i++) {
1043 std::vector<uint8_t> serialized;
1044 ASSERT_TRUE(SerializeTransportParameters(orig_params, &serialized));
1045 if (serialized != first_serialized) {
1046 return;
1047 }
1048 }
1049 }
1050
TEST_P(TransportParametersTest,Degrease)1051 TEST_P(TransportParametersTest, Degrease) {
1052 TransportParameters orig_params;
1053 orig_params.perspective = Perspective::IS_CLIENT;
1054 orig_params.legacy_version_information =
1055 CreateFakeLegacyVersionInformationClient();
1056 orig_params.version_information = CreateFakeVersionInformation();
1057 orig_params.max_idle_timeout_ms.set_value(kFakeIdleTimeoutMilliseconds);
1058 orig_params.max_udp_payload_size.set_value(kMaxPacketSizeForTest);
1059 orig_params.initial_max_data.set_value(kFakeInitialMaxData);
1060 orig_params.initial_max_stream_data_bidi_local.set_value(
1061 kFakeInitialMaxStreamDataBidiLocal);
1062 orig_params.initial_max_stream_data_bidi_remote.set_value(
1063 kFakeInitialMaxStreamDataBidiRemote);
1064 orig_params.initial_max_stream_data_uni.set_value(
1065 kFakeInitialMaxStreamDataUni);
1066 orig_params.initial_max_streams_bidi.set_value(kFakeInitialMaxStreamsBidi);
1067 orig_params.initial_max_streams_uni.set_value(kFakeInitialMaxStreamsUni);
1068 orig_params.ack_delay_exponent.set_value(kAckDelayExponentForTest);
1069 orig_params.max_ack_delay.set_value(kMaxAckDelayForTest);
1070 orig_params.min_ack_delay_us.set_value(kMinAckDelayUsForTest);
1071 orig_params.disable_active_migration = kFakeDisableMigration;
1072 orig_params.active_connection_id_limit.set_value(
1073 kActiveConnectionIdLimitForTest);
1074 orig_params.initial_source_connection_id =
1075 CreateFakeInitialSourceConnectionId();
1076 orig_params.initial_round_trip_time_us.set_value(kFakeInitialRoundTripTime);
1077 std::string google_handshake_message;
1078 ASSERT_TRUE(absl::HexStringToBytes(kFakeGoogleHandshakeMessage,
1079 &google_handshake_message));
1080 orig_params.google_handshake_message = std::move(google_handshake_message);
1081 orig_params.google_connection_options = CreateFakeGoogleConnectionOptions();
1082 orig_params.custom_parameters[kCustomParameter1] = kCustomParameter1Value;
1083 orig_params.custom_parameters[kCustomParameter2] = kCustomParameter2Value;
1084
1085 std::vector<uint8_t> serialized;
1086 ASSERT_TRUE(SerializeTransportParameters(orig_params, &serialized));
1087
1088 TransportParameters new_params;
1089 std::string error_details;
1090 ASSERT_TRUE(ParseTransportParameters(version_, Perspective::IS_CLIENT,
1091 serialized.data(), serialized.size(),
1092 &new_params, &error_details))
1093 << error_details;
1094 EXPECT_TRUE(error_details.empty());
1095
1096 // Deserialized parameters have grease added.
1097 EXPECT_NE(new_params, orig_params);
1098
1099 DegreaseTransportParameters(new_params);
1100 EXPECT_EQ(new_params, orig_params);
1101 }
1102
1103 class TransportParametersTicketSerializationTest : public QuicTest {
1104 protected:
SetUp()1105 void SetUp() override {
1106 original_params_.perspective = Perspective::IS_SERVER;
1107 original_params_.legacy_version_information =
1108 CreateFakeLegacyVersionInformationServer();
1109 original_params_.original_destination_connection_id =
1110 CreateFakeOriginalDestinationConnectionId();
1111 original_params_.max_idle_timeout_ms.set_value(
1112 kFakeIdleTimeoutMilliseconds);
1113 original_params_.stateless_reset_token = CreateStatelessResetTokenForTest();
1114 original_params_.max_udp_payload_size.set_value(kMaxPacketSizeForTest);
1115 original_params_.initial_max_data.set_value(kFakeInitialMaxData);
1116 original_params_.initial_max_stream_data_bidi_local.set_value(
1117 kFakeInitialMaxStreamDataBidiLocal);
1118 original_params_.initial_max_stream_data_bidi_remote.set_value(
1119 kFakeInitialMaxStreamDataBidiRemote);
1120 original_params_.initial_max_stream_data_uni.set_value(
1121 kFakeInitialMaxStreamDataUni);
1122 original_params_.initial_max_streams_bidi.set_value(
1123 kFakeInitialMaxStreamsBidi);
1124 original_params_.initial_max_streams_uni.set_value(
1125 kFakeInitialMaxStreamsUni);
1126 original_params_.ack_delay_exponent.set_value(kAckDelayExponentForTest);
1127 original_params_.max_ack_delay.set_value(kMaxAckDelayForTest);
1128 original_params_.min_ack_delay_us.set_value(kMinAckDelayUsForTest);
1129 original_params_.disable_active_migration = kFakeDisableMigration;
1130 original_params_.preferred_address = CreateFakePreferredAddress();
1131 original_params_.active_connection_id_limit.set_value(
1132 kActiveConnectionIdLimitForTest);
1133 original_params_.initial_source_connection_id =
1134 CreateFakeInitialSourceConnectionId();
1135 original_params_.retry_source_connection_id =
1136 CreateFakeRetrySourceConnectionId();
1137 original_params_.google_connection_options =
1138 CreateFakeGoogleConnectionOptions();
1139
1140 ASSERT_TRUE(SerializeTransportParametersForTicket(
1141 original_params_, application_state_, &original_serialized_params_));
1142 }
1143
1144 TransportParameters original_params_;
1145 std::vector<uint8_t> application_state_ = {0, 1};
1146 std::vector<uint8_t> original_serialized_params_;
1147 };
1148
TEST_F(TransportParametersTicketSerializationTest,StatelessResetTokenDoesntChangeOutput)1149 TEST_F(TransportParametersTicketSerializationTest,
1150 StatelessResetTokenDoesntChangeOutput) {
1151 // Test that changing the stateless reset token doesn't change the ticket
1152 // serialization.
1153 TransportParameters new_params = original_params_;
1154 new_params.stateless_reset_token = CreateFakePreferredStatelessResetToken();
1155 EXPECT_NE(new_params, original_params_);
1156
1157 std::vector<uint8_t> serialized;
1158 ASSERT_TRUE(SerializeTransportParametersForTicket(
1159 new_params, application_state_, &serialized));
1160 EXPECT_EQ(original_serialized_params_, serialized);
1161 }
1162
TEST_F(TransportParametersTicketSerializationTest,ConnectionIDDoesntChangeOutput)1163 TEST_F(TransportParametersTicketSerializationTest,
1164 ConnectionIDDoesntChangeOutput) {
1165 // Changing original destination CID doesn't change serialization.
1166 TransportParameters new_params = original_params_;
1167 new_params.original_destination_connection_id = TestConnectionId(0xCAFE);
1168 EXPECT_NE(new_params, original_params_);
1169
1170 std::vector<uint8_t> serialized;
1171 ASSERT_TRUE(SerializeTransportParametersForTicket(
1172 new_params, application_state_, &serialized));
1173 EXPECT_EQ(original_serialized_params_, serialized);
1174 }
1175
TEST_F(TransportParametersTicketSerializationTest,StreamLimitChangesOutput)1176 TEST_F(TransportParametersTicketSerializationTest, StreamLimitChangesOutput) {
1177 // Changing a stream limit does change the serialization.
1178 TransportParameters new_params = original_params_;
1179 new_params.initial_max_stream_data_bidi_local.set_value(
1180 kFakeInitialMaxStreamDataBidiLocal + 1);
1181 EXPECT_NE(new_params, original_params_);
1182
1183 std::vector<uint8_t> serialized;
1184 ASSERT_TRUE(SerializeTransportParametersForTicket(
1185 new_params, application_state_, &serialized));
1186 EXPECT_NE(original_serialized_params_, serialized);
1187 }
1188
TEST_F(TransportParametersTicketSerializationTest,ApplicationStateChangesOutput)1189 TEST_F(TransportParametersTicketSerializationTest,
1190 ApplicationStateChangesOutput) {
1191 // Changing the application state changes the serialization.
1192 std::vector<uint8_t> new_application_state = {0};
1193 EXPECT_NE(new_application_state, application_state_);
1194
1195 std::vector<uint8_t> serialized;
1196 ASSERT_TRUE(SerializeTransportParametersForTicket(
1197 original_params_, new_application_state, &serialized));
1198 EXPECT_NE(original_serialized_params_, serialized);
1199 }
1200
1201 } // namespace test
1202 } // namespace quic
1203