Debian Codegraph @

third_party/rust/neqo-transport/tests/connection.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 common::assert_dscp;
10 use neqo_common::{Datagram, Decoder, Encoder, Role};
11 use neqo_transport::{
12 CloseReason, ConnectionParameters, Error, State, Version, MIN_INITIAL_PACKET_SIZE,
13 };
14 use test_fixture::{
15 default_client, default_server,
16 header_protection::{
17 apply_header_protection, decode_initial_header, initial_aead_and_hp,
18 remove_header_protection,
19 },
20 new_client, now, split_datagram,
21 };
22
23 #[test]
24 fn connect() {
25 let (client, server) = test_fixture::connect();
26 assert_dscp(&client.stats());
27 assert_dscp(&server.stats());
28 }
29
30 #[test]
31 fn truncate_long_packet() {
32 let mut client = default_client();
33 let mut server = default_server();
34
35 let out = client.process_output(now());
36 let out2 = client.process_output(now());
37 assert!(out.as_dgram_ref().is_some() && out2.as_dgram_ref().is_some());
38 server.process_input(out.dgram().unwrap(), now());
39 let out = server.process(out2.dgram(), now());
40 assert!(out.as_dgram_ref().is_some());
41 let out = client.process(out.dgram(), now());
42 let out = server.process(out.dgram(), now());
43
44 // This will truncate the Handshake packet from the server.
45 let dupe = out.as_dgram_ref().unwrap().clone();
46 // Count the padding in the packet, plus 1.
47 let tail = dupe.iter().rev().take_while(|b| **b == 0).count() + 1;
48 let truncated = Datagram::new(
49 dupe.source(),
50 dupe.destination(),
51 dupe.tos(),
52 &dupe[..(dupe.len() - tail)],
53 );
54 let hs_probe = client.process(Some(truncated), now()).dgram();
55 assert!(hs_probe.is_some());
56
57 // Now feed in the untruncated packet.
58 let out = client.process(out.dgram(), now());
59 assert!(out.as_dgram_ref().is_some()); // Throw this ACK away.
60 assert!(test_fixture::maybe_authenticate(&mut client));
61 let out = client.process_output(now());
62 assert!(out.as_dgram_ref().is_some());
63
64 assert!(client.state().connected());
65 let out = server.process(out.dgram(), now());
66 assert!(out.as_dgram_ref().is_some());
67 assert!(server.state().connected());
68 }
69
70 /// Test that reordering parts of the server Initial doesn't change things.
71 #[test]
72 fn reorder_server_initial() {
73 // A simple ACK_ECN frame for a single packet with packet number 0 with a single ECT(0) mark.
74 const ACK_FRAME: &[u8] = &[0x03, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00];
75
76 // This test needs to decrypt the CI, so turn off MLKEM.
77 let mut client = new_client(
78 ConnectionParameters::default()
79 .versions(Version::Version1, vec![Version::Version1])
80 .mlkem(false),
81 );
82 let mut server = default_server();
83
84 let client_initial = client.process_output(now());
85 let (_, client_dcid, _, _) =
86 decode_initial_header(client_initial.as_dgram_ref().unwrap(), Role::Client).unwrap();
87 let client_dcid = client_dcid.to_owned();
88
89 let server_packet = server.process(client_initial.dgram(), now()).dgram();
90 let (server_initial, server_hs) = split_datagram(server_packet.as_ref().unwrap());
91 let (protected_header, _, _, payload) =
92 decode_initial_header(&server_initial, Role::Server).unwrap();
93
94 // Now decrypt the packet.
95 let (aead, hp) = initial_aead_and_hp(&client_dcid, Role::Server);
96 let (header, pn) = remove_header_protection(&hp, protected_header, payload);
97 assert_eq!(pn, 0);
98 let pn_len = header.len() - protected_header.len();
99 let mut buf = vec![0; payload.len()];
100 let mut plaintext = aead
101 .decrypt(pn, &header, &payload[pn_len..], &mut buf)
102 .unwrap()
103 .to_owned();
104
105 // Now we need to find the frames. Make some really strong assumptions.
106 let mut dec = Decoder::new(&plaintext[..]);
107 assert_eq!(dec.decode(ACK_FRAME.len()), Some(ACK_FRAME));
108 assert_eq!(dec.decode_varint(), Some(0x06)); // CRYPTO
109 assert_eq!(dec.decode_varint(), Some(0x00)); // offset
110 dec.skip_vvec(); // Skip over the payload.
111 let end = dec.offset();
112
113 // Move the ACK frame after the CRYPTO frame.
114 plaintext[..end].rotate_left(ACK_FRAME.len());
115
116 // And rebuild a packet.
117 let mut packet = header.clone();
118 packet.resize(MIN_INITIAL_PACKET_SIZE, 0);
119 aead.encrypt(pn, &header, &plaintext, &mut packet[header.len()..])
120 .unwrap();
121 apply_header_protection(&hp, &mut packet, protected_header.len()..header.len());
122 let reordered = Datagram::new(
123 server_initial.source(),
124 server_initial.destination(),
125 server_initial.tos(),
126 packet,
127 );
128
129 // Now a connection can be made successfully.
130 // Though we modified the server's Initial packet, we get away with it.
131 // TLS only authenticates the content of the CRYPTO frame, which was untouched.
132 client.process_input(reordered, now());
133 client.process_input(server_hs.unwrap(), now());
134 assert!(test_fixture::maybe_authenticate(&mut client));
135 let finished = client.process_output(now());
136 assert_eq!(*client.state(), State::Connected);
137
138 let done = server.process(finished.dgram(), now());
139 assert_eq!(*server.state(), State::Confirmed);
140
141 client.process_input(done.dgram().unwrap(), now());
142 assert_eq!(*client.state(), State::Confirmed);
143 }
144
145 #[cfg(test)]
146 fn set_payload(server_packet: Option<&Datagram>, client_dcid: &[u8], payload: &[u8]) -> Datagram {
147 let (server_initial, _server_hs) = split_datagram(server_packet.as_ref().unwrap());
148 let (protected_header, _, _, orig_payload) =
149 decode_initial_header(&server_initial, Role::Server).unwrap();
150
151 // Now decrypt the packet.
152 let (aead, hp) = initial_aead_and_hp(client_dcid, Role::Server);
153 let (mut header, pn) = remove_header_protection(&hp, protected_header, orig_payload);
154 assert_eq!(pn, 0);
155 // Re-encode the packet number as four bytes, so we have enough material for the header
156 // protection sample if payload is empty.
157 let pn_pos = header.len() - 2;
158 header[pn_pos] = u8::try_from(4 + aead.expansion()).unwrap();
159 header.resize(header.len() + 3, 0);
160 header[0] |= 0b0000_0011; // Set the packet number length to 4.
161
162 // And build a packet containing the given payload.
163 let mut packet = header.clone();
164 packet.resize(header.len() + payload.len() + aead.expansion(), 0);
165 aead.encrypt(pn, &header, payload, &mut packet[header.len()..])
166 .unwrap();
167 apply_header_protection(&hp, &mut packet, protected_header.len()..header.len());
168 Datagram::new(
169 server_initial.source(),
170 server_initial.destination(),
171 server_initial.tos(),
172 packet,
173 )
174 }
175
176 /// Test that the stack treats a packet without any frames as a protocol violation.
177 #[test]
178 fn packet_without_frames() {
179 let mut client = new_client(
180 ConnectionParameters::default().versions(Version::Version1, vec![Version::Version1]),
181 );
182 let mut server = default_server();
183
184 let client_initial = client.process_output(now());
185 let client_initial_clone = client_initial.as_dgram_ref().unwrap().clone();
186 let (_, client_dcid, _, _) =
187 decode_initial_header(&client_initial_clone, Role::Client).unwrap();
188
189 let server_packet = server.process(client_initial.dgram(), now()).dgram();
190 let modified = set_payload(server_packet.as_ref(), client_dcid, &[]);
191 client.process_input(modified, now());
192 assert_eq!(
193 client.state(),
194 &State::Closed(CloseReason::Transport(Error::ProtocolViolation))
195 );
196 }
197
198 /// Test that the stack permits a packet containing only padding.
199 #[test]
200 fn packet_with_only_padding() {
201 let mut client = new_client(
202 ConnectionParameters::default().versions(Version::Version1, vec![Version::Version1]),
203 );
204 let mut server = default_server();
205
206 let client_initial = client.process_output(now());
207 let client_initial_clone = client_initial.as_dgram_ref().unwrap().clone();
208 let (_, client_dcid, _, _) =
209 decode_initial_header(&client_initial_clone, Role::Client).unwrap();
210
211 let server_packet = server.process(client_initial.dgram(), now()).dgram();
212 let modified = set_payload(server_packet.as_ref(), client_dcid, &[0]);
213 client.process_input(modified, now());
214 assert_eq!(client.state(), &State::WaitInitial);
215 }
216
217 /// Overflow the crypto buffer.
218 #[expect(clippy::similar_names, reason = "scid simiar to dcic.")]
219 #[test]
220 fn overflow_crypto() {
221 let mut client = new_client(
222 ConnectionParameters::default().versions(Version::Version1, vec![Version::Version1]),
223 );
224 let mut server = default_server();
225
226 let client_initial = client.process_output(now()).dgram();
227 let (_, client_dcid, _, _) =
228 decode_initial_header(client_initial.as_ref().unwrap(), Role::Client).unwrap();
229 let client_dcid = client_dcid.to_owned();
230
231 let server_packet = server.process(client_initial, now()).dgram();
232 let (server_initial, _) = split_datagram(server_packet.as_ref().unwrap());
233
234 // Now decrypt the server packet to get AEAD and HP instances.
235 // We won't be using the packet, but making new ones.
236 let (aead, hp) = initial_aead_and_hp(&client_dcid, Role::Server);
237 let (_, server_dcid, server_scid, _) =
238 decode_initial_header(&server_initial, Role::Server).unwrap();
239
240 // Send in 100 packets, each with 1000 bytes of crypto frame data each,
241 // eventually this will overrun the buffer we keep for crypto data.
242 let mut payload = Encoder::with_capacity(1024);
243 for pn in 0..100_u64 {
244 payload.truncate(0);
245 payload
246 .encode_varint(0x06_u64) // CRYPTO frame type.
247 .encode_varint(pn * 1000 + 1) // offset
248 .encode_varint(1000_u64); // length
249 let plen = payload.len();
250 payload.pad_to(plen + 1000, 44);
251
252 let mut packet = Encoder::with_capacity(MIN_INITIAL_PACKET_SIZE);
253 packet
254 .encode_byte(0xc1) // Initial with packet number length of 2.
255 .encode_uint(4, Version::Version1.wire_version())
256 .encode_vec(1, server_dcid)
257 .encode_vec(1, server_scid)
258 .encode_vvec(&[]) // token
259 .encode_varint(u64::try_from(2 + payload.len() + aead.expansion()).unwrap()); // length
260 let pn_offset = packet.len();
261 packet.encode_uint(2, pn);
262
263 let mut packet = Vec::from(packet);
264 let header = packet.clone();
265 packet.resize(header.len() + payload.len() + aead.expansion(), 0);
266 aead.encrypt(pn, &header, payload.as_ref(), &mut packet[header.len()..])
267 .unwrap();
268 apply_header_protection(&hp, &mut packet, pn_offset..(pn_offset + 2));
269 packet.resize(MIN_INITIAL_PACKET_SIZE, 0); // Initial has to be MIN_INITIAL_PACKET_SIZE bytes!
270
271 let dgram = Datagram::new(
272 server_initial.source(),
273 server_initial.destination(),
274 server_initial.tos(),
275 packet,
276 );
277 client.process_input(dgram, now());
278 if let State::Closing { error, .. } = client.state() {
279 assert!(
280 matches!(error, CloseReason::Transport(Error::CryptoBufferExceeded)),
281 "the connection need to abort on crypto buffer"
282 );
283 assert!(pn > 64, "at least 64000 bytes of data is buffered");
284 return;
285 }
286 }
287 panic!("Was not able to overflow the crypto buffer");
288 }
289
290 #[test]
291 fn handshake_mlkem768x25519() {
292 let mut client = default_client();
293 let mut server = default_server();
294
295 client
296 .set_groups(&[neqo_crypto::TLS_GRP_KEM_MLKEM768X25519])
297 .unwrap();
298 client.send_additional_key_shares(0).unwrap();
299
300 test_fixture::handshake(&mut client, &mut server);
301 assert_eq!(*client.state(), State::Confirmed);
302 assert_eq!(*server.state(), State::Confirmed);
303 assert_eq!(
304 client.tls_info().unwrap().key_exchange(),
305 neqo_crypto::TLS_GRP_KEM_MLKEM768X25519
306 );
307 assert_eq!(
308 server.tls_info().unwrap().key_exchange(),
309 neqo_crypto::TLS_GRP_KEM_MLKEM768X25519
310 );
311 }