tlspuffin/tls/rustls/msgs/
fragmenter.rs

1use std::collections::VecDeque;
2
3use crate::tls::rustls::error::Error;
4use crate::tls::rustls::msgs::base::Payload;
5use crate::tls::rustls::msgs::enums::{ContentType, ProtocolVersion};
6use crate::tls::rustls::msgs::message::{BorrowedPlainMessage, PlainMessage};
7
8pub const MAX_FRAGMENT_LEN: usize = 16384;
9pub const PACKET_OVERHEAD: usize = 1 + 2 + 2;
10pub const MAX_FRAGMENT_SIZE: usize = MAX_FRAGMENT_LEN + PACKET_OVERHEAD;
11
12pub struct MessageFragmenter {
13    max_frag: usize,
14}
15
16impl MessageFragmenter {
17    /// Make a new fragmenter.
18    ///
19    /// `max_fragment_size` is the maximum fragment size that will be produced --
20    /// this includes overhead. A `max_fragment_size` of 10 will produce TLS fragments
21    /// up to 10 bytes.
22    pub fn new(max_fragment_size: Option<usize>) -> Result<Self, Error> {
23        let mut new = Self { max_frag: 0 };
24        new.set_max_fragment_size(max_fragment_size)?;
25        Ok(new)
26    }
27
28    /// Take the Message `msg` and re-fragment it into new
29    /// messages whose fragment is no more than max_frag.
30    /// The new messages are appended to the `out` deque.
31    /// Payloads are copied.
32    pub fn fragment(&self, msg: PlainMessage, out: &mut VecDeque<PlainMessage>) {
33        // Non-fragment path
34        if msg.payload.0.len() <= self.max_frag {
35            out.push_back(msg);
36            return;
37        }
38
39        for chunk in msg.payload.0.chunks(self.max_frag) {
40            out.push_back(PlainMessage {
41                typ: msg.typ,
42                version: msg.version,
43                payload: Payload(chunk.to_vec()),
44            });
45        }
46    }
47
48    /// Enqueue borrowed fragments of (version, typ, payload) which
49    /// are no longer than max_frag onto the `out` deque.
50    pub fn fragment_borrow<'a>(
51        &self,
52        typ: ContentType,
53        version: ProtocolVersion,
54        payload: &'a [u8],
55        out: &mut VecDeque<BorrowedPlainMessage<'a>>,
56    ) {
57        for chunk in payload.chunks(self.max_frag) {
58            let cm = BorrowedPlainMessage {
59                typ,
60                version,
61                payload: chunk,
62            };
63            out.push_back(cm);
64        }
65    }
66
67    pub fn set_max_fragment_size(&mut self, new: Option<usize>) -> Result<(), Error> {
68        self.max_frag = match new {
69            Some(sz @ 32..=MAX_FRAGMENT_SIZE) => sz - PACKET_OVERHEAD,
70            None => MAX_FRAGMENT_LEN,
71            _ => return Err(Error::BadMaxFragmentSize),
72        };
73        Ok(())
74    }
75}
76
77#[cfg(test)]
78mod tests {
79    use std::collections::VecDeque;
80
81    use puffin::codec::Codec;
82
83    use super::{MessageFragmenter, PACKET_OVERHEAD};
84    use crate::tls::rustls::msgs::base::Payload;
85    use crate::tls::rustls::msgs::enums::{ContentType, ProtocolVersion};
86    use crate::tls::rustls::msgs::message::PlainMessage;
87
88    fn msg_eq(
89        mm: Option<PlainMessage>,
90        total_len: usize,
91        typ: &ContentType,
92        version: &ProtocolVersion,
93        bytes: &[u8],
94    ) {
95        let m = mm.unwrap();
96        let buf = m.clone().into_unencrypted_opaque().get_encoding();
97
98        assert_eq!(&m.typ, typ);
99        assert_eq!(&m.version, version);
100        assert_eq!(m.payload.0, bytes.to_vec());
101
102        assert_eq!(total_len, buf.len());
103    }
104
105    #[test_log::test]
106    fn smoke() {
107        let typ = ContentType::Handshake;
108        let version = ProtocolVersion::TLSv1_2;
109        let data: Vec<u8> = (1..70u8).collect();
110        let m = PlainMessage {
111            typ,
112            version,
113            payload: Payload::new(data),
114        };
115
116        let frag = MessageFragmenter::new(Some(32)).unwrap();
117        let mut q = VecDeque::new();
118        frag.fragment(m, &mut q);
119        msg_eq(
120            q.pop_front(),
121            32,
122            &typ,
123            &version,
124            &[
125                1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
126                24, 25, 26, 27,
127            ],
128        );
129        msg_eq(
130            q.pop_front(),
131            32,
132            &typ,
133            &version,
134            &[
135                28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
136                49, 50, 51, 52, 53, 54,
137            ],
138        );
139        msg_eq(
140            q.pop_front(),
141            20,
142            &typ,
143            &version,
144            &[55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69],
145        );
146        assert_eq!(q.len(), 0);
147    }
148
149    #[test_log::test]
150    fn non_fragment() {
151        let m = PlainMessage {
152            typ: ContentType::Handshake,
153            version: ProtocolVersion::TLSv1_2,
154            payload: Payload::new(b"\x01\x02\x03\x04\x05\x06\x07\x08".to_vec()),
155        };
156
157        let frag = MessageFragmenter::new(Some(32)).unwrap();
158        let mut q = VecDeque::new();
159        frag.fragment(m, &mut q);
160        msg_eq(
161            q.pop_front(),
162            PACKET_OVERHEAD + 8,
163            &ContentType::Handshake,
164            &ProtocolVersion::TLSv1_2,
165            b"\x01\x02\x03\x04\x05\x06\x07\x08",
166        );
167        assert_eq!(q.len(), 0);
168    }
169}