Encrypt & Decrypt Text

What is encryption?

Encryption is the process of transforming readable data (plaintext) into an unreadable form (ciphertext) using an algorithm and a key, so that only someone with the correct key can turn it back into the original. It is the foundation of digital privacy and security — protecting messages, files, passwords, payments and the entire web.

Unlike encoding (Base64, URL-encoding) which only changes a representation and is trivially reversible by anyone, encryption is designed so that without the key the ciphertext reveals nothing practical about the plaintext. And unlike hashing, which is one-way, encryption is reversible by design: with the key you can always recover the original.

This toolkit performs real encryption entirely in your browser using the Web Crypto API and verified implementations, so you can protect text and files without trusting any server.

How encryption works

A cipher takes the plaintext and a key and produces ciphertext. Modern symmetric ciphers like AES also take a unique, random IV (initialization vector) or nonce for each message, which ensures that encrypting the same text twice produces different ciphertext — a critical property called semantic security.

Authenticated encryption (AEAD) modes such as AES-GCM and ChaCha20-Poly1305 go further: alongside the ciphertext they produce an authentication tag. On decryption the tag is checked, so any tampering with the ciphertext — even a single flipped bit — is detected and decryption fails safely. This protects integrity and authenticity, not just confidentiality.

When you encrypt with a password rather than a raw key, a key-derivation function (KDF) such as PBKDF2, scrypt or Argon2id stretches your password into a full-strength key using a random salt and a deliberately expensive computation, making brute-force guessing far harder.

Symmetric encryption

Symmetric encryption uses a single shared secret key for both encryption and decryption. AES (the Advanced Encryption Standard), ChaCha20, Triple-DES and Blowfish are all symmetric. Symmetric ciphers are extremely fast — modern CPUs encrypt gigabytes per second — which makes them the workhorse for encrypting the actual data.

The challenge with symmetric encryption is key distribution: both parties must somehow share the secret key securely. In practice this is solved with asymmetric cryptography or a key-agreement protocol (like Diffie-Hellman) to exchange the symmetric key, after which the fast symmetric cipher does the bulk work.

Asymmetric (public-key) encryption

Asymmetric encryption uses a mathematically linked pair of keys: a public key that anyone can use to encrypt, and a private key that only the owner holds and uses to decrypt. RSA and elliptic-curve schemes are the best-known examples. Because the encrypting party never needs the secret, public-key cryptography solves the key-distribution problem.

The trade-off is speed and size: RSA is far slower than AES and can only encrypt small amounts of data (a 2048-bit RSA-OAEP key encrypts at most ~190 bytes). So real systems use hybrid encryption — RSA (or ECDH) protects a random symmetric key, and AES encrypts the data with that key.

Public key vs. private key cryptography

In a key pair, the public key is meant to be shared freely; the private key must be kept secret. What one key does, only the other can undo. Encrypt with the public key → only the private key decrypts (confidentiality). Sign with the private key → anyone can verify with the public key (authenticity and integrity).

This asymmetry underpins TLS/HTTPS, SSH, code signing, PGP email and digital certificates. Guarding the private key — ideally in an HSM, secure enclave or a secrets manager — is the single most important operational security task in public-key systems.

Digital signatures & message authentication

A digital signature proves who created a message and that it was not altered. The signer hashes the message and encrypts the hash with their private key; verifiers decrypt it with the public key and compare hashes. RSA, ECDSA and EdDSA are common signature algorithms.

For symmetric settings, a Message Authentication Code (MAC) like HMAC provides the same integrity and authenticity guarantee using a shared secret instead of a key pair. AEAD ciphers build a MAC directly into the encryption (the Poly1305 or GCM tag), which is why authenticated encryption is the modern default.

Encryption vs. encoding

Encoding (Base64, hex, URL-encoding) changes how data is represented so it can travel safely through a channel — it provides no security and anyone can reverse it. Encryption uses a secret key and is designed so that data cannot be recovered without it.

