use crate::types::StringAnalysis;
use jsxbin_parser::types::Token;
use log::{debug, trace};
use regex::Regex;
use std::collections::HashMap;
pub struct StringExtractor {
path_regex: Regex,
url_regex: Regex,
email_regex: Regex,
}
impl StringExtractor {
pub fn new() -> Self {
StringExtractor {
path_regex: Regex::new(r#"[/\\][\w./\\-]+"#).unwrap(),
url_regex: Regex::new(r#"https?://[^\s]+"#).unwrap(),
email_regex: Regex::new(r#"[\w\.-]+@[\w\.-]+\.\w+"#).unwrap(),
}
}
pub fn extract_from_tokens(&self, tokens: &[Token]) -> Vec<StringAnalysis> {
debug!("Extracting strings from tokens");
let mut strings = HashMap::new();
for token in tokens {
if let Token::StringLiteral(s) = token {
trace!("Found string: {}", s);
strings
.entry(s.clone())
.and_modify(|count| *count += 1)
.or_insert(1);
}
}
let mut result: Vec<StringAnalysis> = strings
.into_iter()
.map(|(value, count)| {
let is_path = self.path_regex.is_match(&value);
let is_url = self.url_regex.is_match(&value);
let is_email = self.email_regex.is_match(&value);
StringAnalysis {
length: value.len(),
count,
is_path,
is_url,
is_email,
value,
}
})
.collect();
result.sort_by_key(|s| std::cmp::Reverse(s.count));
debug!("Extracted {} unique strings", result.len());
result
}
pub fn filter_suspicious<'a>(&self, strings: &'a [StringAnalysis]) -> Vec<&'a StringAnalysis> {
strings
.iter()
.filter(|s| {
s.value.contains("password")
|| s.value.contains("api_key")
|| s.value.contains("token")
|| s.value.contains("secret")
})
.collect()
}
pub fn categorize<'a>(
&self,
strings: &'a [StringAnalysis],
) -> (Vec<&'a StringAnalysis>, Vec<&'a StringAnalysis>, Vec<&'a StringAnalysis>) {
let paths = strings.iter().filter(|s| s.is_path).collect();
let urls = strings.iter().filter(|s| s.is_url).collect();
let emails = strings.iter().filter(|s| s.is_email).collect();
(paths, urls, emails)
}
}
impl Default for StringExtractor {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_extract_strings() {
let extractor = StringExtractor::new();
let tokens = vec![
Token::StringLiteral("hello".to_string()),
Token::StringLiteral("world".to_string()),
Token::StringLiteral("hello".to_string()),
];
let strings = extractor.extract_from_tokens(&tokens);
assert_eq!(strings.len(), 2);
let hello = strings.iter().find(|s| s.value == "hello").unwrap();
assert_eq!(hello.count, 2);
}
#[test]
fn test_detect_paths() {
let extractor = StringExtractor::new();
let tokens = vec![
Token::StringLiteral("/home/user/file.jsx".to_string()),
Token::StringLiteral("C:\\Users\\file.jsx".to_string()),
];
let strings = extractor.extract_from_tokens(&tokens);
assert!(strings.iter().all(|s| s.is_path));
}
#[test]
fn test_detect_urls() {
let extractor = StringExtractor::new();
let tokens = vec![
Token::StringLiteral("https://example.com".to_string()),
Token::StringLiteral("http://api.example.com".to_string()),
];
let strings = extractor.extract_from_tokens(&tokens);
assert!(strings.iter().all(|s| s.is_url));
}
#[test]
fn test_filter_suspicious() {
let extractor = StringExtractor::new();
let strings = vec![
StringAnalysis {
value: "password123".to_string(),
length: 11,
count: 1,
is_path: false,
is_url: false,
is_email: false,
},
StringAnalysis {
value: "normal_string".to_string(),
length: 12,
count: 1,
is_path: false,
is_url: false,
is_email: false,
},
];
let suspicious = extractor.filter_suspicious(&strings);
assert_eq!(suspicious.len(), 1);
}
}