Skip to content

Security & Privacy

File contents, private keys, and passphrases are processed locally. Public identity, key discovery, and email workflows use network services. Read the data flows separately from the security safeguards.

What stays on your device

File processing and private-key operations run locally. Local storage is different from sending data over the network, and not all stored data is encrypted. Some actions also send public identity or selected metadata, as described below.

Key generation

Your private and public keys are generated using Curve25519 via OpenPGP.js in your browser. Your private key is protected with your passphrase before storage. Generation also automatically attempts to register your public key and identity with the CryptDrop API; see the network details below.

File encryption & decryption

Files are encrypted and decrypted inside your browser tab. CryptDrop does not upload file contents. Decrypted results are held in browser memory until cleared or saved by you; downloading a result writes a plaintext copy to your chosen location. Browser and operating-system memory handling is outside the app’s control.

Digital signatures

Your private key creates signatures locally, and signature verification also runs locally. Obtaining a sender’s public key by email lookup is a separate network request.

Private key storage

If you choose "Remember on this device", CryptDrop saves a fully passphrase-protected private key in this site’s IndexedDB, not your passphrase or unlocked key. Encryption protects the saved copy, but a stolen copy can be subjected to offline passphrase guessing. Browser storage is not a backup.

Contact address book

Saved contacts (names, emails, public keys) are stored in your browser’s localStorage. CryptDrop does not upload or sync the address book as a collection. Looking up a contact or sending an invitation can send selected names or email addresses to network services. localStorage is not encrypted by the app.

Activity history

Encrypt/decrypt history is stored in localStorage, not encrypted by the app. It includes filenames, sizes, timestamps, a signed flag, and recipient or sender details, but not file contents. The history collection is not uploaded. An optional instructions email sends a filename separately. You can clear history or enable auto-clear on page exit; browser events are not guaranteed to run.

Private keys: protections and limits

Local processing reduces what you share with servers. It does not make a browser a hardware vault. These safeguards describe the current implementation, not a security certification or a guarantee against compromise.

Safeguards in place

  • Key generation, encryption, decryption, and signing run on your device. CryptDrop does not upload private keys or passphrases.
  • Remember on this device accepts only fully passphrase-protected private keys and stores them in this site’s IndexedDB.
  • The app does not persist your passphrase or unlocked private key.
  • Browser origin isolation normally prevents unrelated websites from accessing this site’s saved keys.

Browser limitations

  • While loaded, your decrypted private key is held in browser memory. Switching tabs within the app does not unload it.
  • CryptDrop tabs on the same origin share IndexedDB storage. Browser windows are not separate storage security boundaries.
  • Malicious extensions with sufficient permissions, compromised application code, or device malware can expose keys and passphrases.
  • There is no hardware-backed key isolation, automatic idle lock for loaded keys, or guaranteed secure memory erasure.
  • A stolen encrypted key can be subjected to offline passphrase guessing. Use a strong, unique passphrase.
  • Browser storage is not a backup. Keep a separate protected backup and a recoverable passphrase.

Saved is different from loaded. A remembered key is encrypted at rest. Loading it makes decrypted key material available to the app in memory for signing and decryption. Removing it from app state or closing the page is not a guarantee that every memory copy has been securely erased. The decrypted-file expiry timer does not unload your private key.

Older saved keys. Earlier versions may have saved unprotected keys. Those copies are not automatically deleted or made safe by an update. If warned about an older saved key, preserve a protected recovery copy first, then remove the unsafe browser copy. Do not delete your only copy.

For higher-risk use. Use a trusted, updated device and browser with minimal extensions. For especially sensitive keys, consider a trusted offline PGP tool or a hardware-backed workflow that does not expose an exportable private key to a web application. CryptDrop does not currently provide hardware-token integration.

Trust in delivered code. You also trust the code served by this site and its dependencies. Security headers reduce some risks but cannot make compromised application code safe. Using an audited cryptographic library does not mean the entire application has been independently audited.

What reaches the cloud

The browser uses the CryptDrop API and the keys.openpgp.org public keyserver for the workflows below. The backend uses Resend for email. These are application payloads, not an exhaustive inventory of HTTP metadata: loading the site and making requests also involves network information such as IP addresses. CryptDrop does not upload file contents, private keys, or passphrases in these workflows.

Public key lookup

Sent to CryptDrop registry, then keys.openpgp.org — The email address you search for

Email lookup sends the searched address to the CryptDrop API (GET /api/lookup/:email). The backend checks its registry, then queries keys.openpgp.org if needed. If the API fails, the browser can query that keyserver directly. No file contents or private keys are included.

Public key publishing

Sent to keys.openpgp.org — Your public key, including its identity information

If you choose to publish your public key, the armored public key text is uploaded to keys.openpgp.org so others can find you. Your private key is never included. The app may then request address verification from the keyserver; email delivery is not guaranteed.

Email verification

Sent to keys.openpgp.org — A verification token and your email address

After uploading a public key, CryptDrop can send the returned verification token and unpublished email addresses to the keyserver (POST /vks/v1/request-verify) to request confirmation emails. This is separate from the CryptDrop registry.

Key registration

Sent to CryptDrop registry (POST /api/register) — Your name, email, public key, fingerprint, and invitation token if present

