use super::*;
#[test]
fn ships_three_measured_targets() {
assert_eq!(
FINGERPRINT_TARGETS.len(),
3,
"built-in catalogue must contain exactly the three measured targets"
);
}
#[test]
fn every_label_resolves_via_lookup() {
for target in FINGERPRINT_TARGETS {
let resolved = lookup(target.label).expect("label must round-trip");
assert_eq!(resolved, target);
}
}
#[test]
fn lookup_returns_none_for_unknown_label() {
assert!(lookup("internet-explorer-6").is_none());
assert!(lookup("").is_none());
assert!(
lookup("chrome-130-win").is_none(),
"lookup is exact and the old approximate target was removed"
);
assert!(
lookup("CHROME-146-LINUX").is_none(),
"lookup is case-sensitive"
);
}
#[test]
fn every_published_target_has_a_coherent_tcp_companion() {
use crate::fingerprint::{os_network_stack, UserAgentPlatform};
fn os_from_label(label: &str) -> Option<UserAgentPlatform> {
label.split('-').find_map(|seg| match seg {
"win" => Some(UserAgentPlatform::Windows),
"mac" => Some(UserAgentPlatform::MacOs),
"linux" => Some(UserAgentPlatform::Linux),
"ios" => Some(UserAgentPlatform::Ios),
"android" => Some(UserAgentPlatform::Android),
_ => None,
})
}
for target in FINGERPRINT_TARGETS {
let os = os_from_label(target.label)
.unwrap_or_else(|| panic!("{}: label carries no OS segment", target.label));
let stack = os_network_stack(os)
.unwrap_or_else(|| panic!("{}: OS {os:?} has no modeled TCP/IP stack", target.label));
let ja4t = stack
.ja4t()
.unwrap_or_else(|e| panic!("{}: JA4T failed closed: {e}", target.label));
assert_eq!(
ja4t.matches('_').count(),
3,
"{}: malformed JA4T {ja4t}",
target.label
);
let window_field = ja4t.split('_').next().unwrap();
match os {
UserAgentPlatform::Linux | UserAgentPlatform::Android => assert_eq!(
window_field, "*",
"{}: autotuned OS {os:?} must wildcard the JA4T window",
target.label
),
_ => assert!(
window_field.parse::<u16>().is_ok(),
"{}: fixed-window OS {os:?} must carry a numeric JA4T window, got {window_field}",
target.label
),
}
assert!(
!stack.p0f_signature().is_empty(),
"{}: empty p0f signature",
target.label
);
assert!(
!target.ja3.is_empty() && !target.ja4.is_empty() && !target.akamai_h2.is_empty(),
"{}: incomplete TLS/H2 fingerprint set",
target.label
);
}
}
#[test]
fn every_target_has_non_empty_fields() {
for target in FINGERPRINT_TARGETS {
assert!(!target.label.is_empty(), "target label empty");
assert!(!target.ja3.is_empty(), "{}: empty JA3", target.label);
assert!(!target.ja4.is_empty(), "{}: empty JA4", target.label);
assert!(
!target.akamai_h2.is_empty(),
"{}: empty akamai_h2",
target.label
);
assert!(
!target.peet_h2.is_empty(),
"{}: empty peet_h2",
target.label
);
}
}
#[test]
fn all_labels_lists_every_target_in_order() {
let labels = all_labels();
assert_eq!(labels.len(), FINGERPRINT_TARGETS.len());
for (index, target) in FINGERPRINT_TARGETS.iter().enumerate() {
assert_eq!(labels[index], target.label);
}
}
#[test]
fn ja3_format_starts_with_tls_version_771() {
for target in FINGERPRINT_TARGETS {
assert!(
target.ja3.starts_with("771,"),
"{}: JA3 must start with 771, got {}",
target.label,
&target.ja3[..target.ja3.len().min(20)]
);
}
}
#[test]
fn ja4_format_starts_with_t13d_for_tls_13_targets() {
for target in FINGERPRINT_TARGETS {
assert!(
target.ja4.starts_with("t13d"),
"{}: JA4 must start with t13d, got {}",
target.label,
&target.ja4[..target.ja4.len().min(8)]
);
}
}
#[test]
fn akamai_h2_has_pipe_separated_four_part_format() {
for target in FINGERPRINT_TARGETS {
let parts: Vec<&str> = target.akamai_h2.split('|').collect();
assert_eq!(
parts.len(),
4,
"{}: akamai_h2 must have 4 pipe-separated parts, got {}",
target.label,
parts.len()
);
}
}
#[test]
fn every_target_h2_pseudo_header_order_matches_its_browser_family() {
use crate::fingerprint::akamai_h2::{AkamaiH2Fingerprint, PseudoHeader};
use PseudoHeader::{Authority, Method, Path, Scheme};
fn expected_order(label: &str) -> Vec<PseudoHeader> {
if label.starts_with("chrome-") {
vec![Method, Authority, Scheme, Path]
} else if label.starts_with("firefox-") {
vec![Method, Path, Authority, Scheme]
} else {
panic!(
"{label}: H2-coherence gate does not know this browser family. \
extend `expected_order` with its canonical pseudo-header order \
(do NOT let an unclassified target bypass the fence)"
);
}
}
for target in FINGERPRINT_TARGETS {
let parsed = AkamaiH2Fingerprint::parse(target.akamai_h2).unwrap_or_else(|e| {
panic!(
"{}: akamai_h2 {:?} failed to parse: {e:?}",
target.label, target.akamai_h2
)
});
assert_eq!(
parsed.pseudo_header_order,
expected_order(target.label),
"{}: H2 pseudo-header order {:?} does not match the order for its labeled \
browser family (from akamai_h2 {:?})",
target.label,
parsed
.pseudo_header_order
.iter()
.map(|p| p.code())
.collect::<String>(),
target.akamai_h2,
);
}
}
#[test]
fn every_target_h2_settings_profile_matches_its_browser_family() {
use crate::fingerprint::akamai_h2::AkamaiH2Fingerprint;
for target in FINGERPRINT_TARGETS {
let p = AkamaiH2Fingerprint::parse(target.akamai_h2)
.unwrap_or_else(|e| panic!("{}: akamai_h2 failed to parse: {e:?}", target.label));
let has_max_frame = p.max_frame_size().is_some(); let has_max_header_list = p.max_header_list_size().is_some(); let (want_frame, want_header_list) = if target.label.starts_with("chrome-") {
(false, true)
} else if target.label.starts_with("firefox-") {
(true, false)
} else {
panic!(
"{}: H2-SETTINGS-coherence gate does not know this browser family. \
extend it with the family's measured (max_frame_size, max_header_list_size) \
presence (do NOT let an unclassified target bypass the fence)",
target.label
);
};
assert_eq!(
(has_max_frame, has_max_header_list),
(want_frame, want_header_list),
"{}: H2 SETTINGS family shape (max_frame_size present={has_max_frame}, \
max_header_list_size present={has_max_header_list}) does not match its labeled \
browser family's measured profile (from akamai_h2 {:?})",
target.label,
target.akamai_h2
);
}
}
#[test]
fn every_target_peet_h2_is_the_real_md5_of_its_akamai_h2() {
for target in FINGERPRINT_TARGETS {
let real = crate::fingerprint::ja3::md5_string(target.akamai_h2);
assert_eq!(
target.peet_h2, real,
"{}: stored peet_h2 {} is not md5(akamai_h2); real md5 of {:?} is {}",
target.label, target.peet_h2, target.akamai_h2, real
);
}
}
#[test]
fn every_builtin_target_passes_the_shared_validator() {
for t in FINGERPRINT_TARGETS {
validate_target_fields(t.label, t.ja3, t.ja4, t.akamai_h2, t.peet_h2)
.unwrap_or_else(|e| panic!("built-in {} fails the loader's validator: {e}", t.label));
}
}
#[test]
fn builtin_with_appends_extra_after_builtins() {
let extra = [FingerprintTarget {
label: "synthetic-extra",
ja3: "771,4865,0,29,0",
ja4: "t13d0101h2_aaaaaaaaaaaa_bbbbbbbbbbbb",
akamai_h2: "1:1|2|3|m",
peet_h2: "deadbeef",
}];
let merged = builtin_with(&extra);
assert_eq!(merged.len(), FINGERPRINT_TARGETS.len() + 1);
assert_eq!(merged[0].label, FINGERPRINT_TARGETS[0].label);
assert_eq!(merged.last().unwrap().label, "synthetic-extra");
}
#[test]
fn every_builtin_target_is_ja3_ja4_count_consistent() {
for target in FINGERPRINT_TARGETS {
ja4_counts_match_ja3(target.ja3, target.ja4)
.unwrap_or_else(|e| panic!("{} JA3/JA4 counts disagree: {e}", target.label));
}
}
#[test]
fn measured_firefox_150_target_is_ja3_ja4_count_consistent() {
let ff = lookup("firefox-150-linux").expect("ff-150 must ship");
ja4_counts_match_ja3(ff.ja3, ff.ja4)
.unwrap_or_else(|e| panic!("firefox-150-linux JA3/JA4 counts disagree: {e}"));
}
#[test]
fn ja4_counts_match_ja3_detects_mismatched_counts() {
let ja3 = "771,4865-4866,0-23-65281,29,0"; let ja4_ok = "t13d0203h2_aaaaaaaaaaaa_bbbbbbbbbbbb";
assert!(ja4_counts_match_ja3(ja3, ja4_ok).is_ok());
let ja4_bad_cipher = "t13d0303h2_aaaaaaaaaaaa_bbbbbbbbbbbb";
assert!(ja4_counts_match_ja3(ja3, ja4_bad_cipher).is_err());
let ja4_bad_ext = "t13d0202h2_aaaaaaaaaaaa_bbbbbbbbbbbb";
assert!(ja4_counts_match_ja3(ja3, ja4_bad_ext).is_err());
}
#[test]
fn ja4_counts_match_ja3_rejects_malformed_inputs() {
assert!(ja4_counts_match_ja3("not,five,fields", "t13d0202h2_x_y").is_err());
assert!(ja4_counts_match_ja3("771,1,2,3,0", "short").is_err());
assert!(ja4_counts_match_ja3("771,1,2,3,0", "t13dxx02h2_x_y").is_err());
}
#[test]
fn validator_rejects_each_malformed_field() {
let ok = "1:65536|0|0|m,p,a,s";
assert!(
validate_target_fields("", "771,x", "t13", ok, "h").is_err(),
"empty label"
);
assert!(
validate_target_fields("l", "770,x", "t13", ok, "h").is_err(),
"bad JA3 version"
);
assert!(
validate_target_fields("l", "771,x", "t12", ok, "h").is_err(),
"non-TLS1.3 JA4"
);
assert!(
validate_target_fields("l", "771,x", "t13", "a|b|c", "h").is_err(),
"3 sections"
);
assert!(
validate_target_fields("l", "771,x", "t13", "nope|0|0|m", "h").is_err(),
"bad SETTINGS"
);
assert!(
validate_target_fields("l", "771,x", "t13", "1:65536|0|0|x", "h").is_err(),
"bad pseudo-header"
);
assert!(
validate_target_fields("l", "771,x", "t13", ok, "").is_err(),
"empty peetprint"
);
assert!(
validate_target_fields("l", "771,x", "t13", ok, "deadbeefdeadbeefdeadbeefdeadbeef")
.is_err(),
"non-empty peet_h2 that is not md5(akamai_h2) is fabricated → rejected"
);
let ok_peet = crate::fingerprint::ja3::md5_string(ok);
assert!(
validate_target_fields("l", "771,x", "t13", ok, &ok_peet).is_ok(),
"all fields valid (peet_h2 == md5(akamai_h2))"
);
}