A common mistake is to treat Base64 as “encryption.” It is not: Base64-decoding is a one-line operation. If you need confidentiality, use a real cipher like AES-256-GCM with a strong key — exactly what this tool provides.

Encryption vs. hashing

Hashing is a one-way function: it maps data to a fixed-size digest and cannot be reversed. It is used for integrity checks, fingerprints and — with a slow, salted password-hash like Argon2 or bcrypt — for storing passwords. Encryption is two-way: with the key you recover the original.

Rule of thumb: encrypt data you need to read again (messages, files, tokens); hash data you only need to verify (passwords, checksums, signatures). Never “encrypt” passwords for storage — hash them with a memory-hard algorithm instead.

AES explained

AES (Advanced Encryption Standard, FIPS 197) is the most widely used symmetric block cipher in the world, standardized by NIST in 2001. It operates on 128-bit blocks with 128, 192 or 256-bit keys, and is implemented in hardware (AES-NI) on virtually every modern CPU, making it both extremely fast and trusted.

AES is used in a mode of operation. AES-GCM provides authenticated encryption and is the recommended default. AES-CBC is the classic mode but is unauthenticated and needs a separate HMAC and careful padding handling. AES-CTR turns AES into a stream cipher and is also unauthenticated. Always use a fresh random IV/nonce per message and never reuse a nonce with GCM.

RSA explained

RSA (Rivest–Shamir–Adleman, 1977) is the classic public-key algorithm. Its security rests on the difficulty of factoring the product of two large primes. For encryption, RSA-OAEP padding is used; for signatures, RSA-PSS. A 2048-bit key is the practical minimum today, with 3072-bit recommended for long-term security.

RSA can only encrypt data smaller than its modulus minus padding, so it is used to encrypt symmetric keys, not bulk data. Keep the private key secret and rotate keys periodically. For new systems, elliptic-curve cryptography (ECC) achieves the same security with much smaller keys and faster operations.

ChaCha20 explained

ChaCha20 is a modern stream cipher by Daniel J. Bernstein, paired with the Poly1305 MAC to form the ChaCha20-Poly1305 AEAD construction (RFC 8439). It is a TLS 1.3 standard and is used by WireGuard, OpenSSH and mobile platforms.

Its key advantage is performance and safety in software: ChaCha20 is fast and constant-time without special hardware, which makes it the preferred choice on devices without AES acceleration (many phones and embedded systems). It uses a 256-bit key and a 96-bit nonce that must never repeat for a given key.

Post-quantum cryptography

Large-scale quantum computers would break today’s public-key algorithms (RSA, Diffie-Hellman, ECC) using Shor’s algorithm, while only weakening symmetric ciphers (Grover’s algorithm effectively halves key strength, so AES-256 remains safe). This drives the move to post-quantum cryptography (PQC).

In 2024 NIST standardized the first PQC algorithms: ML-KEM (Kyber) for key encapsulation and ML-DSA (Dilithium) and SLH-DSA (SPHINCS+) for signatures. The pragmatic path today is “harvest-now-decrypt-later” defense: use AES-256 for data at rest and adopt hybrid (classical + PQC) key exchange as libraries mature.

// AES-256-GCM with a password (PBKDF2) — runs in any modern browser
async function encrypt(text, password) {
  const enc = new TextEncoder()
  const salt = crypto.getRandomValues(new Uint8Array(16))
  const iv = crypto.getRandomValues(new Uint8Array(12))
  const baseKey = await crypto.subtle.importKey('raw', enc.encode(password), 'PBKDF2', false, ['deriveKey'])
  const key = await crypto.subtle.deriveKey(
    { name: 'PBKDF2', salt, iterations: 310000, hash: 'SHA-256' },
    baseKey, { name: 'AES-GCM', length: 256 }, false, ['encrypt'])
  const ct = await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, key, enc.encode(text))
  return { salt: [...salt], iv: [...iv], ct: [...new Uint8Array(ct)] }
}

Security best practices

Key management