[PM-41798] 1Password access module

.aikido

@@ -0,0 +1,4 @@
+# Test vectors are derived from a throwaway account, no real secrets there.
+exclude:
+  paths:
+    - crates/bitwarden-importers/src/importers/onepassword/access/fixtures

.github/renovate.json5

@@ -77,7 +77,14 @@
     },
     {
       matchManagers: ["cargo"],
-      matchPackageNames: ["keepass"],
+      matchPackageNames: [
+        "aes-gcm",
+        "crypto-bigint",
+        "hkdf",
+        "icu_normalizer",
+        "keepass",
+        "pbkdf2",
+      ],
       commitMessagePrefix: "[deps] Tools:",
       reviewers: ["team:team-tools-dev"],
     },

.prettierignore

@@ -9,6 +9,7 @@ crates/bitwarden-uniffi/swift/*
 
 # Test fixtures
 crates/bitwarden-exporters/resources/*
+crates/bitwarden-importers/src/importers/onepassword/access/fixtures/*
 
 # CI output
 clippy_result.sarif

Cargo.toml

@@ -21,6 +21,7 @@ keywords = ["bitwarden"]
 [workspace.dependencies]
 
 # External crates that are expected to maintain a consistent version across all crates
+aes-gcm = { version = "0.11.0", features = ["zeroize"] }
 async-trait = ">=0.1.80, <0.2"
 bitwarden-api-api = { path = "crates/bitwarden-api-api", version = "=3.0.0" }
 bitwarden-api-base = { path = "crates/bitwarden-api-base", version = "=3.0.0" }
@@ -77,15 +78,22 @@ chrono = { version = ">=0.4.26, <0.5", features = [
     "std",
 ], default-features = false }
 ciborium = ">=0.2.2, <0.3"
+crypto-bigint = { version = "0.7.5", features = ["alloc"], default-features = false }
 data-encoding = ">=2.0, <3"
 ed25519-dalek = { version = "3.0.0-pre.7" }
 futures = ">=0.3.31, <0.4"
+hkdf = "0.13.0"
 hmac = "0.13.0"
 http = ">=1.4.0, <2.0"
+icu_normalizer = { version = "2.2.0", features = [
+    "compiled_data",
+    "utf8_iter",
+], default-features = false }
 js-sys = { version = ">=0.3.72, <0.4" }
 keepass = { version = ">=0.13.7, <0.14", default-features = false }
 mockall = { version = ">=0.13.1, <0.16" }
 password-rules-parser = ">=1.1.0, <2"
+pbkdf2 = { version = "0.13.0", default-features = false }
 proc-macro2 = ">=1.0.89, <2"
 quote = ">=1.0.37, <2"
 rand = ">=0.10.0, <0.11"
@@ -205,9 +213,3 @@ opt-level = 3
 # Stripping the binary reduces the size by ~30%, but the stacktraces won't be usable anymore.
 # This is fine as long as we don't have any unhandled panics, but let's keep it disabled for now
 # strip = true
-
-# crypto-bigint 0.7.0-0.7.4 were yanked and 0.7.5 has not yet propagated to the sparse index,
-# so `rsa`/`ssh-key` (which require `^0.7`) cannot be resolved from crates.io. Pin to the 0.7.5
-# tag until the registry index catches up, then remove this patch.
-[patch.crates-io]
-crypto-bigint = { git = "https://github.com/RustCrypto/crypto-bigint", tag = "v0.7.5" }

crates/bitwarden-importers/Cargo.toml

@@ -3,6 +3,7 @@ name = "bitwarden-importers"
 description = """
 Internal crate for the bitwarden crate. Do not use.
 """
+exclude = ["**/fixtures"]
 
 version.workspace = true
 authors.workspace = true
@@ -15,6 +16,10 @@ license = "GPL-3.0-only OR LicenseRef-Bitwarden-SDK"
 keywords.workspace = true
 
 [features]
