Symmetric Encryption

Symmetric Encryption: Core Concepts

Symmetric encryption uses the same key to encrypt and decrypt data. If Alice encrypts a file with key K, Bob needs the exact same key K to decrypt it. This simplicity makes symmetric encryption fast and efficient -- it is the workhorse of data protection, used in TLS, disk encryption, and encrypted messaging.

The Key Distribution Problem

The fundamental challenge of symmetric encryption is key distribution: how do you securely share the key with the intended recipient without an attacker intercepting it? If you send the key over the same channel as the encrypted data, an attacker who captures both gains nothing (the data is already encrypted), but if they capture the key, they can decrypt everything.

This is why symmetric encryption is almost always combined with asymmetric encryption in practice: use asymmetric encryption to securely exchange the symmetric key, then use symmetric encryption for the actual data transfer. This is exactly what TLS does.

Block Ciphers and Stream Ciphers

Symmetric ciphers fall into two categories:

Block ciphers encrypt data in fixed-size blocks. AES uses 128-bit blocks. If the data is not a multiple of the block size, padding is added. The way you handle multiple blocks is called the mode of operation.

Stream ciphers encrypt data bit by bit or byte by byte, generating a keystream that is XORed with the plaintext. ChaCha20 is a modern stream cipher.

AES: The Advanced Encryption Standard

AES (Rijndael) is the most widely used symmetric cipher in the world. It supports key sizes of 128, 192, and 256 bits, with 10, 12, or 14 rounds of transformation respectively.

Each round applies four operations:

1. SubBytes -- Non-linear byte substitution using an S-box
2. ShiftRows -- Cyclic shift of each row in the state matrix
3. MixColumns -- Matrix multiplication that diffuses bytes across columns
4. AddRoundKey -- XOR the state with the round key

The security of AES comes from the diffusion and confusion these operations provide. After several rounds, every bit of the output depends on every bit of the input and every bit of the key.

Modes of Operation

The mode of operation determines how a block cipher handles multiple blocks:

ECB (Electronic Codebook) -- Each block is encrypted independently. Identical plaintext blocks produce identical ciphertext blocks. This leaks patterns and should never be used for data larger than one block.

CBC (Cipher Block Chaining) -- Each plaintext block is XORed with the previous ciphertext block before encryption. An initialization vector (IV) is used for the first block. CBC provides confidentiality but not integrity -- an attacker can modify ciphertext without detection.

GCM (Galois/Counter Mode) -- Combines counter mode encryption with a Galois field authentication tag. GCM provides both confidentiality and integrity (authenticated encryption). It is the recommended mode for most applications.

from cryptography.hazmat.primitives.ciphers.aead import AESGCM
import os

key = AESGCM.generate_key(bit_length=256)
aesgcm = AESGCM(key)
nonce = os.urandom(12)  # 96-bit nonce for GCM

plaintext = b"Secret message"
associated_data = b"authenticated but not encrypted header"

ciphertext = aesgcm.encrypt(nonce, plaintext, associated_data)
# ciphertext includes the authentication tag

decrypted = aesgcm.decrypt(nonce, ciphertext, associated_data)
assert decrypted == plaintext

Where It Fits

Symmetric encryption provides confidentiality -- ensuring that only authorized parties can read the data. It does not provide authentication (proving who sent the data) or non-repudiation (preventing the sender from denying they sent it). For those, you need asymmetric cryptography. Study Hashing and Integrity first to understand how hashes complement encryption, then move to Asymmetric Encryption to see how key distribution is solved.

Symmetric Encryption: Practice

Symmetric encryption is easy to use incorrectly. The exercises below cover the most common real-world patterns and pitfalls.

Exercise 1: Encrypt a File with AES-GCM

from cryptography.hazmat.primitives.ciphers.aead import AESGCM
import os

def encrypt_file(input_path, output_path, key):
    aesgcm = AESGCM(key)
    nonce = os.urandom(12)
    
    with open(input_path, 'rb') as f:
        plaintext = f.read()
    
    ciphertext = aesgcm.encrypt(nonce, plaintext, None)
    
    with open(output_path, 'wb') as f:
        f.write(nonce + ciphertext)  # Prepend nonce for decryption

def decrypt_file(input_path, output_path, key):
    aesgcm = AESGCM(key)
    
    with open(input_path, 'rb') as f:
        data = f.read()
    
    nonce = data[:12]
    ciphertext = data[12:]
    
    plaintext = aesgcm.decrypt(nonce, ciphertext, None)
    
    with open(output_path, 'wb') as f:
        f.write(plaintext)

# Usage
key = AESGCM.generate_key(bit_length=256)
encrypt_file('secret.txt', 'secret.enc', key)
decrypt_file('secret.enc', 'secret_decrypted.txt', key)

The nonce is prepended to the ciphertext so the decryptor can find it. With GCM, the nonce must be unique for each encryption with the same key -- never reuse a nonce.

Exercise 2: Understand Why ECB Is Broken

Encrypt an image with ECB mode and observe the pattern leakage:

