Skip to content
HexaTransfer
Back to blog
Encryption & Security

Browser Encryption Capabilities: What Modern Browsers Can Do

Modern browsers have powerful built-in encryption capabilities. Explore what Chrome, Firefox, Safari, and Edge can do for client-side file encryption.

Modern browsers ship with native cryptography that rivals dedicated security libraries. Chrome, Firefox, Safari, and Edge all expose the Web Crypto API (crypto.subtle), implement TLS 1.3 with certificate pinning via HPKP's successor mechanisms, support WebAuthn/passkeys for phishing-resistant authentication, sandbox each origin with Site Isolation, and provide hardware-backed key storage via the Trusted Platform Module on Windows and Secure Enclave on macOS/iOS. For developers building encrypted file transfer tools, this means AES-256-GCM encryption, PBKDF2 key derivation, and FIDO2 authentication come for free, no external library needed. Here's what each browser can actually do in 2026.

Web Crypto API: The Common Baseline

All four major browsers support the W3C Web Cryptography API with near-identical surface area. The core algorithms are:

  • Symmetric: AES-GCM, AES-CBC, AES-CTR, AES-KW (128, 192, 256-bit)
  • Asymmetric: RSA-OAEP, RSA-PSS, RSASSA-PKCS1-v1_5 (up to 4096-bit), ECDSA and ECDH (P-256, P-384, P-521)
  • Hashing: SHA-1, SHA-256, SHA-384, SHA-512
  • Key derivation: PBKDF2, HKDF
  • MAC: HMAC

What's missing: ChaCha20-Poly1305 (no browser support), Argon2 (no browser support), Ed25519/X25519 (Safari 17+ and Firefox 129+ have it, Chrome is catching up). For those you still need JavaScript or WASM libraries like libsodium.js or @noble/curves.

Chrome and Edge share the same crypto implementation (BoringSSL via V8). Firefox uses NSS. Safari uses CoreCrypto, Apple's FIPS-validated library. Performance varies: Firefox's PBKDF2 iterations run about 20% slower than Chrome on equivalent hardware; Safari's AES-GCM with hardware acceleration on Apple Silicon is roughly 2x faster than Chrome on the same Mac.

TLS 1.3 and Certificate Transparency

Every major browser defaults to TLS 1.3 on supported origins and falls back to 1.2 only for legacy servers. Chrome removed TLS 1.0 and 1.1 support in Chrome 84 (July 2020). Firefox removed them in Firefox 78. Safari dropped them in macOS 11 / iOS 14.

Certificate Transparency is enforced: certificates issued after April 2018 must appear in at least two CT logs or Chrome and Safari will reject them. This caught DigiNotar-style attacks early by making CA misissuance publicly auditable. Mozilla's Firefox began enforcing CT in Firefox 117 (2023).

Public key pinning via the HPKP header was deprecated (Chrome 72 removed support) because it enabled lockout attacks. Expect-CT headers served the same monitoring purpose and are themselves being phased out now that CT is mandatory. Enterprises needing pinning still have it via trusted root pinning in managed configurations (MDM on macOS, Chrome Enterprise policies).

Origin Isolation and Sandboxing

Chrome's Site Isolation puts each origin in its own OS process since 2018 (desktop) and 2019 (Android). Firefox's Fission achieves the same since Firefox 94. Safari uses WebKit's per-process model. What this means for encryption: a malicious cross-origin script can't read your decrypted file from a sibling tab's memory, because the sibling lives in a different process with its own heap.

Cross-Origin-Opener-Policy (COOP), Cross-Origin-Embedder-Policy (COEP), and Cross-Origin-Resource-Policy (CORP) let pages opt into even stricter isolation. Setting Cross-Origin-Opener-Policy: same-origin and Cross-Origin-Embedder-Policy: require-corp enables cross-origin isolation, which in turn unlocks SharedArrayBuffer and high-resolution timers. Relevant for crypto because Spectre-style timing attacks against AES implementations are mitigated when the attacker can't open a SAB in your origin.

WebAuthn and Passkeys for Authentication

FIDO2 WebAuthn is supported in Chrome 67+, Firefox 60+, Safari 14+, and Edge 18+. It lets applications authenticate users via hardware keys (YubiKey, Titan), platform authenticators (Face ID, Windows Hello, Android biometric), or passkeys synced across a user's devices via iCloud Keychain, Google Password Manager, or 1Password.