Generating a key pair automatically attempts registration with the CryptDrop API. This is nonblocking and best-effort, not an opt-in publishing step or a guarantee of registration. The backend stores successful registrations so others can find your key by email. Your private key and passphrase are not included.

Invitation emails

Sent to CryptDrop backend (POST /api/invite) — Sender name, sender email, recipient email

Sending an invitation sends the sender’s name and email and the recipient’s email to the API. The backend stores an invitation record and attempts to send an invitation link via Resend. No file contents or keys are included; email delivery is not guaranteed.

Opening an invitation

Sent to CryptDrop API (GET /api/invite/:token) — The invitation token from the link

Opening an invitation link sends its token to the API for validation. The response can include the sender’s name and email, recipient email, and invitation status. The token is also passed into guided setup for registration. Treat invitation links as sensitive.

Invitation acceptance notifications

Sent to CryptDrop backend to Resend — Inviter email, registering person’s name and email

Registration can mark invitations accepted using the invitation token or matching email address. The backend then attempts to notify the inviter via Resend, including the registering person’s name and email. This is not a guarantee that an email arrives.

Decrypt instructions email

Sent to CryptDrop backend (POST /api/notify) — Recipient email, loaded sender user ID (which can include name and email), and the selected file’s original filename

If you choose to send decrypt instructions after encryption, the API receives the recipient’s email, the loaded sender user ID (which can include name and email), the original filename, and the notification type. If no sender identity is loaded, “Someone” is sent instead. The backend passes these email details to Resend to attempt delivery; the sender user ID appears in the recipient’s email subject and body. A filename can reveal sensitive information even though file contents are not sent.

Sharing a public key by email

Sent to Your email application (mailto link) — Your public key and public identity in a draft email

The public-key email action opens your email application with a draft containing your public key and identity. Sending it is handled by your email application and provider, not by CryptDrop’s API. No private key is included.

Data stored by the backend

  • Registry: Cloudflare D1 stores registered names, emails, public keys, fingerprints, and creation/update timestamps.
  • Invitations: D1 stores the token, sender name and email, recipient email, status, and creation/acceptance timestamps.
  • Rate limiting: D1 stores an action and an identifier derived from the request’s IP headers (or “unknown”), with a request count and window start. This identifier is not hashed by the middleware.

This is an implementation summary, not a retention or deletion policy. An expired invitation link does not mean its database record has been deleted.

What is never transmitted

CryptDrop’s implemented workflows do not upload the following data. This describes normal application behavior, not a guarantee against malicious extensions, compromised code, or an infected device. See the private-key protections and limits above.

  • Your private key
  • Your passphrase
  • Unencrypted file contents
  • Encrypted file contents
  • Decrypted file contents
  • Your activity history as a collection
  • Your contact list as a collection

Names, email addresses, public keys, and filenames are different from file contents. Selected details can be sent by the network workflows above, even though contact and history collections are not uploaded.

How CryptDrop hardens your security

Beyond the encryption itself, multiple layers of protection are built into the app to minimize attack surface and protect your data.

Content Security Policy

The configured CSP restricts scripts to this origin and explicitly hashed inline scripts, and restricts fetch connections to this origin and keys.openpgp.org. It reduces some injection and data-exfiltration risks; it does not protect secrets from all compromised same-origin code or privileged extensions.

Modern cryptography

New keys use Curve25519 via OpenPGP.js 6.x, which implements OpenPGP encryption and signatures. Cryptographic algorithms are only one part of security; passphrases, key handling, application code, and device integrity also matter.

Passphrase protection

New key generation requires a passphrase of at least 12 characters and a minimum strength score. Imported keys retain their existing protection. Remember on this device rejects unprotected or partially protected keys. Passphrases are not persisted by the app; clearing a form does not guarantee secure memory erasure.

Decrypted file auto-clear

A five-minute timer removes the decrypted result from app state. Browser scheduling can delay timers, and dropping a reference does not guarantee secure memory erasure. Downloaded copies remain on disk, and this timer does not unload your private key.

Filename sanitization

Filenames embedded in encrypted files are sanitized on decryption to prevent path traversal attacks. Control characters, directory separators, and excessive lengths are stripped.

Public-key lookup warnings

Public-key lookup compares the first user ID with the searched email and can show an email-mismatch warning. A missing user ID may not trigger a warning. This check does not reject a mismatched key, prove its owner’s identity, or rule out a malicious key. Verify the fingerprint through a trusted channel.

Security headers

The deployment configuration includes HSTS, framing restrictions, Cross-Origin-Opener-Policy, and Referrer-Policy: no-referrer. When served correctly, these reduce transport, framing, opener, and referrer risks. They do not isolate one CryptDrop tab’s IndexedDB storage from another.

No tracking or analytics

The app does not include analytics scripts or tracking pixels. Network workflows include the CryptDrop API and keys.openpgp.org, as described above; generating keys also attempts to register your public key and identity with the API.

Don't take our word for it

CryptDrop is built on OpenPGP.js, a widely audited open-source encryption library. The source code is publicly available for review — you can read every line, inspect the network requests in your browser's DevTools, and verify every claim on this page yourself.