from Crypto.Cipher import AES
from PIL import Image
import numpy as np

# Load an image and encrypt with ECB
img = Image.open('penguin.png').convert('RGB')
data = img.tobytes()

key = b'0123456789abcdef'  # 128-bit key
cipher = AES.new(key, AES.MODE_ECB)

# Pad data to 16-byte boundary
padded = data + bytes(16 - len(data) % 16)
encrypted = cipher.encrypt(padded)

# The encrypted image still shows the original shape!
# This is because identical pixel blocks encrypt identically.

This is why ECB is never used for images or any data with repeating patterns. Use GCM or CBC instead.

Exercise 3: Use OpenSSL for Command-Line Encryption

# Encrypt a file with AES-256-GCM
openssl enc -aes-256-gcm -salt -in secret.txt -out secret.enc -k "password"

# Decrypt
openssl enc -aes-256-gcm -d -in secret.enc -out secret_decrypted.txt -k "password"

# Note: OpenSSL's enc command uses a key derivation function (PBKDF2)
# to derive the key from the password. For production, use a proper
# key management system instead of password-based encryption.

Exercise 4: Key Rotation

Implement a simple key rotation strategy:

import json
import os
from cryptography.hazmat.primitives.ciphers.aead import AESGCM

class KeyRotator:
    def __init__(self, key_file='keys.json'):
        self.key_file = key_file
        self.keys = self._load_keys()
        self.current_key_id = max(self.keys.keys())
    
    def _load_keys(self):
        if os.path.exists(self.key_file):
            with open(self.key_file) as f:
                return {int(k): v for k, v in json.load(f).items()}
        return {}
    
    def rotate_key(self):
        new_key_id = self.current_key_id + 1
        self.keys[new_key_id] = AESGCM.generate_key(bit_length=256).hex()
        self.current_key_id = new_key_id
        self._save_keys()
    
    def encrypt(self, plaintext):
        key = bytes.fromhex(self.keys[self.current_key_id])
        aesgcm = AESGCM(key)
        nonce = os.urandom(12)
        ciphertext = aesgcm.encrypt(nonce, plaintext, None)
        return json.dumps({
            'key_id': self.current_key_id,
            'nonce': nonce.hex(),
            'ciphertext': ciphertext.hex()
        })

Check Your Understanding

• Why must the nonce be unique for each encryption with the same key in GCM mode?
• What happens if you reuse a key-nonce pair in GCM?
• Why is ECB mode insecure for encrypting images?

Symmetric Encryption: Trade-offs and Interviews

Symmetric encryption is fast and efficient, but it has limitations that make it unsuitable as a standalone solution for many security problems.

When Symmetric Encryption Is the Wrong Tool

• Key distribution over insecure channels: If you cannot securely share the key, symmetric encryption alone cannot protect your communication. Use asymmetric encryption (or a key exchange protocol like Diffie-Hellman) to establish the symmetric key.
• Digital signatures: Symmetric encryption cannot provide non-repudiation. If Alice and Bob share a key, either could have created a message. For proof of origin, use asymmetric signatures.
• Multiple recipients: If you need to send encrypted data to 100 people, you either need 100 different keys (one per recipient) or a way to securely distribute the same key to all 100. Both are management nightmares. Use a hybrid approach: encrypt the data with a symmetric key, then encrypt that key with each recipient's public key.

Performance Comparison

Symmetric encryption is orders of magnitude faster than asymmetric encryption:

This performance difference is why TLS uses asymmetric encryption only for the initial handshake (key exchange) and symmetric encryption for the actual data transfer.

Key Management: The Real Challenge

The security of symmetric encryption depends entirely on key management:

• Key generation: Use a cryptographically secure random number generator (CSPRNG). Never use rand() or other non-crypto PRNGs.
• Key storage: Keys must be stored securely -- in hardware security modules (HSMs), key management services (AWS KMS, Azure Key Vault), or at minimum, in files with restrictive permissions.
• Key rotation: Keys should be rotated regularly to limit the impact of a key compromise. Implement versioning so data encrypted with old keys can still be decrypted.
• Key destruction: When a key is no longer needed, it must be securely destroyed. Simply deleting the file is not enough -- use cryptographic erasure (overwriting) or hardware-based destruction.

How This Comes Up in Interviews

• "Why does TLS use both symmetric and asymmetric encryption?" Asymmetric encryption is used for the initial key exchange because it does not require a pre-shared key. Once the symmetric key is established, symmetric encryption is used for the actual data transfer because it is orders of magnitude faster.
• "What is the difference between CBC and GCM modes?" CBC provides confidentiality but not integrity -- an attacker can modify ciphertext without detection. GCM provides both confidentiality and integrity through authenticated encryption, and it is the recommended mode for most applications.
• "How do you manage encryption keys in production?" Use a dedicated key management service (AWS KMS, Azure Key Vault, HashiCorp Vault). Never hardcode keys in source code. Implement key rotation and versioning. Store keys in HSMs when possible.