Skip to main content

bitwarden_fido/
client.rs

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        // Insert the received UV to be able to return it later in check_user
55        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        // Insert the received UV to be able to return it later in check_user
104        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}