Background: How did people encrypt before computers?

Before digital encryption, people protected secrets using substitution ciphers — schemes that replace each letter in a message with a different letter or symbol. Understanding these classical ciphers is essential because they reveal the fundamental tension at the heart of cryptography: complexity vs. breakability.

1.1 The Caesar Cipher

Julius Caesar reportedly used this cipher to protect military messages. The idea is simple: shift every letter in the alphabet by a fixed number of positions.

With a shift of 3: A → D, B → E, Z → C (it wraps around). So the word HELLO becomes KHOOR.

1.2 ROT13 — A Special Case

ROT13 is a Caesar cipher with a shift of exactly 13. Because the English alphabet has 26 letters, ROT13 is its own inverse: applying it twice gets you back to the original. It is used in online forums to hide spoilers, not for actual security.

1.3 The Vigenère Cipher

The Vigenère cipher uses a keyword instead of a single number. Each letter of the keyword determines the shift for the corresponding letter in the message. This makes frequency analysis harder — but not impossible.

For example, with keyword KEY:

1.4 Breaking Ciphers: Frequency Analysis

In any sufficiently long English text, some letters appear much more often than others. The letter E is the most common (~13%), followed by T, A, O, I, N. Attackers exploit this pattern to crack substitution ciphers.

Exercises

PBZCHGRE FRPHEVGL VF GUR CENPGVPR BS CEBGRPGVAT
FLFGRZF, ARGJBEXF, NAQ CEBTENZF SEBZ NGGNPX.

