All experiments

Kryptos

A C++ encryption system I built in 10th grade where the password wasn't a string but a *sequence of encryption algorithms*. Each character of the password selected a different cipher; the file got recursively encrypted through the chain. An intentional homage to Enigma's configuration-as-key idea.

Context
Personal experiment in obfuscated-pipeline encryption
Role
Designer and implementer.

Bill of materials

  • C++
  • Custom cipher primitives
  • Intended hardware companion unit

10th grade. I was learning C++ as a school subject and also spending a lot of time on the side with Kali Linux and security tooling, and I wanted to build something that combined the two. The name was going to be “Krupt OS” and got stylised into Kryptos.

The premise

Conventional password-based encryption: the file gets encrypted with one cipher, and the password is a string fed to that cipher as a key. Break the password, break the file. My idea was to treat the password as a pipeline specification instead of a key.

Each character in the password mapped to a different encryption algorithm. A might mean XOR against a known pattern; B might mean a substitution cipher; C a transposition; and so on through a catalogue. A six-character password didn’t mean a single algorithm with a six-character key — it meant the file went through six different ciphers in sequence, each adding its own layer. Decryption required reversing the whole chain in exact order.

The intent was to make brute-force fundamentally harder: an attacker wouldn’t just be guessing key material, they’d be guessing which ciphers were used, in what order, with which internal parameters. The software itself — the catalogue of ciphers and their configurations — was effectively part of the key, the way the rotor wiring on an Enigma machine was.

What I actually finished

A C++ implementation of the pipeline with a small library of cipher primitives, command-line usage to encrypt/decrypt against a given password. The hardware companion I’d sketched — a dedicated device that would handle encryption end-to-end so plaintext never touched a general-purpose OS — never got built.

Was it actually secure

Almost certainly not by modern standards. Layering weak ciphers doesn’t give you a strong cipher; it gives you an expensive weak one. But this was 10th grade, and the point wasn’t that it was production-grade cryptography — it was that I learned what a substitution cipher is, what a transposition cipher is, why key space matters, and why obfuscating the pipeline isn’t the same as proving a lower bound on attack cost. Which is a useful set of things to misunderstand before you understand them.