Debian Codegraph @

third_party/rust/neqo-transport/src/connection/tests/resumption.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::{Datagram, Decoder, Role};
10 use neqo_crypto::AuthenticationStatus;
11 use test_fixture::{
12 assertions,
13 header_protection::{
14 apply_header_protection, decode_initial_header, initial_aead_and_hp,
15 remove_header_protection,
16 },
17 now, split_datagram,
18 };
19
20 use super::{
21 connect, connect_with_rtt, default_client, default_server, exchange_ticket, get_tokens,
22 new_client, resumed_server, send_something, AT_LEAST_PTO,
23 };
24 use crate::{
25 addr_valid::{AddressValidation, ValidateAddress},
26 frame::FrameType,
27 rtt::INITIAL_RTT,
28 ConnectionParameters, Error, State, Version, MIN_INITIAL_PACKET_SIZE,
29 };
30
31 #[test]
32 fn resume() {
33 let mut client = default_client();
34 let mut server = default_server();
35 connect(&mut client, &mut server);
36
37 let token = exchange_ticket(&mut client, &mut server, now());
38 let mut client = default_client();
39 client
40 .enable_resumption(now(), token)
41 .expect("should set token");
42 let mut server = resumed_server(&client);
43 connect(&mut client, &mut server);
44 assert!(client.tls_info().unwrap().resumed());
45 assert!(server.tls_info().unwrap().resumed());
46 }
47
48 #[test]
49 fn remember_smoothed_rtt() {
50 const RTT1: Duration = Duration::from_millis(130);
51 const RTT2: Duration = Duration::from_millis(70);
52
53 let mut client = default_client();
54 let mut server = default_server();
55
56 let mut now = connect_with_rtt(&mut client, &mut server, now(), RTT1);
57 assert_eq!(client.paths.rtt(), RTT1);
58
59 // We can't use exchange_ticket here because it doesn't respect RTT.
60 // Also, connect_with_rtt() ends with the server receiving a packet it
61 // wants to acknowledge; so the ticket will include an ACK frame too.
62 let validation = AddressValidation::new(now, ValidateAddress::NoToken).unwrap();
63 let validation = Rc::new(RefCell::new(validation));
64 server.set_validation(&validation);
65 server.send_ticket(now, &[]).expect("can send ticket");
66 let ticket = server.process_output(now).dgram();
67 assert!(ticket.is_some());
68 now += RTT1 / 2;
69 client.process_input(ticket.unwrap(), now);
70 let token = get_tokens(&mut client).pop().unwrap();
71
72 let mut client = default_client();
73 client.enable_resumption(now, token).unwrap();
74 assert_eq!(
75 client.paths.rtt(),
76 RTT1,
77 "client should remember previous RTT"
78 );
79 let mut server = resumed_server(&client);
80
81 connect_with_rtt(&mut client, &mut server, now, RTT2);
82 assert_eq!(
83 client.paths.rtt(),
84 RTT2,
85 "previous RTT should be completely erased"
86 );
87 }
88
89 fn ticket_rtt(rtt: Duration) -> Duration {
90 // A simple ACK_ECN frame for a single packet with packet number 0 with a single ECT(0) mark.
91 const ACK_FRAME_1: &[u8] = &[0x03, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00];
92
93 // This test needs to decrypt the CI, so turn off MLKEM.
94 let mut client = new_client(
95 ConnectionParameters::default()
96 .versions(Version::Version1, vec![Version::Version1])
97 .mlkem(false),
98 );
99 let mut server = default_server();
100 let mut now = now();
101
102 let client_initial = client.process_output(now);
103 let (_, client_dcid, _, _) =
104 decode_initial_header(client_initial.as_dgram_ref().unwrap(), Role::Client).unwrap();
105 let client_dcid = client_dcid.to_owned();
106
107 now += rtt / 2;
108 let server_packet = server.process(client_initial.dgram(), now).dgram();
109 let (server_initial, server_hs) = split_datagram(server_packet.as_ref().unwrap());
110 let (protected_header, _, _, payload) =
111 decode_initial_header(&server_initial, Role::Server).unwrap();
112
113 // Now decrypt the packet.
114 let (aead, hp) = initial_aead_and_hp(&client_dcid, Role::Server);
115 let (header, pn) = remove_header_protection(&hp, protected_header, payload);
116 assert_eq!(pn, 0);
117 let pn_len = header.len() - protected_header.len();
118 let mut buf = vec![0; payload.len()];
119 let mut plaintext = aead
120 .decrypt(pn, &header, &payload[pn_len..], &mut buf)
121 .unwrap()
122 .to_owned();
123
124 // Now we need to find the frames. Make some really strong assumptions.
125 let mut dec = Decoder::new(&plaintext[..]);
126 assert_eq!(dec.decode(ACK_FRAME_1.len()), Some(ACK_FRAME_1));
127 assert_eq!(dec.decode_varint(), Some(0x06)); // CRYPTO
128 assert_eq!(dec.decode_varint(), Some(0x00)); // offset
129 dec.skip_vvec(); // Skip over the payload.
130
131 // Replace the ACK frame with PADDING.
132 plaintext[..ACK_FRAME_1.len()].fill(u8::from(FrameType::Padding));
133
134 // And rebuild a packet.
135 let mut packet = header.clone();
136 packet.resize(MIN_INITIAL_PACKET_SIZE, 0);
137 aead.encrypt(pn, &header, &plaintext, &mut packet[header.len()..])
138 .unwrap();
139 apply_header_protection(&hp, &mut packet, protected_header.len()..header.len());
140 let si = Datagram::new(
141 server_initial.source(),
142 server_initial.destination(),
143 server_initial.tos(),
144 packet,
145 );
146
147 // Now a connection can be made successfully.
148 now += rtt / 2;
149 client.process_input(si, now);
150 client.process_input(server_hs.unwrap(), now);
151 client.authenticated(AuthenticationStatus::Ok, now);
152 let finished = client.process_output(now);
153
154 assert_eq!(*client.state(), State::Connected);
155
156 now += rtt / 2;
157 _ = server.process(finished.dgram(), now);
158 assert_eq!(*server.state(), State::Confirmed);
159
160 // Don't deliver the server's handshake finished, it has ACKs.
161 // Now get a ticket.
162 let validation = AddressValidation::new(now, ValidateAddress::NoToken).unwrap();
163 let validation = Rc::new(RefCell::new(validation));
164 server.set_validation(&validation);
165 send_something(&mut server, now);
166 server.send_ticket(now, &[]).expect("can send ticket");
167 let ticket = server.process_output(now).dgram();
168 assert!(ticket.is_some());
169 now += rtt / 2;
170 client.process_input(ticket.unwrap(), now);
171 let token = get_tokens(&mut client).pop().unwrap();
172
173 // And connect again.
174 let mut client = default_client();
175 client.enable_resumption(now, token).unwrap();
176 let ticket_rtt = client.paths.rtt();
177 let mut server = resumed_server(&client);
178
179 connect_with_rtt(&mut client, &mut server, now, Duration::from_millis(50));
180 assert_eq!(
181 client.paths.rtt(),
182 Duration::from_millis(50),
183 "previous RTT should be completely erased"
184 );
185 ticket_rtt
186 }
187
188 #[test]
189 fn ticket_rtt_less_than_default() {
190 assert_eq!(
191 ticket_rtt(Duration::from_millis(10)),
192 Duration::from_millis(10)
193 );
194 }
195
196 #[test]
197 fn ticket_rtt_larger_than_default() {
198 assert_eq!(ticket_rtt(Duration::from_millis(500)), INITIAL_RTT);
199 }
200
201 /// Check that a resumed connection uses a token on Initial packets.
202 #[test]
203 fn address_validation_token_resume() {
204 const RTT: Duration = Duration::from_millis(10);
205
206 let mut client = default_client();
207 let mut server = default_server();
208 let validation = AddressValidation::new(now(), ValidateAddress::Always).unwrap();
209 let validation = Rc::new(RefCell::new(validation));
210 server.set_validation(&validation);
211 let mut now = connect_with_rtt(&mut client, &mut server, now(), RTT);
212
213 let token = exchange_ticket(&mut client, &mut server, now);
214 let mut client = default_client();
215 client.enable_resumption(now, token).unwrap();
216 let mut server = resumed_server(&client);
217
218 // Grab an Initial packet from the client.
219 let dgram = client.process_output(now).dgram();
220 assertions::assert_initial(dgram.as_ref().unwrap(), true);
221
222 // Now try to complete the handshake after giving time for a client PTO.
223 now += AT_LEAST_PTO;
224 connect_with_rtt(&mut client, &mut server, now, RTT);
225 assert!(client.crypto.tls().info().unwrap().resumed());
226 assert!(server.crypto.tls().info().unwrap().resumed());
227 }
228
229 fn can_resume(token: impl AsRef<[u8]>, initial_has_token: bool) {
230 let mut client = default_client();
231 client.enable_resumption(now(), token).unwrap();
232 let initial = client.process_output(now()).dgram();
233 assertions::assert_initial(initial.as_ref().unwrap(), initial_has_token);
234 }
235
236 #[test]
237 fn two_tickets_on_timer() {
238 let mut client = default_client();
239 let mut server = default_server();
240 connect(&mut client, &mut server);
241
242 // Send two tickets and then bundle those into a packet.
243 server.send_ticket(now(), &[]).expect("send ticket1");
244 server.send_ticket(now(), &[]).expect("send ticket2");
245 let pkt = send_something(&mut server, now());
246
247 // process() will return an ack first
248 assert!(client.process(Some(pkt), now()).dgram().is_some());
249 // We do not have a ResumptionToken event yet, because NEW_TOKEN was not sent.
250 assert_eq!(get_tokens(&mut client).len(), 0);
251
252 // We need to wait for release_resumption_token_timer to expire. The timer will be
253 // set to 3 * PTO
254 let mut now = now() + 3 * client.pto();
255 drop(client.process_output(now));
256 let mut recv_tokens = get_tokens(&mut client);
257 assert_eq!(recv_tokens.len(), 1);
258 let token1 = recv_tokens.pop().unwrap();
259 // Wai for anottheer 3 * PTO to get the nex okeen.
260 now += 3 * client.pto();
261 drop(client.process_output(now));
262 let mut recv_tokens = get_tokens(&mut client);
263 assert_eq!(recv_tokens.len(), 1);
264 let token2 = recv_tokens.pop().unwrap();
265 // Wait for 3 * PTO, but now there are no more tokens.
266 now += 3 * client.pto();
267 drop(client.process_output(now));
268 assert_eq!(get_tokens(&mut client).len(), 0);
269 assert_ne!(token1.as_ref(), token2.as_ref());
270
271 can_resume(token1, false);
272 can_resume(token2, false);
273 }
274
275 #[test]
276 fn two_tickets_with_new_token() {
277 let mut client = default_client();
278 let mut server = default_server();
279 let validation = AddressValidation::new(now(), ValidateAddress::Always).unwrap();
280 let validation = Rc::new(RefCell::new(validation));
281 server.set_validation(&validation);
282 connect(&mut client, &mut server);
283
284 // Send two tickets with tokens and then bundle those into a packet.
285 server.send_ticket(now(), &[]).expect("send ticket1");
286 server.send_ticket(now(), &[]).expect("send ticket2");
287 let pkt = send_something(&mut server, now());
288
289 client.process_input(pkt, now());
290 let mut all_tokens = get_tokens(&mut client);
291 assert_eq!(all_tokens.len(), 2);
292 let token1 = all_tokens.pop().unwrap();
293 let token2 = all_tokens.pop().unwrap();
294 assert_ne!(token1.as_ref(), token2.as_ref());
295
296 can_resume(token1, true);
297 can_resume(token2, true);
298 }
299
300 /// By disabling address validation, the server won't send `NEW_TOKEN`, but
301 /// we can take the session ticket still.
302 #[test]
303 fn take_token() {
304 let mut client = default_client();
305 let mut server = default_server();
306 connect(&mut client, &mut server);
307
308 server.send_ticket(now(), &[]).unwrap();
309 let dgram = server.process_output(now()).dgram();
310 client.process_input(dgram.unwrap(), now());
311
312 // There should be no ResumptionToken event here.
313 let tokens = get_tokens(&mut client);
314 assert_eq!(tokens.len(), 0);
315
316 // But we should be able to get the token directly, and use it.
317 let token = client.take_resumption_token(now()).unwrap();
318 can_resume(token, false);
319 }
320
321 /// If a version is selected and subsequently disabled, resumption fails.
322 #[test]
323 fn resume_disabled_version() {
324 let mut client = new_client(
325 ConnectionParameters::default().versions(Version::Version1, vec![Version::Version1]),
326 );
327 let mut server = default_server();
328 connect(&mut client, &mut server);
329 let token = exchange_ticket(&mut client, &mut server, now());
330
331 let mut client = new_client(
332 ConnectionParameters::default().versions(Version::Version2, vec![Version::Version2]),
333 );
334 assert_eq!(
335 client.enable_resumption(now(), token).unwrap_err(),
336 Error::DisabledVersion
337 );
338 }
339
340 /// It's not possible to resume once a packet has been sent.
341 #[test]
342 fn resume_after_packet() {
343 let mut client = default_client();
344 let mut server = default_server();
345 connect(&mut client, &mut server);
346 let token = exchange_ticket(&mut client, &mut server, now());
347
348 let mut client = default_client();
349 drop(client.process_output(now()).dgram().unwrap());
350 assert_eq!(
351 client.enable_resumption(now(), token).unwrap_err(),
352 Error::ConnectionState
353 );
354 }
355
356 /// It's not possible to resume at the server.
357 #[test]
358 fn resume_server() {
359 let mut client = default_client();
360 let mut server = default_server();
361 connect(&mut client, &mut server);
362 let token = exchange_ticket(&mut client, &mut server, now());
363
364 let mut server = default_server();
365 assert_eq!(
366 server.enable_resumption(now(), token).unwrap_err(),
367 Error::ConnectionState
368 );
369 }