Debian Codegraph @

third_party/rust/neqo-transport/src/connection/tests/zerortt.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::{cell::RefCell, rc::Rc, time::Duration};
8
9 use neqo_common::{event::Provider as _, qdebug};
10 use neqo_crypto::{AllowZeroRtt, AntiReplay};
11 use test_fixture::{assertions, now};
12
13 use super::{
14 super::Connection, connect, default_client, default_server, exchange_ticket, new_server,
15 resumed_server, CountingConnectionIdGenerator, Output,
16 };
17 use crate::{
18 events::ConnectionEvent, ConnectionParameters, Error, StreamType, Version,
19 MIN_INITIAL_PACKET_SIZE,
20 };
21
22 #[test]
23 fn zero_rtt_negotiate() {
24 // Note that the two servers in this test will get different anti-replay filters.
25 // That's OK because we aren't testing anti-replay.
26 let mut client = default_client();
27 let mut server = default_server();
28 connect(&mut client, &mut server);
29
30 let token = exchange_ticket(&mut client, &mut server, now());
31 let mut client = default_client();
32 client
33 .enable_resumption(now(), token)
34 .expect("should set token");
35 let mut server = resumed_server(&client);
36 connect(&mut client, &mut server);
37 assert!(client.tls_info().unwrap().early_data_accepted());
38 assert!(server.tls_info().unwrap().early_data_accepted());
39 }
40
41 #[test]
42 fn zero_rtt_send_recv() {
43 let mut client = default_client();
44 let mut server = default_server();
45 connect(&mut client, &mut server);
46
47 let token = exchange_ticket(&mut client, &mut server, now());
48 let mut client = default_client();
49 client
50 .enable_resumption(now(), token)
51 .expect("should set token");
52 let mut server = resumed_server(&client);
53
54 // Send ClientHello.
55 let client_hs = client.process_output(now());
56 let client_hs2 = client.process_output(now());
57 assert!(client_hs.as_dgram_ref().is_some() && client_hs2.as_dgram_ref().is_some());
58
59 // Wait
60 let delay = client.process_output(now()).callback();
61
62 // Now send a 0-RTT packet.
63 let client_stream_id = client.stream_create(StreamType::UniDi).unwrap();
64 client.stream_send(client_stream_id, &[1, 2, 3]).unwrap();
65 let client_0rtt = client.process_output(now() + delay);
66 assert!(client_0rtt.as_dgram_ref().is_some());
67 // 0-RTT packets on their own shouldn't be padded to MIN_INITIAL_PACKET_SIZE.
68 assert!(client_0rtt.as_dgram_ref().unwrap().len() < MIN_INITIAL_PACKET_SIZE);
69
70 server.process_input(client_hs.dgram().unwrap(), now());
71 let server_hs = server.process(client_hs2.dgram(), now());
72 assert!(server_hs.as_dgram_ref().is_some()); // ServerHello, etc...
73
74 let all_frames = server.stats().frame_tx.all();
75 let ack_frames = server.stats().frame_tx.ack;
76 let server_process_0rtt = server.process(client_0rtt.dgram(), now());
77 assert!(server_process_0rtt.dgram().is_some());
78 assert_eq!(server.stats().frame_tx.all(), all_frames + 3);
79 assert_eq!(server.stats().frame_tx.ack, ack_frames + 1);
80
81 let server_stream_id = server
82 .events()
83 .find_map(|evt| match evt {
84 ConnectionEvent::NewStream { stream_id, .. } => Some(stream_id),
85 _ => None,
86 })
87 .expect("should have received a new stream event");
88 assert_eq!(client_stream_id, server_stream_id.as_u64());
89 }
90
91 #[test]
92 fn zero_rtt_send_coalesce() {
93 let mut client = default_client();
94 let mut server = default_server();
95 connect(&mut client, &mut server);
96
97 let token = exchange_ticket(&mut client, &mut server, now());
98 let mut client = default_client();
99 client
100 .enable_resumption(now(), token)
101 .expect("should set token");
102 let mut server = resumed_server(&client);
103
104 // Write 0-RTT before generating any packets.
105 // This should result in a datagram that coalesces Initial and 0-RTT.
106 let client_stream_id = client.stream_create(StreamType::UniDi).unwrap();
107 client.stream_send(client_stream_id, &[1, 2, 3]).unwrap();
108 let client_init = client.process_output(now());
109 assert!(client_init.as_dgram_ref().is_some());
110 let client_0rtt = client.process_output(now());
111 assert!(client_0rtt.as_dgram_ref().is_some());
112
113 assertions::assert_coalesced_0rtt(&client_0rtt.as_dgram_ref().unwrap()[..]);
114
115 _ = server.process(client_init.dgram(), now());
116 let server_hs = server.process(client_0rtt.dgram(), now());
117 assert!(server_hs.as_dgram_ref().is_some()); // Should produce ServerHello etc...
118
119 let server_stream_id = server
120 .events()
121 .find_map(|evt| match evt {
122 ConnectionEvent::NewStream { stream_id } => Some(stream_id),
123 _ => None,
124 })
125 .expect("should have received a new stream event");
126 assert_eq!(client_stream_id, server_stream_id.as_u64());
127 }
128
129 #[test]
130 fn zero_rtt_before_resumption_token() {
131 let mut client = default_client();
132 assert!(client.stream_create(StreamType::BiDi).is_err());
133 }
134
135 #[test]
136 fn zero_rtt_send_reject() {
137 const MESSAGE: &[u8] = &[1, 2, 3];
138
139 let mut client = default_client();
140 let mut server = default_server();
141 connect(&mut client, &mut server);
142
143 let token = exchange_ticket(&mut client, &mut server, now());
144 let mut client = default_client();
145 client
146 .enable_resumption(now(), token)
147 .expect("should set token");
148 let mut server = Connection::new_server(
149 test_fixture::DEFAULT_KEYS,
150 test_fixture::DEFAULT_ALPN,
151 Rc::new(RefCell::new(CountingConnectionIdGenerator::default())),
152 ConnectionParameters::default().versions(client.version(), Version::all()),
153 )
154 .unwrap();
155 // Using a freshly initialized anti-replay context
156 // should result in the server rejecting 0-RTT.
157 let ar =
158 AntiReplay::new(now(), test_fixture::ANTI_REPLAY_WINDOW, 1, 3).expect("setup anti-replay");
159 server
160 .server_enable_0rtt(&ar, AllowZeroRtt {})
161 .expect("enable 0-RTT");
162
163 // Write some data on the client.
164 let stream_id = client.stream_create(StreamType::UniDi).unwrap();
165 client.stream_send(stream_id, MESSAGE).unwrap();
166
167 // Send ClientHello.
168 let client_hs = client.process_output(now());
169 assert!(client_hs.as_dgram_ref().is_some());
170
171 let client_0rtt = client.process_output(now());
172 assert!(client_0rtt.as_dgram_ref().is_some());
173
174 let server_hs = server.process(client_hs.dgram(), now());
175 assert!(server_hs.as_dgram_ref().is_some()); // Should produce ServerHello etc...
176 let server_hs2 = server.process(client_0rtt.dgram(), now());
177
178 // The server shouldn't receive that 0-RTT data.
179 let recvd_stream_evt = |e| matches!(e, ConnectionEvent::NewStream { .. });
180 assert!(!server.events().any(recvd_stream_evt));
181
182 _ = client.process(server_hs.dgram(), now());
183 let dgram = client.process(server_hs2.dgram(), now()).dgram();
184 let dgram = server.process(dgram, now()).dgram();
185
186 // Client should get a rejection.
187 let client_fin = client.process(dgram, now());
188 let recvd_0rtt_reject = |e| e == ConnectionEvent::ZeroRttRejected;
189 assert!(client.events().any(recvd_0rtt_reject));
190
191 // Server consume client_fin
192 let server_ack = server.process(client_fin.dgram(), now());
193 assert!(server_ack.as_dgram_ref().is_some());
194 let client_out = client.process(server_ack.dgram(), now());
195 assert!(client_out.as_dgram_ref().is_none());
196
197 // ...and the client stream should be gone.
198 let res = client.stream_send(stream_id, MESSAGE);
199 assert!(res.is_err());
200 assert_eq!(res.unwrap_err(), Error::InvalidStreamId);
201
202 // Open a new stream and send data. StreamId should start with 0.
203 let stream_id_after_reject = client.stream_create(StreamType::UniDi).unwrap();
204 assert_eq!(stream_id, stream_id_after_reject);
205 client.stream_send(stream_id_after_reject, MESSAGE).unwrap();
206 let client_after_reject = client.process_output(now()).dgram();
207 assert!(client_after_reject.is_some());
208
209 // The server should receive new stream
210 server.process_input(client_after_reject.unwrap(), now());
211 assert!(server.events().any(recvd_stream_evt));
212 }
213
214 #[test]
215 fn zero_rtt_update_flow_control() {
216 const LOW: u64 = 3;
217 const HIGH: u64 = 10;
218 #[expect(clippy::cast_possible_truncation, reason = "OK in a test.")]
219 const MESSAGE: &[u8] = &[0; HIGH as usize];
220
221 let mut client = default_client();
222 let mut server = new_server(
223 ConnectionParameters::default()
224 .max_stream_data(StreamType::UniDi, true, LOW)
225 .max_stream_data(StreamType::BiDi, true, LOW),
226 );
227 connect(&mut client, &mut server);
228
229 let token = exchange_ticket(&mut client, &mut server, now());
230 let mut client = default_client();
231 client
232 .enable_resumption(now(), token)
233 .expect("should set token");
234 let mut server = new_server(
235 ConnectionParameters::default()
236 .max_stream_data(StreamType::UniDi, true, HIGH)
237 .max_stream_data(StreamType::BiDi, true, HIGH)
238 .versions(client.version, Version::all()),
239 );
240
241 // Stream limits should be low for 0-RTT.
242 let client_hs = client.process_output(now()).dgram();
243 let client_hs2 = client.process_output(now()).dgram();
244 let uni_stream = client.stream_create(StreamType::UniDi).unwrap();
245 assert!(!client.stream_send_atomic(uni_stream, MESSAGE).unwrap());
246 let bidi_stream = client.stream_create(StreamType::BiDi).unwrap();
247 assert!(!client.stream_send_atomic(bidi_stream, MESSAGE).unwrap());
248
249 // Now get the server transport parameters.
250 server.process_input(client_hs.unwrap(), now());
251 let server_hs = server.process(client_hs2, now()).dgram();
252 let client_hs3 = client.process(server_hs, now()).dgram();
253 let server_hs2 = server.process(client_hs3, now()).dgram();
254 client.process_input(server_hs2.unwrap(), now());
255
256 // The streams should report a writeable event.
257 let mut uni_stream_event = false;
258 let mut bidi_stream_event = false;
259 for e in client.events() {
260 if let ConnectionEvent::SendStreamWritable { stream_id } = e {
261 if stream_id.is_uni() {
262 uni_stream_event = true;
263 } else {
264 bidi_stream_event = true;
265 }
266 }
267 }
268 assert!(uni_stream_event);
269 assert!(bidi_stream_event);
270 // But no MAX_STREAM_DATA frame was received.
271 assert_eq!(client.stats().frame_rx.max_stream_data, 0);
272
273 // And the new limit applies.
274 assert!(client.stream_send_atomic(uni_stream, MESSAGE).unwrap());
275 assert!(client.stream_send_atomic(bidi_stream, MESSAGE).unwrap());
276 }
277
278 #[test]
279 fn zero_rtt_loss_accepted() {
280 // This test requires a wider anti-replay window than other tests
281 // because the dropped 0-RTT packets add a bunch of delay.
282 const WINDOW: Duration = Duration::from_secs(20);
283 for i in 0..5 {
284 let mut client = default_client();
285 let mut server = default_server();
286 connect(&mut client, &mut server);
287
288 let mut now = now();
289 let earlier = now;
290
291 let token = exchange_ticket(&mut client, &mut server, now);
292
293 now += WINDOW;
294 let mut client = default_client();
295 client.enable_resumption(now, token).unwrap();
296 let mut server = resumed_server(&client);
297 let anti_replay = AntiReplay::new(earlier, WINDOW, 1, 3).unwrap();
298 server
299 .server_enable_0rtt(&anti_replay, AllowZeroRtt {})
300 .unwrap();
301
302 // Make CI/0-RTT
303 let client_stream_id = client.stream_create(StreamType::UniDi).unwrap();
304 client.stream_send(client_stream_id, &[1, 2, 3]).unwrap();
305 let mut ci = client.process_output(now);
306 assert!(ci.as_dgram_ref().is_some());
307 let mut c0rtt = client.process_output(now);
308 assert!(c0rtt.as_dgram_ref().is_some());
309 assertions::assert_coalesced_0rtt(&c0rtt.as_dgram_ref().unwrap()[..]);
310
311 // Drop CI/0-RTT a number of times
312 qdebug!("Drop CI/0-RTT {i} extra times");
313 for _ in 0..i {
314 now += client.process_output(now).callback();
315 ci = client.process_output(now);
316 assert!(ci.as_dgram_ref().is_some());
317 c0rtt = client.process_output(now);
318 assert!(c0rtt.as_dgram_ref().is_some());
319 }
320
321 // Process CI/0-RTT
322 server.process_input(ci.dgram().unwrap(), now);
323 let si = server.process(c0rtt.dgram(), now);
324 assert!(si.as_dgram_ref().is_some());
325
326 let server_stream_id = server
327 .events()
328 .find_map(|evt| match evt {
329 ConnectionEvent::NewStream { stream_id } => Some(stream_id),
330 _ => None,
331 })
332 .expect("should have received a new stream event");
333 assert_eq!(client_stream_id, server_stream_id.as_u64());
334
335 // 0-RTT should be accepted
336 client.process_input(si.dgram().unwrap(), now);
337 let recvd_0rtt_reject = |e| e == ConnectionEvent::ZeroRttRejected;
338 assert!(
339 !client.events().any(recvd_0rtt_reject),
340 "rejected 0-RTT after {i} extra dropped packets"
341 );
342 }
343 }
344
345 /// Before the first ACK within a packet space, there should be no time
346 /// threshold based loss detection:
347 ///
348 /// > Once a later packet within the same packet number space has been
349 /// > acknowledged, an endpoint SHOULD declare an earlier packet lost if it was
350 /// > sent a threshold amount of time in the past.
351 ///
352 /// <https://www.rfc-editor.org/rfc/rfc9002.html#section-6.1.2>
353 ///
354 /// Previously Neqo client would prematurely declare 0-RTT stream data frame as
355 /// lost based on time threshold.
356 ///
357 /// See <https://github.com/mozilla/neqo/issues/2476> for details.
358 #[test]
359 fn zero_rtt_no_time_threshold_loss_detection_before_first_ack() {
360 const RTT: Duration = Duration::from_millis(4);
361 let mut now = now();
362 let mut client = default_client();
363 let mut server = default_server();
364 connect(&mut client, &mut server);
365 let token = exchange_ticket(&mut client, &mut server, now);
366
367 let mut client = default_client();
368 client
369 .enable_resumption(now, token)
370 .expect("should set token");
371 let mut server = resumed_server(&client);
372
373 // Send ClientHello.
374 let client_hs = client.process_output(now);
375 let client_hs2 = client.process_output(now);
376 assert!(client_hs.as_dgram_ref().is_some() && client_hs2.as_dgram_ref().is_some());
377
378 // Attempt sending 0-RTT stream data.
379 let client_stream_id = client.stream_create(StreamType::UniDi).unwrap();
380 client.stream_send(client_stream_id, &[1, 2, 3]).unwrap();
381 // Blocked due to pacing.
382 let delay = client.process_output(now).callback();
383 // Wait for pacer, then send.
384 let client_0rtt = client.process_output(now + delay);
385 assert!(client_0rtt.as_dgram_ref().is_some());
386
387 now += RTT / 2;
388
389 // Receive ClientHello.
390 server.process_input(client_hs.dgram().unwrap(), now);
391 let server_hs = server.process(client_hs2.dgram(), now);
392 assert!(server_hs.as_dgram_ref().is_some()); // ServerHello, etc...
393
394 now += delay;
395
396 // Receive 0-RTT stream data.
397 let server_process_0rtt = server.process(client_0rtt.dgram(), now);
398 assert!(server_process_0rtt.as_dgram_ref().is_some());
399
400 let server_stream_id = server
401 .events()
402 .find_map(|evt| match evt {
403 ConnectionEvent::NewStream { stream_id, .. } => Some(stream_id),
404 _ => None,
405 })
406 .expect("should have received a new stream event");
407 assert_eq!(client_stream_id, server_stream_id.as_u64());
408
409 now += RTT / 2;
410
411 // Process Server packets. Note that this will not contain an ACK for the
412 // 0-RTT stream data, given that the server does not yet have 1-RTT keys and
413 // it will delay the ACK.
414 let _client_pkt1 = client.process(server_hs.dgram(), now);
415 let _client_pkt2 = client.process(server_process_0rtt.dgram(), now);
416 assert!(matches!(client.process_output(now), Output::Callback(_)));
417
418 // Progress time by half an RTT. Thus ~1.5 RTT have elapsed since the client
419 // sent the 0-RTT application data. ~1.5 RTT is past the time threshold
420 // based loss detection (~ 9/8 RTT).
421 now += RTT / 2;
422
423 // Despite the missing ACK from the server, expect client to neither declare
424 // 0-RTT stream data lost, nor attempt to retransmit it. Given that thus far
425 // no Application space ACK has been received, time threshold based loss
426 // detection does not yet apply.
427 assert!(client.process_output(now).dgram().is_none());
428 assert_eq!(client.stats().lost, 0);
429 }