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() { 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)?)) } 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]) .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]) }
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 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 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 #[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 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#[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#[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 pub fn new(id: PresharedKeyIdentity, binder: Vec<u8>) -> Self {
542 Self {
543 identities: PresharedKeyIdentities(vec![id]), binders: VecU16OfPayloadU8(vec![PresharedKeyBinder::new(binder)]), }
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
569type ResponderIDs = VecU16OfPayloadU16;
571
572#[derive(Clone, Debug, PartialEq, Comparable)]
573pub struct OCSPCertificateStatusRequest {
574 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
638pub type SCTList = VecU16OfPayloadU16;
642
643declare_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(#[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() }
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 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 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])) }
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(#[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 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 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); }
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 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 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), random: fn_hello_retry_request_random().unwrap(), session_id,
1297 cipher_suite,
1298 compression_methods: Compressions(vec![compression_method]), extensions,
1302 })
1303 }
1304}
1305
1306impl HelloRetryRequest {
1307 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 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 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 Some(CertificatePayload(codec::read_vec_u24_limited(r, 0x10000)?))
1498 }
1499}
1500
1501#[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#[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 #[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 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
1920declare_u16_vec!(EncryptedExtensions, ServerExtension);
1922
1923pub trait HasServerExtensions {
1924 fn get_extensions(&self) -> &[ServerExtension];
1925
1926 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
1983declare_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; }
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#[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#[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#[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 let mut sub: Vec<u8> = Vec::new();
2396 self.payload.encode(&mut sub);
2397
2398 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 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 return None;
2513 }
2514 HandshakeType::HelloRetryRequest => {
2515 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}