Debian Codegraph @

third_party/rust/neqo-transport/src/connection/tests/vn.rs

raw
1 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
2 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
3 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
4 // option. This file may not be copied, modified, or distributed
5 // except according to those terms.
6
7 use std::time::Duration;
8
9 use neqo_common::{event::Provider as _, Decoder, Encoder, IpTosDscp};
10 use test_fixture::{assertions, datagram, now};
11
12 use super::{
13 super::{CloseReason, ConnectionEvent, Output, State, ZeroRttState},
14 connect, connect_fail, default_client, default_server, exchange_ticket, new_client, new_server,
15 send_something,
16 };
17 use crate::{
18 packet::PACKET_BIT_LONG,
19 tparams::{TransportParameter, TransportParameterId::*},
20 ConnectionParameters, Error, Stats, Version, MIN_INITIAL_PACKET_SIZE,
21 };
22
23 // The expected PTO duration after the first Initial is sent.
24 const INITIAL_PTO: Duration = Duration::from_millis(300);
25
26 /// # Panics
27 ///
28 /// When the count of received packets doesn't match the count of received packets with the
29 /// (default) DSCP.
30 pub fn assert_dscp(stats: &Stats) {
31 assert_eq!(stats.dscp_rx[IpTosDscp::Cs0], stats.packets_rx);
32 }
33
34 #[test]
35 fn unknown_version() {
36 let mut client = default_client();
37 // Start the handshake.
38 drop(client.process_output(now()).dgram());
39
40 let mut unknown_version_packet = vec![0x80, 0x1a, 0x1a, 0x1a, 0x1a];
41 unknown_version_packet.resize(MIN_INITIAL_PACKET_SIZE, 0x0);
42 drop(client.process(Some(datagram(unknown_version_packet)), now()));
43 assert_eq!(1, client.stats().dropped_rx);
44 assert_dscp(&client.stats());
45 }
46
47 #[test]
48 fn server_receive_unknown_first_packet() {
49 let mut server = default_server();
50
51 let mut unknown_version_packet = vec![0x80, 0x1a, 0x1a, 0x1a, 0x1a];
52 unknown_version_packet.resize(MIN_INITIAL_PACKET_SIZE, 0x0);
53
54 assert_eq!(
55 server.process(Some(datagram(unknown_version_packet)), now()),
56 Output::None
57 );
58
59 assert_eq!(1, server.stats().dropped_rx);
60 assert_dscp(&server.stats());
61 }
62
63 fn create_vn(initial_pkt: &[u8], versions: &[u32]) -> Vec<u8> {
64 let mut dec = Decoder::from(&initial_pkt[5..]); // Skip past version.
65 let dst_cid = dec.decode_vec(1).expect("client DCID");
66 let src_cid = dec.decode_vec(1).expect("client SCID");
67
68 let mut encoder = Encoder::default();
69 encoder.encode_byte(PACKET_BIT_LONG);
70 encoder.encode(&[0; 4]); // Zero version == VN.
71 encoder.encode_vec(1, src_cid);
72 encoder.encode_vec(1, dst_cid);
73
74 for v in versions {
75 encoder.encode_uint(4, *v);
76 }
77 encoder.into()
78 }
79
80 #[test]
81 fn version_negotiation_current_version() {
82 let mut client = default_client();
83 // Start the handshake.
84 let initial_pkt = client
85 .process_output(now())
86 .dgram()
87 .expect("a datagram")
88 .to_vec();
89 _ = client.process_output(now()).dgram().expect("a datagram");
90
91 let vn = create_vn(
92 &initial_pkt,
93 &[0x1a1a_1a1a, Version::default().wire_version()],
94 );
95
96 let dgram = datagram(vn);
97 let mut delay = client.process(Some(dgram), now()).callback();
98 delay += client.process_output(now() + delay).callback(); // TODO: Why is there first a 5ms pacing delay before the PTO?
99 assert_eq!(delay, INITIAL_PTO);
100 assert_eq!(*client.state(), State::WaitInitial);
101 assert_eq!(1, client.stats().dropped_rx);
102 assert_dscp(&client.stats());
103 }
104
105 #[test]
106 fn version_negotiation_version0() {
107 let mut client = default_client();
108 // Start the handshake.
109 let initial_pkt = client
110 .process_output(now())
111 .dgram()
112 .expect("a datagram")
113 .to_vec();
114 _ = client.process_output(now()).dgram().expect("a datagram");
115
116 let vn = create_vn(&initial_pkt, &[0, 0x1a1a_1a1a]);
117
118 let dgram = datagram(vn);
119 let mut delay = client.process(Some(dgram), now()).callback();
120 delay += client.process_output(now() + delay).callback(); // TODO: Why is there first a 5ms pacing delay before the PTO?
121 assert_eq!(delay, INITIAL_PTO);
122 assert_eq!(*client.state(), State::WaitInitial);
123 assert_eq!(1, client.stats().dropped_rx);
124 assert_dscp(&client.stats());
125 }
126
127 #[test]
128 fn version_negotiation_only_reserved() {
129 let mut client = default_client();
130 // Start the handshake.
131 let initial_pkt = client
132 .process_output(now())
133 .dgram()
134 .expect("a datagram")
135 .to_vec();
136
137 let vn = create_vn(&initial_pkt, &[0x1a1a_1a1a, 0x2a2a_2a2a]);
138
139 let dgram = datagram(vn);
140 assert_eq!(client.process(Some(dgram), now()), Output::None);
141 match client.state() {
142 State::Closed(err) => {
143 assert_eq!(*err, CloseReason::Transport(Error::VersionNegotiation));
144 }
145 _ => panic!("Invalid client state"),
146 }
147 assert_dscp(&client.stats());
148 }
149
150 #[test]
151 fn version_negotiation_corrupted() {
152 let mut client = default_client();
153 // Start the handshake.
154 let initial_pkt = client
155 .process_output(now())
156 .dgram()
157 .expect("a datagram")
158 .to_vec();
159 _ = client.process_output(now()).dgram().expect("a datagram");
160
161 let vn = create_vn(&initial_pkt, &[0x1a1a_1a1a, 0x2a2a_2a2a]);
162
163 let dgram = datagram(vn[..vn.len() - 1].to_vec());
164 let mut delay = client.process(Some(dgram), now()).callback();
165 delay += client.process_output(now() + delay).callback(); // TODO: Why is there first a 5ms pacing delay before the PTO?
166 assert_eq!(delay, INITIAL_PTO);
167 assert_eq!(*client.state(), State::WaitInitial);
168 assert_eq!(1, client.stats().dropped_rx);
169 assert_dscp(&client.stats());
170 }
171
172 #[test]
173 fn version_negotiation_empty() {
174 let mut client = default_client();
175 // Start the handshake.
176 let initial_pkt = client
177 .process_output(now())
178 .dgram()
179 .expect("a datagram")
180 .to_vec();
181 _ = client.process_output(now()).dgram().expect("a datagram");
182
183 let vn = create_vn(&initial_pkt, &[]);
184
185 let dgram = datagram(vn);
186 let mut delay = client.process(Some(dgram), now()).callback();
187 delay += client.process_output(now() + delay).callback(); // TODO: Why is there first a 5ms pacing delay before the PTO?
188 assert_eq!(delay, INITIAL_PTO);
189 assert_eq!(*client.state(), State::WaitInitial);
190 assert_eq!(1, client.stats().dropped_rx);
191 assert_dscp(&client.stats());
192 }
193
194 #[test]
195 fn version_negotiation_not_supported() {
196 let mut client = default_client();
197 // Start the handshake.
198 let initial_pkt = client
199 .process_output(now())
200 .dgram()
201 .expect("a datagram")
202 .to_vec();
203
204 let vn = create_vn(&initial_pkt, &[0x1a1a_1a1a, 0x2a2a_2a2a, 0xff00_0001]);
205 let dgram = datagram(vn);
206 assert_eq!(client.process(Some(dgram), now()), Output::None);
207 match client.state() {
208 State::Closed(err) => {
209 assert_eq!(*err, CloseReason::Transport(Error::VersionNegotiation));
210 }
211 _ => panic!("Invalid client state"),
212 }
213 assert_dscp(&client.stats());
214 }
215
216 #[test]
217 fn version_negotiation_bad_cid() {
218 let mut client = default_client();
219 // Start the handshake.
220 let mut initial_pkt = client
221 .process_output(now())
222 .dgram()
223 .expect("a datagram")
224 .to_vec();
225 _ = client.process_output(now()).dgram().expect("a datagram");
226
227 initial_pkt[6] ^= 0xc4;
228 let vn = create_vn(&initial_pkt, &[0x1a1a_1a1a, 0x2a2a_2a2a, 0xff00_0001]);
229
230 let dgram = datagram(vn);
231 let mut delay = client.process(Some(dgram), now()).callback();
232 delay += client.process_output(now() + delay).callback(); // TODO: Why is there first a 5ms pacing delay before the PTO?
233 assert_eq!(delay, INITIAL_PTO);
234 assert_eq!(*client.state(), State::WaitInitial);
235 assert_eq!(1, client.stats().dropped_rx);
236 assert_dscp(&client.stats());
237 }
238
239 #[test]
240 fn compatible_upgrade() {
241 let mut client = default_client();
242 let mut server = default_server();
243
244 connect(&mut client, &mut server);
245 assert_eq!(client.version(), Version::Version2);
246 assert_eq!(server.version(), Version::Version2);
247 assert_dscp(&client.stats());
248 assert_dscp(&server.stats());
249 }
250
251 /// When the first packet from the client is gigantic, the server might generate acknowledgment
252 /// packets in version 1. Both client and server need to handle that gracefully.
253 #[test]
254 fn compatible_upgrade_large_initial() {
255 let params = ConnectionParameters::default().versions(
256 Version::Version1,
257 vec![Version::Version2, Version::Version1],
258 );
259 let mut client = new_client(params.clone());
260 client
261 .set_local_tparam(
262 TestTransportParameter,
263 TransportParameter::Bytes(vec![0; 2048]),
264 )
265 .unwrap();
266 let mut server = new_server(params);
267
268 // Client Initial should take 2 packets.
269 // Each should elicit a Version 1 ACK from the server.
270 let dgram = client.process_output(now()).dgram();
271 let dgram2 = client.process_output(now()).dgram();
272 assert!(dgram.is_some() && dgram2.is_some());
273 server.process_input(dgram.unwrap(), now());
274 let dgram = server.process(dgram2, now()).dgram();
275 assert!(dgram.is_some());
276 // The following uses the Version from *outside* this crate.
277 assertions::assert_version(dgram.as_ref().unwrap(), Version::Version1.wire_version());
278 client.process_input(dgram.unwrap(), now());
279
280 connect(&mut client, &mut server);
281 assert_eq!(client.version(), Version::Version2);
282 assert_eq!(server.version(), Version::Version2);
283 // Only handshake padding is "dropped".
284 assert_eq!(client.stats().dropped_rx, 1);
285 assert!(matches!(server.stats().dropped_rx, 2 | 3));
286 assert_dscp(&client.stats());
287 assert!(
288 server.stats().dscp_rx[IpTosDscp::Cs0] == server.stats().packets_rx
289 || server.stats().dscp_rx[IpTosDscp::Cs0] == server.stats().packets_rx + 1
290 || server.stats().dscp_rx[IpTosDscp::Cs0] == server.stats().packets_rx - 1,
291 "dscp_rx[IpTosDscp::Cs0] {} != packets_rx {} (possibly +/- 1)",
292 server.stats().dscp_rx[IpTosDscp::Cs0],
293 server.stats().packets_rx
294 );
295 }
296
297 /// A server that supports versions 1 and 2 might prefer version 1 and that's OK.
298 /// This one starts with version 1 and stays there.
299 #[test]
300 fn compatible_no_upgrade() {
301 let mut client = new_client(ConnectionParameters::default().versions(
302 Version::Version1,
303 vec![Version::Version2, Version::Version1],
304 ));
305 let mut server = new_server(ConnectionParameters::default().versions(
306 Version::Version1,
307 vec![Version::Version1, Version::Version2],
308 ));
309
310 connect(&mut client, &mut server);
311 assert_eq!(client.version(), Version::Version1);
312 assert_eq!(server.version(), Version::Version1);
313 }
314
315 /// A server that supports versions 1 and 2 might prefer version 1 and that's OK.
316 /// This one starts with version 2 and downgrades to version 1.
317 #[test]
318 fn compatible_downgrade() {
319 let mut client = new_client(ConnectionParameters::default().versions(
320 Version::Version2,
321 vec![Version::Version2, Version::Version1],
322 ));
323 let mut server = new_server(ConnectionParameters::default().versions(
324 Version::Version2,
325 vec![Version::Version1, Version::Version2],
326 ));
327
328 connect(&mut client, &mut server);
329 assert_eq!(client.version(), Version::Version1);
330 assert_eq!(server.version(), Version::Version1);
331 }
332
333 /// Inject a Version Negotiation packet, which the client detects when it validates the
334 /// server `version_negotiation` transport parameter.
335 #[test]
336 fn version_negotiation_downgrade() {
337 const DOWNGRADE: Version = Version::Draft29;
338
339 let mut client = default_client();
340 // The server sets the current version in the transport parameter and
341 // protects Initial packets with the version in its configuration.
342 // When a server `Connection` is created by a `Server`, the configuration is set
343 // to match the version of the packet it first receives. This replicates that.
344 let mut server =
345 new_server(ConnectionParameters::default().versions(DOWNGRADE, Version::all()));
346
347 // Start the handshake and spoof a VN packet.
348 let initial = client.process_output(now()).dgram().unwrap();
349 let vn = create_vn(&initial, &[DOWNGRADE.wire_version()]);
350 let dgram = datagram(vn);
351 client.process_input(dgram, now());
352
353 connect_fail(
354 &mut client,
355 &mut server,
356 Error::VersionNegotiation,
357 Error::PeerError(Error::VersionNegotiation.code()),
358 );
359 }
360
361 /// A server connection needs to be configured with the version that the client attempts.
362 /// Otherwise, it will object to the client transport parameters and not do anything.
363 #[test]
364 fn invalid_server_version() {
365 let mut client =
366 new_client(ConnectionParameters::default().versions(Version::Version1, Version::all()));
367 let mut server =
368 new_server(ConnectionParameters::default().versions(Version::Version2, Version::all()));
369
370 let dgram = client.process_output(now()).dgram();
371 let dgram2 = client.process_output(now()).dgram();
372 server.process_input(dgram.unwrap(), now());
373 server.process_input(dgram2.unwrap(), now());
374
375 // Three packets received (one is zero padding).
376 assert_eq!(server.stats().packets_rx, 3);
377 // One dropped (the zero padding).
378 assert_eq!(server.stats().dropped_rx, 1);
379 assert_eq!(server.stats().saved_datagrams, 0);
380 // The server effectively hasn't reacted here.
381 match server.state() {
382 State::Closed(err) => {
383 assert_eq!(*err, CloseReason::Transport(Error::CryptoAlert(47)));
384 }
385 _ => panic!("invalid server state"),
386 }
387 }
388
389 #[test]
390 fn invalid_current_version_client() {
391 const OTHER_VERSION: Version = Version::Draft29;
392
393 let mut client = default_client();
394 let mut server = default_server();
395
396 assert_ne!(OTHER_VERSION, client.version());
397 client
398 .set_local_tparam(
399 VersionInformation,
400 TransportParameter::Versions {
401 current: OTHER_VERSION.wire_version(),
402 other: Version::all()
403 .iter()
404 .copied()
405 .map(Version::wire_version)
406 .collect(),
407 },
408 )
409 .unwrap();
410
411 connect_fail(
412 &mut client,
413 &mut server,
414 Error::PeerError(Error::CryptoAlert(47).code()),
415 Error::CryptoAlert(47),
416 );
417 }
418
419 /// To test this, we need to disable compatible upgrade so that the server doesn't update
420 /// its transport parameters. Then, we can overwrite its transport parameters without
421 /// them being overwritten. Otherwise, it would be hard to find a window during which
422 /// the transport parameter can be modified.
423 #[test]
424 fn invalid_current_version_server() {
425 const OTHER_VERSION: Version = Version::Draft29;
426
427 let mut client = default_client();
428 let mut server = new_server(
429 ConnectionParameters::default().versions(Version::default(), vec![Version::default()]),
430 );
431
432 assert!(!Version::default().is_compatible(OTHER_VERSION));
433 server
434 .set_local_tparam(
435 VersionInformation,
436 TransportParameter::Versions {
437 current: OTHER_VERSION.wire_version(),
438 other: vec![OTHER_VERSION.wire_version()],
439 },
440 )
441 .unwrap();
442
443 connect_fail(
444 &mut client,
445 &mut server,
446 Error::CryptoAlert(47),
447 Error::PeerError(Error::CryptoAlert(47).code()),
448 );
449 }
450
451 #[test]
452 fn no_compatible_version() {
453 const OTHER_VERSION: Version = Version::Draft29;
454
455 let mut client = default_client();
456 let mut server = default_server();
457
458 assert_ne!(OTHER_VERSION, client.version());
459 client
460 .set_local_tparam(
461 VersionInformation,
462 TransportParameter::Versions {
463 current: Version::default().wire_version(),
464 other: vec![OTHER_VERSION.wire_version()],
465 },
466 )
467 .unwrap();
468
469 connect_fail(
470 &mut client,
471 &mut server,
472 Error::PeerError(Error::CryptoAlert(47).code()),
473 Error::CryptoAlert(47),
474 );
475 }
476
477 /// When a compatible upgrade chooses a different version, 0-RTT is rejected.
478 #[test]
479 fn compatible_upgrade_0rtt_rejected() {
480 // This is the baseline configuration where v1 is attempted and v2 preferred.
481 let prefer_v2 = ConnectionParameters::default().versions(
482 Version::Version1,
483 vec![Version::Version2, Version::Version1],
484 );
485 let mut client = new_client(prefer_v2.clone());
486 // The server will start with this so that the client resumes with v1.
487 let just_v1 =
488 ConnectionParameters::default().versions(Version::Version1, vec![Version::Version1]);
489 let mut server = new_server(just_v1);
490
491 connect(&mut client, &mut server);
492 assert_eq!(client.version(), Version::Version1);
493 let token = exchange_ticket(&mut client, &mut server, now());
494
495 // Now upgrade the server to the preferred configuration.
496 let mut client = new_client(prefer_v2.clone());
497 let mut server = new_server(prefer_v2);
498 client.enable_resumption(now(), token).unwrap();
499
500 // Create a packet with 0-RTT from the client.
501 let initial = send_something(&mut client, now());
502 let initial2 = send_something(&mut client, now());
503 assertions::assert_version(&initial, Version::Version1.wire_version());
504 assertions::assert_coalesced_0rtt(&initial2);
505 server.process_input(initial, now());
506 server.process_input(initial2, now());
507 assert!(!server
508 .events()
509 .any(|e| matches!(e, ConnectionEvent::NewStream { .. })));
510
511 // Finalize the connection. Don't use connect() because it uses
512 // maybe_authenticate() too liberally and that eats the events we want to check.
513 let dgram = server.process_output(now()).dgram(); // ServerHello flight
514 let dgram = client.process(dgram, now()).dgram();
515 let dgram = server.process(dgram, now()).dgram();
516 let dgram = client.process(dgram, now()).dgram(); // Client Finished (note: no authentication)
517 let dgram = server.process(dgram, now()).dgram(); // HANDSHAKE_DONE
518 client.process_input(dgram.unwrap(), now());
519
520 assert!(matches!(client.state(), State::Confirmed));
521 assert!(matches!(server.state(), State::Confirmed));
522
523 assert!(client.events().any(|e| {
524 println!(" client event: {e:?}");
525 matches!(e, ConnectionEvent::ZeroRttRejected)
526 }));
527 assert_eq!(client.zero_rtt_state(), ZeroRttState::Rejected);
528 }