Debian Codegraph @

third_party/rust/neqo-transport/src/connection/tests/handshake.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::{
8 cell::RefCell,
9 net::{IpAddr, Ipv6Addr, SocketAddr},
10 rc::Rc,
11 time::Duration,
12 };
13
14 use neqo_common::{event::Provider as _, qdebug, Datagram};
15 use neqo_crypto::{
16 constants::TLS_CHACHA20_POLY1305_SHA256, generate_ech_keys, AuthenticationStatus,
17 };
18 #[cfg(not(feature = "disable-encryption"))]
19 use test_fixture::datagram;
20 use test_fixture::{
21 assertions, assertions::assert_coalesced_0rtt, fixture_init, now, split_datagram, DEFAULT_ADDR,
22 };
23
24 use super::{
25 super::{Connection, Output, State},
26 assert_error, connect, connect_force_idle, connect_with_rtt, default_client, default_server,
27 get_tokens, handshake, maybe_authenticate, resumed_server, send_something, zero_len_cid_client,
28 CountingConnectionIdGenerator, AT_LEAST_PTO, DEFAULT_RTT, DEFAULT_STREAM_DATA,
29 };
30 use crate::{
31 connection::{
32 tests::{exchange_ticket, new_client, new_server},
33 AddressValidation,
34 },
35 events::ConnectionEvent,
36 server::ValidateAddress,
37 stats::FrameStats,
38 tparams::{TransportParameter, TransportParameterId::*},
39 tracking::DEFAULT_LOCAL_ACK_DELAY,
40 CloseReason, ConnectionParameters, Error, Pmtud, StreamType, Version,
41 };
42
43 const ECH_CONFIG_ID: u8 = 7;
44 const ECH_PUBLIC_NAME: &str = "public.example";
45
46 fn full_handshake(pmtud: bool) {
47 qdebug!("---- client: generate CH");
48 let mut client = new_client(ConnectionParameters::default().pmtud(pmtud));
49 let out = client.process_output(now());
50 let out2 = client.process_output(now());
51 assert!(out.as_dgram_ref().is_some() && out2.as_dgram_ref().is_some());
52 assert_eq!(out.as_dgram_ref().unwrap().len(), client.plpmtu());
53 assert_eq!(out2.as_dgram_ref().unwrap().len(), client.plpmtu());
54
55 qdebug!("---- server: CH -> SH, EE, CERT, CV, FIN");
56 let mut server = new_server(ConnectionParameters::default().pmtud(pmtud));
57 server.process_input(out.dgram().unwrap(), now());
58 let out = server.process(out2.dgram(), now());
59 assert!(out.as_dgram_ref().is_some());
60 assert_eq!(out.as_dgram_ref().unwrap().len(), server.plpmtu());
61
62 qdebug!("---- client: cert verification");
63 let out = client.process(out.dgram(), now());
64 assert!(out.as_dgram_ref().is_some());
65
66 let out = server.process(out.dgram(), now());
67 let out = client.process(out.dgram(), now());
68
69 let out = server.process(out.dgram(), now());
70 assert!(out.as_dgram_ref().is_none());
71
72 assert!(maybe_authenticate(&mut client));
73
74 qdebug!("---- client: SH..FIN -> FIN");
75 let out = client.process(out.dgram(), now());
76 assert!(out.as_dgram_ref().is_some());
77 assert_eq!(*client.state(), State::Connected);
78
79 qdebug!("---- server: FIN -> ACKS");
80 let out = server.process(out.dgram(), now());
81 assert!(out.as_dgram_ref().is_some());
82 assert_eq!(*server.state(), State::Confirmed);
83
84 qdebug!("---- client: ACKS -> 0");
85 let out = client.process(out.dgram(), now());
86 if pmtud {
87 // PMTUD causes a PING probe to be sent here
88 let pkt = out.dgram().unwrap();
89 assert!(pkt.len() > client.plpmtu());
90 } else {
91 assert!(out.as_dgram_ref().is_none());
92 }
93 assert_eq!(*client.state(), State::Confirmed);
94 }
95
96 #[test]
97 fn handshake_no_pmtud() {
98 full_handshake(false);
99 }
100
101 #[test]
102 fn handshake_pmtud() {
103 full_handshake(true);
104 }
105
106 #[test]
107 fn handshake_failed_authentication() {
108 qdebug!("---- client: generate CH");
109 let mut client = default_client();
110 let out = client.process_output(now());
111 let out2 = client.process_output(now());
112 assert!(out.as_dgram_ref().is_some() && out2.as_dgram_ref().is_some());
113
114 qdebug!("---- server: CH -> SH, EE, CERT, CV, FIN");
115 let mut server = default_server();
116 server.process_input(out.dgram().unwrap(), now());
117 let out = server.process(out2.dgram(), now());
118 assert!(out.as_dgram_ref().is_some());
119
120 qdebug!("---- client: cert verification");
121 let out = client.process(out.dgram(), now());
122 assert!(out.as_dgram_ref().is_some());
123
124 let out = server.process(out.dgram(), now());
125 assert!(out.as_dgram_ref().is_some());
126 let out = client.process(out.dgram(), now());
127 assert!(out.as_dgram_ref().is_some());
128 let out = server.process(out.dgram(), now());
129 assert!(out.as_dgram_ref().is_none());
130
131 let authentication_needed = |e| matches!(e, ConnectionEvent::AuthenticationNeeded);
132 assert!(client.events().any(authentication_needed));
133 qdebug!("---- client: Alert(certificate_revoked)");
134 client.authenticated(AuthenticationStatus::CertRevoked, now());
135
136 qdebug!("---- client: -> Alert(certificate_revoked)");
137 let out = client.process_output(now());
138 assert!(out.as_dgram_ref().is_some());
139
140 qdebug!("---- server: Alert(certificate_revoked)");
141 let out = server.process(out.dgram(), now());
142 assert!(out.as_dgram_ref().is_some());
143 assert_error(&client, &CloseReason::Transport(Error::CryptoAlert(44)));
144 assert_error(&server, &CloseReason::Transport(Error::PeerError(300)));
145 }
146
147 #[test]
148 fn no_alpn() {
149 fixture_init();
150 let mut client = Connection::new_client(
151 "example.com",
152 &["bad-alpn"],
153 Rc::new(RefCell::new(CountingConnectionIdGenerator::default())),
154 DEFAULT_ADDR,
155 DEFAULT_ADDR,
156 ConnectionParameters::default(),
157 now(),
158 )
159 .unwrap();
160 let mut server = default_server();
161
162 handshake(&mut client, &mut server, now(), Duration::new(0, 0));
163 // TODO (mt): errors are immediate, which means that we never send CONNECTION_CLOSE
164 // and the client never sees the server's rejection of its handshake.
165 // assert_error(&client, CloseReason::Transport(Error::CryptoAlert(120)));
166 assert_error(&server, &CloseReason::Transport(Error::CryptoAlert(120)));
167 }
168
169 #[test]
170 #[expect(clippy::cognitive_complexity, reason = "OK in a test.")]
171 fn dup_server_flight1() {
172 qdebug!("---- client: generate CH");
173 let mut client = default_client();
174 let out = client.process_output(now());
175 let out2 = client.process_output(now());
176 assert!(out.as_dgram_ref().is_some() && out2.as_dgram_ref().is_some());
177 assert_eq!(out.as_dgram_ref().unwrap().len(), client.plpmtu());
178 assert_eq!(out2.as_dgram_ref().unwrap().len(), client.plpmtu());
179 qdebug!(
180 "Output={:0x?} {:0x?}",
181 out.as_dgram_ref(),
182 out2.as_dgram_ref()
183 );
184
185 qdebug!("---- server: CH -> SH, EE, CERT, CV, FIN");
186 let mut server = default_server();
187 server.process_input(out.dgram().unwrap(), now());
188 let out_to_rep = server.process(out2.dgram(), now());
189 assert!(out_to_rep.as_dgram_ref().is_some());
190 qdebug!("Output={:0x?}", out_to_rep.as_dgram_ref());
191
192 qdebug!("---- client: cert verification");
193 let out = client.process(Some(out_to_rep.as_dgram_ref().cloned().unwrap()), now());
194 let out_to_rep2 = server.process(out.dgram(), now());
195 let out = client.process(out_to_rep2.clone().dgram(), now());
196
197 assert!(out.as_dgram_ref().is_some());
198 qdebug!("Output={:0x?}", out.as_dgram_ref());
199
200 let out = server.process(out.dgram(), now());
201 assert!(out.as_dgram_ref().is_none());
202
203 assert!(maybe_authenticate(&mut client));
204
205 qdebug!("---- client: SH..FIN -> FIN");
206 let out = client.process_output(now());
207 assert!(out.as_dgram_ref().is_some());
208 qdebug!("Output={:0x?}", out.as_dgram_ref());
209
210 assert_eq!(4, client.stats().packets_rx);
211 assert_eq!(0, client.stats().dups_rx);
212 assert_eq!(1, client.stats().dropped_rx);
213
214 qdebug!("---- Dup, ignored");
215 client.process_input(out_to_rep.dgram().unwrap(), now());
216 let out = client.process(out_to_rep2.dgram(), now());
217 assert!(out.as_dgram_ref().is_none());
218 qdebug!("Output={:0x?}", out.as_dgram_ref());
219
220 // Four packets total received, 1 of them is a dup and one has been dropped because Initial keys
221 // are dropped. Add 2 counts of the padding that the server adds to Initial packets.
222 assert_eq!(8, client.stats().packets_rx);
223 assert_eq!(1, client.stats().dups_rx);
224 assert_eq!(4, client.stats().dropped_rx);
225 }
226
227 // Test that we split crypto data if they cannot fit into one packet.
228 // To test this we will use a long server certificate.
229 #[test]
230 fn crypto_frame_split() {
231 // This test has its own logic for generating large CRYPTO frames, so turn off MLKEM.
232 let mut client = new_client(ConnectionParameters::default().mlkem(false));
233
234 let mut server = Connection::new_server(
235 test_fixture::LONG_CERT_KEYS,
236 test_fixture::DEFAULT_ALPN,
237 Rc::new(RefCell::new(CountingConnectionIdGenerator::default())),
238 ConnectionParameters::default(),
239 )
240 .expect("create a server");
241
242 let client1 = client.process_output(now());
243 assert!(client1.as_dgram_ref().is_some());
244
245 // The entire server flight doesn't fit in a single packet because the
246 // certificate is large, therefore the server will produce 2 packets.
247 let server1 = server.process(client1.dgram(), now());
248 assert!(server1.as_dgram_ref().is_some());
249 let server2 = server.process_output(now());
250 assert!(server2.as_dgram_ref().is_some());
251
252 let client2 = client.process(server1.dgram(), now());
253 // This is an ack.
254 assert!(client2.as_dgram_ref().is_some());
255 // The client might have the certificate now, so we can't guarantee that
256 // this will work.
257 let auth1 = maybe_authenticate(&mut client);
258 assert_eq!(*client.state(), State::Handshaking);
259
260 // let server process the ack for the first packet.
261 let server3 = server.process(client2.dgram(), now());
262 assert!(server3.as_dgram_ref().is_none());
263
264 // Consume the second packet from the server.
265 let client3 = client.process(server2.dgram(), now());
266
267 // Check authentication.
268 let auth2 = maybe_authenticate(&mut client);
269 assert!(auth1 ^ auth2);
270 // Now client has all data to finish handshake.
271 assert_eq!(*client.state(), State::Connected);
272
273 let client4 = client.process(server3.dgram(), now());
274 // One of these will contain data depending on whether Authentication was completed
275 // after the first or second server packet.
276 assert!(client3.as_dgram_ref().is_some() ^ client4.as_dgram_ref().is_some());
277
278 drop(server.process(client3.dgram(), now()));
279 drop(server.process(client4.dgram(), now()));
280
281 assert_eq!(*client.state(), State::Connected);
282 assert_eq!(*server.state(), State::Confirmed);
283 }
284
285 /// Run a single ChaCha20-Poly1305 test and get a PTO.
286 #[test]
287 fn chacha20poly1305() {
288 let mut server = default_server();
289 let mut client = zero_len_cid_client(DEFAULT_ADDR, DEFAULT_ADDR);
290 client.set_ciphers(&[TLS_CHACHA20_POLY1305_SHA256]).unwrap();
291 connect_force_idle(&mut client, &mut server);
292 }
293
294 /// Test that a server can send 0.5 RTT application data.
295 #[test]
296 fn send_05rtt() {
297 let mut client = default_client();
298 let mut server = default_server();
299
300 let c1 = client.process_output(now()).dgram();
301 let c2 = client.process_output(now()).dgram();
302 assert!(c1.is_some() && c2.is_some());
303 server.process_input(c1.unwrap(), now());
304 let s1 = server.process(c2, now()).dgram().unwrap();
305 assert_eq!(s1.len(), server.plpmtu());
306
307 // The server should accept writes at this point.
308 let s2 = send_something(&mut server, now());
309
310 // Complete the handshake at the client.
311 client.process_input(s1, now());
312
313 // The client should receive the 0.5-RTT data now.
314 client.process_input(s2, now());
315 maybe_authenticate(&mut client);
316 assert_eq!(*client.state(), State::Connected);
317 let mut buf = vec![0; DEFAULT_STREAM_DATA.len() + 1];
318 let stream_id = client
319 .events()
320 .find_map(|e| {
321 if let ConnectionEvent::RecvStreamReadable { stream_id } = e {
322 Some(stream_id)
323 } else {
324 None
325 }
326 })
327 .unwrap();
328 let (l, ended) = client.stream_recv(stream_id, &mut buf).unwrap();
329 assert_eq!(&buf[..l], DEFAULT_STREAM_DATA);
330 assert!(ended);
331 }
332
333 /// Test that a client buffers 0.5-RTT data when it arrives early.
334 #[test]
335 fn reorder_05rtt() {
336 // This test makes too many assumptions about single-packet PTOs for multi-packet MLKEM flights
337 let mut client = new_client(ConnectionParameters::default().mlkem(false));
338 let mut server = default_server();
339
340 let c1 = client.process_output(now()).dgram();
341 assert!(c1.is_some());
342 let s1 = server.process(c1, now()).dgram().unwrap();
343
344 // The server should accept writes at this point.
345 let s2 = send_something(&mut server, now());
346
347 // We can't use the standard facility to complete the handshake, so
348 // drive it as aggressively as possible.
349 assert_eq!(client.stats().saved_datagrams, 0);
350 assert_eq!(client.stats().packets_rx, 0);
351 client.process_input(s2, now());
352 assert_eq!(client.stats().saved_datagrams, 1);
353 assert_eq!(client.stats().packets_rx, 0);
354
355 // After processing the first packet, the client should go back and
356 // process the 0.5-RTT packet data, which should make data available.
357 client.process_input(s1, now());
358 // We can't use `maybe_authenticate` here as that consumes events.
359 client.authenticated(AuthenticationStatus::Ok, now());
360 assert_eq!(*client.state(), State::Connected);
361
362 let mut buf = vec![0; DEFAULT_STREAM_DATA.len() + 1];
363 let stream_id = client
364 .events()
365 .find_map(|e| {
366 if let ConnectionEvent::RecvStreamReadable { stream_id } = e {
367 Some(stream_id)
368 } else {
369 None
370 }
371 })
372 .unwrap();
373 let (l, ended) = client.stream_recv(stream_id, &mut buf).unwrap();
374 assert_eq!(&buf[..l], DEFAULT_STREAM_DATA);
375 assert!(ended);
376 }
377
378 #[test]
379 fn reorder_05rtt_with_0rtt() {
380 const RTT: Duration = Duration::from_millis(100);
381
382 let mut client = default_client();
383 let mut server = default_server();
384 let validation = AddressValidation::new(now(), ValidateAddress::NoToken).unwrap();
385 let validation = Rc::new(RefCell::new(validation));
386 server.set_validation(&validation);
387 let mut now = connect_with_rtt(&mut client, &mut server, now(), RTT);
388
389 // Include RTT in sending the ticket or the ticket age reported by the
390 // client is wrong, which causes the server to reject 0-RTT.
391 now += RTT / 2;
392 server.send_ticket(now, &[]).unwrap();
393 let ticket = server.process_output(now).dgram().unwrap();
394 now += RTT / 2;
395 client.process_input(ticket, now);
396
397 let token = get_tokens(&mut client).pop().unwrap();
398 // This test makes too many assumptions about what's in the packets to work with multi-packet
399 // MLKEM flights.
400 let mut client = new_client(ConnectionParameters::default().mlkem(false));
401 client.enable_resumption(now, token).unwrap();
402 let mut server = resumed_server(&client);
403
404 // Send ClientHello and some 0-RTT.
405 let c1 = send_something(&mut client, now);
406 assert_coalesced_0rtt(&c1[..]);
407 // Drop the 0-RTT from the coalesced datagram, so that the server
408 // acknowledges the next 0-RTT packet.
409 let (c1, _) = split_datagram(&c1);
410 let c2 = send_something(&mut client, now);
411
412 // Handle the first packet and send 0.5-RTT in response. Drop the response.
413 now += RTT / 2;
414 drop(server.process(Some(c1), now).dgram().unwrap());
415 // The gap in 0-RTT will result in this 0.5 RTT containing an ACK.
416 server.process_input(c2, now);
417 let s2 = send_something(&mut server, now);
418
419 // Save the 0.5 RTT.
420 now += RTT / 2;
421 client.process_input(s2, now);
422 assert_eq!(client.stats().saved_datagrams, 1);
423
424 // Now PTO at the client and cause the server to re-send handshake packets.
425 now += AT_LEAST_PTO;
426 let c3 = client.process_output(now).dgram();
427 assert_coalesced_0rtt(c3.as_ref().unwrap());
428
429 now += RTT / 2;
430 let s3 = server.process(c3, now).dgram().unwrap();
431
432 // The client should be able to process the 0.5 RTT now.
433 // This should contain an ACK, so we are processing an ACK from the past.
434 now += RTT / 2;
435 client.process_input(s3, now);
436 maybe_authenticate(&mut client);
437 let c4 = client.process_output(now).dgram();
438 assert_eq!(*client.state(), State::Connected);
439 assert_eq!(client.paths.rtt(), RTT);
440
441 now += RTT / 2;
442 server.process_input(c4.unwrap(), now);
443 assert_eq!(*server.state(), State::Confirmed);
444 // Don't check server RTT as it will be massively inflated by a
445 // poor initial estimate received when the server dropped the
446 // Initial packet number space.
447 }
448
449 /// Test that a server that coalesces 0.5 RTT with handshake packets
450 /// doesn't cause the client to drop application data.
451 #[test]
452 fn coalesce_05rtt() {
453 const RTT: Duration = Duration::from_millis(100);
454 let mut client = default_client();
455 let mut server = default_server();
456 let mut now = now();
457
458 // The first exchange doesn't offer a chance for the server to send.
459 // So drop the server flight and wait for the PTO.
460 let c1 = client.process_output(now).dgram();
461 let c11 = client.process_output(now).dgram();
462 assert!(c1.is_some() && c11.is_some());
463 now += RTT / 2;
464 server.process_input(c1.unwrap(), now);
465 let s1 = server.process(c11, now).dgram();
466 assert!(s1.is_some());
467
468 // Drop the server flight. Then send some data.
469 let stream_id = server.stream_create(StreamType::UniDi).unwrap();
470 assert!(server.stream_send(stream_id, DEFAULT_STREAM_DATA).is_ok());
471 assert!(server.stream_close_send(stream_id).is_ok());
472
473 // Now after a PTO the client can send another packet.
474 // The server should then send its entire flight again,
475 // including the application data, which it sends in a 1-RTT packet.
476 now += AT_LEAST_PTO;
477 let c2 = client.process_output(now).dgram();
478 let c21 = client.process_output(now).dgram();
479 assert!(c2.is_some() && c21.is_some());
480 now += RTT / 2;
481 server.process_input(c21.unwrap(), now);
482 let s2 = server.process(c2, now).dgram();
483
484 let dgram = client.process(s2, now).dgram();
485 let s2 = server.process(dgram, now).dgram();
486
487 // Even though there is a 1-RTT packet at the end of the datagram, the
488 // flight should be padded to full size.
489 assert_eq!(s2.as_ref().unwrap().len(), server.plpmtu());
490
491 // The client should process the datagram. It can't process the 1-RTT
492 // packet until authentication completes though. So it saves it.
493 now += RTT / 2;
494 assert_eq!(client.stats().dropped_rx, 0);
495 drop(client.process(s2, now).dgram());
496 // This packet will contain an ACK, but we can ignore it.
497 assert_eq!(client.stats().dropped_rx, 0);
498 assert_eq!(client.stats().packets_rx, 3);
499 assert_eq!(client.stats().saved_datagrams, 1);
500
501 // After (successful) authentication, the packet is processed.
502 maybe_authenticate(&mut client);
503 let c3 = client.process_output(now).dgram();
504 assert!(c3.is_some());
505 assert_eq!(client.stats().dropped_rx, 0); // No Initial padding.
506 assert_eq!(client.stats().packets_rx, 4);
507 assert_eq!(client.stats().saved_datagrams, 1);
508 assert!(client.stats().frame_rx.padding > 0); // Padding uses frames.
509
510 // Allow the handshake to complete.
511 now += RTT / 2;
512 let s3 = server.process(c3, now).dgram();
513 assert!(s3.is_some());
514 assert_eq!(*server.state(), State::Confirmed);
515 now += RTT / 2;
516 drop(client.process(s3, now).dgram());
517 assert_eq!(*client.state(), State::Confirmed);
518
519 assert_eq!(client.stats().dropped_rx, 0); // No dropped packets.
520 }
521
522 #[test]
523 fn reorder_handshake() {
524 const RTT: Duration = Duration::from_millis(100);
525 let mut client = default_client();
526 let mut server = default_server();
527 let mut now = now();
528
529 let c1 = client.process_output(now).dgram();
530 let c2 = client.process_output(now).dgram();
531 assert!(c1.is_some() && c2.is_some());
532
533 now += RTT / 2;
534 server.process_input(c1.unwrap(), now);
535 let s1 = server.process(c2, now).dgram();
536 assert!(s1.is_some());
537 now += RTT / 2;
538 let dgram = client.process(s1, now).dgram();
539 assert!(dgram.is_some());
540 now += RTT / 2;
541 let s1 = server.process(dgram, now).dgram();
542 assert!(s1.is_some());
543
544 // Drop the Initial packet from this.
545 let (_, s_hs) = split_datagram(&s1.unwrap());
546 assert!(s_hs.is_some());
547
548 // Pass just the handshake packet in and the client can't handle it yet.
549 // It can only send another Initial packet.
550 now += RTT + RTT / 2; // With multi-packet MLKEM flights, client needs more time here.
551 let dgram = client.process(s_hs, now).dgram();
552 assertions::assert_initial(dgram.as_ref().unwrap(), false);
553 assert_eq!(client.stats().saved_datagrams, 1);
554 assert_eq!(client.stats().packets_rx, 1);
555
556 // Get the server to try again.
557 // Though we currently allow the server to arm its PTO timer, use
558 // a second client Initial packet to cause it to send again.
559 now += AT_LEAST_PTO;
560 let c2 = client.process_output(now).dgram();
561 now += RTT / 2;
562 let s2 = server.process(c2, now).dgram();
563 assert!(s2.is_some());
564
565 let (s_init, s_hs) = split_datagram(&s2.unwrap());
566 assert!(s_hs.is_some());
567
568 // Processing the Handshake packet first should save it.
569 now += RTT / 2;
570 client.process_input(s_hs.unwrap(), now);
571 assert_eq!(client.stats().saved_datagrams, 2);
572 assert_eq!(client.stats().packets_rx, 1);
573
574 client.process_input(s_init, now);
575 // Each saved packet should now be "received" again.
576 assert_eq!(client.stats().packets_rx, 6);
577 maybe_authenticate(&mut client);
578 let c3 = client.process_output(now).dgram();
579 assert!(c3.is_some());
580
581 // Note that though packets were saved and processed very late,
582 // they don't cause the RTT to change.
583 now += RTT / 2;
584 let s3 = server.process(c3, now).dgram();
585 assert_eq!(*server.state(), State::Confirmed);
586 // Don't check server RTT estimate as it will be inflated due to
587 // it making a guess based on retransmissions when it dropped
588 // the Initial packet number space.
589
590 now += RTT / 2;
591 client.process_input(s3.unwrap(), now);
592 assert_eq!(*client.state(), State::Confirmed);
593 assert_eq!(client.paths.rtt(), RTT);
594 }
595
596 #[test]
597 fn reorder_1rtt() {
598 const RTT: Duration = Duration::from_millis(100);
599 const PACKETS: usize = 4; // Many, but not enough to overflow cwnd.
600 let mut client = default_client();
601 let mut server = default_server();
602 let mut now = now();
603
604 let c1 = client.process_output(now).dgram();
605 let c2 = client.process_output(now).dgram();
606 assert!(c1.is_some() && c2.is_some());
607
608 now += RTT / 2;
609 server.process_input(c1.unwrap(), now);
610 let s1 = server.process(c2, now).dgram();
611 assert!(s1.is_some());
612
613 now += RTT / 2;
614 let dgram = client.process(s1, now).dgram();
615
616 now += RTT / 2;
617 let dgram = server.process(dgram, now).dgram();
618
619 now += RTT / 2;
620 client.process_input(dgram.unwrap(), now);
621 maybe_authenticate(&mut client);
622 let c2 = client.process_output(now).dgram();
623 assert!(c2.is_some());
624
625 // Now get a bunch of packets from the client.
626 // Give them to the server before giving it `c2`.
627 for _ in 0..PACKETS {
628 let d = send_something(&mut client, now);
629 server.process_input(d, now + RTT / 2);
630 }
631 // The server has now received those packets, and saved them.
632 // The six extra received are Initial + the junk we use for padding.
633 assert_eq!(server.stats().packets_rx, PACKETS + 2);
634 assert_eq!(server.stats().saved_datagrams, PACKETS);
635 assert_eq!(server.stats().dropped_rx, 3);
636
637 now += RTT / 2;
638 let s2 = server.process(c2, now).dgram();
639 // The server has now received those packets, and saved them.
640 // The two additional are an Initial w/ACK, a Handshake w/ACK and a 1-RTT (w/
641 // NEW_CONNECTION_ID).
642 assert_eq!(server.stats().packets_rx, PACKETS * 2 + 5);
643 assert_eq!(server.stats().saved_datagrams, PACKETS);
644 assert_eq!(server.stats().dropped_rx, 3);
645 assert_eq!(*server.state(), State::Confirmed);
646 assert_eq!(server.paths.rtt(), RTT);
647
648 now += RTT / 2;
649 client.process_input(s2.unwrap(), now);
650 assert_eq!(client.paths.rtt(), RTT);
651
652 // All the stream data that was sent should now be available.
653 let streams = server
654 .events()
655 .filter_map(|e| {
656 if let ConnectionEvent::RecvStreamReadable { stream_id } = e {
657 Some(stream_id)
658 } else {
659 None
660 }
661 })
662 .collect::<Vec<_>>();
663 assert_eq!(streams.len(), PACKETS);
664 for stream_id in streams {
665 let mut buf = vec![0; DEFAULT_STREAM_DATA.len() + 1];
666 let (recvd, fin) = server.stream_recv(stream_id, &mut buf).unwrap();
667 assert_eq!(recvd, DEFAULT_STREAM_DATA.len());
668 assert!(fin);
669 }
670 }
671
672 #[cfg(not(feature = "disable-encryption"))]
673 #[test]
674 fn corrupted_initial() {
675 let mut client = default_client();
676 let mut server = default_server();
677 let d = client.process_output(now()).dgram().unwrap();
678 let mut corrupted = Vec::from(&d[..]);
679 // Find the last non-zero value and corrupt that.
680 let (idx, _) = corrupted
681 .iter()
682 .enumerate()
683 .rev()
684 .find(|(_, &v)| v != 0)
685 .unwrap();
686 corrupted[idx] ^= 0x76;
687 let dgram = Datagram::new(d.source(), d.destination(), d.tos(), corrupted);
688 server.process_input(dgram, now());
689 // The server should have received two packets,
690 // the first should be dropped, the second saved.
691 assert_eq!(server.stats().packets_rx, 2);
692 assert_eq!(server.stats().dropped_rx, 2);
693 assert_eq!(server.stats().saved_datagrams, 0);
694 }
695
696 #[test]
697 // Absent path PTU discovery, max v6 packet size should be PATH_MTU_V6.
698 fn verify_pkt_honors_mtu() {
699 let mut client = default_client();
700 let mut server = default_server();
701 connect_force_idle(&mut client, &mut server);
702
703 let now = now();
704
705 let res = client.process_output(now);
706 let idle_timeout = ConnectionParameters::default().get_idle_timeout();
707 assert_eq!(res, Output::Callback(idle_timeout));
708
709 // Try to send a large stream and verify first packet is correctly sized
710 let stream_id = client.stream_create(StreamType::UniDi).unwrap();
711 assert_eq!(client.stream_send(stream_id, &[0xbb; 2000]).unwrap(), 2000);
712 let pkt0 = client.process_output(now);
713 assert!(matches!(pkt0, Output::Datagram(_)));
714 assert_eq!(pkt0.as_dgram_ref().unwrap().len(), client.plpmtu());
715 }
716
717 #[test]
718 fn extra_initial_hs() {
719 let mut client = default_client();
720 let mut server = default_server();
721 let mut now = now();
722
723 let c_init = client.process_output(now).dgram();
724 let c_init2 = client.process_output(now).dgram();
725 assert!(c_init.is_some() && c_init2.is_some());
726 now += DEFAULT_RTT / 2;
727 server.process_input(c_init.unwrap(), now);
728 let s_init = server.process(c_init2, now).dgram();
729 assert!(s_init.is_some());
730 now += DEFAULT_RTT / 2;
731
732 let dgram = client.process(s_init, now).dgram();
733 let s_init = server.process(dgram, now).dgram();
734
735 // Drop the Initial packet, keep only the Handshake.
736 let (_, undecryptable) = split_datagram(&s_init.unwrap());
737 assert!(undecryptable.is_some());
738
739 // Feed the same undecryptable packet into the client a few times.
740 // Do that EXTRA_INITIALS times and each time the client will emit
741 // another Initial packet.
742 for _ in 0..=super::super::EXTRA_INITIALS {
743 let c_init = match client.process(undecryptable.clone(), now) {
744 Output::None => todo!(),
745 Output::Datagram(c_init) => Some(c_init),
746 Output::Callback(duration) => {
747 now += duration;
748 client.process_output(now).dgram()
749 }
750 };
751 assertions::assert_initial(c_init.as_ref().unwrap(), false);
752 now += DEFAULT_RTT / 10;
753 }
754
755 // After EXTRA_INITIALS, the client stops sending Initial packets.
756 let nothing = client.process(undecryptable, now).dgram();
757 assert!(nothing.is_none());
758
759 // Until PTO, where another Initial can be used to complete the handshake.
760 now += client.process_output(now).callback();
761 let c_init = client.process_output(now).dgram();
762 assertions::assert_initial(c_init.as_ref().unwrap(), false);
763 now += DEFAULT_RTT / 2;
764 let s_init = server.process(c_init, now).dgram();
765 now += DEFAULT_RTT / 2;
766 client.process_input(s_init.unwrap(), now);
767 maybe_authenticate(&mut client);
768 let c_fin = client.process_output(now).dgram();
769 assert_eq!(*client.state(), State::Connected);
770 now += DEFAULT_RTT / 2;
771 server.process_input(c_fin.unwrap(), now);
772 assert_eq!(*server.state(), State::Confirmed);
773 }
774
775 #[test]
776 fn extra_initial_invalid_cid() {
777 let mut client = default_client();
778 let mut server = default_server();
779 let mut now = now();
780
781 let c_init = client.process_output(now).dgram();
782 let c_init2 = client.process_output(now).dgram();
783 assert!(c_init.is_some() && c_init2.is_some());
784 now += DEFAULT_RTT / 2;
785 server.process_input(c_init.unwrap(), now);
786 let s_init = server.process(c_init2, now).dgram();
787 assert!(s_init.is_some());
788 now += DEFAULT_RTT / 2;
789
790 let dgram = client.process(s_init, now).dgram();
791 let s_init = server.process(dgram, now).dgram();
792
793 // If the client receives a packet that contains the wrong connection
794 // ID, it won't send another Initial.
795 let (_, hs) = split_datagram(&s_init.unwrap());
796 let hs = hs.unwrap();
797 let mut copy = hs.to_vec();
798 assert_ne!(copy[5], 0); // The DCID should be non-zero length.
799 copy[6] ^= 0xc4;
800 let dgram_copy = Datagram::new(hs.destination(), hs.source(), hs.tos(), copy);
801 let nothing = client.process(Some(dgram_copy), now).dgram();
802 assert!(nothing.is_none());
803 }
804
805 #[test]
806 fn connect_one_version() {
807 fn connect_v(version: Version) {
808 fixture_init();
809 let mut client = Connection::new_client(
810 test_fixture::DEFAULT_SERVER_NAME,
811 test_fixture::DEFAULT_ALPN,
812 Rc::new(RefCell::new(CountingConnectionIdGenerator::default())),
813 DEFAULT_ADDR,
814 DEFAULT_ADDR,
815 ConnectionParameters::default().versions(version, vec![version]),
816 now(),
817 )
818 .unwrap();
819 let mut server = Connection::new_server(
820 test_fixture::DEFAULT_KEYS,
821 test_fixture::DEFAULT_ALPN,
822 Rc::new(RefCell::new(CountingConnectionIdGenerator::default())),
823 ConnectionParameters::default().versions(version, vec![version]),
824 )
825 .unwrap();
826 connect_force_idle(&mut client, &mut server);
827 assert_eq!(client.version(), version);
828 assert_eq!(server.version(), version);
829 }
830
831 for v in Version::all() {
832 println!("Connecting with {v:?}");
833 connect_v(v);
834 }
835 }
836
837 #[test]
838 fn anti_amplification() {
839 // This test has its own logic for generating large CRYPTO frames, so turn off MLKEM.
840 let mut client = new_client(ConnectionParameters::default().mlkem(false));
841 let mut server = default_server();
842 let mut now = now();
843
844 // With a gigantic transport parameter, the server is unable to complete
845 // the handshake within the amplification limit.
846 let very_big = TransportParameter::Bytes(vec![0; Pmtud::default_plpmtu(DEFAULT_ADDR.ip()) * 3]);
847 server
848 .set_local_tparam(TestTransportParameter, very_big)
849 .unwrap();
850
851 let c_init = client.process_output(now).dgram();
852 now += DEFAULT_RTT / 2;
853 let s_init1 = server.process(c_init, now).dgram().unwrap();
854 assert_eq!(s_init1.len(), server.plpmtu());
855 let s_init2 = server.process_output(now).dgram().unwrap();
856 assert_eq!(s_init2.len(), server.plpmtu());
857 let s_init3 = server.process_output(now).dgram().unwrap();
858 assert_eq!(s_init3.len(), server.plpmtu());
859 let cb = server.process_output(now).callback();
860
861 // We are blocked by the amplification limit now.
862 assert_eq!(cb, server.conn_params.get_idle_timeout());
863
864 now += DEFAULT_RTT / 2;
865 client.process_input(s_init1, now);
866 client.process_input(s_init2, now);
867 let ack_count = client.stats().frame_tx.ack;
868 let frame_count = client.stats().frame_tx.all();
869 let ack = client.process(Some(s_init3), now).dgram().unwrap();
870 assert!(!maybe_authenticate(&mut client)); // No need yet.
871
872 // The client sends a padded datagram, with just ACKs for Initial and Handshake.
873 assert_eq!(client.stats().frame_tx.ack, ack_count + 2);
874 assert_eq!(client.stats().frame_tx.all(), frame_count + 2);
875 assert_ne!(ack.len(), client.plpmtu()); // Not padded (it includes Handshake).
876
877 now += DEFAULT_RTT / 2;
878 let remainder = server.process(Some(ack), now).dgram();
879
880 now += DEFAULT_RTT / 2;
881 client.process_input(remainder.unwrap(), now);
882 assert!(maybe_authenticate(&mut client)); // OK, we have all of it.
883 let fin = client.process_output(now).dgram();
884 assert_eq!(*client.state(), State::Connected);
885
886 now += DEFAULT_RTT / 2;
887 server.process_input(fin.unwrap(), now);
888 assert_eq!(*server.state(), State::Confirmed);
889 }
890
891 #[cfg(not(feature = "disable-encryption"))]
892 #[test]
893 fn garbage_initial() {
894 let mut client = default_client();
895 let mut server = default_server();
896
897 let dgram = client.process_output(now()).dgram().unwrap();
898 let (initial, rest) = split_datagram(&dgram);
899 let mut corrupted = Vec::from(&initial[..initial.len() - 1]);
900 corrupted.push(initial[initial.len() - 1] ^ 0xb7);
901 corrupted.extend_from_slice(rest.as_ref().map_or(&[], |r| &r[..]));
902 let garbage = datagram(corrupted);
903 assert_eq!(Output::None, server.process(Some(garbage), now()));
904 }
905
906 #[test]
907 fn drop_initial_packet_from_wrong_address() {
908 let mut client = default_client();
909 let out = client.process_output(now());
910 let out2 = client.process_output(now());
911 assert!(out.as_dgram_ref().is_some() && out2.as_dgram_ref().is_some());
912
913 let mut server = default_server();
914 server.process_input(out.dgram().unwrap(), now());
915 let out = server.process(out2.dgram(), now());
916 assert!(out.as_dgram_ref().is_some());
917
918 let p = out.dgram().unwrap();
919 let dgram = Datagram::new(
920 SocketAddr::new(IpAddr::V6(Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 2)), 443),
921 p.destination(),
922 p.tos(),
923 &p[..],
924 );
925
926 let out = client.process(Some(dgram), now());
927 assert!(out.as_dgram_ref().is_none());
928 }
929
930 #[test]
931 fn drop_handshake_packet_from_wrong_address() {
932 let mut client = default_client();
933 let out = client.process_output(now());
934 let out2 = client.process_output(now());
935 assert!(out.as_dgram_ref().is_some() && out2.as_dgram_ref().is_some());
936
937 let mut server = default_server();
938 server.process_input(out.dgram().unwrap(), now());
939 let out = server.process(out2.dgram(), now());
940 assert!(out.as_dgram_ref().is_some());
941
942 let out = client.process(out.dgram(), now());
943 let out = server.process(out.dgram(), now());
944
945 let (s_in, s_hs) = split_datagram(&out.dgram().unwrap());
946
947 // Pass the initial packet.
948 drop(client.process(Some(s_in), now()).dgram());
949
950 let p = s_hs.unwrap();
951 let dgram = Datagram::new(
952 SocketAddr::new(IpAddr::V6(Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 2)), 443),
953 p.destination(),
954 p.tos(),
955 &p[..],
956 );
957
958 let out = client.process(Some(dgram), now());
959 assert!(out.as_dgram_ref().is_none());
960 }
961
962 #[test]
963 fn ech() {
964 let mut server = default_server();
965 let (sk, pk) = generate_ech_keys().unwrap();
966 server
967 .server_enable_ech(ECH_CONFIG_ID, ECH_PUBLIC_NAME, &sk, &pk)
968 .unwrap();
969
970 let mut client = default_client();
971 client.client_enable_ech(server.ech_config()).unwrap();
972
973 connect(&mut client, &mut server);
974
975 assert!(client.tls_info().unwrap().ech_accepted());
976 assert!(server.tls_info().unwrap().ech_accepted());
977 assert!(client.tls_preinfo().unwrap().ech_accepted().unwrap());
978 assert!(server.tls_preinfo().unwrap().ech_accepted().unwrap());
979 }
980
981 fn damaged_ech_config(config: &[u8]) -> Vec<u8> {
982 let mut cfg = Vec::from(config);
983 // Ensure that the version and config_id is correct.
984 assert_eq!(cfg[2], 0xfe);
985 assert_eq!(cfg[3], 0x0d);
986 assert_eq!(cfg[6], ECH_CONFIG_ID);
987 // Change the config_id so that the server doesn't recognize it.
988 cfg[6] ^= 0x94;
989 cfg
990 }
991
992 #[test]
993 fn ech_retry() {
994 fixture_init();
995 let mut server = default_server();
996 let (sk, pk) = generate_ech_keys().unwrap();
997 server
998 .server_enable_ech(ECH_CONFIG_ID, ECH_PUBLIC_NAME, &sk, &pk)
999 .unwrap();
1000
1001 let mut client = default_client();
1002 client
1003 .client_enable_ech(damaged_ech_config(server.ech_config()))
1004 .unwrap();
1005
1006 let dgram = client.process_output(now()).dgram();
1007 let dgram2 = client.process_output(now()).dgram();
1008 server.process_input(dgram.unwrap(), now());
1009 let dgram = server.process(dgram2, now()).dgram();
1010 let dgram = client.process(dgram, now()).dgram();
1011 let dgram = server.process(dgram, now()).dgram();
1012 client.process_input(dgram.unwrap(), now());
1013 let auth_event = ConnectionEvent::EchFallbackAuthenticationNeeded {
1014 public_name: String::from(ECH_PUBLIC_NAME),
1015 };
1016 assert!(client.events().any(|e| e == auth_event));
1017 client.authenticated(AuthenticationStatus::Ok, now());
1018 assert!(client.state().error().is_some());
1019
1020 // Tell the server about the error.
1021 let dgram = client.process_output(now()).dgram();
1022 server.process_input(dgram.unwrap(), now());
1023 assert_eq!(
1024 server.state().error(),
1025 Some(&CloseReason::Transport(Error::PeerError(0x100 + 121)))
1026 );
1027
1028 let Some(CloseReason::Transport(Error::EchRetry(updated_config))) = client.state().error()
1029 else {
1030 panic!(
1031 "Client state should be failed with EchRetry, is {:?}",
1032 client.state()
1033 );
1034 };
1035
1036 let mut server = default_server();
1037 server
1038 .server_enable_ech(ECH_CONFIG_ID, ECH_PUBLIC_NAME, &sk, &pk)
1039 .unwrap();
1040 let mut client = default_client();
1041 client.client_enable_ech(updated_config).unwrap();
1042
1043 connect(&mut client, &mut server);
1044
1045 assert!(client.tls_info().unwrap().ech_accepted());
1046 assert!(server.tls_info().unwrap().ech_accepted());
1047 assert!(client.tls_preinfo().unwrap().ech_accepted().unwrap());
1048 assert!(server.tls_preinfo().unwrap().ech_accepted().unwrap());
1049 }
1050
1051 #[test]
1052 fn ech_retry_fallback_rejected() {
1053 fixture_init();
1054 let mut server = default_server();
1055 let (sk, pk) = generate_ech_keys().unwrap();
1056 server
1057 .server_enable_ech(ECH_CONFIG_ID, ECH_PUBLIC_NAME, &sk, &pk)
1058 .unwrap();
1059
1060 let mut client = default_client();
1061 client
1062 .client_enable_ech(damaged_ech_config(server.ech_config()))
1063 .unwrap();
1064
1065 let dgram = client.process_output(now()).dgram();
1066 let dgram2 = client.process_output(now()).dgram();
1067 server.process_input(dgram.unwrap(), now());
1068 let dgram = server.process(dgram2, now()).dgram();
1069 let dgram = client.process(dgram, now()).dgram();
1070 let dgram = server.process(dgram, now()).dgram();
1071 client.process_input(dgram.unwrap(), now());
1072 let auth_event = ConnectionEvent::EchFallbackAuthenticationNeeded {
1073 public_name: String::from(ECH_PUBLIC_NAME),
1074 };
1075 assert!(client.events().any(|e| e == auth_event));
1076 client.authenticated(AuthenticationStatus::PolicyRejection, now());
1077 assert!(client.state().error().is_some());
1078
1079 if let Some(CloseReason::Transport(Error::EchRetry(_))) = client.state().error() {
1080 panic!("Client should not get EchRetry error");
1081 }
1082
1083 // Pass the error on.
1084 let dgram = client.process_output(now()).dgram();
1085 server.process_input(dgram.unwrap(), now());
1086 assert_eq!(
1087 server.state().error(),
1088 Some(&CloseReason::Transport(Error::PeerError(298)))
1089 ); // A bad_certificate alert.
1090 }
1091
1092 #[test]
1093 fn bad_min_ack_delay() {
1094 const EXPECTED_ERROR: CloseReason = CloseReason::Transport(Error::TransportParameterError);
1095 let mut server = default_server();
1096 let max_ad = u64::try_from(DEFAULT_LOCAL_ACK_DELAY.as_micros()).unwrap();
1097 server
1098 .set_local_tparam(MinAckDelay, TransportParameter::Integer(max_ad + 1))
1099 .unwrap();
1100 let mut client = default_client();
1101
1102 let dgram = client.process_output(now()).dgram();
1103 let dgram2 = client.process_output(now()).dgram();
1104 server.process_input(dgram.unwrap(), now());
1105 let dgram = server.process(dgram2, now()).dgram();
1106 let dgram = client.process(dgram, now()).dgram();
1107 let dgram = server.process(dgram, now()).dgram();
1108 client.process_input(dgram.unwrap(), now());
1109 client.authenticated(AuthenticationStatus::Ok, now());
1110 assert_eq!(client.state().error(), Some(&EXPECTED_ERROR));
1111 let dgram = client.process_output(now()).dgram();
1112
1113 server.process_input(dgram.unwrap(), now());
1114 assert_eq!(
1115 server.state().error(),
1116 Some(&CloseReason::Transport(Error::PeerError(
1117 Error::TransportParameterError.code()
1118 )))
1119 );
1120 }
1121
1122 /// Ensure that the client probes correctly if it only receives Initial packets
1123 /// from the server.
1124 #[test]
1125 fn only_server_initial() {
1126 let mut server = default_server();
1127 let mut client = default_client();
1128 let mut now = now();
1129
1130 let client_dgram = client.process_output(now).dgram();
1131 let client_dgram2 = client.process_output(now).dgram();
1132
1133 // Now fetch two flights of messages from the server.
1134 server.process_input(client_dgram.unwrap(), now);
1135 let dgram = server.process(client_dgram2, now).dgram();
1136 let dgram = client.process(dgram, now).dgram();
1137 let server_dgram1 = server.process(dgram, now).dgram();
1138 let server_dgram2 = server.process_output(now + AT_LEAST_PTO).dgram();
1139
1140 // Only pass on the Initial from the first. We should get a Handshake in return.
1141 let (initial, handshake) = split_datagram(&server_dgram1.unwrap());
1142 assert!(handshake.is_some());
1143
1144 // The client sends an Initial ACK.
1145 assert_eq!(client.stats().frame_tx.ack, 1);
1146 let probe = client.process(Some(initial), now).dgram();
1147 assertions::assert_initial(&probe.unwrap(), false);
1148 assert_eq!(client.stats().dropped_rx, 0);
1149 assert_eq!(client.stats().frame_tx.ack, 2);
1150
1151 let (initial, handshake) = split_datagram(&server_dgram2.unwrap());
1152 assert!(handshake.is_some());
1153
1154 // The same happens after a PTO.
1155 now += AT_LEAST_PTO;
1156 assert_eq!(client.stats().frame_tx.ack, 2);
1157 let discarded = client.stats().dropped_rx;
1158 let probe = client.process(Some(initial), now).dgram();
1159 assertions::assert_initial(&probe.unwrap(), false);
1160 assert_eq!(client.stats().frame_tx.ack, 3);
1161 assert_eq!(client.stats().dropped_rx, discarded);
1162
1163 // Pass the Handshake packet and complete the handshake.
1164 client.process_input(handshake.unwrap(), now);
1165 maybe_authenticate(&mut client);
1166 let dgram = client.process_output(now).dgram();
1167 let dgram = server.process(dgram, now).dgram();
1168 client.process_input(dgram.unwrap(), now);
1169
1170 assert_eq!(*client.state(), State::Confirmed);
1171 assert_eq!(*server.state(), State::Confirmed);
1172 }
1173
1174 // Collect a few spare Initial packets as the handshake is exchanged.
1175 // Later, replay those packets to see if they result in additional probes; they should not.
1176 #[test]
1177 fn no_extra_probes_after_confirmed() {
1178 let mut server = default_server();
1179 let mut client = default_client();
1180 let mut now = now();
1181
1182 // First, collect a client Initial.
1183 let spare_initial = client.process_output(now).dgram();
1184 let spare_initial2 = client.process_output(now).dgram();
1185 assert!(spare_initial.is_some() && spare_initial2.is_some());
1186
1187 // Collect ANOTHER client Initial.
1188 now += AT_LEAST_PTO;
1189 let dgram1 = client.process_output(now).dgram();
1190 _ = client.process_output(now).dgram();
1191 let (replay_initial, _) = split_datagram(dgram1.as_ref().unwrap());
1192
1193 // Finally, run the handshake.
1194 now += AT_LEAST_PTO * 2;
1195 let dgram = client.process_output(now).dgram();
1196 let dgram2 = client.process_output(now).dgram();
1197 server.process_input(dgram.unwrap(), now);
1198 let dgram = server.process(dgram2, now).dgram();
1199
1200 // The server should have dropped the Initial keys now, so passing in the Initial
1201 // should elicit a retransmit rather than having it completely ignored.
1202 let spare_handshake = server.process(Some(replay_initial), now).dgram();
1203 assert!(spare_handshake.is_some());
1204
1205 let dgram = client.process(dgram, now).dgram();
1206 let dgram = server.process(dgram, now).dgram();
1207 client.process_input(dgram.unwrap(), now);
1208 maybe_authenticate(&mut client);
1209 let dgram = client.process_output(now).dgram();
1210 let dgram = server.process(dgram, now).dgram();
1211 client.process_input(dgram.unwrap(), now);
1212
1213 assert_eq!(*client.state(), State::Confirmed);
1214 assert_eq!(*server.state(), State::Confirmed);
1215
1216 let probe = server.process(spare_initial, now).dgram();
1217 assert!(probe.is_none());
1218 let probe = client.process(spare_handshake, now).dgram();
1219 assert!(probe.is_none());
1220 }
1221
1222 #[test]
1223 fn implicit_rtt_server() {
1224 const RTT: Duration = Duration::from_secs(2);
1225 let mut server = default_server();
1226 let mut client = default_client();
1227 let mut now = now();
1228
1229 let dgram = client.process_output(now).dgram();
1230 let dgram2 = client.process_output(now).dgram();
1231 now += RTT / 2;
1232 server.process_input(dgram.unwrap(), now);
1233 let dgram = server.process(dgram2, now).dgram();
1234 now += RTT / 2;
1235 let dgram = client.process(dgram, now).dgram();
1236 now += RTT / 2;
1237 let dgram = server.process(dgram, now).dgram();
1238 now += RTT / 2;
1239 let dgram = client.process(dgram, now).dgram();
1240 let (initial, handshake) = split_datagram(dgram.as_ref().unwrap());
1241 assertions::assert_initial(&initial, false);
1242 assertions::assert_handshake(handshake.as_ref().unwrap());
1243 now += RTT / 2;
1244 server.process_input(dgram.unwrap(), now);
1245
1246 // The server doesn't receive any acknowledgments, but it can infer
1247 // an RTT estimate from having discarded the Initial packet number space.
1248 assert_eq!(server.stats().rtt, RTT);
1249 }
1250
1251 #[test]
1252 fn emit_authentication_needed_once() {
1253 let mut client = default_client();
1254
1255 let mut server = Connection::new_server(
1256 test_fixture::LONG_CERT_KEYS,
1257 test_fixture::DEFAULT_ALPN,
1258 Rc::new(RefCell::new(CountingConnectionIdGenerator::default())),
1259 // TODO: Why is this needed to avoind the 5ms pacing delay?
1260 ConnectionParameters::default().pacing(false),
1261 )
1262 .expect("create a server");
1263
1264 let client1 = client.process_output(now());
1265 let client2 = client.process_output(now());
1266 assert!(client1.as_dgram_ref().is_some() && client2.as_dgram_ref().is_some());
1267
1268 // The entire server flight doesn't fit in a single packet because the
1269 // certificate is large, therefore the server will produce 2 packets.
1270 _ = server.process(client1.dgram(), now());
1271 let server1 = server.process(client2.dgram(), now());
1272 assert!(server1.as_dgram_ref().is_some());
1273 let server2 = server.process_output(now());
1274 assert!(server2.as_dgram_ref().is_some());
1275 let server3 = server.process_output(now());
1276 assert!(server3.as_dgram_ref().is_some());
1277
1278 let authentication_needed_count = |client: &mut Connection| {
1279 client
1280 .events()
1281 .filter(|e| matches!(e, ConnectionEvent::AuthenticationNeeded))
1282 .count()
1283 };
1284
1285 // Upon receiving the first two packet, the client has the server certificate,
1286 // but not yet all required handshake data. It moves to
1287 // `HandshakeState::AuthenticationPending` and emits a
1288 // `ConnectionEvent::AuthenticationNeeded` event.
1289 //
1290 // Note that this is a tiny bit fragile in that it depends on having a certificate
1291 // that is within a fairly narrow range of sizes. It has to fit in a single
1292 // packet, but be large enough that the CertificateVerify message does not
1293 // also fit in the same packet. Our default test setup achieves this, but
1294 // changes to the setup might invalidate this test.
1295 _ = client.process(server1.dgram(), now());
1296 _ = client.process(server2.dgram(), now());
1297 assert_eq!(1, authentication_needed_count(&mut client));
1298 assert!(client.peer_certificate().is_some());
1299
1300 // The `AuthenticationNeeded` event is still pending a call to
1301 // `Connection::authenticated`. On receiving the second packet from the
1302 // server, the client must not emit a another
1303 // `ConnectionEvent::AuthenticationNeeded`.
1304 _ = client.process(server3.dgram(), now());
1305 assert_eq!(0, authentication_needed_count(&mut client));
1306 }
1307
1308 #[test]
1309 fn client_initial_retransmits_identical() {
1310 let mut now = now();
1311 // TODO: With pacing on, why does the delay callback return by 5ms and then PTO after 295ms?
1312 let mut client = new_client(ConnectionParameters::default().pacing(false));
1313
1314 // Force the client to retransmit its Initial flight a number of times and make sure the
1315 // retranmissions are identical to the original. Also, verify the PTO durations.
1316 for i in 1..=5 {
1317 let ci = client.process_output(now).dgram().unwrap();
1318 assert_eq!(ci.len(), client.plpmtu());
1319 let ci2 = client.process_output(now).dgram().unwrap();
1320 assert_eq!(ci2.len(), client.plpmtu());
1321 assert_eq!(
1322 client.stats().frame_tx,
1323 FrameStats {
1324 crypto: 3 * i,
1325 ..Default::default()
1326 }
1327 );
1328 let pto = client.process_output(now).callback();
1329 assert_eq!(pto, DEFAULT_RTT * 3 * (1 << (i - 1)));
1330 now += pto;
1331 }
1332 }
1333
1334 #[test]
1335 fn server_initial_retransmits_identical() {
1336 let mut now = now();
1337 let mut client = default_client();
1338 let mut ci = client.process_output(now).dgram();
1339 let mut ci2 = client.process_output(now).dgram();
1340
1341 // Force the server to retransmit its Initial flight a number of times and make sure the
1342 // retranmissions are identical to the original. Also, verify the PTO durations.
1343 let mut server = new_server(ConnectionParameters::default().pacing(false));
1344 let mut total_ptos = Duration::from_secs(0);
1345 for i in 1..=3 {
1346 _ = server.process(ci.take(), now);
1347 _ = server.process(ci2.take(), now);
1348 if i == 1 {
1349 // On the first iteration, the server will want to send its entire flight.
1350 // During later ones, we will have hit a PTO and can hence only send two packets.
1351 _ = server.process(ci2.take(), now);
1352 }
1353 assert_eq!(
1354 server.stats().frame_tx,
1355 FrameStats {
1356 crypto: i * 3,
1357 ack: i * 2 - i.saturating_sub(1),
1358 largest_acknowledged: (i - i.saturating_sub(1)) as u64,
1359 ..Default::default()
1360 }
1361 );
1362
1363 let pto = server.process_output(now).callback();
1364 now += pto;
1365 total_ptos += pto;
1366 }
1367
1368 // Server is amplification-limited now.
1369 let pto = server.process_output(now).callback();
1370 assert_eq!(pto, server.conn_params.get_idle_timeout() - total_ptos);
1371 }
1372
1373 #[test]
1374 fn grease_quic_bit_transport_parameter() {
1375 fn get_remote_tp(conn: &Connection) -> bool {
1376 conn.tps
1377 .borrow()
1378 .remote_handshake()
1379 .as_ref()
1380 .unwrap()
1381 .get_empty(GreaseQuicBit)
1382 }
1383
1384 for client_grease in [true, false] {
1385 for server_grease in [true, false] {
1386 let mut client = new_client(ConnectionParameters::default().grease(client_grease));
1387 let mut server = new_server(ConnectionParameters::default().grease(server_grease));
1388
1389 connect(&mut client, &mut server);
1390
1391 assert_eq!(client_grease, get_remote_tp(&server));
1392 assert_eq!(server_grease, get_remote_tp(&client));
1393 }
1394 }
1395 }
1396
1397 #[test]
1398 fn zero_rtt_with_ech() {
1399 let mut server = default_server();
1400 let (sk, pk) = generate_ech_keys().unwrap();
1401 server
1402 .server_enable_ech(ECH_CONFIG_ID, ECH_PUBLIC_NAME, &sk, &pk)
1403 .unwrap();
1404
1405 let mut client = default_client();
1406 client.client_enable_ech(server.ech_config()).unwrap();
1407
1408 connect(&mut client, &mut server);
1409
1410 assert!(client.tls_info().unwrap().ech_accepted());
1411 assert!(server.tls_info().unwrap().ech_accepted());
1412
1413 let token = exchange_ticket(&mut client, &mut server, now());
1414 let mut client = default_client();
1415 client.client_enable_ech(server.ech_config()).unwrap();
1416 client
1417 .enable_resumption(now(), token)
1418 .expect("should set token");
1419
1420 let mut server = resumed_server(&client);
1421 server
1422 .server_enable_ech(ECH_CONFIG_ID, ECH_PUBLIC_NAME, &sk, &pk)
1423 .unwrap();
1424
1425 connect(&mut client, &mut server);
1426 assert!(client.tls_info().unwrap().ech_accepted());
1427 assert!(server.tls_info().unwrap().ech_accepted());
1428 assert!(client.tls_info().unwrap().early_data_accepted());
1429 assert!(server.tls_info().unwrap().early_data_accepted());
1430 }