use crate::fingerprint::{
infer_initial_ttl, OsNetworkStack, TcpWindow, UserAgentPlatform, KNOWN_INITIAL_TTLS,
};
use std::collections::HashSet;
use std::path::Path;
const MAX_TCP_STACK_TOML_BYTES: u64 = 64 * 1024;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct LabeledTcpStack {
pub label: &'static str,
pub stack: OsNetworkStack,
}
#[derive(Debug)]
pub enum TcpStackLoadError {
Read(String),
TooLarge {
path: String,
bytes: u64,
},
Parse(String),
Invalid {
label: String,
reason: String,
},
DuplicateLabel(String),
}
impl std::fmt::Display for TcpStackLoadError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Read(e) => write!(f, "tier-b tcp-stacks: read failed: {e}"),
Self::TooLarge { path, bytes } => write!(
f,
"tier-b tcp-stacks: {path} is {bytes} bytes, over the {MAX_TCP_STACK_TOML_BYTES}-byte cap"
),
Self::Parse(e) => write!(f, "tier-b tcp-stacks: TOML parse failed: {e}"),
Self::Invalid { label, reason } => {
write!(f, "tier-b tcp-stacks: stack `{label}` invalid: {reason}")
}
Self::DuplicateLabel(label) => {
write!(f, "tier-b tcp-stacks: duplicate label `{label}`")
}
}
}
}
impl std::error::Error for TcpStackLoadError {}
#[derive(serde::Deserialize)]
struct StackDoc {
label: String,
os: String,
initial_ttl: u8,
tcp_mss: u16,
tcp_window_scale: u8,
tcp_window: String,
tcp_options_layout: String,
df: bool,
}
#[derive(serde::Deserialize)]
struct StacksDoc {
#[serde(default)]
stack: Vec<StackDoc>,
}
fn parse_platform(raw: &str) -> Option<UserAgentPlatform> {
match raw.to_ascii_lowercase().as_str() {
"windows" => Some(UserAgentPlatform::Windows),
"linux" => Some(UserAgentPlatform::Linux),
"macos" | "mac" => Some(UserAgentPlatform::MacOs),
"ios" => Some(UserAgentPlatform::Ios),
"android" => Some(UserAgentPlatform::Android),
_ => None,
}
}
fn parse_window(raw: &str) -> Option<TcpWindow> {
let trimmed = raw.trim();
if trimmed.eq_ignore_ascii_case("mss-scaled") || trimmed == "*" {
return Some(TcpWindow::MssScaled);
}
trimmed.parse::<u16>().ok().map(TcpWindow::Fixed)
}
pub fn load_tcp_stacks_from_toml(path: &Path) -> Result<Vec<LabeledTcpStack>, TcpStackLoadError> {
let meta = std::fs::metadata(path)
.map_err(|e| TcpStackLoadError::Read(format!("{}: {e}", path.display())))?;
if meta.len() > MAX_TCP_STACK_TOML_BYTES {
return Err(TcpStackLoadError::TooLarge {
path: path.display().to_string(),
bytes: meta.len(),
});
}
let raw = std::fs::read_to_string(path)
.map_err(|e| TcpStackLoadError::Read(format!("{}: {e}", path.display())))?;
let doc: StacksDoc =
toml::from_str(&raw).map_err(|e| TcpStackLoadError::Parse(e.to_string()))?;
let mut seen: HashSet<String> = HashSet::new();
let mut out = Vec::with_capacity(doc.stack.len());
for d in doc.stack {
let invalid = |reason: &str| TcpStackLoadError::Invalid {
label: d.label.clone(),
reason: reason.to_string(),
};
let os = parse_platform(&d.os)
.filter(|p| *p != UserAgentPlatform::Unknown)
.ok_or_else(|| invalid(&format!("unknown OS family `{}`", d.os)))?;
if !KNOWN_INITIAL_TTLS.contains(&d.initial_ttl) {
return Err(invalid(&format!(
"initial_ttl {} is not a canonical OS default {KNOWN_INITIAL_TTLS:?}",
d.initial_ttl
)));
}
if infer_initial_ttl(d.initial_ttl) != d.initial_ttl {
return Err(invalid("initial_ttl does not survive a zero-hop de-hop"));
}
if d.tcp_options_layout.trim().is_empty() {
return Err(invalid("empty tcp_options_layout"));
}
let tcp_window = parse_window(&d.tcp_window)
.ok_or_else(|| invalid(&format!("unparseable tcp_window `{}`", d.tcp_window)))?;
let layout: &'static str = Box::leak(d.tcp_options_layout.into_boxed_str());
let stack = OsNetworkStack {
os,
initial_ttl: d.initial_ttl,
tcp_mss: d.tcp_mss,
tcp_window_scale: d.tcp_window_scale,
tcp_window,
tcp_options_layout: layout,
df: d.df,
};
if let Err(e) = stack.ja4t() {
return Err(invalid(&format!(
"options layout yields no faithful JA4T: {e}"
)));
}
if !seen.insert(d.label.clone()) {
return Err(TcpStackLoadError::DuplicateLabel(d.label));
}
out.push(LabeledTcpStack {
label: Box::leak(d.label.into_boxed_str()),
stack,
});
}
Ok(out)
}
#[cfg(test)]
#[path = "os_network_tier_b/tests.rs"]
mod tests;