Skip to content

Privacy-first password manager with built-in email aliasing. Fully encrypted and self-hostable.

Update docs

Leendert de Borst1fc62e236981
diff --git a/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/VaultPin.kt b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/VaultPin.kt
index a60fd5cdf..7e62e0034 100644
--- a/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/VaultPin.kt
+++ b/apps/mobile-app/android/app/src/main/java/net/aliasvault/app/vaultstore/VaultPin.kt
@@ -47,13 +47,6 @@ sealed class PinUnlockException(message: String) : Exception(message) {
* The key wrap and the attempt policy live in the Rust core (crypto/pin.rs); this class only stores them.
* Other platform implementations: VaultStore+Pin.swift (iOS), PinUnlockService.ts (browser extension).
*
- * Security features:
- * - 4 failed attempts maximum before requiring full password
- * - Salt stored in Android Keystore (makes offline brute-force impossible)
- * - Failed attempts counter stored in Keystore (prevents tampering)
- * - Encryption key derived using Argon2id (memory-hard, GPU-resistant)
- * - Encrypted data automatically deleted after max failed attempts
- *
* @param context The Android context for accessing SharedPreferences and Keystore
*/
class VaultPin(
diff --git a/core/rust/src/crypto/rsa_oaep.rs b/core/rust/src/crypto/rsa_oaep.rs
index 88b0f7f9a..cbb00ffbe 100644
--- a/core/rust/src/crypto/rsa_oaep.rs
+++ b/core/rust/src/crypto/rsa_oaep.rs
@@ -39,7 +39,7 @@ pub fn generate_rsa_key_pair() -> VaultResult<RsaKeyPair> {
Ok(RsaKeyPair { public_key: rsa_public_to_jwk(&public, Some(OAEP_PUBLIC))?, private_key: rsa_private_to_jwk(&private, Some(OAEP_PRIVATE))? })
}
-/// Check that a key pair generated elsewhere (WebCrypto) is a valid private key whose public half matches.
+/// Check that the public key belongs to the private key, such as an account public key the server serves.
pub fn validate_rsa_key_pair(key_pair: &RsaKeyPair) -> VaultResult<()> {
if rsa_private_from_jwk(&key_pair.private_key)?.to_public_key() != oaep_public_from_jwk(&key_pair.public_key)? {
return Err(VaultError::General("RSA public key does not belong to the private key".to_string()));
@@ -77,8 +77,8 @@ fn encrypt(plaintext: &[u8], public_key_jwk: &str, padding: Oaep) -> VaultResult
fn decrypt(base64_ciphertext: &str, private_key_jwk: &str, padding: Oaep) -> VaultResult<Vec<u8>> {
let private = rsa_private_from_jwk(private_key_jwk)?;
let ciphertext = base64_decode(base64_ciphertext)?;
- // Blinded: plain `decrypt` runs the exponentiation on the ciphertext as given, which leaks timing an
- // attacker who can submit chosen ciphertexts turns into key recovery (RUSTSEC-2023-0071, Marvin attack).
+ // Blinded, which reduces but does not remove the timing leak of RUSTSEC-2023-0071 (Marvin attack): the rsa crate's
+ // big-integer arithmetic is not constant time. Accepted because decryption runs on the client only.
private
.decrypt_blinded(&mut rand_core06::OsRng, padding, &ciphertext)
.map_err(|_| VaultError::General("RSA-OAEP decryption failed (wrong key or corrupt data)".to_string()))
diff --git a/core/rust/src/vault_codec/compress.rs b/core/rust/src/vault_codec/compress.rs
index 63f6a3feb..178daba8e 100644
--- a/core/rust/src/vault_codec/compress.rs
+++ b/core/rust/src/vault_codec/compress.rs
@@ -21,7 +21,7 @@ pub fn gzip(bytes: &[u8]) -> VaultResult<Vec<u8>> {
/// Cap on a decompressed payload, so a gzip bomb in a shared manifest cannot exhaust memory. Derived from the
/// server's default `MAX_UPLOAD_SIZE_MB` (100 MB per vault write, compressed): 5x that leaves room for highly
-/// compressible JSON while staying well below what a wasm32 client can hold.
+/// compressible JSON.
pub const MAX_DECOMPRESSED_PAYLOAD_BYTES: u64 = 512 * 1024 * 1024;
/// Decompress gzipped bytes into a UTF-8 string, refusing output above [`MAX_DECOMPRESSED_PAYLOAD_BYTES`].
diff --git a/core/rust/src/vault_codec/manifest.rs b/core/rust/src/vault_codec/manifest.rs
index 1ba51ac43..240f81676 100644
--- a/core/rust/src/vault_codec/manifest.rs
+++ b/core/rust/src/vault_codec/manifest.rs
@@ -25,9 +25,6 @@ pub struct Manifest {
pub canonicalized_at: String,
/// The server-side id of the manifest this snapshot belongs to.
pub manifest_id: String,
- /// Display name of the manifest, carried inside the encrypted payload so the server never sees it.
- #[serde(default, skip_serializing_if = "Option::is_none")]
- pub name: Option<String>,
/// Tables mapped to arrays of row objects. Blob columns replaced with `{ "__blobRef", "__blobKind" }`.
#[serde(default)]
pub tables: HashMap<String, Vec<CodecRecord>>,
@@ -87,9 +84,6 @@ pub struct ManifestSpec {
pub manifest_id: String,
/// Per-manifest salt for this manifest's blob hashing.
pub manifest_salt: String,
- /// Display name written into the manifest. See [`Manifest::name`].
- #[serde(default)]
- pub name: Option<String>,
}
/// One manifest produced by canonicalize: the manifest blob and the blob map hashed with its own salt.
diff --git a/scripts/dependencies/audit-allowlist.json b/scripts/dependencies/audit-allowlist.json
index de2611840..d6fcfa3b8 100644
--- a/scripts/dependencies/audit-allowlist.json
+++ b/scripts/dependencies/audit-allowlist.json
@@ -21,7 +21,7 @@
{
"id": "RUSTSEC-2023-0071",
"package": "rsa",
- "reason": "The Marvin timing attack is primarily relevant when an attacker can observe decryption timing, such as over a network. Since decryption is performed client-side only and uses decrypt_blinded, this provides a sufficient mitigation."
+ "reason": "No patched release exists. The Marvin timing attack needs an attacker who can observe many decryption timings, such as over a network. RSA decryption runs client-side only, and decrypt_blinded reduces (but does not remove) the leak. Recheck when rsa 0.10 is stable."
},
{
"id": "RUSTSEC-2026-0374",