Debian Codegraph @

third_party/rust/neqo-transport/src/tparams.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 // Transport parameters. See -transport section 7.3.
8
9 use std::{
10 cell::RefCell,
11 fmt::{self, Display, Formatter},
12 net::{Ipv4Addr, Ipv6Addr, SocketAddrV4, SocketAddrV6},
13 rc::Rc,
14 };
15
16 use enum_map::{Enum, EnumMap};
17 use neqo_common::{hex, qdebug, qinfo, qtrace, Decoder, Encoder, Role};
18 use neqo_crypto::{
19 constants::{TLS_HS_CLIENT_HELLO, TLS_HS_ENCRYPTED_EXTENSIONS},
20 ext::{ExtensionHandler, ExtensionHandlerResult, ExtensionWriterResult},
21 random, HandshakeMessage, ZeroRttCheckResult, ZeroRttChecker,
22 };
23 use strum::FromRepr;
24
25 use crate::{
26 cid::{ConnectionId, ConnectionIdEntry, CONNECTION_ID_SEQNO_PREFERRED, MAX_CONNECTION_ID_LEN},
27 packet::MIN_INITIAL_PACKET_SIZE,
28 tracking::DEFAULT_REMOTE_ACK_DELAY,
29 version::{Version, VersionConfig, WireVersion},
30 Error, Res,
31 };
32
33 #[derive(Debug, Clone, Enum, PartialEq, Eq, Copy, FromRepr)]
34 #[repr(u64)]
35 pub enum TransportParameterId {
36 OriginalDestinationConnectionId = 0x00,
37 IdleTimeout = 0x01,
38 StatelessResetToken = 0x02,
39 MaxUdpPayloadSize = 0x03,
40 InitialMaxData = 0x04,
41 InitialMaxStreamDataBidiLocal = 0x05,
42 InitialMaxStreamDataBidiRemote = 0x06,
43 InitialMaxStreamDataUni = 0x07,
44 InitialMaxStreamsBidi = 0x08,
45 InitialMaxStreamsUni = 0x09,
46 AckDelayExponent = 0x0a,
47 MaxAckDelay = 0x0b,
48 DisableMigration = 0x0c,
49 PreferredAddress = 0x0d,
50 ActiveConnectionIdLimit = 0x0e,
51 InitialSourceConnectionId = 0x0f,
52 RetrySourceConnectionId = 0x10,
53 VersionInformation = 0x11,
54 GreaseQuicBit = 0x2ab2,
55 MinAckDelay = 0xff02_de1a,
56 MaxDatagramFrameSize = 0x0020,
57 #[cfg(test)]
58 TestTransportParameter = 0xce16,
59 }
60
61 impl Display for TransportParameterId {
62 fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
63 format!("{self:?}((0x{:02x}))", u64::from(*self)).fmt(f)
64 }
65 }
66
67 impl From<TransportParameterId> for u64 {
68 fn from(val: TransportParameterId) -> Self {
69 val as Self
70 }
71 }
72
73 impl TryFrom<u64> for TransportParameterId {
74 type Error = Error;
75
76 fn try_from(value: u64) -> Result<Self, Self::Error> {
77 Self::from_repr(value).ok_or(Error::UnknownTransportParameter)
78 }
79 }
80
81 #[derive(Clone, Debug)]
82 pub struct PreferredAddress {
83 v4: Option<SocketAddrV4>,
84 v6: Option<SocketAddrV6>,
85 }
86
87 impl PreferredAddress {
88 /// Make a new preferred address configuration.
89 ///
90 /// # Panics
91 ///
92 /// If neither address is provided, or if either address is of the wrong type.
93 #[must_use]
94 pub fn new(v4: Option<SocketAddrV4>, v6: Option<SocketAddrV6>) -> Self {
95 assert!(v4.is_some() || v6.is_some());
96 if let Some(a) = v4 {
97 assert!(!a.ip().is_unspecified());
98 assert_ne!(a.port(), 0);
99 }
100 if let Some(a) = v6 {
101 assert!(!a.ip().is_unspecified());
102 assert_ne!(a.port(), 0);
103 }
104 Self { v4, v6 }
105 }
106
107 /// A generic version of `new()` for testing.
108 /// # Panics
109 /// When the addresses are the wrong type.
110 #[must_use]
111 #[cfg(test)]
112 pub fn new_any(v4: Option<std::net::SocketAddr>, v6: Option<std::net::SocketAddr>) -> Self {
113 use std::net::SocketAddr;
114
115 let v4 = v4.map(|v4| {
116 let SocketAddr::V4(v4) = v4 else {
117 panic!("not v4");
118 };
119 v4
120 });
121 let v6 = v6.map(|v6| {
122 let SocketAddr::V6(v6) = v6 else {
123 panic!("not v6");
124 };
125 v6
126 });
127 Self::new(v4, v6)
128 }
129
130 #[must_use]
131 pub const fn ipv4(&self) -> Option<SocketAddrV4> {
132 self.v4
133 }
134 #[must_use]
135 pub const fn ipv6(&self) -> Option<SocketAddrV6> {
136 self.v6
137 }
138 }
139
140 #[derive(Clone, Debug, PartialEq, Eq)]
141 pub enum TransportParameter {
142 Bytes(Vec<u8>),
143 Integer(u64),
144 Empty,
145 PreferredAddress {
146 v4: Option<SocketAddrV4>,
147 v6: Option<SocketAddrV6>,
148 cid: ConnectionId,
149 srt: [u8; 16],
150 },
151 Versions {
152 current: WireVersion,
153 other: Vec<WireVersion>,
154 },
155 }
156
157 impl TransportParameter {
158 fn encode(&self, enc: &mut Encoder, tp: TransportParameterId) {
159 qtrace!("TP encoded; type {tp}) val {self:?}");
160 enc.encode_varint(tp);
161 match self {
162 Self::Bytes(a) => {
163 enc.encode_vvec(a);
164 }
165 Self::Integer(a) => {
166 enc.encode_vvec_with(|enc_inner| {
167 enc_inner.encode_varint(*a);
168 });
169 }
170 Self::Empty => {
171 enc.encode_varint(0_u64);
172 }
173 Self::PreferredAddress { v4, v6, cid, srt } => {
174 enc.encode_vvec_with(|enc_inner| {
175 if let Some(v4) = v4 {
176 enc_inner.encode(&v4.ip().octets()[..]);
177 enc_inner.encode_uint(2, v4.port());
178 } else {
179 enc_inner.encode(&[0; 6]);
180 }
181 if let Some(v6) = v6 {
182 enc_inner.encode(&v6.ip().octets()[..]);
183 enc_inner.encode_uint(2, v6.port());
184 } else {
185 enc_inner.encode(&[0; 18]);
186 }
187 enc_inner.encode_vec(1, &cid[..]);
188 enc_inner.encode(&srt[..]);
189 });
190 }
191 Self::Versions { current, other } => {
192 enc.encode_vvec_with(|enc_inner| {
193 enc_inner.encode_uint(4, *current);
194 for v in other {
195 enc_inner.encode_uint(4, *v);
196 }
197 });
198 }
199 }
200 }
201
202 fn decode_preferred_address(d: &mut Decoder) -> Res<Self> {
203 // IPv4 address (maybe)
204 let v4ip = Ipv4Addr::from(<[u8; 4]>::try_from(d.decode(4).ok_or(Error::NoMoreData)?)?);
205 let v4port = d.decode_uint::<u16>().ok_or(Error::NoMoreData)?;
206 // Can't have non-zero IP and zero port, or vice versa.
207 if v4ip.is_unspecified() ^ (v4port == 0) {
208 return Err(Error::TransportParameterError);
209 }
210 let v4 = if v4port == 0 {
211 None
212 } else {
213 Some(SocketAddrV4::new(v4ip, v4port))
214 };
215
216 // IPv6 address (mostly the same as v4)
217 let v6ip = Ipv6Addr::from(<[u8; 16]>::try_from(
218 d.decode(16).ok_or(Error::NoMoreData)?,
219 )?);
220 let v6port = d.decode_uint().ok_or(Error::NoMoreData)?;
221 if v6ip.is_unspecified() ^ (v6port == 0) {
222 return Err(Error::TransportParameterError);
223 }
224 let v6 = if v6port == 0 {
225 None
226 } else {
227 Some(SocketAddrV6::new(v6ip, v6port, 0, 0))
228 };
229 // Need either v4 or v6 to be present.
230 if v4.is_none() && v6.is_none() {
231 return Err(Error::TransportParameterError);
232 }
233
234 // Connection ID (non-zero length)
235 let cid = ConnectionId::from(d.decode_vec(1).ok_or(Error::NoMoreData)?);
236 if cid.is_empty() || cid.len() > MAX_CONNECTION_ID_LEN {
237 return Err(Error::TransportParameterError);
238 }
239
240 // Stateless reset token
241 let srtbuf = d.decode(16).ok_or(Error::NoMoreData)?;
242 let srt = <[u8; 16]>::try_from(srtbuf)?;
243
244 Ok(Self::PreferredAddress { v4, v6, cid, srt })
245 }
246
247 fn decode_versions(dec: &mut Decoder) -> Res<Self> {
248 fn dv(dec: &mut Decoder) -> Res<WireVersion> {
249 let v = dec.decode_uint::<WireVersion>().ok_or(Error::NoMoreData)?;
250 if v == 0 {
251 Err(Error::TransportParameterError)
252 } else {
253 Ok(v)
254 }
255 }
256
257 let current = dv(dec)?;
258 // This rounding down is OK because `decode` checks for left over data.
259 let count = dec.remaining() / 4;
260 let mut other = Vec::with_capacity(count);
261 for _ in 0..count {
262 other.push(dv(dec)?);
263 }
264 Ok(Self::Versions { current, other })
265 }
266
267 fn decode(dec: &mut Decoder) -> Res<Option<(TransportParameterId, Self)>> {
268 let tp = dec.decode_varint().ok_or(Error::NoMoreData)?;
269 let content = dec.decode_vvec().ok_or(Error::NoMoreData)?;
270 qtrace!("TP {tp:x} length {:x}", content.len());
271 let tp = match tp.try_into() {
272 Ok(tp) => tp,
273 Err(Error::UnknownTransportParameter) => return Ok(None), // Skip
274 Err(e) => return Err(e),
275 };
276 let mut d = Decoder::from(content);
277 let value = match tp {
278 TransportParameterId::OriginalDestinationConnectionId
279 | TransportParameterId::InitialSourceConnectionId
280 | TransportParameterId::RetrySourceConnectionId => {
281 Self::Bytes(d.decode_remainder().to_vec())
282 }
283 TransportParameterId::StatelessResetToken => {
284 if d.remaining() != 16 {
285 return Err(Error::TransportParameterError);
286 }
287 Self::Bytes(d.decode_remainder().to_vec())
288 }
289 TransportParameterId::IdleTimeout
290 | TransportParameterId::InitialMaxData
291 | TransportParameterId::InitialMaxStreamDataBidiLocal
292 | TransportParameterId::InitialMaxStreamDataBidiRemote
293 | TransportParameterId::InitialMaxStreamDataUni
294 | TransportParameterId::MaxAckDelay
295 | TransportParameterId::MaxDatagramFrameSize => match d.decode_varint() {
296 Some(v) => Self::Integer(v),
297 None => return Err(Error::TransportParameterError),
298 },
299 TransportParameterId::InitialMaxStreamsBidi
300 | TransportParameterId::InitialMaxStreamsUni => match d.decode_varint() {
301 Some(v) if v <= (1 << 60) => Self::Integer(v),
302 _ => return Err(Error::StreamLimitError),
303 },
304 TransportParameterId::MaxUdpPayloadSize => match d.decode_varint() {
305 Some(v) if v >= MIN_INITIAL_PACKET_SIZE.try_into()? => Self::Integer(v),
306 _ => return Err(Error::TransportParameterError),
307 },
308 TransportParameterId::AckDelayExponent => match d.decode_varint() {
309 Some(v) if v <= 20 => Self::Integer(v),
310 _ => return Err(Error::TransportParameterError),
311 },
312 TransportParameterId::ActiveConnectionIdLimit => match d.decode_varint() {
313 Some(v) if v >= 2 => Self::Integer(v),
314 _ => return Err(Error::TransportParameterError),
315 },
316 TransportParameterId::DisableMigration | TransportParameterId::GreaseQuicBit => {
317 Self::Empty
318 }
319 TransportParameterId::PreferredAddress => Self::decode_preferred_address(&mut d)?,
320 TransportParameterId::MinAckDelay => match d.decode_varint() {
321 Some(v) if v < (1 << 24) => Self::Integer(v),
322 _ => return Err(Error::TransportParameterError),
323 },
324 TransportParameterId::VersionInformation => Self::decode_versions(&mut d)?,
325 #[cfg(test)]
326 TransportParameterId::TestTransportParameter => {
327 Self::Bytes(d.decode_remainder().to_vec())
328 }
329 };
330 if d.remaining() > 0 {
331 return Err(Error::TooMuchData);
332 }
333 qtrace!("TP decoded; type {tp} val {value:?}");
334 Ok(Some((tp, value)))
335 }
336 }
337
338 #[derive(Clone, Debug, Default, PartialEq, Eq)]
339 pub struct TransportParameters {
340 params: EnumMap<TransportParameterId, Option<TransportParameter>>,
341 }
342
343 impl TransportParameters {
344 /// Set a value.
345 pub fn set(&mut self, k: TransportParameterId, v: TransportParameter) {
346 self.params[k] = Some(v);
347 }
348
349 /// Clear a key.
350 pub fn remove(&mut self, k: TransportParameterId) {
351 self.params[k].take();
352 }
353
354 /// Decode is a static function that parses transport parameters
355 /// using the provided decoder.
356 pub(crate) fn decode(d: &mut Decoder) -> Res<Self> {
357 let mut tps = Self::default();
358 qtrace!("Parsed fixed TP header");
359
360 while d.remaining() > 0 {
361 match TransportParameter::decode(d) {
362 Ok(Some((tipe, tp))) => {
363 tps.set(tipe, tp);
364 }
365 Ok(None) => {}
366 Err(e) => return Err(e),
367 }
368 }
369 Ok(tps)
370 }
371
372 pub(crate) fn encode(&self, enc: &mut Encoder) {
373 for (tipe, tp) in &self.params {
374 if let Some(tp) = tp {
375 tp.encode(enc, tipe);
376 }
377 }
378 }
379
380 // Get an integer type or a default.
381 /// # Panics
382 /// When the transport parameter isn't recognized as being an integer.
383 #[must_use]
384 pub fn get_integer(&self, tp: TransportParameterId) -> u64 {
385 let default = match tp {
386 TransportParameterId::IdleTimeout
387 | TransportParameterId::InitialMaxData
388 | TransportParameterId::InitialMaxStreamDataBidiLocal
389 | TransportParameterId::InitialMaxStreamDataBidiRemote
390 | TransportParameterId::InitialMaxStreamDataUni
391 | TransportParameterId::InitialMaxStreamsBidi
392 | TransportParameterId::InitialMaxStreamsUni
393 | TransportParameterId::MinAckDelay
394 | TransportParameterId::MaxDatagramFrameSize => 0,
395 TransportParameterId::MaxUdpPayloadSize => 65527,
396 TransportParameterId::AckDelayExponent => 3,
397 TransportParameterId::MaxAckDelay => DEFAULT_REMOTE_ACK_DELAY
398 .as_millis()
399 .try_into()
400 .expect("default remote ack delay in ms can't overflow u64"),
401 TransportParameterId::ActiveConnectionIdLimit => 2,
402 _ => panic!("Transport parameter not known or not an Integer"),
403 };
404 match self.params[tp] {
405 None => default,
406 Some(TransportParameter::Integer(x)) => x,
407 _ => panic!("Internal error"),
408 }
409 }
410
411 // Set an integer type or a default.
412 /// # Panics
413 /// When the transport parameter isn't recognized as being an integer.
414 pub fn set_integer(&mut self, tp: TransportParameterId, value: u64) {
415 match tp {
416 TransportParameterId::IdleTimeout
417 | TransportParameterId::InitialMaxData
418 | TransportParameterId::InitialMaxStreamDataBidiLocal
419 | TransportParameterId::InitialMaxStreamDataBidiRemote
420 | TransportParameterId::InitialMaxStreamDataUni
421 | TransportParameterId::InitialMaxStreamsBidi
422 | TransportParameterId::InitialMaxStreamsUni
423 | TransportParameterId::MaxUdpPayloadSize
424 | TransportParameterId::AckDelayExponent
425 | TransportParameterId::MaxAckDelay
426 | TransportParameterId::ActiveConnectionIdLimit
427 | TransportParameterId::MinAckDelay
428 | TransportParameterId::MaxDatagramFrameSize => {
429 self.set(tp, TransportParameter::Integer(value));
430 }
431 _ => panic!("Transport parameter not known"),
432 }
433 }
434
435 /// # Panics
436 /// When the transport parameter isn't recognized as containing bytes.
437 #[must_use]
438 pub fn get_bytes(&self, tp: TransportParameterId) -> Option<&[u8]> {
439 match tp {
440 TransportParameterId::OriginalDestinationConnectionId
441 | TransportParameterId::InitialSourceConnectionId
442 | TransportParameterId::RetrySourceConnectionId
443 | TransportParameterId::StatelessResetToken => {}
444 _ => panic!("Transport parameter not known or not type bytes"),
445 }
446
447 match &self.params[tp] {
448 None => None,
449 Some(TransportParameter::Bytes(x)) => Some(x),
450 _ => panic!("Internal error"),
451 }
452 }
453
454 /// # Panics
455 /// When the transport parameter isn't recognized as containing bytes.
456 pub fn set_bytes(&mut self, tp: TransportParameterId, value: Vec<u8>) {
457 match tp {
458 TransportParameterId::OriginalDestinationConnectionId
459 | TransportParameterId::InitialSourceConnectionId
460 | TransportParameterId::RetrySourceConnectionId
461 | TransportParameterId::StatelessResetToken => {
462 self.set(tp, TransportParameter::Bytes(value));
463 }
464 _ => panic!("Transport parameter not known or not type bytes"),
465 }
466 }
467
468 /// # Panics
469 /// When the transport parameter isn't recognized as being empty.
470 pub fn set_empty(&mut self, tp: TransportParameterId) {
471 match tp {
472 TransportParameterId::DisableMigration | TransportParameterId::GreaseQuicBit => {
473 self.set(tp, TransportParameter::Empty);
474 }
475 _ => panic!("Transport parameter not known or not type empty"),
476 }
477 }
478
479 /// Set version information.
480 pub fn set_versions(&mut self, role: Role, versions: &VersionConfig) {
481 let mut other: Vec<u32> = Vec::with_capacity(versions.all().len() + 1);
482 let grease = u32::from_ne_bytes(random::<4>()) & 0xf0f0_f0f0 | 0x0a0a_0a0a;
483 other.push(grease);
484 for &v in versions.all() {
485 if role == Role::Client && !versions.initial().is_compatible(v) {
486 continue;
487 }
488 other.push(v.wire_version());
489 }
490 let current = versions.initial().wire_version();
491 self.set(
492 TransportParameterId::VersionInformation,
493 TransportParameter::Versions { current, other },
494 );
495 }
496
497 fn compatible_upgrade(&mut self, v: Version) {
498 if let Some(TransportParameter::Versions {
499 ref mut current, ..
500 }) = self.params[TransportParameterId::VersionInformation]
501 {
502 *current = v.wire_version();
503 } else {
504 unreachable!("Compatible upgrade without transport parameters set!");
505 }
506 }
507
508 /// # Panics
509 /// When the indicated transport parameter is present but NOT empty.
510 /// This should not happen if the parsing code in `TransportParameter::decode` is correct.
511 #[must_use]
512 pub fn get_empty(&self, tipe: TransportParameterId) -> bool {
513 match self.params[tipe] {
514 None => false,
515 Some(TransportParameter::Empty) => true,
516 _ => panic!("Internal error"),
517 }
518 }
519
520 /// Return true if the remembered transport parameters are OK for 0-RTT.
521 /// Generally this means that any value that is currently in effect is greater than
522 /// or equal to the promised value.
523 pub(crate) fn ok_for_0rtt(&self, remembered: &Self) -> bool {
524 for (k, v_rem) in &remembered.params {
525 // Skip checks for these, which don't affect 0-RTT.
526 if v_rem.is_none()
527 || matches!(
528 k,
529 TransportParameterId::OriginalDestinationConnectionId
530 | TransportParameterId::InitialSourceConnectionId
531 | TransportParameterId::RetrySourceConnectionId
532 | TransportParameterId::StatelessResetToken
533 | TransportParameterId::IdleTimeout
534 | TransportParameterId::AckDelayExponent
535 | TransportParameterId::MaxAckDelay
536 | TransportParameterId::ActiveConnectionIdLimit
537 | TransportParameterId::PreferredAddress
538 )
539 {
540 continue;
541 }
542
543 let ok = self.params[k]
544 .as_ref()
545 .is_some_and(|v_self| match (v_self, v_rem) {
546 (
547 TransportParameter::Integer(i_self),
548 Some(TransportParameter::Integer(i_rem)),
549 ) => {
550 if k == TransportParameterId::MinAckDelay {
551 // MIN_ACK_DELAY is backwards:
552 // it can only be reduced safely.
553 *i_self <= *i_rem
554 } else {
555 *i_self >= *i_rem
556 }
557 }
558 (TransportParameter::Empty, Some(TransportParameter::Empty)) => true,
559 (
560 TransportParameter::Versions {
561 current: v_self, ..
562 },
563 Some(TransportParameter::Versions { current: v_rem, .. }),
564 ) => v_self == v_rem,
565 _ => false,
566 });
567 if !ok {
568 return false;
569 }
570 }
571 true
572 }
573
574 /// Get the preferred address in a usable form.
575 #[must_use]
576 pub fn get_preferred_address(&self) -> Option<(PreferredAddress, ConnectionIdEntry<[u8; 16]>)> {
577 if let Some(TransportParameter::PreferredAddress { v4, v6, cid, srt }) =
578 &self.params[TransportParameterId::PreferredAddress]
579 {
580 Some((
581 PreferredAddress::new(*v4, *v6),
582 ConnectionIdEntry::new(CONNECTION_ID_SEQNO_PREFERRED, cid.clone(), *srt),
583 ))
584 } else {
585 None
586 }
587 }
588
589 /// Get the version negotiation values for validation.
590 #[must_use]
591 pub fn get_versions(&self) -> Option<(WireVersion, &[WireVersion])> {
592 if let Some(TransportParameter::Versions { current, other }) =
593 &self.params[TransportParameterId::VersionInformation]
594 {
595 Some((*current, other))
596 } else {
597 None
598 }
599 }
600
601 #[must_use]
602 pub fn has_value(&self, tp: TransportParameterId) -> bool {
603 self.params[tp].is_some()
604 }
605 }
606
607 #[derive(Debug)]
608 pub struct TransportParametersHandler {
609 role: Role,
610 versions: VersionConfig,
611 local: TransportParameters,
612 remote_handshake: Option<TransportParameters>,
613 remote_0rtt: Option<TransportParameters>,
614 }
615
616 impl TransportParametersHandler {
617 #[must_use]
618 pub fn new(role: Role, versions: VersionConfig) -> Self {
619 let mut local = TransportParameters::default();
620 local.set_versions(role, &versions);
621 Self {
622 role,
623 versions,
624 local,
625 remote_handshake: None,
626 remote_0rtt: None,
627 }
628 }
629
630 /// When resuming, the version is set based on the ticket.
631 /// That needs to be done to override the default choice from configuration.
632 pub fn set_version(&mut self, version: Version) {
633 debug_assert_eq!(self.role, Role::Client);
634 self.versions.set_initial(version);
635 self.local.set_versions(self.role, &self.versions);
636 }
637
638 /// # Panics
639 /// When this function is called before the peer has provided transport parameters.
640 /// Do not call this function if you are not also able to send data.
641 #[must_use]
642 pub fn remote(&self) -> &TransportParameters {
643 match (self.remote_handshake(), self.remote_0rtt()) {
644 (Some(tp), _) | (_, Some(tp)) => tp,
645 _ => panic!("no transport parameters from peer"),
646 }
647 }
648
649 /// Get the version as set (or as determined by a compatible upgrade).
650 #[must_use]
651 pub const fn version(&self) -> Version {
652 self.versions.initial()
653 }
654
655 fn compatible_upgrade(&mut self, remote_tp: &TransportParameters) -> Res<()> {
656 if let Some((current, other)) = remote_tp.get_versions() {
657 qtrace!(
658 "Peer versions: {current:x} {other:x?}; config {:?}",
659 self.versions,
660 );
661
662 if self.role == Role::Client {
663 let chosen = Version::try_from(current)?;
664 if self.versions.compatible().any(|&v| v == chosen) {
665 Ok(())
666 } else {
667 qinfo!(
668 "Chosen version {current:x} is not compatible with initial version {:x}",
669 self.versions.initial().wire_version(),
670 );
671 Err(Error::TransportParameterError)
672 }
673 } else {
674 if current != self.versions.initial().wire_version() {
675 qinfo!(
676 "Current version {current:x} != own version {:x}",
677 self.versions.initial().wire_version(),
678 );
679 return Err(Error::TransportParameterError);
680 }
681
682 if let Some(preferred) = self.versions.preferred_compatible(other) {
683 if preferred != self.versions.initial() {
684 qinfo!(
685 "Compatible upgrade {:?} ==> {preferred:?}",
686 self.versions.initial()
687 );
688 self.versions.set_initial(preferred);
689 self.local.compatible_upgrade(preferred);
690 }
691 Ok(())
692 } else {
693 qinfo!("Unable to find any compatible version");
694 Err(Error::TransportParameterError)
695 }
696 }
697 } else {
698 Ok(())
699 }
700 }
701
702 #[must_use]
703 pub const fn local(&self) -> &TransportParameters {
704 &self.local
705 }
706
707 #[must_use]
708 pub fn local_mut(&mut self) -> &mut TransportParameters {
709 &mut self.local
710 }
711
712 pub fn set_remote_0rtt(&mut self, remote_0rtt: Option<TransportParameters>) {
713 self.remote_0rtt = remote_0rtt;
714 }
715
716 #[must_use]
717 pub const fn remote_0rtt(&self) -> Option<&TransportParameters> {
718 self.remote_0rtt.as_ref()
719 }
720
721 #[must_use]
722 pub const fn remote_handshake(&self) -> Option<&TransportParameters> {
723 self.remote_handshake.as_ref()
724 }
725 }
726
727 impl ExtensionHandler for TransportParametersHandler {
728 fn write(&mut self, msg: HandshakeMessage, d: &mut [u8]) -> ExtensionWriterResult {
729 if !matches!(msg, TLS_HS_CLIENT_HELLO | TLS_HS_ENCRYPTED_EXTENSIONS) {
730 return ExtensionWriterResult::Skip;
731 }
732
733 qdebug!("Writing transport parameters, msg={msg:?}");
734
735 // TODO([email protected]): Modify to avoid a copy.
736 let mut enc = Encoder::default();
737 self.local.encode(&mut enc);
738 assert!(enc.len() <= d.len());
739 d[..enc.len()].copy_from_slice(enc.as_ref());
740 ExtensionWriterResult::Write(enc.len())
741 }
742
743 fn handle(&mut self, msg: HandshakeMessage, d: &[u8]) -> ExtensionHandlerResult {
744 qtrace!(
745 "Handling transport parameters, msg={msg:?} value={}",
746 hex(d),
747 );
748
749 if !matches!(msg, TLS_HS_CLIENT_HELLO | TLS_HS_ENCRYPTED_EXTENSIONS) {
750 return ExtensionHandlerResult::Alert(110); // unsupported_extension
751 }
752
753 let mut dec = Decoder::from(d);
754 match TransportParameters::decode(&mut dec) {
755 Ok(tp) => {
756 if self.compatible_upgrade(&tp).is_ok() {
757 self.remote_handshake = Some(tp);
758 ExtensionHandlerResult::Ok
759 } else {
760 ExtensionHandlerResult::Alert(47)
761 }
762 }
763 _ => ExtensionHandlerResult::Alert(47), // illegal_parameter
764 }
765 }
766 }
767
768 #[derive(Debug)]
769 pub(crate) struct TpZeroRttChecker<T> {
770 handler: Rc<RefCell<TransportParametersHandler>>,
771 app_checker: T,
772 }
773
774 impl<T> TpZeroRttChecker<T>
775 where
776 T: ZeroRttChecker + 'static,
777 {
778 pub fn wrap(
779 handler: Rc<RefCell<TransportParametersHandler>>,
780 app_checker: T,
781 ) -> Box<dyn ZeroRttChecker> {
782 Box::new(Self {
783 handler,
784 app_checker,
785 })
786 }
787 }
788
789 impl<T> ZeroRttChecker for TpZeroRttChecker<T>
790 where
791 T: ZeroRttChecker,
792 {
793 fn check(&self, token: &[u8]) -> ZeroRttCheckResult {
794 // Reject 0-RTT if there is no token.
795 if token.is_empty() {
796 qdebug!("0-RTT: no token, no 0-RTT");
797 return ZeroRttCheckResult::Reject;
798 }
799 let mut dec = Decoder::from(token);
800 let Some(tpslice) = dec.decode_vvec() else {
801 qinfo!("0-RTT: token code error");
802 return ZeroRttCheckResult::Fail;
803 };
804 let mut dec_tp = Decoder::from(tpslice);
805 let Ok(remembered) = TransportParameters::decode(&mut dec_tp) else {
806 qinfo!("0-RTT: transport parameter decode error");
807 return ZeroRttCheckResult::Fail;
808 };
809 if self.handler.borrow().local.ok_for_0rtt(&remembered) {
810 qinfo!("0-RTT: transport parameters OK, passing to application checker");
811 self.app_checker.check(dec.decode_remainder())
812 } else {
813 qinfo!("0-RTT: transport parameters bad, rejecting");
814 ZeroRttCheckResult::Reject
815 }
816 }
817 }
818
819 #[cfg(test)]
820 mod tests {
821 use std::net::{Ipv4Addr, Ipv6Addr, SocketAddrV4, SocketAddrV6};
822
823 use neqo_common::{qdebug, Decoder, Encoder};
824 use TransportParameterId::*;
825
826 use super::PreferredAddress;
827 use crate::{
828 tparams::{TransportParameter, TransportParameterId, TransportParameters},
829 ConnectionId, Error, Version,
830 };
831
832 #[test]
833 fn basic_tps() {
834 const RESET_TOKEN: &[u8] = &[1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8];
835 let mut tps = TransportParameters::default();
836 tps.set(
837 StatelessResetToken,
838 TransportParameter::Bytes(RESET_TOKEN.to_vec()),
839 );
840 tps.params[InitialMaxStreamsBidi] = Some(TransportParameter::Integer(10));
841
842 let mut enc = Encoder::default();
843 tps.encode(&mut enc);
844
845 let tps2 = TransportParameters::decode(&mut enc.as_decoder()).expect("Couldn't decode");
846 assert_eq!(tps, tps2);
847
848 println!("TPS = {tps:?}");
849 assert_eq!(tps2.get_integer(IdleTimeout), 0); // Default
850 assert_eq!(tps2.get_integer(MaxAckDelay), 25); // Default
851 assert_eq!(tps2.get_integer(ActiveConnectionIdLimit), 2); // Default
852 assert_eq!(tps2.get_integer(InitialMaxStreamsBidi), 10); // Sent
853 assert_eq!(tps2.get_bytes(StatelessResetToken), Some(RESET_TOKEN));
854 assert_eq!(tps2.get_bytes(OriginalDestinationConnectionId), None);
855 assert_eq!(tps2.get_bytes(InitialSourceConnectionId), None);
856 assert_eq!(tps2.get_bytes(RetrySourceConnectionId), None);
857 assert!(!tps2.has_value(OriginalDestinationConnectionId));
858 assert!(!tps2.has_value(InitialSourceConnectionId));
859 assert!(!tps2.has_value(RetrySourceConnectionId));
860 assert!(tps2.has_value(StatelessResetToken));
861
862 let mut enc = Encoder::default();
863 tps.encode(&mut enc);
864
865 TransportParameters::decode(&mut enc.as_decoder()).expect("Couldn't decode");
866 }
867
868 fn make_spa() -> TransportParameter {
869 TransportParameter::PreferredAddress {
870 v4: Some(SocketAddrV4::new(Ipv4Addr::from(0xc000_0201), 443)),
871 v6: Some(SocketAddrV6::new(
872 Ipv6Addr::from(0xfe80_0000_0000_0000_0000_0000_0000_0001),
873 443,
874 0,
875 0,
876 )),
877 cid: ConnectionId::from(&[1, 2, 3, 4, 5]),
878 srt: [3; 16],
879 }
880 }
881
882 #[test]
883 fn preferred_address_encode_decode() {
884 const ENCODED: &[u8] = &[
885 0x0d, 0x2e, 0xc0, 0x00, 0x02, 0x01, 0x01, 0xbb, 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00,
886 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0xbb, 0x05, 0x01,
887 0x02, 0x03, 0x04, 0x05, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
888 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
889 ];
890 let spa = make_spa();
891 let mut enc = Encoder::new();
892 spa.encode(&mut enc, PreferredAddress);
893 assert_eq!(enc.as_ref(), ENCODED);
894
895 let mut dec = enc.as_decoder();
896 let (id, decoded) = TransportParameter::decode(&mut dec).unwrap().unwrap();
897 assert_eq!(id, PreferredAddress);
898 assert_eq!(decoded, spa);
899 }
900
901 fn mutate_spa<F>(wrecker: F) -> TransportParameter
902 where
903 F: FnOnce(&mut Option<SocketAddrV4>, &mut Option<SocketAddrV6>, &mut ConnectionId),
904 {
905 let mut spa = make_spa();
906 if let TransportParameter::PreferredAddress {
907 ref mut v4,
908 ref mut v6,
909 ref mut cid,
910 ..
911 } = &mut spa
912 {
913 wrecker(v4, v6, cid);
914 } else {
915 unreachable!();
916 }
917 spa
918 }
919
920 /// This takes a `TransportParameter::PreferredAddress` that has been mutilated.
921 /// It then encodes it, working from the knowledge that the `encode` function
922 /// doesn't care about validity, and decodes it. The result should be failure.
923 fn assert_invalid_spa(spa: &TransportParameter) {
924 let mut enc = Encoder::new();
925 spa.encode(&mut enc, PreferredAddress);
926 assert_eq!(
927 TransportParameter::decode(&mut enc.as_decoder()).unwrap_err(),
928 Error::TransportParameterError
929 );
930 }
931
932 /// This is for those rare mutations that are acceptable.
933 fn assert_valid_spa(spa: &TransportParameter) {
934 let mut enc = Encoder::new();
935 spa.encode(&mut enc, PreferredAddress);
936 let mut dec = enc.as_decoder();
937 let (id, decoded) = TransportParameter::decode(&mut dec).unwrap().unwrap();
938 assert_eq!(id, PreferredAddress);
939 assert_eq!(&decoded, spa);
940 }
941
942 #[test]
943 fn preferred_address_zero_address() {
944 // Either port being zero is bad.
945 assert_invalid_spa(&mutate_spa(|v4, _, _| {
946 v4.as_mut().unwrap().set_port(0);
947 }));
948 assert_invalid_spa(&mutate_spa(|_, v6, _| {
949 v6.as_mut().unwrap().set_port(0);
950 }));
951 // Either IP being zero is bad.
952 assert_invalid_spa(&mutate_spa(|v4, _, _| {
953 v4.as_mut().unwrap().set_ip(Ipv4Addr::from(0));
954 }));
955 assert_invalid_spa(&mutate_spa(|_, v6, _| {
956 v6.as_mut().unwrap().set_ip(Ipv6Addr::from(0));
957 }));
958 // Either address being absent is OK.
959 assert_valid_spa(&mutate_spa(|v4, _, _| {
960 *v4 = None;
961 }));
962 assert_valid_spa(&mutate_spa(|_, v6, _| {
963 *v6 = None;
964 }));
965 // Both addresses being absent is bad.
966 assert_invalid_spa(&mutate_spa(|v4, v6, _| {
967 *v4 = None;
968 *v6 = None;
969 }));
970 }
971
972 #[test]
973 fn preferred_address_bad_cid() {
974 assert_invalid_spa(&mutate_spa(|_, _, cid| {
975 *cid = ConnectionId::from(&[]);
976 }));
977 assert_invalid_spa(&mutate_spa(|_, _, cid| {
978 *cid = ConnectionId::from(&[0x0c; 21]);
979 }));
980 }
981
982 #[test]
983 fn preferred_address_truncated() {
984 let spa = make_spa();
985 let mut enc = Encoder::new();
986 spa.encode(&mut enc, PreferredAddress);
987 let mut dec = Decoder::from(&enc.as_ref()[..enc.len() - 1]);
988 assert_eq!(
989 TransportParameter::decode(&mut dec).unwrap_err(),
990 Error::NoMoreData
991 );
992 }
993
994 #[test]
995 #[should_panic(expected = "v4.is_some() || v6.is_some()")]
996 fn preferred_address_neither() {
997 _ = PreferredAddress::new(None, None);
998 }
999
1000 #[test]
1001 #[should_panic(expected = ".is_unspecified")]
1002 fn preferred_address_v4_unspecified() {
1003 _ = PreferredAddress::new(Some(SocketAddrV4::new(Ipv4Addr::from(0), 443)), None);
1004 }
1005
1006 #[test]
1007 #[should_panic(expected = "left != right")]
1008 fn preferred_address_v4_zero_port() {
1009 _ = PreferredAddress::new(
1010 Some(SocketAddrV4::new(Ipv4Addr::from(0xc000_0201), 0)),
1011 None,
1012 );
1013 }
1014
1015 #[test]
1016 #[should_panic(expected = ".is_unspecified")]
1017 fn preferred_address_v6_unspecified() {
1018 _ = PreferredAddress::new(None, Some(SocketAddrV6::new(Ipv6Addr::from(0), 443, 0, 0)));
1019 }
1020
1021 #[test]
1022 #[should_panic(expected = "left != right")]
1023 fn preferred_address_v6_zero_port() {
1024 _ = PreferredAddress::new(None, Some(SocketAddrV6::new(Ipv6Addr::from(1), 0, 0, 0)));
1025 }
1026
1027 #[test]
1028 fn compatible_0rtt_ignored_values() {
1029 let mut tps_a = TransportParameters::default();
1030 tps_a.set(
1031 StatelessResetToken,
1032 TransportParameter::Bytes(vec![1, 2, 3]),
1033 );
1034 tps_a.set(IdleTimeout, TransportParameter::Integer(10));
1035 tps_a.set(MaxAckDelay, TransportParameter::Integer(22));
1036 tps_a.set(ActiveConnectionIdLimit, TransportParameter::Integer(33));
1037
1038 let mut tps_b = TransportParameters::default();
1039 assert!(tps_a.ok_for_0rtt(&tps_b));
1040 assert!(tps_b.ok_for_0rtt(&tps_a));
1041
1042 tps_b.set(
1043 StatelessResetToken,
1044 TransportParameter::Bytes(vec![8, 9, 10]),
1045 );
1046 tps_b.set(IdleTimeout, TransportParameter::Integer(100));
1047 tps_b.set(MaxAckDelay, TransportParameter::Integer(2));
1048 tps_b.set(ActiveConnectionIdLimit, TransportParameter::Integer(44));
1049 assert!(tps_a.ok_for_0rtt(&tps_b));
1050 assert!(tps_b.ok_for_0rtt(&tps_a));
1051 }
1052
1053 #[test]
1054 fn compatible_0rtt_integers() {
1055 const INTEGER_KEYS: &[TransportParameterId] = &[
1056 InitialMaxData,
1057 InitialMaxStreamDataBidiLocal,
1058 InitialMaxStreamDataBidiRemote,
1059 InitialMaxStreamDataUni,
1060 InitialMaxStreamsBidi,
1061 InitialMaxStreamsUni,
1062 MaxUdpPayloadSize,
1063 MinAckDelay,
1064 MaxDatagramFrameSize,
1065 ];
1066
1067 let mut tps_a = TransportParameters::default();
1068 for i in INTEGER_KEYS {
1069 tps_a.set(*i, TransportParameter::Integer(12));
1070 }
1071
1072 let tps_b = tps_a.clone();
1073 assert!(tps_a.ok_for_0rtt(&tps_b));
1074 assert!(tps_b.ok_for_0rtt(&tps_a));
1075
1076 // For each integer key, choose a new value that will be accepted.
1077 for i in INTEGER_KEYS {
1078 let mut tps_b = tps_a.clone();
1079 // Set a safe new value; reducing MIN_ACK_DELAY instead.
1080 let safe_value = if *i == MinAckDelay { 11 } else { 13 };
1081 tps_b.set(*i, TransportParameter::Integer(safe_value));
1082 // If the new value is not safe relative to the remembered value,
1083 // then we can't attempt 0-RTT with these parameters.
1084 assert!(!tps_a.ok_for_0rtt(&tps_b));
1085 // The opposite situation is fine.
1086 assert!(tps_b.ok_for_0rtt(&tps_a));
1087 }
1088
1089 // Drop integer values and check that that is OK.
1090 for i in INTEGER_KEYS {
1091 let mut tps_b = tps_a.clone();
1092 tps_b.remove(*i);
1093 // A value that is missing from what is remembered is OK.
1094 assert!(tps_a.ok_for_0rtt(&tps_b));
1095 // A value that is remembered, but not current is not OK.
1096 assert!(!tps_b.ok_for_0rtt(&tps_a));
1097 }
1098 }
1099
1100 /// `ACTIVE_CONNECTION_ID_LIMIT` can't be less than 2.
1101 #[test]
1102 fn active_connection_id_limit_min_2() {
1103 let mut tps = TransportParameters::default();
1104
1105 // Intentionally set an invalid value for the ACTIVE_CONNECTION_ID_LIMIT transport
1106 // parameter.
1107 tps.params[ActiveConnectionIdLimit] = Some(TransportParameter::Integer(1));
1108
1109 let mut enc = Encoder::default();
1110 tps.encode(&mut enc);
1111
1112 // When decoding a set of transport parameters with an invalid ACTIVE_CONNECTION_ID_LIMIT
1113 // the result should be an error.
1114 let invalid_decode_result = TransportParameters::decode(&mut enc.as_decoder());
1115 assert!(invalid_decode_result.is_err());
1116 }
1117
1118 #[test]
1119 fn versions_encode_decode() {
1120 const ENCODED: &[u8] = &[
1121 0x11, 0x0c, 0x00, 0x00, 0x00, 0x01, 0x1a, 0x2a, 0x3a, 0x4a, 0x5a, 0x6a, 0x7a, 0x8a,
1122 ];
1123 let vn = TransportParameter::Versions {
1124 current: Version::Version1.wire_version(),
1125 other: vec![0x1a2a_3a4a, 0x5a6a_7a8a],
1126 };
1127
1128 let mut enc = Encoder::new();
1129 vn.encode(&mut enc, VersionInformation);
1130 assert_eq!(enc.as_ref(), ENCODED);
1131
1132 let mut dec = enc.as_decoder();
1133 let (id, decoded) = TransportParameter::decode(&mut dec).unwrap().unwrap();
1134 assert_eq!(id, VersionInformation);
1135 assert_eq!(decoded, vn);
1136 }
1137
1138 #[test]
1139 fn versions_truncated() {
1140 const TRUNCATED: &[u8] = &[
1141 0x80, 0xff, 0x73, 0xdb, 0x0c, 0x00, 0x00, 0x00, 0x01, 0x1a, 0x2a, 0x3a, 0x4a, 0x5a,
1142 0x6a, 0x7a,
1143 ];
1144 let mut dec = Decoder::from(&TRUNCATED);
1145 assert_eq!(
1146 TransportParameter::decode(&mut dec).unwrap_err(),
1147 Error::NoMoreData
1148 );
1149 }
1150
1151 #[test]
1152 fn versions_zero() {
1153 const ZERO1: &[u8] = &[0x11, 0x04, 0x00, 0x00, 0x00, 0x00];
1154 const ZERO2: &[u8] = &[0x11, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00];
1155
1156 let mut dec = Decoder::from(&ZERO1);
1157 assert_eq!(
1158 TransportParameter::decode(&mut dec).unwrap_err(),
1159 Error::TransportParameterError
1160 );
1161 let mut dec = Decoder::from(&ZERO2);
1162 assert_eq!(
1163 TransportParameter::decode(&mut dec).unwrap_err(),
1164 Error::TransportParameterError
1165 );
1166 }
1167
1168 #[test]
1169 fn versions_equal_0rtt() {
1170 let mut current = TransportParameters::default();
1171 qdebug!("Current = {:?}", current);
1172 current.set(
1173 VersionInformation,
1174 TransportParameter::Versions {
1175 current: Version::Version1.wire_version(),
1176 other: vec![0x1a2a_3a4a],
1177 },
1178 );
1179
1180 let mut remembered = TransportParameters::default();
1181 // It's OK to not remember having versions.
1182 assert!(current.ok_for_0rtt(&remembered));
1183 // But it is bad in the opposite direction.
1184 assert!(!remembered.ok_for_0rtt(&current));
1185
1186 // If the version matches, it's OK to use 0-RTT.
1187 remembered.set(
1188 VersionInformation,
1189 TransportParameter::Versions {
1190 current: Version::Version1.wire_version(),
1191 other: vec![0x5a6a_7a8a, 0x9aaa_baca],
1192 },
1193 );
1194 assert!(current.ok_for_0rtt(&remembered));
1195 assert!(remembered.ok_for_0rtt(&current));
1196
1197 // An apparent "upgrade" is still cause to reject 0-RTT.
1198 remembered.set(
1199 VersionInformation,
1200 TransportParameter::Versions {
1201 current: Version::Version1.wire_version() + 1,
1202 other: vec![],
1203 },
1204 );
1205 assert!(!current.ok_for_0rtt(&remembered));
1206 assert!(!remembered.ok_for_0rtt(&current));
1207 }
1208 }