Skip to content

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

Update docs

Leendert de Borst599cbd9cc599
diff --git a/docs/docs/security-architecture/index.mdx b/docs/docs/security-architecture/index.mdx
index 761d92d37..473494bdb 100644
--- a/docs/docs/security-architecture/index.mdx
+++ b/docs/docs/security-architecture/index.mdx
@@ -43,7 +43,8 @@ AliasVault is a password and email alias manager with end-to-end encryption: you
- The server cannot read your vaults or your emails.
- The server cannot learn your master password or any of your keys.
- The server cannot change what is in a vault, or move data between vaults or users.
-- The server cannot give anyone access to a vault: only a holder of the vault key can grant access, and every grant is signed.
+- The server cannot give anyone access to a vault: only a holder of the vault key can grant access, and a client opens a shared vault only with a grant it signed itself.
+- The server cannot pass a key of its own off as another user's: your app accepts another user's key only against the account fingerprint you typed.
What the server does store in plaintext, and what an operator can do with it, is listed in the whitepaper: [What the server knows and can do](../security-whitepaper.mdx#24-what-the-server-knows-and-can-do).
diff --git a/docs/docs/security-whitepaper.mdx b/docs/docs/security-whitepaper.mdx
index a74e8d90f..572930992 100644
--- a/docs/docs/security-whitepaper.mdx
+++ b/docs/docs/security-whitepaper.mdx
@@ -11,7 +11,7 @@ import Link from '@docusaurus/Link';
**Security architecture, cryptographic design and threat model**
-*Version 0.5 (draft), 2026-10-18. Applies to AliasVault 0.31.0 and later. See [Document information](#document-information).*
+*Version 0.5, 2026-10-22. See [Document information](#document-information).*
This document describes how AliasVault protects user data: which keys exist, where they are created and stored, how clients authenticate, how personal vaults, shared vaults and emails are encrypted, and what the server can and cannot do. It covers the cryptographic design of all clients and the server, the threat model and the known limitations. It does not cover the operational security of AliasVault Cloud or any other deployment, or the security of the platforms the clients run on. The source code is the final reference and is linked from [Appendix A](#appendix-a-implementation-map).
@@ -59,6 +59,7 @@ The guarantees in this document hold under the following assumptions.
- **The master password is strong and secret.** Anyone holding a copy of the user's encrypted data (the server database, device storage, an export) can run an offline guessing attack at the cost of one Argon2id derivation per guess, and there is no second secret mixed into the derivation. AliasVault requires at least 12 characters and shows a strength indicator, but the strength of the password is the user's choice.
- **The standard cryptography is sound.** Argon2id, AES-256-GCM, RSA-OAEP, Ed25519, SRP-6a, HKDF and HMAC with SHA-256, and the platform's random number generator (WebCrypto in browsers, the system generator on iOS and Android).
- **Members of a shared vault are trusted with that vault.** A member can read and copy everything in the vault. Removing a member stops their future access through the server; it cannot take back what they already synced ([13.1](#limitation-shared-member-removal)).
+- **Account fingerprints are exchanged outside AliasVault.** A client accepts another user's key only when its fingerprint is the account fingerprint its user typed ([10.3](#103-account-fingerprints-and-key-certifications)). This protects against a substituted key only when the fingerprint came from that person over a channel the server does not control.
- **TLS protects the transport, but vault confidentiality does not depend on it.** The master password never crosses the wire (SRP), and vault data is encrypted before it is sent. A broken TLS connection exposes session tokens and metadata, which could give API access but no decryption. The mobile apps only connect over `https://` and do not pin certificates: any certificate the device trusts is accepted, including a certificate authority the user installed, so that self-hosted servers with a private certificate authority work.
- **The server operator is trusted at the moment an email arrives.** Email reaches the SMTP service in plaintext, as the protocol requires, and is encrypted in memory before it is stored. Email encryption therefore protects stored email against later access to the database, backups and the API, not against an operator who captures mail as it arrives. Transport from the sender to the SMTP service depends on the sender's use of STARTTLS, which the service offers when certificates are configured.
@@ -71,7 +72,7 @@ The last column names the mechanism and the section that describes it.
| **Network attacker** (on-path, rogue access point, mis-issued certificate) | Reads and modifies traffic between client and server | Learn the password or any key; read vault contents; impersonate the server to a client during login | SRP with mutual proof ([5](#5-authentication-process)); vault data encrypted before transmission ([6](#6-vault-operations)); TLS |
| **Malicious website** visited while the extension is installed | Runs scripts in its own page, sends messages to the content script, calls the WebAuthn API | Obtain credentials or passkey signatures for another site; trigger autofill for another origin; read extension storage | Autofill suggestions matched on the registrable domain; one item released per user pick, only to the frame it was picked in; content-script isolation; WebAuthn origin and relying-party checks ([8](#8-passkey-authentication)) |
| **Another AliasVault user**, including current and former shared-vault members | Holds their own account, grants they were given, and copies of data they synced | Open a vault they were not invited to; read another user's personal vault; keep receiving a shared vault's mail after removal | One VEK per vault, grants only to invited accounts, per-vault authorization on the server for vaults and their email ([10](#10-vault-sharing)) |
-| **Holder of a stolen session token** | Calls the API as the user until the token expires or is revoked | Decrypt anything | Tokens never decrypt; access tokens live 10 minutes; refresh tokens are stored hashed and rotated on use; sessions can be revoked ([5.3](#53-session-tokens)) |
+| **Holder of a stolen session token** | Calls the API as the user until the token expires or its session is revoked | Decrypt anything; send an alias's future email to another vault; approve a Login with Mobile request | Tokens never decrypt; access tokens live 10 minutes; refresh tokens are stored hashed and rotated on use ([5.3](#53-session-tokens)); Login with Mobile approvals are signed and refused from a revoked session ([9.2](#92-login-flow)); alias moves are signed ([7.1](#71-key-generation-and-storage)) |
| **Holder of a copy of the encrypted data** (server database, device storage, backup, export file) | Unlimited offline computation | Decrypt without the master password or export password | Argon2id with a client-enforced minimum ([4](#4-key-derivation-and-key-hierarchy), [12](#12-vault-exports)); known limitation: the opt-in extension PIN can be guessed offline from a copy of the extension storage ([13.3](#limitation-pin-unlock)) |
| **Sender of a crafted email** | Sends any content to any alias | Run code in a client; read anything from the vault; learn anything about the recipient | Parser in the memory-safe Rust core; HTML sanitized and rendered in a sandboxed frame without scripts; attachments never opened automatically ([7](#7-email)) |
| **Person with physical access to a locked device** | Uses the device as found | Unlock without the master password, PIN or biometrics | Device unlock methods with attempt limits ([11](#11-protecting-keys-on-the-device)); anything beyond that is out of scope ([2.5](#25-out-of-scope)) |
@@ -82,7 +83,7 @@ The last column names the mechanism and the section that describes it.
- Account: username, creation and last-activity times, the SRP salt and verifier, the Argon2id settings of each account unlock method, the TOTP secret and recovery codes when two-factor authentication is enabled, and lockout and block state.
- Keys: public keys with their signatures; every private and symmetric key only in encrypted form ([4.1](#41-key-hierarchy)).
- Vaults: the ciphertext of manifests, data buckets and blobs, with manifest ids, revision numbers, sizes, upload times, ciphertext hashes and a limited history of older versions; the number of items in each vault, reported by the client for operational statistics; and the blobs each vault revision references, with their kind (attachment or logo).
-- Sharing: groups, their members and roles, which accounts hold a grant on which vault, and pending invitations.
+- Sharing: groups, their members and roles, which accounts hold a grant on which vault, pending invitations, and key certifications (which account verified which other account's signing key).
- Aliases: every alias address, the vault it belongs to, its state (active, paused, removed) and its creation time.
- Email: the recipient alias, the time received, the sender's `Date` header, the attachment count and the ciphertext size ([7.4](#74-what-the-server-sees)).
- Logos: the URL of an item whose logo is fetched through the server's favicon service.
@@ -91,7 +92,7 @@ The last column names the mechanism and the section that describes it.
**What the server can do:**
- Deny service, delete data and block accounts ([2.5](#25-out-of-scope)), and serve an older version of a vault ([13.2](#limitation-rollback)).
-- Through the admin portal: see the metadata above, disable a user's two-factor authentication, and block or delete an account. Within 7 days by default, it can also undo a password change made without a key rotation ([4.1](#41-key-hierarchy)).
+- Through the admin portal: see the metadata above, disable a user's two-factor authentication, change a username, change or remove a user's aliases, and block or delete an account. Within 7 days by default, it can also undo a password change made without a key rotation ([4.1](#41-key-hierarchy)).
- Serve modified web app code ([2.2](#22-trust-assumptions)).
- Read an incoming email at the moment it arrives ([2.2](#22-trust-assumptions)), and deliver an email of its own making to any alias.
- Answer whether an alias address is taken, which anyone can also learn from the SMTP bounce for an unknown address.
@@ -129,7 +130,7 @@ AliasVault uses only established primitives standardized by NIST and the IETF; h
| [RSA-OAEP](https://en.wikipedia.org/wiki/Optimal_asymmetric_encryption_padding) | Email encryption, Login with Mobile, vault sharing | [7](#7-email), [9](#9-login-with-mobile), [10](#10-vault-sharing) |
| [Ed25519](https://en.wikipedia.org/wiki/EdDSA#Ed25519) | Signing what an account publishes or changes | [4.1](#41-key-hierarchy), [7](#7-email), [10](#10-vault-sharing) |
| [HMAC-SHA256](https://en.wikipedia.org/wiki/HMAC) | Blob addresses, passkey PRF, session token (JWT) signing | [5](#5-authentication-process), [6](#6-vault-operations), [8](#8-passkey-authentication) |
-| [SHA-256](https://en.wikipedia.org/wiki/SHA-2) | Integrity checks and key fingerprints | [9](#9-login-with-mobile), [Vault Format and Sync](./security-architecture/vault-format.mdx) |
+| [SHA-256](https://en.wikipedia.org/wiki/SHA-2) | Integrity checks and key fingerprints | [9](#9-login-with-mobile), [10.3](#103-account-fingerprints-and-key-certifications), [Vault Format and Sync](./security-architecture/vault-format.mdx) |
| [TOTP](https://en.wikipedia.org/wiki/Time-based_one-time_password) | Two-factor authentication | [5](#5-authentication-process) |
| [ES256](https://en.wikipedia.org/wiki/Elliptic_Curve_Digital_Signature_Algorithm) / [RS256](https://en.wikipedia.org/wiki/PKCS_1) | Passkeys (WebAuthn) | [8](#8-passkey-authentication) |
@@ -184,8 +185,9 @@ When you change your master password, you can choose to also replace all encrypt
- **Replaced**: the Account Key, the personal VEK, both account keypairs and the personal vault's Vault Delivery Keypair, all created on the client. The new signing key is signed with the old one.
- **Re-encrypted**: the personal vault and its blob keys with the new VEK, and every grant the user holds for the new account public key.
+- **Signed again**: every key certification the user made, with the new signing key, after the client verified it under the old one ([10.3](#103-account-fingerprints-and-key-certifications)).
- **Unchanged**: blob bytes, shared vault VEKs and received emails, whose old delivery keypair stays in the vault.
-- **Deleted**: the previous personal VEK, the older revisions of the personal vault with the blobs only they refer to, the password history and the old account encryption keypair, as they can only be opened with the old keys. The old signing public keys stay, so the chain of signing keys can be followed.
+- **Deleted**: the previous personal VEK, the older revisions of the personal vault with the blobs only they refer to, the password history and the old account encryption keypair, as they can only be opened with the old keys. The old signing public keys stay on the server, each new one signed by the one before it.
- **All or nothing**: the server applies the rotation in one transaction and refuses it when a blob key or grant is missing or the vault changed in the meantime.
- **Other devices**: their sessions are revoked, and a device still on the old keys is signed out on its next sync. Device unlock methods have to be set up again, and pending invitations to the user are closed.
- **Scope**: the old keys cannot decrypt anything written to the personal vault after the rotation. Received emails and shared vaults stay under their existing keys ([13.1](#limitation-shared-member-removal)).
@@ -221,7 +223,7 @@ Your master password is never sent to the server. Instead, during login, client
### 5.4. Brute-force protection
- After 10 failed login attempts an account is locked for 30 minutes
- Registration, Login with Mobile, logo fetching and alias availability checks are rate limited per account and per IP address, and the server operator can block IP ranges
-- Every login attempt and security-relevant action (password change, key rotation, two-factor changes, logout, shared vault creation and deletion, account deletion) is written to the authentication log with the IP address and client details
+- Every login attempt and security-relevant action (password change, key rotation, two-factor changes, logout, shared vault creation, deletion, invitations, joins, leaves and access revocations, key certifications, account deletion) is written to the authentication log with the IP address and client details
## 6. Vault operations
Your vaults are always encrypted on your device before they are uploaded. Each vault (your personal vault and every shared vault) is stored on the server as one encrypted *manifest*, plus separate data buckets and blobs. The server only receives and stores these in encrypted form and can never read their contents.
@@ -352,7 +354,7 @@ Two pieces of data travel through the server, both encrypted for the one-time pu
- Mobile app retrieves the public key and requester details (browser, OS, IP address) from the server and checks the public key against the hash in the QR code
- User picks the verification code shown on the requesting screen out of four options, approves, and confirms with biometrics or PIN
- Mobile app encrypts the user's Account Key with the one-time public key generated by the requesting client (RSA-OAEP)
- - Encrypted Account Key is sent to server
+ - Encrypted Account Key is sent to server, signed with the user's account signing key
- Server temporarily stores the encrypted Account Key and marks the request as fulfilled
3. **Polling and retrieval (requesting client)**
@@ -421,7 +423,7 @@ Access to a shared vault is called a *grant*: a copy of the vault's VEK encrypte
- **Group membership alone gives no access**: a group itself holds no keys. A user only gets access to a shared vault after being invited to it and accepting, which gives them their own grant.
- **Each key has one job**: the account encryption keypair only receives vault keys, and a Vault Delivery Keypair only decrypts email, so a key stored inside a vault never opens anything outside it.
- **Grants are tied to their vault**: a grant is encrypted under a label that names the vault, so it cannot be used for another vault.
-- **Grants and keys are signed**: a grant, a published account public key and a published delivery key each carry an Ed25519 signature by the account that created it, over a message that names its purpose, so a grant cannot be created by someone who merely knows a public key, and a signature made for one purpose does not verify for another. The server checks every signature on upload. A client opens a shared vault only with a grant signed by its own account, and encrypts a vault key only for a public key signed by a signing key its user certified ([10.3](#103-account-fingerprints-and-key-certifications)). A grant the server made up, signed with a key of its own, therefore never opens.
+- **Grants and keys are signed**: a grant carries an Ed25519 signature by the member who holds it, and a published account public key or delivery key one by the account that published it, each over a message that names its purpose, so a grant cannot be created by someone who merely knows a public key, and a signature made for one purpose does not verify for another. The server checks every signature on upload. A client opens a shared vault only with a grant signed by its own account, and encrypts a vault key only for a public key signed by a signing key its user certified ([10.3](#103-account-fingerprints-and-key-certifications)). A grant the server made up, signed with a key of its own, therefore never opens.
- **Own keys come from the private key**: a client uses the account public key the server serves as its own only after checking that it is the public half of the private key it holds, and derives its own signing public key from its signing private key. A server that serves another key as the user's own is refused.
- **Enforcement layers**: access to a vault's contents is enforced by cryptography (no grant, no key). Which vaults the server lists for a user, group membership and roles are enforced by the server. A few guards, such as refusing to delete the folder that represents a shared vault, are enforced only in the client.
@@ -433,7 +435,7 @@ The fingerprint is the one input the server does not control, so it has to be ex
- The inviter types the invitee's fingerprint to invite them. The server finds the account by the fingerprint and returns its signing key; the client refuses the key unless its fingerprint is the typed fingerprint.
- The invitee types the inviter's fingerprint to accept. The client checks the inviter's signing key the same way.
-Each check ends in a *key certification*: an Ed25519 signature by the checking account over a message that names the certifier, the certified account and the certified signing key (label `aliasvault/v1/sig/key-certification`). The certifications are stored on the server and served back with the groups' rosters, with the list of people the user verified, and with invitations. A client trusts a certification only after verifying it under its own signing public key, derived from its private key, so the server can withhold a certification but cannot forge one. Without a valid certification the client refuses to hand out or accept a vault key and asks for the other person's fingerprint; it never accepts a served key on its own.
+Each check ends in a *key certification*: an Ed25519 signature by the checking account over a message that names the certifier, the certified account and the certified signing key (label `aliasvault/v1/sig/key-certification`). The certifications are stored on the server and served back with the rosters of the groups the user administers, with the list of people the user verified, and with invitations. A client trusts a certification only after verifying it under its own signing public key, derived from its private key, so the server can withhold a certification but cannot forge one. Without a valid certification the client refuses to hand out or accept a vault key and asks for the other person's fingerprint; it never accepts a served key on its own.
The certified key anchors everything that follows: the account public key a vault key is encrypted to must be signed by it, and the invitation and grant signatures are checked under it. Later shared vaults between the same two people need no further fingerprint. Trust is set up between the admin and each member only: members do not certify each other, as only the admin hands out vault keys. A key rotation ([4.2](#42-key-rotation)) signs the rotating account's own certifications again with its new signing key, in the same transaction; the certifications others made of the old key no longer match, so the next invitation between them asks for the new fingerprint. Leaving or being removed from a shared vault keeps the certifications, so sharing again later needs no fingerprint.
@@ -485,13 +487,13 @@ These are the known limitations of the current design relative to the [threat mo
|---|---|---|---|---|
| [13.1](#limitation-shared-member-removal) | Revocation from a shared vault is not cryptographic | Former membership of the vault and its newer ciphertext obtained outside the API | Read what was added to that vault after the removal | By design |
| [13.2](#limitation-rollback) | Vault freshness is not verified | Control of the server | Serve an older vault revision; no reading or changing of contents | By design |
-| [13.3](#limitation-pin-unlock) | PIN unlock in the browser extension | A copy of the extension's storage, for a user who turned PIN unlock on | Guess the PIN offline | Opt-in, off by default |
+| [13.3](#limitation-pin-unlock) | PIN unlock in the browser extension | A copy of the extension's storage (forensic access or a compromised device), for a user who turned PIN unlock on | Guess the PIN offline | Opt-in, off by default |
| [13.4](#limitation-post-quantum) | RSA-2048 for public-key encryption | Stored ciphertext and a quantum computer able to break RSA-2048 | Decrypt shared vault keys, emails and Login with Mobile transfers | Post-quantum scheme planned |
| [13.5](#limitation-argon2-parameters) | Argon2id floor on a new device | Control of the server while the user logs in on a new device | Guess the master password offline at the OWASP minimum cost | Floor raised after migration |
1. <Link id="limitation-shared-member-removal" />**Revocation from a shared vault is not cryptographic.** The server stops serving the vault and its email to a removed member, and their client deletes its local copy. The VEK and Vault Delivery Keypair stay the same, so the remaining members are not affected. Reading content added after the removal requires both the keys the former member kept and ciphertext the server no longer serves them, such as from a leaked copy of the server database. The remediation is to change the passwords in the shared vault where needed: the former member synced those items before the removal, and no change of keys can take that back. To also keep anything added later out of reach of the former member, create a new shared vault, move the items and aliases to it, invite the remaining members and delete the old vault, which deletes its data from the server, including its emails.
2. <Link id="limitation-rollback" />**Clients verify that a vault revision is authentic, not that it is the latest.** The server can serve a revision that members of the vault wrote earlier, or an empty vault, as the current one; it cannot read, change or create vault contents ([2.4](#24-what-the-server-knows-and-can-do)). A client accepts such a revision, so changes made after it are lost and older states of items return. Clients accept older revisions on purpose: a server restored from a backup serves them in the same way, and refusing them would lock users out of their vaults.
-3. <Link id="limitation-pin-unlock" />**PIN unlock in the browser extension is an opt-in convenience.** PIN unlock is off by default and the master password is the default unlock method; the PIN setting notes that a PIN can be less secure than the master password. The Account Key is encrypted under a key derived from the PIN with Argon2id, and the extension allows 4 attempts. An attacker with a copy of the extension's storage, which requires forensic access or a compromised device ([2.5](#25-out-of-scope)), is not bound by that limit and can try PINs offline at the cost of one Argon2id derivation per guess, which is feasible for a 6-digit PIN; a longer PIN with letters and symbols takes more guesses. On mobile, the PIN-encrypted Account Key is also encrypted with a device-bound key from the iOS Keychain or the Android Keystore, so a copy of the app's storage alone is not enough to start guessing.
+3. <Link id="limitation-pin-unlock" />**PIN unlock in the browser extension is an opt-in convenience.** PIN unlock is off by default and the master password is the default unlock method; the PIN setting notes that a PIN can be less secure than the master password. The Account Key is encrypted under a key derived from the PIN with Argon2id, and the extension deletes it after 4 failed attempts. This limitation applies only to an attacker who already has a copy of the extension's storage from the user's browser profile, which takes forensic access to the device or a compromised device, both outside the threat model ([2.5](#25-out-of-scope)). Such an attacker is not bound by the attempt limit and can try PINs offline at the cost of one Argon2id derivation per guess, which is feasible for a 6-digit PIN; a longer PIN with letters and symbols takes more guesses. Browsers give extensions no hardware-bound key storage, so the extension cannot bind the PIN-encrypted key to the device. On mobile, the PIN-encrypted Account Key is also encrypted with a device-bound key from the iOS Keychain or the Android Keystore, so a copy of the app's storage alone is not enough to start guessing.
4. <Link id="limitation-post-quantum" />**Public-key encryption uses RSA-2048; a post-quantum algorithm is planned.** Grants, email keys and Login with Mobile use RSA-2048-OAEP. An attacker who keeps a copy of that ciphertext (from the server database or captured traffic) could decrypt it once a quantum computer able to break RSA-2048 exists, and with it the shared vault keys, emails and Account Keys it protects. RSA-2048 provides 112-bit security, which NIST SP 800-57 Part 1 approves through 2030; the NIST draft transition plan (IR 8547) sets 2035 for moving public-key encryption to post-quantum algorithms. Vault contents and the keys that protect the personal vault at rest use AES-256-GCM, which is considered safe against quantum computers. Every RSA ciphertext carries an algorithm identifier, so a post-quantum scheme can be added next to RSA without breaking existing data; it will be added once well-reviewed implementations exist on every platform AliasVault supports.
5. <Link id="limitation-argon2-parameters" />**A new device accepts Argon2id settings down to the OWASP minimum.** Accounts use 64 MiB and 5 iterations, but a device that has never logged in before does not know that, so it accepts any settings down to the OWASP minimum of 19 MiB and 2 iterations ([section 4](#4-key-derivation-and-key-hierarchy)). A malicious server could send that minimum to a new device and obtain one login proof to guess the master password against at the lower cost. A device that logged in before refuses weaker settings than it used, and a leaked database only allows guessing at the account's own settings. The minimum matches the default for accounts until version 0.31.0; once all accounts have migrated to the current defaults, it will be raised to match them.
@@ -537,10 +539,12 @@ Where each part of this document lives in the repository, for reviewers.
| **Manifest** | The encrypted document on the server that holds one vault's items. |
| **Data bucket** | A separately encrypted part of a vault for data that changes often. |
| **Blob** | The encrypted bytes of one attachment or logo, with its own key. |
-| **Grant** | A vault's VEK encrypted for one member's account public key, signed by the account that created it. |
+| **Grant** | A vault's VEK encrypted for one member's account public key, signed by the member who holds it. |
| **Vault Delivery Keypair** | The RSA keypair of a vault that incoming email is encrypted to. |
| **Email claim** | The server-side record that an alias address belongs to a vault. |
| **Group** | A set of accounts that can hold shared vaults; a group holds no keys. |
+| **Account fingerprint** | 20 digits derived from an account's signing public key, compared outside AliasVault before sharing. |
+| **Key certification** | An account's signature stating that a signing public key belongs to another account, made after checking its fingerprint. |
| **Account unlock method** | A server-stored copy of the Account Key under a KEK; today the master password. |
| **Device unlock method** | A device-only copy of the Account Key protected by biometrics, a PIN or a passkey. |
@@ -562,11 +566,11 @@ Where each part of this document lives in the repository, for reviewers.
| | |
|---|---|
-| **Document version** | 0.5 (draft) |
+| **Document version** | 0.5 |
| **Author** | AliasVault |
| **Date** | 2026-10-22 |
| **Applies to** | AliasVault 0.31.0 and later (vault format v1) |
-| **Status** | Draft, pending independent review |
+| **Status** | Pending independent review |
| **Canonical copy** | This page. Source: [`docs/docs/security-whitepaper.mdx`](https://github.com/aliasvault/aliasvault/blob/main/docs/docs/security-whitepaper.mdx) |
| **Security contact** | [email protected], see [SECURITY.md](https://github.com/aliasvault/aliasvault/blob/main/SECURITY.md) |
@@ -574,7 +578,7 @@ Where each part of this document lives in the repository, for reviewers.
| Version | Date | Changes |
|---|---|---|
-| 0.5 (draft) | 2026-10-22 | Converted to whitepaper format: threat model, known limitations and appendices added; updated for the 0.31 vault format. |
+| 0.5 | 2026-10-22 | Converted to whitepaper format: threat model, known limitations and appendices added; updated for the 0.31 vault format. |
| 0.4 | 2026-09-30 | Raised Argon2id defaults. |
| 0.3 | 2025-11-18 | Login with Mobile; clarified zero-knowledge scope. |
| 0.2 | 2025-10-28 | Passkeys. |
diff --git a/docs/src/css/custom.css b/docs/src/css/custom.css
index a72394323..089c5926c 100644
--- a/docs/src/css/custom.css
+++ b/docs/src/css/custom.css
@@ -758,13 +758,22 @@ html[data-theme='dark'] .av-install-card__icon {
/* --------------------------------------------------------------- Tables --- */
+/* `overflow-x: auto` (not `hidden`) keeps the rounded corners while letting wide tables scroll sideways. */
.markdown table {
border-radius: 10px;
- overflow: hidden;
+ overflow-x: auto;
border-collapse: separate;
border-spacing: 0;
}
+/* On narrow screens, give text-heavy cells a readable width and let the table scroll instead of squeezing every column. */
+@media (max-width: 768px) {
+ .markdown table:not(.av-compare) td,
+ .markdown table:not(.av-compare) th {
+ min-width: 11rem;
+ }
+}
+
.markdown table thead tr {
border-bottom: none;
}