use std::{io, time::Duration}; use crate::process::collection::{CollectionBudget, CollectionControl}; use serde::{Deserialize, Serialize}; use specta::Type; use super::{ClientOs, serial_number}; use platform::RuntimeNativeHostIdentity; #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)] #[serde(rename_all = "camelCase")] pub struct HostIdentity { computer: String, host_id: String, #[serde(rename = "serialno")] serial_number: String, #[serde(rename = "macAddr")] mac_address: String, } impl HostIdentity { pub fn collect() -> Self { Self::collect_with_host_id(None) } pub fn collect_with_control(control: &dyn CollectionControl) -> io::Result { Self::collect_with_host_id_and_control(None, control) } pub(crate) fn collect_with_host_id(host_id: Option<&str>) -> Self { match Self::collect_with_host_id_and_control(host_id, &CollectionBudget::new(Duration::from_secs(60))) { Ok(identity) => identity, Err(error) => { log::warn!("Host identity collection was unavailable: {error}"); Self::default_with_host_id(host_id) } } } /// Best-effort convenience callers retain the established derived identity /// when native collection is unavailable. Controlled HIP callers get errors. pub(crate) fn default_with_host_id(host_id: Option<&str>) -> Self { Self::from_parts( fallback_hostname(), resolve_host_id(host_id, fallback_host_id), String::new(), primary_mac_colon().unwrap_or_default(), ) } pub(crate) fn collect_with_host_id_and_control( host_id: Option<&str>, control: &dyn CollectionControl, ) -> io::Result { control.check()?; let identity = RuntimeNativeHostIdentity::collect_with_control(host_id, control)?.into_host_identity(); control.check()?; Ok(identity) } #[cfg(test)] pub(crate) fn new(computer: String, host_id: String, serialno: String, mac_addr: String) -> Self { Self::from_parts(computer, host_id, serialno, mac_addr) } /// Construct a host identity from an already collected or negotiated snapshot. pub fn from_parts(computer: String, host_id: String, serialno: String, mac_addr: String) -> Self { let host_id = non_empty(host_id, fallback_host_id()); let computer = non_empty(computer, fallback_hostname()); let serial_number = non_empty(serialno, derive_serial_number(&host_id)); let mac_address = normalize_mac_colon(&mac_addr).unwrap_or_else(|| derive_mac_address(&host_id)); Self { computer, host_id, serial_number, mac_address, } } pub fn computer(&self) -> &str { &self.computer } pub fn host_id(&self) -> &str { &self.host_id } pub fn serialno(&self) -> &str { &self.serial_number } pub fn mac_addr(&self) -> &str { &self.mac_address } pub fn with_computer(mut self, computer: String) -> Self { if !computer.trim().is_empty() { self.computer = computer; } self } pub(crate) fn runtime_os() -> ClientOs { RuntimeNativeHostIdentity::runtime_os() } } pub(super) fn fallback_hostname() -> String { whoami::hostname().unwrap_or_else(|_| String::from("localhost")) } #[derive(Debug, Clone)] struct NativeHostIdentitySnapshot { host_id: String, computer: String, serial_number: Option, mac_address: Option, } impl NativeHostIdentitySnapshot { fn into_host_identity(self) -> HostIdentity { let host_id = non_empty(self.host_id, fallback_host_id()); HostIdentity::from_parts( self.computer, host_id.clone(), self.serial_number.unwrap_or_else(|| derive_serial_number(&host_id)), self.mac_address.unwrap_or_else(|| derive_mac_address(&host_id)), ) } } fn non_empty(value: String, fallback: String) -> String { if value.trim().is_empty() { fallback } else { value } } fn fallback_host_id() -> String { derive_uuid_from_seed(&fallback_hostname(), &["runtime-host-id"]) } fn resolve_host_id(host_id_override: Option<&str>, collect: impl FnOnce() -> String) -> String { host_id_override .filter(|value| !value.trim().is_empty()) .map(str::to_string) .unwrap_or_else(collect) } fn derive_serial_number(host_id: &str) -> String { serial_number::vmware_from_uuid(host_id).unwrap_or_else(|| { let uuid = derive_uuid_from_seed(host_id, &["runtime-serialno"]); serial_number::vmware_from_uuid(&uuid).expect("derived UUID should format as VMware serial") }) } fn derive_mac_address(host_id: &str) -> String { let uuid = derive_uuid_from_seed(host_id, &["runtime-mac"]); let compact = uuid.replace('-', ""); let bytes = compact .as_bytes() .chunks(2) .take(6) .map(|chunk| std::str::from_utf8(chunk).unwrap_or("00").to_lowercase()) .collect::>(); bytes.join(":") } fn normalize_mac_colon(value: &str) -> Option { let compact = value .trim() .replace('-', ":") .split(':') .map(|part| part.to_lowercase()) .collect::>(); let valid = compact.len() == 6 && compact .iter() .all(|part| part.len() == 2 && part.chars().all(|ch| ch.is_ascii_hexdigit())); valid.then(|| compact.join(":")) } fn primary_mac_colon() -> Option { netdev::get_default_interface() .ok() .and_then(|iface| iface.mac_addr.map(|mac| mac.address())) .and_then(|mac| normalize_mac_colon(&mac)) } fn derive_uuid_from_seed(seed: &str, parts: &[&str]) -> String { use uuid::Uuid; let namespace = Uuid::NAMESPACE_DNS; let name = format!("{}-{}", seed, parts.join("-")); Uuid::new_v5(&namespace, name.as_bytes()).hyphenated().to_string() } #[cfg(target_os = "macos")] mod platform { use super::{ ClientOs, NativeHostIdentitySnapshot, derive_mac_address, fallback_hostname, normalize_mac_colon, primary_mac_colon, resolve_host_id, }; use crate::process::collection::{CollectionControl, CollectorCommands}; use std::io; pub(super) struct RuntimeNativeHostIdentity; impl RuntimeNativeHostIdentity { pub(super) fn runtime_os() -> ClientOs { ClientOs::Mac } pub(super) fn collect_with_control( host_id_override: Option<&str>, control: &dyn CollectionControl, ) -> io::Result { let commands = CollectorCommands::new(control); let native_mac = macos_builtin_mac(&commands)?.or_else(primary_mac_colon); control.check()?; let host_id = resolve_host_id(host_id_override, || { native_mac .clone() .unwrap_or_else(|| derive_mac_address(&fallback_hostname())) }); let computer = macos_computer_name(&commands)?.unwrap_or_else(fallback_hostname); let serial_number = collect_macos_serial_number(&commands)?; control.check()?; Ok(NativeHostIdentitySnapshot { host_id, computer, serial_number, mac_address: native_mac, }) } } fn output(commands: &CollectorCommands<'_>, program: &str, args: &[&str]) -> io::Result> { Ok( commands .run(program, args)? .filter(|output| output.status.success()) .and_then(|output| String::from_utf8(output.stdout).ok()), ) } fn macos_computer_name(commands: &CollectorCommands<'_>) -> io::Result> { for name in ["ComputerName", "LocalHostName"] { if let Some(value) = output(commands, "scutil", &["--get", name])? .map(|value| value.trim().to_string()) .filter(|value| !value.is_empty()) { return Ok(Some(value)); } } Ok(None) } fn macos_builtin_mac(commands: &CollectorCommands<'_>) -> io::Result> { if let Some(stdout) = output(commands, "networksetup", &["-listallhardwareports"])? { for name in ["Wi-Fi", "AirPort"] { if let Some(mac) = parse_hardware_port_mac(&stdout, name) { return Ok(Some(mac)); } } } macos_system_profiler_wifi_mac(commands) } fn parse_hardware_port_mac(stdout: &str, name: &str) -> Option { let mut in_port = false; for line in stdout.lines() { if let Some(port) = line.strip_prefix("Hardware Port: ") { in_port = port == name; continue; } if in_port && let Some(mac) = line.strip_prefix("Ethernet Address: ") { return normalize_mac_colon(mac); } } None } fn macos_system_profiler_wifi_mac(commands: &CollectorCommands<'_>) -> io::Result> { let Some(stdout) = output(commands, "system_profiler", &["SPNetworkDataType"])? else { return Ok(None); }; let mut in_wifi = false; for line in stdout.lines() { let trimmed = line.trim(); if trimmed.ends_with(':') && !trimmed.starts_with("MAC Address:") { in_wifi = trimmed == "Wi-Fi:" || trimmed == "AirPort:"; continue; } if in_wifi && let Some(mac) = trimmed.strip_prefix("MAC Address: ") { return Ok(normalize_mac_colon(mac)); } } Ok(None) } fn collect_macos_serial_number(commands: &CollectorCommands<'_>) -> io::Result> { let Some(stdout) = output(commands, "ioreg", &["-rd1", "-c", "IOPlatformExpertDevice"])? else { return Ok(None); }; Ok(stdout.lines().find_map(|line| { line .split_once("IOPlatformSerialNumber") .and_then(|(_, value)| value.split_once('=')) .map(|(_, value)| value.trim().trim_matches('"').to_string()) .filter(|value| !value.is_empty()) })) } } #[cfg(target_os = "windows")] mod platform { use std::process::Command; use super::{ClientOs, NativeHostIdentitySnapshot, fallback_hostname, primary_mac_colon, resolve_host_id}; pub(super) struct RuntimeNativeHostIdentity; impl RuntimeNativeHostIdentity { pub(super) fn runtime_os() -> ClientOs { ClientOs::Windows } pub(super) fn collect_with_control( host_id_override: Option<&str>, control: &dyn super::CollectionControl, ) -> super::io::Result { control.check()?; let identity = Self::collect(host_id_override); control.check()?; Ok(identity) } fn collect(host_id_override: Option<&str>) -> NativeHostIdentitySnapshot { let host_id = resolve_host_id(host_id_override, Self::host_id); NativeHostIdentitySnapshot { host_id, computer: fallback_hostname(), serial_number: collect_windows_serial_number(), mac_address: primary_mac_colon(), } } fn host_id() -> String { windows_machine_seed().unwrap_or_else(fallback_hostname) } } fn collect_windows_serial_number() -> Option { let output = Command::new("wmic") .args(["bios", "get", "serialnumber"]) .output() .ok()?; let stdout = String::from_utf8(output.stdout).ok()?; stdout .lines() .map(str::trim) .filter(|line| !line.is_empty() && *line != "SerialNumber") .map(str::to_string) .next() } fn windows_machine_seed() -> Option { collect_windows_csproduct_uuid().or_else(collect_windows_machine_guid) } fn collect_windows_csproduct_uuid() -> Option { let output = Command::new("wmic").args(["csproduct", "get", "uuid"]).output().ok()?; let stdout = String::from_utf8(output.stdout).ok()?; stdout .lines() .map(str::trim) .filter(|line| !line.is_empty() && *line != "UUID") .map(str::to_string) .next() } fn collect_windows_machine_guid() -> Option { let output = Command::new("reg") .args(["query", r"HKLM\SOFTWARE\Microsoft\Cryptography", "/v", "MachineGuid"]) .output() .ok()?; if !output.status.success() { return None; } let stdout = String::from_utf8(output.stdout).ok()?; stdout.lines().find_map(|line| { let mut parts = line.split_whitespace(); if parts.next()? != "MachineGuid" { return None; } parts.last().map(str::to_string) }) } } #[cfg(not(any(target_os = "macos", target_os = "windows")))] mod platform { use super::{ ClientOs, NativeHostIdentitySnapshot, derive_uuid_from_seed, fallback_hostname, primary_mac_colon, resolve_host_id, serial_number, }; use log::debug; pub(super) struct RuntimeNativeHostIdentity; impl RuntimeNativeHostIdentity { pub(super) fn runtime_os() -> ClientOs { ClientOs::Linux } pub(super) fn collect_with_control( host_id_override: Option<&str>, control: &dyn super::CollectionControl, ) -> super::io::Result { control.check()?; let identity = Self::collect(host_id_override); control.check()?; Ok(identity) } fn collect(host_id_override: Option<&str>) -> NativeHostIdentitySnapshot { if let Some(host_id) = host_id_override.filter(|value| !value.trim().is_empty()) { debug!("Runtime host-id source: explicit override ({})", host_id); } let host_id = resolve_host_id(host_id_override, Self::host_id); NativeHostIdentitySnapshot { host_id, computer: fallback_hostname(), serial_number: collect_linux_serial_number(), mac_address: primary_mac_colon(), } } fn host_id() -> String { if let Some(host_id) = collect_linux_product_uuid() { debug!("Runtime host-id source: /sys/class/dmi/id/product_uuid ({})", host_id); return host_id; } let (source_name, source) = collect_linux_fallback_seed().unwrap_or_else(|| { let hostname = fallback_hostname(); ("hostname", hostname) }); let host_id = derive_uuid_from_seed(&source, &[]); debug!("Runtime host-id source: derived from {} ({})", source_name, host_id); host_id } } fn collect_linux_product_uuid() -> Option { read_linux_identity_file("/sys/class/dmi/id/product_uuid").and_then(|value| normalize_uuid(&value)) } fn normalize_uuid(value: &str) -> Option { uuid::Uuid::parse_str(value.trim()) .ok() .map(|uuid| uuid.hyphenated().to_string()) } fn collect_linux_fallback_seed() -> Option<(&'static str, String)> { ["/etc/machine-id", "/var/lib/dbus/machine-id"] .iter() .find_map(|path| read_linux_identity_file(path).map(|value| (*path, value))) } fn read_linux_identity_file(path: &str) -> Option { std::fs::read_to_string(path) .ok() .map(|value| value.trim().to_string()) .filter(|value| is_usable_linux_identity_value(value)) } fn is_usable_linux_identity_value(value: &str) -> bool { !value.is_empty() && value != "None" && value != "To Be Filled By O.E.M." } fn collect_linux_serial_number() -> Option { resolve_linux_serial_number( read_linux_identity_file("/sys/class/dmi/id/product_serial"), collect_linux_product_uuid, ) } fn resolve_linux_serial_number( product_serial: Option, product_uuid: impl FnOnce() -> Option, ) -> Option { product_serial.or_else(|| product_uuid().and_then(|uuid| serial_number::vmware_from_uuid(&uuid))) } #[cfg(test)] mod tests { use super::*; #[test] fn normalize_uuid_preserves_real_uuid_identity() { assert_eq!( normalize_uuid("5A784D56-6461-19AC-9EA9-D36A3B9C6CEF"), Some("5a784d56-6461-19ac-9ea9-d36a3b9c6cef".to_string()) ); assert_eq!(normalize_uuid("not-a-uuid"), None); } #[test] fn linux_serial_number_preserves_product_serial_and_formats_uuid_fallback() { let uuid = Some("5a784d56-6461-19ac-9ea9-d36a3b9c6cef".to_string()); assert_eq!( resolve_linux_serial_number(Some("product-serial".to_string()), || uuid.clone()), Some("product-serial".to_string()) ); assert_eq!( resolve_linux_serial_number(None, || uuid), Some("VMware-56 4d 78 5a 61 64 ac 19-9e a9 d3 6a 3b 9c 6c ef".to_string()) ); } } } #[cfg(test)] mod tests { use super::*; #[test] fn controlled_identity_collection_propagates_cancellation() { let control = || Err(io::Error::new(io::ErrorKind::Interrupted, "cancelled")); let error = HostIdentity::collect_with_control(&control).unwrap_err(); assert_eq!(error.kind(), io::ErrorKind::Interrupted); let error = HostIdentity::collect_with_host_id_and_control(Some("supplied"), &control).unwrap_err(); assert_eq!(error.kind(), io::ErrorKind::Interrupted); } #[test] fn collect_produces_non_empty_identity() { let identity = HostIdentity::collect(); assert!(!identity.computer().is_empty()); assert!(!identity.host_id().is_empty()); assert!(!identity.serialno().is_empty()); assert!(!identity.mac_addr().is_empty()); assert_mac(identity.mac_addr(), ':'); } #[test] fn collect_with_host_id_uses_provided_host_id() { let identity = HostIdentity::collect_with_host_id(Some("provided-host-id")); assert_eq!(identity.host_id(), "provided-host-id"); assert!(!identity.computer().is_empty()); assert!(!identity.serialno().is_empty()); assert!(!identity.mac_addr().is_empty()); } #[test] fn collect_with_blank_host_id_falls_back_to_runtime_host_id() { let identity = HostIdentity::collect_with_host_id(Some(" ")); assert!(!identity.host_id().is_empty()); assert_ne!(identity.host_id(), " "); } #[test] fn resolve_host_id_does_not_collect_when_override_is_provided() { let host_id = resolve_host_id(Some("provided-host-id"), || { panic!("runtime host id should not be collected") }); assert_eq!(host_id, "provided-host-id"); } #[test] fn host_identity_normalizes_mac_to_lowercase_colon_format() { let identity = HostIdentity::new( "computer".to_string(), "host-id".to_string(), "serial-number".to_string(), "AA-BB-CC-DD-EE-FF".to_string(), ); assert_eq!(identity.mac_addr(), "aa:bb:cc:dd:ee:ff"); } #[test] fn native_snapshot_uses_host_id_as_derivation_seed() { let native = RuntimeNativeHostIdentity::collect_with_control(None, &CollectionBudget::new(Duration::from_secs(60))).unwrap(); assert!(!native.host_id.is_empty()); } #[test] fn serialization_keeps_globalprotect_field_names() { let identity = HostIdentity::new( "computer".to_string(), "host-id".to_string(), "serial-number".to_string(), "aa:bb:cc:dd:ee:ff".to_string(), ); let value = serde_json::to_value(identity).unwrap(); assert_eq!(value["hostId"], "host-id"); assert_eq!(value["computer"], "computer"); assert!(value.get("osVersion").is_none()); assert!(value.get("softwareVersion").is_none()); assert_eq!(value["serialno"], "serial-number"); assert_eq!(value["macAddr"], "aa:bb:cc:dd:ee:ff"); } #[test] fn native_identity_falls_back_to_derived_values_when_missing() { let native = NativeHostIdentitySnapshot { host_id: "native-host-id".to_string(), computer: "native-computer".to_string(), serial_number: None, mac_address: None, }; let identity = native.into_host_identity(); assert_eq!(identity.computer(), "native-computer"); assert_eq!(identity.host_id(), "native-host-id"); assert!(identity.serialno().starts_with("VMware-")); assert_mac(identity.mac_addr(), ':'); } #[test] fn derived_serial_uses_vmware_uuid_byte_order_when_host_id_is_uuid() { let identity = HostIdentity::new( "computer".to_string(), "5a784d56-6461-19ac-9ea9-d36a3b9c6cef".to_string(), String::new(), "aa:bb:cc:dd:ee:ff".to_string(), ); assert_eq!( identity.serialno(), "VMware-56 4d 78 5a 61 64 ac 19-9e a9 d3 6a 3b 9c 6c ef" ); } #[test] fn empty_host_id_falls_back_to_non_empty_value() { let identity = HostIdentity::new(String::new(), String::new(), String::new(), String::new()); assert!(!identity.host_id().is_empty()); assert!(!identity.computer().is_empty()); assert!(!identity.serialno().is_empty()); assert!(!identity.mac_addr().is_empty()); } fn assert_mac(value: &str, separator: char) { let parts: Vec<&str> = value.split(separator).collect(); assert_eq!(parts.len(), 6, "MAC should have 6 octets"); for part in &parts { assert_eq!(part.len(), 2); assert!(part.chars().all(|c| c.is_ascii_hexdigit())); } } }