#Encryption: Protecting Data Through Cryptography

Start with readable data that needs protection.

plaintextOriginal Message: "Hello, this is a secret message"

Examples of Plaintext:

• Chat messages
• Credit card numbers
• Document contents
• Passwords (should be hashed, not encrypted!)
• Database records

Use a mathematical algorithm with a secret key to transform the data.

yamlAlgorithm: AES-256-GCM
Key: "my-secret-encryption-key-12345-very-long-and-random"
Key Length: 256 bits (32 bytes)
Mode: GCM (Galois/Counter Mode)

Popular Algorithms:

• AES-256 - Industry standard, very secure
• ChaCha20 - Modern, fast on mobile devices
• RSA-2048 - For public key encryption
• DES - OBSOLETE, never use!

The output is scrambled, unreadable data that looks like random bytes.

hexEncrypted Output: "8f3a9c7e2d1b5a4f9e3c7d2a1b8f4e6c2d9f1a3b5c7e9f0a2b4c6d8e0f2a4b6c..."

Ciphertext Properties:

• Appears completely random
• Same size or slightly larger than original
• Cannot be reversed without the key
• Secure even if attacker intercepts it

Only someone with the correct key can reverse the process and recover the original data.

plaintextDecrypted Output: "Hello, this is a secret message"

Decryption Process:

1. Use the same key (symmetric) or private key (asymmetric)
2. Apply the decryption algorithm
3. Recover original plaintext
4. Verify integrity (if using authenticated encryption)

Advantages:

• Fast: Very quick encryption/decryption
• Efficient: Low computational overhead
• Strong: Can provide excellent security

Disadvantages:

• Key Distribution Problem: How do you securely share the key?
• Key Management: Need different keys for different parties

Advantages:

• No Key Distribution Problem: Public key can be shared openly
• Digital Signatures: Can prove authenticity and integrity
• Better Key Management: Don't need to share secret keys

Disadvantages:

• Slower: 100-1000x slower than symmetric encryption
• Resource Intensive: Requires more computational power
• Larger Output: Ciphertext is larger than plaintext

┌─────────────┐
│   Sender    │
└──────┬──────┘
       │
       ├─1─> Generate random AES key
       │
       ├─2─> Encrypt message with AES key (fast)
       │     Message: "Secret data..."
       │     Result: [Encrypted Data]
       │
       ├─3─> Encrypt AES key with recipient's RSA public key
       │     AES Key: "random-key-123"
       │     Result: [Encrypted Key]
       │
       └─4─> Send both [Encrypted Data] + [Encrypted Key]
                          │
                          ▼
                   ┌──────────────┐
                   │  Recipient   │
                   └──────┬───────┘
                          │
                          ├─5─> Decrypt AES key with RSA private key
                          │     Result: "random-key-123"
                          │
                          └─6─> Decrypt data with AES key
                                Result: "Secret data..."

SECURE REQUIRES IV

How It Works: Each plaintext block is XORed with the previous ciphertext block before encryption.

Advantages:

• Secure when implemented correctly
• Same plaintext produces different ciphertext (with different IV)

Disadvantages:

• Sequential (can't parallelize encryption)
• Requires padding
• Vulnerable to padding oracle attacks if not handled properly

Use Case: File encryption, database encryption

python# CBC Mode
cipher = AES.new(key, AES.MODE_CBC)
ciphertext = cipher.encrypt(pad(plaintext, AES.block_size))
# Must store cipher.iv for decryption!

RECOMMENDED AUTHENTICATED

How It Works: Combines encryption with authentication, providing both confidentiality and integrity.

Advantages:

• Authenticated encryption (detects tampering)
• Parallelizable (fast)
• No padding required
• Built-in integrity check

Disadvantages:

• Slightly more complex
• IV reuse is catastrophic

Use Case: HTTPS/TLS, modern applications, network protocols

python# GCM Mode (Authenticated Encryption)
cipher = AES.new(key, AES.MODE_GCM)
ciphertext, tag = cipher.encrypt_and_digest(plaintext)
# Tag verifies data hasn't been tampered with

How It Works: Each block is encrypted independently with the same key.

Critical Problems:

• Same plaintext block → same ciphertext block (pattern leakage)
• Patterns in plaintext visible in ciphertext
• No integrity protection
• Attackers can rearrange encrypted blocks
• Reveals information about data structure

The Famous ECB Penguin Example:

VISUAL PROOF ECB IS BROKEN

Original Image → ECB Encryption → Pattern Still Visible! ❌
(Penguin bitmap)    (ECB mode)      (Penguin outline visible in "encrypted" image!)

When you encrypt an image with ECB, you can still see the outline of the image in the encrypted version! This demonstrates that ECB preserves patterns, which is catastrophic for security.

ABSOLUTELY NEVER USE ECB MODE IN ANY APPLICATION!

USE GCM INSTEAD

SECURE PARALLELIZABLE

How It Works: Converts block cipher into stream cipher using counter.

Advantages:

• Parallelizable (very fast)
• No padding required
• Random access possible

Disadvantages:

• No built-in authentication
• IV/nonce must never repeat

Use Case: Disk encryption, high-performance applications

python# CTR Mode
cipher = AES.new(key, AES.MODE_CTR)
ciphertext = cipher.encrypt(plaintext)

pythonfrom Crypto.Random import get_random_bytes

# ✅ CORRECT: Cryptographically secure
key = get_random_bytes(32)  # 256-bit key

# ❌ WRONG: Predictable
import random
key = bytes([random.randint(0, 255) for _ in range(32)])  # INSECURE!

javascriptconst crypto = require('crypto');

// ✅ CORRECT: Cryptographically secure
const key = crypto.randomBytes(32);

// ❌ WRONG: Predictable
const insecureKey = Buffer.from(
  Array.from({length: 32}, () => Math.floor(Math.random() * 256))
); // INSECURE!

javaimport java.security.SecureRandom;

// ✅ CORRECT: Cryptographically secure
SecureRandom random = new SecureRandom();
byte[] key = new byte[32];
random.nextBytes(key);

// ❌ WRONG: Predictable
Random insecureRandom = new Random();
insecureRandom.nextBytes(key); // INSECURE!

pythonimport os
from base64 import b64decode

# ✅ Load from environment
key = b64decode(os.environ['ENCRYPTION_KEY'])

bash# Set in environment
export ENCRYPTION_KEY="base64_encoded_key_here"

python# ✅ Use AWS KMS
import boto3

kms = boto3.client('kms')
response = kms.decrypt(CiphertextBlob=encrypted_key)
key = response['Plaintext']

python# ✅ Use Azure Key Vault
from azure.keyvault.secrets import SecretClient

client = SecretClient(vault_url=vault_url, credential=credential)
key = client.get_secret("encryption-key").value

python# ✅ Use HSM for high-security applications
from pkcs11 import Session

# Keys never leave the HSM hardware
session = Session(...)
key = session.get_key(...)
encrypted = key.encrypt(data)

pythonimport sqlite3
from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes
import json

class EncryptedDatabase:
    def __init__(self, db_path, master_key):
        self.conn = sqlite3.connect(db_path)
        self.master_key = master_key

    def store_encrypted(self, table, data):
        """Store encrypted data"""
        # Generate unique key for this record
        key = get_random_bytes(32)

        # Encrypt data
        cipher = AES.new(key, AES.MODE_GCM)
        json_data = json.dumps(data).encode()
        ciphertext, tag = cipher.encrypt_and_digest(json_data)

        # Encrypt the key with master key
        master_cipher = AES.new(self.master_key, AES.MODE_GCM)
        encrypted_key, key_tag = master_cipher.encrypt_and_digest(key)

        # Store in database
        self.conn.execute(
            f"INSERT INTO {table} (data, key, nonce, tag, key_nonce, key_tag) VALUES (?, ?, ?, ?, ?, ?)",
            (ciphertext, encrypted_key, cipher.nonce, tag, master_cipher.nonce, key_tag)
        )
        self.conn.commit()

    def retrieve_encrypted(self, table, record_id):
        """Retrieve and decrypt data"""
        cursor = self.conn.execute(
            f"SELECT data, key, nonce, tag, key_nonce, key_tag FROM {table} WHERE id = ?",
            (record_id,)
        )
        row = cursor.fetchone()

        # Decrypt the key
        master_cipher = AES.new(self.master_key, AES.MODE_GCM, nonce=row[4])
        key = master_cipher.decrypt_and_verify(row[1], row[5])

        # Decrypt the data
        cipher = AES.new(key, AES.MODE_GCM, nonce=row[2])
        json_data = cipher.decrypt_and_verify(row[0], row[3])

        return json.loads(json_data)

pythonfrom Crypto.Cipher import AES
from Crypto.Protocol.KDF import PBKDF2
import os

def encrypt_file(input_file, output_file, password):
    """Encrypt a file with password"""
    # Derive key from password
    salt = get_random_bytes(32)
    key = PBKDF2(password, salt, dkLen=32, count=1000000)

    # Read file
    with open(input_file, 'rb') as f:
        plaintext = f.read()

    # Encrypt
    cipher = AES.new(key, AES.MODE_GCM)
    ciphertext, tag = cipher.encrypt_and_digest(plaintext)

    # Write encrypted file
    with open(output_file, 'wb') as f:
        f.write(salt)           # 32 bytes
        f.write(cipher.nonce)   # 16 bytes
        f.write(tag)            # 16 bytes
        f.write(ciphertext)     # Variable

def decrypt_file(input_file, output_file, password):
    """Decrypt a file with password"""
    # Read encrypted file
    with open(input_file, 'rb') as f:
        salt = f.read(32)
        nonce = f.read(16)
        tag = f.read(16)
        ciphertext = f.read()

    # Derive key from password
    key = PBKDF2(password, salt, dkLen=32, count=1000000)

    # Decrypt
    cipher = AES.new(key, AES.MODE_GCM, nonce=nonce)
    plaintext = cipher.decrypt_and_verify(ciphertext, tag)

    # Write decrypted file
    with open(output_file, 'wb') as f:
        f.write(plaintext)

# Usage
encrypt_file('secret.pdf', 'secret.pdf.enc', 'strong-password-123')
decrypt_file('secret.pdf.enc', 'secret.pdf', 'strong-password-123')

Modern web applications should always use HTTPS:

python# Flask with HTTPS
from flask import Flask

app = Flask(__name__)

@app.route('/api/data')
def get_data():
    return {'secret': 'data'}

if __name__ == '__main__':
    # Use SSL context
    app.run(
        ssl_context=('cert.pem', 'key.pem'),
        host='0.0.0.0',
        port=443
    )

javascript// Node.js with HTTPS
const https = require('https');
const fs = require('fs');
const express = require('express');

const app = express();

const options = {
  key: fs.readFileSync('key.pem'),
  cert: fs.readFileSync('cert.pem')
};

https.createServer(options, app).listen(443);

pythonclass SecureChannel:
    """End-to-end encrypted communication"""

    def __init__(self):
        # Each party generates key pair
        self.private_key = RSA.generate(2048)
        self.public_key = self.private_key.publickey()

    def get_public_key(self):
        """Share public key with other party"""
        return self.public_key.export_key()

    def encrypt_message(self, message, recipient_public_key_pem):
        """Encrypt message for recipient"""
        recipient_public_key = RSA.import_key(recipient_public_key_pem)

        # Generate session key
        session_key = get_random_bytes(32)

        # Encrypt message with session key
        cipher = AES.new(session_key, AES.MODE_GCM)
        ciphertext, tag = cipher.encrypt_and_digest(message.encode())

        # Encrypt session key with recipient's public key
        rsa_cipher = PKCS1_OAEP.new(recipient_public_key)
        encrypted_session_key = rsa_cipher.encrypt(session_key)

        return {
            'encrypted_key': encrypted_session_key,
            'nonce': cipher.nonce,
            'tag': tag,
            'ciphertext': ciphertext
        }

    def decrypt_message(self, encrypted_data):
        """Decrypt received message"""
        # Decrypt session key with private key
        rsa_cipher = PKCS1_OAEP.new(self.private_key)
        session_key = rsa_cipher.decrypt(encrypted_data['encrypted_key'])

        # Decrypt message with session key
        cipher = AES.new(session_key, AES.MODE_GCM, nonce=encrypted_data['nonce'])
        plaintext = cipher.decrypt_and_verify(
            encrypted_data['ciphertext'],
            encrypted_data['tag']
        )

        return plaintext.decode()

# Usage
alice = SecureChannel()
bob = SecureChannel()

# Alice encrypts message for Bob
encrypted = alice.encrypt_message("Hi Bob!", bob.get_public_key())

# Bob decrypts Alice's message
message = bob.decrypt_message(encrypted)
print(message)  # "Hi Bob!"

Use standard libraries (don't roll your own crypto - it WILL have vulnerabilities) Use AES-256-GCM for symmetric encryption (industry standard, hardware accelerated) Use RSA-2048+ or ECC-256+ for asymmetric encryption (RSA-4096 or ECC-384 for high security) Generate random IV/nonce for each encryption (NEVER reuse!) Use authenticated encryption (GCM, ChaCha20-Poly1305) to detect tampering Use key derivation functions (PBKDF2, Argon2, scrypt) for passwords, not plain hashing Rotate keys regularly (every 90 days for high-security applications) Use HTTPS/TLS for ALL network communication (no exceptions!) Store keys securely (KMS, HSM, encrypted vault - never in code or config) Keep cryptographic libraries updated (new vulnerabilities discovered regularly) Use constant-time comparisons for MACs and hashes (prevent timing attacks) Test encryption implementation (encrypt/decrypt tests, tamper tests, fuzzing)

Never use ECB mode (broken, leaks patterns - use GCM instead) Never reuse IV/nonce (catastrophic security failure - can break encryption) Never hardcode keys in source code (WILL be leaked on GitHub) Never use MD5 or SHA1 for security (completely broken, use SHA-256+) Never implement your own encryption algorithm (professionals take decades to design secure crypto) Never store passwords encrypted (hash them with Argon2/bcrypt instead) Never use encryption without authentication (allows tampering - use GCM or add HMAC) Never use weak keys (<128 bits - use 256 bits for symmetric, 2048+ for RSA) Never trust user input for cryptographic operations (validate and sanitize everything) Never use the same key for multiple purposes (encryption key ≠ MAC key) Never ignore library errors (failed decryption = tampered data, handle securely) Never use predictable random numbers (random() is NOT crypto-secure!)

python# ✅ Use PyCryptodome or cryptography
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.backends import default_backend

# Or
from Crypto.Cipher import AES

javascript// ✅ Use built-in crypto module
const crypto = require('crypto');

// Or for advanced features
const sodium = require('libsodium-wrappers');

java// ✅ Use javax.crypto (built-in)
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;

// Or Google Tink for modern API
import com.google.crypto.tink.Aead;
import com.google.crypto.tink.KeysetHandle;

go// ✅ Use crypto package
import (
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
)

Use Symmetric (AES) when:

• Both parties can securely share a key
• Encrypting large amounts of data (files, databases, disk encryption)
• Performance is critical - need fast encryption/decryption
• Encrypting data at rest (backups, archives)

Use Asymmetric (RSA/ECC) when:

• Sharing keys securely is difficult or impossible
• Digital signatures are needed (authentication, non-repudiation)
• Key exchange in untrusted networks (initial connection)
• One-way communication (encrypt for recipient who isn't online)

Use Hybrid (BEST CHOICE) when:

• Encrypting data for transmission (HTTPS, VPN, messaging)
• Need both security and performance
• Building any production system
• This is what the real world uses!

Recommended Key Sizes (2025):

SYMMETRIC ENCRYPTION

• AES-128: 128 bits - Secure for most uses
• AES-192: 192 bits - Extra security margin
• AES-256: 256 bits - Maximum security, government use RECOMMENDED

ASYMMETRIC ENCRYPTION (RSA)

• RSA-1024: Broken - can be cracked
• RSA-2048: Minimum for 2025 MINIMUM
• RSA-3072: Good security margin
• RSA-4096: High security, slower HIGH SECURITY

ASYMMETRIC ENCRYPTION (ECC)

• ECC-256: Equivalent to RSA-3072 RECOMMENDED
• ECC-384: Equivalent to RSA-7680
• ECC-521: Maximum security

Rule of thumb: Longer keys = more security, but slower performance. For symmetric encryption, 256 bits is the sweet spot. For asymmetric, RSA-2048 or ECC-256 is the minimum.

When to use each:

• Encryption: Credit cards, files, messages, data you need to decrypt later
• Hashing: Passwords, file integrity, blockchain, digital signatures

Yes and No:

THREATENED BY QUANTUM

• RSA - Shor's algorithm can break RSA in polynomial time
• ECC - Also vulnerable to Shor's algorithm
• Diffie-Hellman - Key exchange compromised
• DSA/ECDSA - Digital signatures broken

SAFE FROM QUANTUM

• AES-256 - Quantum reduces to ~128-bit security (still secure)
• SHA-256 - Hash functions remain secure (Grover's algorithm only gives quadratic speedup)
• ChaCha20 - Symmetric ciphers remain strong

THE SOLUTION

Post-Quantum Cryptography (PQC):

• NIST standardizing new quantum-resistant algorithms
• Kyber - Quantum-safe key exchange (standardized 2024)
• Dilithium - Quantum-safe digital signatures
• SPHINCS+ - Stateless hash-based signatures

MUST ENCRYPT (ALWAYS)

Critical Data - NEVER store unencrypted:

• Passwords - Hash with Argon2/bcrypt, NEVER encrypt!
• Credit card numbers - PCI-DSS requires encryption
• Social Security Numbers - Required by law (GDPR, HIPAA)
• Personal health information - HIPAA compliance
• Authentication tokens - Session tokens, JWTs with sensitive data
• API keys & secrets - Exposed keys = system compromise
• Private communications - Messages, emails, chat logs
• Private encryption keys - Encrypt with master key or KMS
• Database credentials - Use secret managers
• Biometric data - Fingerprints, facial recognition data

SHOULD ENCRYPT (RECOMMENDED)

Sensitive Data - Strong recommendation:

• User personal data - Names, addresses, phone numbers, emails
• Business documents - Contracts, financial records, strategic plans
• Database backups - Contains all sensitive data
• Log files with sensitive info - May contain PII, tokens, errors
• User activity data - Browsing history, usage patterns
• Email archives - May contain sensitive conversations
• Cloud storage - Files uploaded by users

MAY NOT NEED ENCRYPTION

Public/Non-Sensitive Data:

• Public website content - Already publicly accessible
• Non-sensitive configuration - Public settings, feature flags
• Public documentation - User guides, FAQs
• Anonymized analytics - No PII, aggregated only
• Cached public data - Already public information

Decision Framework:

Ask yourself:

1. Would a breach harm users? → Encrypt
2. Is it regulated data (PII, PHI, PCI)? → Encrypt
3. Would competitors benefit from seeing it? → Encrypt
4. Would you be embarrassed if it leaked? → Encrypt
5. Is it publicly available already? → Maybe don't encrypt