Skip to content

Commit a8309b7

Browse files
whitequarkwhitequark
committedDec 25, 2016
Validate TCP ACKs.
·
v0.12.0v0.1.0
1 parent c2311a3 commit a8309b7

File tree

3 files changed

+116
-60
lines changed

3 files changed

+116
-60
lines changed
 

‎README.md

+1
Original file line numberDiff line numberDiff line change
@@ -47,6 +47,7 @@ The TCP protocol is supported over IPv4.
4747

4848
* TCP header checksum is supported.
4949
* TCP options are **not** supported.
50+
* TCP SYN packets with a payload are **not** supported.
5051

5152
Installation
5253
------------

‎src/iface/ethernet.rs

+16-2
Original file line numberDiff line numberDiff line change
@@ -215,8 +215,22 @@ impl<'a, 'b: 'a,
215215
for socket in self.sockets.borrow_mut() {
216216
match socket.collect(&src_addr.into(), &dst_addr.into(),
217217
protocol, ip_packet.payload()) {
218-
Ok(()) => { handled = true; break }
219-
Err(Error::Rejected) => continue,
218+
Ok(()) => {
219+
// The packet was valid and handled by socket.
220+
handled = true;
221+
break
222+
}
223+
Err(Error::Rejected) => {
224+
// The packet wasn't addressed to the socket.
225+
// For TCP, send RST only if no other socket accepts
226+
// the packet.
227+
continue
228+
}
229+
Err(Error::Malformed) => {
230+
// The packet was addressed to the socket but is malformed.
231+
// For TCP, send RST immediately.
232+
break
233+
}
220234
Err(e) => return Err(e)
221235
}
222236
}

‎src/socket/tcp.rs

+99-58
Original file line numberDiff line numberDiff line change
@@ -25,14 +25,19 @@ impl<'a> SocketBuffer<'a> {
2525
}
2626
}
2727

28-
/// Return the amount of octets enqueued in the buffer.
28+
/// Return the maximum amount of octets that can be enqueued in the buffer.
29+
pub fn capacity(&self) -> usize {
30+
self.storage.len()
31+
}
32+
33+
/// Return the amount of octets already enqueued in the buffer.
2934
pub fn len(&self) -> usize {
3035
self.length
3136
}
3237

