use crate::fingerprint::SignatureDb;
use crate::model::host::NetworkRole;
use crate::protocols::{dns, netbios};
const DNS: u16 = 53;
const NETBIOS_NS: u16 = 137;
pub fn for_port(port: u16) -> &'static [u8] {
SignatureDb::global()
.udp_probe_payloads(port)
.first()
.map_or(&[], Vec::as_slice)
}
pub fn declared_role(port: u16, reply: &[u8]) -> Option<NetworkRole> {
match port {
DNS => dns::is_response(reply).then_some(NetworkRole::DnsServer),
NETBIOS_NS => netbios::node_status(reply)
.is_some_and(|table| table.domain_controller())
.then_some(NetworkRole::DomainController),
_ => None,
}
}
#[cfg(test)]
mod tests {
use super::*;
const NTP: u16 = 123;
const L2TP: u16 = 1701;
const EXPECTED: &[u16] = &[53, 123, 137, 161, 1900, 5353];
#[test]
fn every_expected_port_has_a_payload() {
for &port in EXPECTED {
assert!(
!for_port(port).is_empty(),
"port {port} lost its UDP probe from the corpus"
);
}
}
fn dns_response() -> Vec<u8> {
let mut message = for_port(DNS).to_vec();
message[2] |= 0b1000_0000;
message
}
#[test]
fn a_role_is_read_from_the_reply_and_not_from_the_port() {
assert_eq!(
declared_role(DNS, &dns_response()),
Some(NetworkRole::DnsServer)
);
assert_eq!(
declared_role(DNS, for_port(DNS)),
None,
"a query is not an answer"
);
assert_eq!(declared_role(DNS, b"not a dns message at all"), None);
assert_eq!(declared_role(DNS, &[]), None);
assert_eq!(
declared_role(5353, &dns_response()),
None,
"an mDNS responder is not a name server"
);
}
fn node_status_from_a_controller() -> Vec<u8> {
let mut out = vec![0x80, 0xf0, 0x84, 0x00];
out.extend_from_slice(&0u16.to_be_bytes()); out.extend_from_slice(&1u16.to_be_bytes()); out.extend_from_slice(&[0u8; 4]); out.push(0x20);
out.extend_from_slice(b"CKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
out.push(0x00);
out.extend_from_slice(&[0x00, 0x21, 0x00, 0x01]); out.extend_from_slice(&0u32.to_be_bytes()); out.extend_from_slice(&(1u16 + 18 + 46).to_be_bytes());
out.push(1); out.extend_from_slice(b"CORP ");
out.push(0x1C); out.extend_from_slice(&0x8000u16.to_be_bytes()); out.extend_from_slice(&[0u8; 46]); out
}
#[test]
fn a_name_table_names_a_controller_and_a_workstation_is_not_one() {
assert_eq!(
declared_role(NETBIOS_NS, &node_status_from_a_controller()),
Some(NetworkRole::DomainController)
);
assert_eq!(
declared_role(NETBIOS_NS, for_port(NETBIOS_NS)),
None,
"our own query echoed back is not a name table"
);
let mut workstation = node_status_from_a_controller();
let suffix = 12 + 34 + 10 + 1 + 15;
workstation[suffix] = 0x00; assert_eq!(
declared_role(NETBIOS_NS, &workstation),
None,
"an ordinary domain member is not a controller"
);
assert_eq!(declared_role(NETBIOS_NS, b"not netbios at all"), None);
assert_eq!(declared_role(NETBIOS_NS, &[]), None);
}
#[test]
fn ntp_registers_a_client_request_first_and_a_control_message_behind_it() {
const MODE: u8 = 0b0000_0111;
const MODE_CLIENT: u8 = 3;
const MODE_CONTROL: u8 = 6;
let payloads = SignatureDb::global().udp_probe_payloads(NTP);
assert_eq!(
payloads.len(),
2,
"NTP registers a client and a control probe"
);
assert_eq!(
payloads[0][0] & MODE,
MODE_CLIENT,
"the port scan sends the first probe and needs the one every server answers"
);
assert!(
payloads
.iter()
.any(|payload| payload[0] & MODE == MODE_CONTROL),
"the control message is what the readvar rules were written for"
);
}
#[test]
fn l2tp_registers_two_requests_naming_different_tunnels() {
let payloads = SignatureDb::global().udp_probe_payloads(L2TP);
assert_eq!(payloads.len(), 2, "L2TP registers a second tunnel request");
let tunnel = |payload: &Vec<u8>| payload[payload.len() - 2..].to_vec();
assert_ne!(
tunnel(&payloads[0]),
tunnel(&payloads[1]),
"both requests name the same tunnel, so the second draws only an acknowledgement"
);
}
#[test]
fn a_port_with_no_probe_yields_an_empty_payload() {
assert!(for_port(9_999).is_empty());
}
#[test]
fn payloads_fit_in_one_datagram() {
for &port in EXPECTED {
assert!(
for_port(port).len() < 512,
"port {port} payload is oversized"
);
}
}
#[test]
fn payloads_are_decoded_to_wire_bytes() {
let snmp = for_port(161);
assert_eq!(snmp[0], 0x30, "SNMP must start with a BER SEQUENCE tag");
assert!(
!snmp.starts_with(b"\\x"),
"escapes reached the wire undecoded"
);
let dns = for_port(53);
assert!(
dns.windows(7).any(|w| w == b"version"),
"DNS payload lost its QNAME"
);
}
#[test]
fn mdns_reuses_the_dns_question() {
assert_eq!(for_port(5353), for_port(53));
}
}