What end-to-end encrypted notes actually means (and which apps really do it)

The three tiers of encryption in modern software

Marketing departments across the tech industry frequently use the word "encrypted" as a generic badge of security. But encryption is not binary: what matters is where the cryptographic keys reside and who has the technical authority to decrypt data.

To evaluate whether a note-taking app genuinely protects your confidential notes, journal entries, and personal intellectual property, you need to understand the three distinct tiers of data encryption:

1. In-Transit Encryption (TLS/HTTPS): Encrypts traffic between your browser or app and the cloud server. This prevents eavesdropping on open Wi-Fi networks at coffee shops or airports, but the cloud server decrypts the payload immediately upon receipt.

2. At-Rest Encryption (Server-Side AES): Encrypts the raw blocks on the cloud provider’s storage volume (e.g. AWS EBS or Google Cloud persistent disk). While this protects against physical theft of hard drives from a server rack, the running application server holds the decryption key in memory and can read all user notes at any time.

3. Zero-Knowledge Client-Side End-to-End Encryption (E2EE): Decryption keys are derived and stored strictly on your local hardware. Data is transformed into unreadable ciphertext before it leaves your machine. The sync server stores and routes encrypted blobs without ever holding the decryption key.

Why server-side encryption fails the privacy test

When an app like Notion, Google Keep, or Evernote states that user notes are "stored securely with AES-256 encryption," they are referring to server-side encryption. Because the server holds the decryption keys, vendor engineers and automated background workers have unrestricted access to your files.

This server-side access enables cloud features like server-rendered search, AI indexing, and link previews, but it creates significant privacy vulnerabilities:

First, any database breach, compromised admin credential, or misconfigured cloud bucket exposes your entire note history to attackers. Second, insider threat remains a constant reality: curious or malicious employees can inspect private vaults without leaving an audit trail on your device.

Third, service providers are legally compelled to comply with government subpoenas, national security letters, and civil discovery requests. When an app uses server-side keys, they decrypt and hand over your personal journals, financial records, and medical notes without your consent.

How genuine zero-knowledge E2EE works under the hood

In a genuine zero-knowledge architecture like memrynote, cryptographic operations occur strictly on your physical machine before any byte touches the network wire. The sync server acts as a blind relay for encrypted binary chunks.

Here is the step-by-step cryptographic pipeline that ensures mathematical confidentiality:

1. Key Derivation: When you create a vault, your device derives a 256-bit master key using Argon2id with memory-hard parameters, making brute-force dictionary attacks computationally infeasible.

2. Symmetric Payload Encryption: Every note, journal entry, and task payload is encrypted locally using libsodium’s authenticated XChaCha20-Poly1305 cipher with random 192-bit nonces, ensuring both privacy and tamper-proofing.

3. Device Identity & Signing: Each authorized device generates an Ed25519 asymmetric keypair. Sync requests and CRDT vector updates are cryptographically signed by the device private key to prevent replay attacks.

4. Storage Separation: Encrypted payload blobs reside in Cloudflare R2 object storage, while opaque item IDs and version vectors reside in D1. The server coordinates sync routing but possesses zero capability to decrypt note text, filenames, or tag properties.

// High-level conceptual flow of zero-knowledge client sync
import sodium from 'libsodium-wrappers-sumo'

export function encryptVaultPayload(plaintext: Uint8Array, vaultKey: Uint8Array): EncryptedPayload {
  const nonce = sodium.randombytes_buf(sodium.crypto_aead_xchacha20poly1305_ietf_NPUBBYTES)
  const ciphertext = sodium.crypto_aead_xchacha20poly1305_ietf_encrypt(
    plaintext,
    null, // additional authenticated data
    null, // secret nonce
    nonce,
    vaultKey
  )
  return { nonce, ciphertext }
}

Comparing encryption across major note apps

Understanding which note applications implement genuine zero-knowledge encryption helps you make informed choices about where to store sensitive ideas:

Notion uses standard TLS in transit and AWS AES-256 at rest. Notion servers have full access to your workspace plaintext to run search indexes and train AI workspace features.

Evernote allows users to highlight specific snippets of text and encrypt them with a custom passphrase. However, note titles, tags, notebooks, and unselected text remain completely unencrypted on Evernote servers.

Apple Notes offers standard iCloud encryption where Apple manages keys. When Advanced Data Protection (ADP) is enabled in iCloud settings, notes are end-to-end encrypted, though access is restricted to Apple ecosystem devices.

Obsidian Sync offers genuine zero-knowledge end-to-end encryption with a user-defined passphrase as a paid add-on ($4 to $5 monthly), while the base app operates entirely locally.

memrynote is built local-first by default with zero cloud requirement. When optional hosted sync is enabled, every note, task, journal entry, and attachment is protected with zero-knowledge XChaCha20-Poly1305 encryption across macOS, Windows, and Linux.

• Notion: Standard TLS in transit, AES at rest. No client-side encryption. Vendor has full plaintext access.
• Evernote: Individual text snippets can be manually encrypted with a passphrase, but note titles, tags, and notebooks are unencrypted on servers.
• Apple Notes: Standard iCloud notes are server-encrypted. If you turn on Advanced Data Protection (ADP), end-to-end encryption is enabled across Apple devices, though Windows/Linux platforms remain unsupported.
• Obsidian Sync: Offers end-to-end encryption with a user-supplied passphrase as a paid add-on ($4–$5/mo).
• memrynote: Local-first by default with zero cloud requirement. Hosted sync is 100% zero-knowledge E2EE via XChaCha20-Poly1305 across macOS, Windows, and Linux.