Kill Chain

A native attacker toolkit on Apple Silicon, targets that fit the hardware, research checked fresh, and an eleven-module course that pairs every attack with its detection — built by an AI agent, once I found a model that would take the brief.

A colossal skull built from stacked server racks and cabling looms over a lone operator's workstation in a blood-red data hall, eyes glowing red — the anatomy of a cyber attack.
0:00
/4:17
A narrated documentary of a cyberattack, from authorization to domain compromise and the sentinel that catches it. Rendered from code with Claude Fable, one of the models that declined to build the lab in my sessions.

I wanted to learn offensive security the only way it sticks: hands on keyboard, against targets I own, running a full modern kill chain and understanding why each step works and how it is caught. So I asked my coding agent to build me the lab: a real security workstation on my Mac, the targets to attack, and a step-by-step course from recon to domain compromise.

The first thing I learned had nothing to do with hacking. I learned which model would do the work.

I run everything through Claude Code, and I let the harness pick the model per task. For this project, the defaults would not take it. In my sessions, the newer models I reach for by default — Claude Opus 5.5, Claude Fable 5.2 — declined the work, even with a lab on my own Mac, machines I own, public training ranges and authorization treated as step zero. The model that read the same brief and built the whole thing was the older one: Claude Opus 4.8. So that is what this project runs on, chosen by hand at launch, and it is the first line in the project's rulebook.

The station is the Mac, not a sandbox

My first instinct was the usual one: isolate everything. A host-only network, no route out, the lab sealed off from the world. I started building it that way and then stopped, because it was the wrong complexity. The thing that keeps a security lab lawful is not network plumbing — it is authorization. You attack what you own or have written permission to test. A perfectly isolated lab does not make an unauthorized target legal; a lab pointed at your own containers is fine.

So the design got simpler. All the attacker tooling installs natively on the Mac — a real workstation, from nmap to Metasploit, each a normal command. The targets are whatever is cheapest for the lesson: Docker containers for web apps, a local VM when I want to own a whole machine, and public platforms for everything that is painful to host. The only "isolation" left is binding the practice apps to 127.0.0.1 so they are not on my coffee-shop Wi-Fi.

My machine is Apple Silicon, and that changes the plan. You cannot run x86 Windows Server at any usable speed on an M-series chip — the emulators crawl, and the turnkey Active Directory labs everyone uses are built for x86 hypervisors. Rather than buy a second machine to host a domain, the lab sends all serious AD practice to the graded online ranges, which do not care what my laptop is, and keeps only a lightweight Arm Windows VM for owning a single box.

Nothing from memory

I gave the build one hard rule: research everything fresh before writing it down. Security moves too fast to trust a model's training data, and the point was borne out immediately. Left to memory, the lab would have taught the 2021 OWASP Top 10 — but there is a 2025 edition now, with a new category for software supply-chain failures. It would have reached for kube-hunter, which is end-of-life; the current tool is Trivy.

None of that is exotic knowledge; it is just newer than the model's memory. Every page in the lab's knowledge base now carries a "verified on" date and a source, and the standing instruction is to re-check before relying on it.

The course, one step at a time

A pile of tools is not an education. The part I care about most is the curriculum: eleven modules that build a full kill chain, designed to be done one at a time, practice first. You do the thing on a real target, then you learn why it worked, then you learn how a defender sees it. You do not move on until you pass the module's checkpoint.

  • 0 — Foundations. Scope and authorization, the method, your tools. You can state your rules of engagement from memory and name the stages of the kill chain.
  • 1 — Recon. nmap, masscan, ffuf against the local range and an easy box. From a cold address you produce a ranked map of services and hidden content, with your reasoning.
  • 2 — Web and API. The OWASP Top 10, by hand first, then Burp. Juice Shop, DVWA, WebGoat, a vulnerable API, then the graded web academy, one vulnerability class at a time.
  • 3 — Social engineering. An authorized phishing simulation against your own test users, with a local mail sink so nothing leaves the lab — paired hard with the detection side: email authentication, the report button, the telemetry.
  • 4 — Command and control. A callback on a lab machine with Sliver, operated like a red teamer, while you watch exactly what telemetry you generate.
  • 5 — Active Directory. The modern domain kill chain on the online ranges: Kerberoasting, certificate-service abuse, the graph, lateral movement, domain takeover — each mapped to the Windows event ID it trips.
  • 6 — Credentials. Cracking with the GPU and passing hashes, the connective tissue of every phase.
  • 7 — Cloud and containers. Kubernetes misconfig locally, cloud IAM paths on a throwaway account.
  • 8 — Mobile. Decompile, instrument, and proxy a vulnerable Android app; the iOS path.
  • 9 — Linux priv-esc and persistence, threaded through real boxes.
  • 10 — Capstone. Chain all of it end to end and write the engagement report. That report is the exit bar.

Every module ends on detection, so the lab tells you to turn on logging before you attack and watch your own technique land.

What the agent did

Strip away the subject and this was a day of agentic engineering. The agent researched six topic areas in parallel, each from primary sources with citations. It installed and verified the toolchain, hit the real snags — a C2 binary with an inconsistent release name, a framework that needed Rosetta, a port that macOS quietly squats — and worked around each one. It stood up the container range and proved every target reachable with a script that returns an exit code. It wrote the knowledge base and the curriculum, indexed it for search, and recorded the decisions it could not make alone so the next session inherits them.

I gave it root when it needed root — a single bounded grant, revoked the moment the privileged installs were done.

My read

The refusal is the part I keep turning over. I understand why "offensive security" makes a model cautious. But this brief was a lawful, scoped, defense-paired course against systems I own, which is how defenders are trained.

The lab is real and the course starts at Module 0. Next I work through it on my own machines and write up what the kill chain feels like once I have walked it.