Debian Codegraph @

third_party/rust/neqo-transport/tests/retry.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 #![cfg(not(feature = "disable-encryption"))]
8
9 mod common;
10
11 use std::{
12 net::{IpAddr, Ipv4Addr, SocketAddr},
13 time::Duration,
14 };
15
16 use common::{assert_dscp, connected_server, default_server, generate_ticket};
17 use neqo_common::{hex_with_len, qdebug, qtrace, Datagram, Encoder, Role};
18 use neqo_crypto::AuthenticationStatus;
19 use neqo_transport::{
20 server::ValidateAddress, CloseReason, ConnectionParameters, Error, State, StreamType,
21 MIN_INITIAL_PACKET_SIZE,
22 };
23 use test_fixture::{
24 assertions, datagram, default_client,
25 header_protection::{
26 apply_header_protection, decode_initial_header, initial_aead_and_hp,
27 remove_header_protection,
28 },
29 now, split_datagram,
30 };
31
32 #[test]
33 fn retry_basic() {
34 let mut server = default_server();
35 server.set_validation(ValidateAddress::Always);
36 let mut client = default_client();
37
38 let dgram = client.process_output(now()).dgram(); // Initial
39 let dgram2 = client.process_output(now()).dgram(); // Initial
40 assert!(dgram.is_some() && dgram2.is_some());
41 _ = server.process(dgram, now()).dgram().unwrap(); // Retry
42 let dgram = server.process(dgram2, now()).dgram().unwrap(); // Retry
43 assertions::assert_retry(&dgram);
44
45 let dgram = client.process(Some(dgram), now()).dgram(); // Initial w/token
46 let dgram2 = client.process_output(now()).dgram(); // Initial
47 assert!(dgram.is_some() && dgram2.is_some());
48 _ = server.process(dgram, now()).dgram().unwrap();
49 let dgram = server.process(dgram2, now()).dgram();
50 let dgram = client.process(dgram, now()).dgram();
51 let dgram = server.process(dgram, now()).dgram(); // Initial, HS
52 assert!(dgram.is_some());
53 drop(client.process(dgram, now()).dgram()); // Ingest, drop any ACK.
54 client.authenticated(AuthenticationStatus::Ok, now());
55 let dgram = client.process_output(now()).dgram(); // Send Finished
56 assert!(dgram.is_some());
57 assert_eq!(*client.state(), State::Connected);
58 let dgram = server.process(dgram, now()).dgram(); // (done)
59 assert!(dgram.is_some()); // Note that this packet will be dropped...
60 connected_server(&server);
61 assert_dscp(&client.stats());
62 }
63
64 /// Receiving a Retry is enough to infer something about the RTT.
65 /// Probably.
66 #[test]
67 fn implicit_rtt_retry() {
68 const RTT: Duration = Duration::from_secs(2);
69 let mut server = default_server();
70 server.set_validation(ValidateAddress::Always);
71 let mut client = default_client();
72 let mut now = now();
73
74 let dgram = client.process_output(now).dgram();
75 now += RTT / 2;
76 let dgram = server.process(dgram, now).dgram();
77 assertions::assert_retry(dgram.as_ref().unwrap());
78 now += RTT / 2;
79 client.process_input(dgram.unwrap(), now);
80
81 assert_eq!(client.stats().rtt, RTT);
82 assert_dscp(&client.stats());
83 }
84
85 #[test]
86 fn retry_expired() {
87 let mut server = default_server();
88 server.set_validation(ValidateAddress::Always);
89 let mut client = default_client();
90 let mut now = now();
91
92 let dgram = client.process_output(now).dgram(); // Initial
93 assert!(dgram.is_some());
94 let dgram = server.process(dgram, now).dgram(); // Retry
95 assert!(dgram.is_some());
96
97 assertions::assert_retry(dgram.as_ref().unwrap());
98
99 let dgram = client.process(dgram, now).dgram(); // Initial w/token
100 assert!(dgram.is_some());
101
102 now += Duration::from_secs(60); // Too long for Retry.
103 let dgram = server.process(dgram, now).dgram(); // Initial, HS
104 assert!(dgram.is_none());
105 assert_dscp(&client.stats());
106 }
107
108 // Attempt a retry with 0-RTT, and have 0-RTT packets sent with the second ClientHello.
109 #[test]
110 fn retry_0rtt() {
111 let mut server = default_server();
112 let token = generate_ticket(&mut server);
113 server.set_validation(ValidateAddress::Always);
114
115 let mut client = default_client();
116 client.enable_resumption(now(), &token).unwrap();
117
118 let client_stream = client.stream_create(StreamType::UniDi).unwrap();
119 client.stream_send(client_stream, &[1, 2, 3]).unwrap();
120
121 let dgram = client.process_output(now()).dgram(); // Initial
122 let dgram2 = client.process_output(now()).dgram(); // Initial w/0-RTT
123 assert!(dgram.is_some() && dgram2.is_some());
124 assertions::assert_coalesced_0rtt(dgram2.as_ref().unwrap());
125 _ = server.process(dgram, now()).dgram(); // Retry
126 let dgram = server.process(dgram2, now()).dgram(); // Retry
127 assert!(dgram.is_some());
128 assertions::assert_retry(dgram.as_ref().unwrap());
129
130 // After retry, there should be a token and still coalesced 0-RTT.
131 let dgram = client.process(dgram, now()).dgram(); // Initial
132 let dgram2 = client.process_output(now()).dgram(); // Initial w/0-RTT
133 assert!(dgram.is_some() && dgram2.is_some());
134 assertions::assert_coalesced_0rtt(dgram2.as_ref().unwrap());
135
136 _ = server.process(dgram, now()).dgram(); // ACK
137 let dgram = server.process(dgram2, now()).dgram(); // Initial, HS
138 assert!(dgram.is_some());
139 let dgram = client.process(dgram, now()).dgram();
140 let dgram = server.process(dgram, now()).dgram();
141 let dgram = client.process(dgram, now()).dgram();
142 // Note: the client doesn't need to authenticate the server here
143 // as there is no certificate; authentication is based on the ticket.
144 assert!(dgram.is_some());
145 assert_eq!(*client.state(), State::Connected);
146 let dgram = server.process(dgram, now()).dgram(); // (done)
147 assert!(dgram.is_some());
148 connected_server(&server);
149 assert!(client.tls_info().unwrap().resumed());
150 assert_dscp(&client.stats());
151 }
152
153 #[test]
154 fn retry_different_ip() {
155 let mut server = default_server();
156 server.set_validation(ValidateAddress::Always);
157 let mut client = default_client();
158
159 let dgram = client.process_output(now()).dgram(); // Initial
160 assert!(dgram.is_some());
161 let dgram = server.process(dgram, now()).dgram(); // Retry
162 assert!(dgram.is_some());
163
164 assertions::assert_retry(dgram.as_ref().unwrap());
165
166 let dgram = client.process(dgram, now()).dgram(); // Initial w/token
167 assert!(dgram.is_some());
168
169 // Change the source IP on the address from the client.
170 let dgram = dgram.unwrap();
171 let other_v4 = IpAddr::V4(Ipv4Addr::new(127, 0, 0, 2));
172 let other_addr = SocketAddr::new(other_v4, 443);
173 let from_other = Datagram::new(other_addr, dgram.destination(), dgram.tos(), &dgram[..]);
174 let dgram = server.process(Some(from_other), now()).dgram();
175 assert!(dgram.is_none());
176 assert_dscp(&client.stats());
177 }
178
179 #[test]
180 fn new_token_different_ip() {
181 let mut server = default_server();
182 let token = generate_ticket(&mut server);
183 server.set_validation(ValidateAddress::NoToken);
184
185 let mut client = default_client();
186 client.enable_resumption(now(), &token).unwrap();
187
188 let dgram = client.process_output(now()).dgram(); // Initial
189 assert!(dgram.is_some());
190 assertions::assert_initial(dgram.as_ref().unwrap(), true);
191
192 // Now rewrite the source address.
193 let d = dgram.unwrap();
194 let src = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 2)), d.source().port());
195 let dgram = Some(Datagram::new(src, d.destination(), d.tos(), &d[..]));
196 let dgram = server.process(dgram, now()).dgram(); // Retry
197 assert!(dgram.is_some());
198 assertions::assert_retry(dgram.as_ref().unwrap());
199 assert_dscp(&client.stats());
200 }
201
202 #[test]
203 fn new_token_expired() {
204 let mut server = default_server();
205 let token = generate_ticket(&mut server);
206 server.set_validation(ValidateAddress::NoToken);
207
208 let mut client = default_client();
209 client.enable_resumption(now(), &token).unwrap();
210
211 let dgram = client.process_output(now()).dgram(); // Initial
212 assert!(dgram.is_some());
213 assertions::assert_initial(dgram.as_ref().unwrap(), true);
214
215 // Now move into the future.
216 // We can't go too far or we'll overflow our field. Not when checking,
217 // but when trying to generate another Retry. A month is fine.
218 let the_future = now() + Duration::from_secs(60 * 60 * 24 * 30);
219 let d = dgram.unwrap();
220 let src = SocketAddr::new(d.source().ip(), d.source().port() + 1);
221 let dgram = Some(Datagram::new(src, d.destination(), d.tos(), &d[..]));
222 let dgram = server.process(dgram, the_future).dgram(); // Retry
223 assert!(dgram.is_some());
224 assertions::assert_retry(dgram.as_ref().unwrap());
225 assert_dscp(&client.stats());
226 }
227
228 #[test]
229 fn retry_after_initial() {
230 let mut server = default_server();
231 let mut retry_server = default_server();
232 retry_server.set_validation(ValidateAddress::Always);
233 let mut client = default_client();
234
235 let cinit = client.process_output(now()).dgram(); // Initial
236 let cinit2 = client.process_output(now()).dgram(); // Initial
237 assert!(cinit.is_some() && cinit2.is_some());
238 _ = server.process(cinit.clone(), now()).dgram(); // Initial
239 let server_flight = server.process(cinit2, now()).dgram(); // Initial
240 assert!(server_flight.is_some());
241
242 let dgram = client.process(server_flight, now()).dgram();
243 let server_flight = server.process(dgram, now()).dgram();
244
245 // We need to have the client just process the Initial.
246 let (server_initial, _other) = split_datagram(server_flight.as_ref().unwrap());
247 let dgram = client.process(Some(server_initial), now()).dgram();
248 assert!(dgram.is_some());
249 assert!(*client.state() != State::Connected);
250
251 let retry = retry_server.process(cinit, now()).dgram(); // Retry!
252 assert!(retry.is_some());
253 assertions::assert_retry(retry.as_ref().unwrap());
254
255 // The client should ignore the retry.
256 let junk = client.process(retry, now()).dgram();
257 assert!(junk.is_none());
258
259 // Either way, the client should still be able to process the server flight and connect.
260 let dgram = client.process(server_flight, now()).dgram();
261 assert!(dgram.is_some()); // Drop this one.
262 assert!(test_fixture::maybe_authenticate(&mut client));
263 let dgram = server.process(dgram, now()).dgram();
264 let dgram = client.process(dgram, now()).dgram();
265 assert!(dgram.is_some());
266
267 assert_eq!(*client.state(), State::Connected);
268 let dgram = server.process(dgram, now()).dgram(); // (done)
269 assert!(dgram.is_some());
270 connected_server(&server);
271 assert_dscp(&client.stats());
272 }
273
274 #[test]
275 fn retry_bad_integrity() {
276 let mut server = default_server();
277 server.set_validation(ValidateAddress::Always);
278 let mut client = default_client();
279
280 let dgram = client.process_output(now()).dgram(); // Initial
281 let dgram2 = client.process_output(now()).dgram(); // Initial
282 assert!(dgram.is_some() && dgram2.is_some());
283 _ = server.process(dgram, now()).dgram(); // Retry
284 let dgram = server.process(dgram2, now()).dgram(); // Retry
285 assert!(dgram.is_some());
286
287 let retry = &dgram.as_ref().unwrap();
288 assertions::assert_retry(retry);
289
290 let mut tweaked = retry.to_vec();
291 tweaked[retry.len() - 1] ^= 0x45; // damage the auth tag
292 let tweaked_packet = Datagram::new(retry.source(), retry.destination(), retry.tos(), tweaked);
293
294 // The client should ignore this packet.
295 let dgram = client.process(Some(tweaked_packet), now()).dgram();
296 assert!(dgram.is_none());
297 assert_dscp(&client.stats());
298 }
299
300 #[test]
301 fn retry_bad_token() {
302 let mut client = default_client();
303 let mut retry_server = default_server();
304 retry_server.set_validation(ValidateAddress::Always);
305 let mut server = default_server();
306
307 // Send a retry to one server, then replay it to the other.
308 let client_initial1 = client.process_output(now()).dgram();
309 assert!(client_initial1.is_some());
310 let retry = retry_server.process(client_initial1, now()).dgram();
311 assert!(retry.is_some());
312 let client_initial2 = client.process(retry, now()).dgram();
313 assert!(client_initial2.is_some());
314
315 let dgram = server.process(client_initial2, now()).dgram();
316 assert!(dgram.is_none());
317 assert_dscp(&client.stats());
318 }
319
320 // This is really a client test, but we need a server with Retry to test it.
321 // In this test, the client sends Initial on PTO. The Retry should cause
322 // all loss recovery timers to be reset, but we had a bug where the PTO timer
323 // was not properly reset. This tests that the client generates a new Initial
324 // in response to receiving a Retry, even after it sends the Initial on PTO.
325 #[test]
326 fn retry_after_pto() {
327 let mut client = default_client();
328 let mut server = default_server();
329 server.set_validation(ValidateAddress::Always);
330 let mut now = now();
331
332 let ci = client.process_output(now).dgram();
333 let ci2 = client.process_output(now).dgram();
334 assert!(ci.is_some() && ci2.is_some()); // sit on this for a bit
335
336 // Let PTO fire on the client and then let it exhaust its PTO packets.
337 now += Duration::from_secs(1);
338 let pto = client.process_output(now).dgram();
339 assert!(pto.unwrap().len() >= MIN_INITIAL_PACKET_SIZE);
340 _ = client.process_output(now).dgram();
341 let cb = client.process_output(now).callback();
342 assert_ne!(cb, Duration::new(0, 0));
343
344 _ = server.process(ci, now).dgram();
345 let retry = server.process(ci2, now).dgram();
346 assertions::assert_retry(retry.as_ref().unwrap());
347
348 let ci2 = client.process(retry, now).dgram();
349 assert!(ci2.unwrap().len() >= MIN_INITIAL_PACKET_SIZE);
350 assert_dscp(&client.stats());
351 }
352
353 #[test]
354 fn vn_after_retry() {
355 let mut server = default_server();
356 server.set_validation(ValidateAddress::Always);
357 let mut client = default_client();
358
359 let dgram = client.process_output(now()).dgram(); // Initial
360 let dgram2 = client.process_output(now()).dgram(); // Initial
361 assert!(dgram.is_some() && dgram2.is_some());
362 _ = server.process(dgram, now()).dgram(); // Retry
363 let dgram = server.process(dgram2, now()).dgram(); // Retry
364 assert!(dgram.is_some());
365
366 assertions::assert_retry(dgram.as_ref().unwrap());
367
368 let dgram = client.process(dgram, now()).dgram(); // Initial w/token
369 assert!(dgram.is_some());
370 let dgram = server.process(dgram, now()).dgram();
371 _ = client.process(dgram, now()).dgram();
372
373 let mut encoder = Encoder::default();
374 encoder.encode_byte(0x80);
375 encoder.encode(&[0; 4]); // Zero version == VN.
376 encoder.encode_vec(1, &client.odcid().unwrap()[..]);
377 encoder.encode_vec(1, &[]);
378 encoder.encode_uint(4, 0x5a5a_6a6a_u64);
379 let vn = datagram(encoder.into());
380
381 assert_ne!(
382 client.process(Some(vn), now()).callback(),
383 Duration::from_secs(0)
384 );
385 assert_dscp(&client.stats());
386 }
387
388 // This tests a simulated on-path attacker that intercepts the first
389 // client Initial packet and spoofs a retry.
390 // The tricky part is in rewriting the second client Initial so that
391 // the server doesn't reject the Initial for having a bad token.
392 // The client is the only one that can detect this, and that is because
393 // the original connection ID is not in transport parameters.
394 //
395 // Note that this depends on having the server produce a CID that is
396 // at least 8 bytes long. Otherwise, the second Initial won't have a
397 // long enough connection ID.
398 #[test]
399 fn mitm_retry() {
400 // This test decrypts packets and hence does not work with MLKEM enabled.
401 let mut client = test_fixture::new_client(ConnectionParameters::default().mlkem(false));
402 let mut retry_server = default_server();
403 retry_server.set_validation(ValidateAddress::Always);
404 let mut server = default_server();
405
406 // Trigger initial and a second client Initial.
407 let client_initial1 = client.process_output(now()).dgram();
408 assert!(client_initial1.is_some());
409 let retry = retry_server.process(client_initial1, now()).dgram();
410 assert!(retry.is_some());
411 let client_initial2 = client.process(retry, now()).dgram();
412 assert!(client_initial2.is_some());
413
414 // Now to start the epic process of decrypting the packet,
415 // rewriting the header to remove the token, and then re-encrypting.
416 let client_initial2 = client_initial2.unwrap();
417 let (protected_header, d_cid, s_cid, payload) =
418 decode_initial_header(&client_initial2, Role::Client).unwrap();
419
420 // Now we have enough information to make keys.
421 let (aead, hp) = initial_aead_and_hp(d_cid, Role::Client);
422 let (header, pn) = remove_header_protection(&hp, protected_header, payload);
423 let pn_len = header.len() - protected_header.len();
424
425 // Decrypt.
426 assert_eq!(pn, 1);
427 let mut plaintext_buf = vec![0; client_initial2.len()];
428 let plaintext = aead
429 .decrypt(pn, &header, &payload[pn_len..], &mut plaintext_buf)
430 .unwrap();
431
432 // Now re-encode without the token.
433 let mut enc = Encoder::with_capacity(header.len());
434 enc.encode(&header[..5])
435 .encode_vec(1, d_cid)
436 .encode_vec(1, s_cid)
437 .encode_vvec(&[])
438 .encode_varint(u64::try_from(payload.len()).unwrap());
439 let pn_offset = enc.len();
440 let notoken_header = enc.encode_uint(pn_len, pn).as_ref().to_vec();
441 qtrace!("notoken_header={}", hex_with_len(&notoken_header));
442
443 // Encrypt.
444 let mut notoken_packet = Encoder::with_capacity(MIN_INITIAL_PACKET_SIZE)
445 .encode(&notoken_header)
446 .as_ref()
447 .to_vec();
448 notoken_packet.resize_with(MIN_INITIAL_PACKET_SIZE, u8::default);
449 aead.encrypt(
450 pn,
451 &notoken_header,
452 plaintext,
453 &mut notoken_packet[notoken_header.len()..],
454 )
455 .unwrap();
456 // Unlike with decryption, don't truncate.
457 // All MIN_INITIAL_PACKET_SIZE bytes are needed to reach the minimum datagram size.
458
459 apply_header_protection(&hp, &mut notoken_packet, pn_offset..(pn_offset + pn_len));
460 qtrace!("packet={}", hex_with_len(&notoken_packet));
461
462 let new_datagram = Datagram::new(
463 client_initial2.source(),
464 client_initial2.destination(),
465 client_initial2.tos(),
466 notoken_packet,
467 );
468 qdebug!("passing modified Initial to the main server");
469 let dgram = server.process(Some(new_datagram), now()).dgram();
470 assert!(dgram.is_some());
471
472 let dgram = client.process(dgram, now()).dgram(); // Generate an ACK.
473 assert!(dgram.is_some());
474 let dgram = server.process(dgram, now()).dgram();
475 assert!(dgram.is_none());
476 assert!(test_fixture::maybe_authenticate(&mut client));
477 let dgram = client.process(dgram, now()).dgram();
478 assert!(dgram.is_some()); // Client sending CLOSE_CONNECTIONs
479 assert!(matches!(
480 *client.state(),
481 State::Closing {
482 error: CloseReason::Transport(Error::ProtocolViolation),
483 ..
484 }
485 ));
486 assert_dscp(&client.stats());
487 }