Debian Codegraph @

third_party/rust/neqo-transport/tests/server.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 mod common;
8
9 use std::{cell::RefCell, net::SocketAddr, rc::Rc, time::Duration};
10
11 use common::{connect, connected_server, default_server, find_ticket, generate_ticket, new_server};
12 use neqo_common::{qtrace, Datagram, Decoder, Encoder, Role};
13 use neqo_crypto::{
14 generate_ech_keys, AllowZeroRtt, AuthenticationStatus, ZeroRttCheckResult, ZeroRttChecker,
15 };
16 use neqo_transport::{
17 server::{ConnectionRef, Server, ValidateAddress},
18 version::WireVersion,
19 CloseReason, Connection, ConnectionParameters, Error, Output, State, StreamType, Version,
20 MIN_INITIAL_PACKET_SIZE,
21 };
22 use test_fixture::{
23 assertions, datagram, default_client,
24 header_protection::{
25 apply_header_protection, decode_initial_header, initial_aead_and_hp,
26 remove_header_protection,
27 },
28 new_client, now, split_datagram, CountingConnectionIdGenerator,
29 };
30
31 /// Take a pair of connections in any state and complete the handshake.
32 /// The `datagram` argument is a packet that was received from the server.
33 /// See `connect` for what this returns.
34 ///
35 /// # Panics
36 ///
37 /// Only when the connection fails.
38 pub fn complete_connection(
39 client: &mut Connection,
40 server: &mut Server,
41 mut datagram: Option<Datagram>,
42 ) -> ConnectionRef {
43 let is_done = |c: &Connection| {
44 matches!(
45 c.state(),
46 State::Confirmed | State::Closing { .. } | State::Closed(..)
47 )
48 };
49 while !is_done(client) {
50 _ = test_fixture::maybe_authenticate(client);
51 let out = client.process(datagram, now());
52 let out = server.process(out.dgram(), now());
53 datagram = out.dgram();
54 }
55
56 assert_eq!(*client.state(), State::Confirmed);
57 connected_server(server)
58 }
59
60 #[test]
61 fn single_client() {
62 let mut server = default_server();
63 let mut client = default_client();
64 connect(&mut client, &mut server);
65 }
66
67 #[test]
68 fn connect_single_version_both() {
69 fn connect_one_version(version: Version) {
70 let params = ConnectionParameters::default().versions(version, vec![version]);
71 let mut server = new_server(params.clone());
72
73 let mut client = new_client(params);
74 let server_conn = connect(&mut client, &mut server);
75 assert_eq!(client.version(), version);
76 assert_eq!(server_conn.borrow().version(), version);
77 }
78
79 for v in Version::all() {
80 println!("Connecting with {v:?}");
81 connect_one_version(v);
82 }
83 }
84
85 #[test]
86 fn connect_single_version_client() {
87 fn connect_one_version(version: Version) {
88 let mut server = default_server();
89
90 let mut client =
91 new_client(ConnectionParameters::default().versions(version, vec![version]));
92 let server_conn = connect(&mut client, &mut server);
93 assert_eq!(client.version(), version);
94 assert_eq!(server_conn.borrow().version(), version);
95 }
96
97 for v in Version::all() {
98 println!("Connecting with {v:?}");
99 connect_one_version(v);
100 }
101 }
102
103 #[test]
104 fn connect_single_version_server() {
105 fn connect_one_version(version: Version) {
106 let mut server =
107 new_server(ConnectionParameters::default().versions(version, vec![version]));
108
109 let mut client = default_client();
110
111 if client.version() != version {
112 // Run the version negotiation exchange if necessary.
113 let out = client.process_output(now());
114 assert!(out.as_dgram_ref().is_some());
115 let dgram = server.process(out.dgram(), now()).dgram();
116 assertions::assert_vn(dgram.as_ref().unwrap());
117 client.process_input(dgram.unwrap(), now());
118 }
119
120 let server_conn = connect(&mut client, &mut server);
121 assert_eq!(client.version(), version);
122 assert_eq!(server_conn.borrow().version(), version);
123 }
124
125 for v in Version::all() {
126 println!("Connecting with {v:?}");
127 connect_one_version(v);
128 }
129 }
130
131 #[test]
132 fn duplicate_initial() {
133 let mut server = default_server();
134 let mut client = default_client();
135
136 assert_eq!(*client.state(), State::Init);
137 let initial = client.process_output(now());
138 assert!(initial.as_dgram_ref().is_some());
139
140 // The server should ignore a packets with the same remote address and
141 // destination connection ID as an existing connection attempt.
142 let server_initial = server
143 .process(initial.as_dgram_ref().cloned(), now())
144 .dgram();
145 assert!(server_initial.is_some());
146 let dgram = server.process(initial.dgram(), now()).dgram();
147 assert!(dgram.is_none());
148
149 assert_eq!(server.active_connections().len(), 1);
150 complete_connection(&mut client, &mut server, server_initial);
151 }
152
153 #[test]
154 fn duplicate_initial_new_path() {
155 let mut server = default_server();
156 let mut client = default_client();
157
158 assert_eq!(*client.state(), State::Init);
159 let initial = client.process_output(now()).dgram().unwrap();
160 let other = Datagram::new(
161 SocketAddr::new(initial.source().ip(), initial.source().port() ^ 23),
162 initial.destination(),
163 initial.tos(),
164 &initial[..],
165 );
166
167 let server_initial = server.process(Some(initial), now()).dgram();
168 assert!(server_initial.is_some());
169
170 // The server should ignore a packet with the same destination connection ID.
171 let dgram = server.process(Some(other), now()).dgram();
172 assert!(dgram.is_none());
173
174 assert_eq!(server.active_connections().len(), 1);
175 complete_connection(&mut client, &mut server, server_initial);
176 }
177
178 #[test]
179 fn different_initials_same_path() {
180 let mut server = default_server();
181 let mut client1 = default_client();
182 let mut client2 = default_client();
183
184 let client_initial1 = client1.process_output(now());
185 assert!(client_initial1.as_dgram_ref().is_some());
186 let client_initial2 = client2.process_output(now());
187 assert!(client_initial2.as_dgram_ref().is_some());
188
189 // The server should respond to both as these came from different addresses.
190 let server_initial1 = server.process(client_initial1.dgram(), now()).dgram();
191 assert!(server_initial1.is_some());
192
193 let server_initial2 = server.process(client_initial2.dgram(), now()).dgram();
194 assert!(server_initial2.is_some());
195
196 assert_eq!(server.active_connections().len(), 2);
197 complete_connection(&mut client1, &mut server, server_initial1);
198 complete_connection(&mut client2, &mut server, server_initial2);
199 }
200
201 #[test]
202 fn same_initial_after_connected() {
203 let mut server = default_server();
204 let mut client = default_client();
205
206 let client_initial = client.process_output(now());
207 assert!(client_initial.as_dgram_ref().is_some());
208
209 let server_initial = server
210 .process(client_initial.as_dgram_ref().cloned(), now())
211 .dgram();
212 assert!(server_initial.is_some());
213 complete_connection(&mut client, &mut server, server_initial);
214 assert_eq!(server.active_connections().len(), 1);
215
216 // Now make a new connection using the exact same initial as before.
217 // The server should respond to an attempt to connect with the same Initial.
218 let dgram = server.process(client_initial.dgram(), now()).dgram();
219 assert!(dgram.is_some());
220 // The server should make a new connection object.
221 assert_eq!(server.active_connections().len(), 2);
222 }
223
224 #[test]
225 fn drop_non_initial() {
226 const CID: &[u8] = &[55; 8]; // not a real connection ID
227 let mut server = default_server();
228
229 // This is big enough to look like an Initial, but it uses the Retry type.
230 let mut header = Encoder::with_capacity(MIN_INITIAL_PACKET_SIZE);
231 header
232 .encode_byte(0xfa)
233 .encode_uint(4, Version::default().wire_version())
234 .encode_vec(1, CID)
235 .encode_vec(1, CID);
236 let mut bogus_data: Vec<u8> = header.into();
237 bogus_data.resize(MIN_INITIAL_PACKET_SIZE, 66);
238
239 let bogus = datagram(bogus_data);
240 assert!(server.process(Some(bogus), now()).dgram().is_none());
241 }
242
243 #[test]
244 fn drop_short_initial() {
245 const CID: &[u8] = &[55; 8]; // not a real connection ID
246 let mut server = default_server();
247
248 // This too small to be an Initial, but it is otherwise plausible.
249 let mut header = Encoder::with_capacity(1199);
250 header
251 .encode_byte(0xca)
252 .encode_uint(4, Version::default().wire_version())
253 .encode_vec(1, CID)
254 .encode_vec(1, CID);
255 let mut bogus_data: Vec<u8> = header.into();
256 bogus_data.resize(1199, 66);
257
258 let bogus = datagram(bogus_data);
259 assert!(server.process(Some(bogus), now()).dgram().is_none());
260 }
261
262 #[test]
263 fn drop_short_header_packet_for_unknown_connection() {
264 const CID: &[u8] = &[55; 8]; // not a real connection ID
265 let mut server = default_server();
266
267 let mut header = Encoder::with_capacity(MIN_INITIAL_PACKET_SIZE);
268 header
269 .encode_byte(0x40) // short header
270 .encode_vec(1, CID)
271 .encode_byte(1);
272 let mut bogus_data: Vec<u8> = header.into();
273 bogus_data.resize(MIN_INITIAL_PACKET_SIZE, 66);
274
275 let bogus = datagram(bogus_data);
276 assert!(server.process(Some(bogus), now()).dgram().is_none());
277 }
278
279 /// Verify that the server can read 0-RTT properly. A more robust server would buffer
280 /// 0-RTT before the handshake begins and let 0-RTT arrive for a short period after
281 /// the handshake completes, but ours is for testing so it only allows 0-RTT while
282 /// the handshake is running.
283 #[test]
284 fn zero_rtt() {
285 let mut server = default_server();
286 let token = generate_ticket(&mut server);
287
288 // Discharge the old connection so that we don't have to worry about it.
289 let mut now = now();
290 let t = server.process_output(now).callback();
291 now += t;
292 assert_eq!(server.process_output(now), Output::None);
293 assert_eq!(server.active_connections().len(), 0);
294
295 let start_time = now;
296 let mut client = default_client();
297 client.enable_resumption(now, &token).unwrap();
298
299 let mut client_send = || {
300 let client_stream = client.stream_create(StreamType::UniDi).unwrap();
301 client.stream_send(client_stream, &[1, 2, 3]).unwrap();
302 match client.process_output(now) {
303 Output::Datagram(d) => d,
304 Output::Callback(t) => {
305 // Pacing...
306 now += t;
307 client.process_output(now).dgram().unwrap()
308 }
309 Output::None => panic!(),
310 }
311 };
312
313 // Now generate a bunch of 0-RTT packets...
314 let c0 = client_send();
315 let c1 = client_send();
316 assertions::assert_coalesced_0rtt(&c1);
317 let c2 = client_send();
318 let c3 = client_send();
319 let c4 = client_send();
320
321 // 0-RTT packets that arrive before the handshake get dropped.
322 drop(server.process(Some(c2), now));
323 assert!(server.active_connections().is_empty());
324
325 // Now handshake and let another 0-RTT packet in.
326 _ = server.process(Some(c0), now);
327 let shs = server.process(Some(c1), now);
328 drop(server.process(Some(c3), now));
329 // The server will have received three STREAM frames now if it processed both packets.
330 #[expect(
331 clippy::mutable_key_type,
332 reason = "ActiveConnectionRef::Hash doesn't access any of the interior mutable types."
333 )]
334 let active = server.active_connections();
335 assert_eq!(active.len(), 1);
336 assert_eq!(
337 active
338 .iter()
339 .next()
340 .unwrap()
341 .borrow()
342 .stats()
343 .frame_rx
344 .stream,
345 3
346 );
347
348 // Complete the handshake. As the client was pacing 0-RTT packets, extend the time
349 // a little so that the pacer doesn't prevent the Finished from being sent.
350 now += now - start_time;
351 let cfin = client.process(shs.dgram(), now);
352 drop(server.process(cfin.dgram(), now));
353
354 // The server will drop this last 0-RTT packet.
355 drop(server.process(Some(c4), now));
356 #[expect(
357 clippy::mutable_key_type,
358 reason = "ActiveConnectionRef::Hash doesn't access any of the interior mutable types."
359 )]
360 let active = server.active_connections();
361 assert_eq!(active.len(), 1);
362 assert_eq!(
363 active
364 .iter()
365 .next()
366 .unwrap()
367 .borrow()
368 .stats()
369 .frame_rx
370 .stream,
371 4
372 );
373 }
374
375 #[test]
376 fn new_token_0rtt() {
377 let mut server = default_server();
378 let token = generate_ticket(&mut server);
379 server.set_validation(ValidateAddress::NoToken);
380
381 let mut client = default_client();
382 client.enable_resumption(now(), &token).unwrap();
383
384 let client_stream = client.stream_create(StreamType::UniDi).unwrap();
385 client.stream_send(client_stream, &[1, 2, 3]).unwrap();
386
387 let out = client.process_output(now());
388 let out2 = client.process_output(now()); // Initial w/0-RTT
389 assert!(out.as_dgram_ref().is_some() && out2.as_dgram_ref().is_some());
390 assertions::assert_initial(out.as_dgram_ref().unwrap(), true);
391 assertions::assert_coalesced_0rtt(out2.as_dgram_ref().unwrap());
392 _ = server.process(out.dgram(), now()); // Initial
393 let out = server.process(out2.dgram(), now()); // Initial
394 assert!(out.as_dgram_ref().is_some());
395 assertions::assert_initial(out.as_dgram_ref().unwrap(), false);
396
397 let dgram = client.process(out.as_dgram_ref().cloned(), now());
398 let dgram = server.process(dgram.as_dgram_ref().cloned(), now());
399 let dgram = client.process(dgram.as_dgram_ref().cloned(), now());
400 // Note: the client doesn't need to authenticate the server here
401 // as there is no certificate; authentication is based on the ticket.
402 assert!(out.as_dgram_ref().is_some());
403 assert_eq!(*client.state(), State::Connected);
404 let dgram = server.process(dgram.dgram(), now()); // (done)
405 assert!(dgram.as_dgram_ref().is_some());
406 connected_server(&server);
407 assert!(client.tls_info().unwrap().resumed());
408 }
409
410 #[test]
411 fn new_token_different_port() {
412 let mut server = default_server();
413 let token = generate_ticket(&mut server);
414 server.set_validation(ValidateAddress::NoToken);
415
416 let mut client = default_client();
417 client.enable_resumption(now(), &token).unwrap();
418
419 let dgram = client.process_output(now()).dgram(); // Initial
420 assert!(dgram.is_some());
421 assertions::assert_initial(dgram.as_ref().unwrap(), true);
422
423 // Now rewrite the source port, which should not change that the token is OK.
424 let d = dgram.unwrap();
425 let src = SocketAddr::new(d.source().ip(), d.source().port() + 1);
426 let dgram = Some(Datagram::new(src, d.destination(), d.tos(), &d[..]));
427 let dgram = server.process(dgram, now()).dgram(); // Retry
428 assert!(dgram.is_some());
429 assertions::assert_initial(dgram.as_ref().unwrap(), false);
430 }
431
432 #[test]
433 fn bad_client_initial() {
434 // This test needs to decrypt the CI, so turn off MLKEM.
435 let mut client = new_client(ConnectionParameters::default().mlkem(false));
436 let mut server = default_server();
437
438 let dgram = client.process_output(now()).dgram().expect("a datagram");
439 let (header, d_cid, s_cid, payload) = decode_initial_header(&dgram, Role::Client).unwrap();
440 let (aead, hp) = initial_aead_and_hp(d_cid, Role::Client);
441 let (fixed_header, pn) = remove_header_protection(&hp, header, payload);
442 let payload = &payload[(fixed_header.len() - header.len())..];
443
444 let mut plaintext_buf = vec![0; dgram.len()];
445 let plaintext = aead
446 .decrypt(pn, &fixed_header, payload, &mut plaintext_buf)
447 .unwrap();
448
449 let mut payload_enc = Encoder::from(plaintext);
450 payload_enc.encode(&[0x08, 0x02, 0x00, 0x00]); // Add a stream frame.
451
452 // Make a new header with a 1 byte packet number length.
453 let mut header_enc = Encoder::new();
454 header_enc
455 .encode_byte(0xc0) // Initial with 1 byte packet number.
456 .encode_uint(4, Version::default().wire_version())
457 .encode_vec(1, d_cid)
458 .encode_vec(1, s_cid)
459 .encode_vvec(&[])
460 .encode_varint(u64::try_from(payload_enc.len() + aead.expansion() + 1).unwrap())
461 .encode_byte(u8::try_from(pn).unwrap());
462
463 let mut ciphertext = header_enc.as_ref().to_vec();
464 ciphertext.resize(header_enc.len() + payload_enc.len() + aead.expansion(), 0);
465 let v = aead
466 .encrypt(
467 pn,
468 header_enc.as_ref(),
469 payload_enc.as_ref(),
470 &mut ciphertext[header_enc.len()..],
471 )
472 .unwrap();
473 assert_eq!(header_enc.len() + v.len(), ciphertext.len());
474 // Pad with zero to get up to MIN_INITIAL_PACKET_SIZE.
475 ciphertext.resize(MIN_INITIAL_PACKET_SIZE, 0);
476
477 apply_header_protection(
478 &hp,
479 &mut ciphertext,
480 (header_enc.len() - 1)..header_enc.len(),
481 );
482 let bad_dgram = Datagram::new(dgram.source(), dgram.destination(), dgram.tos(), ciphertext);
483
484 // The server should reject this.
485 let response = server.process(Some(bad_dgram), now());
486 let close_dgram = response.dgram().unwrap();
487 // The resulting datagram might contain multiple packets, but each is small.
488 let (initial_close, rest) = split_datagram(&close_dgram);
489 // Allow for large connection IDs and a 32 byte CONNECTION_CLOSE.
490 assert!(initial_close.len() <= 100);
491 let (handshake_close, short_close) = split_datagram(&rest.unwrap());
492 // The Handshake packet containing the close is the same size as the Initial,
493 // plus 1 byte for the Token field in the Initial.
494 assert_eq!(initial_close.len(), handshake_close.len() + 1);
495 assert!(short_close.unwrap().len() <= 73);
496
497 // The client should accept this new and stop trying to connect.
498 // It will generate a CONNECTION_CLOSE first though.
499 let response = client.process(Some(close_dgram), now()).dgram();
500 assert!(response.is_some());
501 // The client will now wait out its closing period.
502 let delay = client.process_output(now()).callback();
503 assert_ne!(delay, Duration::from_secs(0));
504 assert!(matches!(
505 *client.state(),
506 State::Draining { error: CloseReason::Transport(Error::PeerError(code)), .. } if code == Error::ProtocolViolation.code()
507 ));
508
509 #[expect(
510 clippy::iter_over_hash_type,
511 reason = "OK to loop over active connections in an undefined order."
512 )]
513 for server in server.active_connections() {
514 assert_eq!(
515 *server.borrow().state(),
516 State::Closed(CloseReason::Transport(Error::ProtocolViolation))
517 );
518 }
519
520 // After sending the CONNECTION_CLOSE, the server goes idle.
521 let res = server.process_output(now());
522 assert_eq!(res, Output::None);
523 }
524
525 #[test]
526 fn bad_client_initial_connection_close() {
527 let mut client = default_client();
528 let mut server = default_server();
529
530 let dgram = client.process_output(now()).dgram().expect("a datagram");
531 let (header, d_cid, s_cid, payload) = decode_initial_header(&dgram, Role::Client).unwrap();
532 let (aead, hp) = initial_aead_and_hp(d_cid, Role::Client);
533 let (_, pn) = remove_header_protection(&hp, header, payload);
534
535 let mut payload_enc = Encoder::with_capacity(MIN_INITIAL_PACKET_SIZE);
536 payload_enc.encode(&[0x1c, 0x01, 0x00, 0x00]); // Add a CONNECTION_CLOSE frame.
537
538 // Make a new header with a 1 byte packet number length.
539 let mut header_enc = Encoder::new();
540 header_enc
541 .encode_byte(0xc0) // Initial with 1 byte packet number.
542 .encode_uint(4, Version::default().wire_version())
543 .encode_vec(1, d_cid)
544 .encode_vec(1, s_cid)
545 .encode_vvec(&[])
546 .encode_varint(u64::try_from(payload_enc.len() + aead.expansion() + 1).unwrap())
547 .encode_byte(u8::try_from(pn).unwrap());
548
549 let mut ciphertext = header_enc.as_ref().to_vec();
550 ciphertext.resize(header_enc.len() + payload_enc.len() + aead.expansion(), 0);
551 let v = aead
552 .encrypt(
553 pn,
554 header_enc.as_ref(),
555 payload_enc.as_ref(),
556 &mut ciphertext[header_enc.len()..],
557 )
558 .unwrap();
559 assert_eq!(header_enc.len() + v.len(), ciphertext.len());
560 // Pad with zero to get up to MIN_INITIAL_PACKET_SIZE.
561 ciphertext.resize(MIN_INITIAL_PACKET_SIZE, 0);
562
563 apply_header_protection(
564 &hp,
565 &mut ciphertext,
566 (header_enc.len() - 1)..header_enc.len(),
567 );
568 let bad_dgram = Datagram::new(dgram.source(), dgram.destination(), dgram.tos(), ciphertext);
569
570 // The server should ignore this and go to Draining.
571 let mut now = now();
572 let response = server.process(Some(bad_dgram), now);
573 now += response.callback();
574 let response = server.process_output(now);
575 assert_eq!(response, Output::None);
576 }
577
578 #[test]
579 fn version_negotiation_ignored() {
580 let mut server = default_server();
581 let mut client = default_client();
582
583 // Any packet will do, but let's make something that looks real.
584 let dgram = client.process_output(now()).dgram().expect("a datagram");
585 _ = client.process_output(now()).dgram().expect("a datagram");
586 let mut input = dgram.to_vec();
587 input[1] ^= 0x12;
588 let damaged = Datagram::new(
589 dgram.source(),
590 dgram.destination(),
591 dgram.tos(),
592 input.clone(),
593 );
594 let vn = server.process(Some(damaged), now()).dgram();
595
596 let mut dec = Decoder::from(&input[5..]); // Skip past version.
597 let d_cid = dec.decode_vec(1).expect("client DCID").to_vec();
598 let s_cid = dec.decode_vec(1).expect("client SCID").to_vec();
599
600 // We should have received a VN packet.
601 let vn = vn.expect("a vn packet");
602 let mut dec = Decoder::from(&vn[1..]); // Skip first byte.
603
604 assert_eq!(dec.decode_uint::<u32>().expect("VN"), 0);
605 assert_eq!(dec.decode_vec(1).expect("VN DCID"), &s_cid[..]);
606 assert_eq!(dec.decode_vec(1).expect("VN SCID"), &d_cid[..]);
607 let mut found = false;
608 while dec.remaining() > 0 {
609 let v = dec.decode_uint::<WireVersion>().expect("supported version");
610 found |= v == Version::default().wire_version();
611 }
612 assert!(found, "valid version not found");
613
614 // Client ignores VN packet that contain negotiated version.
615 let res = client.process(Some(vn), now());
616 assert!(res.callback() > Duration::new(0, 120));
617 assert_eq!(client.state(), &State::WaitInitial);
618 }
619
620 /// Test that if the server doesn't support a version it will signal with a
621 /// Version Negotiation packet and the client will use that version.
622 #[test]
623 fn version_negotiation() {
624 const VN_VERSION: Version = Version::Draft29;
625 assert_ne!(VN_VERSION, Version::default());
626 assert!(!Version::default().is_compatible(VN_VERSION));
627
628 let mut server =
629 new_server(ConnectionParameters::default().versions(VN_VERSION, vec![VN_VERSION]));
630 let mut client = default_client();
631
632 // `connect()` runs a fixed exchange, so manually run the Version Negotiation.
633 let dgram = client.process_output(now()).dgram();
634 assert!(dgram.is_some());
635 let dgram = server.process(dgram, now()).dgram();
636 assertions::assert_vn(dgram.as_ref().unwrap());
637 client.process_input(dgram.unwrap(), now());
638
639 let sconn = connect(&mut client, &mut server);
640 assert_eq!(client.version(), VN_VERSION);
641 assert_eq!(sconn.borrow().version(), VN_VERSION);
642 }
643
644 /// Test that the client can pick a version from a Version Negotiation packet,
645 /// which is then subsequently upgraded to a compatible version by the server.
646 #[test]
647 fn version_negotiation_and_compatible() {
648 const ORIG_VERSION: Version = Version::Draft29;
649 const VN_VERSION: Version = Version::Version1;
650 const COMPAT_VERSION: Version = Version::Version2;
651 assert!(!ORIG_VERSION.is_compatible(VN_VERSION));
652 assert!(!ORIG_VERSION.is_compatible(COMPAT_VERSION));
653 assert!(VN_VERSION.is_compatible(COMPAT_VERSION));
654
655 let mut server = new_server(
656 ConnectionParameters::default().versions(VN_VERSION, vec![COMPAT_VERSION, VN_VERSION]),
657 );
658 // Note that the order of versions at the client only determines what it tries first.
659 // The server will pick between VN_VERSION and COMPAT_VERSION.
660 let mut client = new_client(
661 ConnectionParameters::default()
662 .versions(ORIG_VERSION, vec![ORIG_VERSION, VN_VERSION, COMPAT_VERSION]),
663 );
664
665 // Run the full exchange so that we can observe the versions in use.
666
667 // Version Negotiation
668 let dgram = client.process_output(now()).dgram();
669 let dgram2 = client.process_output(now()).dgram();
670 assert!(dgram.is_some() && dgram2.is_some());
671 assertions::assert_version(dgram.as_ref().unwrap(), ORIG_VERSION.wire_version());
672 _ = server.process(dgram, now()).dgram();
673 let dgram = server.process(dgram2, now()).dgram();
674 assertions::assert_vn(dgram.as_ref().unwrap());
675 client.process_input(dgram.unwrap(), now());
676
677 let dgram = client.process_output(now()).dgram(); // ClientHello
678 let dgram2 = client.process_output(now()).dgram(); // ClientHello
679 assertions::assert_version(dgram.as_ref().unwrap(), VN_VERSION.wire_version());
680 _ = server.process(dgram, now()).dgram(); // ServerHello...
681 let dgram = server.process(dgram2, now()).dgram(); // ServerHello...
682 assertions::assert_version(dgram.as_ref().unwrap(), COMPAT_VERSION.wire_version());
683 let dgram = client.process(dgram, now()).dgram();
684 let dgram = server.process(dgram, now()).dgram();
685 client.process_input(dgram.unwrap(), now());
686
687 client.authenticated(AuthenticationStatus::Ok, now());
688 let dgram = client.process_output(now()).dgram();
689 assertions::assert_version(dgram.as_ref().unwrap(), COMPAT_VERSION.wire_version());
690 assert_eq!(*client.state(), State::Connected);
691 let dgram = server.process(dgram, now()).dgram(); // ACK + HANDSHAKE_DONE + NST
692 client.process_input(dgram.unwrap(), now());
693 assert_eq!(*client.state(), State::Confirmed);
694
695 let sconn = connected_server(&server);
696 assert_eq!(client.version(), COMPAT_VERSION);
697 assert_eq!(sconn.borrow().version(), COMPAT_VERSION);
698 }
699
700 /// When a client resumes it remembers the version that the connection last used.
701 /// A subsequent connection will use that version, but if it then receives
702 /// a version negotiation packet, it should validate based on what it attempted
703 /// not what it was originally configured for.
704 #[test]
705 fn compatible_upgrade_resumption_and_vn() {
706 // Start at v1, compatible upgrade to v2.
707 const ORIG_VERSION: Version = Version::Version1;
708 const COMPAT_VERSION: Version = Version::Version2;
709 const RESUMPTION_VERSION: Version = Version::Draft29;
710
711 let client_params = ConnectionParameters::default().versions(
712 ORIG_VERSION,
713 vec![COMPAT_VERSION, ORIG_VERSION, RESUMPTION_VERSION],
714 );
715 let mut client = new_client(client_params.clone());
716 assert_eq!(client.version(), ORIG_VERSION);
717
718 let mut server = default_server();
719 let server_conn = connect(&mut client, &mut server);
720 assert_eq!(client.version(), COMPAT_VERSION);
721 assert_eq!(server_conn.borrow().version(), COMPAT_VERSION);
722
723 server_conn.borrow_mut().send_ticket(now(), &[]).unwrap();
724 let dgram = server.process_output(now()).dgram();
725 client.process_input(dgram.unwrap(), now()); // Consume ticket, ignore output.
726 let ticket = find_ticket(&mut client);
727
728 // This new server will reject the ticket, but it will also generate a VN packet.
729 let mut client = new_client(client_params);
730 let mut server = new_server(
731 ConnectionParameters::default().versions(RESUMPTION_VERSION, vec![RESUMPTION_VERSION]),
732 );
733 client.enable_resumption(now(), ticket).unwrap();
734
735 // The version negotiation exchange.
736 let dgram = client.process_output(now()).dgram();
737 assert!(dgram.is_some());
738 assertions::assert_version(dgram.as_ref().unwrap(), COMPAT_VERSION.wire_version());
739 let dgram = server.process(dgram, now()).dgram();
740 assertions::assert_vn(dgram.as_ref().unwrap());
741 client.process_input(dgram.unwrap(), now());
742
743 let server_conn = connect(&mut client, &mut server);
744 assert_eq!(client.version(), RESUMPTION_VERSION);
745 assert_eq!(server_conn.borrow().version(), RESUMPTION_VERSION);
746 }
747
748 #[test]
749 fn closed() {
750 // Let a server connection idle and it should be removed.
751 let mut server = default_server();
752 let mut client = default_client();
753 connect(&mut client, &mut server);
754
755 // The server will have sent a few things, so it will be on PTO.
756 let res = server.process_output(now());
757 assert!(res.callback() > Duration::new(0, 0));
758 // The client will be on the delayed ACK timer.
759 let res = client.process_output(now());
760 assert!(res.callback() > Duration::new(0, 0));
761
762 qtrace!("60s later");
763 let res = server.process_output(now() + Duration::from_secs(60));
764 assert_eq!(res, Output::None);
765 }
766
767 #[cfg(test)]
768 fn can_create_streams(c: &mut Connection, t: StreamType, n: u64) {
769 for _ in 0..n {
770 c.stream_create(t).unwrap();
771 }
772 assert_eq!(c.stream_create(t), Err(Error::StreamLimitError));
773 }
774
775 #[test]
776 fn max_streams() {
777 const MAX_STREAMS: u64 = 40;
778 let mut server = Server::new(
779 now(),
780 test_fixture::DEFAULT_KEYS,
781 test_fixture::DEFAULT_ALPN,
782 test_fixture::anti_replay(),
783 Box::new(AllowZeroRtt {}),
784 Rc::new(RefCell::new(CountingConnectionIdGenerator::default())),
785 ConnectionParameters::default()
786 .max_streams(StreamType::BiDi, MAX_STREAMS)
787 .max_streams(StreamType::UniDi, MAX_STREAMS),
788 )
789 .expect("should create a server");
790
791 let mut client = default_client();
792 connect(&mut client, &mut server);
793
794 // Make sure that we can create MAX_STREAMS uni- and bidirectional streams.
795 can_create_streams(&mut client, StreamType::UniDi, MAX_STREAMS);
796 can_create_streams(&mut client, StreamType::BiDi, MAX_STREAMS);
797 }
798
799 #[test]
800 fn max_streams_default() {
801 let mut server = Server::new(
802 now(),
803 test_fixture::DEFAULT_KEYS,
804 test_fixture::DEFAULT_ALPN,
805 test_fixture::anti_replay(),
806 Box::new(AllowZeroRtt {}),
807 Rc::new(RefCell::new(CountingConnectionIdGenerator::default())),
808 ConnectionParameters::default(),
809 )
810 .expect("should create a server");
811
812 let mut client = default_client();
813 connect(&mut client, &mut server);
814
815 // Make sure that we can create streams up to the local limit.
816 let local_limit_unidi = ConnectionParameters::default().get_max_streams(StreamType::UniDi);
817 can_create_streams(&mut client, StreamType::UniDi, local_limit_unidi);
818 let local_limit_bidi = ConnectionParameters::default().get_max_streams(StreamType::BiDi);
819 can_create_streams(&mut client, StreamType::BiDi, local_limit_bidi);
820 }
821
822 #[derive(Debug)]
823 struct RejectZeroRtt {}
824 impl ZeroRttChecker for RejectZeroRtt {
825 fn check(&self, _token: &[u8]) -> ZeroRttCheckResult {
826 ZeroRttCheckResult::Reject
827 }
828 }
829
830 #[test]
831 fn max_streams_after_0rtt_rejection() {
832 const MAX_STREAMS_BIDI: u64 = 40;
833 const MAX_STREAMS_UNIDI: u64 = 30;
834 let mut server = Server::new(
835 now(),
836 test_fixture::DEFAULT_KEYS,
837 test_fixture::DEFAULT_ALPN,
838 test_fixture::anti_replay(),
839 Box::new(RejectZeroRtt {}),
840 Rc::new(RefCell::new(CountingConnectionIdGenerator::default())),
841 ConnectionParameters::default()
842 .max_streams(StreamType::BiDi, MAX_STREAMS_BIDI)
843 .max_streams(StreamType::UniDi, MAX_STREAMS_UNIDI),
844 )
845 .expect("should create a server");
846 let token = generate_ticket(&mut server);
847
848 let mut client = default_client();
849 client.enable_resumption(now(), &token).unwrap();
850 _ = client.stream_create(StreamType::BiDi).unwrap();
851 let dgram = client.process_output(now()).dgram();
852 let dgram2 = client.process_output(now()).dgram();
853 _ = server.process(dgram, now()).dgram();
854 let dgram = server.process(dgram2, now()).dgram();
855 let dgram = client.process(dgram, now()).dgram();
856 let dgram = server.process(dgram, now()).dgram();
857 let dgram = client.process(dgram, now()).dgram();
858 assert!(dgram.is_some()); // We're far enough along to complete the test now.
859
860 // Make sure that we can create MAX_STREAMS uni- and bidirectional streams.
861 can_create_streams(&mut client, StreamType::UniDi, MAX_STREAMS_UNIDI);
862 can_create_streams(&mut client, StreamType::BiDi, MAX_STREAMS_BIDI);
863 }
864
865 #[test]
866 fn ech() {
867 // Check that ECH can be used.
868 let mut server = default_server();
869 let (sk, pk) = generate_ech_keys().unwrap();
870 server.enable_ech(0x4a, "public.example", &sk, &pk).unwrap();
871
872 let mut client = default_client();
873 client.client_enable_ech(server.ech_config()).unwrap();
874 let server_instance = connect(&mut client, &mut server);
875
876 assert!(client.tls_info().unwrap().ech_accepted());
877 assert!(server_instance.borrow().tls_info().unwrap().ech_accepted());
878 assert!(client.tls_preinfo().unwrap().ech_accepted().unwrap());
879 assert!(server_instance
880 .borrow()
881 .tls_preinfo()
882 .unwrap()
883 .ech_accepted()
884 .unwrap());
885 }
886
887 #[test]
888 fn has_active_connections() {
889 let mut server = default_server();
890 let mut client = default_client();
891
892 assert!(!server.has_active_connections());
893
894 let initial = client.process_output(now());
895 _ = server.process(initial.dgram(), now()).dgram();
896
897 assert!(server.has_active_connections());
898 }