Forge Learn/Algorithms Behind Security

Browsing as a guest. Sign in to save your progress and earn XP as you complete chapters.

Modular Arithmetic & the Caesar Cipher

4 min read

You'll learn to

-Use the % operator for wrap-around, and implement a Caesar shift that encrypts and decrypts
-Explain why only 26 keys makes it trivial to break by brute force
-Recognize it as the vocabulary of cryptography (key, plaintext, ciphertext), not as real security

The security chapters of this course are about cryptography, which means keeping messages secret or checking they are genuine. They lean on math you already have: modular arithmetic (the % operator) for wrap-around, and hashing, from the hashmap tier, with a very different set of guarantees. The Caesar Cipher Codex level starts with the simplest possible cipher: the Caesar cipher, named for Julius Caesar, who reportedly used a shift of 3 to encode military messages.

An Analogy: The Clock Face

On a clock, 10 o'clock plus 5 hours is 3 o'clock, not 15. The numbers wrap around at 12. The alphabet is a clock with 26 positions: shift "y" forward by 3 and you wrap to "b". Modular arithmetic is the math of clocks, and % 26 is how Python wraps a number back into range.

Shifting With Wrap-Around

A Caesar cipher shifts every letter forward by a fixed amount k, wrapping back to 'a' after 'z'. Convert a letter to its 0 to 25 index, add the shift, take the result mod 26, then convert back to a character. Decryption is the same operation with the shift negated, (index - k) % 26. Python's % operator always returns a non-negative result for a positive modulus, unlike some other languages, so the negative-shift case just works without special handling.

Press Run: encrypt, decrypt, and then break the cipher by trying every shift

def caesar_shift(text: str, k: int) -> str:
    k %= 26
    result = []
    for ch in text:
        if ch.isalpha():
            base = ord('A') if ch.isupper() else ord('a')
            shifted = (ord(ch) - base + k) % 26
            result.append(chr(base + shifted))
        else:
            result.append(ch)  # leave punctuation/spaces untouched
    return ''.join(result)


def caesar_encrypt(text: str, k: int) -> str:
    return caesar_shift(text, k)


def caesar_decrypt(text: str, k: int) -> str:
    return caesar_shift(text, -k)

secret = caesar_encrypt("The answer is in the bridge at noon", 3)
print("encrypted:", secret)
print("decrypted:", caesar_decrypt(secret, 3))
print("(-3) % 26 in Python is", (-3) % 26, "- the negative shift just works")

# an attacker does not know the key, so tries all 26 and keeps the guess with the most common English words
COMMON = {"the", "is", "in", "at", "of", "and", "to", "a"}
def score(text):
    return sum(1 for word in text.lower().split() if word in COMMON)

best = max(range(26), key=lambda k: score(caesar_decrypt(secret, k)))
print("brute force found shift", best, "->", caesar_decrypt(secret, best))

def caesar_shift(text: str, k: int) -> str:
    k %= 26
    result = []
    for ch in text:
        if ch.isalpha():
            base = ord('A') if ch.isupper() else ord('a')
            shifted = (ord(ch) - base + k) % 26
            result.append(chr(base + shifted))
        else:
            result.append(ch)  # leave punctuation/spaces untouched
    return ''.join(result)

def caesar_encrypt(text: str, k: int) -> str:
    return caesar_shift(text, k)

def caesar_decrypt(text: str, k: int) -> str:
    return caesar_shift(text, -k)

secret = caesar_encrypt("The answer is in the bridge at noon", 3)
print("encrypted:", secret)
print("decrypted:", caesar_decrypt(secret, 3))
print("(-3) % 26 in Python is", (-3) % 26, "- the negative shift just works")

# an attacker does not know the key, so tries all 26 and keeps the guess with the most common English words
COMMON = {"the", "is", "in", "at", "of", "and", "to", "a"}
def score(text):
    return sum(1 for word in text.lower().split() if word in COMMON)

best = max(range(26), key=lambda k: score(caesar_decrypt(secret, k)))
print("brute force found shift", best, "->", caesar_decrypt(secret, best))

Why This Is a Stepping Stone, Not Real Security

A Caesar cipher has exactly 26 possible keys (25 useful ones, since a shift of 0 does nothing). So trying every shift and spotting which gives readable text takes a human seconds and a computer microseconds, as the last lines of the demo show. Even without brute force, letter-frequency analysis cracks it almost as fast: in English, 'e' and 't' are the most common letters, and a shift preserves the pattern of how often each letter appears. The cipher does teach the vocabulary real cryptography builds on: key, plaintext (the readable message), ciphertext (the scrambled one), and encrypt and decrypt as inverse operations. It has none of the actual security. The rest of this module builds toward algorithms where "just try every key" is computationally infeasible, not merely inconvenient.

Never use a Caesar cipher, or any shift or substitution cipher, for anything that actually needs to be secret. Its only job here is to introduce the vocabulary and the modular-arithmetic mechanics that real cryptography builds on, such as RSA (a public-key encryption method) and SHA-256 (a widely used hash function).

Interview Signal is part of Pro

See a real weak answer next to a real strong one for this exact topic.

Quiz is part of Pro

Test what you just read with a short quiz, and bank the XP.

Ready to Build This?

The Caesar Cipher Codex level has you implement shift-based encryption and decryption using modular arithmetic on character codes, the same wrap-around logic above, plus handling edge cases like case and non-alphabetic characters.

Exponential Backoff & Jitter Cryptographic Hashing: SHA-256

Discussion0

Join the Discussion

No comments yet. Be the first to start the thread!