Skip to main content

cmtraceopen_parser/parser/
patchmypc_detection.rs

1//! PatchMyPC detection/requirement script log parser.
2//!
3//! Parses tilde-delimited detection script log lines:
4//!   MM/DD/YYYY HH:MM:SS~[AppName Version]~[Found:True|False]~[Purpose:Detection|Requirement]~[Context:HOST$)]~[Hive:...]
5//!
6//! These files are typically UTF-16LE encoded; the encoding layer handles
7//! decoding before lines reach this parser.
8
9use regex::Regex;
10use std::sync::OnceLock;
11
12use crate::models::log_entry::{LogEntry, LogFormat, Severity};
13
14/// Regex matching PatchMyPC detection log lines.
15/// Groups: timestamp, app_info, found_status, purpose, context, hive
16fn detection_re() -> &'static Regex {
17    static CELL: OnceLock<Regex> = OnceLock::new();
18    CELL.get_or_init(|| {
19        Regex::new(concat!(
20            r"^(\d{2}/\d{2}/\d{4}\s+\d{2}:\d{2}:\d{2})", // timestamp
21            r"~\[([^\]]*)\]",                            // ~[app info]
22            r"~\[Found:(True|False)\]",                  // ~[Found:T/F]
23            r"~\[Purpose:([^\]]*)\]",                    // ~[Purpose:...]
24            r"(?:~\[Context:([^\]]*)\])?",               // ~[Context:...] (optional)
25            r"(?:~\[Hive:([^\]]*)\])?",                  // ~[Hive:...] (optional)
26        ))
27        .expect("PatchMyPC detection regex must compile")
28    })
29}
30
31/// Check if a line matches the PatchMyPC detection format (used by detect.rs).
32pub fn matches_patchmypc_detection_record(line: &str) -> bool {
33    detection_re().is_match(line)
34}
35
36/// Parse all lines as PatchMyPC detection/requirement script format.
37pub fn parse_lines(lines: &[&str], file_path: &str) -> (Vec<LogEntry>, u32) {
38    let mut entries = Vec::with_capacity(lines.len());
39    let mut parse_errors: u32 = 0;
40    let mut id: u64 = 0;
41
42    for (i, line) in lines.iter().enumerate() {
43        let trimmed = line.trim();
44        if trimmed.is_empty() {
45            continue;
46        }
47
48        if let Some(caps) = detection_re().captures(trimmed) {
49            let ts_str = caps.get(1).unwrap().as_str();
50            let app_info = caps.get(2).unwrap().as_str().to_string();
51            let found = caps.get(3).unwrap().as_str();
52            let purpose = caps.get(4).unwrap().as_str();
53            let context = caps.get(5).map(|m| m.as_str().to_string());
54            let _hive = caps.get(6).map(|m| m.as_str());
55
56            // Found:True → Info, Found:False → Warning
57            let severity = if found == "True" {
58                Severity::Info
59            } else {
60                Severity::Warning
61            };
62
63            // Parse timestamp: MM/DD/YYYY HH:MM:SS
64            let timestamp = chrono::NaiveDateTime::parse_from_str(ts_str, "%m/%d/%Y %H:%M:%S")
65                .ok()
66                .map(|dt| dt.and_utc().timestamp_millis());
67
68            let timestamp_display = Some(ts_str.to_string());
69
70            // Build a readable message
71            let message = format!("[{}] {} — Found:{}", purpose, app_info, found);
72
73            let component = Some("PatchMyPC".to_string());
74
75            // Extract hostname from context (strip trailing "$)" if present)
76            let host_name = context
77                .as_ref()
78                .map(|c| c.trim_end_matches(')').trim_end_matches('$').to_string());
79
80            entries.push(LogEntry {
81                id,
82                line_number: (i + 1) as u32,
83                message,
84                component,
85                timestamp,
86                timestamp_display,
87                severity,
88                thread: None,
89                thread_display: None,
90                source_file: None,
91                format: LogFormat::Timestamped,
92                file_path: file_path.to_string(),
93                timezone_offset: None,
94                error_code_spans: Vec::new(),
95                ip_address: None,
96                host_name,
97                mac_address: None,
98                result_code: None,
99                gle_code: None,
100                setup_phase: None,
101                operation_name: Some(purpose.to_string()),
102                http_method: None,
103                uri_stem: None,
104                uri_query: None,
105                status_code: None,
106                sub_status: None,
107                time_taken_ms: None,
108                client_ip: None,
109                server_ip: None,
110                user_agent: None,
111                server_port: None,
112                username: None,
113                win32_status: None,
114                query_name: None,
115                query_type: None,
116                response_code: None,
117                dns_direction: None,
118                dns_protocol: None,
119                source_ip: None,
120                dns_flags: None,
121                dns_event_id: None,
122                zone_name: None,
123                entry_kind: None,
124                whatif: None,
125                section_name: None,
126                section_color: None,
127                iteration: None,
128                tags: None,
129            });
130        } else {
131            entries.push(LogEntry {
132                id,
133                line_number: (i + 1) as u32,
134                message: trimmed.to_string(),
135                component: None,
136                timestamp: None,
137                timestamp_display: None,
138                severity: super::severity::detect_severity_from_text(trimmed),
139                thread: None,
140                thread_display: None,
141                source_file: None,
142                format: LogFormat::Plain,
143                file_path: file_path.to_string(),
144                timezone_offset: None,
145                error_code_spans: Vec::new(),
146                ip_address: None,
147                host_name: None,
148                mac_address: None,
149                result_code: None,
150                gle_code: None,
151                setup_phase: None,
152                operation_name: None,
153                http_method: None,
154                uri_stem: None,
155                uri_query: None,
156                status_code: None,
157                sub_status: None,
158                time_taken_ms: None,
159                client_ip: None,
160                server_ip: None,
161                user_agent: None,
162                server_port: None,
163                username: None,
164                win32_status: None,
165                query_name: None,
166                query_type: None,
167                response_code: None,
168                dns_direction: None,
169                dns_protocol: None,
170                source_ip: None,
171                dns_flags: None,
172                dns_event_id: None,
173                zone_name: None,
174                entry_kind: None,
175                whatif: None,
176                section_name: None,
177                section_color: None,
178                iteration: None,
179                tags: None,
180            });
181            parse_errors += 1;
182        }
183        id += 1;
184    }
185
186    (entries, parse_errors)
187}
188
189#[cfg(test)]
190mod tests {
191    use super::*;
192
193    #[test]
194    fn test_matches_detection_record() {
195        assert!(matches_patchmypc_detection_record(
196            r#"04/07/2026 22:57:20~[7-Zip*x64* {23170f69-40c1-2702-2501-000001000000} 25.01]~[Found:False]~[Purpose:Detection]~[Context:GELL-1060D7ABC7$)]~[Hive:HKLM:\software\microsoft\windows\currentversion\uninstall\*]"#
197        ));
198        assert!(!matches_patchmypc_detection_record("Just plain text"));
199        assert!(!matches_patchmypc_detection_record(
200            "<![LOG[some CCM log]LOG]!><time=\"12:00:00\" date=\"01-01-2025\">"
201        ));
202    }
203
204    #[test]
205    fn test_parse_found_false() {
206        let lines = vec![
207            r#"04/07/2026 22:57:20~[7-Zip*x64* {23170f69-40c1-2702-2501-000001000000} 25.01]~[Found:False]~[Purpose:Detection]~[Context:GELL-1060D7ABC7$)]~[Hive:HKLM:\software\microsoft\windows\currentversion\uninstall\*]"#,
208        ];
209        let (entries, errors) = parse_lines(&lines, "test.log");
210        assert_eq!(errors, 0);
211        assert_eq!(entries.len(), 1);
212        assert_eq!(entries[0].severity, Severity::Warning);
213        assert!(entries[0].message.contains("7-Zip"));
214        assert!(entries[0].message.contains("Found:False"));
215        assert_eq!(entries[0].component.as_deref(), Some("PatchMyPC"));
216        assert_eq!(entries[0].host_name.as_deref(), Some("GELL-1060D7ABC7"));
217        assert_eq!(entries[0].operation_name.as_deref(), Some("Detection"));
218        assert!(entries[0].timestamp.is_some());
219    }
220
221    #[test]
222    fn test_parse_found_true() {
223        let lines = vec![
224            r#"04/07/2026 22:58:50~[7-Zip 25.01 (x64 edition) {23170f69-40c1-2702-2501-000001000000}]~[Found:True]~[Purpose:Detection]~[Context:GELL-1060D7ABC7$)]~[Hive:HKLM:\software\microsoft\windows\currentversion\uninstall\*]"#,
225        ];
226        let (entries, errors) = parse_lines(&lines, "test.log");
227        assert_eq!(errors, 0);
228        assert_eq!(entries[0].severity, Severity::Info);
229        assert!(entries[0].message.contains("Found:True"));
230    }
231
232    #[test]
233    fn test_parse_requirement_purpose() {
234        let lines = vec![
235            r#"04/07/2026 23:42:21~[Microsoft OneDrive* 26.032.0217.0003]~[Found:False]~[Purpose:Requirement]~[Context:GELL-1060D7ABC7$)]~[Hive:HKLM:\software\microsoft\windows\currentversion\uninstall\*]"#,
236        ];
237        let (entries, _) = parse_lines(&lines, "test.log");
238        assert_eq!(entries[0].operation_name.as_deref(), Some("Requirement"));
239    }
240}