1use passkey::client::WebauthnError;
2use thiserror::Error;
3
4use super::{
5 Fido2Authenticator, PublicKeyCredentialAuthenticatorAssertionResponse,
6 PublicKeyCredentialAuthenticatorAttestationResponse,
7 authenticator::GetSelectedCredentialError,
8 get_string_name_from_enum,
9 types::{
10 AuthenticatorAssertionResponse, AuthenticatorAttestationResponse, ClientData,
11 ClientExtensionResults, CredPropsResult, Origin,
12 },
13};
14use crate::types::InvalidOriginError;
15
16#[allow(missing_docs)]
17#[derive(Debug, Error)]
18#[cfg_attr(feature = "uniffi", derive(uniffi::Error), uniffi(flat_error))]
19pub enum Fido2ClientError {
20 #[error(transparent)]
21 InvalidOrigin(#[from] InvalidOriginError),
22 #[error(transparent)]
23 Serde(#[from] serde_json::Error),
24 #[error(transparent)]
25 GetSelectedCredential(#[from] GetSelectedCredentialError),
26
27 #[error("Webauthn error: {0:?}")]
28 Webauthn(WebauthnError),
29}
30
31impl From<WebauthnError> for Fido2ClientError {
32 fn from(e: WebauthnError) -> Self {
33 Self::Webauthn(e)
34 }
35}
36
37#[allow(missing_docs)]
38pub struct Fido2Client<'a> {
39 pub authenticator: Fido2Authenticator<'a>,
40}
41
42impl Fido2Client<'_> {
43 #[allow(missing_docs)]
44 pub async fn register(
45 &mut self,
46 origin: Origin,
47 request: String,
48 client_data: ClientData,
49 ) -> Result<PublicKeyCredentialAuthenticatorAttestationResponse, Fido2ClientError> {
50 let origin: passkey::client::Origin = origin.try_into()?;
51 let request: passkey::types::webauthn::CredentialCreationOptions =
52 serde_json::from_str(&request)?;
53
54 let uv = request
56 .public_key
57 .authenticator_selection
58 .as_ref()
59 .map(|s| s.user_verification.into());
60 *self
61 .authenticator
62 .requested_uv
63 .get_mut()
64 .expect("Mutex is not poisoned") = uv;
65
66 let mut client = passkey::client::Client::new(self.authenticator.get_authenticator(true));
67 let result = client.register(origin, request, client_data).await?;
68
69 Ok(PublicKeyCredentialAuthenticatorAttestationResponse {
70 id: result.id,
71 raw_id: result.raw_id.into(),
72 ty: get_string_name_from_enum(result.ty)?,
73 authenticator_attachment: result
74 .authenticator_attachment
75 .map(get_string_name_from_enum)
76 .transpose()?,
77 client_extension_results: ClientExtensionResults {
78 cred_props: result.client_extension_results.cred_props.map(Into::into),
79 },
80 response: AuthenticatorAttestationResponse {
81 client_data_json: result.response.client_data_json.into(),
82 authenticator_data: result.response.authenticator_data.into(),
83 public_key: result.response.public_key.map(|x| x.into()),
84 public_key_algorithm: result.response.public_key_algorithm,
85 attestation_object: result.response.attestation_object.into(),
86 transports: Some(vec!["internal".to_string(), "hybrid".to_string()]),
87 },
88 selected_credential: self.authenticator.get_selected_credential()?,
89 })
90 }
91
92 #[allow(missing_docs)]
93 pub async fn authenticate(
94 &mut self,
95 origin: Origin,
96 request: String,
97 client_data: ClientData,
98 ) -> Result<PublicKeyCredentialAuthenticatorAssertionResponse, Fido2ClientError> {
99 let origin: passkey::client::Origin = origin.try_into()?;
100 let request: passkey::types::webauthn::CredentialRequestOptions =
101 serde_json::from_str(&request)?;
102
103 let uv = request.public_key.user_verification.into();
105 self.authenticator
106 .requested_uv
107 .get_mut()
108 .expect("Mutex is not poisoned")
109 .replace(uv);
110
111 let mut client = passkey::client::Client::new(self.authenticator.get_authenticator(false));
112 let result = client.authenticate(origin, request, client_data).await?;
113
114 Ok(PublicKeyCredentialAuthenticatorAssertionResponse {
115 id: result.id,
116 raw_id: result.raw_id.into(),
117 ty: get_string_name_from_enum(result.ty)?,
118
119 authenticator_attachment: result
120 .authenticator_attachment
121 .map(get_string_name_from_enum)
122 .transpose()?,
123 client_extension_results: ClientExtensionResults {
124 cred_props: result
125 .client_extension_results
126 .cred_props
127 .map(|c| CredPropsResult { rk: c.discoverable }),
128 },
129 response: AuthenticatorAssertionResponse {
130 client_data_json: result.response.client_data_json.into(),
131 authenticator_data: result.response.authenticator_data.into(),
132 signature: result.response.signature.into(),
133 user_handle: result.response.user_handle.unwrap_or_default().into(),
134 },
135 selected_credential: self.authenticator.get_selected_credential()?,
136 })
137 }
138}