1use std::any::TypeId;
2
3use comparable::Comparable;
4use extractable_macro::Extractable;
5use puffin::codec;
6use puffin::codec::{Codec, Reader, VecCodecWoSize};
7use puffin::error::Error::{Term, TermBug};
8use puffin::protocol::{EvaluatedTerm, ProtocolMessage};
9
10use crate::claims::*;
11use crate::protocol::{MessageFlight, OpaqueMessageFlight, TLSProtocolTypes};
12use crate::tls::rustls::error::Error;
13use crate::tls::rustls::hash_hs::HandshakeHash;
14use crate::tls::rustls::key::Certificate;
15use crate::tls::rustls::msgs::alert::AlertMessagePayload;
16use crate::tls::rustls::msgs::base::{Payload, PayloadU16, PayloadU24, PayloadU8};
17use crate::tls::rustls::msgs::ccs::ChangeCipherSpecPayload;
18use crate::tls::rustls::msgs::enums::ContentType::ApplicationData;
19use crate::tls::rustls::msgs::enums::ProtocolVersion::TLSv1_3;
20use crate::tls::rustls::msgs::enums::{
21 AlertDescription, AlertLevel, CipherSuite, Compression, ContentType, HandshakeType, NamedGroup,
22 ProtocolVersion, SignatureScheme,
23};
24use crate::tls::rustls::msgs::handshake::{
25 CertReqExtension, CertificateEntries, CertificateEntry, CertificateExtension,
26 CertificateExtensions, CipherSuites, ClientExtension, ClientExtensions, Compressions,
27 HandshakeMessagePayload, HelloRetryExtension, HelloRetryExtensions, KeyShareEntries,
28 KeyShareEntry, NewSessionTicketExtension, NewSessionTicketExtensions, PresharedKeyIdentity,
29 Random, ServerExtension, ServerExtensions, ServerName, ServerNameRequest, SessionID,
30 SupportedSignatureSchemes, VecU16OfPayloadU16, VecU16OfPayloadU8,
31};
32use crate::tls::rustls::msgs::heartbeat::HeartbeatPayload;
33
34#[derive(Debug, Clone, Extractable, Comparable)]
35#[extractable(TLSProtocolTypes)]
36pub enum MessagePayload {
37 Alert(AlertMessagePayload),
38 Handshake(HandshakeMessagePayload),
39 TLS12EncryptedHandshake(Payload),
41 ChangeCipherSpec(ChangeCipherSpecPayload),
42 ApplicationData(Payload),
43 Heartbeat(HeartbeatPayload),
44}
45
46impl codec::CodecP for MessagePayload {
47 fn encode(&self, bytes: &mut Vec<u8>) {
48 MessagePayload::encode(self, bytes);
49 }
50
51 fn read(&mut self, _: &mut Reader) -> Result<(), puffin::error::Error> {
52 Err(puffin::error::Error::Codec(format!(
53 "Failed to read for type {:?}",
54 std::any::type_name::<MessagePayload>()
55 )))
56 }
57}
58
59impl PartialEq for MessagePayload {
60 fn eq(&self, other: &Self) -> bool {
61 match (self, other) {
62 (MessagePayload::Alert(_), MessagePayload::Alert(_)) => true,
63 (MessagePayload::Handshake(_), MessagePayload::Handshake(_)) => true,
64 (
65 MessagePayload::TLS12EncryptedHandshake(_),
66 MessagePayload::TLS12EncryptedHandshake(_),
67 ) => true,
68 (MessagePayload::ChangeCipherSpec(_), MessagePayload::ChangeCipherSpec(_)) => true,
69 (MessagePayload::ApplicationData(_), MessagePayload::ApplicationData(_)) => true,
70 (MessagePayload::Heartbeat(_), MessagePayload::Heartbeat(_)) => true,
71 (_, _) => false,
72 }
73 }
74}
75
76impl MessagePayload {
77 pub fn encode(&self, bytes: &mut Vec<u8>) {
78 match *self {
79 Self::Alert(ref x) => x.encode(bytes),
80 Self::Handshake(ref x) => x.encode(bytes),
81 Self::TLS12EncryptedHandshake(ref x) => x.encode(bytes),
82 Self::ChangeCipherSpec(ref x) => x.encode(bytes),
83 Self::ApplicationData(ref x) => x.encode(bytes),
84 Self::Heartbeat(ref x) => x.encode(bytes),
85 }
86 }
87
88 pub fn new(typ: ContentType, vers: ProtocolVersion, payload: Payload) -> Result<Self, Error> {
89 let fallback_payload = payload.clone();
90 let mut r = Reader::init(&payload.0);
91 let parsed = match typ {
92 ContentType::ApplicationData => return Ok(Self::ApplicationData(payload)),
93 ContentType::Alert => AlertMessagePayload::read(&mut r).map(MessagePayload::Alert),
94 ContentType::Handshake => {
95 HandshakeMessagePayload::read_version_exact(&mut r, vers)
96 .map(MessagePayload::Handshake)
97 .or(Some(MessagePayload::TLS12EncryptedHandshake(
99 fallback_payload,
100 )))
101 }
102 ContentType::ChangeCipherSpec => {
103 ChangeCipherSpecPayload::read(&mut r).map(MessagePayload::ChangeCipherSpec)
104 }
105 ContentType::Heartbeat => HeartbeatPayload::read(&mut r).map(MessagePayload::Heartbeat),
106 _ => None,
107 };
108
109 parsed.ok_or(Error::corrupt_message(typ))
110 }
114
115 pub fn multiple_new(
117 typ: ContentType,
118 vers: ProtocolVersion,
119 payload: Payload,
120 ) -> Result<Vec<Self>, Error> {
121 let fallback_payload = &payload;
122 let mut r = Reader::init(&payload.0);
123 let mut parsed: Vec<Self> = vec![];
124 while r.any_left() {
125 let parsed_msg = match typ {
126 ContentType::ApplicationData => Some(Self::ApplicationData(payload.clone())),
127 ContentType::Alert => AlertMessagePayload::read(&mut r).map(MessagePayload::Alert),
128 ContentType::Handshake => {
129 HandshakeMessagePayload::read_version(&mut r, vers)
130 .map(MessagePayload::Handshake)
131 .or(Some(MessagePayload::TLS12EncryptedHandshake(
133 fallback_payload.clone(),
134 )))
135 }
136 ContentType::ChangeCipherSpec => {
137 ChangeCipherSpecPayload::read(&mut r).map(MessagePayload::ChangeCipherSpec)
138 }
139 ContentType::Heartbeat => {
140 HeartbeatPayload::read(&mut r).map(MessagePayload::Heartbeat)
141 }
142 _ => None,
143 };
144 if let Some(msg) = parsed_msg {
145 parsed.push(msg);
146 }
147 }
148
149 Ok(parsed)
150 }
151
152 pub fn content_type(&self) -> ContentType {
153 match self {
154 Self::Alert(_) => ContentType::Alert,
155 Self::Handshake(_) => ContentType::Handshake,
156 Self::TLS12EncryptedHandshake(_) => ContentType::Handshake,
157 Self::ChangeCipherSpec(_) => ContentType::ChangeCipherSpec,
158 Self::ApplicationData(_) => ContentType::ApplicationData,
159 Self::Heartbeat(_) => ContentType::Heartbeat,
160 }
161 }
162}
163
164#[derive(Debug, Clone, Extractable, Comparable, PartialEq)]
170#[extractable(TLSProtocolTypes)]
171pub struct OpaqueMessage {
172 #[extractable_ignore]
173 pub typ: ContentType,
174 #[extractable_ignore]
175 pub version: ProtocolVersion,
176 #[extractable_ignore]
177 #[comparable_ignore]
178 pub payload: Payload,
179}
180
181impl codec::VecCodecWoSize for OpaqueMessage {}
182
183impl Codec for OpaqueMessage {
184 fn encode(&self, bytes: &mut Vec<u8>) {
185 self.typ.encode(bytes);
186 self.version.encode(bytes);
187 (self.payload.0.len() as u16).encode(bytes);
188 self.payload.encode(bytes);
189 }
190
191 fn read(reader: &mut Reader) -> Option<Self> {
192 Self::read(reader).ok()
193 }
194}
195
196impl OpaqueMessage {
197 const HEADER_SIZE: u16 = 1 + 2 + 2;
199 const MAX_PAYLOAD: u16 = 16384 + 2048;
203 pub const MAX_WIRE_SIZE: usize = (Self::MAX_PAYLOAD + Self::HEADER_SIZE) as usize;
205
206 pub fn read(r: &mut Reader) -> Result<Self, MessageError> {
209 #[cfg(not(feature = "enable-guards"))]
210 let typ = ContentType::read(r).unwrap_or(ApplicationData);
211 #[cfg(not(feature = "enable-guards"))]
212 let version = ProtocolVersion::read(r).unwrap_or(TLSv1_3);
213
214 #[cfg(feature = "enable-guards")]
215 let typ = ContentType::read(r).ok_or(MessageError::TooShortForHeader)?;
216 #[cfg(feature = "enable-guards")]
217 let version = ProtocolVersion::read(r).ok_or(MessageError::TooShortForHeader)?;
218
219 let len = u16::read(r).ok_or(MessageError::TooShortForHeader)?;
220
221 #[cfg(feature = "enable-guards")]
222 if typ != ContentType::ApplicationData && len == 0 {
226 return Err(MessageError::IllegalLength);
227 }
228
229 #[cfg(feature = "enable-guards")]
230 if len >= Self::MAX_PAYLOAD {
232 return Err(MessageError::IllegalLength);
233 }
234
235 #[cfg(feature = "enable-guards")]
236 if let ContentType::Unknown(_) = typ {
238 return Err(MessageError::IllegalContentType);
239 }
240
241 #[cfg(feature = "enable-guards")]
242 match version {
244 ProtocolVersion::Unknown(ref v) if (v & 0xff00) != 0x0300 => {
245 return Err(MessageError::IllegalProtocolVersion);
246 }
247 _ => {}
248 };
249
250 let mut sub = r.sub(len as usize).ok_or(MessageError::TooShortForLength)?;
251 let payload = Payload::read(&mut sub);
252
253 Ok(Self {
254 typ,
255 version,
256 payload,
257 })
258 }
259
260 pub fn into_plain_message(self) -> PlainMessage {
265 PlainMessage {
266 version: self.version,
267 typ: self.typ,
268 payload: self.payload,
269 }
270 }
271}
272
273impl From<Message> for PlainMessage {
274 fn from(msg: Message) -> Self {
275 let typ = msg.payload.content_type();
276 let payload = match msg.payload {
277 MessagePayload::ApplicationData(payload) => payload,
278 _ => {
279 let mut buf = Vec::new();
280 msg.payload.encode(&mut buf);
281 Payload(buf)
282 }
283 };
284
285 Self {
286 typ,
287 version: msg.version,
288 payload,
289 }
290 }
291}
292
293#[derive(Clone, Debug)]
298pub struct PlainMessage {
299 pub typ: ContentType,
300 pub version: ProtocolVersion,
301 pub payload: Payload,
302}
303
304impl PlainMessage {
305 pub fn into_unencrypted_opaque(self) -> OpaqueMessage {
306 OpaqueMessage {
307 version: self.version,
308 typ: self.typ,
309 payload: self.payload,
310 }
311 }
312
313 pub fn borrow(&self) -> BorrowedPlainMessage<'_> {
314 BorrowedPlainMessage {
315 version: self.version,
316 typ: self.typ,
317 payload: &self.payload.0,
318 }
319 }
320}
321
322#[derive(Debug, Clone, Comparable, PartialEq)]
324pub struct Message {
325 pub version: ProtocolVersion,
326 pub payload: MessagePayload,
327}
328
329impl VecCodecWoSize for Message {}
331
332impl Codec for Message {
333 fn encode(&self, bytes: &mut Vec<u8>) {
334 Codec::encode(&self.create_opaque(), bytes);
335 }
336
337 fn read(reader: &mut Reader) -> Option<Self> {
338 <OpaqueMessage>::read(reader)
339 .ok()
340 .and_then(|op| Message::try_from(op).ok())
341 }
342}
343
344impl Message {
345 pub fn is_handshake_type(&self, hstyp: HandshakeType) -> bool {
346 if let MessagePayload::Handshake(ref hsp) = self.payload {
348 hsp.typ == hstyp
349 } else {
350 false
351 }
352 }
353
354 pub fn build_alert(level: AlertLevel, desc: AlertDescription) -> Self {
355 Self {
356 version: ProtocolVersion::TLSv1_2,
357 payload: MessagePayload::Alert(AlertMessagePayload {
358 level,
359 description: desc,
360 }),
361 }
362 }
363
364 pub fn build_key_update_notify() -> Self {
365 Self {
366 version: ProtocolVersion::TLSv1_3,
367 payload: MessagePayload::Handshake(HandshakeMessagePayload::build_key_update_notify()),
368 }
369 }
370}
371
372impl TryFrom<PlainMessage> for Message {
377 type Error = Error;
378
379 fn try_from(plain: PlainMessage) -> Result<Self, Self::Error> {
380 Ok(Self {
381 version: plain.version,
382 payload: MessagePayload::new(plain.typ, plain.version, plain.payload)?,
383 })
384 }
385}
386
387impl TryFrom<OpaqueMessage> for Message {
388 type Error = Error;
389
390 fn try_from(value: OpaqueMessage) -> Result<Self, Self::Error> {
391 Message::try_from(value.into_plain_message())
392 }
393}
394
395pub struct BorrowedPlainMessage<'a> {
404 pub typ: ContentType,
405 pub version: ProtocolVersion,
406 pub payload: &'a [u8],
407}
408
409#[derive(Debug)]
410pub enum MessageError {
411 TooShortForHeader,
412 TooShortForLength,
413 IllegalLength,
414 IllegalContentType,
415 IllegalProtocolVersion,
416}
417
418impl VecCodecWoSize for ClientExtension {} impl VecCodecWoSize for ServerExtension {} impl VecCodecWoSize for HelloRetryExtension {} impl VecCodecWoSize for CertReqExtension {} impl VecCodecWoSize for CertificateExtension {} impl VecCodecWoSize for NewSessionTicketExtension {} impl VecCodecWoSize for Compression {} impl VecCodecWoSize for Certificate {} impl VecCodecWoSize for CertificateEntry {} impl VecCodecWoSize for CipherSuite {} impl VecCodecWoSize for PresharedKeyIdentity {} impl VecCodecWoSize for NamedGroup {} impl VecCodecWoSize for KeyShareEntry {} impl VecCodecWoSize for SignatureScheme {} impl VecCodecWoSize for ServerName {} #[macro_export]
451macro_rules! try_read {
452 ($bitstring:expr, $ti:expr, $T:ty, $($Ts:ty),+) => {
453 {
454 if $ti == TypeId::of::<$T>() {
455 log::trace!("Type match TypeID {:?}...!", core::any::type_name::<$T>());
456 <$T>::read_bytes($bitstring).ok_or(Term(format!(
457 "[try_read_bytes] Failed to read to type {:?} the bitstring {:?}",
458 core::any::type_name::<$T>(),
459 & $bitstring
460 ))).map(|v| Box::new(v) as Box<dyn EvaluatedTerm<TLSProtocolTypes>>)
461 } else {
462 try_read!($bitstring, $ti, $($Ts),+)
463 }
464 }
465 };
466
467 ($bitstring:expr, $ti:expr, $T:ty ) => {
468 {
469 if $ti == TypeId::of::<$T>() {
470 log::trace!("Type match TypeID {:?}...!", core::any::type_name::<$T>());
471 <$T>::read_bytes($bitstring).ok_or(Term(format!(
472 "[try_read_bytes] Failed to read to type {:?} the bitstring {:?}",
473 core::any::type_name::<$T>(),
474 &$bitstring
475 )).into()).map(|v| Box::new(v) as Box<dyn EvaluatedTerm<TLSProtocolTypes>>)
476 } else {
477 log::warn!("Failed to find a suitable type with typeID {:?} to read the bitstring {:?}", $ti, &$bitstring);
478 Err(TermBug(format!(
479 "[try_read_bytes] Failed to find a suitable type with typeID {:?} to read the bitstring {:?}",
480 $ti,
481 &$bitstring
482 )))
483 }
484 }
485 };
486}
487
488pub fn try_read_bytes(
495 bitstring: &[u8],
496 ty: TypeId,
497) -> Result<Box<dyn EvaluatedTerm<TLSProtocolTypes>>, puffin::error::Error> {
498 log::trace!("Trying read...");
499 try_read!(
500 bitstring,
501 ty,
502 Message,
507 OpaqueMessage,
508 MessageFlight,
509 OpaqueMessageFlight,
510 Vec<Certificate>,
511 Certificate,
512 CertificateEntries,
513 Vec<CertificateEntry>,
514 CertificateEntry,
515 ServerExtensions,
516 Vec<ServerExtension>,
517 ClientExtensions,
518 Vec<ClientExtension>,
519 ClientExtension,
520 ServerExtension,
521 HelloRetryExtensions,
522 Vec<HelloRetryExtension>,
523 HelloRetryExtension,
524 Vec<CertReqExtension>,
525 CertReqExtension,
526 Vec<CertificateExtension>,
527 CertificateExtension,
528 CertificateExtensions,
529 Vec<NewSessionTicketExtension>,
530 NewSessionTicketExtension,
531 NewSessionTicketExtensions,
532 Random,
533 Compressions,
534 Vec<Compression>,
535 Compression,
536 SessionID,
537 CipherSuites,
540 Vec<CipherSuite>,
541 CipherSuite,
542 Vec<PresharedKeyIdentity>,
543 PresharedKeyIdentity,
544 AlertMessagePayload,
545 SignatureScheme,
546 ProtocolVersion,
547 HandshakeHash,
548 TranscriptServerFinished,
549 TlsTranscript,
550 TranscriptPartialClientHello,
551 TranscriptServerHello,
552 TranscriptCertificate,
553 TranscriptClientFinished,
554 u64,
555 u32,
556 u16,
557 u8,
558 PayloadU24,
560 PayloadU16,
561 PayloadU8,
562 Vec<PayloadU24>,
563 Vec<PayloadU16>,
564 Vec<PayloadU8>,
565 VecU16OfPayloadU16,
566 VecU16OfPayloadU8,
567 Vec<u8>,
568 Option<Vec<u8>>,
569 Vec<NamedGroup>,
570 SupportedSignatureSchemes,
577 Vec<SignatureScheme>,
578 ServerNameRequest,
579 Vec<ServerName>,
580 ServerName,
581 KeyShareEntries,
582 Vec<KeyShareEntry>,
583 KeyShareEntry,
584 Vec<Vec<u8>>,
585 bool,
586 NamedGroup )
598}