This page describes exactly how Kodimu protects the content of your tasks, what it does not protect, and what is still missing. It is written for people who want to check the claims rather than take them on trust. Every statement below matches the code as of the review date.
Summary
- Your task text, project names, notes and ideas are encrypted in your browser with AES-256-GCM before they are sent to the server.
- The encryption key is a random data key. It is stored on the server only in wrapped form, encrypted with a key derived from your encryption password (PBKDF2-SHA-256, 600,000 iterations).
- The server never receives your encryption password or the unwrapped data key. It cannot decrypt your content, and neither can anyone who obtains a copy of the database.
- Encryption is mandatory: the app cannot be used until an encryption password is set.
- Metadata — your email, timestamps, due dates, priorities, stages and focus timings — is not encrypted, because the server needs it to run the app.
- The client is not open source and has not been independently audited. Kodimu is hosted in the United States.
Key hierarchy
Kodimu uses a two-level key hierarchy, the same pattern used by most end-to-end encrypted storage products:
encryption password (chosen by you, never leaves the browser)
│
│ PBKDF2-SHA-256, 600,000 iterations, 16-byte random salt
▼
KEK — key-encryption key (AES-256-GCM, non-extractable, used only to wrap/unwrap)
│
│ AES-GCM key wrap, 12-byte random IV
▼
DEK — data-encryption key (random AES-256-GCM key, generated in your browser)
│
│ AES-256-GCM, fresh 12-byte random IV per value
▼
"enc:" + base64( IV ‖ ciphertext ‖ 128-bit auth tag ) → stored on the serverSeparating the two keys means a password change only needs to re-wrap one small key instead of re-encrypting every task, and the DEK itself is never derived from anything guessable.
Algorithms and parameters
| Component | Choice | Notes |
|---|---|---|
| Implementation | Web Crypto API (window.crypto.subtle) | Built into the browser. No third-party crypto library. |
| Key derivation | PBKDF2 with SHA-256 | 600,000 iterations, in line with the OWASP 2023 recommendation for PBKDF2-HMAC-SHA256. |
| Salt | 16 random bytes per account | Generated with crypto.getRandomValues, stored on the server. |
| KEK | AES-256-GCM key | Marked non-extractable; usages limited to wrapKey / unwrapKey. |
| DEK | Random AES-256-GCM key | Generated with crypto.subtle.generateKey. |
| Content encryption | AES-256-GCM | Fresh 12-byte random IV for every value; authenticated, so tampering is detected on decrypt. |
| Password check | encryptionTest | A known constant encrypted with the DEK. Unlock succeeds only if it decrypts correctly. |
| Encoding | enc: | Prefix marks encrypted values; values without it are treated as legacy plaintext. |
Key lifecycle
Setup
- After the first sign-in you choose an encryption password (minimum 8 characters). It is separate from your login password.
- The browser generates the salt and the DEK, derives the KEK, wraps the DEK and creates the
encryptionTestvalue. - Any content you created before encryption existed is encrypted in the browser and written back.
- The server stores the wrapped DEK, its IV, the salt and the test value.
Unlock
On a new browser you enter the encryption password. The browser downloads the wrapped DEK and salt, derives the KEK, unwraps the DEK and verifies it against encryptionTest. A wrong password fails the AES-GCM authentication and nothing is decrypted.
Staying unlocked
After a successful unlock, the raw DEK is kept in the browser’s localStorage, keyed by your account email, so you do not need to type the encryption password on every visit. This is a convenience trade-off, and it has consequences:
- The key stays in that browser after you log out. It is removed when you delete your account or clear the site data for Kodimu.
- Anyone with access to that browser profile, or a script running in the page, can read it.
- On a shared or public computer, clear the browser’s site data for Kodimu after use.
Recovery key
In Settings, Download Recovery Key saves a text file that contains the raw DEK in base64. Keep it in a password manager. Be aware that, today, there is no screen in the app to restore access from this file — it is a backup of the key material, not yet a self-service recovery flow.
Forgotten encryption password
Kodimu cannot recover it, and cannot decrypt your data for you. If you lose both the encryption password and the key material (an unlocked browser or the recovery key file), your encrypted content is unrecoverable. This is the intended property of end-to-end encryption, not a policy choice. Resetting your login password by email does not affect the encryption password.
What is encrypted
| Data | Encrypted in the browser | Why |
|---|---|---|
| Task and subtask text, Inbox items | Yes | Content |
| Project name, description and notes | Yes | Content |
| Category names and their emoji icons | Yes | Content |
| Project ideas and global ideas (text) | Yes | Content |
| Notes (title and text) | Yes | Content |
| Goals (text) | Yes | Content |
| Pause reasons in focus sessions | Yes | Content |
| Completed-task snapshots in History (task, parent, project name) | Yes | Content |
| Idea tags | No | Used for filtering on the server |
| Custom stage names, project colors, goal colors | No | Structure / display |
| Priorities, due dates, recurrence, today/queue flags, order | No | Needed for queries and scheduling |
| Focus session start/end, durations, pause durations | No | Needed for statistics |
| Created / updated / completed timestamps | No | Needed for History and “Today” |
| Email, display name, timezone | No | Needed for login, email and date calculations |
What the server sees
For a single task, the database row looks like this (shortened):
text: "enc:3q2+7wAAAB4f…Xr1w==" ← ciphertext priority: "urgent" ← plaintext dueDate: 2026-10-24T00:00:00Z ← plaintext focusSeconds: 2832 ← plaintext projectId: "cm2…" ← plaintext reference userId: "cm1…"
Per account the server additionally stores encryptedDEK, dekIV, encryptionSalt and encryptionTest. None of these can be turned into the DEK without the encryption password.
Threat model
| Threat | Protected? | Explanation |
|---|---|---|
| Database leak or stolen backup | Yes | Content is ciphertext; the DEK is wrapped. An attacker must brute-force PBKDF2 per account. |
| Hosting provider or database operator reading data | Yes | They see the same ciphertext the database holds. |
| Kodimu operator browsing the database | Yes | No key is available server-side. |
| Legal request to Kodimu for your task content | Yes | Only ciphertext and metadata could be handed over. |
| Network eavesdropper | Yes | TLS in transit (HSTS enabled), plus content is already encrypted. |
| Weak encryption password | Partly | PBKDF2 slows guessing, but a short or reused password can still be cracked offline from a leaked database. |
| Someone with access to your unlocked browser | No | The DEK is stored in localStorage, including after logout. |
| Malicious browser extension or malware on your device | No | It can read the page and the key, as with any web app. |
| A compromised or malicious server delivering modified JavaScript | No | The fundamental limit of browser-based end-to-end encryption: you run the code the server sends. See below. |
| Metadata analysis | No | Timestamps, durations, priorities and structure are plaintext. |
Known limitations
Browser-delivered cryptography
In any web app, the encryption code is delivered by the same server you are protecting your data from. A server that is compromised — or an operator acting in bad faith — could ship JavaScript that sends your password or key elsewhere. Native apps have a version of this problem too (updates), but app stores and reproducible builds make it more visible. Kodimu does not yet have an open-source client or reproducible builds that would let you verify the code you run. Recent research on “zero-knowledge” password managers under a malicious-server model shows why this matters (USENIX Security 2026). This is the main reason we use “end-to-end encrypted” as our term and treat “zero-knowledge” only as an explanation.
Content Security Policy
The site sends a Content Security Policy that restricts scripts to Kodimu’s own origin, PostHog’s asset host and, for Google Analytics on the public pages, Google Tag Manager. The policy currently allows 'unsafe-inline' and 'unsafe-eval' for scripts, which weakens its protection against injected scripts. Tightening it is on the list in What is not in place yet.
No key rotation
The DEK is created once per account and is not rotated. There is currently no in-app way to change the encryption password.
Infrastructure and third parties
- Hosting: Vercel, with a PostgreSQL database, in the United States. Data at rest on that infrastructure is the ciphertext and metadata described above.
- Email: Resend sends verification codes and password-reset links. It receives your email address, never task content.
- Sign-in: email and password (bcrypt-hashed), or Google / GitHub sign-in. Sign-in providers learn that you use Kodimu; they never see the encryption password.
- Analytics: PostHog (US cloud) records page views and clicks. All text is masked before sending, there is no session recording or heatmaps, Do Not Track is respected, no cookies are set (in-memory only), and only an internal account ID is attached — not your email or name. Because task content is encrypted and masked, PostHog never receives it.
- Public pages only: Google Analytics 4 runs on the home page, guides, comparisons and legal pages, with consent for visitors from the EU/EEA, the UK and Switzerland. It sets cookies there. It is never loaded in the app and is switched off when you move into the app, so it never sees app pages or task content.
- Security headers: HSTS, X-Frame-Options, X-Content-Type-Options, Referrer-Policy, Permissions-Policy and the CSP described above.
Legal details, including the basis for transfers to the US, are in the privacy policy.
What is not in place yet
We list these so you can weigh them, not as promises with dates:
- No independent security audit.
- The client is closed source; there are no reproducible builds or Subresource Integrity hashes.
- The CSP still allows inline and eval scripts.
- No in-app restore from the recovery key file, and no way to change the encryption password.
- The data key stays in localStorage after logout; there is no explicit “lock” button.
- Metadata (dates, durations, priorities, structure) is not encrypted.
Reporting a problem
If you find a flaw in this design or in its implementation, please contact the developer directly on X at @romanfinkwp before publishing it, so users can be protected first. The legal contact details are in the Impressum. This page will be updated whenever the implementation changes; the review date at the top shows when it was last checked against the code.