tlspuffin/tls/rustls/msgs/
handshake.rs

1use std::{collections, fmt};
2
3use comparable::Comparable;
4use extractable_macro::Extractable;
5use puffin::codec::{Codec, Reader};
6use puffin::error::Error;
7use puffin::protocol::{Extractable, ProtocolTypes};
8use puffin::trace::{Knowledge, Source};
9use puffin::{atom_extract_knowledge, codec};
10
11use crate::protocol::TLSProtocolTypes;
12use crate::tls::fn_impl::fn_hello_retry_request_random;
13use crate::tls::rustls::msgs::base::{Payload, PayloadU16, PayloadU24, PayloadU8};
14use crate::tls::rustls::msgs::enums::{
15    CertificateStatusType, CipherSuite, ClientCertificateType, Compression, ECCurveType,
16    ECPointFormat, ExtensionType, HandshakeType, HashAlgorithm, KeyUpdateRequest, NamedGroup,
17    PSKKeyExchangeMode, ProtocolVersion, ServerNameType, SignatureAlgorithm, SignatureScheme,
18};
19use crate::tls::rustls::{key, rand};
20
21macro_rules! declare_u8_vec (
22  ($name:ident, $itemtype:ty) => {
23    #[derive(Debug, Clone, Comparable, PartialEq)]
24    pub struct $name(pub Vec<$itemtype>);
25
26    atom_extract_knowledge!(TLSProtocolTypes, $name);
27
28    impl puffin::codec::Codec for $name {
29      fn encode(&self, bytes: &mut Vec<u8>) {
30        puffin::codec::encode_vec_u8(bytes, &self.0);
31      }
32
33      fn read(r: &mut puffin::codec::Reader) -> Option<Self> {
34        Some($name(puffin::codec::read_vec_u8::<$itemtype>(r)?))
35      }
36    }
37  }
38);
39
40macro_rules! declare_u16_vec (
41  ($name:ident, $itemtype:ty) => {
42    #[derive(Debug, Clone, Comparable, PartialEq)]
43    pub struct $name(pub Vec<$itemtype>);
44
45    impl Extractable<TLSProtocolTypes> for $name {
46        fn extract_knowledge<'a>(
47            &'a self,
48            knowledges: &mut Vec<Knowledge<'a, TLSProtocolTypes>>,
49            matcher: Option<<TLSProtocolTypes as ProtocolTypes>::Matcher>,
50            source: &'a Source,
51        ) -> Result<(), Error> {
52            knowledges.push(Knowledge {
53                source,
54                matcher,
55                data: self,
56            });
57
58            for x in &self.0 {
59                x.extract_knowledge(knowledges, matcher, source)?;
60            }
61            Ok(())
62        }
63    }
64
65    impl puffin::codec::Codec for $name {
66      fn encode(&self, bytes: &mut Vec<u8>) {
67        puffin::codec::encode_vec_u16(bytes, &self.0);
68      }
69
70      fn read(r: &mut puffin::codec::Reader) -> Option<Self> {
71          if r.any_left() {
72              Some($name(puffin::codec::read_vec_u16::<$itemtype>(r)?))
73          } else {
74              Some($name(vec!()))
75          }
76      }
77    }
78  }
79);
80
81macro_rules! declare_u16_vec_empty (
82  ($name:ident, $itemtype:ty) => {
83    #[derive(Debug, Clone, Extractable, Comparable)]
84    #[extractable(TLSProtocolTypes)]
85    pub struct $name(pub Vec<$itemtype>);
86
87
88    impl puffin::codec::Codec for $name {
89      fn encode(&self, bytes: &mut Vec<u8>) {
90          if !self.0.is_empty() { // for optional fields such as ClientExtensions
91            puffin::codec::encode_vec_u16(bytes, &self.0);
92          }
93      }
94
95      fn read(r: &mut puffin::codec::Reader) -> Option<Self> {
96          log::trace!("Starting declare_u16_vec_empty of base type {}...", std::any::type_name::<$name>());
97          if r.any_left() {
98              Some($name(puffin::codec::read_vec_u16::<$itemtype>(r)?)) // we still try to read even though we might
99                // mis-interpret a ['0'] as being the empty list, which is must however must be serialized as [] (empty bittstring).
100                // This is a trade-off we accept to be able to correctly read in most cases (non-empty lists).
101                // Moroever, when reading a struct containing $name as a field, we shall first check that there is remaining
102                // bytes to read!
103          } else {
104              Some($name(vec!()))
105         }
106      }
107    }
108  }
109);
110
111macro_rules! declare_u24_vec_limited (
112  ($name:ident, $itemtype:ty) => {
113    #[derive(Debug, Clone, Comparable)]
114    pub struct $name(pub Vec<$itemtype>);
115
116    atom_extract_knowledge!(TLSProtocolTypes, $name);
117
118    impl puffin::codec::Codec for $name {
119      fn encode(&self, bytes: &mut Vec<u8>) {
120        puffin::codec::encode_vec_u24(bytes, &self.0);
121      }
122
123      fn read(r: &mut puffin::codec::Reader) -> Option<Self> {
124          if r.any_left() {
125              Some($name(puffin::codec::read_vec_u24_limited::<$itemtype>(r, 0x10000)?))
126          } else {
127              Some($name(vec!()))
128          }
129      }
130    }
131  }
132);
133
134declare_u16_vec!(VecU16OfPayloadU8, PayloadU8);
135declare_u16_vec!(VecU16OfPayloadU16, PayloadU16);
136
137#[derive(Clone, Copy, Debug, PartialEq, Comparable)]
138pub struct Random(pub [u8; 32]);
139
140static ZERO_RANDOM: Random = Random([0u8; 32]);
141
142impl codec::Codec for Random {
143    fn encode(&self, bytes: &mut Vec<u8>) {
144        bytes.extend_from_slice(&self.0);
145    }
146
147    fn read(r: &mut codec::Reader) -> Option<Self> {
148        let bytes = r.take(32)?;
149        let mut opaque = [0; 32];
150        opaque.clone_from_slice(bytes);
151
152        Some(Self(opaque))
153    }
154}
155
156impl Random {
157    pub fn new() -> Result<Self, rand::GetRandomFailed> {
158        let mut data = [0u8; 32];
159        rand::fill_random(&mut data)?;
160        Ok(Self(data))
161    }
162
163    pub fn write_slice(&self, bytes: &mut [u8]) {
164        let buf = self.get_encoding();
165        bytes.copy_from_slice(&buf);
166    }
167}
168
169impl From<[u8; 32]> for Random {
170    #[inline]
171    fn from(bytes: [u8; 32]) -> Self {
172        Self(bytes)
173    }
174}
175
176#[derive(Copy, Clone, Comparable)]
177pub struct SessionID {
178    len: usize,
179    data: [u8; 32],
180}
181
182impl fmt::Debug for SessionID {
183    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
184        f.debug_tuple("SessionID")
185            .field(&&self.data[..self.len]) // must be `Sized` to cast to `dyn Debug`
186            .finish()
187    }
188}
189
190impl PartialEq for SessionID {
191    fn eq(&self, other: &Self) -> bool {
192        if self.len != other.len {
193            return false;
194        }
195
196        let mut diff = 0u8;
197        for i in 0..self.len {
198            diff |= self.data[i] ^ other.data[i]
199        }
200
201        diff == 0u8
202    }
203}
204
205impl codec::Codec for SessionID {
206    fn encode(&self, bytes: &mut Vec<u8>) {
207        debug_assert!(self.len <= 32);
208        bytes.push(self.len as u8);
209        bytes.extend_from_slice(&self.data[..self.len]);
210    }
211
212    fn read(r: &mut codec::Reader) -> Option<Self> {
213        let len = u8::read(r)? as usize;
214        if len > 32 {
215            return None;
216        }
217
218        let bytes = r.take(len)?;
219        let mut out = [0u8; 32];
220        out[..len].clone_from_slice(&bytes[..len]);
221
222        Some(Self { data: out, len })
223    }
224}
225
226impl SessionID {
227    pub fn random() -> Result<Self, rand::GetRandomFailed> {
228        let mut data = [0u8; 32];
229        rand::fill_random(&mut data)?;
230        Ok(Self { data, len: 32 })
231    }
232
233    pub fn empty() -> Self {
234        Self {
235            data: [0u8; 32],
236            len: 0,
237        }
238    }
239
240    pub fn len(&self) -> usize {
241        self.len
242    }
243
244    pub fn is_empty(&self) -> bool {
245        self.len == 0
246    }
247}
248
249#[derive(Clone, Debug, Extractable, Comparable, PartialEq)]
250#[extractable(TLSProtocolTypes)]
251pub struct UnknownExtension {
252    pub typ: ExtensionType,
253    #[comparable_ignore]
254    pub payload: Payload,
255}
256
257impl UnknownExtension {
258    fn encode(&self, bytes: &mut Vec<u8>) {
259        self.payload.encode(bytes);
260    }
261
262    fn read(typ: ExtensionType, r: &mut codec::Reader) -> Self {
263        let payload = Payload::read(r);
264        Self { typ, payload }
265    }
266}
267
268declare_u8_vec!(ECPointFormatList, ECPointFormat);
269
270pub trait SupportedPointFormats {
271    fn supported() -> ECPointFormatList;
272}
273
274impl SupportedPointFormats for ECPointFormatList {
275    fn supported() -> ECPointFormatList {
276        ECPointFormatList(vec![ECPointFormat::Uncompressed]) // TODO-Mapper: could be extended to
277                                                             // change
278                                                             // this field
279    }
280}
281
282declare_u16_vec!(NamedGroups, NamedGroup);
283
284declare_u16_vec!(SupportedSignatureSchemes, SignatureScheme);
285
286pub trait DecomposedSignatureScheme {
287    fn sign(&self) -> SignatureAlgorithm;
288    fn make(alg: SignatureAlgorithm, hash: HashAlgorithm) -> SignatureScheme;
289}
290
291impl DecomposedSignatureScheme for SignatureScheme {
292    fn sign(&self) -> SignatureAlgorithm {
293        match *self {
294            Self::RSA_PKCS1_SHA1
295            | Self::RSA_PKCS1_SHA256
296            | Self::RSA_PKCS1_SHA384
297            | Self::RSA_PKCS1_SHA512
298            | Self::RSA_PSS_SHA256
299            | Self::RSA_PSS_SHA384
300            | Self::RSA_PSS_SHA512 => SignatureAlgorithm::RSA,
301            Self::ECDSA_NISTP256_SHA256
302            | Self::ECDSA_NISTP384_SHA384
303            | Self::ECDSA_NISTP521_SHA512 => SignatureAlgorithm::ECDSA,
304            _ => SignatureAlgorithm::Unknown(0),
305        }
306    }
307
308    fn make(alg: SignatureAlgorithm, hash: HashAlgorithm) -> SignatureScheme {
309        use crate::tls::rustls::msgs::enums::HashAlgorithm::{SHA1, SHA256, SHA384, SHA512};
310        use crate::tls::rustls::msgs::enums::SignatureAlgorithm::{ECDSA, RSA};
311
312        match (alg, hash) {
313            (RSA, SHA1) => Self::RSA_PKCS1_SHA1,
314            (RSA, SHA256) => Self::RSA_PKCS1_SHA256,
315            (RSA, SHA384) => Self::RSA_PKCS1_SHA384,
316            (RSA, SHA512) => Self::RSA_PKCS1_SHA512,
317            (ECDSA, SHA256) => Self::ECDSA_NISTP256_SHA256,
318            (ECDSA, SHA384) => Self::ECDSA_NISTP384_SHA384,
319            (ECDSA, SHA512) => Self::ECDSA_NISTP521_SHA512,
320            (_, _) => unreachable!(),
321        }
322    }
323}
324
325#[derive(Clone, Debug, PartialEq)]
326pub enum ServerNamePayload {
327    // Stored twice, bytes so we can round-trip, and DnsName for use
328    HostName((PayloadU16, webpki::DnsName)),
329    Unknown(Payload),
330}
331
332impl ServerNamePayload {
333    pub fn new_hostname(hostname: webpki::DnsName) -> Self {
334        let raw = {
335            let s: &str = hostname.as_ref().into();
336            PayloadU16::new(s.as_bytes().into())
337        };
338        Self::HostName((raw, hostname))
339    }
340
341    fn read_hostname(r: &mut codec::Reader) -> Option<Self> {
342        let raw = PayloadU16::read(r)?;
343
344        let dns_name = {
345            match webpki::DnsNameRef::try_from_ascii(&raw.0) {
346                Ok(dns_name) => dns_name.into(),
347                Err(_) => {
348                    //log::warn!("Illegal SNI hostname received {:?}", raw.0);
349                    return None;
350                }
351            }
352        };
353        Some(Self::HostName((raw, dns_name)))
354    }
355
356    fn encode(&self, bytes: &mut Vec<u8>) {
357        match *self {
358            Self::HostName((ref r, _)) => r.encode(bytes),
359            Self::Unknown(ref r) => r.encode(bytes),
360        }
361    }
362}
363
364#[derive(Clone, Debug, Extractable, Comparable, PartialEq)]
365#[extractable(TLSProtocolTypes)]
366pub struct ServerName {
367    // Fields in this struct could probably be aligned but for now they are ignored
368    #[extractable_ignore]
369    pub typ: ServerNameType,
370    #[extractable_ignore]
371    #[comparable_ignore]
372    pub payload: ServerNamePayload,
373}
374
375impl codec::Codec for ServerName {
376    fn encode(&self, bytes: &mut Vec<u8>) {
377        self.typ.encode(bytes);
378        self.payload.encode(bytes);
379    }
380
381    fn read(r: &mut codec::Reader) -> Option<Self> {
382        let typ = ServerNameType::read(r)?;
383
384        let payload = match typ {
385            ServerNameType::HostName => ServerNamePayload::read_hostname(r)?,
386            _ => ServerNamePayload::Unknown(Payload::read(r)),
387        };
388
389        Some(Self { typ, payload })
390    }
391}
392
393declare_u16_vec!(ServerNameRequest, ServerName);
394
395pub trait ConvertServerNameList {
396    fn has_duplicate_names_for_type(&self) -> bool;
397    fn get_single_hostname(&self) -> Option<webpki::DnsNameRef<'_>>;
398}
399
400impl ConvertServerNameList for ServerNameRequest {
401    /// RFC6066: "The ServerNameList MUST NOT contain more than one name of the same name_type."
402    fn has_duplicate_names_for_type(&self) -> bool {
403        let mut seen = collections::HashSet::new();
404
405        for name in &self.0 {
406            if !seen.insert(name.typ.get_u8()) {
407                return true;
408            }
409        }
410
411        false
412    }
413
414    fn get_single_hostname(&self) -> Option<webpki::DnsNameRef<'_>> {
415        fn only_dns_hostnames(name: &ServerName) -> Option<webpki::DnsNameRef<'_>> {
416            if let ServerNamePayload::HostName((_, ref dns)) = name.payload {
417                Some(dns.as_ref())
418            } else {
419                None
420            }
421        }
422
423        self.0.iter().filter_map(only_dns_hostnames).next()
424    }
425}
426
427pub type ProtocolNameList = VecU16OfPayloadU8;
428
429pub trait ConvertProtocolNameList {
430    fn from_slices(names: &[&[u8]]) -> Self;
431    fn to_slices(&self) -> Vec<&[u8]>;
432    fn as_single_slice(&self) -> Option<&[u8]>;
433}
434
435impl ConvertProtocolNameList for ProtocolNameList {
436    fn from_slices(names: &[&[u8]]) -> Self {
437        let mut ret = VecU16OfPayloadU8(Vec::new());
438
439        for name in names {
440            ret.0.push(PayloadU8::new(name.to_vec()));
441        }
442
443        ret
444    }
445
446    fn to_slices(&self) -> Vec<&[u8]> {
447        self.0
448            .iter()
449            .map(|proto| -> &[u8] { &proto.0 })
450            .collect::<Vec<&[u8]>>()
451    }
452
453    fn as_single_slice(&self) -> Option<&[u8]> {
454        if self.0.len() == 1 {
455            Some(&self.0[0].0)
456        } else {
457            None
458        }
459    }
460}
461
462// --- TLS 1.3 Key shares ---
463#[derive(Clone, Debug, Extractable, Comparable, PartialEq)]
464#[extractable(TLSProtocolTypes)]
465pub struct KeyShareEntry {
466    pub group: NamedGroup,
467    #[comparable_ignore]
468    pub payload: PayloadU16,
469}
470
471impl KeyShareEntry {
472    pub fn new(group: NamedGroup, payload: &[u8]) -> Self {
473        Self {
474            group,
475            payload: PayloadU16::new(payload.to_vec()),
476        }
477    }
478}
479
480impl codec::Codec for KeyShareEntry {
481    fn encode(&self, bytes: &mut Vec<u8>) {
482        self.group.encode(bytes);
483        self.payload.encode(bytes);
484    }
485
486    fn read(r: &mut codec::Reader) -> Option<Self> {
487        let group = NamedGroup::read(r)?;
488        let payload = PayloadU16::read(r)?;
489
490        Some(Self { group, payload })
491    }
492}
493
494// --- TLS 1.3 PresharedKey offers ---
495#[derive(Clone, Debug, Comparable, PartialEq)]
496pub struct PresharedKeyIdentity {
497    #[comparable_ignore]
498    pub identity: PayloadU16,
499    #[comparable_ignore]
500    pub obfuscated_ticket_age: u32,
501}
502
503impl PresharedKeyIdentity {
504    pub fn new(id: Vec<u8>, age: u32) -> Self {
505        Self {
506            identity: PayloadU16::new(id),
507            obfuscated_ticket_age: age,
508        }
509    }
510}
511
512impl codec::Codec for PresharedKeyIdentity {
513    fn encode(&self, bytes: &mut Vec<u8>) {
514        self.identity.encode(bytes);
515        self.obfuscated_ticket_age.encode(bytes);
516    }
517
518    fn read(r: &mut codec::Reader) -> Option<Self> {
519        Some(Self {
520            identity: PayloadU16::read(r)?,
521            obfuscated_ticket_age: u32::read(r)?,
522        })
523    }
524}
525
526declare_u16_vec!(PresharedKeyIdentities, PresharedKeyIdentity);
527pub type PresharedKeyBinder = PayloadU8;
528pub type PresharedKeyBinders = VecU16OfPayloadU8;
529
530#[derive(Clone, Debug, Extractable, PartialEq, Comparable)]
531#[extractable(TLSProtocolTypes)]
532pub struct PresharedKeyOffer {
533    #[extractable_ignore]
534    pub identities: PresharedKeyIdentities,
535    #[extractable_ignore]
536    pub binders: PresharedKeyBinders,
537}
538
539impl PresharedKeyOffer {
540    /// Make a new one with one entry.
541    pub fn new(id: PresharedKeyIdentity, binder: Vec<u8>) -> Self {
542        Self {
543            identities: PresharedKeyIdentities(vec![id]), /* TODO-Mapper: could be extended to
544                                                           * change
545                                                           * this field */
546            binders: VecU16OfPayloadU8(vec![PresharedKeyBinder::new(binder)]), /* TODO-Mapper:
547                                                                                * could
548                                                                                * be extended to
549                                                                                * change this
550                                                                                * field */
551        }
552    }
553}
554
555impl codec::Codec for PresharedKeyOffer {
556    fn encode(&self, bytes: &mut Vec<u8>) {
557        self.identities.encode(bytes);
558        self.binders.encode(bytes);
559    }
560
561    fn read(r: &mut codec::Reader) -> Option<Self> {
562        Some(Self {
563            identities: PresharedKeyIdentities::read(r)?,
564            binders: PresharedKeyBinders::read(r)?,
565        })
566    }
567}
568
569// --- RFC6066 certificate status request ---
570type ResponderIDs = VecU16OfPayloadU16;
571
572#[derive(Clone, Debug, PartialEq, Comparable)]
573pub struct OCSPCertificateStatusRequest {
574    // Fields in this struct were previously ignored but do no seem to introduce differences
575    pub responder_ids: ResponderIDs,
576    pub extensions: PayloadU16,
577}
578
579impl codec::Codec for OCSPCertificateStatusRequest {
580    fn encode(&self, bytes: &mut Vec<u8>) {
581        CertificateStatusType::OCSP.encode(bytes);
582        self.responder_ids.encode(bytes);
583        self.extensions.encode(bytes);
584    }
585
586    fn read(r: &mut codec::Reader) -> Option<Self> {
587        Some(Self {
588            responder_ids: ResponderIDs::read(r)?,
589            extensions: PayloadU16::read(r)?,
590        })
591    }
592}
593
594#[derive(Clone, Debug, Extractable, PartialEq, Comparable)]
595#[extractable(TLSProtocolTypes)]
596pub enum CertificateStatusRequest {
597    OCSP(#[extractable_ignore] OCSPCertificateStatusRequest),
598    Unknown(#[extractable_ignore] (CertificateStatusType, Payload)),
599}
600
601impl codec::Codec for CertificateStatusRequest {
602    fn encode(&self, bytes: &mut Vec<u8>) {
603        match self {
604            Self::OCSP(ref r) => r.encode(bytes),
605            Self::Unknown((typ, payload)) => {
606                typ.encode(bytes);
607                payload.encode(bytes);
608            }
609        }
610    }
611
612    fn read(r: &mut codec::Reader) -> Option<Self> {
613        let typ = CertificateStatusType::read(r)?;
614
615        match typ {
616            CertificateStatusType::OCSP => {
617                let ocsp_req = OCSPCertificateStatusRequest::read(r)?;
618                Some(Self::OCSP(ocsp_req))
619            }
620            _ => {
621                let data = Payload::read(r);
622                Some(Self::Unknown((typ, data)))
623            }
624        }
625    }
626}
627
628impl CertificateStatusRequest {
629    pub fn build_ocsp() -> Self {
630        let ocsp = OCSPCertificateStatusRequest {
631            responder_ids: VecU16OfPayloadU16(Vec::new()),
632            extensions: PayloadU16::empty(),
633        };
634        Self::OCSP(ocsp)
635    }
636}
637
638// ---
639// SCTs
640
641pub type SCTList = VecU16OfPayloadU16;
642
643// ---
644
645declare_u8_vec!(PSKKeyExchangeModes, PSKKeyExchangeMode);
646declare_u16_vec!(KeyShareEntries, KeyShareEntry);
647declare_u8_vec!(ProtocolVersions, ProtocolVersion);
648
649#[derive(Debug, Clone, Extractable, PartialEq, Comparable)]
650#[extractable(TLSProtocolTypes)]
651pub enum ClientExtension {
652    // `ECPointFormats` is ignored as the not all implementations send this extension
653    ECPointFormats(#[comparable_ignore] ECPointFormatList),
654    NamedGroups(NamedGroups),
655    SignatureAlgorithms(SupportedSignatureSchemes),
656    ServerName(ServerNameRequest),
657    SessionTicket(ClientSessionTicket),
658    Protocols(ProtocolNameList),
659    SupportedVersions(ProtocolVersions),
660    KeyShare(KeyShareEntries),
661    PresharedKeyModes(PSKKeyExchangeModes),
662    PresharedKey(PresharedKeyOffer),
663    Cookie(PayloadU16),
664    ExtendedMasterSecretRequest,
665    CertificateStatusRequest(CertificateStatusRequest),
666    SignedCertificateTimestampRequest,
667    TransportParameters(Vec<u8>),
668    TransportParametersDraft(Vec<u8>),
669    EarlyData,
670    RenegotiationInfo(PayloadU8),
671    SignatureAlgorithmsCert(SupportedSignatureSchemes),
672    Unknown(UnknownExtension),
673}
674
675impl ClientExtension {
676    pub fn get_type(&self) -> ExtensionType {
677        match *self {
678            Self::ECPointFormats(_) => ExtensionType::ECPointFormats,
679            Self::NamedGroups(_) => ExtensionType::EllipticCurves,
680            Self::SignatureAlgorithms(_) => ExtensionType::SignatureAlgorithms,
681            Self::ServerName(_) => ExtensionType::ServerName,
682            Self::SessionTicket(_) => ExtensionType::SessionTicket,
683            Self::Protocols(_) => ExtensionType::ALProtocolNegotiation,
684            Self::SupportedVersions(_) => ExtensionType::SupportedVersions,
685            Self::KeyShare(_) => ExtensionType::KeyShare,
686            Self::PresharedKeyModes(_) => ExtensionType::PSKKeyExchangeModes,
687            Self::PresharedKey(_) => ExtensionType::PreSharedKey,
688            Self::Cookie(_) => ExtensionType::Cookie,
689            Self::ExtendedMasterSecretRequest => ExtensionType::ExtendedMasterSecret,
690            Self::CertificateStatusRequest(_) => ExtensionType::StatusRequest,
691            Self::SignedCertificateTimestampRequest => ExtensionType::SCT,
692            Self::TransportParameters(_) => ExtensionType::TransportParameters,
693            Self::TransportParametersDraft(_) => ExtensionType::TransportParametersDraft,
694            Self::EarlyData => ExtensionType::EarlyData,
695            ClientExtension::RenegotiationInfo(_) => ExtensionType::RenegotiationInfo,
696            Self::SignatureAlgorithmsCert(_) => ExtensionType::SignatureAlgorithmsCert,
697            Self::Unknown(ref r) => r.typ,
698        }
699    }
700}
701
702impl codec::Codec for ClientExtension {
703    fn encode(&self, bytes: &mut Vec<u8>) {
704        self.get_type().encode(bytes);
705
706        let mut sub: Vec<u8> = Vec::new();
707        match *self {
708            Self::ECPointFormats(ref r) => r.encode(&mut sub),
709            Self::NamedGroups(ref r) => r.encode(&mut sub),
710            Self::SignatureAlgorithms(ref r) => r.encode(&mut sub),
711            Self::ServerName(ref r) => r.encode(&mut sub),
712            Self::SessionTicket(ClientSessionTicket::Request)
713            | Self::ExtendedMasterSecretRequest
714            | Self::SignedCertificateTimestampRequest
715            | Self::EarlyData => {}
716            Self::SessionTicket(ClientSessionTicket::Offer(ref r)) => r.encode(&mut sub),
717            Self::Protocols(ref r) => r.encode(&mut sub),
718            Self::SupportedVersions(ref r) => r.encode(&mut sub),
719            Self::KeyShare(ref r) => r.encode(&mut sub),
720            Self::PresharedKeyModes(ref r) => r.encode(&mut sub),
721            Self::PresharedKey(ref r) => r.encode(&mut sub),
722            Self::Cookie(ref r) => r.encode(&mut sub),
723            Self::CertificateStatusRequest(ref r) => r.encode(&mut sub),
724            Self::TransportParameters(ref r) | Self::TransportParametersDraft(ref r) => {
725                sub.extend_from_slice(r)
726            }
727            Self::RenegotiationInfo(ref r) => r.encode(&mut sub),
728            Self::SignatureAlgorithmsCert(ref r) => r.encode(&mut sub),
729            Self::Unknown(ref r) => r.encode(&mut sub),
730        }
731
732        (sub.len() as u16).encode(bytes);
733        bytes.append(&mut sub);
734    }
735
736    fn read(r: &mut codec::Reader) -> Option<Self> {
737        let typ = ExtensionType::read(r)?;
738        let len = u16::read(r)? as usize;
739        let mut sub = r.sub(len)?;
740
741        let ext = match typ {
742            ExtensionType::ECPointFormats => {
743                Self::ECPointFormats(ECPointFormatList::read(&mut sub)?)
744            }
745            ExtensionType::EllipticCurves => Self::NamedGroups(NamedGroups::read(&mut sub)?),
746            ExtensionType::SignatureAlgorithms => {
747                let schemes = SupportedSignatureSchemes::read(&mut sub)?;
748                Self::SignatureAlgorithms(schemes)
749            }
750            ExtensionType::ServerName => Self::ServerName(ServerNameRequest::read(&mut sub)?),
751            ExtensionType::SessionTicket => {
752                if sub.any_left() {
753                    let contents = Payload::read(&mut sub);
754                    Self::SessionTicket(ClientSessionTicket::Offer(contents))
755                } else {
756                    Self::SessionTicket(ClientSessionTicket::Request)
757                }
758            }
759            ExtensionType::ALProtocolNegotiation => {
760                Self::Protocols(ProtocolNameList::read(&mut sub)?)
761            }
762            ExtensionType::SupportedVersions => {
763                Self::SupportedVersions(ProtocolVersions::read(&mut sub)?)
764            }
765            ExtensionType::KeyShare => Self::KeyShare(KeyShareEntries::read(&mut sub)?),
766            ExtensionType::PSKKeyExchangeModes => {
767                Self::PresharedKeyModes(PSKKeyExchangeModes::read(&mut sub)?)
768            }
769            ExtensionType::PreSharedKey => Self::PresharedKey(PresharedKeyOffer::read(&mut sub)?),
770            ExtensionType::Cookie => Self::Cookie(PayloadU16::read(&mut sub)?),
771            ExtensionType::ExtendedMasterSecret if !sub.any_left() => {
772                Self::ExtendedMasterSecretRequest
773            }
774            ExtensionType::StatusRequest => {
775                let csr = CertificateStatusRequest::read(&mut sub)?;
776                Self::CertificateStatusRequest(csr)
777            }
778            ExtensionType::SCT if !sub.any_left() => Self::SignedCertificateTimestampRequest,
779            ExtensionType::TransportParameters => Self::TransportParameters(sub.rest().to_vec()),
780            ExtensionType::TransportParametersDraft => {
781                Self::TransportParametersDraft(sub.rest().to_vec())
782            }
783            ExtensionType::RenegotiationInfo => {
784                let mut content_without_size = sub.rest().to_vec();
785                if !content_without_size.is_empty() {
786                    content_without_size = content_without_size[1..].to_vec() // because PayloadU8::new adds one byte for the length already
787                }
788                Self::RenegotiationInfo(PayloadU8::new(content_without_size))
789            }
790            ExtensionType::SignatureAlgorithmsCert => {
791                let schemes = SupportedSignatureSchemes::read(&mut sub)?;
792                ClientExtension::SignatureAlgorithmsCert(schemes)
793            }
794            ExtensionType::EarlyData if !sub.any_left() => Self::EarlyData,
795            _ => Self::Unknown(UnknownExtension::read(typ, &mut sub)),
796        };
797
798        if sub.any_left() {
799            None
800        } else {
801            Some(ext)
802        }
803    }
804}
805
806fn trim_hostname_trailing_dot_for_sni(dns_name: webpki::DnsNameRef) -> webpki::DnsName {
807    let dns_name_str: &str = dns_name.into();
808
809    // RFC6066: "The hostname is represented as a byte string using
810    // ASCII encoding without a trailing dot"
811    if dns_name_str.ends_with('.') {
812        let trimmed = &dns_name_str[0..dns_name_str.len() - 1];
813        webpki::DnsNameRef::try_from_ascii_str(trimmed)
814            .unwrap()
815            .to_owned()
816    } else {
817        dns_name.to_owned()
818    }
819}
820
821impl ClientExtension {
822    /// Make a basic SNI ServerNameRequest quoting `hostname`.
823    pub fn make_sni(dns_name: webpki::DnsNameRef) -> Self {
824        let name = ServerName {
825            typ: ServerNameType::HostName,
826            payload: ServerNamePayload::new_hostname(trim_hostname_trailing_dot_for_sni(dns_name)),
827        };
828
829        Self::ServerName(ServerNameRequest(vec![name])) // TODO-Mapper: could be extended to change
830                                                        // this
831                                                        // field
832    }
833}
834
835#[derive(Clone, Debug, Extractable, Comparable, PartialEq)]
836#[extractable(TLSProtocolTypes)]
837pub enum ClientSessionTicket {
838    Request,
839    Offer(#[extractable_ignore] Payload),
840}
841
842#[derive(Clone, Debug, PartialEq, Comparable)]
843pub enum ServerExtension {
844    // `ECPointFormats` is ignored as the not all implementations send this extension
845    ECPointFormats(#[comparable_ignore] ECPointFormatList),
846    ServerNameAck,
847    SessionTicketAck,
848    RenegotiationInfo(PayloadU8),
849    Protocols(ProtocolNameList),
850    KeyShare(KeyShareEntry),
851    PresharedKey(u16),
852    ExtendedMasterSecretAck,
853    CertificateStatusAck,
854    SignedCertificateTimestamp(SCTList),
855    SupportedVersions(ProtocolVersion),
856    TransportParameters(Vec<u8>),
857    TransportParametersDraft(Vec<u8>),
858    EarlyData,
859    Unknown(UnknownExtension),
860}
861
862impl ServerExtension {
863    pub fn get_type(&self) -> ExtensionType {
864        match *self {
865            Self::ECPointFormats(_) => ExtensionType::ECPointFormats,
866            Self::ServerNameAck => ExtensionType::ServerName,
867            Self::SessionTicketAck => ExtensionType::SessionTicket,
868            Self::RenegotiationInfo(_) => ExtensionType::RenegotiationInfo,
869            Self::Protocols(_) => ExtensionType::ALProtocolNegotiation,
870            Self::KeyShare(_) => ExtensionType::KeyShare,
871            Self::PresharedKey(_) => ExtensionType::PreSharedKey,
872            Self::ExtendedMasterSecretAck => ExtensionType::ExtendedMasterSecret,
873            Self::CertificateStatusAck => ExtensionType::StatusRequest,
874            Self::SignedCertificateTimestamp(_) => ExtensionType::SCT,
875            Self::SupportedVersions(_) => ExtensionType::SupportedVersions,
876            Self::TransportParameters(_) => ExtensionType::TransportParameters,
877            Self::TransportParametersDraft(_) => ExtensionType::TransportParametersDraft,
878            Self::EarlyData => ExtensionType::EarlyData,
879            Self::Unknown(ref r) => r.typ,
880        }
881    }
882}
883
884impl codec::Codec for ServerExtension {
885    fn encode(&self, bytes: &mut Vec<u8>) {
886        self.get_type().encode(bytes);
887
888        let mut sub: Vec<u8> = Vec::new();
889        match *self {
890            Self::ECPointFormats(ref r) => r.encode(&mut sub),
891            Self::ServerNameAck
892            | Self::SessionTicketAck
893            | Self::ExtendedMasterSecretAck
894            | Self::CertificateStatusAck
895            | Self::EarlyData => {}
896            Self::RenegotiationInfo(ref r) => r.encode(&mut sub),
897            Self::Protocols(ref r) => r.encode(&mut sub),
898            Self::KeyShare(ref r) => r.encode(&mut sub),
899            Self::PresharedKey(r) => r.encode(&mut sub),
900            Self::SignedCertificateTimestamp(ref r) => r.encode(&mut sub),
901            Self::SupportedVersions(ref r) => r.encode(&mut sub),
902            Self::TransportParameters(ref r) | Self::TransportParametersDraft(ref r) => {
903                sub.extend_from_slice(r)
904            }
905            Self::Unknown(ref r) => r.encode(&mut sub),
906        }
907
908        (sub.len() as u16).encode(bytes);
909        bytes.append(&mut sub);
910    }
911
912    fn read(r: &mut codec::Reader) -> Option<Self> {
913        let typ = ExtensionType::read(r)?;
914        let len = u16::read(r)? as usize;
915        let mut sub = r.sub(len)?;
916
917        let ext = match typ {
918            ExtensionType::ECPointFormats => {
919                Self::ECPointFormats(ECPointFormatList::read(&mut sub)?)
920            }
921            ExtensionType::ServerName => Self::ServerNameAck,
922            ExtensionType::SessionTicket => Self::SessionTicketAck,
923            ExtensionType::StatusRequest => Self::CertificateStatusAck,
924            ExtensionType::RenegotiationInfo => Self::RenegotiationInfo(PayloadU8::read(&mut sub)?),
925            ExtensionType::ALProtocolNegotiation => {
926                Self::Protocols(ProtocolNameList::read(&mut sub)?)
927            }
928            ExtensionType::KeyShare => Self::KeyShare(KeyShareEntry::read(&mut sub)?),
929            ExtensionType::PreSharedKey => Self::PresharedKey(u16::read(&mut sub)?),
930            ExtensionType::ExtendedMasterSecret => Self::ExtendedMasterSecretAck,
931            ExtensionType::SCT => {
932                let scts = SCTList::read(&mut sub)?;
933                Self::SignedCertificateTimestamp(scts)
934            }
935            ExtensionType::SupportedVersions => {
936                Self::SupportedVersions(ProtocolVersion::read(&mut sub)?)
937            }
938            ExtensionType::TransportParameters => Self::TransportParameters(sub.rest().to_vec()),
939            ExtensionType::TransportParametersDraft => {
940                Self::TransportParametersDraft(sub.rest().to_vec())
941            }
942            ExtensionType::EarlyData => Self::EarlyData,
943            _ => Self::Unknown(UnknownExtension::read(typ, &mut sub)),
944        };
945
946        if sub.any_left() {
947            None
948        } else {
949            Some(ext)
950        }
951    }
952}
953
954impl ServerExtension {
955    pub fn make_alpn(proto: &[&[u8]]) -> Self {
956        Self::Protocols(ProtocolNameList::from_slices(proto))
957    }
958
959    pub fn make_empty_renegotiation_info() -> Self {
960        let empty = Vec::new();
961        Self::RenegotiationInfo(PayloadU8::new(empty))
962    }
963
964    pub fn make_sct(sctl: Vec<u8>) -> Self {
965        let scts = SCTList::read_bytes(&sctl).expect("invalid SCT list");
966        Self::SignedCertificateTimestamp(scts)
967    }
968}
969
970declare_u16_vec_empty!(ClientExtensions, ClientExtension);
971declare_u16_vec!(CipherSuites, CipherSuite);
972declare_u8_vec!(Compressions, Compression);
973
974#[derive(Debug, Clone, Extractable, Comparable)]
975#[extractable(TLSProtocolTypes)]
976pub struct ClientHelloPayload {
977    #[comparable_synthetic {
978        let sorted_cipher_suites = |x: &Self| -> CipherSuites {
979            // we ignore `TLS_EMPTY_RENEGOTIATION_INFO_SCSV` as it is not present on all TLS 1.2 PUTs
980            let mut ciphers = CipherSuites(x.cipher_suites.0.iter().filter(|c| ! matches!(c, CipherSuite::TLS_EMPTY_RENEGOTIATION_INFO_SCSV)).cloned().collect());
981            ciphers.0.sort_by(puffin::codec::compare_encoding);
982            ciphers
983        };
984    }]
985    #[comparable_synthetic {
986        let sorted_extensions = |x: &Self| -> ClientExtensions { let mut ext = x.extensions.clone(); ext.0.sort_by(puffin::codec::compare_encoding); ext };
987    }]
988    pub client_version: ProtocolVersion,
989    #[comparable_ignore]
990    pub random: Random,
991    #[comparable_ignore]
992    pub session_id: SessionID,
993    #[comparable_ignore]
994    pub cipher_suites: CipherSuites,
995    // #[comparable_ignore]
996    pub compression_methods: Compressions,
997    #[comparable_ignore]
998    pub extensions: ClientExtensions,
999}
1000
1001impl codec::Codec for ClientHelloPayload {
1002    fn encode(&self, bytes: &mut Vec<u8>) {
1003        self.client_version.encode(bytes);
1004        self.random.encode(bytes);
1005        self.session_id.encode(bytes);
1006        self.cipher_suites.encode(bytes);
1007        self.compression_methods.encode(bytes);
1008        self.extensions.encode(bytes); // will not write anything if the list is empty!
1009    }
1010
1011    fn read(r: &mut codec::Reader) -> Option<Self> {
1012        let mut ret = Self {
1013            client_version: ProtocolVersion::read(r)?,
1014            random: Random::read(r)?,
1015            session_id: SessionID::read(r)?,
1016            cipher_suites: CipherSuites::read(r)?,
1017            compression_methods: Compressions::read(r)?,
1018            extensions: ClientExtensions(Vec::new()),
1019        };
1020
1021        if r.any_left() {
1022            ret.extensions = ClientExtensions::read(r)?;
1023        }
1024
1025        if r.any_left() {
1026            None
1027        } else {
1028            Some(ret)
1029        }
1030    }
1031}
1032
1033impl ClientHelloPayload {
1034    /// Returns true if there is more than one extension of a given
1035    /// type.
1036    pub fn has_duplicate_extension(&self) -> bool {
1037        let mut seen = collections::HashSet::new();
1038
1039        for ext in &self.extensions.0 {
1040            let typ = ext.get_type().get_u16();
1041
1042            if seen.contains(&typ) {
1043                return true;
1044            }
1045            seen.insert(typ);
1046        }
1047
1048        false
1049    }
1050
1051    pub fn find_extension(&self, ext: ExtensionType) -> Option<&ClientExtension> {
1052        self.extensions.0.iter().find(|x| x.get_type() == ext)
1053    }
1054
1055    pub fn get_sni_extension(&self) -> Option<&ServerNameRequest> {
1056        let ext = self.find_extension(ExtensionType::ServerName)?;
1057        match *ext {
1058            ClientExtension::ServerName(ref req) => Some(req),
1059            _ => None,
1060        }
1061    }
1062
1063    pub fn get_sigalgs_extension(&self) -> Option<&SupportedSignatureSchemes> {
1064        let ext = self.find_extension(ExtensionType::SignatureAlgorithms)?;
1065        match *ext {
1066            ClientExtension::SignatureAlgorithms(ref req) => Some(req),
1067            _ => None,
1068        }
1069    }
1070
1071    pub fn get_namedgroups_extension(&self) -> Option<&NamedGroups> {
1072        let ext = self.find_extension(ExtensionType::EllipticCurves)?;
1073        match *ext {
1074            ClientExtension::NamedGroups(ref req) => Some(req),
1075            _ => None,
1076        }
1077    }
1078
1079    pub fn get_ecpoints_extension(&self) -> Option<&ECPointFormatList> {
1080        let ext = self.find_extension(ExtensionType::ECPointFormats)?;
1081        match *ext {
1082            ClientExtension::ECPointFormats(ref req) => Some(req),
1083            _ => None,
1084        }
1085    }
1086
1087    pub fn get_alpn_extension(&self) -> Option<&ProtocolNameList> {
1088        let ext = self.find_extension(ExtensionType::ALProtocolNegotiation)?;
1089        match *ext {
1090            ClientExtension::Protocols(ref req) => Some(req),
1091            _ => None,
1092        }
1093    }
1094
1095    pub fn get_quic_params_extension(&self) -> Option<Vec<u8>> {
1096        let ext = self
1097            .find_extension(ExtensionType::TransportParameters)
1098            .or_else(|| self.find_extension(ExtensionType::TransportParametersDraft))?;
1099        match *ext {
1100            ClientExtension::TransportParameters(ref bytes)
1101            | ClientExtension::TransportParametersDraft(ref bytes) => Some(bytes.to_vec()),
1102            _ => None,
1103        }
1104    }
1105
1106    pub fn get_ticket_extension(&self) -> Option<&ClientExtension> {
1107        self.find_extension(ExtensionType::SessionTicket)
1108    }
1109
1110    pub fn get_versions_extension(&self) -> Option<&ProtocolVersions> {
1111        let ext = self.find_extension(ExtensionType::SupportedVersions)?;
1112        match *ext {
1113            ClientExtension::SupportedVersions(ref vers) => Some(vers),
1114            _ => None,
1115        }
1116    }
1117
1118    pub fn get_keyshare_extension(&self) -> Option<&KeyShareEntries> {
1119        let ext = self.find_extension(ExtensionType::KeyShare)?;
1120        match *ext {
1121            ClientExtension::KeyShare(ref shares) => Some(shares),
1122            _ => None,
1123        }
1124    }
1125
1126    pub fn has_keyshare_extension_with_duplicates(&self) -> bool {
1127        if let Some(entries) = self.get_keyshare_extension() {
1128            let mut seen = collections::HashSet::new();
1129
1130            for kse in &entries.0 {
1131                let grp = kse.group.get_u16();
1132
1133                if !seen.insert(grp) {
1134                    return true;
1135                }
1136            }
1137        }
1138
1139        false
1140    }
1141
1142    pub fn get_psk(&self) -> Option<&PresharedKeyOffer> {
1143        let ext = self.find_extension(ExtensionType::PreSharedKey)?;
1144        match *ext {
1145            ClientExtension::PresharedKey(ref psk) => Some(psk),
1146            _ => None,
1147        }
1148    }
1149
1150    pub fn check_psk_ext_is_last(&self) -> bool {
1151        self.extensions
1152            .0
1153            .last()
1154            .is_some_and(|ext| ext.get_type() == ExtensionType::PreSharedKey)
1155    }
1156
1157    pub fn get_psk_modes(&self) -> Option<&PSKKeyExchangeModes> {
1158        let ext = self.find_extension(ExtensionType::PSKKeyExchangeModes)?;
1159        match *ext {
1160            ClientExtension::PresharedKeyModes(ref psk_modes) => Some(psk_modes),
1161            _ => None,
1162        }
1163    }
1164
1165    pub fn psk_mode_offered(&self, mode: PSKKeyExchangeMode) -> bool {
1166        self.get_psk_modes()
1167            .map(|modes| modes.0.contains(&mode))
1168            .unwrap_or(false)
1169    }
1170
1171    pub fn set_psk_binder(&mut self, binder: impl Into<Vec<u8>>) {
1172        let last_extension = self.extensions.0.last_mut();
1173        if let Some(ClientExtension::PresharedKey(ref mut offer)) = last_extension {
1174            if !offer.binders.0.is_empty() {
1175                offer.binders.0[0] = PresharedKeyBinder::new(binder.into());
1176            }
1177        }
1178    }
1179
1180    pub fn ems_support_offered(&self) -> bool {
1181        self.find_extension(ExtensionType::ExtendedMasterSecret)
1182            .is_some()
1183    }
1184
1185    pub fn early_data_extension_offered(&self) -> bool {
1186        self.find_extension(ExtensionType::EarlyData).is_some()
1187    }
1188}
1189
1190#[derive(Debug, Clone, PartialEq, Comparable)]
1191pub enum HelloRetryExtension {
1192    KeyShare(NamedGroup),
1193    Cookie(PayloadU16),
1194    SupportedVersions(ProtocolVersion),
1195    Unknown(UnknownExtension),
1196}
1197
1198impl HelloRetryExtension {
1199    pub fn get_type(&self) -> ExtensionType {
1200        match *self {
1201            HelloRetryExtension::KeyShare(_) => ExtensionType::KeyShare,
1202            HelloRetryExtension::Cookie(_) => ExtensionType::Cookie,
1203            HelloRetryExtension::SupportedVersions(_) => ExtensionType::SupportedVersions,
1204            HelloRetryExtension::Unknown(ref r) => r.typ,
1205        }
1206    }
1207}
1208
1209impl codec::Codec for HelloRetryExtension {
1210    fn encode(&self, bytes: &mut Vec<u8>) {
1211        self.get_type().encode(bytes);
1212
1213        let mut sub: Vec<u8> = Vec::new();
1214        match *self {
1215            HelloRetryExtension::KeyShare(ref r) => r.encode(&mut sub),
1216            HelloRetryExtension::Cookie(ref r) => r.encode(&mut sub),
1217            HelloRetryExtension::SupportedVersions(ref r) => r.encode(&mut sub),
1218            HelloRetryExtension::Unknown(ref r) => r.encode(&mut sub),
1219        }
1220
1221        (sub.len() as u16).encode(bytes);
1222        bytes.append(&mut sub);
1223    }
1224
1225    fn read(r: &mut codec::Reader) -> Option<Self> {
1226        let typ = ExtensionType::read(r)?;
1227        let len = u16::read(r)? as usize;
1228        let mut sub = r.sub(len)?;
1229
1230        let ext = match typ {
1231            ExtensionType::KeyShare => Self::KeyShare(NamedGroup::read(&mut sub)?),
1232            ExtensionType::Cookie => Self::Cookie(PayloadU16::read(&mut sub)?),
1233            ExtensionType::SupportedVersions => {
1234                Self::SupportedVersions(ProtocolVersion::read(&mut sub)?)
1235            }
1236            _ => Self::Unknown(UnknownExtension::read(typ, &mut sub)),
1237        };
1238
1239        if sub.any_left() {
1240            None
1241        } else {
1242            Some(ext)
1243        }
1244    }
1245}
1246
1247declare_u16_vec_empty!(HelloRetryExtensions, HelloRetryExtension);
1248
1249#[derive(Debug, Clone, Comparable)]
1250pub struct HelloRetryRequest {
1251    #[comparable_synthetic {
1252        let sorted_extensions = |x: &Self| -> HelloRetryExtensions { let mut ext = x.extensions.clone(); ext.0.sort_by(puffin::codec::compare_encoding); ext };
1253    }]
1254    pub legacy_version: ProtocolVersion,
1255    #[comparable_ignore]
1256    pub random: Random,
1257    #[comparable_ignore]
1258    pub session_id: SessionID,
1259    pub cipher_suite: CipherSuite,
1260    pub compression_methods: Compressions,
1261    #[comparable_ignore]
1262    pub extensions: HelloRetryExtensions,
1263}
1264
1265impl codec::Codec for HelloRetryRequest {
1266    fn encode(&self, bytes: &mut Vec<u8>) {
1267        self.legacy_version.encode(bytes);
1268        self.random.encode(bytes);
1269        self.session_id.encode(bytes);
1270        self.cipher_suite.encode(bytes);
1271        // HelloRetryRequest is encoded as a ServerHello
1272        // ServerHello only contains one compression method while HRR can hold a vec of compression
1273        // methods if the vec is not empty we encode the first element, else we encode the
1274        // Null compression
1275        if !self.compression_methods.0.is_empty() {
1276            self.compression_methods.0[0].encode(bytes);
1277        } else {
1278            Compression::Null.encode(bytes);
1279        }
1280        self.extensions.encode(bytes);
1281    }
1282
1283    fn read(r: &mut codec::Reader) -> Option<Self> {
1284        let session_id = SessionID::read(r)?;
1285        let cipher_suite = CipherSuite::read(r)?;
1286        let compression_method = Compression::read(r)?;
1287        let extensions = HelloRetryExtensions::read(r)?;
1288        if compression_method != Compression::Null {
1289            return None;
1290        }
1291
1292        Some(Self {
1293            legacy_version: ProtocolVersion::Unknown(0), /* will be stored by the HandShake
1294                                                          * message wrapping this payload */
1295            random: fn_hello_retry_request_random().unwrap(), // same
1296            session_id,
1297            cipher_suite,
1298            compression_methods: Compressions(vec![compression_method]), /* TODO-Mapper: could be
1299                                                                          * extended to change
1300                                                                          * this field */
1301            extensions,
1302        })
1303    }
1304}
1305
1306impl HelloRetryRequest {
1307    /// Returns true if there is more than one extension of a given
1308    /// type.
1309    pub fn has_duplicate_extension(&self) -> bool {
1310        let mut seen = collections::HashSet::new();
1311
1312        for ext in &self.extensions.0 {
1313            let typ = ext.get_type().get_u16();
1314
1315            if seen.contains(&typ) {
1316                return true;
1317            }
1318            seen.insert(typ);
1319        }
1320
1321        false
1322    }
1323
1324    pub fn has_unknown_extension(&self) -> bool {
1325        self.extensions.0.iter().any(|ext| {
1326            ext.get_type() != ExtensionType::KeyShare
1327                && ext.get_type() != ExtensionType::SupportedVersions
1328                && ext.get_type() != ExtensionType::Cookie
1329        })
1330    }
1331
1332    fn find_extension(&self, ext: ExtensionType) -> Option<&HelloRetryExtension> {
1333        self.extensions.0.iter().find(|x| x.get_type() == ext)
1334    }
1335
1336    pub fn get_requested_key_share_group(&self) -> Option<NamedGroup> {
1337        let ext = self.find_extension(ExtensionType::KeyShare)?;
1338        match *ext {
1339            HelloRetryExtension::KeyShare(grp) => Some(grp),
1340            _ => None,
1341        }
1342    }
1343
1344    pub fn get_cookie(&self) -> Option<&PayloadU16> {
1345        let ext = self.find_extension(ExtensionType::Cookie)?;
1346        match *ext {
1347            HelloRetryExtension::Cookie(ref ck) => Some(ck),
1348            _ => None,
1349        }
1350    }
1351
1352    pub fn get_supported_versions(&self) -> Option<ProtocolVersion> {
1353        let ext = self.find_extension(ExtensionType::SupportedVersions)?;
1354        match *ext {
1355            HelloRetryExtension::SupportedVersions(ver) => Some(ver),
1356            _ => None,
1357        }
1358    }
1359}
1360
1361declare_u16_vec_empty!(ServerExtensions, ServerExtension);
1362
1363#[derive(Debug, Clone, Extractable, Comparable)]
1364#[extractable(TLSProtocolTypes)]
1365pub struct ServerHelloPayload {
1366    #[comparable_synthetic {
1367        let sorted_extensions = |x: &Self| -> ServerExtensions {
1368            let mut ext = x.extensions.clone();
1369            // Remove optional extensions whose presence/absence is an
1370            // implementation choice, not a protocol bug:
1371            //  - RenegotiationInfo: optional in TLS 1.2 renegotiation
1372            //  - ExtendedMasterSecretAck: optional TLS 1.2 extension (RFC 7627)
1373            ext.0 = ext.0
1374                    .into_iter()
1375                    .filter(|x|!matches!(x,
1376                        ServerExtension::RenegotiationInfo(_)
1377                        | ServerExtension::ExtendedMasterSecretAck))
1378                    .collect();
1379            ext.0.sort_by(puffin::codec::compare_encoding);
1380            ext
1381        };
1382    }]
1383    pub legacy_version: ProtocolVersion,
1384    #[comparable_ignore]
1385    pub random: Random,
1386    #[comparable_ignore]
1387    pub session_id: SessionID,
1388    pub cipher_suite: CipherSuite,
1389    pub compression_method: Compression,
1390    #[comparable_ignore]
1391    pub extensions: ServerExtensions,
1392}
1393
1394impl codec::Codec for ServerHelloPayload {
1395    fn encode(&self, bytes: &mut Vec<u8>) {
1396        self.legacy_version.encode(bytes);
1397        self.random.encode(bytes);
1398
1399        self.session_id.encode(bytes);
1400        self.cipher_suite.encode(bytes);
1401        self.compression_method.encode(bytes);
1402        self.extensions.encode(bytes);
1403    }
1404
1405    // minus version and random, which have already been read.
1406    fn read(r: &mut codec::Reader) -> Option<Self> {
1407        let session_id = SessionID::read(r)?;
1408        let suite = CipherSuite::read(r)?;
1409        let compression = Compression::read(r)?;
1410        let extensions = if r.any_left() {
1411            ServerExtensions::read(r)?
1412        } else {
1413            ServerExtensions(vec![])
1414        };
1415
1416        let ret = Self {
1417            legacy_version: ProtocolVersion::Unknown(0),
1418            random: ZERO_RANDOM,
1419            session_id,
1420            cipher_suite: suite,
1421            compression_method: compression,
1422            extensions,
1423        };
1424
1425        if r.any_left() {
1426            None
1427        } else {
1428            Some(ret)
1429        }
1430    }
1431}
1432
1433impl HasServerExtensions for ServerHelloPayload {
1434    fn get_extensions(&self) -> &[ServerExtension] {
1435        &self.extensions.0
1436    }
1437}
1438
1439impl ServerHelloPayload {
1440    pub fn get_key_share(&self) -> Option<&KeyShareEntry> {
1441        let ext = self.find_extension(ExtensionType::KeyShare)?;
1442        match *ext {
1443            ServerExtension::KeyShare(ref share) => Some(share),
1444            _ => None,
1445        }
1446    }
1447
1448    pub fn get_psk_index(&self) -> Option<u16> {
1449        let ext = self.find_extension(ExtensionType::PreSharedKey)?;
1450        match *ext {
1451            ServerExtension::PresharedKey(ref index) => Some(*index),
1452            _ => None,
1453        }
1454    }
1455
1456    pub fn get_ecpoints_extension(&self) -> Option<&ECPointFormatList> {
1457        let ext = self.find_extension(ExtensionType::ECPointFormats)?;
1458        match *ext {
1459            ServerExtension::ECPointFormats(ref fmts) => Some(fmts),
1460            _ => None,
1461        }
1462    }
1463
1464    pub fn ems_support_acked(&self) -> bool {
1465        self.find_extension(ExtensionType::ExtendedMasterSecret)
1466            .is_some()
1467    }
1468
1469    pub fn get_sct_list(&self) -> Option<&SCTList> {
1470        let ext = self.find_extension(ExtensionType::SCT)?;
1471        match *ext {
1472            ServerExtension::SignedCertificateTimestamp(ref sctl) => Some(sctl),
1473            _ => None,
1474        }
1475    }
1476
1477    pub fn get_supported_versions(&self) -> Option<ProtocolVersion> {
1478        let ext = self.find_extension(ExtensionType::SupportedVersions)?;
1479        match *ext {
1480            ServerExtension::SupportedVersions(vers) => Some(vers),
1481            _ => None,
1482        }
1483    }
1484}
1485
1486#[derive(Debug, Clone, Extractable, Comparable)]
1487#[extractable(TLSProtocolTypes)]
1488pub struct CertificatePayload(#[extractable_no_recursion] pub Vec<key::Certificate>);
1489
1490impl codec::Codec for CertificatePayload {
1491    fn encode(&self, bytes: &mut Vec<u8>) {
1492        codec::encode_vec_u24(bytes, &self.0);
1493    }
1494
1495    fn read(r: &mut codec::Reader) -> Option<Self> {
1496        // 64KB of certificates is plenty, 16MB is obviously silly
1497        Some(CertificatePayload(codec::read_vec_u24_limited(r, 0x10000)?))
1498    }
1499}
1500
1501// TLS1.3 changes the Certificate payload encoding.
1502// That's annoying. It means the parsing is not
1503// context-free any more.
1504
1505#[derive(Debug, Clone, PartialEq, Comparable)]
1506pub enum CertificateExtension {
1507    CertificateStatus(CertificateStatus),
1508    SignedCertificateTimestamp(SCTList),
1509    Unknown(UnknownExtension),
1510}
1511
1512impl CertificateExtension {
1513    pub fn get_type(&self) -> ExtensionType {
1514        match *self {
1515            CertificateExtension::CertificateStatus(_) => ExtensionType::StatusRequest,
1516            CertificateExtension::SignedCertificateTimestamp(_) => ExtensionType::SCT,
1517            CertificateExtension::Unknown(ref r) => r.typ,
1518        }
1519    }
1520
1521    pub fn make_sct(sct_list: Vec<u8>) -> Self {
1522        let sctl = SCTList::read_bytes(&sct_list).expect("invalid SCT list");
1523        Self::SignedCertificateTimestamp(sctl)
1524    }
1525
1526    pub fn get_cert_status(&self) -> Option<&Vec<u8>> {
1527        match *self {
1528            CertificateExtension::CertificateStatus(ref cs) => Some(&cs.ocsp_response.0),
1529            _ => None,
1530        }
1531    }
1532
1533    pub fn get_sct_list(&self) -> Option<&SCTList> {
1534        match *self {
1535            CertificateExtension::SignedCertificateTimestamp(ref sctl) => Some(sctl),
1536            _ => None,
1537        }
1538    }
1539}
1540
1541impl codec::Codec for CertificateExtension {
1542    fn encode(&self, bytes: &mut Vec<u8>) {
1543        self.get_type().encode(bytes);
1544
1545        let mut sub: Vec<u8> = Vec::new();
1546        match *self {
1547            CertificateExtension::CertificateStatus(ref r) => r.encode(&mut sub),
1548            CertificateExtension::SignedCertificateTimestamp(ref r) => r.encode(&mut sub),
1549            CertificateExtension::Unknown(ref r) => r.encode(&mut sub),
1550        }
1551
1552        (sub.len() as u16).encode(bytes);
1553        bytes.append(&mut sub);
1554    }
1555
1556    fn read(r: &mut codec::Reader) -> Option<Self> {
1557        let typ = ExtensionType::read(r)?;
1558        let len = u16::read(r)? as usize;
1559        let mut sub = r.sub(len)?;
1560
1561        let ext = match typ {
1562            ExtensionType::StatusRequest => {
1563                let st = CertificateStatus::read(&mut sub)?;
1564                Self::CertificateStatus(st)
1565            }
1566            ExtensionType::SCT => {
1567                let scts = SCTList::read(&mut sub)?;
1568                Self::SignedCertificateTimestamp(scts)
1569            }
1570            _ => Self::Unknown(UnknownExtension::read(typ, &mut sub)),
1571        };
1572
1573        if sub.any_left() {
1574            None
1575        } else {
1576            Some(ext)
1577        }
1578    }
1579}
1580
1581declare_u16_vec!(CertificateExtensions, CertificateExtension);
1582
1583#[derive(Debug, Clone, Comparable, PartialEq)]
1584pub struct CertificateEntry {
1585    pub cert: key::Certificate,
1586    pub exts: CertificateExtensions,
1587}
1588
1589impl codec::Codec for CertificateEntry {
1590    fn encode(&self, bytes: &mut Vec<u8>) {
1591        self.cert.encode(bytes);
1592        self.exts.encode(bytes);
1593    }
1594
1595    fn read(r: &mut codec::Reader) -> Option<Self> {
1596        Some(Self {
1597            cert: key::Certificate::read(r)?,
1598            exts: CertificateExtensions::read(r)?,
1599        })
1600    }
1601}
1602
1603impl CertificateEntry {
1604    pub fn new(cert: key::Certificate) -> Self {
1605        Self {
1606            cert,
1607            exts: CertificateExtensions(Vec::new()),
1608        }
1609    }
1610
1611    pub fn has_duplicate_extension(&self) -> bool {
1612        let mut seen = collections::HashSet::new();
1613
1614        for ext in &self.exts.0 {
1615            let typ = ext.get_type().get_u16();
1616
1617            if seen.contains(&typ) {
1618                return true;
1619            }
1620            seen.insert(typ);
1621        }
1622
1623        false
1624    }
1625
1626    pub fn has_unknown_extension(&self) -> bool {
1627        self.exts.0.iter().any(|ext| {
1628            ext.get_type() != ExtensionType::StatusRequest && ext.get_type() != ExtensionType::SCT
1629        })
1630    }
1631
1632    pub fn get_ocsp_response(&self) -> Option<&Vec<u8>> {
1633        self.exts
1634            .0
1635            .iter()
1636            .find(|ext| ext.get_type() == ExtensionType::StatusRequest)
1637            .and_then(CertificateExtension::get_cert_status)
1638    }
1639
1640    pub fn get_scts(&self) -> Option<&SCTList> {
1641        self.exts
1642            .0
1643            .iter()
1644            .find(|ext| ext.get_type() == ExtensionType::SCT)
1645            .and_then(CertificateExtension::get_sct_list)
1646    }
1647}
1648
1649declare_u24_vec_limited!(CertificateEntries, CertificateEntry);
1650
1651#[derive(Debug, Clone, Comparable)]
1652pub struct CertificatePayloadTLS13 {
1653    pub context: PayloadU8,
1654    pub entries: CertificateEntries,
1655}
1656
1657impl codec::Codec for CertificatePayloadTLS13 {
1658    fn encode(&self, bytes: &mut Vec<u8>) {
1659        self.context.encode(bytes);
1660        self.entries.encode(bytes);
1661    }
1662
1663    fn read(r: &mut codec::Reader) -> Option<Self> {
1664        Some(Self {
1665            context: PayloadU8::read(r)?,
1666            entries: CertificateEntries::read(r)?,
1667        })
1668    }
1669}
1670
1671impl CertificatePayloadTLS13 {
1672    pub fn new(entries: Vec<CertificateEntry>) -> Self {
1673        Self {
1674            context: PayloadU8::empty(),
1675            entries: CertificateEntries(entries),
1676        }
1677    }
1678
1679    pub fn any_entry_has_duplicate_extension(&self) -> bool {
1680        for entry in &self.entries.0 {
1681            if entry.has_duplicate_extension() {
1682                return true;
1683            }
1684        }
1685
1686        false
1687    }
1688
1689    pub fn any_entry_has_unknown_extension(&self) -> bool {
1690        for entry in &self.entries.0 {
1691            if entry.has_unknown_extension() {
1692                return true;
1693            }
1694        }
1695
1696        false
1697    }
1698
1699    pub fn any_entry_has_extension(&self) -> bool {
1700        for entry in &self.entries.0 {
1701            if !entry.exts.0.is_empty() {
1702                return true;
1703            }
1704        }
1705
1706        false
1707    }
1708
1709    pub fn get_end_entity_ocsp(&self) -> Vec<u8> {
1710        self.entries
1711            .0
1712            .first()
1713            .and_then(CertificateEntry::get_ocsp_response)
1714            .cloned()
1715            .unwrap_or_default()
1716    }
1717
1718    pub fn get_end_entity_scts(&self) -> Option<SCTList> {
1719        self.entries
1720            .0
1721            .first()
1722            .and_then(CertificateEntry::get_scts)
1723            .cloned()
1724    }
1725
1726    pub fn convert(&self) -> CertificatePayload {
1727        let mut ret = Vec::new();
1728        for entry in &self.entries.0 {
1729            ret.push(entry.cert.clone());
1730        }
1731        CertificatePayload(ret)
1732    }
1733}
1734
1735#[derive(Debug)]
1736pub enum KeyExchangeAlgorithm {
1737    BulkOnly,
1738    DH,
1739    DHE,
1740    RSA,
1741    ECDH,
1742    ECDHE,
1743}
1744
1745// We don't support arbitrary curves.  It's a terrible
1746// idea and unnecessary attack surface.  Please,
1747// get a grip.
1748#[derive(Debug, Clone, Comparable)]
1749pub struct ECParameters {
1750    pub curve_type: ECCurveType,
1751    pub named_group: NamedGroup,
1752}
1753
1754impl codec::Codec for ECParameters {
1755    fn encode(&self, bytes: &mut Vec<u8>) {
1756        self.curve_type.encode(bytes);
1757        self.named_group.encode(bytes);
1758    }
1759
1760    fn read(r: &mut codec::Reader) -> Option<Self> {
1761        let ct = ECCurveType::read(r)?;
1762        let grp = NamedGroup::read(r)?;
1763
1764        Some(Self {
1765            curve_type: ct,
1766            named_group: grp,
1767        })
1768    }
1769}
1770
1771#[derive(Debug, Clone, Comparable)]
1772pub struct DigitallySignedStruct {
1773    pub scheme: SignatureScheme,
1774    #[comparable_ignore]
1775    pub sig: PayloadU16,
1776}
1777
1778impl DigitallySignedStruct {
1779    pub fn new(scheme: SignatureScheme, sig: Vec<u8>) -> Self {
1780        Self {
1781            scheme,
1782            sig: PayloadU16::new(sig),
1783        }
1784    }
1785}
1786
1787impl codec::Codec for DigitallySignedStruct {
1788    fn encode(&self, bytes: &mut Vec<u8>) {
1789        self.scheme.encode(bytes);
1790        self.sig.encode(bytes);
1791    }
1792
1793    fn read(r: &mut codec::Reader) -> Option<Self> {
1794        let scheme = SignatureScheme::read(r)?;
1795        let sig = PayloadU16::read(r)?;
1796
1797        Some(Self { scheme, sig })
1798    }
1799}
1800
1801#[derive(Debug)]
1802pub struct ClientECDHParams {
1803    pub public: PayloadU8,
1804}
1805
1806impl codec::Codec for ClientECDHParams {
1807    fn encode(&self, bytes: &mut Vec<u8>) {
1808        self.public.encode(bytes);
1809    }
1810
1811    fn read(r: &mut codec::Reader) -> Option<Self> {
1812        let pb = PayloadU8::read(r)?;
1813        Some(Self { public: pb })
1814    }
1815}
1816
1817#[derive(Debug, Clone, Extractable, Comparable)]
1818#[extractable(TLSProtocolTypes)]
1819pub struct ServerECDHParams {
1820    // Fields in this struct are ignored but TLS implementation could probably be aligned
1821    #[extractable_ignore]
1822    pub curve_params: ECParameters,
1823    #[extractable_ignore]
1824    #[comparable_ignore]
1825    pub public: PayloadU8,
1826}
1827
1828impl ServerECDHParams {
1829    pub fn new(named_group: NamedGroup, pubkey: &[u8]) -> Self {
1830        Self {
1831            curve_params: ECParameters {
1832                curve_type: ECCurveType::NamedCurve,
1833                named_group,
1834            },
1835            public: PayloadU8::new(pubkey.to_vec()),
1836        }
1837    }
1838}
1839
1840impl codec::Codec for ServerECDHParams {
1841    fn encode(&self, bytes: &mut Vec<u8>) {
1842        self.curve_params.encode(bytes);
1843        self.public.encode(bytes);
1844    }
1845
1846    fn read(r: &mut codec::Reader) -> Option<Self> {
1847        let cp = ECParameters::read(r)?;
1848        let pb = PayloadU8::read(r)?;
1849
1850        Some(Self {
1851            curve_params: cp,
1852            public: pb,
1853        })
1854    }
1855}
1856
1857#[derive(Debug, Clone, Extractable, Comparable)]
1858#[extractable(TLSProtocolTypes)]
1859pub struct ECDHEServerKeyExchange {
1860    pub params: ServerECDHParams,
1861    #[extractable_ignore]
1862    pub dss: DigitallySignedStruct,
1863}
1864
1865impl codec::Codec for ECDHEServerKeyExchange {
1866    fn encode(&self, bytes: &mut Vec<u8>) {
1867        self.params.encode(bytes);
1868        self.dss.encode(bytes);
1869    }
1870
1871    fn read(r: &mut codec::Reader) -> Option<Self> {
1872        let params = ServerECDHParams::read(r)?;
1873        let dss = DigitallySignedStruct::read(r)?;
1874
1875        Some(Self { params, dss })
1876    }
1877}
1878
1879#[derive(Debug, Clone, Extractable, Comparable)]
1880#[extractable(TLSProtocolTypes)]
1881pub enum ServerKeyExchangePayload {
1882    ECDHE(ECDHEServerKeyExchange),
1883    Unknown(Payload),
1884}
1885
1886impl codec::Codec for ServerKeyExchangePayload {
1887    fn encode(&self, bytes: &mut Vec<u8>) {
1888        match *self {
1889            ServerKeyExchangePayload::ECDHE(ref x) => x.encode(bytes),
1890            ServerKeyExchangePayload::Unknown(ref x) => x.encode(bytes),
1891        }
1892    }
1893
1894    fn read(r: &mut codec::Reader) -> Option<Self> {
1895        // read as Unknown, fully parse when we know the
1896        // KeyExchangeAlgorithm
1897        Some(Self::Unknown(Payload::read(r)))
1898    }
1899}
1900
1901impl ServerKeyExchangePayload {
1902    pub fn unwrap_given_kxa(&self, kxa: &KeyExchangeAlgorithm) -> Option<ECDHEServerKeyExchange> {
1903        if let ServerKeyExchangePayload::Unknown(ref unk) = *self {
1904            let mut rd = codec::Reader::init(&unk.0);
1905
1906            let result = match *kxa {
1907                KeyExchangeAlgorithm::ECDHE => ECDHEServerKeyExchange::read(&mut rd),
1908                _ => None,
1909            };
1910
1911            if !rd.any_left() {
1912                return result;
1913            };
1914        }
1915
1916        None
1917    }
1918}
1919
1920// -- EncryptedExtensions (TLS1.3 only) --
1921declare_u16_vec!(EncryptedExtensions, ServerExtension);
1922
1923pub trait HasServerExtensions {
1924    fn get_extensions(&self) -> &[ServerExtension];
1925
1926    /// Returns true if there is more than one extension of a given
1927    /// type.
1928    fn has_duplicate_extension(&self) -> bool {
1929        let mut seen = collections::HashSet::new();
1930
1931        for ext in self.get_extensions() {
1932            let typ = ext.get_type().get_u16();
1933
1934            if seen.contains(&typ) {
1935                return true;
1936            }
1937            seen.insert(typ);
1938        }
1939
1940        false
1941    }
1942
1943    fn find_extension(&self, ext: ExtensionType) -> Option<&ServerExtension> {
1944        self.get_extensions().iter().find(|x| x.get_type() == ext)
1945    }
1946
1947    fn get_alpn_protocol(&self) -> Option<&[u8]> {
1948        let ext = self.find_extension(ExtensionType::ALProtocolNegotiation)?;
1949        match *ext {
1950            ServerExtension::Protocols(ref protos) => protos.as_single_slice(),
1951            _ => None,
1952        }
1953    }
1954
1955    fn get_quic_params_extension(&self) -> Option<Vec<u8>> {
1956        let ext = self
1957            .find_extension(ExtensionType::TransportParameters)
1958            .or_else(|| self.find_extension(ExtensionType::TransportParametersDraft))?;
1959        match *ext {
1960            ServerExtension::TransportParameters(ref bytes)
1961            | ServerExtension::TransportParametersDraft(ref bytes) => Some(bytes.to_vec()),
1962            _ => None,
1963        }
1964    }
1965
1966    fn early_data_extension_offered(&self) -> bool {
1967        self.find_extension(ExtensionType::EarlyData).is_some()
1968    }
1969}
1970
1971impl HasServerExtensions for EncryptedExtensions {
1972    fn get_extensions(&self) -> &[ServerExtension] {
1973        &self.0
1974    }
1975}
1976
1977impl HasServerExtensions for Vec<ServerExtension> {
1978    fn get_extensions(&self) -> &[ServerExtension] {
1979        self
1980    }
1981}
1982
1983// -- CertificateRequest and sundries --
1984declare_u8_vec!(ClientCertificateTypes, ClientCertificateType);
1985pub type DistinguishedName = PayloadU16;
1986pub type DistinguishedNames = VecU16OfPayloadU16;
1987
1988#[derive(Debug, Clone, Comparable)]
1989pub struct CertificateRequestPayload {
1990    pub certtypes: ClientCertificateTypes,
1991    pub sigschemes: SupportedSignatureSchemes,
1992    pub canames: DistinguishedNames,
1993}
1994
1995impl codec::Codec for CertificateRequestPayload {
1996    fn encode(&self, bytes: &mut Vec<u8>) {
1997        self.certtypes.encode(bytes);
1998        self.sigschemes.encode(bytes);
1999        self.canames.encode(bytes);
2000    }
2001
2002    fn read(r: &mut codec::Reader) -> Option<Self> {
2003        let certtypes = ClientCertificateTypes::read(r)?;
2004        let sigschemes = SupportedSignatureSchemes::read(r)?;
2005        let canames = DistinguishedNames::read(r)?;
2006
2007        Some(Self {
2008            certtypes,
2009            sigschemes,
2010            canames,
2011        })
2012    }
2013}
2014
2015#[derive(Debug, Clone, PartialEq, Comparable)]
2016pub enum CertReqExtension {
2017    SignatureAlgorithms(#[comparable_ignore] SupportedSignatureSchemes),
2018    AuthorityNames(DistinguishedNames),
2019    Unknown(UnknownExtension),
2020}
2021
2022impl CertReqExtension {
2023    pub fn get_type(&self) -> ExtensionType {
2024        match *self {
2025            CertReqExtension::SignatureAlgorithms(_) => ExtensionType::SignatureAlgorithms,
2026            CertReqExtension::AuthorityNames(_) => ExtensionType::CertificateAuthorities,
2027            CertReqExtension::Unknown(ref r) => r.typ,
2028        }
2029    }
2030}
2031
2032impl codec::Codec for CertReqExtension {
2033    fn encode(&self, bytes: &mut Vec<u8>) {
2034        self.get_type().encode(bytes);
2035
2036        let mut sub: Vec<u8> = Vec::new();
2037        match *self {
2038            CertReqExtension::SignatureAlgorithms(ref r) => r.encode(&mut sub),
2039            CertReqExtension::AuthorityNames(ref r) => r.encode(&mut sub),
2040            CertReqExtension::Unknown(ref r) => r.encode(&mut sub),
2041        }
2042
2043        (sub.len() as u16).encode(bytes);
2044        bytes.append(&mut sub);
2045    }
2046
2047    fn read(r: &mut codec::Reader) -> Option<Self> {
2048        let typ = ExtensionType::read(r)?;
2049        let len = u16::read(r)? as usize;
2050        let mut sub = r.sub(len)?;
2051
2052        let ext = match typ {
2053            ExtensionType::SignatureAlgorithms => {
2054                let schemes = SupportedSignatureSchemes::read(&mut sub)?;
2055                if schemes.0.is_empty() {
2056                    return None;
2057                }
2058                Self::SignatureAlgorithms(schemes)
2059            }
2060            ExtensionType::CertificateAuthorities => {
2061                let cas = DistinguishedNames::read(&mut sub)?;
2062                Self::AuthorityNames(cas)
2063            }
2064            _ => Self::Unknown(UnknownExtension::read(typ, &mut sub)),
2065        };
2066
2067        if sub.any_left() {
2068            None
2069        } else {
2070            Some(ext)
2071        }
2072    }
2073}
2074
2075declare_u16_vec!(CertReqExtensions, CertReqExtension);
2076
2077#[derive(Debug, Clone, Comparable)]
2078pub struct CertificateRequestPayloadTLS13 {
2079    pub context: PayloadU8,
2080    pub extensions: CertReqExtensions,
2081}
2082
2083impl codec::Codec for CertificateRequestPayloadTLS13 {
2084    fn encode(&self, bytes: &mut Vec<u8>) {
2085        self.context.encode(bytes);
2086        if self.extensions.0.is_empty() {
2087            return; // do not print 0, 0 (declare_u16_vec) in that case
2088        }
2089        self.extensions.encode(bytes);
2090    }
2091
2092    fn read(r: &mut codec::Reader) -> Option<Self> {
2093        let context = PayloadU8::read(r)?;
2094        let extensions = if r.any_left() {
2095            CertReqExtensions::read(r)?
2096        } else {
2097            CertReqExtensions(vec![])
2098        };
2099
2100        Some(Self {
2101            context,
2102            extensions,
2103        })
2104    }
2105}
2106
2107impl CertificateRequestPayloadTLS13 {
2108    pub fn find_extension(&self, ext: ExtensionType) -> Option<&CertReqExtension> {
2109        self.extensions.0.iter().find(|x| x.get_type() == ext)
2110    }
2111
2112    pub fn get_sigalgs_extension(&self) -> Option<&SupportedSignatureSchemes> {
2113        let ext = self.find_extension(ExtensionType::SignatureAlgorithms)?;
2114        match *ext {
2115            CertReqExtension::SignatureAlgorithms(ref sa) => Some(sa),
2116            _ => None,
2117        }
2118    }
2119
2120    pub fn get_authorities_extension(&self) -> Option<&DistinguishedNames> {
2121        let ext = self.find_extension(ExtensionType::CertificateAuthorities)?;
2122        match *ext {
2123            CertReqExtension::AuthorityNames(ref an) => Some(an),
2124            _ => None,
2125        }
2126    }
2127}
2128
2129// -- NewSessionTicket --
2130#[derive(Debug, Clone, Extractable, Comparable)]
2131#[extractable(TLSProtocolTypes)]
2132pub struct NewSessionTicketPayload {
2133    #[comparable_ignore]
2134    pub lifetime_hint: u32,
2135    #[comparable_ignore]
2136    pub ticket: PayloadU16,
2137}
2138
2139impl NewSessionTicketPayload {
2140    pub fn new(lifetime_hint: u32, ticket: Vec<u8>) -> Self {
2141        Self {
2142            lifetime_hint,
2143            ticket: PayloadU16::new(ticket),
2144        }
2145    }
2146}
2147
2148impl codec::Codec for NewSessionTicketPayload {
2149    fn encode(&self, bytes: &mut Vec<u8>) {
2150        self.lifetime_hint.encode(bytes);
2151        self.ticket.encode(bytes);
2152    }
2153
2154    fn read(r: &mut codec::Reader) -> Option<Self> {
2155        let lifetime = u32::read(r)?;
2156        let ticket = PayloadU16::read(r)?;
2157
2158        Some(Self {
2159            lifetime_hint: lifetime,
2160            ticket,
2161        })
2162    }
2163}
2164
2165// -- NewSessionTicket electric boogaloo --
2166#[derive(Debug, Clone, Comparable, PartialEq)]
2167pub enum NewSessionTicketExtension {
2168    EarlyData(u32),
2169    Unknown(UnknownExtension),
2170}
2171
2172impl NewSessionTicketExtension {
2173    pub fn get_type(&self) -> ExtensionType {
2174        match *self {
2175            NewSessionTicketExtension::EarlyData(_) => ExtensionType::EarlyData,
2176            NewSessionTicketExtension::Unknown(ref r) => r.typ,
2177        }
2178    }
2179}
2180
2181impl codec::Codec for NewSessionTicketExtension {
2182    fn encode(&self, bytes: &mut Vec<u8>) {
2183        self.get_type().encode(bytes);
2184
2185        let mut sub: Vec<u8> = Vec::new();
2186        match *self {
2187            NewSessionTicketExtension::EarlyData(r) => r.encode(&mut sub),
2188            NewSessionTicketExtension::Unknown(ref r) => r.encode(&mut sub),
2189        }
2190
2191        (sub.len() as u16).encode(bytes);
2192        bytes.append(&mut sub);
2193    }
2194
2195    fn read(r: &mut codec::Reader) -> Option<Self> {
2196        let typ = ExtensionType::read(r)?;
2197        let len = u16::read(r)? as usize;
2198        let mut sub = r.sub(len)?;
2199
2200        let ext = match typ {
2201            ExtensionType::EarlyData => Self::EarlyData(u32::read(&mut sub)?),
2202            _ => Self::Unknown(UnknownExtension::read(typ, &mut sub)),
2203        };
2204
2205        if sub.any_left() {
2206            None
2207        } else {
2208            Some(ext)
2209        }
2210    }
2211}
2212
2213declare_u16_vec!(NewSessionTicketExtensions, NewSessionTicketExtension);
2214
2215#[derive(Debug, Clone, Comparable)]
2216pub struct NewSessionTicketPayloadTLS13 {
2217    pub lifetime: u32,
2218    pub age_add: u32,
2219    pub nonce: PayloadU8,
2220    pub ticket: PayloadU16,
2221    pub exts: NewSessionTicketExtensions,
2222}
2223
2224impl NewSessionTicketPayloadTLS13 {
2225    pub fn new(lifetime: u32, age_add: u32, nonce: Vec<u8>, ticket: Vec<u8>) -> Self {
2226        Self {
2227            lifetime,
2228            age_add,
2229            nonce: PayloadU8::new(nonce),
2230            ticket: PayloadU16::new(ticket),
2231            exts: NewSessionTicketExtensions(vec![]),
2232        }
2233    }
2234
2235    pub fn has_duplicate_extension(&self) -> bool {
2236        let mut seen = collections::HashSet::new();
2237
2238        for ext in &self.exts.0 {
2239            let typ = ext.get_type().get_u16();
2240
2241            if seen.contains(&typ) {
2242                return true;
2243            }
2244            seen.insert(typ);
2245        }
2246
2247        false
2248    }
2249
2250    pub fn find_extension(&self, ext: ExtensionType) -> Option<&NewSessionTicketExtension> {
2251        self.exts.0.iter().find(|x| x.get_type() == ext)
2252    }
2253
2254    pub fn get_max_early_data_size(&self) -> Option<u32> {
2255        let ext = self.find_extension(ExtensionType::EarlyData)?;
2256        match *ext {
2257            NewSessionTicketExtension::EarlyData(ref sz) => Some(*sz),
2258            _ => None,
2259        }
2260    }
2261}
2262
2263impl codec::Codec for NewSessionTicketPayloadTLS13 {
2264    fn encode(&self, bytes: &mut Vec<u8>) {
2265        self.lifetime.encode(bytes);
2266        self.age_add.encode(bytes);
2267        self.nonce.encode(bytes);
2268        self.ticket.encode(bytes);
2269        self.exts.encode(bytes);
2270    }
2271
2272    fn read(r: &mut codec::Reader) -> Option<Self> {
2273        let lifetime = u32::read(r)?;
2274        let age_add = u32::read(r)?;
2275        let nonce = PayloadU8::read(r)?;
2276        let ticket = PayloadU16::read(r)?;
2277        let exts = NewSessionTicketExtensions::read(r)?;
2278
2279        Some(Self {
2280            lifetime,
2281            age_add,
2282            nonce,
2283            ticket,
2284            exts,
2285        })
2286    }
2287}
2288
2289// -- RFC6066 certificate status types
2290
2291/// Only supports OCSP
2292#[derive(Debug, Clone, PartialEq, Comparable)]
2293pub struct CertificateStatus {
2294    pub ocsp_response: PayloadU24,
2295}
2296
2297impl codec::Codec for CertificateStatus {
2298    fn encode(&self, bytes: &mut Vec<u8>) {
2299        CertificateStatusType::OCSP.encode(bytes);
2300        self.ocsp_response.encode(bytes);
2301    }
2302
2303    fn read(r: &mut codec::Reader) -> Option<Self> {
2304        let typ = CertificateStatusType::read(r)?;
2305
2306        match typ {
2307            CertificateStatusType::OCSP => Some(Self {
2308                ocsp_response: PayloadU24::read(r)?,
2309            }),
2310            _ => None,
2311        }
2312    }
2313}
2314
2315impl CertificateStatus {
2316    pub fn new(ocsp: Vec<u8>) -> Self {
2317        Self {
2318            ocsp_response: PayloadU24::new(ocsp),
2319        }
2320    }
2321
2322    pub fn into_inner(self) -> Vec<u8> {
2323        self.ocsp_response.0
2324    }
2325}
2326
2327#[derive(Debug, Clone, Extractable, Comparable)]
2328#[extractable(TLSProtocolTypes)]
2329pub enum HandshakePayload {
2330    HelloRequest,
2331    ClientHello(ClientHelloPayload),
2332    ServerHello(ServerHelloPayload),
2333    HelloRetryRequest(#[extractable_ignore] HelloRetryRequest),
2334    Certificate(CertificatePayload),
2335    CertificateTLS13(CertificatePayloadTLS13),
2336    ServerKeyExchange(ServerKeyExchangePayload),
2337    CertificateRequest(CertificateRequestPayload),
2338    CertificateRequestTLS13(CertificateRequestPayloadTLS13),
2339    CertificateVerify(DigitallySignedStruct),
2340    ServerHelloDone,
2341    EndOfEarlyData,
2342    ClientKeyExchange(Payload),
2343    NewSessionTicket(NewSessionTicketPayload),
2344    NewSessionTicketTLS13(NewSessionTicketPayloadTLS13),
2345    EncryptedExtensions(EncryptedExtensions),
2346    KeyUpdate(KeyUpdateRequest),
2347    Finished(Payload),
2348    CertificateStatus(CertificateStatus),
2349    MessageHash(Payload),
2350    Unknown(Payload),
2351}
2352
2353impl codec::Codec for HandshakePayload {
2354    fn encode(&self, bytes: &mut Vec<u8>) {
2355        use self::HandshakePayload::*;
2356        match *self {
2357            HelloRequest | ServerHelloDone | EndOfEarlyData => {}
2358            ClientHello(ref x) => x.encode(bytes),
2359            ServerHello(ref x) => x.encode(bytes),
2360            HelloRetryRequest(ref x) => x.encode(bytes),
2361            Certificate(ref x) => x.encode(bytes),
2362            CertificateTLS13(ref x) => x.encode(bytes),
2363            ServerKeyExchange(ref x) => x.encode(bytes),
2364            ClientKeyExchange(ref x) => x.encode(bytes),
2365            CertificateRequest(ref x) => x.encode(bytes),
2366            CertificateRequestTLS13(ref x) => x.encode(bytes),
2367            CertificateVerify(ref x) => x.encode(bytes),
2368            NewSessionTicket(ref x) => x.encode(bytes),
2369            NewSessionTicketTLS13(ref x) => x.encode(bytes),
2370            EncryptedExtensions(ref x) => x.encode(bytes),
2371            KeyUpdate(ref x) => x.encode(bytes),
2372            Finished(ref x) => x.encode(bytes),
2373            CertificateStatus(ref x) => x.encode(bytes),
2374            MessageHash(ref x) => x.encode(bytes),
2375            Unknown(ref x) => x.encode(bytes),
2376        }
2377    }
2378
2379    fn read(_: &mut Reader) -> Option<Self> {
2380        None
2381    }
2382}
2383
2384#[derive(Debug, Clone, Extractable, Comparable)]
2385#[extractable(TLSProtocolTypes)]
2386pub struct HandshakeMessagePayload {
2387    #[extractable_ignore]
2388    pub typ: HandshakeType,
2389    pub payload: HandshakePayload,
2390}
2391
2392impl codec::Codec for HandshakeMessagePayload {
2393    fn encode(&self, bytes: &mut Vec<u8>) {
2394        // encode payload to learn length
2395        let mut sub: Vec<u8> = Vec::new();
2396        self.payload.encode(&mut sub);
2397
2398        // output type, length, and encoded payload
2399        match self.typ {
2400            HandshakeType::HelloRetryRequest => HandshakeType::ServerHello,
2401            _ => self.typ,
2402        }
2403        .encode(bytes);
2404        codec::u24(sub.len() as u32).encode(bytes);
2405        bytes.append(&mut sub);
2406    }
2407
2408    fn read(r: &mut codec::Reader) -> Option<Self> {
2409        Self::read_version(r, ProtocolVersion::TLSv1_2)
2410    }
2411}
2412
2413impl HandshakeMessagePayload {
2414    /// Like `read_version`, but returns `None` if any bytes remain in `r` after parsing.
2415    /// Use this when parsing a single isolated handshake message (the whole buffer must be
2416    /// consumed). Without this check, an encrypted blob whose first 4 bytes happen to be
2417    /// `[0x00, 0x00, 0x00, 0x00]` would be silently accepted as an empty `HelloRequest`.
2418    pub fn read_version_exact(r: &mut codec::Reader, vers: ProtocolVersion) -> Option<Self> {
2419        let result = Self::read_version(r, vers)?;
2420        if r.any_left() {
2421            None
2422        } else {
2423            Some(result)
2424        }
2425    }
2426
2427    pub fn read_version(r: &mut codec::Reader, vers: ProtocolVersion) -> Option<Self> {
2428        let mut typ = HandshakeType::read(r)?;
2429
2430        let len = codec::u24::read(r)?.0 as usize;
2431        let mut sub = r.sub(len)?;
2432
2433        let payload = match typ {
2434            HandshakeType::HelloRequest if sub.left() == 0 => HandshakePayload::HelloRequest,
2435            HandshakeType::ClientHello => {
2436                HandshakePayload::ClientHello(ClientHelloPayload::read(&mut sub)?)
2437            }
2438            HandshakeType::ServerHello => {
2439                let version = ProtocolVersion::read(&mut sub)?;
2440                let random = Random::read(&mut sub)?;
2441
2442                if Ok(random) == fn_hello_retry_request_random() {
2443                    let mut hrr = HelloRetryRequest::read(&mut sub)?;
2444                    hrr.legacy_version = version;
2445                    hrr.random = random;
2446                    typ = HandshakeType::HelloRetryRequest;
2447                    HandshakePayload::HelloRetryRequest(hrr)
2448                } else {
2449                    let mut shp = ServerHelloPayload::read(&mut sub)?;
2450                    shp.legacy_version = version;
2451                    shp.random = random;
2452                    HandshakePayload::ServerHello(shp)
2453                }
2454            }
2455            HandshakeType::Certificate if vers == ProtocolVersion::TLSv1_3 => {
2456                let p = CertificatePayloadTLS13::read(&mut sub)?;
2457                HandshakePayload::CertificateTLS13(p)
2458            }
2459            HandshakeType::Certificate => {
2460                HandshakePayload::Certificate(CertificatePayload::read(&mut sub)?)
2461            }
2462            HandshakeType::ServerKeyExchange => {
2463                let p = ServerKeyExchangePayload::read(&mut sub)?;
2464                HandshakePayload::ServerKeyExchange(p)
2465            }
2466            HandshakeType::ServerHelloDone => {
2467                if sub.any_left() {
2468                    return None;
2469                }
2470                HandshakePayload::ServerHelloDone
2471            }
2472            HandshakeType::ClientKeyExchange => {
2473                HandshakePayload::ClientKeyExchange(Payload::read(&mut sub))
2474            }
2475            HandshakeType::CertificateRequest if vers == ProtocolVersion::TLSv1_3 => {
2476                let p = CertificateRequestPayloadTLS13::read(&mut sub)?;
2477                HandshakePayload::CertificateRequestTLS13(p)
2478            }
2479            HandshakeType::CertificateRequest => {
2480                let p = CertificateRequestPayload::read(&mut sub)?;
2481                HandshakePayload::CertificateRequest(p)
2482            }
2483            HandshakeType::CertificateVerify => {
2484                HandshakePayload::CertificateVerify(DigitallySignedStruct::read(&mut sub)?)
2485            }
2486            HandshakeType::NewSessionTicket if vers == ProtocolVersion::TLSv1_3 => {
2487                let p = NewSessionTicketPayloadTLS13::read(&mut sub)?;
2488                HandshakePayload::NewSessionTicketTLS13(p)
2489            }
2490            HandshakeType::NewSessionTicket => {
2491                let p = NewSessionTicketPayload::read(&mut sub)?;
2492                HandshakePayload::NewSessionTicket(p)
2493            }
2494            HandshakeType::EncryptedExtensions => {
2495                HandshakePayload::EncryptedExtensions(EncryptedExtensions::read(&mut sub)?)
2496            }
2497            HandshakeType::KeyUpdate => {
2498                HandshakePayload::KeyUpdate(KeyUpdateRequest::read(&mut sub)?)
2499            }
2500            HandshakeType::EndOfEarlyData => {
2501                if sub.any_left() {
2502                    return None;
2503                }
2504                HandshakePayload::EndOfEarlyData
2505            }
2506            HandshakeType::Finished => HandshakePayload::Finished(Payload::read(&mut sub)),
2507            HandshakeType::CertificateStatus => {
2508                HandshakePayload::CertificateStatus(CertificateStatus::read(&mut sub)?)
2509            }
2510            HandshakeType::MessageHash => {
2511                // does not appear on the wire
2512                return None;
2513            }
2514            HandshakeType::HelloRetryRequest => {
2515                // not legal on wire
2516                return None;
2517            }
2518            _ => HandshakePayload::Unknown(Payload::read(&mut sub)),
2519        };
2520
2521        if sub.any_left() {
2522            None
2523        } else {
2524            Some(Self { typ, payload })
2525        }
2526    }
2527
2528    pub fn build_key_update_notify() -> Self {
2529        Self {
2530            typ: HandshakeType::KeyUpdate,
2531            payload: HandshakePayload::KeyUpdate(KeyUpdateRequest::UpdateNotRequested),
2532        }
2533    }
2534
2535    pub fn get_encoding_for_binder_signing(&self) -> Vec<u8> {
2536        let mut ret = self.get_encoding();
2537
2538        let binder_len = match self.payload {
2539            HandshakePayload::ClientHello(ref ch) => match ch.extensions.0.last() {
2540                Some(ClientExtension::PresharedKey(ref offer)) => {
2541                    let mut binders_encoding = Vec::new();
2542                    offer.binders.encode(&mut binders_encoding);
2543                    binders_encoding.len()
2544                }
2545                _ => 0,
2546            },
2547            _ => 0,
2548        };
2549
2550        let ret_len = ret.len() - binder_len;
2551        ret.truncate(ret_len);
2552        ret
2553    }
2554
2555    pub fn build_handshake_hash(hash: &[u8]) -> Self {
2556        Self {
2557            typ: HandshakeType::MessageHash,
2558            payload: HandshakePayload::MessageHash(Payload::new(hash.to_vec())),
2559        }
2560    }
2561}