use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::time::SystemTime;
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct Technology {
#[serde(default)]
pub cats: Vec<u32>,
#[serde(default)]
pub website: String,
#[serde(default)]
pub headers: HashMap<String, String>,
#[serde(default)]
pub cookies: HashMap<String, String>,
#[serde(default)]
#[serde(deserialize_with = "deserialize_meta_map")]
pub meta: HashMap<String, Vec<String>>,
#[serde(default)]
#[serde(alias = "scriptSrc")]
#[serde(deserialize_with = "deserialize_string_or_array")]
pub script: Vec<String>,
#[serde(default)]
#[serde(deserialize_with = "deserialize_string_or_array")]
pub scripts: Vec<String>,
#[serde(default)]
#[serde(deserialize_with = "deserialize_string_or_array")]
pub html: Vec<String>,
#[serde(default)]
#[serde(deserialize_with = "deserialize_string_or_array")]
pub url: Vec<String>,
#[serde(default)]
#[serde(deserialize_with = "deserialize_meta_map")]
pub dns: HashMap<String, Vec<String>>,
#[serde(default)]
#[serde(alias = "certIssuer")]
#[serde(deserialize_with = "deserialize_string_or_array")]
pub cert_issuer: Vec<String>,
#[serde(default)]
pub js: HashMap<String, String>,
#[serde(default)]
#[serde(deserialize_with = "deserialize_string_or_array")]
pub implies: Vec<String>,
#[serde(default)]
#[serde(deserialize_with = "deserialize_string_or_array")]
pub excludes: Vec<String>,
#[serde(default)]
#[serde(deserialize_with = "deserialize_string_or_array")]
pub requires: Vec<String>,
#[serde(default)]
#[serde(alias = "requiresCategory")]
#[serde(deserialize_with = "deserialize_u32_or_array")]
pub requires_category: Vec<u32>,
}
fn deserialize_string_or_array<'de, D>(deserializer: D) -> Result<Vec<String>, D::Error>
where
D: serde::Deserializer<'de>,
{
use serde::de::{self, Visitor};
use std::fmt;
struct StringOrArrayVisitor;
impl<'de> Visitor<'de> for StringOrArrayVisitor {
type Value = Vec<String>;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("a string or an array of strings")
}
fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(vec![value.to_string()])
}
fn visit_string<E>(self, value: String) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(vec![value])
}
fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
where
A: de::SeqAccess<'de>,
{
let mut vec = Vec::new();
while let Some(elem) = seq.next_element::<String>()? {
vec.push(elem);
}
Ok(vec)
}
}
deserializer.deserialize_any(StringOrArrayVisitor)
}
fn deserialize_u32_or_array<'de, D>(deserializer: D) -> Result<Vec<u32>, D::Error>
where
D: serde::Deserializer<'de>,
{
use serde::de::{self, Visitor};
use std::fmt;
struct U32OrArrayVisitor;
impl<'de> Visitor<'de> for U32OrArrayVisitor {
type Value = Vec<u32>;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("a number or an array of numbers")
}
fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
where
E: de::Error,
{
u32::try_from(value)
.map(|n| vec![n])
.map_err(|_| de::Error::custom("category id exceeds u32"))
}
fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E>
where
E: de::Error,
{
u32::try_from(value)
.map(|n| vec![n])
.map_err(|_| de::Error::custom("category id must be a non-negative u32"))
}
fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
where
E: de::Error,
{
value
.parse::<u32>()
.map(|n| vec![n])
.map_err(|_| de::Error::custom("category id string is not u32"))
}
fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
where
A: de::SeqAccess<'de>,
{
let mut vec = Vec::new();
while let Some(elem) = seq.next_element::<serde_json::Value>()? {
let n = match elem {
serde_json::Value::Number(num) => num
.as_u64()
.and_then(|v| u32::try_from(v).ok())
.ok_or_else(|| de::Error::custom("category id is not u32"))?,
serde_json::Value::String(s) => s
.parse::<u32>()
.map_err(|_| de::Error::custom("category id string is not u32"))?,
_ => {
return Err(de::Error::invalid_type(
de::Unexpected::Other("expected number or string"),
&self,
));
}
};
vec.push(n);
}
Ok(vec)
}
}
deserializer.deserialize_any(U32OrArrayVisitor)
}
fn deserialize_meta_map<'de, D>(deserializer: D) -> Result<HashMap<String, Vec<String>>, D::Error>
where
D: serde::Deserializer<'de>,
{
use serde::de::{self, MapAccess, Visitor};
use std::fmt;
struct MetaMapVisitor;
impl<'de> Visitor<'de> for MetaMapVisitor {
type Value = HashMap<String, Vec<String>>;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("a map of string to string or array of strings")
}
fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
where
M: MapAccess<'de>,
{
let mut result = HashMap::new();
while let Some((key, value)) = map.next_entry::<String, serde_json::Value>()? {
let patterns = match value {
serde_json::Value::String(s) => vec![s],
serde_json::Value::Array(arr) => arr
.into_iter()
.filter_map(|v| v.as_str().map(std::string::ToString::to_string))
.collect(),
_ => {
return Err(de::Error::invalid_type(
de::Unexpected::Other("expected string or array"),
&self,
));
}
};
result.insert(key, patterns);
}
Ok(result)
}
}
deserializer.deserialize_map(MetaMapVisitor)
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FingerprintMetadata {
pub source: String,
pub version: String,
pub last_updated: SystemTime,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub(crate) struct Category {
pub(crate) name: String,
#[serde(default)]
description: String,
#[serde(default)]
priority: u32,
}
#[derive(Debug, Clone)]
pub struct FingerprintRuleset {
pub technologies: HashMap<String, Technology>,
pub categories: HashMap<u32, String>,
pub metadata: FingerprintMetadata,
}
impl FingerprintRuleset {
#[cfg(test)]
#[must_use]
pub fn empty_for_tests() -> Self {
Self {
technologies: HashMap::new(),
categories: HashMap::new(),
metadata: FingerprintMetadata {
source: "test".into(),
version: "0".into(),
last_updated: SystemTime::now(),
},
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_technology_deserialize_string_fields() {
let json = r#"{
"cats": [1, 2],
"website": "https://example.com",
"html": "pattern1",
"script": "jquery.js",
"implies": "PHP"
}"#;
let tech: Technology = serde_json::from_str(json).expect("Failed to deserialize");
assert_eq!(tech.cats, vec![1, 2]);
assert_eq!(tech.website, "https://example.com");
assert_eq!(tech.html, vec!["pattern1"]);
assert_eq!(tech.script, vec!["jquery.js"]);
assert_eq!(tech.implies, vec!["PHP"]);
}
#[test]
fn test_technology_deserialize_array_fields() {
let json = r#"{
"cats": [1],
"html": ["pattern1", "pattern2"],
"script": ["jquery.js", "bootstrap.js"],
"implies": ["PHP", "MySQL"]
}"#;
let tech: Technology = serde_json::from_str(json).expect("Failed to deserialize");
assert_eq!(tech.html, vec!["pattern1", "pattern2"]);
assert_eq!(tech.script, vec!["jquery.js", "bootstrap.js"]);
assert_eq!(tech.implies, vec!["PHP", "MySQL"]);
}
#[test]
fn test_technology_deserialize_meta_string() {
let json = r#"{
"meta": {
"generator": "WordPress"
}
}"#;
let tech: Technology = serde_json::from_str(json).expect("Failed to deserialize");
assert_eq!(
tech.meta.get("generator"),
Some(&vec!["WordPress".to_string()])
);
}
#[test]
fn test_technology_deserialize_meta_array() {
let json = r#"{
"meta": {
"generator": ["WordPress", "Drupal"]
}
}"#;
let tech: Technology = serde_json::from_str(json).expect("Failed to deserialize");
assert_eq!(
tech.meta.get("generator"),
Some(&vec!["WordPress".to_string(), "Drupal".to_string()])
);
}
#[test]
fn test_technology_deserialize_headers() {
let json = r#"{
"headers": {
"Server": "Apache",
"X-Powered-By": "PHP"
}
}"#;
let tech: Technology = serde_json::from_str(json).expect("Failed to deserialize");
assert_eq!(tech.headers.get("Server"), Some(&"Apache".to_string()));
assert_eq!(tech.headers.get("X-Powered-By"), Some(&"PHP".to_string()));
}
#[test]
fn test_technology_deserialize_cookies() {
let json = r#"{
"cookies": {
"PHPSESSID": "",
"laravel_session": "^eyJ"
}
}"#;
let tech: Technology = serde_json::from_str(json).expect("Failed to deserialize");
assert_eq!(tech.cookies.get("PHPSESSID"), Some(&"".to_string()));
assert_eq!(
tech.cookies.get("laravel_session"),
Some(&"^eyJ".to_string())
);
}
#[test]
fn test_technology_deserialize_script_src_alias() {
let json = r#"{
"scriptSrc": ["jquery.min.js", "bootstrap.bundle.js"]
}"#;
let tech: Technology = serde_json::from_str(json).expect("Failed to deserialize");
assert_eq!(tech.script, vec!["jquery.min.js", "bootstrap.bundle.js"]);
}
#[test]
fn test_technology_deserialize_defaults() {
let json = r#"{}"#;
let tech: Technology = serde_json::from_str(json).expect("Failed to deserialize");
assert!(tech.cats.is_empty());
assert!(tech.website.is_empty());
assert!(tech.headers.is_empty());
assert!(tech.cookies.is_empty());
assert!(tech.meta.is_empty());
assert!(tech.script.is_empty());
assert!(tech.scripts.is_empty());
assert!(tech.html.is_empty());
assert!(tech.url.is_empty());
assert!(tech.dns.is_empty());
assert!(tech.cert_issuer.is_empty());
assert!(tech.js.is_empty());
assert!(tech.implies.is_empty());
assert!(tech.excludes.is_empty());
assert!(tech.requires.is_empty());
assert!(tech.requires_category.is_empty());
}
#[test]
fn test_technology_deserialize_requires_and_requires_category() {
let json = r#"{
"requires": "WordPress",
"requiresCategory": 1
}"#;
let tech: Technology = serde_json::from_str(json).expect("deserialize");
assert_eq!(tech.requires, vec!["WordPress"]);
assert_eq!(tech.requires_category, vec![1]);
let json_arr = r#"{
"requires": ["WordPress", "PHP"],
"requiresCategory": [1, 11]
}"#;
let tech: Technology = serde_json::from_str(json_arr).expect("deserialize");
assert_eq!(tech.requires, vec!["WordPress", "PHP"]);
assert_eq!(tech.requires_category, vec![1, 11]);
}
#[test]
fn test_technology_deserialize_dns_cert_scripts() {
let json = r#"{
"dns": {
"TXT": "google-site-verification",
"MX": ["google\\.com", "aspmx"]
},
"certIssuer": "Let's Encrypt",
"scripts": "function webpackJsonpCallback\\(data\\) {"
}"#;
let tech: Technology = serde_json::from_str(json).expect("Failed to deserialize");
assert_eq!(
tech.dns.get("TXT"),
Some(&vec!["google-site-verification".to_string()])
);
assert_eq!(
tech.dns.get("MX"),
Some(&vec!["google\\.com".to_string(), "aspmx".to_string()])
);
assert_eq!(tech.cert_issuer, vec!["Let's Encrypt".to_string()]);
assert_eq!(
tech.scripts,
vec![r"function webpackJsonpCallback\(data\) {".to_string()]
);
}
#[test]
fn test_technology_deserialize_complete() {
let json = r#"{
"cats": [1, 11],
"website": "https://wordpress.org",
"headers": {
"X-Powered-By": "WordPress"
},
"cookies": {
"wp-settings-": ""
},
"meta": {
"generator": "^WordPress\\s+([\\d.]+)?\\;version:\\1"
},
"html": [
"<link[^>]+/wp-(?:content|includes)/",
"data-flavor=\"developer\""
],
"scriptSrc": "wp-(?:content|includes)/",
"implies": ["PHP", "MySQL"]
}"#;
let tech: Technology = serde_json::from_str(json).expect("Failed to deserialize");
assert_eq!(tech.cats, vec![1, 11]);
assert_eq!(tech.website, "https://wordpress.org");
assert_eq!(tech.headers.len(), 1);
assert_eq!(tech.cookies.len(), 1);
assert_eq!(tech.meta.len(), 1);
assert_eq!(tech.html.len(), 2);
assert_eq!(tech.script.len(), 1);
assert_eq!(tech.implies, vec!["PHP", "MySQL"]);
}
#[test]
fn test_category_deserialize() {
let json = r#"{
"name": "CMS",
"description": "Content Management System",
"priority": 10
}"#;
let cat: Category = serde_json::from_str(json).expect("Failed to deserialize");
assert_eq!(cat.name, "CMS");
}
#[test]
fn test_category_deserialize_defaults() {
let json = r#"{"name": "CMS"}"#;
let cat: Category = serde_json::from_str(json).expect("Failed to deserialize");
assert_eq!(cat.name, "CMS");
}
#[test]
fn test_fingerprint_metadata_roundtrip() {
let metadata = FingerprintMetadata {
source: "https://example.com/rules".to_string(),
version: "1.0.0".to_string(),
last_updated: SystemTime::now(),
};
let json = serde_json::to_string(&metadata).expect("Failed to serialize");
let deserialized: FingerprintMetadata =
serde_json::from_str(&json).expect("Failed to deserialize");
assert_eq!(deserialized.source, metadata.source);
assert_eq!(deserialized.version, metadata.version);
}
#[test]
fn test_technology_deserialize_mixed_meta() {
let json = r#"{
"meta": {
"generator": "WordPress",
"author": ["John", "Jane"],
"keywords": "single keyword"
}
}"#;
let tech: Technology = serde_json::from_str(json).expect("Failed to deserialize");
assert_eq!(
tech.meta.get("generator"),
Some(&vec!["WordPress".to_string()])
);
assert_eq!(
tech.meta.get("author"),
Some(&vec!["John".to_string(), "Jane".to_string()])
);
assert_eq!(
tech.meta.get("keywords"),
Some(&vec!["single keyword".to_string()])
);
}
#[test]
fn test_technology_deserialize_url_patterns() {
let json = r#"{
"url": ["^https?://[^/]+/wp-admin/", "\\.aspx$"]
}"#;
let tech: Technology = serde_json::from_str(json).expect("Failed to deserialize");
assert_eq!(tech.url.len(), 2);
assert!(tech.url[0].contains("wp-admin"));
assert!(tech.url[1].contains("aspx"));
}
#[test]
fn test_technology_deserialize_js_patterns() {
let json = r#"{
"js": {
"jQuery": "",
"jQuery.fn.jquery": "\\;version:\\1"
}
}"#;
let tech: Technology = serde_json::from_str(json).expect("Failed to deserialize");
assert_eq!(tech.js.len(), 2);
assert_eq!(tech.js.get("jQuery"), Some(&"".to_string()));
}
#[test]
fn test_technology_deserialize_excludes() {
let json = r#"{
"excludes": ["WordPress", "Drupal"]
}"#;
let tech: Technology = serde_json::from_str(json).expect("Failed to deserialize");
assert_eq!(tech.excludes, vec!["WordPress", "Drupal"]);
}
#[test]
fn test_technology_deserialize_invalid_json() {
let invalid_json = r#"{
"cats": [1, 2],
"html": "pattern1",
"invalid_field": {
"nested": "invalid"
}
}"#;
let result: Result<Technology, _> = serde_json::from_str(invalid_json);
assert!(result.is_ok(), "Should handle invalid fields gracefully");
}
#[test]
fn test_technology_deserialize_wrong_type_in_array() {
let json = r#"{
"html": [123, "pattern2"]
}"#;
let result: Result<Technology, _> = serde_json::from_str(json);
assert!(
result.is_err(),
"Should fail when array contains non-string values"
);
}
#[test]
fn test_technology_deserialize_wrong_type_in_meta() {
let json = r#"{
"meta": {
"generator": 123
}
}"#;
let result: Result<Technology, _> = serde_json::from_str(json);
assert!(
result.is_err(),
"Should fail when meta value is not string or array"
);
}
#[test]
fn test_technology_deserialize_malformed_meta_array() {
let json = r#"{
"meta": {
"generator": [123, "WordPress"]
}
}"#;
let result: Result<Technology, _> = serde_json::from_str(json);
assert!(
result.is_ok(),
"Should handle non-string values by filtering them out"
);
let tech = result.unwrap();
assert_eq!(
tech.meta.get("generator"),
Some(&vec!["WordPress".to_string()]),
"Should only include string values"
);
}
#[test]
fn test_category_deserialize_invalid_json() {
let invalid_json = r#"{
"name": 123
}"#;
let result: Result<Category, _> = serde_json::from_str(invalid_json);
assert!(
result.is_err(),
"Should fail when category name is not a string"
);
}
#[test]
fn test_category_deserialize_missing_name() {
let json = r#"{
"description": "Test"
}"#;
let result: Result<Category, _> = serde_json::from_str(json);
assert!(result.is_err(), "Should fail when category name is missing");
}
#[test]
fn test_technology_deserialize_empty_arrays() {
let json = r#"{
"html": [],
"script": [],
"url": [],
"implies": [],
"excludes": []
}"#;
let tech: Technology = serde_json::from_str(json).expect("Failed to deserialize");
assert!(tech.html.is_empty());
assert!(tech.script.is_empty());
assert!(tech.url.is_empty());
assert!(tech.implies.is_empty());
assert!(tech.excludes.is_empty());
}
#[test]
fn test_technology_deserialize_empty_strings_in_arrays() {
let json = r#"{
"html": ["pattern1", "", "pattern2"],
"script": [""]
}"#;
let tech: Technology = serde_json::from_str(json).expect("Failed to deserialize");
assert_eq!(tech.html.len(), 3);
assert_eq!(tech.html[0], "pattern1");
assert_eq!(tech.html[1], "");
assert_eq!(tech.html[2], "pattern2");
assert_eq!(tech.script.len(), 1);
assert_eq!(tech.script[0], "");
}
#[test]
fn test_technology_deserialize_empty_meta_map() {
let json = r#"{
"meta": {}
}"#;
let tech: Technology = serde_json::from_str(json).expect("Failed to deserialize");
assert!(tech.meta.is_empty());
}
#[test]
fn test_technology_deserialize_meta_array_with_nulls() {
let json = r#"{
"meta": {
"generator": [null, "WordPress", null]
}
}"#;
let tech: Technology = serde_json::from_str(json).expect("Failed to deserialize");
assert_eq!(
tech.meta.get("generator"),
Some(&vec!["WordPress".to_string()]),
"Should filter out null values and only include strings"
);
}
#[test]
fn test_technology_deserialize_meta_array_with_empty_strings() {
let json = r#"{
"meta": {
"generator": ["WordPress", "", "Drupal"]
}
}"#;
let tech: Technology = serde_json::from_str(json).expect("Failed to deserialize");
assert_eq!(
tech.meta.get("generator"),
Some(&vec![
"WordPress".to_string(),
"".to_string(),
"Drupal".to_string()
]),
"Should preserve empty strings in meta arrays"
);
}
#[test]
fn test_technology_deserialize_meta_empty_key() {
let json = r#"{
"meta": {
"": "value",
"generator": "WordPress"
}
}"#;
let tech: Technology = serde_json::from_str(json).expect("Failed to deserialize");
assert_eq!(tech.meta.get(""), Some(&vec!["value".to_string()]));
assert_eq!(
tech.meta.get("generator"),
Some(&vec!["WordPress".to_string()])
);
}
#[test]
fn test_technology_deserialize_string_or_array_null() {
let json = r#"{
"html": null
}"#;
let result: Result<Technology, _> = serde_json::from_str(json);
assert!(
result.is_err(),
"Should fail when string_or_array field is null"
);
}
#[test]
fn test_technology_deserialize_meta_array_mixed_with_other_types() {
let json = r#"{
"meta": {
"generator": [null, 123, "WordPress", true, "Drupal"]
}
}"#;
let tech: Technology = serde_json::from_str(json).expect("Failed to deserialize");
assert_eq!(
tech.meta.get("generator"),
Some(&vec!["WordPress".to_string(), "Drupal".to_string()]),
"Should filter out null, numbers, and booleans, keeping only strings"
);
}
#[test]
fn test_fingerprint_metadata_empty_strings() {
let metadata = FingerprintMetadata {
source: "".to_string(),
version: "".to_string(),
last_updated: SystemTime::now(),
};
let json = serde_json::to_string(&metadata).expect("Failed to serialize");
let deserialized: FingerprintMetadata =
serde_json::from_str(&json).expect("Failed to deserialize");
assert_eq!(deserialized.source, "");
assert_eq!(deserialized.version, "");
}
#[test]
fn test_category_deserialize_empty_name() {
let json = r#"{
"name": ""
}"#;
let cat: Category = serde_json::from_str(json).expect("Failed to deserialize");
assert_eq!(cat.name, "");
}
#[test]
fn test_technology_deserialize_all_empty() {
let json = r#"{
"cats": [],
"website": "",
"headers": {},
"cookies": {},
"meta": {},
"script": [],
"html": [],
"url": [],
"js": {},
"implies": [],
"excludes": []
}"#;
let tech: Technology = serde_json::from_str(json).expect("Failed to deserialize");
assert!(tech.cats.is_empty());
assert!(tech.website.is_empty());
assert!(tech.headers.is_empty());
assert!(tech.cookies.is_empty());
assert!(tech.meta.is_empty());
assert!(tech.script.is_empty());
assert!(tech.scripts.is_empty());
assert!(tech.html.is_empty());
assert!(tech.url.is_empty());
assert!(tech.dns.is_empty());
assert!(tech.cert_issuer.is_empty());
assert!(tech.js.is_empty());
assert!(tech.implies.is_empty());
assert!(tech.excludes.is_empty());
assert!(tech.requires.is_empty());
assert!(tech.requires_category.is_empty());
}
}