The control nobody wrote down

On the evening of 2 November 1988, a graduate student at Cornell released ninety-nine lines of code onto the internet.

Robert Morris wasn't trying to break anything. The worm was supposed to be a census a quiet crawl to count how many machines were out there. He got one parameter wrong. Within hours it was replicating out of control, reinfecting the same machines over and over until they choked. By morning it had taken down roughly ten percent of the internet, back when ten percent of the internet was about six thousand computers.

Here's the part that matters. To write that worm, Morris had to independently discover a buffer overflow in fingerd, understand sendmail's debug mode well enough to abuse it, and write self-propagating code that worked across multiple architectures in 1988, with no Stack Overflow, no exploit database, no one to ask.

Almost nobody on Earth could have done it. That was the entire security posture of the early internet. Not that the systems were hard to break. They were trivially easy to break. It's that the number of people who knew how was somewhere in the low hundreds.

The systems weren't secure. The expertise was scarce. We confused the two, and we've been confusing them ever since.

What happens when someone packages it

Fast forward ten years. In 1998, a hacker collective called the Cult of the Dead Cow released a tool called Back Orifice at DEF CON. It gave you remote control of a Windows machine. It had a graphical interface.

You didn't need to understand a single thing about how it worked. You needed to be able to double-click.

The security community's reaction was mostly contempt, and it produced a lovely piece of vocabulary: script kiddie. Someone who attacks systems without understanding them. The word is an insult, and it was meant to be. But listen to what the insult is actually complaining about.

It isn't complaining that the attacks got better. The attacks were identical. It's complaining that the wrong people can now do them that a capability which used to require years of study had been compressed into a download.

The industry treated this as a matter of dignity. It was a matter of arithmetic. The population of people who could take over your machine went from hundreds to hundreds of thousands, overnight, and not one line of your defence had changed.

Same story, over and over, for twenty-five years:

1. HD Moore releases Metasploit. Exploitation becomes a menu.

2. The source code for the Mirai botnet gets dumped on a hacking forum. Within weeks there are dozens of forks, run by people who couldn't have written a line of it, and the internet gets some of the largest DDoS attacks in its history.

2017 onward. Ransomware goes affiliate. You didn't have to write the crypto, or find the initial access, or run the negotiation. You could just... sign up. The innovation wasn't technical at all. It was a business model that let people with no skills rent the skills of people who had them.

Every one of these was the same event. Not a new attack. A new population.

The control nobody wrote down

Go and read a risk register. Any risk register. Somewhere in it you'll find a phrase like "requires a sophisticated actor" or "low likelihood high skill barrier." It's usually attached to the risks that never get funded.

That phrase is doing enormous, silent work. It's the only place in the whole document where we admit the truth: a large amount of what protects you is that the people who could hurt you are rare, and busy, and mostly pointed at someone else.

Nobody ever wrote that down as a control. You won't find it in a framework. There's no ISO clause for the intersection of people who know how and people who care is nearly empty. But it's been holding the line since 1988, and every democratisation event Back Orifice, Metasploit, Mirai, ransomware-as-a-service was a piece of it falling away, one attack class at a time.

One attack class at a time. That's the reassuring bit. That's the bit that just ended.

Why this one is different

The tools that came before were packaged expertise. Someone who understood the attack built a wrapper so that people who didn't could still run that specific attack. The wrapper was narrow. It did one thing.

Large language models are not a wrapper around one attack. They're a general-purpose engine for converting intent into competence. Not perfectly. Not reliably. But well enough, often enough, cheaply enough, in whatever direction you point them.

The taxonomy of what they enable prompt injection, jailbreaking, adversarial manipulation, plain misuse is now a well-populated research field, and the consistent finding is that these models lower the technical threshold and the cost of multi-stage attacks. Researchers at IEEE S&P showed in 2024 that commercial models could be pushed into producing convincing phishing with evasive tactics built in.

Read that result carefully, because the interesting part is easy to miss. It is not a new phishing technique. Phishing is thirty years old and nobody needed help. What changed is who can produce good phishing and the answer moved from "people with a particular knack" to "anyone who can describe what they want."

Now run that substitution across your whole risk register. Every row where the mitigation was, if you're honest, nobody around here knows how.

The honest version

Let me argue against myself, because this field is full of people who won't.

Capable isn't reliable. A model that produces a working attack one time in five, with an expert filtering the output, is a completely different animal from one that works unattended. A lot of the alarming research demonstrates the first thing and gets reported as the second.

Much of it is theatre. Getting a model to say something bad in a lab, with a helpful prompt and no defender, is not operational uplift against a real target. The gap is enormous, and it is routinely elided by people with something to sell you.

The defenders got the same gift. Triage, detection engineering, code review, threat hunting all lifted by the identical capability jump. It is genuinely not obvious the trade favours attackers.

All three are fair. I still think the population argument survives all of them because it doesn't need the model to be good. It only needs the model to be good enough to move one person from couldn't have to could. That's a far lower bar than autonomy, and it drops with every release.

What to do on Monday

Stop discounting risk by attacker sophistication. If a row in your register is low-likelihood because it takes skill, that discount now has an expiry date on it. Re-rate it on impact and reachability.

Hunt for "nobody would bother." That sentence is where the assumption hides. It was usually right! Ask what happens when bothering becomes free.

Test with what attackers actually have. Not what your pentest vendor licenses. If a free model on a laptop could plausibly be aimed at your system, that's the test that counts and it costs nothing, which removes the usual excuse.

Go looking for what was never tested. Not because it was proven robust. Because building the test required exactly the expertise that used to be scarce. Absence of evidence has been quietly filed as evidence of absence for years, and some of those files are about to be opened.

Morris needed to be one of the few hundred people alive who could do what he did.

The uncomfortable thing was never that attackers might get smarter. It's that we built thirty years of defences on the assumption that most of them wouldn't and we never wrote it down, so now we can't find it to check.

It's worth asking what else in your risk register was resting on a control that isn't there.