Types of Encryption

Symmetric encryption

Symmetric encryption uses one shared secret key for both encryption and decryption.

It is the default choice for bulk data: files, database fields, backups, and network traffic after a session is established.

The hard part is key distribution and storage. Everyone who can decrypt must already have the same secret key, and you must protect it at rest and in transit.

• Use symmetric encryption when you control both ends or share a secret out of band.
• Prefer AEAD modes (AES-GCM or ChaCha20-Poly1305) so tampering is detected.
• Rotate keys and separate keys by purpose (system, env, dataset).

Asymmetric (public key) cryptography

Asymmetric cryptography uses a key pair: a public key that you can share and a private key that you keep secret.

It is commonly used for three tasks:

• Key agreement: establish a shared secret without sharing it directly.
• Key transport: encrypt a short secret (often a data key) to the recipient.
• Digital signatures: prove who signed and that data was not modified.

Public key operations are more expensive than symmetric encryption. That is why most systems avoid using public key crypto to encrypt large payloads directly.

• Use public key crypto when you need secure setup without a pre-shared secret.
• Use signatures when others must verify who signed and that it was not modified.
• For RSA encryption, use modern padding (RSA-OAEP) from your crypto library.

Hybrid encryption

Hybrid encryption combines both approaches: it uses public key cryptography to establish or protect a short symmetric key, then uses symmetric encryption to protect the actual data.

This pattern is common because it scales: the symmetric data key can be rotated per session or per file, while public keys can be distributed widely.

Example (conceptually): generate a random data key, encrypt the data with that key using an AEAD mode, then protect the data key using the recipient public key or a key agreement step.

• You get symmetric performance for data and public key convenience for key setup.
• It reduces blast radius: one data key compromise does not expose all sessions/files.
• Most real protocols follow this shape (handshake then symmetric record protection).

Quick compare

Use this as a fast decision aid. If you are unsure, hybrid is usually the right mental model for how real systems are built.

Common errors

These mistakes show up often in real projects and make otherwise strong algorithms fail.

• Encrypting a large file directly with RSA instead of using a hybrid envelope.
• Using encryption without integrity (no AEAD and no MAC), then assuming it cannot be modified.
• Reusing a nonce or IV with the same key (especially with AES-GCM and stream ciphers).
• Hardcoding secrets in source code or config files and calling that key management.

Quick example

(async () => {
  // Symmetric encryption demo: AES-GCM encrypt + decrypt.
  // Hybrid encryption would add a public-key step to protect the AES key.

  const plaintext = "hello";
  const encoder = new TextEncoder();
  const decoder = new TextDecoder();

  const key = await crypto.subtle.generateKey(
    { name: "AES-GCM", length: 256 },
    true,
    ["encrypt", "decrypt"]
  );

  // Use a unique IV (nonce) for each encryption with this key.
  // The IV is not secret. You must store/transmit it with the ciphertext.
  const iv = crypto.getRandomValues(new Uint8Array(12));

  const ciphertext = await crypto.subtle.encrypt(
    { name: "AES-GCM", iv },
    key,
    encoder.encode(plaintext)
  );

  const decrypted = await crypto.subtle.decrypt(
    { name: "AES-GCM", iv },
    key,
    ciphertext
  );

  console.log(decoder.decode(decrypted)); // hello
})();

Use with Encrypt Online

Practical check

• Encrypt the exact text: hello.
• Decrypt using the same secret and the stored IV/nonce.
• Expected output after decryption: hello.
• Do not compare ciphertext between runs; IV/nonce changes ciphertext each time.

References

• NIST SP 800-38D (GCM and GMAC): https://csrc.nist.gov/publications/detail/sp/800-38d/final
• RFC 8446 (TLS 1.3): https://datatracker.ietf.org/doc/html/rfc8446
• RFC 8017 (PKCS #1 v2.2, RSAES-OAEP): https://datatracker.ietf.org/doc/html/rfc8017
• NIST SP 800-56B Rev.2 (RSA key establishment schemes): https://csrc.nist.gov/pubs/sp/800/56/b/r2/final
• Web Cryptography API (W3C WebCrypto Level 2): https://www.w3.org/TR/webcrypto-2/

FAQ

Why not use asymmetric encryption for everything? Public key operations are slower and not designed for bulk data. Most systems use public key crypto for key setup and signatures, then symmetric AEAD for data.

Is hybrid encryption the same as envelope encryption? Envelope encryption is a common hybrid pattern: encrypt data with a unique data key, then protect that data key with a public key or a key-encryption key.

Related guides

• Encryption definition
• Base64 vs Base64URL
• Bcrypt Hashing and Verification

Related tools

• Encrypt Text
• Decrypt Text
• RSA-OAEP Key Wrap Demo