use std::net::IpAddr;
use pnet::packet::tcp::TcpPacket;
use crate::model::technique::{TcpReply, TcpScanTechnique};
use crate::protocols::craft;
use crate::protocols::error::{PacketError, Result};
use crate::protocols::sizes::TCP_HDR_LEN;
pub mod flags {
pub const FIN: u8 = 1;
pub const SYN: u8 = 1 << 1;
pub const RST: u8 = 1 << 2;
pub const PSH: u8 = 1 << 3;
pub const ACK: u8 = 1 << 4;
pub const URG: u8 = 1 << 5;
}
#[cfg(test)]
const TCP_HDR_LEN_WITH_OPTIONS: usize = TCP_HDR_LEN + SYN_OPTIONS_LEN;
#[cfg(test)]
const WORD_IN_BYTES: usize = 4;
const PROBE_WINDOW: u16 = 1024;
const PROBE_MSS: u16 = 1412;
const SYN_OPTIONS_LEN: usize = 20;
pub const fn probe_flags(technique: TcpScanTechnique) -> u8 {
match technique {
TcpScanTechnique::Syn => flags::SYN,
TcpScanTechnique::Fin => flags::FIN,
TcpScanTechnique::Null => 0,
TcpScanTechnique::Xmas => flags::FIN | flags::PSH | flags::URG,
TcpScanTechnique::Maimon => flags::FIN | flags::ACK,
TcpScanTechnique::Ack => flags::ACK,
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum NonceField {
Sequence { span: u32 },
Acknowledgement,
}
const fn nonce_field(flags: u8) -> NonceField {
if flags & flags::ACK != 0 {
return NonceField::Acknowledgement;
}
let mut span = 0;
if flags & flags::SYN != 0 {
span += 1;
}
if flags & flags::FIN != 0 {
span += 1;
}
NonceField::Sequence { span }
}
pub fn create_probe(
technique: TcpScanTechnique,
src_addr: &IpAddr,
dst_addr: &IpAddr,
src_port: u16,
dst_port: u16,
nonce: u32,
) -> Result<Vec<u8>> {
let flags = probe_flags(technique);
let mut segment = craft::Tcp::new(src_port, dst_port).with_flags(flags);
segment.window = PROBE_WINDOW;
match nonce_field(flags) {
NonceField::Sequence { .. } => {
segment.sequence = nonce;
segment.acknowledgement = 0;
}
NonceField::Acknowledgement => {
segment.sequence = rand::random();
segment.acknowledgement = nonce;
}
}
if flags & flags::SYN != 0 {
segment.options = syn_options(PROBE_MSS);
}
segment.to_bytes(Some((*src_addr, *dst_addr)))
}
fn syn_options(mss: u16) -> Vec<u8> {
let [high, low] = mss.to_be_bytes();
let timestamp: u32 = rand::random();
let mut options = Vec::with_capacity(SYN_OPTIONS_LEN);
options.extend_from_slice(&[2, 4, high, low]); options.extend_from_slice(&[4, 2]); options.extend_from_slice(&[8, 10]); options.extend_from_slice(×tamp.to_be_bytes()); options.extend_from_slice(&0u32.to_be_bytes()); options.push(1); options.extend_from_slice(&[3, 3, 7]); options
}
pub fn echoed_nonce(technique: TcpScanTechnique, reply: &TcpPacket) -> u32 {
match nonce_field(probe_flags(technique)) {
NonceField::Sequence { span } => reply.get_acknowledgement().wrapping_sub(span),
NonceField::Acknowledgement => reply.get_sequence(),
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct QuotedProbe {
pub source: u16,
pub destination: u16,
pub sequence: u32,
pub acknowledgement: Option<u32>,
}
pub fn quoted_probe(quoted: &[u8]) -> Option<QuotedProbe> {
let head: &[u8; 8] = quoted.first_chunk()?;
Some(QuotedProbe {
source: u16::from_be_bytes([head[0], head[1]]),
destination: u16::from_be_bytes([head[2], head[3]]),
sequence: u32::from_be_bytes([head[4], head[5], head[6], head[7]]),
acknowledgement: quoted
.first_chunk::<12>()
.map(|full| u32::from_be_bytes([full[8], full[9], full[10], full[11]])),
})
}
pub fn quoted_nonce(technique: TcpScanTechnique, quoted: &QuotedProbe) -> Option<u32> {
match nonce_field(probe_flags(technique)) {
NonceField::Sequence { .. } => Some(quoted.sequence),
NonceField::Acknowledgement => quoted.acknowledgement,
}
}
pub fn parse(bytes: &'_ [u8]) -> Result<TcpPacket<'_>> {
TcpPacket::new(bytes)
.ok_or_else(|| PacketError::truncated("a TCP segment", TCP_HDR_LEN, bytes.len()))
}
pub fn classify_probe_response(packet: &TcpPacket) -> Option<TcpReply> {
let flags = packet.get_flags();
if flags & flags::RST != 0 {
Some(TcpReply::Rst)
} else if flags & flags::SYN != 0 && flags & flags::ACK != 0 {
Some(TcpReply::SynAck)
} else if flags & flags::ACK != 0 && flags & (flags::SYN | flags::FIN) == 0 {
Some(TcpReply::ChallengeAck)
} else {
None
}
}
#[cfg(test)]
mod tests {
use super::*;
use pnet::packet::Packet;
use pnet::packet::tcp::MutableTcpPacket;
use std::net::Ipv4Addr;
const SRC: IpAddr = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 10));
const DST: IpAddr = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 20));
const NONCE: u32 = 0xDEAD_BEEF;
fn packet_with_flags(flags: u8) -> Vec<u8> {
let mut buffer = vec![0u8; TCP_HDR_LEN];
let mut tcp = MutableTcpPacket::new(&mut buffer).unwrap();
tcp.set_data_offset((TCP_HDR_LEN / WORD_IN_BYTES) as u8);
tcp.set_flags(flags);
buffer
}
fn probe(technique: TcpScanTechnique) -> Vec<u8> {
create_probe(technique, &SRC, &DST, 50_000, 80, NONCE).expect("probe builds")
}
fn conformant_rst(probe: &[u8]) -> Vec<u8> {
let sent = TcpPacket::new(probe).expect("the probe parses");
let sent_flags = sent.get_flags();
let mut buffer = vec![0u8; TCP_HDR_LEN];
let mut rst = MutableTcpPacket::new(&mut buffer).unwrap();
rst.set_source(sent.get_destination());
rst.set_destination(sent.get_source());
rst.set_data_offset((TCP_HDR_LEN / WORD_IN_BYTES) as u8);
if sent_flags & flags::ACK != 0 {
rst.set_flags(flags::RST);
rst.set_sequence(sent.get_acknowledgement());
} else {
let control_octets = u32::from(sent_flags & flags::SYN != 0)
+ u32::from(sent_flags & flags::FIN != 0)
+ sent.payload().len() as u32;
rst.set_flags(flags::RST | flags::ACK);
rst.set_sequence(0);
rst.set_acknowledgement(sent.get_sequence().wrapping_add(control_octets));
}
buffer
}
#[test]
fn each_technique_carries_its_own_flags() {
use TcpScanTechnique::*;
let sent = |technique| TcpPacket::new(&probe(technique)).unwrap().get_flags();
assert_eq!(sent(Syn), flags::SYN);
assert_eq!(sent(Fin), flags::FIN);
assert_eq!(sent(Null), 0);
assert_eq!(sent(Xmas), flags::FIN | flags::PSH | flags::URG);
assert_eq!(sent(Maimon), flags::FIN | flags::ACK);
assert_eq!(sent(Ack), flags::ACK);
}
#[test]
fn the_nonce_goes_in_the_field_the_reply_will_echo() {
use TcpScanTechnique::*;
for technique in [Syn, Fin, Null, Xmas] {
let bytes = probe(technique);
let sent = TcpPacket::new(&bytes).unwrap();
assert_eq!(sent.get_sequence(), NONCE, "{technique} nonce");
assert_eq!(
sent.get_acknowledgement(),
0,
"{technique} must not claim to acknowledge anything"
);
}
for technique in [Maimon, Ack] {
let bytes = probe(technique);
let sent = TcpPacket::new(&bytes).unwrap();
assert_eq!(sent.get_acknowledgement(), NONCE, "{technique} nonce");
}
}
#[test]
fn only_a_syn_probe_carries_options() {
assert_eq!(probe(TcpScanTechnique::Syn).len(), TCP_HDR_LEN_WITH_OPTIONS);
for technique in [
TcpScanTechnique::Fin,
TcpScanTechnique::Null,
TcpScanTechnique::Xmas,
TcpScanTechnique::Maimon,
TcpScanTechnique::Ack,
] {
assert_eq!(probe(technique).len(), TCP_HDR_LEN, "{technique}");
}
}
#[test]
fn a_syn_offers_every_option_it_wants_answered() {
let probe = probe(TcpScanTechnique::Syn);
let options = &probe[TCP_HDR_LEN..];
assert_eq!(options[0..2], [2, 4], "maximum segment size");
assert_eq!(options[4..6], [4, 2], "SACK permitted");
assert_eq!(options[6..8], [8, 10], "timestamp");
assert_eq!(options[16], 1, "no-op, aligning what follows");
assert_eq!(options[17..20], [3, 3, 7], "window scale");
assert_eq!(options[12..16], [0, 0, 0, 0], "TSecr");
assert_eq!(
options.len() % 4,
0,
"the header is measured in four-byte words, so an option list that is \
not a multiple of four needs padding it does not have"
);
}
#[test]
fn a_probe_across_address_families_is_refused_rather_than_mis_checksummed() {
let v6: IpAddr = "2001:db8::1".parse().unwrap();
assert!(create_probe(TcpScanTechnique::Syn, &SRC, &v6, 50_000, 80, NONCE).is_err());
}
#[test]
fn every_technique_reads_its_nonce_back_out_of_a_conformant_reset() {
for technique in TcpScanTechnique::ALL {
let sent = probe(technique);
let rst = conformant_rst(&sent);
let reply = TcpPacket::new(&rst).unwrap();
assert_eq!(
echoed_nonce(technique, &reply),
NONCE,
"{technique} could not recognize its own answer"
);
}
}
#[test]
fn a_reset_answering_a_different_probe_yields_a_different_nonce() {
let ours = probe(TcpScanTechnique::Fin);
let theirs = create_probe(
TcpScanTechnique::Fin,
&SRC,
&DST,
50_000,
80,
NONCE ^ 0x1234,
)
.expect("probe builds");
assert_ne!(ours, theirs);
let reply_bytes = conformant_rst(&theirs);
let reply = TcpPacket::new(&reply_bytes).unwrap();
assert_ne!(echoed_nonce(TcpScanTechnique::Fin, &reply), NONCE);
}
#[test]
fn a_null_probe_and_a_fin_probe_are_acknowledged_one_apart() {
let null = conformant_rst(&probe(TcpScanTechnique::Null));
let fin = conformant_rst(&probe(TcpScanTechnique::Fin));
let null_ack = TcpPacket::new(&null).unwrap().get_acknowledgement();
let fin_ack = TcpPacket::new(&fin).unwrap().get_acknowledgement();
assert_eq!(null_ack, NONCE);
assert_eq!(fin_ack, NONCE.wrapping_add(1));
}
#[test]
fn eight_quoted_bytes_name_the_probe_and_a_sequence_nonce() {
let sent = probe(TcpScanTechnique::Fin);
let quoted = quoted_probe(&sent[..8]).expect("eight bytes are enough");
assert_eq!(quoted.source, 50_000);
assert_eq!(quoted.destination, 80);
assert_eq!(quoted.acknowledgement, None);
assert_eq!(quoted_nonce(TcpScanTechnique::Fin, "ed), Some(NONCE));
}
#[test]
fn an_ack_carrying_probe_needs_a_generous_quotation_to_name_its_attempt() {
let sent = probe(TcpScanTechnique::Ack);
let short = quoted_probe(&sent[..8]).expect("eight bytes are enough");
assert_eq!(short.destination, 80, "the probe is still identified");
assert_eq!(quoted_nonce(TcpScanTechnique::Ack, &short), None);
let full = quoted_probe(&sent).expect("a full header parses");
assert_eq!(quoted_nonce(TcpScanTechnique::Ack, &full), Some(NONCE));
}
#[test]
fn a_quotation_too_short_to_name_a_probe_is_rejected() {
assert_eq!(quoted_probe(&probe(TcpScanTechnique::Syn)[..7]), None);
}
#[test]
fn classifies_syn_ack_and_rst() {
let syn_ack = packet_with_flags(flags::SYN | flags::ACK);
let rst = packet_with_flags(flags::RST);
assert_eq!(
classify_probe_response(&TcpPacket::new(&syn_ack).unwrap()),
Some(TcpReply::SynAck)
);
assert_eq!(
classify_probe_response(&TcpPacket::new(&rst).unwrap()),
Some(TcpReply::Rst)
);
}
#[test]
fn classifies_rst_ack_as_a_reset() {
let bytes = packet_with_flags(flags::RST | flags::ACK);
assert_eq!(
classify_probe_response(&TcpPacket::new(&bytes).unwrap()),
Some(TcpReply::Rst)
);
}
#[test]
fn classifies_a_bare_ack_as_a_challenge() {
let bytes = packet_with_flags(flags::ACK);
assert_eq!(
classify_probe_response(&TcpPacket::new(&bytes).unwrap()),
Some(TcpReply::ChallengeAck)
);
}
#[test]
fn ignores_unrelated_flag_combinations() {
for flags in [
flags::ACK | flags::FIN,
flags::SYN,
flags::PSH,
flags::URG,
0,
] {
let bytes = packet_with_flags(flags);
assert_eq!(
classify_probe_response(&TcpPacket::new(&bytes).unwrap()),
None,
"flags {flags:#04b} answer no probe"
);
}
}
}