jsxbin_analyzer/
string_extractor.rs1use crate::types::StringAnalysis;
2use jsxbin_parser::types::Token;
3use log::{debug, trace};
4use regex::Regex;
5use std::collections::HashMap;
6
7pub struct StringExtractor {
9 path_regex: Regex,
10 url_regex: Regex,
11 email_regex: Regex,
12}
13
14impl StringExtractor {
15 pub fn new() -> Self {
17 StringExtractor {
18 path_regex: Regex::new(r#"[/\\][\w./\\-]+"#).unwrap(),
20
21 url_regex: Regex::new(r#"https?://[^\s]+"#).unwrap(),
23
24 email_regex: Regex::new(r#"[\w\.-]+@[\w\.-]+\.\w+"#).unwrap(),
26 }
27 }
28
29 pub fn extract_from_tokens(&self, tokens: &[Token]) -> Vec<StringAnalysis> {
31 debug!("Extracting strings from tokens");
32 let mut strings = HashMap::new();
33
34 for token in tokens {
35 if let Token::StringLiteral(s) = token {
36 trace!("Found string: {}", s);
37 strings
38 .entry(s.clone())
39 .and_modify(|count| *count += 1)
40 .or_insert(1);
41 }
42 }
43
44 let mut result: Vec<StringAnalysis> = strings
45 .into_iter()
46 .map(|(value, count)| {
47 let is_path = self.path_regex.is_match(&value);
48 let is_url = self.url_regex.is_match(&value);
49 let is_email = self.email_regex.is_match(&value);
50
51 StringAnalysis {
52 length: value.len(),
53 count,
54 is_path,
55 is_url,
56 is_email,
57 value,
58 }
59 })
60 .collect();
61
62 result.sort_by_key(|s| std::cmp::Reverse(s.count));
63 debug!("Extracted {} unique strings", result.len());
64 result
65 }
66
67 pub fn filter_suspicious<'a>(&self, strings: &'a [StringAnalysis]) -> Vec<&'a StringAnalysis> {
69 strings
70 .iter()
71 .filter(|s| {
72 s.value.contains("password")
74 || s.value.contains("api_key")
75 || s.value.contains("token")
76 || s.value.contains("secret")
77 })
78 .collect()
79 }
80
81 pub fn categorize<'a>(
83 &self,
84 strings: &'a [StringAnalysis],
85 ) -> (Vec<&'a StringAnalysis>, Vec<&'a StringAnalysis>, Vec<&'a StringAnalysis>) {
86 let paths = strings.iter().filter(|s| s.is_path).collect();
87 let urls = strings.iter().filter(|s| s.is_url).collect();
88 let emails = strings.iter().filter(|s| s.is_email).collect();
89 (paths, urls, emails)
90 }
91}
92
93impl Default for StringExtractor {
94 fn default() -> Self {
95 Self::new()
96 }
97}
98
99#[cfg(test)]
100mod tests {
101 use super::*;
102
103 #[test]
104 fn test_extract_strings() {
105 let extractor = StringExtractor::new();
106 let tokens = vec![
107 Token::StringLiteral("hello".to_string()),
108 Token::StringLiteral("world".to_string()),
109 Token::StringLiteral("hello".to_string()),
110 ];
111
112 let strings = extractor.extract_from_tokens(&tokens);
113 assert_eq!(strings.len(), 2);
114
115 let hello = strings.iter().find(|s| s.value == "hello").unwrap();
116 assert_eq!(hello.count, 2);
117 }
118
119 #[test]
120 fn test_detect_paths() {
121 let extractor = StringExtractor::new();
122 let tokens = vec![
123 Token::StringLiteral("/home/user/file.jsx".to_string()),
124 Token::StringLiteral("C:\\Users\\file.jsx".to_string()),
125 ];
126
127 let strings = extractor.extract_from_tokens(&tokens);
128 assert!(strings.iter().all(|s| s.is_path));
129 }
130
131 #[test]
132 fn test_detect_urls() {
133 let extractor = StringExtractor::new();
134 let tokens = vec![
135 Token::StringLiteral("https://example.com".to_string()),
136 Token::StringLiteral("http://api.example.com".to_string()),
137 ];
138
139 let strings = extractor.extract_from_tokens(&tokens);
140 assert!(strings.iter().all(|s| s.is_url));
141 }
142
143 #[test]
144 fn test_filter_suspicious() {
145 let extractor = StringExtractor::new();
146 let strings = vec![
147 StringAnalysis {
148 value: "password123".to_string(),
149 length: 11,
150 count: 1,
151 is_path: false,
152 is_url: false,
153 is_email: false,
154 },
155 StringAnalysis {
156 value: "normal_string".to_string(),
157 length: 12,
158 count: 1,
159 is_path: false,
160 is_url: false,
161 is_email: false,
162 },
163 ];
164
165 let suspicious = extractor.filter_suspicious(&strings);
166 assert_eq!(suspicious.len(), 1);
167 }
168}