use std::borrow::Cow;
use crate::fingerprint::os::OsSource;
use crate::model::host::{HostStatus, NetworkRole, StatusProtocol};
use crate::model::port::discovery::ScanResponse;
use crate::model::port::{PortSet, PortState, Protocol};
use crate::scanner::report::{PortScope, ScanKind, StopReason};
use crate::scanner::session::ScannerKind;
const CUSTOM: &str = "custom:";
pub fn host_status_name(status: HostStatus) -> &'static str {
match status {
HostStatus::Unknown => "unknown",
HostStatus::Down => "down",
HostStatus::Filtered => "filtered",
HostStatus::Up => "up",
}
}
pub fn host_status(name: &str) -> Option<HostStatus> {
Some(match name {
"unknown" => HostStatus::Unknown,
"down" => HostStatus::Down,
"filtered" => HostStatus::Filtered,
"up" => HostStatus::Up,
_ => return None,
})
}
pub fn port_state_name(state: PortState) -> &'static str {
match state {
PortState::ClosedFiltered => "closed_filtered",
PortState::Filtered => "filtered",
PortState::Unfiltered => "unfiltered",
PortState::Closed => "closed",
PortState::OpenFiltered => "open_filtered",
PortState::Open => "open",
}
}
pub fn port_state(name: &str) -> Option<PortState> {
Some(match name {
"closed_filtered" => PortState::ClosedFiltered,
"filtered" => PortState::Filtered,
"unfiltered" => PortState::Unfiltered,
"closed" => PortState::Closed,
"open_filtered" => PortState::OpenFiltered,
"open" => PortState::Open,
_ => return None,
})
}
pub fn protocol_name(protocol: Protocol) -> &'static str {
match protocol {
Protocol::Tcp => "tcp",
Protocol::Udp => "udp",
}
}
pub fn protocol(name: &str) -> Option<Protocol> {
Some(match name {
"tcp" => Protocol::Tcp,
"udp" => Protocol::Udp,
_ => return None,
})
}
pub fn network_role_name(role: NetworkRole) -> &'static str {
match role {
NetworkRole::Router => "router",
NetworkRole::DnsServer => "dns",
NetworkRole::DhcpServer => "dhcp",
NetworkRole::NtpServer => "ntp",
NetworkRole::SnmpAgent => "snmp",
NetworkRole::Origin => "origin",
NetworkRole::Tarpit => "tarpit",
NetworkRole::Truncated => "truncated",
}
}
pub fn network_role(name: &str) -> Option<NetworkRole> {
Some(match name {
"router" => NetworkRole::Router,
"dns" => NetworkRole::DnsServer,
"dhcp" => NetworkRole::DhcpServer,
"ntp" => NetworkRole::NtpServer,
"snmp" => NetworkRole::SnmpAgent,
"origin" => NetworkRole::Origin,
"tarpit" => NetworkRole::Tarpit,
"truncated" => NetworkRole::Truncated,
_ => return None,
})
}
pub fn status_protocol_name(protocol: &StatusProtocol) -> Cow<'_, str> {
match protocol {
StatusProtocol::Arp => Cow::Borrowed("arp"),
StatusProtocol::Ndp => Cow::Borrowed("ndp"),
StatusProtocol::IcmpEcho => Cow::Borrowed("icmp_echo"),
StatusProtocol::IcmpUnreachable => Cow::Borrowed("icmp_unreachable"),
StatusProtocol::TcpSyn => Cow::Borrowed("tcp_syn"),
StatusProtocol::Tcp => Cow::Borrowed("tcp"),
StatusProtocol::Dhcp => Cow::Borrowed("dhcp"),
StatusProtocol::Udp => Cow::Borrowed("udp"),
StatusProtocol::Custom(name) => Cow::Owned(format!("{CUSTOM}{name}")),
}
}
pub fn status_protocol(name: &str) -> Option<StatusProtocol> {
if let Some(custom) = name.strip_prefix(CUSTOM) {
return (!custom.is_empty()).then(|| StatusProtocol::Custom(custom.into()));
}
Some(match name {
"arp" => StatusProtocol::Arp,
"ndp" => StatusProtocol::Ndp,
"icmp_echo" => StatusProtocol::IcmpEcho,
"icmp_unreachable" => StatusProtocol::IcmpUnreachable,
"tcp_syn" => StatusProtocol::TcpSyn,
"tcp" => StatusProtocol::Tcp,
"dhcp" => StatusProtocol::Dhcp,
"udp" => StatusProtocol::Udp,
_ => return None,
})
}
pub fn scan_response_name(response: &ScanResponse) -> Cow<'_, str> {
match response {
ScanResponse::TcpSynAck => Cow::Borrowed("tcp_syn_ack"),
ScanResponse::TcpRst => Cow::Borrowed("tcp_rst"),
ScanResponse::UdpResponse => Cow::Borrowed("udp_response"),
ScanResponse::NoResponse => Cow::Borrowed("no_response"),
ScanResponse::IcmpUnreachable => Cow::Borrowed("icmp_unreachable"),
ScanResponse::IcmpProhibited => Cow::Borrowed("icmp_prohibited"),
ScanResponse::Custom(name) => Cow::Owned(format!("{CUSTOM}{name}")),
}
}
pub fn scan_response(name: &str) -> Option<ScanResponse> {
if let Some(custom) = name.strip_prefix(CUSTOM) {
return (!custom.is_empty()).then(|| ScanResponse::Custom(custom.to_string()));
}
Some(match name {
"tcp_syn_ack" => ScanResponse::TcpSynAck,
"tcp_rst" => ScanResponse::TcpRst,
"udp_response" => ScanResponse::UdpResponse,
"no_response" => ScanResponse::NoResponse,
"icmp_unreachable" => ScanResponse::IcmpUnreachable,
"icmp_prohibited" => ScanResponse::IcmpProhibited,
_ => return None,
})
}
pub fn os_source_name(source: OsSource) -> &'static str {
match source {
OsSource::TcpStack => "tcp_stack",
OsSource::HardwareVendor => "hardware_vendor",
OsSource::ServiceBanner => "service_banner",
OsSource::Hostname => "hostname",
}
}
pub fn os_source(name: &str) -> Option<OsSource> {
Some(match name {
"tcp_stack" => OsSource::TcpStack,
"hardware_vendor" => OsSource::HardwareVendor,
"service_banner" => OsSource::ServiceBanner,
"hostname" => OsSource::Hostname,
_ => return None,
})
}
pub fn scan_kind_name(kind: ScanKind) -> &'static str {
match kind {
ScanKind::Discovery => "discovery",
ScanKind::PortScan => "port_scan",
}
}
pub fn scan_kind(name: &str) -> Option<ScanKind> {
Some(match name {
"discovery" => ScanKind::Discovery,
"port_scan" => ScanKind::PortScan,
_ => return None,
})
}
pub fn scanner_kind_name(kind: ScannerKind) -> &'static str {
match kind {
ScannerKind::Local => "local",
ScannerKind::Routed => "routed",
ScannerKind::SynPort => "syn_port",
ScannerKind::TcpPort => "tcp_port",
ScannerKind::Connect => "connect",
ScannerKind::ConnectUdp => "connect_udp",
ScannerKind::UdpPort => "udp_port",
ScannerKind::OsEcho => "os_echo",
ScannerKind::OsSeries => "os_series",
ScannerKind::OsSnmp => "os_snmp",
ScannerKind::Composite => "composite",
}
}
pub fn scanner_kind(name: &str) -> Option<ScannerKind> {
Some(match name {
"local" => ScannerKind::Local,
"routed" => ScannerKind::Routed,
"syn_port" => ScannerKind::SynPort,
"tcp_port" => ScannerKind::TcpPort,
"connect" => ScannerKind::Connect,
"connect_udp" => ScannerKind::ConnectUdp,
"udp_port" => ScannerKind::UdpPort,
"os_echo" => ScannerKind::OsEcho,
"os_series" => ScannerKind::OsSeries,
"os_snmp" => ScannerKind::OsSnmp,
"composite" => ScannerKind::Composite,
_ => return None,
})
}
pub fn stop_reason_name(reason: StopReason) -> &'static str {
match reason {
StopReason::Aborted => "aborted",
StopReason::AllResponded => "all_responded",
StopReason::AttemptsSpent => "attempts_spent",
StopReason::DeadlineExpired => "deadline_expired",
StopReason::StreamClosed => "stream_closed",
}
}
pub fn stop_reason(name: &str) -> Option<StopReason> {
Some(match name {
"aborted" => StopReason::Aborted,
"all_responded" => StopReason::AllResponded,
"attempts_spent" => StopReason::AttemptsSpent,
"deadline_expired" => StopReason::DeadlineExpired,
"stream_closed" => StopReason::StreamClosed,
_ => return None,
})
}
pub fn port_scope_name(scope: &PortScope) -> &'static str {
match scope {
PortScope::Unstated => "unstated",
PortScope::NoPorts => "none",
PortScope::Every(_) => "every",
PortScope::Mixed(_) => "mixed",
}
}
pub fn port_scope(name: &str, ports: Option<PortSet>) -> Option<PortScope> {
Some(match (name, ports) {
("unstated", _) => PortScope::Unstated,
("none", _) => PortScope::NoPorts,
("every", Some(ports)) => PortScope::Every(ports),
("mixed", Some(ports)) => PortScope::Mixed(ports),
("every" | "mixed", None) => PortScope::Unstated,
_ => return None,
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn every_name_parses_back() {
for value in [
HostStatus::Unknown,
HostStatus::Down,
HostStatus::Filtered,
HostStatus::Up,
] {
assert_eq!(host_status(host_status_name(value)), Some(value));
}
for value in [
PortState::ClosedFiltered,
PortState::Filtered,
PortState::Unfiltered,
PortState::Closed,
PortState::OpenFiltered,
PortState::Open,
] {
assert_eq!(port_state(port_state_name(value)), Some(value));
}
for value in [ScanKind::Discovery, ScanKind::PortScan] {
assert_eq!(scan_kind(scan_kind_name(value)), Some(value));
}
for value in [
ScannerKind::Local,
ScannerKind::Routed,
ScannerKind::SynPort,
ScannerKind::TcpPort,
ScannerKind::Connect,
ScannerKind::ConnectUdp,
ScannerKind::UdpPort,
ScannerKind::OsEcho,
ScannerKind::OsSeries,
ScannerKind::OsSnmp,
ScannerKind::Composite,
] {
assert_eq!(scanner_kind(scanner_kind_name(value)), Some(value));
}
for value in [
StopReason::Aborted,
StopReason::AllResponded,
StopReason::AttemptsSpent,
StopReason::DeadlineExpired,
StopReason::StreamClosed,
] {
assert_eq!(stop_reason(stop_reason_name(value)), Some(value));
}
for value in [Protocol::Tcp, Protocol::Udp] {
assert_eq!(protocol(protocol_name(value)), Some(value));
}
for value in NetworkRole::ALL {
assert_eq!(network_role(network_role_name(value)), Some(value));
}
for value in [
OsSource::TcpStack,
OsSource::HardwareVendor,
OsSource::ServiceBanner,
OsSource::Hostname,
] {
assert_eq!(os_source(os_source_name(value)), Some(value));
}
for value in [
StatusProtocol::Arp,
StatusProtocol::Ndp,
StatusProtocol::IcmpEcho,
StatusProtocol::IcmpUnreachable,
StatusProtocol::TcpSyn,
StatusProtocol::Tcp,
StatusProtocol::Dhcp,
StatusProtocol::Udp,
StatusProtocol::Custom("a-strategy".into()),
] {
let name = status_protocol_name(&value);
assert_eq!(status_protocol(&name), Some(value.clone()), "{name}");
}
for value in [
ScanResponse::TcpSynAck,
ScanResponse::TcpRst,
ScanResponse::UdpResponse,
ScanResponse::NoResponse,
ScanResponse::IcmpUnreachable,
ScanResponse::IcmpProhibited,
ScanResponse::Custom("a-strategy".to_string()),
] {
let name = scan_response_name(&value);
assert_eq!(scan_response(&name), Some(value.clone()), "{name}");
}
}
#[test]
fn every_built_in_protocol_is_named_everywhere() {
const SCHEMA: &str = include_str!("../../assets/schema/zond-report-v1.schema.json");
let described = SCHEMA
.find("The protocol event that produced the evidence")
.expect("the schema describes the evidence protocol");
let names = &SCHEMA[described..];
let names = &names[..names.find(']').expect("the enum closes")];
assert!(
!names.contains("\"router\""),
"the search caught the network-role enum instead"
);
for protocol in [
StatusProtocol::Arp,
StatusProtocol::Ndp,
StatusProtocol::IcmpEcho,
StatusProtocol::IcmpUnreachable,
StatusProtocol::TcpSyn,
StatusProtocol::Tcp,
StatusProtocol::Dhcp,
StatusProtocol::Udp,
] {
match protocol {
StatusProtocol::Arp
| StatusProtocol::Ndp
| StatusProtocol::IcmpEcho
| StatusProtocol::IcmpUnreachable
| StatusProtocol::TcpSyn
| StatusProtocol::Tcp
| StatusProtocol::Dhcp
| StatusProtocol::Udp => {}
StatusProtocol::Custom(_) => {
unreachable!("the list above holds no strategy-supplied names")
}
}
let name = status_protocol_name(&protocol);
assert_eq!(status_protocol(&name), Some(protocol.clone()));
assert!(
names.contains(&format!("\"{name}\"")),
"the report schema does not name '{name}'"
);
}
}
#[test]
fn an_unknown_name_is_refused() {
assert_eq!(host_status("perhaps"), None);
assert_eq!(port_state("ajar"), None);
assert_eq!(protocol("sctp"), None);
assert_eq!(network_role("gateway"), None);
assert_eq!(os_source("astrology"), None);
assert_eq!(status_protocol("igmp"), None);
assert_eq!(scan_response("tcp_fin_ack"), None);
assert_eq!(scan_kind("enrichment"), None);
assert_eq!(scanner_kind("telepathy"), None);
assert_eq!(stop_reason("bored"), None);
}
#[test]
fn an_empty_custom_name_is_refused() {
assert_eq!(status_protocol(CUSTOM), None);
assert_eq!(scan_response(CUSTOM), None);
}
}