tlspuffin/tls/rustls/msgs/
hsjoiner.rs

1use std::collections::VecDeque;
2
3use puffin::codec;
4
5use crate::tls::rustls::msgs::enums::{ContentType, ProtocolVersion};
6use crate::tls::rustls::msgs::handshake::HandshakeMessagePayload;
7use crate::tls::rustls::msgs::message::{Message, MessagePayload, PlainMessage};
8
9const HEADER_SIZE: usize = 1 + 3;
10
11/// TLS allows for handshake messages of up to 16MB.  We
12/// restrict that to 64KB to limit potential for denial-of-
13/// service.
14const MAX_HANDSHAKE_SIZE: u32 = 0xffff;
15
16/// This works to reconstruct TLS handshake messages
17/// from individual TLS messages.  It's guaranteed that
18/// TLS messages output from this layer contain precisely
19/// one handshake payload.
20pub struct HandshakeJoiner {
21    /// Completed handshake frames for output.
22    pub frames: VecDeque<Message>,
23
24    /// The message payload we're currently accumulating.
25    buf: Vec<u8>,
26}
27
28impl Default for HandshakeJoiner {
29    fn default() -> Self {
30        Self::new()
31    }
32}
33
34enum BufferState {
35    /// Buffer contains a header that introduces a message that is too long.
36    MessageTooLarge,
37
38    /// Buffer contains a full header and body.
39    OneMessage,
40
41    /// We need more data to see a header and complete body.
42    NeedsMoreData,
43}
44
45impl HandshakeJoiner {
46    /// Make a new HandshakeJoiner.
47    pub fn new() -> Self {
48        Self {
49            frames: VecDeque::new(),
50            buf: Vec::new(),
51        }
52    }
53
54    /// Do we want to process this message?
55    pub fn want_message(&self, msg: &PlainMessage) -> bool {
56        msg.typ == ContentType::Handshake
57    }
58
59    /// Do we have any buffered data?
60    pub fn is_empty(&self) -> bool {
61        self.buf.is_empty()
62    }
63
64    /// Take the message, and join/split it as needed.
65    /// Return the number of new messages added to the
66    /// output deque as a result of this message.
67    ///
68    /// Returns None if msg or a preceding message was corrupt.
69    /// You cannot recover from this situation.  Otherwise returns
70    /// a count of how many messages we queued.
71    pub fn take_message(&mut self, msg: PlainMessage) -> Option<usize> {
72        // The vast majority of the time `self.buf` will be empty since most
73        // handshake messages arrive in a single fragment. Avoid allocating and
74        // copying in that common case.
75        if self.buf.is_empty() {
76            self.buf = msg.payload.0;
77        } else {
78            self.buf.extend_from_slice(&msg.payload.0[..]);
79        }
80
81        let mut count = 0;
82        loop {
83            match self.buf_contains_message() {
84                BufferState::MessageTooLarge => return None,
85                BufferState::NeedsMoreData => break,
86                BufferState::OneMessage => {
87                    if !self.deframe_one(msg.version) {
88                        return None;
89                    }
90
91                    count += 1;
92                }
93            }
94        }
95
96        Some(count)
97    }
98
99    /// Does our `buf` contain a full handshake payload?  It does if it is big
100    /// enough to contain a header, and that header has a length which falls
101    /// within `buf`.
102    fn buf_contains_message(&self) -> BufferState {
103        if self.buf.len() < HEADER_SIZE {
104            return BufferState::NeedsMoreData;
105        }
106
107        let (header, rest) = self.buf.split_at(HEADER_SIZE);
108        match codec::u24::decode(&header[1..]) {
109            Some(len) if len.0 > MAX_HANDSHAKE_SIZE => BufferState::MessageTooLarge,
110            Some(len) if rest.get(..len.into()).is_some() => BufferState::OneMessage,
111            _ => BufferState::NeedsMoreData,
112        }
113    }
114
115    /// Take a TLS handshake payload off the front of `buf`, and put it onto
116    /// the back of our `frames` deque inside a normal `Message`.
117    ///
118    /// Returns false if the stream is desynchronised beyond repair.
119    fn deframe_one(&mut self, version: ProtocolVersion) -> bool {
120        let used = {
121            let mut rd = codec::Reader::init(&self.buf);
122            let payload = match HandshakeMessagePayload::read_version(&mut rd, version) {
123                Some(p) => p,
124                None => return false,
125            };
126
127            let m = Message {
128                version,
129                payload: MessagePayload::Handshake(payload),
130            };
131
132            self.frames.push_back(m);
133            rd.used()
134        };
135        self.buf = self.buf.split_off(used);
136        true
137    }
138}
139
140#[cfg(test)]
141mod tests {
142    use puffin::codec::Codec;
143
144    use super::HandshakeJoiner;
145    use crate::tls::rustls::msgs::base::Payload;
146    use crate::tls::rustls::msgs::enums::{ContentType, HandshakeType, ProtocolVersion};
147    use crate::tls::rustls::msgs::handshake::{HandshakeMessagePayload, HandshakePayload};
148    use crate::tls::rustls::msgs::message::{Message, MessagePayload, PlainMessage};
149
150    #[test_log::test]
151    fn want() {
152        let hj = HandshakeJoiner::new();
153        assert!(hj.is_empty());
154
155        let wanted = PlainMessage {
156            typ: ContentType::Handshake,
157            version: ProtocolVersion::TLSv1_2,
158            payload: Payload::new(b"hello world".to_vec()),
159        };
160
161        let unwanted = PlainMessage {
162            typ: ContentType::Alert,
163            version: ProtocolVersion::TLSv1_2,
164            payload: Payload::new(b"ponytown".to_vec()),
165        };
166
167        assert!(hj.want_message(&wanted));
168        assert!(!hj.want_message(&unwanted));
169    }
170
171    fn pop_eq(expect: &PlainMessage, hj: &mut HandshakeJoiner) {
172        let got = hj.frames.pop_front().unwrap();
173        assert_eq!(got.payload.content_type(), expect.typ);
174        assert_eq!(got.version, expect.version);
175
176        let (mut left, mut right) = (Vec::new(), Vec::new());
177        got.payload.encode(&mut left);
178        expect.payload.encode(&mut right);
179
180        assert_eq!(left, right);
181    }
182
183    #[test_log::test]
184    fn split() {
185        // Check we split two handshake messages within one PDU.
186        let mut hj = HandshakeJoiner::new();
187
188        // two HelloRequests
189        let msg = PlainMessage {
190            typ: ContentType::Handshake,
191            version: ProtocolVersion::TLSv1_2,
192            payload: Payload::new(b"\x00\x00\x00\x00\x00\x00\x00\x00".to_vec()),
193        };
194
195        assert!(hj.want_message(&msg));
196        assert_eq!(hj.take_message(msg), Some(2));
197        assert!(hj.is_empty());
198
199        let expect = Message {
200            version: ProtocolVersion::TLSv1_2,
201            payload: MessagePayload::Handshake(HandshakeMessagePayload {
202                typ: HandshakeType::HelloRequest,
203                payload: HandshakePayload::HelloRequest,
204            }),
205        }
206        .into();
207
208        pop_eq(&expect, &mut hj);
209        pop_eq(&expect, &mut hj);
210    }
211
212    #[test_log::test]
213    fn broken() {
214        // Check obvious crap payloads are reported as errors, not panics.
215        let mut hj = HandshakeJoiner::new();
216
217        // short ClientHello
218        let msg = PlainMessage {
219            typ: ContentType::Handshake,
220            version: ProtocolVersion::TLSv1_2,
221            payload: Payload::new(b"\x01\x00\x00\x02\xff\xff".to_vec()),
222        };
223
224        assert!(hj.want_message(&msg));
225        assert_eq!(hj.take_message(msg), None);
226    }
227
228    #[test_log::test]
229    fn join() {
230        // Check we join one handshake message split over two PDUs.
231        let mut hj = HandshakeJoiner::new();
232        assert!(hj.is_empty());
233
234        // Introduce Finished of 16 bytes, providing 4.
235        let mut msg = PlainMessage {
236            typ: ContentType::Handshake,
237            version: ProtocolVersion::TLSv1_2,
238            payload: Payload::new(b"\x14\x00\x00\x10\x00\x01\x02\x03\x04".to_vec()),
239        };
240
241        assert!(hj.want_message(&msg));
242        assert_eq!(hj.take_message(msg), Some(0));
243        assert!(!hj.is_empty());
244
245        // 11 more bytes.
246        msg = PlainMessage {
247            typ: ContentType::Handshake,
248            version: ProtocolVersion::TLSv1_2,
249            payload: Payload::new(b"\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e".to_vec()),
250        };
251
252        assert!(hj.want_message(&msg));
253        assert_eq!(hj.take_message(msg), Some(0));
254        assert!(!hj.is_empty());
255
256        // Final 1 byte.
257        msg = PlainMessage {
258            typ: ContentType::Handshake,
259            version: ProtocolVersion::TLSv1_2,
260            payload: Payload::new(b"\x0f".to_vec()),
261        };
262
263        assert!(hj.want_message(&msg));
264        assert_eq!(hj.take_message(msg), Some(1));
265        assert!(hj.is_empty());
266
267        let payload = b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f".to_vec();
268        let expect = Message {
269            version: ProtocolVersion::TLSv1_2,
270            payload: MessagePayload::Handshake(HandshakeMessagePayload {
271                typ: HandshakeType::Finished,
272                payload: HandshakePayload::Finished(Payload::new(payload)),
273            }),
274        }
275        .into();
276
277        pop_eq(&expect, &mut hj);
278    }
279
280    #[test_log::test]
281    fn test_rejects_giant_certs() {
282        let mut hj = HandshakeJoiner::new();
283        let msg = PlainMessage {
284            typ: ContentType::Handshake,
285            version: ProtocolVersion::TLSv1_2,
286            payload: Payload::new(b"\x0b\x01\x00\x04\x01\x00\x01\x00\xff\xfe".to_vec()),
287        };
288
289        assert!(hj.want_message(&msg));
290        assert_eq!(hj.take_message(msg), None);
291        assert!(!hj.is_empty());
292    }
293}