cmtraceopen_parser/dsregcmd/
parser.rs1use regex::Regex;
2
3use crate::dsregcmd::models::DsregcmdFacts;
4use std::sync::OnceLock;
5
6fn field_line_re() -> &'static Regex {
7 static CELL: OnceLock<Regex> = OnceLock::new();
8 CELL.get_or_init(|| {
9 Regex::new(r"(?m)^\s*([^\r\n:=][^\r\n:=]*?)\s*[:=]\s*([^\r\n]*)\s*$")
10 .expect("valid dsregcmd field regex")
11 })
12}
13
14pub fn parse_dsregcmd(input: &str) -> Result<DsregcmdFacts, String> {
15 if input.trim().is_empty() {
16 return Err("dsregcmd input was empty".to_string());
17 }
18
19 let mut facts = DsregcmdFacts::default();
20 let mut recognized_fields = 0usize;
21
22 for captures in field_line_re().captures_iter(input) {
23 let Some(raw_key) = captures.get(1) else {
24 continue;
25 };
26 let Some(raw_value) = captures.get(2) else {
27 continue;
28 };
29
30 let key = normalize_key(raw_key.as_str());
31 let value = raw_value.as_str().trim();
32
33 if apply_field(&mut facts, &key, value) {
34 recognized_fields += 1;
35 }
36 }
37
38 if recognized_fields == 0 {
39 return Err("Input did not contain recognizable dsregcmd /status fields".to_string());
40 }
41
42 Ok(facts)
43}
44
45fn apply_field(facts: &mut DsregcmdFacts, key: &str, value: &str) -> bool {
46 match key {
47 "azureadjoined" => {
48 facts.join_state.azure_ad_joined = parse_bool(value);
49 true
50 }
51 "domainjoined" => {
52 facts.join_state.domain_joined = parse_bool(value);
53 true
54 }
55 "workplacejoined" => {
56 facts.join_state.workplace_joined = parse_bool(value);
57 true
58 }
59 "enterprisejoined" => {
60 facts.join_state.enterprise_joined = parse_bool(value);
61 true
62 }
63 "tenantid" => set_string(&mut facts.tenant_details.tenant_id, value),
64 "tenantname" => set_string(&mut facts.tenant_details.tenant_name, value),
65 "domainname" => set_string(&mut facts.tenant_details.domain_name, value),
66 "deviceid" => set_string(&mut facts.device_details.device_id, value),
67 "thumbprint" => set_string(&mut facts.device_details.thumbprint, value),
68 "devicecertificatevalidity" => {
69 set_string(&mut facts.device_details.device_certificate_validity, value)
70 }
71 "keycontainerid" => set_string(&mut facts.device_details.key_container_id, value),
72 "keyprovider" => set_string(&mut facts.device_details.key_provider, value),
73 "tpmprotected" => {
74 facts.device_details.tpm_protected = parse_bool(value);
75 true
76 }
77 "deviceauthstatus" => set_string(&mut facts.device_details.device_auth_status, value),
78 "mdmurl" => set_string(&mut facts.management_details.mdm_url, value),
79 "mdmcomplianceurl" | "dmcomplianceurl" => {
80 set_string(&mut facts.management_details.mdm_compliance_url, value)
81 }
82 "mdmtouurl" => set_string(&mut facts.management_details.mdm_tou_url, value),
83 "settingsurl" => set_string(&mut facts.management_details.settings_url, value),
84 "devicemanagementsrvver" => set_string(
85 &mut facts.management_details.device_management_srv_ver,
86 value,
87 ),
88 "devicemanagementsrvurl" => set_string(
89 &mut facts.management_details.device_management_srv_url,
90 value,
91 ),
92 "devicemanagementsrvid" => set_string(
93 &mut facts.management_details.device_management_srv_id,
94 value,
95 ),
96 "idp" => set_string(&mut facts.tenant_details.idp, value),
97 "authcodeurl" => set_string(&mut facts.service_endpoints.auth_code_url, value),
98 "accesstokenurl" => set_string(&mut facts.service_endpoints.access_token_url, value),
99 "joinsrvversion" => set_string(&mut facts.service_endpoints.join_srv_version, value),
100 "joinsrvurl" => set_string(&mut facts.service_endpoints.join_srv_url, value),
101 "joinsrvid" => set_string(&mut facts.service_endpoints.join_srv_id, value),
102 "keysrvversion" => set_string(&mut facts.service_endpoints.key_srv_version, value),
103 "keysrvurl" => set_string(&mut facts.service_endpoints.key_srv_url, value),
104 "keysrvid" => set_string(&mut facts.service_endpoints.key_srv_id, value),
105 "webauthnsrvversion" => {
106 set_string(&mut facts.service_endpoints.web_authn_srv_version, value)
107 }
108 "webauthnsrvurl" => set_string(&mut facts.service_endpoints.web_authn_srv_url, value),
109 "webauthnsrvid" => set_string(&mut facts.service_endpoints.web_authn_srv_id, value),
110 "ngcset" => {
111 facts.user_state.ngc_set = parse_bool(value);
112 true
113 }
114 "ngckeyid" => set_string(&mut facts.user_state.ngc_key_id, value),
115 "canreset" => set_string(&mut facts.user_state.can_reset, value),
116 "wamdefaultset" => {
117 facts.user_state.wam_default_set = parse_bool(value);
118 true
119 }
120 "wamdefaultauthority" => set_string(&mut facts.user_state.wam_default_authority, value),
121 "wamdefaultid" => set_string(&mut facts.user_state.wam_default_id, value),
122 "wamdefaultguid" => set_string(&mut facts.user_state.wam_default_guid, value),
123 "isdevicejoined" => {
124 facts.user_state.is_device_joined = parse_bool(value);
125 true
126 }
127 "isuserazuread" => {
128 facts.user_state.is_user_azure_ad = parse_bool(value);
129 true
130 }
131 "policyenabled" => {
132 facts.user_state.policy_enabled = parse_bool(value);
133 true
134 }
135 "postlogonenabled" => {
136 facts.user_state.post_logon_enabled = parse_bool(value);
137 true
138 }
139 "deviceeligible" => {
140 facts.user_state.device_eligible = parse_bool(value);
141 true
142 }
143 "sessionisnotremote" => {
144 facts.user_state.session_is_not_remote = parse_bool(value);
145 true
146 }
147 "azureadprt" => {
148 facts.sso_state.azure_ad_prt = parse_bool(value);
149 true
150 }
151 "azureadprtauthority" => set_string(&mut facts.sso_state.azure_ad_prt_authority, value),
152 "azureadprtupdatetime" => set_string(&mut facts.sso_state.azure_ad_prt_update_time, value),
153 "acquireprtdiagnostics" => set_string(&mut facts.sso_state.acquire_prt_diagnostics, value),
154 "enterpriseprt" => {
155 facts.sso_state.enterprise_prt = parse_bool(value);
156 true
157 }
158 "enterpriseprtupdatetime" => {
159 set_string(&mut facts.sso_state.enterprise_prt_update_time, value)
160 }
161 "enterpriseprtexpirytime" => {
162 set_string(&mut facts.sso_state.enterprise_prt_expiry_time, value)
163 }
164 "enterpriseprtauthority" => {
165 set_string(&mut facts.sso_state.enterprise_prt_authority, value)
166 }
167 "onpremtgt" => {
168 facts.sso_state.on_prem_tgt = parse_bool(value);
169 true
170 }
171 "cloudtgt" => {
172 facts.sso_state.cloud_tgt = parse_bool(value);
173 true
174 }
175 "adfsrefreshtoken" => {
176 facts.sso_state.adfs_refresh_token = parse_bool(value);
177 true
178 }
179 "adfsraisready" => {
180 facts.sso_state.adfs_ra_is_ready = parse_bool(value);
181 true
182 }
183 "kerbtoplevelnames" => set_string(&mut facts.sso_state.kerb_top_level_names, value),
184 "previousprtattempt" => set_string(&mut facts.diagnostics.previous_prt_attempt, value),
185 "attemptstatus" => set_string(&mut facts.diagnostics.attempt_status, value),
186 "useridentity" => set_string(&mut facts.diagnostics.user_identity, value),
187 "credentialtype" => set_string(&mut facts.diagnostics.credential_type, value),
188 "correlationid" => set_string(&mut facts.diagnostics.correlation_id, value),
189 "endpointuri" => set_string(&mut facts.diagnostics.endpoint_uri, value),
190 "httpmethod" => set_string(&mut facts.diagnostics.http_method, value),
191 "httperror" => set_string(&mut facts.diagnostics.http_error, value),
192 "httpstatus" => {
193 facts.diagnostics.http_status = parse_u16(value);
194 true
195 }
196 "requestid" => set_string(&mut facts.diagnostics.request_id, value),
197 "diagnosticsreference" => set_string(&mut facts.diagnostics.diagnostics_reference, value),
198 "usercontext" => set_string(&mut facts.diagnostics.user_context, value),
199 "clienttime" => set_string(&mut facts.diagnostics.client_time, value),
200 "adconnectivitytest" => set_string(&mut facts.pre_join_tests.ad_connectivity_test, value),
201 "adconfigurationtest" => set_string(&mut facts.pre_join_tests.ad_configuration_test, value),
202 "drsdiscoverytest" => set_string(&mut facts.pre_join_tests.drs_discovery_test, value),
203 "drsconnectivitytest" => set_string(&mut facts.pre_join_tests.drs_connectivity_test, value),
204 "tokenacquisitiontest" => {
205 set_string(&mut facts.pre_join_tests.token_acquisition_test, value)
206 }
207 "fallbacktosyncjoin" => set_string(&mut facts.pre_join_tests.fallback_to_sync_join, value),
208 "previousregistration" => set_string(&mut facts.registration.previous_registration, value),
209 "errorphase" => set_string(&mut facts.registration.error_phase, value),
210 "certenrollment" => set_string(&mut facts.registration.cert_enrollment, value),
211 "logoncerttemplateready" => {
212 set_string(&mut facts.registration.logon_cert_template_ready, value)
213 }
214 "prereqresult" => set_string(&mut facts.registration.pre_req_result, value),
215 "clienterrorcode" => set_string(&mut facts.registration.client_error_code, value),
216 "servererrorcode" => set_string(&mut facts.registration.server_error_code, value),
217 "servermessage" => set_string(&mut facts.registration.server_message, value),
218 "servererrordescription" => {
219 set_string(&mut facts.registration.server_error_description, value)
220 }
221 "aadrecoveryenabled" => {
222 facts.post_join_diagnostics.aad_recovery_enabled = parse_bool(value);
223 true
224 }
225 "keysigntest" => set_string(&mut facts.post_join_diagnostics.key_sign_test, value),
226 _ => false,
227 }
228}
229
230fn normalize_key(key: &str) -> String {
231 key.chars()
232 .filter(|character| character.is_ascii_alphanumeric())
233 .map(|character| character.to_ascii_lowercase())
234 .collect()
235}
236
237fn normalize_absent(value: &str) -> Option<String> {
238 let trimmed = value.trim();
239 if trimmed.is_empty() {
240 return None;
241 }
242
243 if trimmed == "-" || trimmed.eq_ignore_ascii_case("n/a") {
244 return None;
245 }
246
247 Some(trimmed.to_string())
248}
249
250fn set_string(slot: &mut Option<String>, value: &str) -> bool {
251 *slot = normalize_absent(value);
252 true
253}
254
255fn parse_bool(value: &str) -> Option<bool> {
256 match value.trim().to_ascii_lowercase().as_str() {
257 "yes" | "true" | "1" => Some(true),
258 "no" | "false" | "0" => Some(false),
259 _ => None,
260 }
261}
262
263fn parse_u16(value: &str) -> Option<u16> {
264 value.trim().parse::<u16>().ok()
265}
266
267#[cfg(test)]
268mod tests {
269 use super::parse_dsregcmd;
270
271 const SAMPLE: &str = r#"
272+----------------------------------------------------------------------+
273| Device State |
274+----------------------------------------------------------------------+
275 AzureAdJoined : YES
276 DomainJoined = NO
277 WorkplaceJoined : NO
278 EnterpriseJoined : NO
279 TenantId : 11111111-2222-3333-4444-555555555555
280 DeviceId : abcdefab-1111-2222-3333-abcdefabcdef
281 MdmUrl : https://enrollment.manage.microsoft.com/enrollmentserver/discovery.svc
282 dmComplianceUrl : https://portal.manage.microsoft.com/Compliance
283 AzureAdPrt : YES
284 AzureAdPrtUpdateTime : 2025-03-10 10:00:00.000 UTC
285 Previous Prt Attempt : 2025-03-10 09:55:00.000 UTC
286 Attempt Status : 0xc000006d
287 HTTP status : 401
288 User Context : SYSTEM
289 SessionIsNotRemote : NO
290 AD Connectivity Test : PASS
291 DRS Discovery Test : FAIL [0x801c0021]
292 Client ErrorCode : 0x801c03f2
293 KeySignTest : PASSED
294 AadRecoveryEnabled : NO
295 DeviceCertificateValidity : [ 2025-03-01 00:00:00.000 UTC -- 2025-03-20 00:00:00.000 UTC ]
296"#;
297
298 #[test]
299 fn parses_high_value_fields_and_fallback_names() {
300 let facts = parse_dsregcmd(SAMPLE).expect("parse sample dsregcmd");
301
302 assert_eq!(facts.join_state.azure_ad_joined, Some(true));
303 assert_eq!(facts.join_state.domain_joined, Some(false));
304 assert_eq!(
305 facts.management_details.mdm_compliance_url.as_deref(),
306 Some("https://portal.manage.microsoft.com/Compliance")
307 );
308 assert_eq!(facts.diagnostics.http_status, Some(401));
309 assert_eq!(facts.diagnostics.user_context.as_deref(), Some("SYSTEM"));
310 assert_eq!(facts.user_state.session_is_not_remote, Some(false));
311 assert_eq!(
312 facts.pre_join_tests.drs_discovery_test.as_deref(),
313 Some("FAIL [0x801c0021]")
314 );
315 assert_eq!(
316 facts.registration.client_error_code.as_deref(),
317 Some("0x801c03f2")
318 );
319 assert_eq!(
320 facts.post_join_diagnostics.key_sign_test.as_deref(),
321 Some("PASSED")
322 );
323 assert_eq!(
324 facts.post_join_diagnostics.aad_recovery_enabled,
325 Some(false)
326 );
327 }
328
329 #[test]
330 fn rejects_non_dsregcmd_input() {
331 let error = parse_dsregcmd("totally unrelated text").expect_err("expected parse error");
332 assert!(error.to_string().contains("recognizable dsregcmd"));
333 }
334
335 #[test]
336 fn treats_placeholder_values_as_absent() {
337 let facts = parse_dsregcmd("MdmUrl : -\nTenantName : n/a\nAzureAdJoined : YES")
338 .expect("parse placeholder sample");
339
340 assert_eq!(facts.management_details.mdm_url, None);
341 assert_eq!(facts.tenant_details.tenant_name, None);
342 assert_eq!(facts.join_state.azure_ad_joined, Some(true));
343 }
344}