Skip to main content

cmtraceopen_parser/dsregcmd/
parser.rs

1use 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}