Capstok — learn by doing

Why this matters

Vigenère was called 'le chiffre indéchiffrable' for nearly three centuries — from its publication in 1553 until Babbage and Kasiski independently broke it in the mid-1800s. The reason it survived so long is the reason it is worth studying now: it diffuses the single-letter frequency signal that destroyed the Caesar cipher by using a different shift for every position determined by a repeating key. This is the first real glimpse of two ideas that drive all modern symmetric cryptography: the idea that a key should be expanded into per-position keystream material, and the idea that period-based structure (here, the key length) is itself a form of leakage. When we get to stream ciphers like ChaCha20, you'll see the same architecture — generate a long pseudorandom keystream, XOR with plaintext — but with a key whose period is 2^256 instead of 6.

Demo

Vigenère encrypts the i-th plaintext letter by shifting it by the i-th letter of the key, where the key is repeated to match the plaintext length. With a key of length L, every L-th letter is encrypted with the same Caesar shift.

C_i = (P_i + K_{i \bmod L}) \bmod 26

Try it yourself

Encrypt 'ATTACKATDAWN' with key 'LEMON' using Vigenère by hand and verify each shift: A+L=L, T+E=X, T+M=F, A+O=O, C+N=P, K+L=V, ...
Encrypt 'CRYPTOGRAPHY' with key 'KEY' and identify which plaintext letters end up encrypted to the same ciphertext letter (period collisions).
Show that Vigenère with key length 1 reduces to a Caesar cipher — encrypt with key 'D' and confirm the result equals caesar_encrypt(pt, 3).
Encrypt the same plaintext with two different 6-letter keys and observe that the ciphertexts share no obvious relationship despite the period being equal.
Write a short script that XORs the encrypted message with the encrypted message of itself shifted by the key length, and observe what structure emerges (this is the hint for Kasiski's attack).

References

// main.go
package main

import (
	"fmt"
	"strings"
)

func vigenereEncrypt(plaintext, key string) string {
	pt := strings.ToUpper(strings.ReplaceAll(plaintext, " ", ""))
	k := strings.ToUpper(key)
	out := make([]byte, 0, len(pt))
	for i, ch := range pt {
		if ch >= 'A' && ch <= 'Z' {
			shift := k[i%len(k)] - 'A'
			out = append(out, byte((int(ch-'A')+int(shift))%26)+'A')
		}
	}
	return string(out)
}

func vigenereDecrypt(ciphertext, key string) string {
	ct := strings.ToUpper(ciphertext)
	k := strings.ToUpper(key)
	out := make([]byte, 0, len(ct))
	for i, ch := range ct {
		if ch >= 'A' && ch <= 'Z' {
			shift := int(k[i%len(k)] - 'A')
			out = append(out, byte((int(ch-'A')-shift+26)%26)+'A')
		}
	}
	return string(out)
}

func main() {
	ct := vigenereEncrypt("ATTACKATDAWN", "LEMON")
	fmt.Println(ct)                          // LXFOPVEFRNHR
	fmt.Println(vigenereDecrypt(ct, "LEMON")) // ATTACKATDAWN
}

Run: go run main.go

The Vigenère Cipher

Why this matters

Demo

Try it yourself

References