tlspuffin/tls/rustls/msgs/
hsjoiner.rs1use 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
11const MAX_HANDSHAKE_SIZE: u32 = 0xffff;
15
16pub struct HandshakeJoiner {
21 pub frames: VecDeque<Message>,
23
24 buf: Vec<u8>,
26}
27
28impl Default for HandshakeJoiner {
29 fn default() -> Self {
30 Self::new()
31 }
32}
33
34enum BufferState {
35 MessageTooLarge,
37
38 OneMessage,
40
41 NeedsMoreData,
43}
44
45impl HandshakeJoiner {
46 pub fn new() -> Self {
48 Self {
49 frames: VecDeque::new(),
50 buf: Vec::new(),
51 }
52 }
53
54 pub fn want_message(&self, msg: &PlainMessage) -> bool {
56 msg.typ == ContentType::Handshake
57 }
58
59 pub fn is_empty(&self) -> bool {
61 self.buf.is_empty()
62 }
63
64 pub fn take_message(&mut self, msg: PlainMessage) -> Option<usize> {
72 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 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 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 let mut hj = HandshakeJoiner::new();
187
188 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 let mut hj = HandshakeJoiner::new();
216
217 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 let mut hj = HandshakeJoiner::new();
232 assert!(hj.is_empty());
233
234 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 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 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}