Privacy-first password manager with built-in email aliasing. Fully encrypted and self-hostable.
//! WASM bindings for the web app and the browser extension.
use serde::Serialize;
use wasm_bindgen::prelude::*;
use crate::credential_matcher::{filter_credentials, CredentialMatcherInput, CredentialMatcherOutput};
use crate::password_generator::{available_languages, generate_password};
use crate::vault_codec;
/// Initialize panic hook for better error messages.
#[wasm_bindgen(start)]
pub fn init() {
console_error_panic_hook::set_once();
}
/// A JS error carrying the core's error message.
fn js_err(error: impl std::fmt::Display) -> JsValue {
JsValue::from_str(&error.to_string())
}
/// Serialize a core value to a JsValue with Rust maps rendered as plain JS objects and absent optionals as null.
fn to_js<T: Serialize>(value: &T) -> Result<JsValue, JsValue> {
value.serialize(&serde_wasm_bindgen::Serializer::new().serialize_maps_as_objects(true).serialize_missing_as_null(true)).map_err(js_err)
}
/// The sha256 (lowercase hex) of an uploaded logo's bytes: the `Source` of a `custom` logo row, and
/// what `vaultCodecLogoIdFor` then derives the row id from.
#[wasm_bindgen(js_name = vaultCodecLogoContentHash)]
pub fn vault_codec_logo_content_hash_js(bytes: Vec<u8>) -> String {
vault_codec::logo_content_hash(&bytes)
}
/// The `Logos.Id` to use for the logo `(kind, source)` inside the manifest with id `manifestId`.
/// `kind` is 'favicon' (source = domain), 'builtin' (source = catalog key) or 'custom' (source = image content hash).
#[wasm_bindgen(js_name = vaultCodecLogoIdFor)]
pub fn vault_codec_logo_id_for_js(manifest_id: String, kind: String, source: String) -> String {
vault_codec::logo_id_for(&manifest_id, &kind, &source)
}
/// Filter credentials for autofill. Input: `CredentialMatcherInput`. Output: `CredentialMatcherOutput`.
#[wasm_bindgen(js_name = filterCredentials)]
pub fn filter_credentials_js(input: JsValue) -> Result<JsValue, JsValue> {
let input: CredentialMatcherInput = serde_wasm_bindgen::from_value(input).map_err(js_err)?;
let output: CredentialMatcherOutput = filter_credentials(input);
to_js(&output)
}
/// The domain of a URL or partial domain: no protocol, `www.` prefix, path, query or fragment.
#[wasm_bindgen(js_name = extractDomain)]
pub fn extract_domain_js(url: &str) -> String {
crate::credential_matcher::extract_domain(url)
}
/// The root domain of a domain: `sub.example.co.uk` gives `example.co.uk`.
#[wasm_bindgen(js_name = extractRootDomain)]
pub fn extract_root_domain_js(domain: &str) -> String {
crate::credential_matcher::extract_root_domain(domain)
}
/// Whether a page on `host` may use `rpId` as its WebAuthn relying party id: the host or a parent that is not a public suffix.
#[wasm_bindgen(js_name = isRpIdAllowedForHost)]
pub fn is_rp_id_allowed_for_host_js(rp_id: &str, host: &str) -> bool {
crate::credential_matcher::is_rp_id_allowed_for_host(rp_id, host)
}
/// Whether `callerOrigin` is listed in the `origins` of an rp id's `/.well-known/webauthn` file (WebAuthn related origins).
#[wasm_bindgen(js_name = isRelatedOriginAllowed)]
pub fn is_related_origin_allowed_js(caller_origin: &str, origins: Vec<String>) -> bool {
crate::credential_matcher::is_related_origin_allowed(caller_origin, &origins)
}
/// The favicon target for an item's URLs (in item order): the URL to fetch and the `Logos.Source` key, or null.
#[wasm_bindgen(js_name = selectFaviconTarget)]
pub fn select_favicon_target_js(urls: Vec<String>) -> Result<JsValue, JsValue> {
match crate::favicon::select_favicon_target(&urls) {
Some(target) => to_js(&target),
None => Ok(JsValue::NULL),
}
}
/// The RFC 6238 code for a Base32 secret at `unixSeconds`, or undefined for an unusable secret. Unknown parameters fall back to SHA1, 6 digits, 30 seconds.
#[wasm_bindgen(js_name = generateTotpCode)]
pub fn generate_totp_code_js(secret: &str, unix_seconds: f64, algorithm: &str, digits: u32, period: u32) -> Option<String> {
crate::totp::generate_totp_code(secret, unix_seconds as i64, algorithm, digits, period)
}
/// Generate a password or passphrase from `PasswordSettings` JSON; `Type` selects "basic" or "diceware".
#[wasm_bindgen(js_name = generatePassword)]
pub fn generate_password_js(settings_json: &str) -> Result<String, JsValue> {
generate_password(settings_json).map_err(js_err)
}
/// Get the list of bundled Diceware language codes (first is the default, English).
#[wasm_bindgen(js_name = getDicewareLanguages)]
pub fn get_diceware_languages_js() -> Vec<String> {
available_languages()
}
/// Generate a random identity from `IdentityRequest` JSON; returns `Identity` JSON.
#[wasm_bindgen(js_name = generateIdentity)]
pub fn generate_identity_js(request_json: &str) -> Result<String, JsValue> {
crate::identity_generator::generate_identity(request_json).map_err(js_err)
}
/// Generate a username from name input JSON (`firstName`, `lastName`, `birthDate`).
#[wasm_bindgen(js_name = generateIdentityUsername)]
pub fn generate_identity_username_js(input_json: &str) -> Result<String, JsValue> {
crate::identity_generator::generate_username(input_json).map_err(js_err)
}
/// Generate an email prefix from name input JSON (`firstName`, `lastName`, `birthDate`).
#[wasm_bindgen(js_name = generateIdentityEmailPrefix)]
pub fn generate_identity_email_prefix_js(input_json: &str) -> Result<String, JsValue> {
crate::identity_generator::generate_email_prefix(input_json).map_err(js_err)
}
/// Generate a random alphanumeric email prefix that is not based on any identity.
#[wasm_bindgen(js_name = generateRandomEmailPrefix)]
pub fn generate_random_email_prefix_js(length: u32) -> String {
crate::identity_generator::generate_random_email_prefix(length)
}
/// Get the list of bundled identity dictionary language codes.
#[wasm_bindgen(js_name = getIdentityLanguages)]
pub fn get_identity_languages_js() -> Vec<String> {
crate::identity_generator::available_languages()
}
/// Get the list of age range option values ("random" plus 5-year ranges).
#[wasm_bindgen(js_name = getIdentityAgeRanges)]
pub fn get_identity_age_ranges_js() -> Vec<String> {
crate::identity_generator::available_age_ranges()
}
/// Parse a stored email source into its bodies and attachment metadata.
#[wasm_bindgen(js_name = parseEmailSource)]
pub fn parse_email_source_js(source: &[u8]) -> Result<JsValue, JsValue> {
to_js(&crate::email_parser::parse_email_source(source).map_err(js_err)?)
}
/// The raw RFC 822 bytes of a stored email source.
#[wasm_bindgen(js_name = decodeEmailSource)]
pub fn decode_email_source_js(source: &[u8]) -> Result<Vec<u8>, JsValue> {
crate::email_parser::decode_email_source(source).map_err(js_err)
}
/// The decoded bytes of the attachment at `index`, with its separately fetched body when it is `detached`.
#[wasm_bindgen(js_name = extractEmailAttachment)]
pub fn extract_email_attachment_js(source: &[u8], index: usize, detached_body: Option<Box<[u8]>>) -> Result<Vec<u8>, JsValue> {
crate::email_parser::extract_email_attachment(source, index, detached_body.as_deref()).map_err(js_err)
}
/// Derive a 32-byte key from a password and salt (UTF-8 bytes) with Argon2id under the `EncryptionSettings` JSON (required).
#[wasm_bindgen(js_name = argon2DeriveKey)]
pub fn argon2_derive_key_js(password: String, salt: &str, encryption_settings: &str) -> Result<js_sys::Uint8Array, JsValue> {
let password = zeroize::Zeroizing::new(password);
let params = crate::crypto::argon2::Argon2Params::from_settings_json(encryption_settings).map_err(js_err)?;
crate::crypto::argon2::argon2_derive_key(password.as_bytes(), salt.as_bytes(), params).map(|key| js_sys::Uint8Array::from(&key[..])).map_err(js_err)
}
/// AES-256-GCM decrypt a base64 `IV | ciphertext | tag` string (no AAD) into UTF-8 with a base64 key. An empty ciphertext is an error.
#[wasm_bindgen(js_name = symmetricDecrypt)]
pub fn symmetric_decrypt_js(base64_ciphertext: &str, key_base64: &str) -> Result<String, JsValue> {
crate::crypto::aes_gcm::decrypt_text(base64_ciphertext, key_base64, &[]).map_err(js_err)
}
/// AES-256-GCM decrypt `IV | ciphertext | tag` bytes with a base64 key.
#[wasm_bindgen(js_name = symmetricDecryptBytes)]
pub fn symmetric_decrypt_bytes_js(encrypted: &[u8], key_base64: &str) -> Result<Vec<u8>, JsValue> {
crate::crypto::aes_gcm::decrypt(encrypted, key_base64, &[]).map_err(js_err)
}
/// AES-256-GCM encrypt bytes with a base64 key (random IV, no AAD) into `IV | ciphertext | tag` bytes.
#[wasm_bindgen(js_name = symmetricEncryptBytes)]
pub fn symmetric_encrypt_bytes_js(plaintext: &[u8], key_base64: &str) -> Result<Vec<u8>, JsValue> {
crate::crypto::aes_gcm::encrypt(plaintext, key_base64, &[]).map_err(js_err)
}
/// SHA-256 of a mobile login request's public key JWK string, unpadded base64url; the QR code carries it.
#[wasm_bindgen(js_name = mobileLoginPublicKeyHash)]
pub fn mobile_login_public_key_hash_js(public_key_jwk: &str) -> String {
crate::crypto::mobile_login_public_key_hash(public_key_jwk)
}
/// The verification code both devices show for a mobile login request's public key JWK string.
#[wasm_bindgen(js_name = mobileLoginVerificationCode)]
pub fn mobile_login_verification_code_js(public_key_jwk: &str) -> String {
crate::crypto::mobile_login_verification_code(public_key_jwk)
}
/// The fingerprint of the account's own signing key, derived from its private key encrypted with the Account Key.
#[wasm_bindgen(js_name = accountSigningKeyFingerprint)]
pub fn account_signing_key_fingerprint_js(encrypted_signing_private_key: &str, account_key_base64: &str) -> Result<String, JsValue> {
crate::crypto::account_signing_key_fingerprint(encrypted_signing_private_key, account_key_base64).map_err(js_err)
}
/// Open an approved mobile login request with its one-off JWK private key: `{ accountKey, payload }`.
#[wasm_bindgen(js_name = mobileLoginOpenApproval)]
pub fn mobile_login_open_approval_js(private_key_jwk: &str, encrypted_account_key: &str, encrypted_payload_key: &str, encrypted_payload: &str) -> Result<JsValue, JsValue> {
to_js(&crate::crypto::mobile_login_open_approval(private_key_jwk, encrypted_account_key, encrypted_payload_key, encrypted_payload).map_err(js_err)?)
}
/// A new RSA-OAEP-256 2048-bit key pair, both halves as JWK strings: `{ publicKey, privateKey }`.
#[wasm_bindgen(js_name = generateRsaKeyPair)]
pub fn generate_rsa_key_pair_js() -> Result<JsValue, JsValue> {
to_js(&crate::crypto::generate_rsa_key_pair().map_err(js_err)?)
}
/// RSA-OAEP-256 decrypt base64 ciphertext with a JWK private key.
#[wasm_bindgen(js_name = rsaDecrypt)]
pub fn rsa_decrypt_js(base64_ciphertext: &str, private_key_jwk: &str) -> Result<Vec<u8>, JsValue> {
crate::crypto::rsa_oaep::decrypt(base64_ciphertext, private_key_jwk, &[]).map_err(js_err)
}
/// Decrypt the shared manifest name encrypted into an invitation for this JWK private key.
#[wasm_bindgen(js_name = decryptManifestInvitationName)]
pub fn decrypt_manifest_invitation_name_js(encrypted_name: &str, manifest_id: &str, private_key_jwk: &str) -> Result<String, JsValue> {
crate::vault_sync::keys::decrypt_manifest_invitation_name(encrypted_name, manifest_id, private_key_jwk).map_err(js_err)
}
/// Encrypt .avux bytes into an .avex file under the export password.
#[wasm_bindgen(js_name = avexEncrypt)]
pub fn avex_encrypt_js(avux: Vec<u8>, password: String, exported_at: &str, app_version: &str) -> Result<Vec<u8>, JsValue> {
let (avux, password) = (zeroize::Zeroizing::new(avux), zeroize::Zeroizing::new(password));
crate::crypto::avex_encrypt(&avux, &password, exported_at, app_version).map_err(js_err)
}
/// Read and check the header of an .avex file.
#[wasm_bindgen(js_name = avexParseHeader)]
pub fn avex_parse_header_js(avex: &[u8]) -> Result<JsValue, JsValue> {
to_js(&crate::crypto::avex_parse_header(avex).map_err(js_err)?)
}
/// Decrypt an .avex file into its .avux bytes. Fails for a wrong password.
#[wasm_bindgen(js_name = avexDecrypt)]
pub fn avex_decrypt_js(avex: &[u8], password: String) -> Result<js_sys::Uint8Array, JsValue> {
let password = zeroize::Zeroizing::new(password);
crate::crypto::avex_decrypt(avex, &password).map(|avux| js_sys::Uint8Array::from(&avux[..])).map_err(js_err)
}
/// A fresh random salt for a new PIN key.
#[wasm_bindgen(js_name = pinGenerateSalt)]
pub fn pin_generate_salt_js() -> Vec<u8> {
crate::crypto::pin_generate_salt()
}
/// The salt the browser extension derives its PIN key with, from the stored random salt and the extension id.
#[wasm_bindgen(js_name = pinExtensionSalt)]
pub fn pin_extension_salt_js(salt: &[u8], extension_id: &str) -> Vec<u8> {
crate::crypto::pin_extension_salt(salt, extension_id)
}
/// Encrypt `secret` with a key derived from the PIN and salt. Returns `IV | ciphertext | tag`.
#[wasm_bindgen(js_name = pinEncrypt)]
pub fn pin_encrypt_js(pin: String, salt: &[u8], secret: Vec<u8>) -> Result<Vec<u8>, JsValue> {
let (pin, secret) = (zeroize::Zeroizing::new(pin), zeroize::Zeroizing::new(secret));
crate::crypto::pin_encrypt(&pin, salt, &secret).map_err(js_err)
}
/// Decrypt a key encrypted with the PIN. Fails for a wrong PIN.
#[wasm_bindgen(js_name = pinDecrypt)]
pub fn pin_decrypt_js(pin: String, salt: &[u8], encrypted: &[u8]) -> Result<js_sys::Uint8Array, JsValue> {
let pin = zeroize::Zeroizing::new(pin);
crate::crypto::pin_decrypt(&pin, salt, encrypted).map(|secret| js_sys::Uint8Array::from(&secret[..])).map_err(js_err)
}
/// Whether a stored failed-attempt count means the PIN is locked.
#[wasm_bindgen(js_name = pinIsLocked)]
pub fn pin_is_locked_js(failed_attempts: u32) -> bool {
crate::crypto::pin_is_locked(failed_attempts)
}
/// The counter state after one more failed PIN attempt on top of the stored count.
#[wasm_bindgen(js_name = pinRegisterFailure)]
pub fn pin_register_failure_js(failed_attempts: u32) -> Result<JsValue, JsValue> {
to_js(&crate::crypto::pin_register_failure(failed_attempts))
}
/// Create a new account key hierarchy for the base64 unlock key.
#[wasm_bindgen(js_name = createAccountKeyHierarchy)]
pub fn create_account_key_hierarchy_js(unlock_key_base64: &str) -> Result<JsValue, JsValue> {
to_js(&crate::crypto::create_account_key_hierarchy(unlock_key_base64).map_err(js_err)?)
}
/// Re-encrypt the Account Key from the old to the new base64 unlock key; `null` when the old unlock key does not open it.
#[wasm_bindgen(js_name = reencryptAccountKey)]
pub fn reencrypt_account_key_js(encrypted_account_key: &str, old_unlock_key_base64: &str, new_unlock_key_base64: &str) -> Result<JsValue, JsValue> {
match crate::crypto::reencrypt_account_key(encrypted_account_key, old_unlock_key_base64, new_unlock_key_base64) {
Ok(reencrypted) => to_js(&reencrypted),
Err(crate::crypto::KeyChainError::UnlockKeyRejected) => Ok(JsValue::NULL),
Err(e) => Err(js_err(e)),
}
}
/// The SRP `password_hash` (uppercase hex) for an account's `encryptionType`, from the base64 unlock key.
#[wasm_bindgen(js_name = deriveSrpPasswordHash)]
pub fn derive_srp_password_hash_js(unlock_key_base64: &str, encryption_type: &str) -> Result<String, JsValue> {
let unlock_key = zeroize::Zeroizing::new(crate::common::encoding::base64_decode(unlock_key_base64).map_err(js_err)?);
crate::crypto::derive_srp_password_hash(&unlock_key, encryption_type).map(|hash| hash.to_string()).map_err(js_err)
}
/// The outcome of opening a key chain: `status` is `opened`, `unlockKeyRejected`, `accountKeyRejected` or `keyChainUnreadable`.
#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct KeyChainOpenResult {
status: &'static str,
vault_encryption_key: Option<String>,
account_key: Option<String>,
account_private_key: Option<String>,
message: Option<String>,
}
impl KeyChainOpenResult {
fn from(result: Result<crate::crypto::key_chain::OpenedKeyChain, crate::crypto::KeyChainError>) -> Self {
use crate::crypto::KeyChainError;
let rejected = |status: &'static str, message: Option<String>| KeyChainOpenResult { status, vault_encryption_key: None, account_key: None, account_private_key: None, message };
match result {
Ok(opened) => KeyChainOpenResult {
status: "opened",
vault_encryption_key: Some(opened.vault_encryption_key.to_string()),
account_key: Some(opened.account_key.to_string()),
account_private_key: opened.account_private_key.as_ref().map(|key| key.to_string()),
message: None,
},
Err(KeyChainError::UnlockKeyRejected) => rejected("unlockKeyRejected", None),
Err(KeyChainError::AccountKeyRejected) => rejected("accountKeyRejected", None),
Err(KeyChainError::KeyChainUnreadable(message)) => rejected("keyChainUnreadable", Some(message)),
}
}
}
/// Open a key chain with the unlock key (base64). On success `accountKey` is what the caller stores for later unlocks.
#[wasm_bindgen(js_name = openKeyChainWithUnlockKey)]
pub fn open_key_chain_with_unlock_key_js(unlock_key: &str, encrypted_account_key: &str, encrypted_vek: &str, encrypted_account_private_key: Option<String>) -> Result<JsValue, JsValue> {
to_js(&KeyChainOpenResult::from(crate::crypto::open_key_chain_with_unlock_key(unlock_key, encrypted_account_key, encrypted_vek, encrypted_account_private_key.as_deref())))
}
/// Open a key chain with the Account Key (base64).
#[wasm_bindgen(js_name = openKeyChainWithAccountKey)]
pub fn open_key_chain_with_account_key_js(account_key: &str, encrypted_vek: &str, encrypted_account_private_key: Option<String>) -> Result<JsValue, JsValue> {
to_js(&KeyChainOpenResult::from(crate::crypto::open_key_chain_with_account_key(account_key, encrypted_vek, encrypted_account_private_key.as_deref())))
}
/// A random 32-byte SRP salt as an uppercase hex string.
#[wasm_bindgen(js_name = srpGenerateSalt)]
pub fn srp_generate_salt_js() -> String {
crate::crypto::srp::srp_generate_salt()
}
/// The SRP private key (x) as uppercase hex from the hex salt, the identity and the hex password hash.
#[wasm_bindgen(js_name = srpDerivePrivateKey)]
pub fn srp_derive_private_key_js(salt: &str, identity: &str, password_hash: &str) -> Result<String, JsValue> {
crate::crypto::srp::srp_derive_private_key(salt, identity, password_hash).map_err(js_err)
}
/// The SRP verifier (v) as uppercase hex from the hex private key, for registration.
#[wasm_bindgen(js_name = srpDeriveVerifier)]
pub fn srp_derive_verifier_js(private_key: &str) -> Result<String, JsValue> {
crate::crypto::srp::srp_derive_verifier(private_key).map_err(js_err)
}
/// A client ephemeral pair as `{ public, secret }` (uppercase hex).
#[wasm_bindgen(js_name = srpGenerateEphemeral)]
pub fn srp_generate_ephemeral_js() -> Result<JsValue, JsValue> {
to_js(&crate::crypto::srp::srp_generate_ephemeral())
}
/// The client session as `{ proof, key }` (uppercase hex) from the server's public ephemeral; hex inputs.
#[wasm_bindgen(js_name = srpDeriveSession)]
pub fn srp_derive_session_js(client_secret: &str, server_public: &str, salt: &str, identity: &str, private_key: &str) -> Result<JsValue, JsValue> {
to_js(&crate::crypto::srp::srp_derive_session(client_secret, server_public, salt, identity, private_key).map_err(js_err)?)
}
/// Whether the server's proof (M2) matches, which confirms it derived the same session key; hex inputs.
#[wasm_bindgen(js_name = srpVerifySession)]
pub fn srp_verify_session_js(client_public: &str, client_proof: &str, session_key: &str, server_proof: &str) -> Result<bool, JsValue> {
crate::crypto::srp::srp_verify_session(client_public, client_proof, session_key, server_proof).map_err(js_err)
}
/// One engine operation. The host loops on `nextCommand` / `resume` until the command is `done`; see the
/// `vault_sync` module docs for the command and response shapes.
#[wasm_bindgen(js_name = VaultSyncSession)]
pub struct VaultSyncSessionJs {
inner: crate::vault_sync::SyncSession,
}
#[wasm_bindgen(js_class = VaultSyncSession)]
impl VaultSyncSessionJs {
/// Start an operation from its `SyncRequest` JSON.
#[wasm_bindgen(constructor)]
pub fn new(request_json: &str) -> Result<VaultSyncSessionJs, JsValue> {
Ok(Self { inner: crate::vault_sync::SyncSession::new(request_json).map_err(js_err)? })
}
/// The next command for the host, as JSON.
#[wasm_bindgen(js_name = nextCommand)]
pub fn next_command(&self) -> Result<String, JsValue> {
self.inner.next_command().map_err(js_err)
}
/// Take the raw bytes attached to the last command (the body of a binary `http` request), if any.
#[wasm_bindgen(js_name = commandBytes)]
pub fn command_bytes(&self) -> Result<Option<Vec<u8>>, JsValue> {
self.inner.command_bytes().map_err(js_err)
}
/// Hand the host's response to the last command back, as JSON, with raw bytes for a `dbExport` or a binary `http` response.
pub fn resume(&self, response_json: &str, bytes: Option<Vec<u8>>) -> Result<(), JsValue> {
self.inner.resume(response_json, bytes).map_err(js_err)
}
}
/// SQLite host bindings: an in-memory database the JS hosts read and write through.
mod sqlite_js {
use js_sys::{Array, Object, Reflect, Uint8Array};
use wasm_bindgen::prelude::*;
use super::js_err;
use crate::sqlite_host::{MemoryDatabase, SqlResult, SqlValue};
/// JavaScript's `Number.MAX_SAFE_INTEGER` (2^53 - 1).
const MAX_SAFE_INTEGER: f64 = 9_007_199_254_740_991.0;
/// An in-memory SQLite database the host reads and writes through.
#[wasm_bindgen(js_name = SqliteMemoryDatabase)]
pub struct SqliteMemoryDatabaseJs {
inner: Option<MemoryDatabase>,
}
#[wasm_bindgen(js_class = SqliteMemoryDatabase)]
impl SqliteMemoryDatabaseJs {
/// Open a database from its SQLite file bytes.
#[wasm_bindgen(js_name = fromBytes)]
pub fn from_bytes(bytes: &[u8]) -> Result<SqliteMemoryDatabaseJs, JsValue> {
Ok(Self { inner: Some(MemoryDatabase::from_bytes(bytes).map_err(js_err)?) })
}
/// Open an empty database.
pub fn empty() -> Result<SqliteMemoryDatabaseJs, JsValue> {
Ok(Self { inner: Some(MemoryDatabase::empty().map_err(js_err)?) })
}
/// Run a statement that returns no rows and report how many rows it changed.
pub fn run(&self, sql: &str, params: JsValue) -> Result<f64, JsValue> {
Ok(self.db()?.execute(sql, ¶ms_from_js(params)?).map_err(js_err)? as f64)
}
/// Run a statement and return its rows.
pub fn query(&self, sql: &str, params: JsValue) -> Result<JsValue, JsValue> {
Ok(rows_to_js(&self.db()?.query_values(sql, ¶ms_from_js(params)?).map_err(js_err)?))
}
/// Run one or more statements separated by semicolons, without parameters.
pub fn exec(&self, sql: &str) -> Result<(), JsValue> {
self.db()?.execute_batch(sql).map_err(js_err)
}
/// The database as SQLite file bytes.
pub fn export(&self) -> Result<Vec<u8>, JsValue> {
self.db()?.export().map_err(js_err)
}
/// Close the database and free its memory.
pub fn close(&mut self) {
self.inner = None;
}
fn db(&self) -> Result<&MemoryDatabase, JsValue> {
self.inner.as_ref().ok_or_else(|| JsValue::from_str("The database is closed"))
}
}
fn params_from_js(params: JsValue) -> Result<Vec<SqlValue>, JsValue> {
if params.is_undefined() || params.is_null() {
return Ok(Vec::new());
}
Array::from(¶ms).iter().map(|value| value_from_js(&value)).collect()
}
fn value_from_js(value: &JsValue) -> Result<SqlValue, JsValue> {
if value.is_null() || value.is_undefined() {
Ok(SqlValue::Null)
} else if let Some(text) = value.as_string() {
Ok(SqlValue::Text(text))
} else if let Some(flag) = value.as_bool() {
Ok(SqlValue::Integer(flag as i64))
} else if let Some(number) = value.as_f64() {
// Whole numbers within the safe integer range bind as INTEGER.
if number.fract() == 0.0 && number.abs() <= MAX_SAFE_INTEGER { Ok(SqlValue::Integer(number as i64)) } else { Ok(SqlValue::Real(number)) }
} else if value.is_instance_of::<Uint8Array>() {
Ok(SqlValue::Blob(Uint8Array::new(value).to_vec()))
} else {
Err(JsValue::from_str("Unsupported SQLite parameter: expected string, number, boolean, null or Uint8Array"))
}
}
fn value_to_js(value: &SqlValue) -> JsValue {
match value {
SqlValue::Null => JsValue::NULL,
SqlValue::Integer(number) => JsValue::from_f64(*number as f64),
SqlValue::Real(number) => JsValue::from_f64(*number),
SqlValue::Text(text) => JsValue::from_str(text),
SqlValue::Blob(bytes) => Uint8Array::from(bytes.as_slice()).into(),
}
}
fn rows_to_js(result: &SqlResult) -> JsValue {
let columns: Vec<JsValue> = result.columns.iter().map(|column| JsValue::from_str(column)).collect();
let rows = Array::new();
for row in &result.rows {
let object = Object::new();
for (index, column) in columns.iter().enumerate() {
let _ = Reflect::set(&object, column, &value_to_js(&row[index]));
}
rows.push(&object);
}
rows.into()
}
}
/// Passkey authenticator bindings for the browser extension. Results are plain objects with Uint8Array bytes.
mod passkey_js {
use js_sys::{Object, Reflect, Uint8Array};
use wasm_bindgen::prelude::*;
use super::js_err;
use crate::passkey::{self, PasskeyPrfInputs, PasskeyPrfResults};
/// The first algorithm (COSE id) in the relying party's order that the authenticator supports; ES256 for an empty list.
#[wasm_bindgen(js_name = passkeyPickAlgorithm)]
pub fn pick_algorithm(requested: Vec<i32>) -> Result<i32, JsValue> {
let requested: Vec<i64> = requested.into_iter().map(i64::from).collect();
passkey::pick_algorithm(&requested).map(|alg| alg as i32).map_err(js_err)
}
/// Create a passkey: `{ attestationObject, authenticatorData, publicKeyJwk, publicKeySpki, privateKeyJwk, prfSecret, prfResults }`.
/// With `selfAttestationClientDataHash` the attestation is "packed" self-attestation, otherwise "none".
#[wasm_bindgen(js_name = passkeyCreate)]
#[allow(clippy::too_many_arguments)]
pub fn create(
credential_id: &[u8],
rp_id: &str,
algorithm: i32,
uv_performed: bool,
enable_prf: bool,
prf_first: Option<Vec<u8>>,
prf_second: Option<Vec<u8>>,
self_attestation_client_data_hash: Option<Vec<u8>>,
) -> Result<JsValue, JsValue> {
let inputs = PasskeyPrfInputs { first: prf_first, second: prf_second };
let created = passkey::create_passkey(credential_id, rp_id, i64::from(algorithm), uv_performed, enable_prf, Some(&inputs), self_attestation_client_data_hash.as_deref()).map_err(js_err)?;
let object = Object::new();
set(&object, "attestationObject", bytes(&created.attestation_object));
set(&object, "authenticatorData", bytes(&created.authenticator_data));
set(&object, "publicKeyJwk", JsValue::from_str(&created.public_key_jwk));
set(&object, "publicKeySpki", bytes(&created.public_key_spki));
set(&object, "privateKeyJwk", JsValue::from_str(&created.private_key_jwk));
set(&object, "prfSecret", created.prf_secret.as_deref().map_or(JsValue::NULL, bytes));
set(&object, "prfResults", prf_results(created.prf_results.as_ref()));
Ok(object.into())
}
/// Sign an assertion: `{ authenticatorData, signature, prfResults }`.
#[wasm_bindgen(js_name = passkeyGetAssertion)]
pub fn get_assertion(rp_id: &str, client_data_hash: &[u8], private_key_jwk: &str, uv_performed: bool, prf_first: Option<Vec<u8>>, prf_second: Option<Vec<u8>>, prf_secret: Option<Vec<u8>>) -> Result<JsValue, JsValue> {
let inputs = PasskeyPrfInputs { first: prf_first, second: prf_second };
let assertion = passkey::get_assertion(rp_id, client_data_hash, private_key_jwk, uv_performed, Some(&inputs), prf_secret.as_deref()).map_err(js_err)?;
let object = Object::new();
set(&object, "authenticatorData", bytes(&assertion.authenticator_data));
set(&object, "signature", bytes(&assertion.signature));
set(&object, "prfResults", prf_results(assertion.prf_results.as_ref()));
Ok(object.into())
}
fn prf_results(results: Option<&PasskeyPrfResults>) -> JsValue {
let Some(results) = results else { return JsValue::NULL };
let object = Object::new();
set(&object, "first", bytes(&results.first));
set(&object, "second", results.second.as_deref().map_or(JsValue::NULL, bytes));
object.into()
}
fn bytes(value: &[u8]) -> JsValue {
Uint8Array::from(value).into()
}
fn set(object: &Object, key: &str, value: JsValue) {
let _ = Reflect::set(object, &JsValue::from_str(key), &value);
}
}