use crate::model::port::Protocol;
use std::{
fmt,
num::{IntErrorKind, ParseIntError},
ops::RangeInclusive,
str::FromStr,
};
use thiserror::Error;
pub const COMMON_DISCOVERY_PORTS: &[u16] = &[22, 80, 443, 445, 3389];
const FIRST_PORT: u16 = 1;
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq, Error)]
pub enum PortSetParseError {
#[error("{}", invalid_port(input, source))]
InvalidPort {
input: String,
#[source]
source: ParseIntError,
},
#[error("range {start}-{end} runs backwards (write {end}-{start})")]
InvalidRange {
start: u16,
end: u16,
},
#[error("'{0}' is not a port or a range (write 22 or 1-1024)")]
MalformedSpec(String),
#[error("'{0}' has spaces in a range (write {joined})", joined = .0.split_whitespace().collect::<String>())]
SpacedRange(String),
#[error("'{0}' is a name, not a port number (write one, as 22)")]
ServiceName(String),
#[error("names no ports (write 22 or 1-1024)")]
NoPorts,
}
fn invalid_port(input: &str, source: &ParseIntError) -> String {
match source.kind() {
IntErrorKind::PosOverflow => format!("'{input}' is not a port (the highest is 65535)"),
IntErrorKind::Empty => format!("'{input}' names no port (write {input}53)"),
_ => format!("'{input}' is not a port number (write 22, 1-1024 or u:53)"),
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct PortSet {
tcp: Vec<RangeInclusive<u16>>,
udp: Vec<RangeInclusive<u16>>,
sctp: Vec<RangeInclusive<u16>>,
}
impl PortSet {
pub fn new() -> Self {
Self {
tcp: Vec::new(),
udp: Vec::new(),
sctp: Vec::new(),
}
}
pub fn common_discovery() -> Self {
COMMON_DISCOVERY_PORTS
.iter()
.map(|&port| (port, Protocol::Tcp))
.collect()
}
pub fn top_tcp(count: usize) -> Self {
super::catalog::top_tcp(count)
.iter()
.map(|&port| (port, Protocol::Tcp))
.collect()
}
pub fn top_udp(count: usize) -> Self {
super::catalog::top_udp(count)
.iter()
.map(|&port| (port, Protocol::Udp))
.collect()
}
pub fn top_sctp(count: usize) -> Self {
super::catalog::top_sctp(count)
.iter()
.map(|&port| (port, Protocol::Sctp))
.collect()
}
pub fn len(&self) -> usize {
Protocol::ALL
.iter()
.copied()
.map(|protocol| self.len_on(protocol))
.sum()
}
pub fn is_empty(&self) -> bool {
Protocol::ALL
.iter()
.copied()
.all(|protocol| self.ranges(protocol).is_empty())
}
pub fn iter(&self) -> impl Iterator<Item = (u16, Protocol)> + '_ {
Protocol::ALL.iter().copied().flat_map(move |protocol| {
self.ranges(protocol)
.iter()
.flat_map(move |range| range.clone().map(move |port| (port, protocol)))
})
}
pub fn to_vec(&self) -> Vec<(u16, Protocol)> {
self.iter().collect()
}
pub fn ranges(&self, protocol: Protocol) -> &[RangeInclusive<u16>] {
match protocol {
Protocol::Tcp => &self.tcp,
Protocol::Udp => &self.udp,
Protocol::Sctp => &self.sctp,
}
}
fn lane_mut(&mut self, protocol: Protocol) -> &mut Vec<RangeInclusive<u16>> {
match protocol {
Protocol::Tcp => &mut self.tcp,
Protocol::Udp => &mut self.udp,
Protocol::Sctp => &mut self.sctp,
}
}
pub fn len_on(&self, protocol: Protocol) -> usize {
self.ranges(protocol)
.iter()
.map(|range| usize::from(*range.end() - *range.start()) + 1)
.sum()
}
pub fn union(&self, other: &PortSet) -> PortSet {
let mut merged = PortSet::new();
for &protocol in Protocol::ALL {
let lane = merged.lane_mut(protocol);
lane.extend(self.ranges(protocol).iter().cloned());
lane.extend(other.ranges(protocol).iter().cloned());
Self::merge_ranges(lane);
}
merged
}
pub fn difference(&self, other: &PortSet) -> PortSet {
let mut kept = PortSet::new();
for &protocol in Protocol::ALL {
let cuts = other.ranges(protocol);
let lane = kept.lane_mut(protocol);
for range in self.ranges(protocol) {
let mut rest = Some(*range.start());
for cut in cuts {
let Some(start) = rest else { break };
if *cut.end() < start {
continue;
}
if *cut.start() > *range.end() {
break;
}
if *cut.start() > start {
lane.push(start..=*cut.start() - 1);
}
rest = cut.end().checked_add(1).filter(|next| next <= range.end());
}
if let Some(start) = rest {
lane.push(start..=*range.end());
}
}
}
kept
}
pub fn contains(&self, port: u16, protocol: Protocol) -> bool {
self.ranges(protocol)
.binary_search_by(|range| {
if port < *range.start() {
std::cmp::Ordering::Greater
} else if port > *range.end() {
std::cmp::Ordering::Less
} else {
std::cmp::Ordering::Equal
}
})
.is_ok()
}
pub fn has_tcp(&self, port: u16) -> bool {
self.contains(port, Protocol::Tcp)
}
pub fn has_udp(&self, port: u16) -> bool {
self.contains(port, Protocol::Udp)
}
pub fn has_sctp(&self, port: u16) -> bool {
self.contains(port, Protocol::Sctp)
}
fn merge_ranges(ranges: &mut Vec<RangeInclusive<u16>>) {
if ranges.is_empty() {
return;
}
ranges.sort_by_key(|r| *r.start());
let mut merged = Vec::with_capacity(ranges.len());
let mut it = ranges.drain(..);
let mut current = it.next().unwrap();
for next in it {
if *next.start() <= (*current.end()).saturating_add(1) {
if *next.end() > *current.end() {
current = *current.start()..=*next.end();
}
} else {
merged.push(current);
current = next;
}
}
merged.push(current);
*ranges = merged;
}
}
impl Default for PortSet {
fn default() -> Self {
Self::new()
}
}
impl fmt::Display for PortSet {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut first = true;
for &protocol in Protocol::ALL {
for range in self.ranges(protocol) {
if !first {
f.write_str(",")?;
}
first = false;
f.write_str(protocol.spec_prefix())?;
if range.start() == range.end() {
write!(f, "{}", range.start())?;
} else {
write!(f, "{}-{}", range.start(), range.end())?;
}
}
}
Ok(())
}
}
fn split_qualifier(word: &str) -> (Option<Protocol>, &str) {
for &protocol in Protocol::ALL {
let qualifier = protocol.qualifier();
if let Some(head) = word.get(..qualifier.len())
&& head.eq_ignore_ascii_case(qualifier)
{
return (Some(protocol), &word[qualifier.len()..]);
}
}
(None, word)
}
fn refuse_spaced_range(words: &[&str]) -> Result<(), PortSetParseError> {
for (index, word) in words.iter().enumerate() {
let opens_back = word.starts_with('-') && index > 0;
let opens_on = word.ends_with('-') && index + 1 < words.len();
if opens_back || opens_on {
let first = if opens_back { index - 1 } else { index };
let last = if opens_on { index + 1 } else { index };
return Err(PortSetParseError::SpacedRange(
words[first..=last].join(" "),
));
}
}
Ok(())
}
fn port_number(text: &str, whole: &str) -> Result<u16, PortSetParseError> {
text.parse::<u16>().map_err(|source| {
let named = text.starts_with(|c: char| c.is_ascii_alphabetic())
&& text
.chars()
.all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_');
if named {
PortSetParseError::ServiceName(whole.to_string())
} else {
PortSetParseError::InvalidPort {
input: whole.to_string(),
source,
}
}
})
}
impl TryFrom<&str> for PortSet {
type Error = PortSetParseError;
fn try_from(value: &str) -> Result<Self, Self::Error> {
let mut set = PortSet::new();
let mut protocol = Protocol::Tcp;
for part in value.split(',') {
let words: Vec<&str> = part.split_whitespace().collect();
refuse_spaced_range(&words)?;
for word in words {
let (qualifier, raw_range) = split_qualifier(word);
if let Some(named) = qualifier {
protocol = named;
}
let range = match raw_range.split('-').collect::<Vec<_>>().as_slice() {
[single] => {
let port = port_number(single, word)?;
port..=port
}
[start, end] => {
let start = if start.is_empty() {
FIRST_PORT
} else {
port_number(start, start)?
};
let end = if end.is_empty() {
u16::MAX
} else {
port_number(end, end)?
};
if start > end {
return Err(PortSetParseError::InvalidRange { start, end });
}
start..=end
}
_ => return Err(PortSetParseError::MalformedSpec(word.to_string())),
};
set.lane_mut(protocol).push(range);
}
}
for &protocol in Protocol::ALL {
Self::merge_ranges(set.lane_mut(protocol));
}
Ok(set)
}
}
impl PortSet {
pub(crate) fn parse_scan(spec: &str) -> Result<Self, PortSetParseError> {
let set = Self::try_from(spec)?;
if set.is_empty() {
return Err(PortSetParseError::NoPorts);
}
Ok(set)
}
}
impl TryFrom<String> for PortSet {
type Error = PortSetParseError;
fn try_from(value: String) -> Result<Self, Self::Error> {
Self::try_from(value.as_str())
}
}
impl FromStr for PortSet {
type Err = PortSetParseError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
Self::try_from(s)
}
}
impl FromIterator<(u16, Protocol)> for PortSet {
fn from_iter<T: IntoIterator<Item = (u16, Protocol)>>(iter: T) -> Self {
let mut set = PortSet::new();
for (port, protocol) in iter {
set.lane_mut(protocol).push(port..=port);
}
for &protocol in Protocol::ALL {
Self::merge_ranges(set.lane_mut(protocol));
}
set
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_difference_keeps_every_port_outside_the_cut_and_none_inside_it() {
let set = |spec: &str| PortSet::try_from(spec).expect("a specification");
let cases = [
("1-100", "1", "2-100"),
("1-100", "100", "1-99"),
("1-100", "50-60", "1-49,61-100"),
("1-10,20-30", "5-25", "1-4,26-30"),
("1-65535", "65535", "1-65534"),
("1-65535", "1-65535", ""),
("80,443", "u:80", "80,443"),
("80,u:53,s:2905", "u:53", "80,s:2905"),
("9100-9107", "9000-9007,9100-9107", ""),
];
for (from, cut, left) in cases {
let kept = set(from).difference(&set(cut));
assert_eq!(kept.to_string(), left, "{from} less {cut}");
for (port, protocol) in set(from).iter() {
assert_eq!(
kept.contains(port, protocol),
!set(cut).contains(port, protocol),
"{from} less {cut}, at {port}/{protocol:?}"
);
}
}
}
#[test]
fn a_specification_keeps_its_three_transports_apart() {
let set = PortSet::try_from("80, u:53, S:2905-2906").expect("a mixed specification");
assert!(set.has_tcp(80) && !set.has_sctp(80));
assert!(set.has_udp(53) && !set.has_sctp(53));
assert!(set.has_sctp(2905) && set.has_sctp(2906) && !set.has_udp(2905));
assert_eq!(set.len_on(Protocol::Sctp), 2);
assert_eq!(set.to_string(), "80,u:53,s:2905-2906");
assert_eq!(PortSet::try_from(set.to_string().as_str()).unwrap(), set);
}
#[test]
fn the_udp_prefix_is_read_the_way_every_other_token_is() {
let lower = PortSet::try_from("u:53").expect("the spelling that always worked");
let upper = PortSet::try_from("U:53").expect("and the one that did not");
assert_eq!(lower, upper);
assert!(upper.has_udp(53) && !upper.has_tcp(53));
let mixed = PortSet::try_from("80, U:53, u:161-162").expect("parses");
assert!(mixed.has_tcp(80));
assert!(mixed.has_udp(53) && mixed.has_udp(161) && mixed.has_udp(162));
assert!(!mixed.has_tcp(53));
let error = PortSet::try_from("U:http")
.expect_err("not a port")
.to_string();
assert!(error.contains("U:http"), "the token as written: {error}");
}
#[test]
fn a_specification_may_mix_ports_ranges_and_protocols() {
let port_set_single = PortSet::try_from("21");
let port_set_multiple = PortSet::try_from("21, 22 80, 800-1000, u:53 t:8080");
assert!(port_set_single.is_ok());
assert!(port_set_multiple.is_ok());
let port_set_single = port_set_single.unwrap();
let port_set_multiple = port_set_multiple.unwrap();
assert!(port_set_single.has_tcp(21));
assert!(port_set_multiple.has_tcp(21));
assert!(port_set_multiple.has_tcp(22));
assert!(port_set_multiple.has_tcp(80));
assert!(port_set_multiple.has_tcp(900));
assert!(port_set_multiple.has_udp(53));
assert!(port_set_multiple.has_tcp(8080));
}
#[test]
fn the_udp_prefix_applies_to_single_ports_and_to_ranges() {
let port_set_udp = PortSet::try_from("u:22 u:53-100, u:1024");
assert!(port_set_udp.is_ok());
let port_set_udp = port_set_udp.unwrap();
assert!(port_set_udp.has_udp(22));
assert!(port_set_udp.has_udp(53));
assert!(port_set_udp.has_udp(80));
assert!(port_set_udp.has_udp(100));
assert!(port_set_udp.has_udp(1024));
}
#[test]
fn a_range_may_leave_off_either_end_or_both() {
let everything = PortSet::try_from("-").unwrap();
assert!(everything.has_tcp(1));
assert!(everything.has_tcp(65_535));
assert_eq!(everything.len(), 65_535);
let up_to = PortSet::try_from("-1024").unwrap();
assert!(up_to.has_tcp(1) && up_to.has_tcp(1024));
assert!(!up_to.has_tcp(1025));
let onward = PortSet::try_from("1024-").unwrap();
assert!(onward.has_tcp(1024) && onward.has_tcp(65_535));
assert!(!onward.has_tcp(1023));
}
#[test]
fn an_open_ended_range_starts_at_one_and_zero_must_be_asked_for() {
assert!(!PortSet::try_from("-").unwrap().has_tcp(0));
assert!(PortSet::try_from("0-").unwrap().has_tcp(0));
assert!(PortSet::try_from("0").unwrap().has_tcp(0));
}
#[test]
fn an_open_ended_range_composes_with_the_rest_of_the_grammar() {
let mixed = PortSet::try_from("22, u:-, t:9000-").unwrap();
assert!(mixed.has_tcp(22));
assert!(mixed.has_tcp(9000) && mixed.has_tcp(65_535));
assert!(!mixed.has_tcp(8999));
assert!(mixed.has_udp(1) && mixed.has_udp(65_535));
}
#[test]
fn more_than_one_dash_is_still_malformed() {
assert!(matches!(
PortSet::try_from("--"),
Err(PortSetParseError::MalformedSpec(_))
));
assert!(matches!(
PortSet::try_from("1-2-3"),
Err(PortSetParseError::MalformedSpec(_))
));
}
#[test]
fn a_specification_naming_nothing_is_an_empty_set_not_an_error() {
let empty = PortSet::try_from(" ");
assert!(empty.is_ok());
let set = empty.unwrap();
assert!(set.tcp.is_empty());
assert!(set.udp.is_empty());
for nothing in ["", " ", " , ,"] {
assert_eq!(
PortSet::parse_scan(nothing),
Err(PortSetParseError::NoPorts)
);
}
assert!(PortSet::parse_scan("22").is_ok());
}
#[test]
fn the_ends_of_the_port_space_parse_and_are_held() {
let limits = PortSet::try_from("0, 65535, u:0-65535").unwrap();
assert!(limits.has_tcp(0));
assert!(limits.has_tcp(65535));
assert!(limits.has_udp(32768));
}
#[test]
fn stray_separators_are_tolerated_rather_than_refused() {
let messy = PortSet::try_from(", 80, , 443 ,").unwrap();
assert!(messy.has_tcp(80));
assert!(messy.has_tcp(443));
}
#[test]
fn each_malformed_specification_is_refused_with_its_own_reason() {
let port_set_invalid_port = PortSet::try_from("80 70000 22");
let port_set_invalid_range = PortSet::try_from("21 8000-80");
let port_set_malformed_spec = PortSet::try_from("22 60-70-80 8080");
let port_set_not_numeric = PortSet::try_from("u:53 12ab 80");
let port_set_named = PortSet::try_from("u:53 abcdef 80");
assert!(matches!(
port_set_invalid_port,
Err(PortSetParseError::InvalidPort { .. })
));
assert!(matches!(
port_set_invalid_range,
Err(PortSetParseError::InvalidRange {
start: 8000,
end: 80
})
));
assert!(matches!(
port_set_not_numeric,
Err(PortSetParseError::InvalidPort { .. })
));
assert!(matches!(
port_set_named,
Err(PortSetParseError::ServiceName(_))
));
assert!(matches!(
port_set_malformed_spec,
Err(PortSetParseError::MalformedSpec(_))
));
}
#[test]
fn a_qualifier_holds_until_the_next_one_as_nmap_reads_it() {
let set = PortSet::try_from("U:53,161").expect("an nmap specification");
assert!(set.has_udp(53) && set.has_udp(161));
assert!(!set.has_tcp(161), "161 is UDP, as the qualifier said");
let mixed = PortSet::try_from("8080, u:53,161, T:21-25,80, s:2905").expect("parses");
assert!(mixed.has_tcp(8080) && mixed.has_tcp(23) && mixed.has_tcp(80));
assert!(mixed.has_udp(53) && mixed.has_udp(161));
assert!(!mixed.has_udp(80) && !mixed.has_tcp(161));
assert!(mixed.has_sctp(2905));
assert_eq!(mixed.len(), 1 + 2 + 5 + 1 + 1);
let tcp = PortSet::try_from("t:22").expect("TCP named outright");
assert!(tcp.has_tcp(22) && tcp.len() == 1);
}
#[test]
fn a_range_written_with_spaces_is_refused_rather_than_widened() {
for (written, fix) in [
("80 - 90", "80-90"),
("80- 90", "80-90"),
("22, 80 -90", "80-90"),
("u:80 - 90", "u:80-90"),
] {
let error = PortSet::try_from(written)
.expect_err("a spaced range")
.to_string();
assert!(
error.contains(&format!("write {fix}")),
"{written}: {error}"
);
}
let open = PortSet::try_from("80, -1024 9000-, 443").expect("open ends by commas");
assert!(open.has_tcp(1) && open.has_tcp(65_535) && open.has_tcp(443));
assert!(PortSet::try_from("-1024 8080").unwrap().has_tcp(8080));
}
#[test]
fn each_refusal_says_what_to_write_instead() {
let hint = |written: &str| PortSet::try_from(written).expect_err("refused").to_string();
let ssh = hint("ssh");
assert!(
ssh.contains("'ssh' is a name") && ssh.contains("as 22"),
"{ssh}"
);
let snmp = hint("U:snmp");
assert!(snmp.contains("'U:snmp' is a name"), "{snmp}");
let stray = hint("8o");
assert!(
stray.contains("'8o'") && stray.contains("write 22"),
"{stray}"
);
let large = hint("70000");
assert!(large.contains("65535"), "{large}");
let backwards = hint("80-20");
assert!(backwards.contains("write 20-80"), "{backwards}");
let bare = hint("u:");
assert!(bare.contains("write u:53"), "{bare}");
let dashes = hint("1-2-3");
assert!(
dashes.contains("'1-2-3'") && dashes.contains("write"),
"{dashes}"
);
}
#[test]
fn an_owned_string_parses_the_same_as_a_borrowed_one() {
let port_set = PortSet::try_from(String::from("21 80-100 u:5353"));
assert!(port_set.is_ok());
let port_set = port_set.unwrap();
assert!(port_set.has_tcp(21));
assert!(port_set.has_tcp(80));
assert!(port_set.has_tcp(92));
assert!(port_set.has_tcp(100));
assert!(port_set.has_udp(5353));
}
#[test]
fn the_discovery_set_is_what_the_constant_names_and_default_stays_empty() {
let set = PortSet::common_discovery();
for &port in COMMON_DISCOVERY_PORTS {
assert!(set.has_tcp(port), "{port} is named in the discovery set");
}
assert_eq!(
set.len(),
COMMON_DISCOVERY_PORTS.len(),
"and nothing else is"
);
assert!(PortSet::default().is_empty());
assert_eq!(PortSet::default(), PortSet::new());
}
#[test]
fn overlapping_and_adjacent_ranges_collapse_on_construction() {
let set = PortSet::try_from("1-10, 5-15").unwrap();
assert_eq!(set.len(), 15);
assert_eq!(set.tcp.len(), 1);
let set = PortSet::try_from("20, 21").unwrap();
assert_eq!(set.len(), 2);
assert_eq!(set.tcp.len(), 1);
let set = PortSet::try_from("100-200, 150").unwrap();
assert_eq!(set.len(), 101);
assert_eq!(set.tcp.len(), 1);
let set = PortSet::try_from("u:53, u:53-53, u:50-60, u:55-65").unwrap();
assert_eq!(set.len(), 16); assert_eq!(set.udp.len(), 1);
}
}
#[cfg(test)]
mod property_tests {
use super::*;
use proptest::prelude::*;
proptest::proptest! {
#[test]
fn single_port_roundtrip(p in 0..=65535u16) {
let s = format!("{}", p);
let set = PortSet::from_str(&s).unwrap();
prop_assert!(set.has_tcp(p));
prop_assert_eq!(set.len(), 1);
}
#[test]
fn port_range_invariant(a in 0..=65535u16, b in 0..=65535u16) {
let (start, end) = if a < b { (a, b) } else { (b, a) };
let s = format!("{}-{}", start, end);
let set = PortSet::from_str(&s).unwrap();
prop_assert!(set.has_tcp(start));
prop_assert!(set.has_tcp(end));
prop_assert_eq!(set.len(), (end - start + 1) as usize);
}
#[test]
fn udp_prefix_honored(p in 0..=65535u16) {
let s = format!("u:{}", p);
let set = PortSet::from_str(&s).unwrap();
prop_assert!(set.has_udp(p));
prop_assert!(!set.has_tcp(p));
}
#[test]
fn multiple_ports_aggregation(p1 in 0..=1000u16, p2 in 2000..=3000u16) {
let s = format!("{}, {}", p1, p2);
let set = PortSet::from_str(&s).unwrap();
prop_assert!(set.has_tcp(p1));
prop_assert!(set.has_tcp(p2));
prop_assert_eq!(set.len(), 2);
}
#[test]
fn normalization_invariant(ports in prop::collection::vec(0..=500u16, 1..=50)) {
let s = ports.iter().map(|p| p.to_string()).collect::<Vec<_>>().join(",");
let set = PortSet::from_str(&s).unwrap();
let unique_count = ports.into_iter().collect::<std::collections::HashSet<_>>().len();
prop_assert_eq!(set.len(), unique_count);
prop_assert!(set.tcp.len() <= unique_count);
}
}
}