WKHUHDUH WRPHWKHU HQFUBSWHG PHVVDJHV KLGGHQ
LQ SODLQ VLJKW. WKH DUWRI KLGLQJ PHVVDJHV LV
FDOOHG VWHJDQRJUDSKB. LW LV GLIIHUHQW IURP
HQFUBSWLRQ EHFDXVH LW KLGHV WKH IDFW WKDW D
PHVVDJH H[LVWV DW DOO. HQFUBSWLRQ KLGHV WKH
FRQWHQW EXW QRW WKH IDFW WKDW D PHVVDJH ZDV VHQW.

Python Lab: Implement Your Own Caesar Cipher

# caesar.py — Build and break a Caesar cipher from scratch

def caesar_encrypt(text, shift):
    result = ""
    for char in text.upper():
        if char.isalpha():
            # ord() converts a letter to its ASCII number
            # A=65, Z=90. We shift within the alphabet using modulo.
            shifted = (ord(char) - 65 + shift) % 26 + 65
            result += chr(shifted)
        else:
            result += char  # preserve spaces and punctuation
    return result

def caesar_decrypt(ciphertext, shift):
    # Decrypting is just encrypting with the opposite shift
    return caesar_encrypt(ciphertext, 26 - shift)

def brute_force(ciphertext):
    """Try all 25 possible shifts"""
    for shift in range(1, 26):
        attempt = caesar_decrypt(ciphertext, shift)
        print(f"Shift {shift:2d}: {attempt}")

# --- Try it ---
secret = "HELLO WORLD"
encrypted = caesar_encrypt(secret, 7)
print(f"Original:  {secret}")
print(f"Encrypted: {encrypted}")
print(f"Decrypted: {caesar_decrypt(encrypted, 7)}")
print("\n--- Brute Force Attack ---")
brute_force(encrypted)

Background: What is hashing, and how does it differ from encryption?

Hashing and encryption are often confused, but they serve different purposes. Encryption is reversible — if you have the key, you can always get the original message back. Hashing is one-way — it converts data into a fixed-length "fingerprint" called a hash or digest. There is no key, and there is no way to reconstruct the original from the hash alone (in theory).

2.1 What are hash functions used for?

• Password storage: Databases store the hash of your password, not the password itself. When you log in, your input is hashed and compared to the stored hash.
• File integrity: Software downloads include a hash. After downloading, you hash the file yourself and compare — if they match, the file wasn't tampered with.
• Digital signatures: Instead of signing an entire document, you sign its hash (much faster).
• Blockchain: Each block contains the hash of the previous block, chaining them together immutably.

2.2 Properties a good hash function must have

2.3 The Avalanche Effect in Action

Change one character in your input and watch how completely the hash changes. This is called the avalanche effect and is a crucial security property.

2.4 On-Machine Labs: File Integrity Verification

import hashlib
import json
import os
from pathlib import Path

def hash_file(filepath, algorithm="sha256"):
    """Compute the hash of a file, reading in chunks for large files."""
    h = hashlib.new(algorithm)
    with open(filepath, "rb") as f:
        for chunk in iter(lambda: f.read(4096), b""):
            h.update(chunk)
    return h.hexdigest()

def create_baseline(directory, outfile="baseline.json"):
    """Hash all files in a directory and save the results."""
    baseline = {}
    for path in Path(directory).rglob("*"):
        if path.is_file():
            baseline[str(path)] = hash_file(path)
    with open(outfile, "w") as f:
        json.dump(baseline, f, indent=2)
    print(f"Baseline saved: {len(baseline)} files hashed.")

def verify_integrity(directory, baseline_file="baseline.json"):
    """Compare current hashes against the saved baseline."""
    with open(baseline_file) as f:
        baseline = json.load(f)
    tampered = []
    for filepath, stored_hash in baseline.items():
        if os.path.exists(filepath):
            current_hash = hash_file(filepath)
            if current_hash != stored_hash:
                tampered.append(filepath)
                print(f"[CHANGED] {filepath}")
        else:
            print(f"[MISSING] {filepath}")
    if not tampered:
        print("✓ All files intact. No changes detected.")

# --- Usage ---
# Step 1: create a baseline of a folder
create_baseline("./test_folder")

# Step 2: modify a file in test_folder, then run:
verify_integrity("./test_folder")

Background: Modern symmetric encryption

Classical ciphers like Caesar were symmetric: both parties used the same key. Modern symmetric encryption works the same way, but uses algorithms so mathematically complex that brute-force attacks would take longer than the age of the universe.

AES (Advanced Encryption Standard) is the global standard, adopted by NIST in 2001. It operates on 128-bit blocks of data using keys of 128, 192, or 256 bits. The NSA uses AES-256 for top-secret data. Understanding how to use it — and how to use it correctly — is a fundamental skill.

3.1 Block Cipher Modes: Why They Matter

Imagine encrypting a long message that is broken into 10 blocks. The simplest approach is to encrypt each block independently — this is ECB (Electronic Codebook) mode. The problem: identical plaintext blocks produce identical ciphertext blocks. Patterns survive.

3.2 CBC Mode and the Initialization Vector (IV)

CBC (Cipher Block Chaining) fixes the ECB pattern problem by XOR-ing each plaintext block with the previous ciphertext block before encrypting. This means identical plaintext blocks produce different ciphertext depending on their position and what came before them.

But the very first block has no previous block to XOR with — so we use an Initialization Vector (IV): a random value that starts the chain. The IV must be:

• Random — not a constant. A fixed IV breaks CBC security.
• Unique per message — reusing an IV with the same key leaks information about the plaintexts.
• Not secret — it can be sent alongside the ciphertext. Its job is randomness, not secrecy.

3.3 OpenSSL on the Command Line

OpenSSL is a free, open-source toolkit that implements SSL/TLS and a broad set of cryptographic operations. It comes pre-installed on all Linux distributions and on every Google Colab instance.

from IPython.display import Image, display
print("Original:")
display(Image('/content/tux.bmp'),     width=200)
print("ECB encrypted:")
display(Image('/content/tux_ecb.bmp'), width=200)
print("CBC encrypted:")
display(Image('/content/tux_cbc.bmp'), width=200)

import os
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.primitives import padding

def aes_encrypt(plaintext: bytes, key: bytes) -> bytes:
    """
    Encrypt plaintext using AES-128-CBC.
    Returns: IV (16 bytes) + ciphertext (padded to 16-byte boundary)
    """
    # Generate a fresh random IV for every encryption operation
    iv = os.urandom(16)

    # Apply PKCS7 padding so plaintext length is a multiple of 16
    padder = padding.PKCS7(128).padder()
    padded = padder.update(plaintext) + padder.finalize()

    # Encrypt using AES-CBC
    cipher = Cipher(algorithms.AES(key), modes.CBC(iv))
    encryptor = cipher.encryptor()
    ciphertext = encryptor.update(padded) + encryptor.finalize()

    # Prepend the IV to the ciphertext so the receiver can use it
    return iv + ciphertext

def aes_decrypt(data: bytes, key: bytes) -> bytes:
    """
    Decrypt data produced by aes_encrypt.
    Expects: IV (first 16 bytes) + ciphertext
    """
    iv = data[:16]
    ciphertext = data[16:]

    cipher = Cipher(algorithms.AES(key), modes.CBC(iv))
    decryptor = cipher.decryptor()
    padded = decryptor.update(ciphertext) + decryptor.finalize()

    # Remove the padding to get original plaintext back
    unpadder = padding.PKCS7(128).unpadder()
    return unpadder.update(padded) + unpadder.finalize()

# --- Demo ---
key = os.urandom(16)  # AES-128 requires 16-byte key
message = b"This is a secret message!"

encrypted = aes_encrypt(message, key)
decrypted = aes_decrypt(encrypted, key)

print(f"Original:  {message}")
print(f"Encrypted: {encrypted.hex()}")
print(f"Decrypted: {decrypted}")
print(f"\nIV used: {encrypted[:16].hex()}")

# Encrypt the same message twice — different IVs mean different outputs
enc1 = aes_encrypt(message, key)
enc2 = aes_encrypt(message, key)
print(f"\nEncryption 1: {enc1.hex()[:40]}...")
print(f"Encryption 2: {enc2.hex()[:40]}...")
print(f"Are they the same? {enc1 == enc2}")  # Should be False!