wip

crates/bitwarden-json/src/client.rs

@@ -1,5 +1,9 @@
 use async_lock::Mutex;
-use bitwarden::client::client_settings::ClientSettings;
+use bitwarden::{
+    client::client_settings::ClientSettings,
+    error::Result,
+    platform::{Fido2ClientGetAssertionRequest, Fido2GetAssertionUserInterface},
+};
 
 #[cfg(feature = "secrets")]
 use crate::command::{ProjectsCommand, SecretsCommand};
@@ -16,6 +20,19 @@ impl Client {
         Self(Mutex::new(bitwarden::Client::new(settings)))
     }
 
+    pub async fn client_get_assertion(
+        &self,
+        request: Fido2ClientGetAssertionRequest,
+        user_interface: impl Fido2GetAssertionUserInterface,
+    ) -> Result<String> {
+        let mut client = self.0.lock().await;
+
+        client
+            .platform()
+            .client_get_assertion(request, user_interface)
+            .await
+    }
+
     pub async fn run_command(&self, input_str: &str) -> String {
         const SUBCOMMANDS_TO_CLEAN: &[&str] = &["Secrets"];
         let mut cmd_value: serde_json::Value = match serde_json::from_str(input_str) {
@@ -63,11 +80,6 @@ impl Client {
             #[cfg(feature = "internal")]
             Command::Fingerprint(req) => client.platform().fingerprint(&req).into_string(),
 
-            #[cfg(feature = "internal")]
-            Command::Fido2ClientGetAssertion(req) => {
-                client.platform().client_get_assertion(req).into_string()
-            }
-
             #[cfg(feature = "secrets")]
             Command::Secrets(cmd) => match cmd {
                 SecretsCommand::Get(req) => client.secrets().get(&req).await.into_string(),

crates/bitwarden-json/src/command.rs

@@ -15,9 +15,7 @@ use bitwarden::{
 #[cfg(feature = "internal")]
 use bitwarden::{
     auth::login::{ApiKeyLoginRequest, PasswordLoginRequest},
-    platform::{
-        Fido2ClientGetAssertionRequest, FingerprintRequest, SecretVerificationRequest, SyncRequest,
-    },
+    platform::{FingerprintRequest, SecretVerificationRequest, SyncRequest},
 };
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
@@ -73,12 +71,6 @@ pub enum Command {
     /// Returns: [SyncResponse](bitwarden::platform::SyncResponse)
     Sync(SyncRequest),
 
-    #[cfg(feature = "internal")]
-    /// > Requires Authentication
-    ///
-    /// Returns: ?
-    Fido2ClientGetAssertion(Fido2ClientGetAssertionRequest),
-
     #[cfg(feature = "secrets")]
     Secrets(SecretsCommand),
     #[cfg(feature = "secrets")]

crates/bitwarden-json/src/lib.rs

@@ -1,3 +1,8 @@
 pub mod client;
 pub mod command;
 pub mod response;
+
+pub use bitwarden::{
+    error::Result,
+    platform::{Fido2ClientGetAssertionRequest, Fido2GetAssertionUserInterface, VaultItem},
+};

crates/bitwarden-wasm/src/client.rs

@@ -1,8 +1,11 @@
 extern crate console_error_panic_hook;
-use std::rc::Rc;
+use std::{fmt::Result, process::Output, rc::Rc};
 
-use bitwarden_json::client::Client as JsonClient;
-use js_sys::Promise;
+use bitwarden_json::{
+    client::Client as JsonClient, Fido2ClientGetAssertionRequest, Fido2GetAssertionUserInterface,
+    VaultItem,
+};
+use js_sys::{Object, Promise};
 use log::Level;
 use wasm_bindgen::prelude::*;
 use wasm_bindgen_futures::future_to_promise;
@@ -26,6 +29,36 @@ fn convert_level(level: LogLevel) -> Level {
     }
 }
 
+#[wasm_bindgen]
+extern "C" {
+    pub type JSFido2GetAssertionUserInterface;
+
+    #[wasm_bindgen(structural, method)]
+    pub fn pick_credential(
+        this: &JSFido2GetAssertionUserInterface,
+        cipher_ids: Vec<String>,
+        rp_id: String,
+    ) -> Promise;
+}
+
+impl Fido2GetAssertionUserInterface for JSFido2GetAssertionUserInterface {
+    async fn pick_credential(
+        &self,
+        cipher_ids: Vec<String>,
+        rp_id: &str,
+    ) -> bitwarden_json::Result<VaultItem> {
+        log::debug!("JSFido2GetAssertionUserInterface.pick_credential");
+        let picked_id_promise = self.pick_credential(cipher_ids.clone(), rp_id.to_string());
+
+        let picked_id = wasm_bindgen_futures::JsFuture::from(picked_id_promise).await;
+
+        Ok(VaultItem::new(
+            picked_id.unwrap().as_string().unwrap(),
+            "name".to_string(),
+        ))
+    }
+}
+
 // Rc<...> is to avoid needing to take ownership of the Client during our async run_command
 // function https://github.com/rustwasm/wasm-bindgen/issues/2195#issuecomment-799588401
 #[wasm_bindgen]
@@ -53,4 +86,27 @@ impl BitwardenClient {
             Ok(result.into())
         })
     }
+
+    #[wasm_bindgen]
+    pub async fn client_get_assertion(
+        &mut self,
+        param: String,
+        user_interface: JSFido2GetAssertionUserInterface,
+    ) {
+        log::info!("wasm_bindgen.client_get_assertion");
+        log::debug!("wasm_bindgen.client_get_assertion");
+        // let rc = self.0.clone();
+        // future_to_promise(async move {
+        //     let result = rc.run_command(&js_input).await;
+        //     Ok(result.into())
+        // })
+        let request = Fido2ClientGetAssertionRequest {
+            webauthn_json: param,
+        };
+
+        self.0
+            .client_get_assertion(request, user_interface)
+            .await
+            .unwrap();
+    }
 }

crates/bitwarden/Cargo.toml

@@ -57,6 +57,7 @@ sha1 = ">=0.10.5, <0.11"
 sha2 = ">=0.10.6, <0.11"
 thiserror = ">=1.0.40, <2.0"
 uniffi = { version = "=0.26.1", optional = true, features = ["tokio"] }
+url = "2.5.0"
 uuid = { version = ">=1.3.3, <2.0", features = ["serde"] }
 zxcvbn = ">= 2.2.2, <3.0"
 

crates/bitwarden/src/platform/client_platform.rs

@@ -1,5 +1,6 @@
 use super::{
     client_get_assertion,
+    fido2::Fido2GetAssertionUserInterface,
     generate_fingerprint::{generate_fingerprint, generate_user_fingerprint},
     Fido2ClientGetAssertionRequest, FingerprintRequest, FingerprintResponse,
 };
@@ -18,8 +19,13 @@ impl<'a> ClientPlatform<'a> {
         generate_user_fingerprint(self.client, fingerprint_material)
     }
 
-    pub fn client_get_assertion(&self, request: Fido2ClientGetAssertionRequest) -> Result<String> {
-        client_get_assertion(request)
+    pub async fn client_get_assertion(
+        &self,
+        request: Fido2ClientGetAssertionRequest,
+        user_interface: impl Fido2GetAssertionUserInterface,
+    ) -> Result<String> {
+        log::debug!("client_platform.client_get_assertion");
+        client_get_assertion(request, user_interface).await
     }
 }