33-
/// Return the maximum amount of octets that can be enqueued in the buffer.
34-
pub fn capacity(&self) -> usize {
35-
self.storage.len()
38+
/// Return the amount of octets that remain to be enqueued in the buffer.
39+
pub fn window(&self) -> usize {
40+
self.capacity() - self.len()
3641
}
3742

3843
/// Enqueue a slice of octets up to the given size into the buffer, and return a pointer
@@ -135,14 +140,14 @@ impl Retransmit {
135140
/// A Transmission Control Protocol data stream.
136141
#[derive(Debug)]
137142
pub struct TcpSocket<'a> {
138-
state: State,
139-
local_end: IpEndpoint,
140-
remote_end: IpEndpoint,
141-
local_seq_no: i32,
142-
remote_seq_no: i32,
143-
retransmit: Retransmit,
144-
rx_buffer: SocketBuffer<'a>,
145-
tx_buffer: SocketBuffer<'a>
143+
state: State,
144+
local_endpoint: IpEndpoint,
145+
remote_endpoint: IpEndpoint,
146+
local_seq_no: i32,
147+
remote_seq_no: i32,
148+
retransmit: Retransmit,
149+
rx_buffer: SocketBuffer<'a>,
150+
tx_buffer: SocketBuffer<'a>
146151
}
147152

148153
impl<'a> TcpSocket<'a> {
@@ -156,14 +161,14 @@ impl<'a> TcpSocket<'a> {
156161
}
157162

158163
Socket::Tcp(TcpSocket {
159-
state: State::Closed,
160-
local_end: IpEndpoint::default(),
161-
remote_end: IpEndpoint::default(),
162-
local_seq_no: 0,
163-
remote_seq_no: 0,
164-
retransmit: Retransmit::new(),
165-
tx_buffer: tx_buffer.into(),
166-
rx_buffer: rx_buffer.into()
164+
state: State::Closed,
165+
local_endpoint: IpEndpoint::default(),
166+
remote_endpoint: IpEndpoint::default(),
167+
local_seq_no: 0,
168+
remote_seq_no: 0,
169+
retransmit: Retransmit::new(),
170+
tx_buffer: tx_buffer.into(),
171+
rx_buffer: rx_buffer.into()
167172
})
168173
}
169174

@@ -176,23 +181,23 @@ impl<'a> TcpSocket<'a> {
176181
/// Return the local endpoint.
177182
#[inline(always)]
178183
pub fn local_endpoint(&self) -> IpEndpoint {
179-
self.local_end
184+
self.local_endpoint
180185
}
181186

182187
/// Return the remote endpoint.
183188
#[inline(always)]
184189
pub fn remote_endpoint(&self) -> IpEndpoint {
185-
self.remote_end
190+
self.remote_endpoint
186191
}
187192

188193
fn set_state(&mut self, state: State) {
189194
if self.state != state {
190-
if self.remote_end.addr.is_unspecified() {
195+
if self.remote_endpoint.addr.is_unspecified() {
191196
net_trace!("tcp:{}: state={}→{}",
192-
self.local_end, self.state, state);
197+
self.local_endpoint, self.state, state);
193198
} else {
194199
net_trace!("tcp:{}:{}: state={}→{}",
195-
self.local_end, self.remote_end, self.state, state);
200+
self.local_endpoint, self.remote_endpoint, self.state, state);
196201
}
197202
}
198203
self.state = state
@@ -205,8 +210,8 @@ impl<'a> TcpSocket<'a> {
205210
pub fn listen(&mut self, endpoint: IpEndpoint) {
206211
assert!(self.state == State::Closed);
207212

208-
self.local_end = endpoint;
209-
self.remote_end = IpEndpoint::default();
213+
self.local_endpoint = endpoint;
214+
self.remote_endpoint = IpEndpoint::default();
210215
self.set_state(State::Listen);
211216
}
212217

@@ -219,49 +224,83 @@ impl<'a> TcpSocket<'a> {
219224
let packet = try!(TcpPacket::new(payload));
220225
let repr = try!(TcpRepr::parse(&packet, src_addr, dst_addr));
221226

222-
if self.local_end.port != repr.dst_port { return Err(Error::Rejected) }
223-
if !self.local_end.addr.is_unspecified() &&
224-
self.local_end.addr != *dst_addr { return Err(Error::Rejected) }
227+
// Reject packets with a wrong destination.
228+
if self.local_endpoint.port != repr.dst_port { return Err(Error::Rejected) }
229+
if !self.local_endpoint.addr.is_unspecified() &&
230+
self.local_endpoint.addr != *dst_addr { return Err(Error::Rejected) }
225231

226-
if self.remote_end.port != 0 &&
227-
self.remote_end.port != repr.src_port { return Err(Error::Rejected) }
228-
if !self.remote_end.addr.is_unspecified() &&
229-
self.remote_end.addr != *src_addr { return Err(Error::Rejected) }
232+
// Reject packets from a source to which we aren't connected.
233+
if self.remote_endpoint.port != 0 &&
234+
self.remote_endpoint.port != repr.src_port { return Err(Error::Rejected) }
235+
if !self.remote_endpoint.addr.is_unspecified() &&
236+
self.remote_endpoint.addr != *src_addr { return Err(Error::Rejected) }
230237

231238
match (self.state, repr) {
232-
(State::Closed, _) => Err(Error::Rejected),
239+
// Reject packets addressed to a closed socket.
240+
(State::Closed, TcpRepr { src_port, .. }) => {
241+
net_trace!("tcp:{}:{}:{}: packet sent to a closed socket",
242+
self.local_endpoint, src_addr, src_port);
243+
return Err(Error::Malformed)
244+
}
245+
// Don't care about ACKs when performing the handshake.
246+
(State::Listen, _) => (),
247+
(State::SynSent, _) => (),
248+
// Every packet after the initial SYN must be an acknowledgement.
249+
(_, TcpRepr { ack_number: None, .. }) => {
250+
net_trace!("tcp:{}:{}: expecting an ACK packet",
251+
self.local_endpoint, self.remote_endpoint);
252+
return Err(Error::Malformed)
253+
}
254+
// Reject unacceptable acknowledgements.
255+
(state, TcpRepr { ack_number: Some(ack_number), .. }) => {
256+
let unacknowledged =
257+
if state != State::SynReceived { self.rx_buffer.len() as i32 } else { 1 };
258+
if !(ack_number - self.local_seq_no > 0 &&
259+
ack_number - (self.local_seq_no + unacknowledged) <= 0) {
260+
net_trace!("tcp:{}:{}: unacceptable ACK ({} not in {}..{})",
261+
self.local_endpoint, self.remote_endpoint,
262+
ack_number, self.local_seq_no, self.local_seq_no + unacknowledged);
263+
return Err(Error::Malformed)
264+
}
265+
}
266+
}
233267

268+
// Handle the incoming packet.
269+
match (self.state, repr) {
234270
(State::Listen, TcpRepr {
235-
src_port, dst_port, control: TcpControl::Syn, seq_number, ack_number: None, ..
271+
src_port, dst_port, control: TcpControl::Syn, seq_number, ack_number: None,
272+
payload, ..
236273
}) => {
237-
self.local_end = IpEndpoint::new(*dst_addr, dst_port);
238-
self.remote_end = IpEndpoint::new(*src_addr, src_port);
239-
self.remote_seq_no = seq_number;
240-
// FIXME: use something more secure
241-
self.local_seq_no = !seq_number;
274+
// FIXME: don't do this, just enqueue the payload
275+
if payload.len() > 0 {
276+
net_trace!("tcp:{}:{}: SYN with payload rejected",
277+
IpEndpoint::new(*dst_addr, dst_port),
278+
IpEndpoint::new(*src_addr, src_port));
279+
return Err(Error::Malformed)
280+
}
281+
282+
self.local_endpoint = IpEndpoint::new(*dst_addr, dst_port);
283+
self.remote_endpoint = IpEndpoint::new(*src_addr, src_port);
284+
self.remote_seq_no = seq_number + 1;
285+
self.local_seq_no = -seq_number; // FIXME: use something more secure
242286
self.set_state(State::SynReceived);
243287

244-
// FIXME: queue data from SYN
245288
self.retransmit.reset();
246289
Ok(())
247290
}
248291

249292
(State::SynReceived, TcpRepr {
250293
control: TcpControl::None, ack_number: Some(ack_number), ..
251294
}) => {
252-
if ack_number != self.local_seq_no + 1 { return Err(Error::Rejected) }
295+
self.local_seq_no = ack_number;
253296
self.set_state(State::Established);
254297

255298
// FIXME: queue data from ACK
256-
// FIXME: update sequence numbers
257299
self.retransmit.reset();
258300
Ok(())
259301
}
260302

261-
_ => {
262-
// This will cause the interface to reply with an RST.
263-
Err(Error::Rejected)
264-
}
303+
_ => Err(Error::Malformed)
265304
}
266305
}
267306

@@ -270,12 +309,12 @@ impl<'a> TcpSocket<'a> {
270309
IpProtocol, &PacketRepr) -> Result<(), Error>)
271310
-> Result<(), Error> {
272311
let mut repr = TcpRepr {
273-
src_port: self.local_end.port,
274-
dst_port: self.remote_end.port,
312+
src_port: self.local_endpoint.port,
313+
dst_port: self.remote_endpoint.port,
275314
control: TcpControl::None,
276315
seq_number: 0,
277316
ack_number: None,
278-
window_len: (self.rx_buffer.capacity() - self.rx_buffer.len()) as u16,
317+
window_len: self.rx_buffer.window() as u16,
279318
payload: &[]
280319
};
281320

@@ -291,9 +330,9 @@ impl<'a> TcpSocket<'a> {
291330
if !self.retransmit.check() { return Err(Error::Exhausted) }
292331
repr.control = TcpControl::Syn;
293332
repr.seq_number = self.local_seq_no;
294-
repr.ack_number = Some(self.remote_seq_no + 1);
333+
repr.ack_number = Some(self.remote_seq_no);
295334
net_trace!("tcp:{}:{}: SYN sent",
296-
self.local_end, self.remote_end);
335+
self.local_endpoint, self.remote_endpoint);
297336
}
298337

299338
State::Established => {
@@ -304,7 +343,7 @@ impl<'a> TcpSocket<'a> {
304343
_ => unreachable!()
305344
}
306345

307-
f(&self.local_end.addr, &self.remote_end.addr, IpProtocol::Tcp, &repr)
346+
f(&self.local_endpoint.addr, &self.remote_endpoint.addr, IpProtocol::Tcp, &repr)
308347
}
309348
}
310349

@@ -342,7 +381,7 @@ mod test {
342381
const LOCAL_END: IpEndpoint = IpEndpoint::new(LOCAL_IP, LOCAL_PORT);
343382
const REMOTE_END: IpEndpoint = IpEndpoint::new(REMOTE_IP, REMOTE_PORT);
344383
const LOCAL_SEQ: i32 = 100;
345-
const REMOTE_SEQ: i32 = !100;
384+
const REMOTE_SEQ: i32 = -100;
346385

347386
const SEND_TEMPL: TcpRepr<'static> = TcpRepr {
348387
src_port: REMOTE_PORT, dst_port: LOCAL_PORT,
@@ -434,22 +473,24 @@ mod test {
434473

435474
send!(s, TcpRepr {
436475
control: TcpControl::Syn,
437-
seq_number: LOCAL_SEQ, ack_number: None,
476+
seq_number: REMOTE_SEQ, ack_number: None,
438477
..SEND_TEMPL
439478
});
440479
assert_eq!(s.state(), State::SynReceived);
441480
assert_eq!(s.local_endpoint(), LOCAL_END);
442481
assert_eq!(s.remote_endpoint(), REMOTE_END);
443482
recv!(s, TcpRepr {
444483
control: TcpControl::Syn,
445-
seq_number: REMOTE_SEQ, ack_number: Some(LOCAL_SEQ + 1),
484+
seq_number: LOCAL_SEQ, ack_number: Some(REMOTE_SEQ + 1),
446485
..RECV_TEMPL
447486
});
448487
send!(s, TcpRepr {
449488
control: TcpControl::None,
450-
seq_number: LOCAL_SEQ + 1, ack_number: Some(REMOTE_SEQ + 1),
489+
seq_number: REMOTE_SEQ + 1, ack_number: Some(LOCAL_SEQ + 1),
451490
..SEND_TEMPL
452491
});
453492
assert_eq!(s.state(), State::Established);
493+
assert_eq!(s.local_seq_no, LOCAL_SEQ + 1);
494+
assert_eq!(s.remote_seq_no, REMOTE_SEQ + 1);
454495
}
455496
}

0 commit comments

Comments
 (0)
Please sign in to comment.