cmtraceopen_parser/parser/
secureboot_log.rs1use regex::Regex;
14
15use crate::models::log_entry::{LogEntry, LogFormat, Severity};
16use std::sync::OnceLock;
17
18fn 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})", r" \[(\w+)\]", r" \[(INFO|WARNING|ERROR|SUCCESS|SYSTEM)\]", r" (.*)", ))
29 .expect("SecureBoot log regex must compile")
30 })
31}
32
33pub 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
46pub 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 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}