+# Re-exports the 1Password access module so the out-of-tree CLI can drive it against a real
+# account. Never enable in production builds.
+# TODO: Remove once the importer consumes the module directly.
+test-utils = []
 uniffi = [
     "dep:uniffi",
     "bitwarden-core/uniffi",
@@ -31,29 +36,46 @@ wasm = [
 ]
 
 [dependencies]
+aes-gcm = { workspace = true }
+async-trait = { workspace = true }
 bitwarden-api-api = { workspace = true }
 bitwarden-collections = { workspace = true }
 bitwarden-core = { workspace = true }
 bitwarden-crypto = { workspace = true }
 bitwarden-error = { workspace = true }
 bitwarden-exporters = { workspace = true }
+bitwarden-random = { workspace = true }
 bitwarden-vault = { workspace = true }
 chrono = { workspace = true, features = ["std"] }
+crypto-bigint = { workspace = true }
 data-encoding = { workspace = true }
+hkdf = { workspace = true }
+hmac = { workspace = true }
+icu_normalizer = { workspace = true }
 keepass = { workspace = true }
+pbkdf2 = { workspace = true }
+rand = { workspace = true }
+reqwest = { workspace = true }
+rsa = { workspace = true }
 serde = { workspace = true }
+serde_json = { workspace = true }
+sha1 = { workspace = true }
+sha2 = { workspace = true }
 thiserror = { workspace = true }
 tsify = { workspace = true, optional = true }
 uniffi = { workspace = true, optional = true }
+url = { workspace = true }
 uuid = { workspace = true }
 wasm-bindgen = { workspace = true, optional = true }
 wasm-bindgen-futures = { workspace = true, optional = true }
 zeroize = { workspace = true }
 
 [dev-dependencies]
+bitwarden-api-base = { workspace = true }
 bitwarden-core = { workspace = true, features = ["internal", "test-fixtures"] }
 keepass = { workspace = true, features = ["save_kdbx4"] }
 tokio = { workspace = true, features = ["rt"] }
+wiremock = { workspace = true }
 
 [lints]
 workspace = true

crates/bitwarden-importers/src/importers/mod.rs

@@ -2,3 +2,4 @@
 //! [`crate::pipeline::ParsedImport`]; the generic pipeline encrypts and submits it.
 
 pub(crate) mod kdbx;
+pub(crate) mod onepassword;

crates/bitwarden-importers/src/importers/onepassword/access/README.md

@@ -0,0 +1,52 @@
+# 1Password access module
+
+Read access to a 1Password account. Logging in needs the username, master password and Secret Key,
+plus a TOTP passcode when the account has 2FA. Once authenticated it downloads and decrypts every
+accessible vault into a native 1Password model.
+
+A Rust port of the OnePassword module in Bitwarden's C# `password-manager-access` library.
+
+The 1P and BW name things differently. 1P has vaults that are independent, could be shared
+separately, could have different access rights, encrypted with different keys. They will be imported
+into Bitwarden collections. 1P doesn't have folders, only tags.
+
+## Notes
+
+- Supports TOTP 2FA only ATM
+- No SSO support
+- No service account support (they are not so good for export/import)
+- One entry point, `Client::download_all_vaults`. No vault selection, no random access
+- Added `aes-gcm`, `hkdf`, `pbkdf2`, `crypto-bigint` and `icu_normalizer` to the workspace, will
+  increase the wasm size.
+- SRP uses `crypto-bigint` rather than `num-bigint` for the constant-time `modpow`
+- Uses RustCrypto directly rather than `bitwarden-crypto`, which keeps HKDF, AES-GCM and RSA-OAEP
+  private
+- Only the two algorithms the web client implements, `PBES2g-HS256` and the legacy `PBES2-HS256`.
+  The `HS512` spellings the C# original accepts are rejected: the client throws `Invalid PBKDF2 alg`
+  on them, so its behaviour there is unknown
+- The legacy path is transcribed from the client and cannot be tested end to end. Patching the web
+  client to mint a `PBES2-HS256` account fails: the server answers `POST /api/v1/user/auth` with a
+  400, so no new account can be created on it
+- Only the credentials and the keys are zeroed. The decrypted vault data is not
+
+## TODO
+
+- The client fingerprint lives in `identity.rs`: app version, HTTP library and per-platform strings.
+  Question: do we need per-platform impersonation, or is one fixed identity enough?
+- There are many tests converted from the C# repo, they became very noisy in Rust. Do we even need
+  them? See start_registers_an_unknown_device_then_retries for an example.
+- Do we need to import password history?
+- A wrong password reports as
+  `Internal("unexpected response from 'v2/auth/confirm-key' (HTTP 401)")` rather than
+  `BadCredentials`. The server only rejects at `confirm-key`, and its body there is not the
+  `errorCode` shape `parse_server_error` understands
+- The wire DTOs derive `Debug`, so a debug log of one would print secrets
+- The sign-in domain is taken as a raw string and never validated
+- A vault we hold no key for is skipped silently, and one undecryptable item aborts the whole import
+- The module is under a blanket `allow(dead_code, unused_imports)` until the conversion layer lands
+- Now that only PBKDF2-SHA256 is supported, `bitwarden_crypto::pbkdf2` would do for that one step
+- The username goes on the wire raw, `v2/auth/methods` and `v3/auth/start` do not get the normalized
+  one
+- `SrpInfo` validates the SRP key method, then `compute_x` ignores it and always derives the modern
+  way
+- `OnePasswordError::TwoFactorRequired` is never constructed