rustnet_core/network/protocol/
tcp.rs1use crate::network::dpi;
4use crate::network::parser::{ParsedPacket, ParserConfig};
5use crate::network::protocol::{TransportParams, orient_endpoints};
6use crate::network::types::{Protocol, ProtocolState, TcpState};
7
8const TCP_FIN: u8 = 0x01;
9const TCP_SYN: u8 = 0x02;
10const TCP_RST: u8 = 0x04;
11const TCP_ACK: u8 = 0x10;
12
13#[derive(Debug, Clone, Copy)]
15pub struct TcpFlags {
16 pub fin: bool,
17 pub syn: bool,
18 pub rst: bool,
19 pub ack: bool,
20}
21
22#[derive(Debug, Clone, Copy)]
24pub struct TcpHeaderInfo {
25 pub seq: u32, pub ack: u32, pub window: u16, pub flags: TcpFlags, pub payload_len: u32, pub window_scale: Option<SynWindowScale>,
33}
34
35#[derive(Debug, Clone, Copy, PartialEq, Eq)]
42pub enum SynWindowScale {
43 Present(u8),
45 Absent,
47 Unknown,
50}
51
52const MAX_WINDOW_SCALE: u8 = 14;
54
55fn parse_window_scale(options: &[u8]) -> SynWindowScale {
57 let mut i = 0;
58 while i < options.len() {
59 match options[i] {
60 0 => return SynWindowScale::Absent, 1 => i += 1, kind => {
63 let Some(&len) = options.get(i + 1) else {
64 return SynWindowScale::Unknown; };
66 let len = len as usize;
67 if len < 2 || i + len > options.len() {
68 return SynWindowScale::Unknown; }
70 if kind == 3 {
71 return if len == 3 {
75 SynWindowScale::Present(options[i + 2].min(MAX_WINDOW_SCALE))
76 } else {
77 SynWindowScale::Unknown
78 };
79 }
80 i += len;
81 }
82 }
83 }
84 SynWindowScale::Absent
85}
86
87pub(crate) fn parse_tcp_flags(flags: u8) -> TcpFlags {
89 TcpFlags {
90 fin: (flags & TCP_FIN) != 0,
91 syn: (flags & TCP_SYN) != 0,
92 rst: (flags & TCP_RST) != 0,
93 ack: (flags & TCP_ACK) != 0,
94 }
95}
96
97pub(crate) fn parse(
99 transport_data: &[u8],
100 params: TransportParams,
101 config: &ParserConfig,
102 local_ips: &std::collections::HashSet<std::net::IpAddr>,
103) -> Option<ParsedPacket> {
104 if transport_data.len() < 20 {
105 return None;
106 }
107
108 let src_port = u16::from_be_bytes([transport_data[0], transport_data[1]]);
109 let dst_port = u16::from_be_bytes([transport_data[2], transport_data[3]]);
110
111 let seq = u32::from_be_bytes([
112 transport_data[4],
113 transport_data[5],
114 transport_data[6],
115 transport_data[7],
116 ]);
117 let ack = u32::from_be_bytes([
118 transport_data[8],
119 transport_data[9],
120 transport_data[10],
121 transport_data[11],
122 ]);
123 let window = u16::from_be_bytes([transport_data[14], transport_data[15]]);
124 let flags = transport_data[13];
125
126 let tcp_flags = parse_tcp_flags(flags);
127
128 let tcp_header_len = ((transport_data[12] >> 4) as usize) * 4;
132 if tcp_header_len < 20 {
133 return None;
134 }
135 let tcp_payload_len = transport_data.len().saturating_sub(tcp_header_len) as u32;
136
137 let window_scale = if tcp_flags.syn {
141 Some(if transport_data.len() < tcp_header_len {
142 SynWindowScale::Unknown
143 } else if tcp_header_len > 20 {
144 parse_window_scale(&transport_data[20..tcp_header_len])
145 } else {
146 SynWindowScale::Absent
147 })
148 } else {
149 None
150 };
151
152 let tcp_header = TcpHeaderInfo {
153 seq,
154 ack,
155 window,
156 flags: tcp_flags,
157 payload_len: tcp_payload_len,
158 window_scale,
159 };
160
161 log::trace!(
162 "TCP flags: FIN={} SYN={} RST={} ACK={}",
163 tcp_flags.fin,
164 tcp_flags.syn,
165 tcp_flags.rst,
166 tcp_flags.ack
167 );
168
169 let (local_addr, remote_addr, is_outgoing) =
170 orient_endpoints(¶ms, src_port, dst_port, local_ips);
171
172 let dpi_result = if config.enable_dpi {
173 if transport_data.len() > tcp_header_len {
174 let payload = &transport_data[tcp_header_len..];
175 dpi::analyze_tcp_packet(payload, local_addr.port(), remote_addr.port(), is_outgoing)
176 } else {
177 None
178 }
179 } else {
180 None
181 };
182
183 let mut packet = ParsedPacket::new(
184 Protocol::Tcp,
185 local_addr,
186 remote_addr,
187 ProtocolState::Tcp(TcpState::Unknown),
188 is_outgoing,
189 params.packet_len,
190 params.process_name,
191 params.process_id,
192 );
193 packet.tcp_header = Some(tcp_header);
194 packet.dpi_result = dpi_result;
195 Some(packet)
196}
197
198#[cfg(test)]
199mod tests {
200 use super::*;
201
202 #[test]
203 fn test_tcp_flags_parsing() {
204 let flags = parse_tcp_flags(0x02); assert!(flags.syn);
206 assert!(!flags.ack);
207 assert!(!flags.fin);
208
209 let flags = parse_tcp_flags(0x12); assert!(flags.syn);
211 assert!(flags.ack);
212
213 let flags = parse_tcp_flags(0x11); assert!(flags.fin);
215 assert!(flags.ack);
216 }
217
218 #[test]
219 fn window_scale_option_parsed() {
220 let options = [2, 4, 0x05, 0xb4, 1, 3, 3, 7];
222 assert_eq!(parse_window_scale(&options), SynWindowScale::Present(7));
223 }
224
225 #[test]
226 fn window_scale_proven_absent() {
227 let options = [2, 4, 0x05, 0xb4, 0, 0, 0, 0];
229 assert_eq!(parse_window_scale(&options), SynWindowScale::Absent);
230 let options = [2, 4, 0x05, 0xb4];
232 assert_eq!(parse_window_scale(&options), SynWindowScale::Absent);
233 }
234
235 #[test]
236 fn window_scale_clamped_to_rfc_max() {
237 let options = [3, 3, 60];
238 assert_eq!(parse_window_scale(&options), SynWindowScale::Present(14));
239 }
240
241 #[test]
242 fn window_scale_unknown_on_malformed_options() {
243 let options = [2, 40, 0x05];
246 assert_eq!(parse_window_scale(&options), SynWindowScale::Unknown);
247 let options = [5, 0, 3, 3, 7];
249 assert_eq!(parse_window_scale(&options), SynWindowScale::Unknown);
250 let options = [3];
252 assert_eq!(parse_window_scale(&options), SynWindowScale::Unknown);
253 }
254
255 #[test]
256 fn window_scale_with_illegal_length_is_unknown() {
257 let options = [3, 2];
260 assert_eq!(parse_window_scale(&options), SynWindowScale::Unknown);
261 let options = [3, 4, 7, 0];
262 assert_eq!(parse_window_scale(&options), SynWindowScale::Unknown);
263 }
264}