Secret codes decided the outcome of World War II before a single soldier read the message they protected. The German military trusted a typewriter-sized machine called Enigma to scramble its orders into what looked like random noise, and for years that trust was justified. Then a small group of Polish mathematicians, followed by the codebreakers at Bletchley Park, found the cracks. The story of how that happened, and what came after it, is really the story of modern cryptography.
A Commercial Invention Turned Into a Weapon
Enigma wasn't built for war. German engineer Arthur Scherbius patented the machine in 1918, hoping to sell it to banks and businesses that wanted to protect commercial correspondence. He founded a company to manufacture it and showed early models at a trade fair in 1923, but civilian demand never took off the way he expected. The German military saw something Scherbius's business customers didn't: a fast, repeatable way to encrypt battlefield communications without relying on codebooks that could be lost or stolen.
By the late 1920s, the German armed forces had adopted modified versions of Enigma for their own use, and mass production ramped up through the 1930s. The machine used a set of rotating wheels, each wired internally to swap one letter for another. Every keystroke advanced at least one rotor, so pressing the same letter twice in a row rarely produced the same encrypted output twice. A plugboard added a further layer of substitution before the signal ever reached the rotors. The number of possible settings ran into the billions, and German commanders had good reason to believe the system was unbreakable.
The Poles Found the First Crack
The first real breakthrough didn't come from Britain, and it didn't come during the war. It came from Poland in the early 1930s, years before the German invasion. French intelligence had obtained stolen Enigma operating manuals and passed them to the Polish Cipher Bureau, which put the documents to far better use than the French had. Mathematician Marian Rejewski used the leaked material, combined with pure mathematical analysis, to work out the internal wiring of the rotors without ever touching a real machine.
That achievement is easy to undervalue today because Bletchley Park gets most of the credit in popular accounts. But Rejewski's team had reconstructed a working replica of Enigma and built early codebreaking machines years before the war started. When Germany's invasion of Poland became a near-certainty in 1939, Polish intelligence handed their findings, along with physical Enigma replicas, to British and French codebreakers. That handoff gave Bletchley Park a running start it would not otherwise have had.
Bletchley Park and the Bombe
Britain's Government Code and Cypher School, based at Bletchley Park, absorbed the Polish research and pushed it further. As Germany added complexity to Enigma, including more rotor options and stricter operating procedures, the Polish techniques stopped working on their own. Alan Turing, working alongside other mathematicians and engineers, designed an electromechanical device called the Bombe that could test thousands of possible rotor settings far faster than any human. By 1940, the Bombe was producing usable decryptions of German military traffic.
The intelligence generated by this effort, codenamed Ultra, gave the Allies insight into German troop movements, naval deployments, and strategic planning throughout the war. Because Germany had shared Enigma technology with Japan, some of the same codebreaking techniques contributed to Allied successes in the Pacific theater as well. Some historians consider the cracking of Enigma one of the single most consequential Allied achievements of the war, not because it ended any one battle, but because it removed the fog of war from an adversary who believed their communications were completely secure.
From Rotors to Algorithms
Enigma belongs to a category cryptographers now call classical cryptography: methods built on physical devices, pencil-and-paper substitution, or mechanical rotors. Once electronic computing matured after the war, the field shifted almost entirely toward mathematics. Encryption stopped being something you could hold in your hand and became something expressed in algorithms designed to resist attacks that no mechanical device could ever face.
The first widely adopted standard for the computer age was the Data Encryption Standard, developed in the 1970s and adopted by the U.S. government for protecting sensitive but unclassified data. DES used a fixed-length key to scramble data in blocks, and for a while it was good enough. But computing power grew faster than DES's key length could keep up with, and by the late 1990s brute-force attacks against it were practical rather than theoretical.
That gap set the stage for the algorithm most people rely on today without realizing it. In 2001, the National Institute of Standards and Technology replaced DES with the Advanced Encryption Standard. AES is a symmetric cipher, meaning the same key both encrypts and decrypts the data, but it uses a much longer key than DES and has proven remarkably resistant to attack ever since. AES now secures everything from Wi-Fi traffic to encrypted messaging apps to the files on your laptop's hard drive.
Here's a simplified illustration of AES-style symmetric encryption in Python, using a well-established cryptography library rather than a hand-rolled implementation:
from cryptography. fernet import Fernet
# Generate a key and use it to create a Fernet cipher instance.
# Fernet uses AES under the hood, combined with authentication.
key = Fernet.generate_key()
cipher = Fernet(key)
message = b"Meet at the north bridge at 0600."
encrypted = cipher.encrypt(message)
decrypted = cipher.decrypt(encrypted)
print("Encrypted:", encrypted)
print("Decrypted:", decrypted.decode())
This code produces ciphertext that looks as meaningless to an outside observer as an intercepted Enigma transmission once did, except the underlying math would take longer than the age of the universe to brute-force with current computers.
Solving the Key Distribution Problem
Symmetric ciphers like DES and AES share a weakness that goes all the way back to Enigma: both parties need the same secret key, and getting that key safely into the right hands is its own security problem. German operators had to distribute rotor settings through printed codebooks, which is exactly the kind of physical vulnerability that let the Allies gain footholds in the first place.
In 1977, Ron Rivest, Adi Shamir, and Leonard Adleman introduced a different approach: public key cryptography, later named RSA after its creators. RSA lets each user hold a private key that never has to be shared, paired with a public key that anyone can use to encrypt a message meant only for that person. The security of the system rests on how difficult it is to factor the product of two very large prime numbers. Multiplying two large primes together is fast; reversing the process without knowing the original numbers is, for practical purposes, not.
RSA and the closely related Diffie-Hellman key exchange solved the distribution problem that had haunted cryptography since Enigma. Two parties who have never met can now agree on a shared secret over an open channel that an eavesdropper is watching the entire time, and the eavesdropper still can't recover the secret. That capability underpins the padlock icon in a web browser and the encrypted connection behind most everyday internet transactions.
A basic illustration of asymmetric encryption looks like this:
from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives import hashes
# Generate a private/public key pair.
private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
public_key = private_key.public_key()
message = b"Confirm rendezvous coordinates."
# Encrypt with the public key.
ciphertext = public_key.encrypt(
message,
padding.OAEP(
mgf=padding.MGF1(algorithm=hashes.SHA256()),
algorithm=hashes.SHA256(),
label=None,
),
)
# Only the matching private key can decrypt it.
plaintext = private_key.decrypt(
ciphertext,
padding.OAEP(
mgf=padding.MGF1(algorithm=hashes.SHA256()),
algorithm=hashes.SHA256(),
label=None,
),
)
print(plaintext.decode())
In practice, most secure systems combine both approaches. RSA or a similar algorithm handles the initial handshake and key exchange, then AES takes over for the bulk encryption of the actual data, since symmetric ciphers are much faster for large volumes of traffic.
The Next Disruption: Quantum Computing
Every era of cryptography has eventually met a method that broke it, and the current era is no exception. Quantum computers, if built at sufficient scale, threaten to undo the mathematical assumptions behind RSA and other public key systems. Shor's algorithm, a quantum algorithm developed in the 1990s, can in theory factor large numbers efficiently enough to break RSA encryption that would otherwise take classical computers longer than the age of the universe to crack. Elliptic curve cryptography, widely used as a more compact alternative to RSA, faces a similar threat because it also depends on a mathematical problem that quantum computers can solve far faster than classical ones.
Symmetric ciphers like AES fare better against this threat. Grover's algorithm, another quantum technique, only offers a quadratic speedup against symmetric encryption rather than the exponential break Shor's algorithm poses to RSA. Practically, that means AES-256 is expected to retain roughly 128 bits of effective security even against a capable quantum adversary, which remains strong by current standards, while AES-128 would be considered weaker and worth upgrading.
The response to this looming risk is already underway. The National Institute of Standards and Technology has finalized post-quantum cryptography standards designed to resist both classical and quantum attacks. One of them, a key-encapsulation mechanism built on lattice-based mathematics rather than prime factorization, is intended to eventually replace RSA and Diffie-Hellman for establishing shared secrets. A companion standard covers digital signatures using the same lattice-based foundation. Because large-scale quantum computers capable of actually breaking RSA don't exist yet, organizations have time to migrate, but government guidance already recommends phasing out smaller RSA keys well before 2035 and treating today's encrypted traffic as potentially exposed to future decryption once quantum capability catches up.
What the History Actually Teaches
Every generation of cryptography has followed the same arc: a method gets adopted with confidence, someone finds a flaw the designers didn't anticipate, and the field moves to something stronger. Enigma's designers didn't imagine that stolen manuals and careful mathematics could reconstruct their rotor wiring from the outside. DES's designers didn't anticipate how cheap computing power would become. RSA's designers built a system that has held up for nearly five decades, but even that system now has a visible expiration date on the horizon.
None of this means today's encryption is weak. AES remains extremely difficult to break by any known method, classical or quantum, and RSA is still safe for the threats that exist right now. What history shows is that cryptography is never a finished project. It's a continuous negotiation between people trying to keep secrets and people trying to expose them, and the winner of that negotiation has changed hands more than once. Anyone building or relying on secure systems today would do well to remember that the "unbreakable" label has never lasted as long as it sounded like it would.
Top comments (0)