use chromiumoxide::cdp::browser_protocol::emulation::{UserAgentBrandVersion, UserAgentMetadata};
#[derive(Debug, Clone, PartialEq)]
pub struct UaFingerprint {
pub metadata: Option<UserAgentMetadata>,
pub navigator_platform: Option<&'static str>,
}
fn android_architecture() -> &'static str {
"arm"
}
fn profile_architecture(ua: &str, mobile: bool, platform: &str) -> &'static str {
if mobile && platform == "Android" {
return android_architecture();
}
let lowered = ua.to_ascii_lowercase();
if lowered.contains("aarch64")
|| lowered.contains("arm64")
|| lowered.contains("armv8")
|| lowered.contains("armv7")
{
return "arm";
}
"x86"
}
const BITNESS: &str = "64";
#[must_use]
pub fn build_ua_fingerprint(
ua: &str,
sec_ch_ua: &str,
profile_platform: &str,
mobile: bool,
) -> UaFingerprint {
let brands = parse_sec_ch_ua(sec_ch_ua);
let metadata = brands.map(|b| {
let (platform, platform_version) = client_hint_platform(profile_platform, ua);
let architecture = profile_architecture(ua, mobile, &platform).to_string();
UserAgentMetadata {
brands: Some(b),
full_version_list: None,
platform,
platform_version,
architecture,
model: parse_device_model(ua, mobile),
mobile,
bitness: Some(BITNESS.to_string()),
wow64: None,
form_factors: None,
}
});
UaFingerprint {
metadata,
navigator_platform: navigator_platform(ua),
}
}
fn parse_sec_ch_ua(sec_ch_ua: &str) -> Option<Vec<UserAgentBrandVersion>> {
let trimmed = sec_ch_ua.trim();
if trimmed.is_empty() {
return None;
}
let mut brands = Vec::new();
for part in trimmed.split(',') {
let part = part.trim();
let brand = part
.strip_prefix('"')
.and_then(|rest| rest.split("\"").next())
.unwrap_or_default();
if brand.is_empty() {
continue;
}
let Some(v_pos) = part.find("v=\"") else {
continue;
};
let version: String = part[v_pos + 3..]
.chars()
.take_while(|c| c.is_ascii_digit() || *c == '.')
.collect();
if version.is_empty() {
continue;
}
brands.push(UserAgentBrandVersion::new(brand, version));
}
if brands.is_empty() {
None
} else {
Some(brands)
}
}
fn client_hint_platform(profile_platform: &str, ua: &str) -> (String, String) {
let platform = if profile_platform.is_empty() {
ua_fallback_platform(ua).to_string()
} else {
profile_platform.to_string()
};
(platform, platform_version_from_ua(ua))
}
fn navigator_platform(ua: &str) -> Option<&'static str> {
if ua.contains("iPhone") {
Some("iPhone")
} else if ua.contains("iPad") {
Some("iPad")
} else if ua.contains("Windows NT") {
Some("Win32")
} else if ua.contains("Macintosh") {
Some("MacIntel")
} else if ua.contains("Android") {
Some("Linux armv8l")
} else if ua.contains("Linux") {
Some("Linux x86_64")
} else {
None
}
}
fn ua_fallback_platform(ua: &str) -> &'static str {
if ua.contains("iPhone") || ua.contains("iPad") {
"iOS"
} else if ua.contains("Android") {
"Android"
} else if ua.contains("Macintosh") {
"macOS"
} else if ua.contains("Windows NT") {
"Windows"
} else if ua.contains("Linux") {
"Linux"
} else {
""
}
}
fn platform_version_from_ua(ua: &str) -> String {
if ua.contains("iPhone") || ua.contains("iPad") {
let version = find_token(ua, "iPhone OS ").or_else(|| find_token(ua, "CPU OS "));
normalize_version(version.as_deref())
} else if let Some(raw) = find_token(ua, "Android ") {
normalize_version(Some(&raw))
} else if let Some(raw) = find_token(ua, "Windows NT ") {
normalize_version(Some(&raw))
} else if ua.contains("Macintosh") {
normalize_version(find_token(ua, "Mac OS X ").as_deref())
} else {
String::new()
}
}
fn parse_device_model(ua: &str, mobile: bool) -> String {
if !mobile {
return String::new();
}
let Some(rest) = ua.split_once("Android ").map(|(_, r)| r) else {
return String::new();
};
let Some(after_version) = rest.split_once("; ") else {
return String::new();
};
let model: String = after_version.1.chars().take_while(|c| *c != ')').collect();
let model = model
.split(" Build")
.next()
.unwrap_or_default()
.trim()
.to_string();
if model == "wv" {
String::new()
} else {
model
}
}
fn find_token(ua: &str, marker: &str) -> Option<String> {
let start = ua.find(marker)? + marker.len();
let token: String = ua[start..]
.chars()
.take_while(|c| !c.is_whitespace() && *c != ';' && *c != ')')
.collect();
if token.is_empty() {
None
} else {
Some(token)
}
}
fn normalize_version(raw: Option<&str>) -> String {
let Some(raw) = raw else {
return String::new();
};
let normalized = raw.replace('_', ".");
let mut parts: Vec<&str> = normalized.split('.').collect();
if parts.len() > 3 {
parts.truncate(3);
}
if parts
.iter()
.any(|p| p.is_empty() || !p.bytes().all(|b| b.is_ascii_digit()))
{
return String::new();
}
while parts.len() < 3 {
parts.push("0");
}
parts.join(".")
}
#[cfg(test)]
mod tests {
use super::*;
const SEC_CHROME_131: &str =
"\"Chromium\";v=\"131\", \"Not_A Brand\";v=\"24\", \"Google Chrome\";v=\"131\"";
const SEC_EDGE_131: &str =
"\"Microsoft Edge\";v=\"131\", \"Chromium\";v=\"131\", \"Not_A Brand\";v=\"24\", \"Google Chrome\";v=\"131\"";
const UA_WIN_CHROME: &str = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
const UA_MAC_CHROME: &str = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
const UA_ANDROID_PIXEL: &str = "Mozilla/5.0 (Linux; Android 14; Pixel 8) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Mobile Safari/537.36";
const UA_IPHONE_CRIOS: &str = "Mozilla/5.0 (iPhone; CPU iPhone OS 17_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/131.0.6778.73 Mobile/15E148 Safari/604.1";
fn brand_version(brands: &[UserAgentBrandVersion], brand: &str) -> Option<String> {
brands
.iter()
.find(|b| b.brand == brand)
.map(|b| b.version.clone())
}
#[test]
fn test_windows_desktop_full_fingerprint() {
let fp = build_ua_fingerprint(UA_WIN_CHROME, SEC_CHROME_131, "Windows", false);
let meta = fp.metadata.expect("chrome profile must have metadata");
assert_eq!(meta.platform, "Windows");
assert_eq!(meta.platform_version, "10.0.0");
assert_eq!(meta.architecture, "x86");
assert_eq!(meta.bitness.as_deref(), Some("64"));
assert_eq!(meta.model, "");
assert!(!meta.mobile);
let brands = meta.brands.expect("brands from sec_ch_ua template");
assert_eq!(
brand_version(&brands, "Google Chrome").as_deref(),
Some("131")
);
assert_eq!(brand_version(&brands, "Not_A Brand").as_deref(), Some("24"));
assert_eq!(fp.navigator_platform, Some("Win32"));
}
#[test]
fn test_macos_platform_vocabularies_split() {
let fp = build_ua_fingerprint(UA_MAC_CHROME, SEC_CHROME_131, "macOS", false);
let meta = fp.metadata.expect("metadata present");
assert_eq!(meta.platform, "macOS");
assert_eq!(meta.platform_version, "10.15.7");
assert_eq!(fp.navigator_platform, Some("MacIntel"));
}
#[test]
fn test_edge_brands_from_template_no_google_chrome_substitution() {
let ua = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36 Edg/131.0.0.0";
let fp = build_ua_fingerprint(ua, SEC_EDGE_131, "Windows", false);
let meta = fp.metadata.expect("metadata present");
let brands = meta.brands.expect("brands from Edge template");
assert_eq!(
brand_version(&brands, "Microsoft Edge").as_deref(),
Some("131")
);
assert_eq!(
brand_version(&brands, "Google Chrome").as_deref(),
Some("131")
);
assert_eq!(fp.navigator_platform, Some("Win32"));
}
#[test]
fn test_android_arm_and_device_model() {
let fp = build_ua_fingerprint(UA_ANDROID_PIXEL, SEC_CHROME_131, "Android", true);
let meta = fp.metadata.expect("metadata present");
assert_eq!(meta.platform, "Android");
assert_eq!(meta.platform_version, "14.0.0");
assert_eq!(meta.architecture, "arm");
assert_eq!(meta.model, "Pixel 8");
assert!(meta.mobile);
assert_eq!(fp.navigator_platform, Some("Linux armv8l"));
}
#[test]
fn test_crios_empty_client_hints_metadata_absent() {
let fp = build_ua_fingerprint(UA_IPHONE_CRIOS, "", "iOS", true);
assert!(
fp.metadata.is_none(),
"WKWebView profile must not send client hints metadata"
);
assert_eq!(fp.navigator_platform, Some("iPhone"));
}
#[test]
fn test_ipad_cpu_os_form() {
let ua = "Mozilla/5.0 (iPad; CPU OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/128.0.6778.39 Mobile/15E148 Safari/604.1";
let fp = build_ua_fingerprint(ua, "", "iOS", true);
assert!(fp.metadata.is_none());
assert_eq!(fp.navigator_platform, Some("iPad"));
}
#[test]
fn test_linux_desktop_version_unparsable_left_empty() {
let ua = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36";
let fp = build_ua_fingerprint(ua, SEC_CHROME_131, "Linux", false);
let meta = fp.metadata.expect("metadata present");
assert_eq!(meta.platform, "Linux");
assert_eq!(meta.platform_version, "");
assert_eq!(fp.navigator_platform, Some("Linux x86_64"));
}
#[test]
fn test_firefox_fallback_platform_labels() {
let ua = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
let fp = build_ua_fingerprint(ua, SEC_CHROME_131, "", false);
let meta = fp.metadata.expect("metadata present");
assert_eq!(meta.platform, "macOS");
}
#[test]
fn test_profile_architecture_from_ua() {
assert_eq!(
super::profile_architecture(UA_WIN_CHROME, false, "Windows"),
"x86"
);
assert_eq!(
super::profile_architecture(UA_MAC_CHROME, false, "macOS"),
"x86"
);
assert_eq!(
super::profile_architecture(UA_ANDROID_PIXEL, true, "Android"),
"arm"
);
let ua_linux_arm = "Mozilla/5.0 (X11; Linux aarch64) AppleWebKit/537.36 \
(KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
assert_eq!(
super::profile_architecture(ua_linux_arm, false, "Linux"),
"arm"
);
assert_eq!(
super::profile_architecture("unknown-ua", false, "Windows"),
"x86"
);
}
#[test]
fn test_unparsable_ua_deterministic_and_neutral() {
let fp = build_ua_fingerprint("totally-unrelated-string", "", "", true);
assert!(fp.metadata.is_none());
assert_eq!(fp.navigator_platform, None);
assert_eq!(
build_ua_fingerprint("totally-unrelated-string", "", "", true),
fp
);
}
#[test]
fn test_malformed_sec_ch_ua_defensive() {
assert!(
build_ua_fingerprint(UA_WIN_CHROME, "\"\";v=, broken", "Windows", false)
.metadata
.is_none()
);
let fp = build_ua_fingerprint(UA_WIN_CHROME, "\"A\";v=\"1\", broken", "Windows", false);
let brands = fp.metadata.expect("one valid segment").brands.unwrap();
assert_eq!(brands.len(), 1);
assert_eq!(brands[0].brand, "A");
}
#[test]
fn test_webview_marker_model_empty() {
let ua = "Mozilla/5.0 (Linux; Android 6.0; wv) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Mobile Safari/537.36";
let fp = build_ua_fingerprint(ua, SEC_CHROME_131, "Android", true);
let meta = fp.metadata.expect("metadata present");
assert_eq!(meta.model, "", "wv is a WebView marker, not a device model");
}
}
#[must_use]
pub fn cdp_accept_language(accept_language: &str) -> &str {
match accept_language.rsplit_once(";q=") {
Some((head, q)) if !q.is_empty() && q.bytes().all(|b| b.is_ascii_digit() || b == b'.') => {
head
}
_ => accept_language,
}
}
#[cfg(test)]
mod cdp_accept_language_tests {
use super::cdp_accept_language;
#[test]
fn strips_trailing_q() {
assert_eq!(cdp_accept_language("en-GB,en;q=0.9"), "en-GB,en");
assert_eq!(
cdp_accept_language("zh-CN,zh;q=0.9,en;q=0.5"),
"zh-CN,zh;q=0.9,en"
);
}
#[test]
fn keeps_values_without_trailing_q() {
assert_eq!(cdp_accept_language("en-US,en"), "en-US,en");
assert_eq!(
cdp_accept_language("en-GB,en;q=nonsense"),
"en-GB,en;q=nonsense"
);
assert_eq!(cdp_accept_language(""), "");
}
}