tlspuffin/tls/rustls/msgs/
fragmenter.rs1use 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 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 pub fn fragment(&self, msg: PlainMessage, out: &mut VecDeque<PlainMessage>) {
33 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 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}