use crate::model::port::Protocol;
use std::{fmt, num::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("Failed to parse port from '{input}': {source}")]
InvalidPort {
input: String,
#[source]
source: ParseIntError,
},
#[error("Invalid port range: start ({start}) cannot be strictly greater than end ({end})")]
InvalidRange {
start: u16,
end: u16,
},
#[error("Malformed port specification, expected a single port or a range: '{0}'")]
MalformedSpec(String),
}
#[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
.into_iter()
.map(|protocol| self.len_on(protocol))
.sum()
}
pub fn is_empty(&self) -> bool {
Protocol::ALL
.into_iter()
.all(|protocol| self.ranges(protocol).is_empty())
}
pub fn iter(&self) -> impl Iterator<Item = (u16, Protocol)> + '_ {
Protocol::ALL.into_iter().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 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_prefix(part: &str) -> (Protocol, &str) {
for protocol in Protocol::ALL {
let prefix = protocol.spec_prefix();
if prefix.is_empty() {
continue;
}
if let Some(head) = part.get(..prefix.len())
&& head.eq_ignore_ascii_case(prefix)
{
return (protocol, &part[prefix.len()..]);
}
}
(Protocol::Tcp, part)
}
impl TryFrom<&str> for PortSet {
type Error = PortSetParseError;
fn try_from(value: &str) -> Result<Self, Self::Error> {
let mut set = PortSet::new();
for part in value.split([',', ' ']).filter(|s| !s.trim().is_empty()) {
let part = part.trim();
let (protocol, raw_range) = split_prefix(part);
let parts: Vec<&str> = raw_range.split('-').collect();
let range = match parts.as_slice() {
[single_port] => {
let p = single_port.parse::<u16>().map_err(|source| {
PortSetParseError::InvalidPort {
input: part.to_string(),
source,
}
})?;
p..=p
}
[start_str, end_str] => {
let start = if start_str.is_empty() {
FIRST_PORT
} else {
start_str.parse::<u16>().map_err(|source| {
PortSetParseError::InvalidPort {
input: start_str.to_string(),
source,
}
})?
};
let end = if end_str.is_empty() {
u16::MAX
} else {
end_str
.parse::<u16>()
.map_err(|source| PortSetParseError::InvalidPort {
input: end_str.to_string(),
source,
})?
};
if start > end {
return Err(PortSetParseError::InvalidRange { start, end });
}
start..=end
}
_ => return Err(PortSetParseError::MalformedSpec(part.to_string())),
};
set.lane_mut(protocol).push(range);
}
for protocol in Protocol::ALL {
Self::merge_ranges(set.lane_mut(protocol));
}
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_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 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:-, 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());
}
#[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 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_malformed_spec,
Err(PortSetParseError::MalformedSpec(_))
));
}
#[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);
}
}
}