[PM-20094] Generate Password/Passphrase Generator WASM (#197)

## 🎟️ Tracking

https://bitwarden.atlassian.net/browse/PM-20094

## 📔 Objective

Add WASM generation for generating passwords and passphrases.

## ⏰ Reminders before review

- Contributor guidelines followed
- All formatters and local linters executed and passed
- Written new unit and / or integration tests where applicable
- Protected functional changes with optionality (feature flags)
- Used internationalization (i18n) for all UI strings
- CI builds passed
- Communicated to DevOps any deployment requirements
- Updated any necessary documentation (Confluence, contributing docs) or
informed the documentation
  team

## 🦮 Reviewer guidelines

<!-- Suggested interactions but feel free to use (or not) as you desire!
-->

- 👍 (`:+1:`) or similar for great changes
- 📝 (`:memo:`) or ℹ️ (`:information_source:`) for notes or general info
- ❓ (`:question:`) for questions
- 🤔 (`:thinking:`) or 💭 (`:thought_balloon:`) for more open inquiry
that's not quite a confirmed
  issue and could potentially benefit from discussion
- 🎨 (`:art:`) for suggestions / improvements
- ❌ (`:x:`) or ⚠️ (`:warning:`) for more significant problems or
concerns needing attention
- 🌱 (`:seedling:`) or ♻️ (`:recycle:`) for future improvements or
indications of technical debt
- ⛏ (`:pick:`) for minor or nitpick changes

Author: adudek-bw

Cargo.lock

@@ -16,17 +16,21 @@ keywords.workspace = true
 
 [features]
 uniffi = ["dep:uniffi"] # Uniffi bindings
+wasm = ["dep:tsify-next", "dep:wasm-bindgen"]
 
 [dependencies]
 bitwarden-core = { workspace = true, features = ["internal"] }
 bitwarden-crypto = { workspace = true }
+bitwarden-error = { workspace = true }
 rand = ">=0.8.5, <0.9"
 reqwest = { workspace = true }
 schemars = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
+tsify-next = { workspace = true, optional = true }
 uniffi = { workspace = true, optional = true }
+wasm-bindgen = { workspace = true, optional = true }
 
 [dev-dependencies]
 rand_chacha = "0.3.1"

crates/bitwarden-generators/Cargo.toml

@@ -1,11 +1,15 @@
 use bitwarden_crypto::EFF_LONG_WORD_LIST;
+use bitwarden_error::bitwarden_error;
 use rand::{seq::SliceRandom, Rng, RngCore};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
+#[cfg(feature = "wasm")]
+use tsify_next::Tsify;
 
 use crate::util::capitalize_first_letter;
 
+#[bitwarden_error(flat)]
 #[derive(Debug, Error)]
 pub enum PassphraseError {
     #[error("'num_words' must be between {} and {}", minimum, maximum)]
@@ -16,6 +20,7 @@ pub enum PassphraseError {
 #[derive(Serialize, Deserialize, Debug, JsonSchema)]
 #[serde(rename_all = "camelCase", deny_unknown_fields)]
 #[cfg_attr(feature = "uniffi", derive(uniffi::Record))]
+#[cfg_attr(feature = "wasm", derive(Tsify), tsify(into_wasm_abi, from_wasm_abi))]
 pub struct PassphraseGeneratorRequest {
     /// Number of words in the generated passphrase.
     /// This value must be between 3 and 20.

crates/bitwarden-generators/src/passphrase.rs

@@ -1,10 +1,14 @@
 use std::collections::BTreeSet;
 
+use bitwarden_error::bitwarden_error;
 use rand::{distributions::Distribution, seq::SliceRandom, RngCore};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
+#[cfg(feature = "wasm")]
+use tsify_next::Tsify;
 
+#[bitwarden_error(flat)]
 #[derive(Debug, Error)]
 pub enum PasswordError {
     #[error("No character set enabled")]
@@ -17,6 +21,7 @@ pub enum PasswordError {
 #[derive(Serialize, Deserialize, Debug, JsonSchema)]
 #[serde(rename_all = "camelCase", deny_unknown_fields)]
 #[cfg_attr(feature = "uniffi", derive(uniffi::Record))]
+#[cfg_attr(feature = "wasm", derive(Tsify), tsify(into_wasm_abi, from_wasm_abi))]
 pub struct PasswordGeneratorRequest {
     /// Include lowercase characters (a-z).
     pub lowercase: bool,

crates/bitwarden-generators/src/password.rs

@@ -19,6 +19,7 @@ crate-type = ["cdylib"]
 bitwarden-core = { workspace = true, features = ["wasm", "internal"] }
 bitwarden-crypto = { workspace = true, features = ["wasm"] }
 bitwarden-error = { workspace = true }
+bitwarden-generators = { workspace = true, features = ["wasm"] }
 bitwarden-ipc = { workspace = true, features = ["wasm"] }
 bitwarden-ssh = { workspace = true, features = ["wasm"] }
 bitwarden-vault = { workspace = true, features = ["wasm"] }

crates/bitwarden-wasm-internal/Cargo.toml

@@ -6,7 +6,7 @@ use bitwarden_error::bitwarden_error;
 use bitwarden_vault::VaultClientExt;
 use wasm_bindgen::prelude::*;
 
-use crate::{CryptoClient, VaultClient};
+use crate::{CryptoClient, GeneratorClient, VaultClient};
 
 #[wasm_bindgen]
 pub struct BitwardenClient(pub(crate) Client);
@@ -46,6 +46,11 @@ impl BitwardenClient {
     pub fn vault(&self) -> VaultClient {
         VaultClient::new(self.0.vault())
     }
+
+    /// Constructs a specific client for generating passwords and passphrases
+    pub fn generator(&self) -> GeneratorClient {
+        GeneratorClient::new(self.0.clone())
+    }
 }
 
 #[bitwarden_error(basic)]

crates/bitwarden-wasm-internal/src/client.rs

@@ -0,0 +1,54 @@
+use bitwarden_core::Client;
+use bitwarden_generators::{
+    GeneratorClientsExt, PassphraseGeneratorRequest, PasswordGeneratorRequest,
+};
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+pub struct GeneratorClient(Client);
+
+impl GeneratorClient {
+    /// Constructs a new SDK client for generating random passwords and passphrases
+    ///
+    /// # Arguments
+    /// - `client` - The client used to access the SDK
+    ///
+    /// # Returns
+    /// - `Self` - Returns newly constructed client
+    pub fn new(client: Client) -> Self {
+        Self(client)
+    }
+}
+
+#[wasm_bindgen]
+impl GeneratorClient {
+    /// Generates a password from a provided request
+    ///
+    /// # Arguments
+    /// - `request` - Settings for the character sets and password length
+    ///
+    /// # Returns
+    /// - `Ok(String)` containing the generated password
+    /// - `Err(PasswordError)` if password generation fails
+    pub fn password(
+        &self,
+        request: PasswordGeneratorRequest,
+    ) -> Result<String, bitwarden_generators::PasswordError> {
+        self.0.generator().password(request)
+    }
+
+    /// Generates a passphrase from a provided request
+    ///
+    /// # Arguments
+    /// - `request` - Settings for the word count, word separators character sets
+    ///
+    /// # Returns
+    /// - `Ok(String)` containing the generated passphrase
+    /// - `Err(PassphraseError)` if passphrase generation fails
+    pub fn passphrase(
+        &self,
+        request: PassphraseGeneratorRequest,
+    ) -> Result<String, bitwarden_generators::PassphraseError> {
+        self.0.generator().passphrase(request)
+    }
+}

crates/bitwarden-wasm-internal/src/generators.rs

@@ -3,6 +3,7 @@
 mod client;
 mod crypto;
 mod custom_types;
+mod generators;
 mod init;
 mod pure_crypto;
 mod ssh;
@@ -11,5 +12,6 @@ mod vault;
 pub use bitwarden_ipc::wasm::*;
 pub use client::BitwardenClient;
 pub use crypto::CryptoClient;
+pub use generators::GeneratorClient;
 pub use init::init_sdk;
 pub use vault::{folders::ClientFolders, VaultClient};