Skip to main content

jsxbin_analyzer/
string_extractor.rs

1use crate::types::StringAnalysis;
2use jsxbin_parser::types::Token;
3use log::{debug, trace};
4use regex::Regex;
5use std::collections::HashMap;
6
7/// Extracts and analyzes string literals from code
8pub struct StringExtractor {
9    path_regex: Regex,
10    url_regex: Regex,
11    email_regex: Regex,
12}
13
14impl StringExtractor {
15    /// Create a new string extractor
16    pub fn new() -> Self {
17        StringExtractor {
18            // Matches file paths: /path/to/file or C:\path\to\file
19            path_regex: Regex::new(r#"[/\\][\w./\\-]+"#).unwrap(),
20
21            // Matches URLs: http://... or https://...
22            url_regex: Regex::new(r#"https?://[^\s]+"#).unwrap(),
23
24            // Matches email addresses
25            email_regex: Regex::new(r#"[\w\.-]+@[\w\.-]+\.\w+"#).unwrap(),
26        }
27    }
28
29    /// Extract strings from tokens
30    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    /// Filter strings by criteria
68    pub fn filter_suspicious<'a>(&self, strings: &'a [StringAnalysis]) -> Vec<&'a StringAnalysis> {
69        strings
70            .iter()
71            .filter(|s| {
72                // Consider strings suspicious if they contain credentials patterns
73                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    /// Categorize strings
82    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}