structured_webauthn/request/auth/ser.rs
1#[cfg(test)]
2mod tests;
3use super::{
4 super::{super::response::ser::Null, ser::PrfHelper},
5 AllowedCredential, AllowedCredentials, Challenge, CredentialMediationRequirement,
6 CredentialUiMode, Credentials as _, DiscoverableAuthenticationClientState,
7 DiscoverableCredentialRequestOptions, Extension, ExtensionReq, FIVE_MINUTES, Hints,
8 NonDiscoverableAuthenticationClientState, NonDiscoverableCredentialRequestOptions, PrfInput,
9 PrfInputOwned, PublicKeyCredentialRequestOptions, RpId, UserVerificationRequirement,
10};
11use core::{
12 error::Error as E,
13 fmt::{self, Display, Formatter},
14 num::NonZeroU32,
15};
16use serde::{
17 de::{Deserialize, Deserializer, Error, MapAccess, Unexpected, Visitor},
18 ser::{Serialize, SerializeMap as _, SerializeStruct as _, Serializer},
19};
20/// `"immediate"`.
21const IMMEDIATE: &str = "immediate";
22impl Serialize for CredentialUiMode {
23 /// Serializes `self` as a [`prim@str`] conforming with
24 /// [`CredentialUiMode`](https://www.w3.org/TR/credential-management-1/#enumdef-credentialuimode).
25 ///
26 /// # Examples
27 ///
28 /// ```
29 /// # use structured_webauthn::request::auth::CredentialUiMode;
30 /// assert_eq!(
31 /// serde_json::to_string(&CredentialUiMode::Immediate)?,
32 /// r#""immediate""#
33 /// );
34 /// # Ok::<_, serde_json::Error>(())
35 /// ```
36 #[inline]
37 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
38 where
39 S: Serializer,
40 {
41 serializer.serialize_str(IMMEDIATE)
42 }
43}
44impl Serialize for PrfInputOwned {
45 /// See [`PrfInput::serialize`]
46 #[inline]
47 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
48 where
49 S: Serializer,
50 {
51 PrfInput {
52 first: self.first.as_slice(),
53 second: self.second.as_deref(),
54 }
55 .serialize(serializer)
56 }
57}
58impl Serialize for AllowedCredential {
59 /// Serializes `self` to conform with
60 /// [`PublicKeyCredentialDescriptorJSON`](https://www.w3.org/TR/webauthn-3/#dictdef-publickeycredentialdescriptorjson).
61 ///
62 /// # Examples
63 ///
64 /// ```
65 /// # #[cfg(all(feature = "bin", feature = "custom"))]
66 /// # use structured_webauthn::{bin::Decode, response::bin::DecodeAuthTransportsErr};
67 /// # use structured_webauthn::{
68 /// # request::{auth::AllowedCredential, PublicKeyCredentialDescriptor},
69 /// # response::{AuthTransports, CredentialId},
70 /// # };
71 /// /// Retrieves the `AuthTransports` associated with the unique `cred_id`
72 /// /// from the database.
73 /// # #[cfg(all(feature = "bin", feature = "custom"))]
74 /// fn get_transports(cred_id: CredentialId<&[u8]>) -> Result<AuthTransports, DecodeAuthTransportsErr> {
75 /// // ⋮
76 /// # AuthTransports::decode(32)
77 /// }
78 /// // `CredentialId::try_from` only exists when `custom` is enabled; and even then, it is
79 /// // likely never needed since the `CredentialId` was originally sent from the client and is likely
80 /// // stored in a database which would be fetched by `UserHandle` or `Authentication::raw_id`.
81 /// # #[cfg(all(feature = "bin", feature = "custom"))]
82 /// let id = CredentialId::try_from(vec![0; 16].into_boxed_slice())?;
83 /// # #[cfg(all(feature = "bin", feature = "custom"))]
84 /// let transports = get_transports((&id).into())?;
85 /// # #[cfg(all(feature = "bin", feature = "custom"))]
86 /// assert_eq!(
87 /// serde_json::to_string(&AllowedCredential::from(PublicKeyCredentialDescriptor {
88 /// id,
89 /// transports
90 /// })).unwrap(),
91 /// r#"{"type":"public-key","id":"AAAAAAAAAAAAAAAAAAAAAA","transports":["usb"]}"#
92 /// );
93 /// # Ok::<_, structured_webauthn::AggErr>(())
94 /// ```
95 #[inline]
96 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
97 where
98 S: Serializer,
99 {
100 self.credential.serialize(serializer)
101 }
102}
103impl Serialize for AllowedCredentials {
104 /// Serializes `self` to conform with
105 /// [`allowCredentials`](https://www.w3.org/TR/webauthn-3/#dom-publickeycredentialrequestoptionsjson-allowcredentials).
106 ///
107 /// # Examples
108 ///
109 /// ```
110 /// # #[cfg(all(feature = "bin", feature = "custom"))]
111 /// # use structured_webauthn::{bin::Decode, response::bin::DecodeAuthTransportsErr};
112 /// # use structured_webauthn::{
113 /// # request::{auth::AllowedCredentials, PublicKeyCredentialDescriptor, Credentials},
114 /// # response::{AuthTransports, CredentialId},
115 /// # };
116 /// /// Retrieves the `AuthTransports` associated with the unique `cred_id`
117 /// /// from the database.
118 /// # #[cfg(all(feature = "bin", feature = "custom"))]
119 /// fn get_transports(cred_id: CredentialId<&[u8]>) -> Result<AuthTransports, DecodeAuthTransportsErr> {
120 /// // ⋮
121 /// # AuthTransports::decode(32)
122 /// }
123 /// // `CredentialId::try_from` only exists when `custom` is enabled; and even then, it is
124 /// // likely never needed since the `CredentialId` was originally sent from the client and is likely
125 /// // stored in a database which would be fetched by `UserHandle` or `Authentication::raw_id`.
126 /// # #[cfg(all(feature = "bin", feature = "custom"))]
127 /// let id = CredentialId::try_from(vec![0; 16].into_boxed_slice())?;
128 /// # #[cfg(all(feature = "bin", feature = "custom"))]
129 /// let transports = get_transports((&id).into())?;
130 /// let mut creds = AllowedCredentials::with_capacity(1);
131 /// # #[cfg(all(feature = "bin", feature = "custom"))]
132 /// creds.push(PublicKeyCredentialDescriptor { id, transports }.into());
133 /// # #[cfg(all(feature = "bin", feature = "custom"))]
134 /// assert_eq!(
135 /// serde_json::to_string(&creds).unwrap(),
136 /// r#"[{"type":"public-key","id":"AAAAAAAAAAAAAAAAAAAAAA","transports":["usb"]}]"#
137 /// );
138 /// # Ok::<_, structured_webauthn::AggErr>(())
139 /// ```
140 #[inline]
141 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
142 where
143 S: Serializer,
144 {
145 self.creds.serialize(serializer)
146 }
147}
148/// [`evalByCredential`](https://www.w3.org/TR/webauthn-3/#dom-authenticationextensionsprfinputs-evalbycredential).
149struct PrfCreds<'a>(&'a AllowedCredentials);
150impl Serialize for PrfCreds<'_> {
151 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
152 where
153 S: Serializer,
154 {
155 serializer
156 .serialize_map(Some(self.0.prf_count))
157 .and_then(|mut ser| {
158 self.0
159 .creds
160 .iter()
161 .try_fold((), |(), cred| {
162 cred.extension.prf.as_ref().map_or(Ok(()), |input| {
163 ser.serialize_entry(&cred.credential.id, input)
164 })
165 })
166 .and_then(|()| ser.end())
167 })
168 }
169}
170/// [`AuthenticationExtensionsPRFInputs`](https://www.w3.org/TR/webauthn-3/#dictdef-authenticationextensionsprfinputs).
171struct PrfInputs<'a, 'b, 'c> {
172 /// [`eval`](https://www.w3.org/TR/webauthn-3/#dom-authenticationextensionsprfinputs-eval).
173 eval: Option<PrfInput<'a, 'b>>,
174 /// [`evalByCredential`](https://www.w3.org/TR/webauthn-3/#dom-authenticationextensionsprfinputs-evalbycredential).
175 eval_by_credential: PrfCreds<'c>,
176}
177impl Serialize for PrfInputs<'_, '_, '_> {
178 #[expect(
179 clippy::arithmetic_side_effects,
180 reason = "comment explains how overflow is not possible"
181 )]
182 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
183 where
184 S: Serializer,
185 {
186 serializer
187 .serialize_struct(
188 "PrfInputs",
189 // The max is 1 + 1 = 2, so overflow is not an issue.
190 usize::from(self.eval.is_some())
191 + usize::from(self.eval_by_credential.0.prf_count > 0),
192 )
193 .and_then(|mut ser| {
194 self.eval
195 .map_or(Ok(()), |eval| ser.serialize_field("eval", &eval))
196 .and_then(|()| {
197 if self.eval_by_credential.0.prf_count == 0 {
198 Ok(())
199 } else {
200 ser.serialize_field("evalByCredential", &self.eval_by_credential)
201 }
202 })
203 .and_then(|()| ser.end())
204 })
205 }
206}
207/// Serializes `self` to conform with
208/// [`AuthenticationExtensionsClientInputsJSON`](https://www.w3.org/TR/webauthn-3/#dictdef-authenticationextensionsclientinputsjson).
209struct ExtensionHelper<'a, 'b, 'c> {
210 /// [`extension`](https://www.w3.org/TR/webauthn-3/#dom-publickeycredentialrequestoptionsjson-extensions).
211 extension: &'a Extension<'b, 'c>,
212 /// [`extension`](https://www.w3.org/TR/webauthn-3/#dom-publickeycredentialrequestoptionsjson-extensions).
213 ///
214 /// Some extensions contain records, so we need both this and above.
215 allow_credentials: &'a AllowedCredentials,
216}
217impl Serialize for ExtensionHelper<'_, '_, '_> {
218 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
219 where
220 S: Serializer,
221 {
222 let ext_count =
223 usize::from(self.extension.prf.is_some() || self.allow_credentials.prf_count > 0);
224 serializer
225 .serialize_struct("Extension", ext_count)
226 .and_then(|mut ser| {
227 if ext_count == 0 {
228 Ok(())
229 } else {
230 ser.serialize_field(
231 "prf",
232 &PrfInputs {
233 eval: self.extension.prf.map(|prf| prf.0),
234 eval_by_credential: PrfCreds(self.allow_credentials),
235 },
236 )
237 }
238 .and_then(|()| ser.end())
239 })
240 }
241}
242/// `"challenge"`
243const CHALLENGE: &str = "challenge";
244/// `"timeout"`
245const TIMEOUT: &str = "timeout";
246/// `"rpId"`
247const RP_ID: &str = "rpId";
248/// `"allowCredentials"`
249const ALLOW_CREDENTIALS: &str = "allowCredentials";
250/// `"extensions"`
251const EXTENSIONS: &str = "extensions";
252/// `"hints"`
253const HINTS: &str = "hints";
254/// `"userVerification"`
255const USER_VERIFICATION: &str = "userVerification";
256/// Helper type that peforms the serialization for both [`DiscoverableAuthenticationClientState`] and
257/// [`NonDiscoverableAuthenticationClientState`] and
258struct AuthenticationClientState<'rp_id, 'prf_first, 'prf_second, 'opt, 'cred>(
259 &'opt PublicKeyCredentialRequestOptions<'rp_id, 'prf_first, 'prf_second>,
260 &'cred AllowedCredentials,
261);
262impl Serialize for AuthenticationClientState<'_, '_, '_, '_, '_> {
263 #[inline]
264 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
265 where
266 S: Serializer,
267 {
268 serializer
269 .serialize_struct("PublicKeyCredentialRequestOptions", 7)
270 .and_then(|mut ser| {
271 ser.serialize_field(CHALLENGE, &self.0.challenge)
272 .and_then(|()| {
273 ser.serialize_field(TIMEOUT, &self.0.timeout)
274 .and_then(|()| {
275 ser.serialize_field(RP_ID, &self.0.rp_id).and_then(|()| {
276 ser.serialize_field(ALLOW_CREDENTIALS, &self.1)
277 .and_then(|()| {
278 ser.serialize_field(
279 USER_VERIFICATION,
280 &self.0.user_verification,
281 )
282 .and_then(
283 |()| {
284 ser.serialize_field(HINTS, &self.0.hints)
285 .and_then(|()| {
286 ser.serialize_field(
287 EXTENSIONS,
288 &ExtensionHelper {
289 extension: &self.0.extensions,
290 allow_credentials: self.1,
291 },
292 )
293 .and_then(|()| ser.end())
294 })
295 },
296 )
297 })
298 })
299 })
300 })
301 })
302 }
303}
304/// `"mediation"`.
305const MEDIATION: &str = "mediation";
306/// `"uiMode"`.
307const UI_MODE: &str = "uiMode";
308/// `"publicKey"`.
309const PUBLIC_KEY: &str = "publicKey";
310impl Serialize for DiscoverableCredentialRequestOptions<'_, '_, '_> {
311 /// Serializes `self` to conform with
312 /// [`CredentialRequestOptions`](https://www.w3.org/TR/credential-management-1/#dictdef-credentialrequestoptions).
313 ///
314 /// Note [`signal`](https://www.w3.org/TR/credential-management-1/#dom-credentialrequestoptions-signal)
315 /// is not present, and [`publicKey`](https://www.w3.org/TR/credential-management-1/#sctn-cred-type-registry)
316 /// is serialized to conform to
317 /// [`PublicKeyCredentialRequestOptionsJSON`](https://www.w3.org/TR/webauthn-3/#dictdef-publickeycredentialrequestoptionsjson).
318 /// Additionally [`uiMode`](https://www.w3.org/TR/credential-management-1/#dom-credentialrequestoptions-uiMode)
319 /// is not present iff [`Self::ui_mode`] is `None`.
320 #[inline]
321 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
322 where
323 S: Serializer,
324 {
325 serializer
326 .serialize_struct(
327 "DiscoverableCredentialRequestOptions",
328 if self.ui_mode.is_none() { 2 } else { 3 },
329 )
330 .and_then(|mut ser| {
331 ser.serialize_field(MEDIATION, &self.mediation)
332 .and_then(|()| {
333 if self.ui_mode.is_none() {
334 Ok(())
335 } else {
336 ser.serialize_field(UI_MODE, &self.ui_mode)
337 }
338 .and_then(|()| {
339 ser.serialize_field(
340 PUBLIC_KEY,
341 &AuthenticationClientState(
342 &self.public_key,
343 &AllowedCredentials::with_capacity(0),
344 ),
345 )
346 .and_then(|()| ser.end())
347 })
348 })
349 })
350 }
351}
352impl Serialize for NonDiscoverableCredentialRequestOptions<'_, '_, '_> {
353 /// Serializes `self` to conform with
354 /// [`CredentialRequestOptions`](https://www.w3.org/TR/credential-management-1/#dictdef-credentialrequestoptions).
355 ///
356 /// Note [`signal`](https://www.w3.org/TR/credential-management-1/#dom-credentialrequestoptions-signal)
357 /// and [`uiMode`](https://www.w3.org/TR/credential-management-1/#dom-credentialrequestoptions-uiMode)
358 /// are not present, and [`publicKey`](https://www.w3.org/TR/credential-management-1/#sctn-cred-type-registry)
359 /// is serialized to conform to
360 /// [`PublicKeyCredentialRequestOptionsJSON`](https://www.w3.org/TR/webauthn-3/#dictdef-publickeycredentialrequestoptionsjson).
361 #[inline]
362 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
363 where
364 S: Serializer,
365 {
366 serializer
367 .serialize_struct("NonDiscoverableCredentialRequestOptions", 2)
368 .and_then(|mut ser| {
369 ser.serialize_field(MEDIATION, &self.mediation)
370 .and_then(|()| {
371 ser.serialize_field(
372 PUBLIC_KEY,
373 &AuthenticationClientState(&self.options, &self.allow_credentials),
374 )
375 .and_then(|()| ser.end())
376 })
377 })
378 }
379}
380impl Serialize for DiscoverableAuthenticationClientState<'_, '_, '_> {
381 /// Serializes `self` according to [`DiscoverableCredentialRequestOptions::serialize`].
382 ///
383 /// # Examples
384 ///
385 /// ```
386 /// # use structured_webauthn::{
387 /// # request::{
388 /// # auth::{
389 /// # AllowedCredential, AllowedCredentials, CredentialSpecificExtension, Extension,
390 /// # PrfInputOwned, DiscoverableCredentialRequestOptions
391 /// # },
392 /// # AsciiDomain, ExtensionReq, Hints, PublicKeyCredentialHint, PrfInput, RpId, PublicKeyCredentialDescriptor, Credentials, UserVerificationRequirement,
393 /// # },
394 /// # response::{AuthTransports, CredentialId},
395 /// # };
396 /// let rp_id = RpId::Domain(AsciiDomain::try_from("example.com".to_owned())?);
397 /// let mut options = DiscoverableCredentialRequestOptions::passkey(&rp_id);
398 /// options.public_key.hints = Hints::EMPTY.add(PublicKeyCredentialHint::SecurityKey);
399 /// options.public_key.extensions = Extension {
400 /// prf: Some((PrfInput {
401 /// first: [0; 4].as_slice(),
402 /// second: None,
403 /// }, ExtensionReq::Require)),
404 /// };
405 /// let client_state = serde_json::to_string(&options.start_ceremony()?.1).unwrap();
406 /// let json = serde_json::json!({
407 /// "mediation":"required",
408 /// "publicKey":{
409 /// "challenge":"AAAAAAAAAAAAAAAAAAAAAA",
410 /// "timeout":300000,
411 /// "rpId":"example.com",
412 /// "allowCredentials":[],
413 /// "userVerification":"required",
414 /// "hints":[
415 /// "security-key"
416 /// ],
417 /// "extensions":{
418 /// "prf":{
419 /// "eval":{
420 /// "first":"AAAAAA"
421 /// },
422 /// }
423 /// }
424 /// }
425 /// }).to_string();
426 /// // Since `Challenge`s are randomly generated, we don't know what it will be; thus
427 /// // we test the JSON string for everything except it.
428 /// # #[cfg(all(feature = "bin", feature = "custom"))]
429 /// assert_eq!(client_state.get(..50), json.get(..50));
430 /// # #[cfg(all(feature = "bin", feature = "custom"))]
431 /// assert_eq!(client_state.get(72..), json.get(72..));
432 /// # Ok::<_, structured_webauthn::AggErr>(())
433 /// ```
434 #[inline]
435 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
436 where
437 S: Serializer,
438 {
439 self.0.serialize(serializer)
440 }
441}
442impl Serialize for NonDiscoverableAuthenticationClientState<'_, '_, '_> {
443 /// Serializes `self` according to [`NonDiscoverableCredentialRequestOptions::serialize`].
444 ///
445 /// # Examples
446 ///
447 /// ```
448 /// # #[cfg(all(feature = "bin", feature = "custom"))]
449 /// # use structured_webauthn::{bin::Decode, response::bin::DecodeAuthTransportsErr};
450 /// # use structured_webauthn::{
451 /// # request::{
452 /// # auth::{
453 /// # AllowedCredential, AllowedCredentials, CredentialSpecificExtension, Extension,
454 /// # PrfInputOwned, NonDiscoverableCredentialRequestOptions
455 /// # },
456 /// # AsciiDomain, ExtensionReq, Hints, PublicKeyCredentialHint, PrfInput, RpId, PublicKeyCredentialDescriptor, Credentials, UserVerificationRequirement,
457 /// # },
458 /// # response::{AuthTransports, CredentialId},
459 /// # };
460 /// /// Retrieves the `AuthTransports` associated with the unique `cred_id`
461 /// /// from the database.
462 /// # #[cfg(all(feature = "bin", feature = "custom"))]
463 /// fn get_transports(cred_id: CredentialId<&[u8]>) -> Result<AuthTransports, DecodeAuthTransportsErr> {
464 /// // ⋮
465 /// # AuthTransports::decode(32)
466 /// }
467 /// let mut creds = AllowedCredentials::with_capacity(1);
468 /// // `CredentialId::try_from` only exists when `custom` is enabled; and even then, it is
469 /// // likely never needed since the `CredentialId` was originally sent from the client and is likely
470 /// // stored in a database which would be fetched by `UserHandle` or `Authentication::raw_id`.
471 /// # #[cfg(all(feature = "bin", feature = "custom"))]
472 /// let id = CredentialId::try_from(vec![0; 16].into_boxed_slice())?;
473 /// # #[cfg(all(feature = "bin", feature = "custom"))]
474 /// let transports = get_transports((&id).into())?;
475 /// # #[cfg(all(feature = "bin", feature = "custom"))]
476 /// creds.push(AllowedCredential {
477 /// credential: PublicKeyCredentialDescriptor { id, transports },
478 /// extension: CredentialSpecificExtension {
479 /// prf: Some(PrfInputOwned {
480 /// first: vec![2; 6],
481 /// second: Some(vec![3; 2]),
482 /// ext_req: ExtensionReq::Require,
483 /// }),
484 /// },
485 /// });
486 /// let rp_id = RpId::Domain(AsciiDomain::try_from("example.com".to_owned())?);
487 /// # #[cfg(all(feature = "bin", feature = "custom"))]
488 /// let mut options = NonDiscoverableCredentialRequestOptions::second_factor(&rp_id, creds);
489 /// # #[cfg(all(feature = "bin", feature = "custom"))]
490 /// let opts = &mut options.options;
491 /// # #[cfg(not(all(feature = "bin", feature = "custom")))]
492 /// # let mut opts = structured_webauthn::DiscoverableCredentialRequestOptions::passkey(&rp_id).public_key;
493 /// opts.hints = Hints::EMPTY.add(PublicKeyCredentialHint::SecurityKey);
494 /// // This is actually useless since `CredentialSpecificExtension` takes priority
495 /// // when the client receives the payload. We set it for illustration purposes only.
496 /// // If `creds` contained an `AllowedCredential` that didn't set
497 /// // `CredentialSpecificExtension::prf`, then this would be used for it.
498 /// opts.extensions = Extension {
499 /// prf: Some((PrfInput {
500 /// first: [0; 4].as_slice(),
501 /// second: None,
502 /// }, ExtensionReq::Require)),
503 /// };
504 /// // Since we are requesting the PRF extension, we must require user verification; otherwise
505 /// // `NonDiscoverableCredentialRequestOptions::start_ceremony` would error.
506 /// opts.user_verification = UserVerificationRequirement::Required;
507 /// # #[cfg(all(feature = "bin", feature = "custom"))]
508 /// let client_state = serde_json::to_string(&options.start_ceremony()?.1).unwrap();
509 /// let json = serde_json::json!({
510 /// "mediation":"required",
511 /// "publicKey":{
512 /// "challenge":"AAAAAAAAAAAAAAAAAAAAAA",
513 /// "timeout":300000,
514 /// "rpId":"example.com",
515 /// "allowCredentials":[
516 /// {
517 /// "type":"public-key",
518 /// "id":"AAAAAAAAAAAAAAAAAAAAAA",
519 /// "transports":["usb"]
520 /// }
521 /// ],
522 /// "userVerification":"required",
523 /// "hints":[
524 /// "security-key"
525 /// ],
526 /// "extensions":{
527 /// "prf":{
528 /// "eval":{
529 /// "first":"AAAAAA"
530 /// },
531 /// "evalByCredential":{
532 /// "AAAAAAAAAAAAAAAAAAAAAA":{
533 /// "first":"AgICAgIC",
534 /// "second":"AwM"
535 /// }
536 /// }
537 /// }
538 /// }
539 /// }
540 /// }).to_string();
541 /// // Since `Challenge`s are randomly generated, we don't know what it will be; thus
542 /// // we test the JSON string for everything except it.
543 /// # #[cfg(all(feature = "bin", feature = "custom"))]
544 /// assert_eq!(client_state.get(..50), json.get(..50));
545 /// # #[cfg(all(feature = "bin", feature = "custom"))]
546 /// assert_eq!(client_state.get(72..), json.get(72..));
547 /// # Ok::<_, structured_webauthn::AggErr>(())
548 /// ```
549 #[inline]
550 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
551 where
552 S: Serializer,
553 {
554 self.0.serialize(serializer)
555 }
556}
557impl<'de> Deserialize<'de> for CredentialUiMode {
558 /// Deserializes a [`prim@str`] based on
559 /// [`CredentialUiMode`](https://www.w3.org/TR/credential-management-1/#enumdef-credentialuimode).
560 ///
561 /// # Examples
562 ///
563 /// ```
564 /// # use structured_webauthn::request::auth::CredentialUiMode;
565 /// assert_eq!(
566 /// serde_json::from_str::<CredentialUiMode>(r#""immediate""#)?,
567 /// CredentialUiMode::Immediate,
568 /// );
569 /// # Ok::<_, serde_json::Error>(())
570 /// ```
571 #[inline]
572 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
573 where
574 D: Deserializer<'de>,
575 {
576 struct CredentialUiModeVisitor;
577 impl Visitor<'_> for CredentialUiModeVisitor {
578 type Value = CredentialUiMode;
579 fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
580 write!(formatter, "'{IMMEDIATE}'")
581 }
582 fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
583 where
584 E: Error,
585 {
586 if v == IMMEDIATE {
587 Ok(CredentialUiMode::Immediate)
588 } else {
589 Err(E::invalid_value(
590 Unexpected::Str(v),
591 &format!("'{IMMEDIATE}'").as_str(),
592 ))
593 }
594 }
595 }
596 deserializer.deserialize_str(CredentialUiModeVisitor)
597 }
598}
599/// Similar to [`Extension`] except [`PrfInputOwned`] is used.
600///
601/// This is primarily useful to assist [`ClientCredentialRequestOptions::deserialize`].
602#[derive(Debug, Default)]
603pub struct ExtensionOwned {
604 /// See [`Extension::prf`].
605 pub prf: Option<PrfInputOwned>,
606}
607impl ExtensionOwned {
608 /// Returns an `Extension` based on `self`.
609 #[inline]
610 #[must_use]
611 pub fn as_extension(&self) -> Extension<'_, '_> {
612 Extension {
613 prf: self.prf.as_ref().map(|prf| {
614 (
615 PrfInput {
616 first: &prf.first,
617 second: prf.second.as_deref(),
618 },
619 prf.ext_req,
620 )
621 }),
622 }
623 }
624 /// Returns an `Extension` based on `self` and `prf`.
625 ///
626 /// Note `prf` is used _unconditionally_ regardless if [`Self::prf`] is `Some`.
627 #[inline]
628 #[must_use]
629 pub const fn with_prf<'prf_first, 'prf_second>(
630 &self,
631 prf: (PrfInput<'prf_first, 'prf_second>, ExtensionReq),
632 ) -> Extension<'prf_first, 'prf_second> {
633 Extension { prf: Some(prf) }
634 }
635}
636impl<'de> Deserialize<'de> for ExtensionOwned {
637 /// Deserializes a `struct` according to the following pseudo-schema:
638 ///
639 /// ```json
640 /// {
641 /// "prf": null | PRFJSON
642 /// }
643 /// // PRFJSON:
644 /// {
645 /// "eval": PRFInputs
646 /// }
647 /// // PRFInputs:
648 /// {
649 /// "first": <base64url-encoded string>,
650 /// "second": null | <base64url-encoded string>
651 /// }
652 /// ```
653 ///
654 /// where the only required fields are `"eval"` and `"first"`.
655 ///
656 /// All extensions are not required to have a response sent back; but _if_ a response is sent back, its value
657 /// will be enforced.
658 ///
659 /// Unknown or duplicate fields lead to an error.
660 ///
661 /// # Examples
662 ///
663 /// ```
664 /// # use structured_webauthn::request::{ExtensionReq, auth::ser::ExtensionOwned};
665 /// let ext = serde_json::from_str::<ExtensionOwned>(
666 /// r#"{"prf":{"eval":{"first":"","second":null}}}"#,
667 /// )?;
668 /// assert!(ext.prf.map_or(false, |prf| prf.first.is_empty()
669 /// && prf.second.is_none()
670 /// && matches!(prf.ext_req, ExtensionReq::Allow)));
671 /// # Ok::<_, serde_json::Error>(())
672 /// ```
673 #[inline]
674 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
675 where
676 D: Deserializer<'de>,
677 {
678 /// `Visitor` for `ExtensionOwned`.
679 struct ExtensionOwnedVisitor;
680 impl<'d> Visitor<'d> for ExtensionOwnedVisitor {
681 type Value = ExtensionOwned;
682 fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
683 formatter.write_str("ExtensionOwned")
684 }
685 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
686 where
687 A: MapAccess<'d>,
688 {
689 /// Field for `ExtensionOwned`.
690 struct Field;
691 impl<'e> Deserialize<'e> for Field {
692 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
693 where
694 D: Deserializer<'e>,
695 {
696 /// `Visitor` for `Field`.
697 struct FieldVisitor;
698 impl Visitor<'_> for FieldVisitor {
699 type Value = Field;
700 fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
701 write!(formatter, "'{PRF}'")
702 }
703 fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
704 where
705 E: Error,
706 {
707 if v == PRF {
708 Ok(Field)
709 } else {
710 Err(E::unknown_field(v, FIELDS))
711 }
712 }
713 }
714 deserializer.deserialize_identifier(FieldVisitor)
715 }
716 }
717 map.next_key::<Field>().and_then(|opt_key| {
718 opt_key
719 .map_or_else(
720 || Ok(None),
721 |_k| {
722 map.next_value::<Option<PrfHelper>>().and_then(|prf| {
723 map.next_key::<Field>().and_then(|opt_key2| {
724 opt_key2.map_or_else(
725 || Ok(prf.map(|val| val.0)),
726 |_k2| Err(Error::duplicate_field(PRF)),
727 )
728 })
729 })
730 },
731 )
732 .map(|prf| ExtensionOwned { prf })
733 })
734 }
735 }
736 /// `"prf"`.
737 const PRF: &str = "prf";
738 /// Fields for `ExtensionOwned`.
739 const FIELDS: &[&str; 1] = &[PRF];
740 deserializer.deserialize_struct("ExtensionOwned", FIELDS, ExtensionOwnedVisitor)
741 }
742}
743/// Error returned by [`PublicKeyCredentialRequestOptionsOwned::as_options`] when
744/// [`PublicKeyCredentialRequestOptionsOwned::rp_id`] is `None`.
745#[derive(Clone, Copy, Debug, Eq, PartialEq)]
746pub struct PublicKeyCredentialRequestOptionsOwnedErr;
747impl Display for PublicKeyCredentialRequestOptionsOwnedErr {
748 #[inline]
749 fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
750 f.write_str("request options did not have an RP ID")
751 }
752}
753impl E for PublicKeyCredentialRequestOptionsOwnedErr {}
754/// Similar to [`PublicKeyCredentialRequestOptions`] except the fields are based on owned data, and
755/// [`Self::rp_id`] is optional.
756///
757/// This is primarily useful to assist [`ClientCredentialRequestOptions::deserialize`],
758#[derive(Debug)]
759pub struct PublicKeyCredentialRequestOptionsOwned {
760 /// See [`PublicKeyCredentialRequestOptions::rp_id`].
761 pub rp_id: Option<RpId>,
762 /// See [`PublicKeyCredentialRequestOptions::timeout`].
763 pub timeout: NonZeroU32,
764 /// See [`PublicKeyCredentialRequestOptions::user_verification`].
765 pub user_verification: UserVerificationRequirement,
766 /// See [`PublicKeyCredentialRequestOptions::hints`].
767 pub hints: Hints,
768 /// See [`PublicKeyCredentialRequestOptions::extensions`].
769 pub extensions: ExtensionOwned,
770}
771impl PublicKeyCredentialRequestOptionsOwned {
772 /// Returns a `PublicKeyCredentialRequestOptions` based on `self`.
773 ///
774 /// # Errors
775 ///
776 /// Errors iff [`Self::rp_id`] is `None`.
777 #[inline]
778 pub fn as_options(
779 &self,
780 ) -> Result<
781 PublicKeyCredentialRequestOptions<'_, '_, '_>,
782 PublicKeyCredentialRequestOptionsOwnedErr,
783 > {
784 self.rp_id
785 .as_ref()
786 .ok_or(PublicKeyCredentialRequestOptionsOwnedErr)
787 .map(|rp_id| PublicKeyCredentialRequestOptions {
788 challenge: Challenge::new(),
789 timeout: self.timeout,
790 rp_id,
791 user_verification: self.user_verification,
792 hints: self.hints,
793 extensions: self.extensions.as_extension(),
794 })
795 }
796 /// Returns a `PublicKeyCredentialRequestOptions` based on `self` and `rp_id`.
797 ///
798 /// Note `rp_id` is used _unconditionally_ regardless if [`Self::rp_id`] is `Some`.
799 #[inline]
800 #[must_use]
801 pub fn with_rp_id<'rp_id>(
802 &self,
803 rp_id: &'rp_id RpId,
804 ) -> PublicKeyCredentialRequestOptions<'rp_id, '_, '_> {
805 PublicKeyCredentialRequestOptions {
806 challenge: Challenge::new(),
807 timeout: self.timeout,
808 rp_id,
809 user_verification: self.user_verification,
810 hints: self.hints,
811 extensions: self.extensions.as_extension(),
812 }
813 }
814 /// Returns a `PublicKeyCredentialRequestOptions` based on `self`, `exclude_credentials`, and `extensions`.
815 ///
816 /// Note `extensions` is used _unconditionally_ regardless of what [`Self::extensions`] is.
817 ///
818 /// # Errors
819 ///
820 /// Errors iff [`Self::rp_id`] is `None`.
821 #[inline]
822 pub fn with_extensions<'prf_first, 'prf_second>(
823 &self,
824 extensions: Extension<'prf_first, 'prf_second>,
825 ) -> Result<
826 PublicKeyCredentialRequestOptions<'_, 'prf_first, 'prf_second>,
827 PublicKeyCredentialRequestOptionsOwnedErr,
828 > {
829 self.rp_id
830 .as_ref()
831 .ok_or(PublicKeyCredentialRequestOptionsOwnedErr)
832 .map(|rp_id| PublicKeyCredentialRequestOptions {
833 challenge: Challenge::new(),
834 timeout: self.timeout,
835 rp_id,
836 user_verification: self.user_verification,
837 hints: self.hints,
838 extensions,
839 })
840 }
841 /// Returns a `PublicKeyCredentialRequestOptions` based on `self`, `rp_id`, and `extensions`.
842 ///
843 /// Note `rp_id` and `extensions` are used _unconditionally_ regardless if [`Self::rp_id`] is `Some` or what
844 /// [`Self::extensions`] is.
845 #[inline]
846 #[must_use]
847 pub fn with_rp_id_and_extensions<'rp_id, 'prf_first, 'prf_second>(
848 &self,
849 rp_id: &'rp_id RpId,
850 extensions: Extension<'prf_first, 'prf_second>,
851 ) -> PublicKeyCredentialRequestOptions<'rp_id, 'prf_first, 'prf_second> {
852 PublicKeyCredentialRequestOptions {
853 challenge: Challenge::new(),
854 timeout: self.timeout,
855 rp_id,
856 user_verification: self.user_verification,
857 hints: self.hints,
858 extensions,
859 }
860 }
861}
862impl Default for PublicKeyCredentialRequestOptionsOwned {
863 #[inline]
864 fn default() -> Self {
865 Self {
866 rp_id: None,
867 timeout: FIVE_MINUTES,
868 user_verification: UserVerificationRequirement::Preferred,
869 hints: Hints::default(),
870 extensions: ExtensionOwned::default(),
871 }
872 }
873}
874impl<'de> Deserialize<'de> for PublicKeyCredentialRequestOptionsOwned {
875 /// Deserializes a `struct` based on
876 /// [`PublicKeyCredentialRequestOptionsJSON`](https://www.w3.org/TR/webauthn-3/#dictdef-publickeycredentialrequestoptionsjson).
877 ///
878 /// Note that none of the fields are required, and all are allowed to be `null`.
879 ///
880 /// If [`challenge`](https://www.w3.org/TR/webauthn-3/#dom-publickeycredentialrequestoptionsjson-challenge)
881 /// exists, it must be `null`. If
882 /// [`allowCredentials`](https://www.w3.org/TR/webauthn-3/#dom-publickeycredentialrequestoptionsjson-allowcredentials)
883 /// exists, it must be `null` or empty.
884 ///
885 /// If [`timeout`](https://www.w3.org/TR/webauthn-3/#dom-publickeycredentialrequestoptionsjson-timeout) exists,
886 /// it must be `null` or positive. If `timeout` is missing or is `null`, then [`FIVE_MINUTES`] will be used.
887 ///
888 /// If `userVerification` is missing or is `null`, then [`UserVerificationRequirement::Required`] will be used.
889 ///
890 /// Unknown or duplicate fields lead to an error.
891 #[expect(clippy::too_many_lines, reason = "131 lines is fine")]
892 #[inline]
893 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
894 where
895 D: Deserializer<'de>,
896 {
897 /// `Visitor` for `PublicKeyCredentialRequestOptionsOwned`.
898 struct PublicKeyCredentialRequestOptionsOwnedVisitor;
899 impl<'d> Visitor<'d> for PublicKeyCredentialRequestOptionsOwnedVisitor {
900 type Value = PublicKeyCredentialRequestOptionsOwned;
901 fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
902 formatter.write_str("PublicKeyCredentialRequestOptionsOwned")
903 }
904 #[expect(clippy::too_many_lines, reason = "104 lines is fine")]
905 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
906 where
907 A: MapAccess<'d>,
908 {
909 /// Field for `PublicKeyCredentialRequestOptionsOwned`.
910 enum Field {
911 /// `rpId`.
912 RpId,
913 /// `userVerification`.
914 UserVerification,
915 /// `challenge`.
916 Challenge,
917 /// `timeout`.
918 Timeout,
919 /// `allowCredentials`.
920 AllowCredentials,
921 /// `hints`.
922 Hints,
923 /// `extensions`.
924 Extensions,
925 }
926 impl<'e> Deserialize<'e> for Field {
927 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
928 where
929 D: Deserializer<'e>,
930 {
931 /// `Visitor` for `Field`.
932 struct FieldVisitor;
933 impl Visitor<'_> for FieldVisitor {
934 type Value = Field;
935 fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
936 write!(
937 formatter,
938 "'{RP_ID}', '{USER_VERIFICATION}', '{CHALLENGE}', '{TIMEOUT}', '{ALLOW_CREDENTIALS}', '{HINTS}', or '{EXTENSIONS}'"
939 )
940 }
941 fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
942 where
943 E: Error,
944 {
945 match v {
946 RP_ID => Ok(Field::RpId),
947 USER_VERIFICATION => Ok(Field::UserVerification),
948 CHALLENGE => Ok(Field::Challenge),
949 TIMEOUT => Ok(Field::Timeout),
950 ALLOW_CREDENTIALS => Ok(Field::AllowCredentials),
951 HINTS => Ok(Field::Hints),
952 EXTENSIONS => Ok(Field::Extensions),
953 _ => Err(E::unknown_field(v, FIELDS)),
954 }
955 }
956 }
957 deserializer.deserialize_identifier(FieldVisitor)
958 }
959 }
960 let mut rp = None;
961 let mut user_veri = None;
962 let mut chall = None;
963 let mut time = None;
964 let mut allow = None;
965 let mut hint = None;
966 let mut ext = None;
967 while let Some(key) = map.next_key()? {
968 match key {
969 Field::RpId => {
970 if rp.is_some() {
971 return Err(Error::duplicate_field(RP_ID));
972 }
973 rp = map.next_value::<Option<_>>().map(Some)?;
974 }
975 Field::UserVerification => {
976 if user_veri.is_some() {
977 return Err(Error::duplicate_field(USER_VERIFICATION));
978 }
979 user_veri = map.next_value::<Option<_>>().map(Some)?;
980 }
981 Field::Challenge => {
982 if chall.is_some() {
983 return Err(Error::duplicate_field(CHALLENGE));
984 }
985 chall = map.next_value::<Null>().map(Some)?;
986 }
987 Field::Timeout => {
988 if time.is_some() {
989 return Err(Error::duplicate_field(TIMEOUT));
990 }
991 time = map.next_value::<Option<_>>().map(Some)?;
992 }
993 Field::AllowCredentials => {
994 if allow.is_some() {
995 return Err(Error::duplicate_field(ALLOW_CREDENTIALS));
996 }
997 allow = map.next_value::<Option<[(); 0]>>().map(Some)?;
998 }
999 Field::Hints => {
1000 if hint.is_some() {
1001 return Err(Error::duplicate_field(HINTS));
1002 }
1003 hint = map.next_value::<Option<_>>().map(Some)?;
1004 }
1005 Field::Extensions => {
1006 if ext.is_some() {
1007 return Err(Error::duplicate_field(EXTENSIONS));
1008 }
1009 ext = map.next_value::<Option<_>>().map(Some)?;
1010 }
1011 }
1012 }
1013 Ok(PublicKeyCredentialRequestOptionsOwned {
1014 rp_id: rp.flatten(),
1015 user_verification: user_veri
1016 .flatten()
1017 .unwrap_or(UserVerificationRequirement::Preferred),
1018 timeout: time.flatten().unwrap_or(FIVE_MINUTES),
1019 extensions: ext.flatten().unwrap_or_default(),
1020 hints: hint.flatten().unwrap_or_default(),
1021 })
1022 }
1023 }
1024 /// Fields for `PublicKeyCredentialRequestOptionsOwned`.
1025 const FIELDS: &[&str; 7] = &[
1026 RP_ID,
1027 USER_VERIFICATION,
1028 CHALLENGE,
1029 TIMEOUT,
1030 ALLOW_CREDENTIALS,
1031 HINTS,
1032 EXTENSIONS,
1033 ];
1034 deserializer.deserialize_struct(
1035 "PublicKeyCredentialRequestOptionsOwned",
1036 FIELDS,
1037 PublicKeyCredentialRequestOptionsOwnedVisitor,
1038 )
1039 }
1040}
1041/// Deserializes client-supplied data to assist in the creation of [`DiscoverableCredentialRequestOptions`]
1042/// and [`NonDiscoverableCredentialRequestOptions`].
1043///
1044/// It's common to tailor an authentication ceremony based on a user's environment. The options that should be
1045/// used are then sent to the server. To facilitate this, [`Self::deserialize`] can be used to deserialize the data
1046/// sent from the client.
1047///
1048/// Note one may want to change some of the [`Extension`] data since [`ExtensionReq::Allow`] is unconditionally
1049/// used. Read [`ExtensionOwned::deserialize`] for more information.
1050///
1051/// Additionally, one may want to change the value of [`PublicKeyCredentialRequestOptions::rp_id`] since
1052/// `"example.invalid"` is used in the event the RP ID was not supplied.
1053#[derive(Debug)]
1054pub struct ClientCredentialRequestOptions {
1055 /// See [`DiscoverableCredentialRequestOptions::mediation`] and
1056 /// [`NonDiscoverableCredentialRequestOptions::mediation`].
1057 pub mediation: CredentialMediationRequirement,
1058 /// See [`DiscoverableCredentialRequestOptions::mediation`].
1059 pub ui_mode: Option<CredentialUiMode>,
1060 /// See [`DiscoverableCredentialRequestOptions::public_key`] and
1061 /// See [`NonDiscoverableCredentialRequestOptions::options`].
1062 pub public_key: PublicKeyCredentialRequestOptionsOwned,
1063}
1064impl<'de> Deserialize<'de> for ClientCredentialRequestOptions {
1065 /// Deserializes a `struct` according to the following pseudo-schema:
1066 ///
1067 /// ```json
1068 /// {
1069 /// "mediation": null | "required" | "conditional",
1070 /// "uiMode": null | "immediate",
1071 /// "publicKey": null | <PublicKeyCredentialRequestOptionsOwned>
1072 /// }
1073 /// ```
1074 ///
1075 /// where none of the fields are required and `"publicKey"` is deserialized according to
1076 /// [`PublicKeyCredentialRequestOptionsOwned::deserialize`]. If any field is missing or is `null`, then
1077 /// the corresponding [`Default`] `impl` will be used.
1078 ///
1079 /// Unknown or duplicate fields lead to an error.
1080 #[inline]
1081 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1082 where
1083 D: Deserializer<'de>,
1084 {
1085 /// `Visitor` for `ClientCredentialRequestOptions`.
1086 struct ClientCredentialRequestOptionsVisitor;
1087 impl<'d> Visitor<'d> for ClientCredentialRequestOptionsVisitor {
1088 type Value = ClientCredentialRequestOptions;
1089 fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
1090 formatter.write_str("ClientCredentialRequestOptions")
1091 }
1092 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
1093 where
1094 A: MapAccess<'d>,
1095 {
1096 /// Field in `ClientCredentialRequestOptions`.
1097 enum Field {
1098 /// `mediation`.
1099 Mediation,
1100 /// `uiMode`.
1101 UiMode,
1102 /// `publicKey`
1103 PublicKey,
1104 }
1105 impl<'e> Deserialize<'e> for Field {
1106 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1107 where
1108 D: Deserializer<'e>,
1109 {
1110 /// `Visitor` for `Field`.
1111 struct FieldVisitor;
1112 impl Visitor<'_> for FieldVisitor {
1113 type Value = Field;
1114 fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
1115 write!(formatter, "'{MEDIATION}', '{UI_MODE}', or '{PUBLIC_KEY}'")
1116 }
1117 fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
1118 where
1119 E: Error,
1120 {
1121 match v {
1122 MEDIATION => Ok(Field::Mediation),
1123 UI_MODE => Ok(Field::UiMode),
1124 PUBLIC_KEY => Ok(Field::PublicKey),
1125 _ => Err(E::unknown_field(v, FIELDS)),
1126 }
1127 }
1128 }
1129 deserializer.deserialize_identifier(FieldVisitor)
1130 }
1131 }
1132 let mut med = None;
1133 let mut ui = None;
1134 let mut key = None;
1135 while let Some(k) = map.next_key()? {
1136 match k {
1137 Field::Mediation => {
1138 if med.is_some() {
1139 return Err(Error::duplicate_field(MEDIATION));
1140 }
1141 med = map.next_value::<Option<_>>().map(Some)?;
1142 }
1143 Field::UiMode => {
1144 if ui.is_some() {
1145 return Err(Error::duplicate_field(UI_MODE));
1146 }
1147 ui = map.next_value().map(Some)?;
1148 }
1149 Field::PublicKey => {
1150 if key.is_some() {
1151 return Err(Error::duplicate_field(PUBLIC_KEY));
1152 }
1153 key = map.next_value::<Option<_>>().map(Some)?;
1154 }
1155 }
1156 }
1157 Ok(ClientCredentialRequestOptions {
1158 mediation: med.flatten().unwrap_or_default(),
1159 ui_mode: ui.flatten(),
1160 public_key: key.flatten().unwrap_or_default(),
1161 })
1162 }
1163 }
1164 /// Fields for `ClientCredentialRequestOptions`.
1165 const FIELDS: &[&str; 3] = &[MEDIATION, UI_MODE, PUBLIC_KEY];
1166 deserializer.deserialize_struct(
1167 "ClientCredentialRequestOptions",
1168 FIELDS,
1169 ClientCredentialRequestOptionsVisitor,
1170 )
1171 }
1172}