For a file transfer application, WebAuthn replaces passwords as the factor that protects access to a stored share link. Crucially, WebAuthn is phishing-resistant: the signature is bound to the origin, so a lookalike domain can't capture credentials. Chrome and Safari both moved to passkey-default flows in 2023-2024, dropping the physical key requirement for most consumer use.

Hardware-Backed Key Storage

On Windows, the TPM 2.0 chip (mandatory on Windows 11) can store Web Crypto keys generated as non-extractable via the Windows CNG bridge. On macOS and iOS, the Secure Enclave holds keys used for Face ID, Touch ID, and passkeys. On Android, the Keystore backed by StrongBox (hardware) or TEE (Trusted Execution Environment) provides similar protection.

What this means practically: a key generated as extractable: false via Web Crypto on a modern laptop may live in the TPM or Secure Enclave, not in main memory. Even a full browser exploit that dumps JavaScript memory won't yield the raw key bytes. For file transfer tools, this is most useful for long-lived recipient keys; ephemeral per-file AES keys don't need this protection.

Content Security Policy as a Crypto Multiplier

Encryption is worthless if a malicious script can read plaintext before it's encrypted. Content Security Policy headers let a site declare which scripts are allowed to run. A strict policy like:

Content-Security-Policy: default-src 'self'; script-src 'self' 'strict-dynamic' 'nonce-abc123';

blocks inline scripts and third-party code, leaving no attack surface for injected crypto-stealing payloads. All major browsers support CSP Level 3. For file transfer apps, combine CSP with Subresource Integrity (SRI) on any external scripts to ensure even allowed third-party JS hasn't been tampered with.

File System Access and OPFS

The File System Access API (Chrome 86+, Edge 86+, partial Safari 15.2+ via Origin Private File System) lets web apps read and write local files with user permission. The Origin Private File System is particularly relevant for encryption: it's a private filesystem per origin, browser-managed, used for staging large encrypted payloads before upload without loading the whole thing into memory.

Firefox has been slower to adopt FSA but supports OPFS since Firefox 111. Safari supports OPFS across the board but has more restrictive behavior on the broader File System Access API.

What Browsers Still Can't Do Well

A few gaps remain:

  • Argon2 key derivation is absent from Web Crypto. Use WASM libraries for password hashing above PBKDF2.
  • ChaCha20-Poly1305 isn't exposed. AES-GCM covers most needs, but ChaCha would help on devices without AES-NI (older ARM).
  • Key attestation for hardware-backed keys is limited. WebAuthn provides attestation; the broader Web Crypto API does not.
  • Streaming AEAD is not yet part of the spec. Large file encryption requires chunking logic or WASM.
  • Post-quantum algorithms (Kyber, Dilithium) aren't yet in the browser. Google has shipped Kyber in TLS handshakes (Chrome 116+) but JavaScript-exposed post-quantum crypto is still library territory.

What to Use Today for File Transfer

A credible browser-based file transfer stack in 2026:

  • AES-256-GCM via crypto.subtle.encrypt for file contents
  • PBKDF2-SHA-256 at 600,000 iterations for password-derived keys
  • crypto.getRandomValues() for salts and nonces (never Math.random)
  • URL fragments (#key=...) to pass keys client-side without server exposure
  • HTTPS with TLS 1.3 minimum, HSTS enabled, COOP/COEP for isolation
  • CSP strict-dynamic, no inline scripts
  • WebAuthn passkeys for any stored-account feature
  • OPFS for large-file staging on Chrome/Edge/Safari 16+

HexaTransfer runs essentially this stack. So does SwissTransfer, Tresorit Send, Cryptpad, and Proton Drive Share. The primitives are mature and consistent across browsers.

Testing Across Browsers

Always test in all four. Real-world bugs: Firefox throws OperationError on PBKDF2 inputs that Chrome accepts silently. Safari's FileReader is slower on 2+ GB files. Chrome's OPFS writes chunked above 4 GB in some versions. WebAuthn user verification prompts differ significantly (Face ID vs Touch ID vs Windows Hello vs Android biometric). Use BrowserStack, Sauce Labs, or a local matrix of physical devices for pre-release testing.

Browsers have quietly become one of the most complete crypto platforms available. The same standards-based primitives that power banking apps, password managers, and messaging clients sit a single JavaScript call away for anyone building encrypted file transfer tools.

Try it at hexatransfer.com — free, no account, 10 GB max.

Send large files securely with end-to-end encryption

Transfer files up to 10 GB for free with end-to-end encryption. No account required. Your files are encrypted in your browser before upload — no one else can read them.

Send a file