Skip to main content

cmtraceopen_parser/parser/
secureboot_log.rs

1//! Secure Boot certificate update log parser.
2//!
3//! Parses log lines in the format:
4//!   YYYY-MM-DD HH:MM:SS [SCRIPTNAME] [LEVEL] Message
5//!
6//! Where LEVEL is one of: INFO, WARNING, ERROR, SUCCESS, SYSTEM.
7//!
8//! Examples:
9//!   2026-04-07 11:25:47 [DETECT] [INFO] ========== DETECTION STARTED ==========
10//!   2026-04-07 11:25:48 [DETECT] [WARNING] MicrosoftUpdateManagedOptIn is NOT SET
11//!   2026-04-07 11:25:48 [DETECT] [SUCCESS] Secure Boot is ENABLED
12
13use regex::Regex;
14
15use crate::models::log_entry::{LogEntry, LogFormat, Severity};
16use std::sync::OnceLock;
17
18/// Regex matching the SecureBoot certificate update log format.
19/// Groups: timestamp, script_name, level, message
20fn secureboot_log_re() -> &'static Regex {
21    static CELL: OnceLock<Regex> = OnceLock::new();
22    CELL.get_or_init(|| {
23        Regex::new(concat!(
24            r"^(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})",   // timestamp
25            r" \[(\w+)\]",                               // [SCRIPTNAME]
26            r" \[(INFO|WARNING|ERROR|SUCCESS|SYSTEM)\]", // [LEVEL]
27            r" (.*)",                                    // message
28        ))
29        .expect("SecureBoot log regex must compile")
30    })
31}
32
33/// Check if a line matches the SecureBoot certificate update log format.
34pub fn matches_secureboot_log_record(line: &str) -> bool {
35    secureboot_log_re().is_match(line)
36}
37
38fn severity_from_level(level: &str) -> Severity {
39    match level {
40        "ERROR" => Severity::Error,
41        "WARNING" => Severity::Warning,
42        _ => Severity::Info,
43    }
44}
45
46/// Parse all lines as SecureBoot certificate update log format.
47pub fn parse_lines(lines: &[&str], file_path: &str) -> (Vec<LogEntry>, u32) {
48    let mut entries = Vec::with_capacity(lines.len());
49    let mut parse_errors: u32 = 0;
50    let mut id: u64 = 0;
51
52    for (i, line) in lines.iter().enumerate() {
53        let trimmed = line.trim();
54        if trimmed.is_empty() {
55            continue;
56        }
57
58        if let Some(caps) = secureboot_log_re().captures(trimmed) {
59            let ts_str = caps.get(1).unwrap().as_str();
60            let script_name = caps.get(2).unwrap().as_str();
61            let level = caps.get(3).unwrap().as_str();
62            let message = caps
63                .get(4)
64                .map(|m| m.as_str().to_string())
65                .unwrap_or_default();
66
67            let severity = severity_from_level(level);
68
69            let timestamp = chrono::NaiveDateTime::parse_from_str(ts_str, "%Y-%m-%d %H:%M:%S")
70                .ok()
71                .map(|dt| dt.and_utc().timestamp_millis());
72
73            let timestamp_display = Some(format!("{}.000", ts_str));
74
75            entries.push(LogEntry {
76                id,
77                line_number: (i + 1) as u32,
78                message,
79                component: Some(script_name.to_string()),
80                timestamp,
81                timestamp_display,
82                severity,
83                thread: None,
84                thread_display: None,
85                source_file: None,
86                format: LogFormat::Timestamped,
87                file_path: file_path.to_string(),
88                timezone_offset: None,
89                error_code_spans: Vec::new(),
90                ip_address: None,
91                host_name: None,
92                mac_address: None,
93                result_code: None,
94                gle_code: None,
95                setup_phase: None,
96                operation_name: None,
97                http_method: None,
98                uri_stem: None,
99                uri_query: None,
100                status_code: None,
101                sub_status: None,
102                time_taken_ms: None,
103                client_ip: None,
104                server_ip: None,
105                user_agent: None,
106                server_port: None,
107                username: None,
108                win32_status: None,
109                query_name: None,
110                query_type: None,
111                response_code: None,
112                dns_direction: None,
113                dns_protocol: None,
114                source_ip: None,
115                dns_flags: None,
116                dns_event_id: None,
117                zone_name: None,
118                entry_kind: None,
119                whatif: None,
120                section_name: None,
121                section_color: None,
122                iteration: None,
123                tags: None,
124            });
125        } else {
126            // Non-matching line — plain text fallback
127            entries.push(LogEntry {
128                id,
129                line_number: (i + 1) as u32,
130                message: trimmed.to_string(),
131                component: None,
132                timestamp: None,
133                timestamp_display: None,
134                severity: super::severity::detect_severity_from_text(trimmed),
135                thread: None,
136                thread_display: None,
137                source_file: None,
138                format: LogFormat::Plain,
139                file_path: file_path.to_string(),
140                timezone_offset: None,
141                error_code_spans: Vec::new(),
142                ip_address: None,
143                host_name: None,
144                mac_address: None,
145                result_code: None,
146                gle_code: None,
147                setup_phase: None,
148                operation_name: None,
149                http_method: None,
150                uri_stem: None,
151                uri_query: None,
152                status_code: None,
153                sub_status: None,
154                time_taken_ms: None,
155                client_ip: None,
156                server_ip: None,
157                user_agent: None,
158                server_port: None,
159                username: None,
160                win32_status: None,
161                query_name: None,
162                query_type: None,
163                response_code: None,
164                dns_direction: None,
165                dns_protocol: None,
166                source_ip: None,
167                dns_flags: None,
168                dns_event_id: None,
169                zone_name: None,
170                entry_kind: None,
171                whatif: None,
172                section_name: None,
173                section_color: None,
174                iteration: None,
175                tags: None,
176            });
177            parse_errors += 1;
178        }
179        id += 1;
180    }
181
182    (entries, parse_errors)
183}
184
185#[cfg(test)]
186mod tests {
187    use super::*;
188
189    #[test]
190    fn test_parse_info_line() {
191        let lines =
192            vec!["2026-04-07 11:25:47 [DETECT] [INFO] ========== DETECTION STARTED =========="];
193        let (entries, errors) = parse_lines(&lines, "SecureBootCertificateUpdate.log");
194        assert_eq!(errors, 0);
195        assert_eq!(entries.len(), 1);
196        assert_eq!(entries[0].severity, Severity::Info);
197        assert_eq!(entries[0].component.as_deref(), Some("DETECT"));
198        assert!(entries[0].message.contains("DETECTION STARTED"));
199        assert_eq!(
200            entries[0].timestamp_display.as_deref(),
201            Some("2026-04-07 11:25:47.000")
202        );
203    }
204
205    #[test]
206    fn test_parse_warning_line() {
207        let lines = vec![
208            "2026-04-07 11:25:48 [DETECT] [WARNING] MicrosoftUpdateManagedOptIn is NOT SET or 0",
209        ];
210        let (entries, errors) = parse_lines(&lines, "SecureBootCertificateUpdate.log");
211        assert_eq!(errors, 0);
212        assert_eq!(entries[0].severity, Severity::Warning);
213        assert_eq!(entries[0].component.as_deref(), Some("DETECT"));
214    }
215
216    #[test]
217    fn test_parse_success_line() {
218        let lines = vec!["2026-04-07 11:25:48 [DETECT] [SUCCESS] Secure Boot is ENABLED"];
219        let (entries, errors) = parse_lines(&lines, "SecureBootCertificateUpdate.log");
220        assert_eq!(errors, 0);
221        assert_eq!(entries[0].severity, Severity::Info);
222        assert_eq!(entries[0].component.as_deref(), Some("DETECT"));
223    }
224
225    #[test]
226    fn test_parse_error_line() {
227        let lines = vec!["2026-04-07 11:25:48 [REMEDIATE] [ERROR] Failed to set registry value"];
228        let (entries, errors) = parse_lines(&lines, "SecureBootCertificateUpdate.log");
229        assert_eq!(errors, 0);
230        assert_eq!(entries[0].severity, Severity::Error);
231        assert_eq!(entries[0].component.as_deref(), Some("REMEDIATE"));
232    }
233
234    #[test]
235    fn test_matches_secureboot_log_record() {
236        assert!(matches_secureboot_log_record(
237            "2026-04-07 11:25:47 [DETECT] [INFO] test"
238        ));
239        assert!(matches_secureboot_log_record(
240            "2026-04-07 11:25:48 [SYSTEM] [WARNING] test"
241        ));
242        assert!(!matches_secureboot_log_record("Just plain text"));
243        assert!(!matches_secureboot_log_record(
244            "2024-01-15 14:30:00 some generic timestamped line"
245        ));
246    }
247
248    #[test]
249    fn test_parse_multiple_lines() {
250        let lines = vec![
251            "2026-04-07 11:25:47 [DETECT] [INFO] Script Version: 4.0",
252            "2026-04-07 11:25:48 [DETECT] [SUCCESS] Secure Boot is ENABLED",
253            "2026-04-07 11:25:48 [DETECT] [WARNING] MicrosoftUpdateManagedOptIn is NOT SET",
254            "2026-04-07 11:25:48 [DETECT] [INFO] Detection Result: NON-COMPLIANT",
255        ];
256        let (entries, errors) = parse_lines(&lines, "SecureBootCertificateUpdate.log");
257        assert_eq!(errors, 0);
258        assert_eq!(entries.len(), 4);
259        assert_eq!(entries[0].severity, Severity::Info);
260        assert_eq!(entries[1].severity, Severity::Info);
261        assert_eq!(entries[2].severity, Severity::Warning);
262        assert_eq!(entries[3].severity, Severity::Info);
263    }
264}