Dark Perimeter: Real Breaches, Real Stakes
Every major cyberattack has a story behind it. A vulnerability no one patched. A phishing email someone clicked. A nation-state with a motive. Dark Perimeter goes beyond the headlines to explore the true stories of the hacks, breaches, and cyber operations that shaped history - told in narrative form for security professionals and curious minds alike. No guests, no panels, no filler. Just the story.
Dark Perimeter: Real Breaches, Real Stakes
Kill the Attacker at Machine Speed
Use Left/Right to seek, Home/End to jump to start or end. Hold shift to jump forward or backward.
Here's a number I want you to sit with. Thirty-one seconds. That's how long it took an attacker to hit a failed login, reason about why it failed, rewrite the approach and get back in. No human at the keyboard. No operator awake somewhere pasting commands from a playbook. Just a language model narrating its own logic and code. Comments as it worked, fixing its own mistakes faster than most of us can read the alert. That attack has a name now Jadepuffer. And Sysdig is calling it the first ransomware operation run, start to finish by an AI agent. Tonight we're not going to panic about it. We're going to ask the harder question. If the attacker moves at machine speed, what does defense actually have to become? And what happens to the sacred cow of our whole industry? The human in the loop. I've got two people to help me take this apart. Dr. Elliot Vance, who tracks the research side of this, and Marcus Hale, who runs the kind of program where these decisions have real consequences. Elliot, uh start with the mechanism. What actually happened here?
SPEAKER_00So the shape of it matters more than the branding. The agent got in through an internet-facing Langflow instance, an AI orchestration tool using a known remote code execution flaw, CVE 20253248. From there, it behaved the way you'd expect a competent human operator to behave, but compressed. It dumped the local PostgreSQL database, hunted for environment variables and secrets, found credentials, enumerated a MiniO object store, and notably walked right into that store using the factory default login, Mini OAdmin over Mini OAdmin. Then it pivoted to a separate production target. A MyCQL server running Alibaba Nakos exploited a second vulnerability to mint a rogue admin account and encrypted over 1,300 configuration items before deleting the originals. Two distinct targets: credential theft, lateral movement, encryption, destruction. A full kill chain.
SPEAKER_01And the part that got everyone's attention wasn't the sophistication. It was that it didn't need to be sophisticated.
SPEAKER_00Exactly right. None of these vulnerabilities were novel. The default Minio credential is almost embarrassing. What's new is the orchestration. The payloads were self-nerrating, full of natural language reasoning and target prioritization that human operators almost never write, but that LLM generated code produces reflexively. The agent adapted in real time, retried failed steps with refined parameters. It's not that the AI discovered a new way to break in, it's that it removed the human labor from stitching the steps together.
SPEAKER_02And that's the piece I'd underline for anyone running a program. For years, our comfort blanket has been that skilled attackers are scarce and expensive. A crew can run a handful of intrusions at once because it's limited by how many good operators it can pay. That constraint is what a lot of our risk math quietly assumes. An agent doesn't have that constraint. It runs thousands in parallel at the cost of inference. So the thing that changed isn't the ceiling of what attackers can do. It's the floor. The bar to entry just fell through the basement, and the volume ceiling just disappeared.
SPEAKER_01So, hold on, I want to be fair to the skeptics here. Because this show doesn't do hype. TechCrunch pointed out this attack still needed a human to kick it off. It wasn't fully autonomous from nothing.
SPEAKER_02That's true, and it's worth saying plainly, a human still lit the fuse, but that's cold comfort. The expensive, skill-intensive, time-intensive middle of the attack, the part that used to give defenders hours or days, is what got automated away. I don't care that a person pressed go. I care that the 90 minutes of hands-on keyboard work in the middle collapsed to almost nothing.
SPEAKER_01Which brings us to the real subject. Elliot, put the speed change in numbers because I think people underestimate how fast this actually moved.
SPEAKER_00The 2026 Unit 42 incident response report is the clearest data point. In the fastest cases they investigated, attackers went from initial access to data exfiltration in 72 minutes. That's four times faster than the equivalent figure a year earlier. And that trend line predates fully agentic attacks. Layer machine speed orchestration on top, and the window keeps compressing. The uncomfortable implication is structural. Almost every incident response framework we use was designed for human speed attacks. Detect, triage, escalate, convene a bridge call, decide, act. That loop assumes you have hours. Increasingly, you have minutes.
SPEAKER_01Marcus, walk me through what that does to a normal program. Because on paper, most of us have an IR plan. We've got the runbook. We've got the on-call rotation.
SPEAKER_02Right, and here's where it breaks. Picture the real sequence. An alert fires at two in the morning. It sits in a queue for 11 minutes because the analyst is working three others. They open it, spend 10 minutes deciding it's real, another 10 pulling context, then they page the on-call lead. The lead wakes up, joins a call, asks for more data. Somewhere around minute 50, someone with authority to isolate a production database says yes. By then in the JDPuffer timeline, it's over. The data's encrypted and the originals are gone. The plan didn't fail because it was a bad plan. It failed because every step assumed a human tempo the attacker no longer respects.
SPEAKER_01So the instinct in the room, the obvious instinct, is fine, take the humans out, automate the whole thing, machine against machine. Elliot, is that where this goes?
SPEAKER_00It's the tempting conclusion, and it's wrong, at least in the naive form, because the same reports that document the speed problem also document an accuracy problem. Autonomous triage and response systems get a meaningful fraction of cases wrong. The figure that gets cited is roughly 30% error on judgment calls. If you hand full unsupervised authority to a system that's wrong three times in ten, you haven't solved your incident problem. You've built a new one, and you've pointed it at your own production estate. Imagine an agent that isolates the wrong subnet or revokes credentials for a service that turns out to be your payment processor at machine speed thousands of times.
SPEAKER_01So we can't keep the human in the loop because the human is too slow. And we can't take the human out of the loop because the machine is too wrong. That's the trap. That's the whole episode, really. How do we get out of it?
SPEAKER_02The way out is to stop treating human in the loop as one setting and start treating it as a roading decision. Not every action carries the same risk. Some responses are cheap and reversible, some are expensive and permanent. The mistake is applying the same approval tax to both.
SPEAKER_01Give me the concrete version of that.
SPEAKER_02Take reversibility as the axis. Killing a suspicious network session, quarantining a single endpoint, forcing a step-up authentication challenge, dropping a host into microsegmentation isolation. Those are reversible. If the machine gets it wrong, you undo it in seconds, and the blast radius is one box or one session. Let the machine do those autonomously, at full speed, all day, no human approval. Now the other bucket, wiping a system, mass revoking credentials across a domain, shutting down a production database, anything that's hard or impossible to walk back. Those route to a human, fast, but a human. The design principle is that autonomy scales with reversibility. You give the machine free reign exactly where a mistake is cheap, and you reserve human judgment for where a mistake is permanent.
SPEAKER_00And there's a useful phrase emerging for the posture itself: moving the human from in the loop to on the loop. In the loop means every action waits for a person. That's the bottleneck we described. On the loop means the system acts within pre-authorized boundaries, and the human supervises, sees what it's doing in real time, and can intervene or override. The human is setting policy and watching the exceptions, not gating every keystroke. The Cloud Security Alliance work on machine speed defense frames it as agents that collect and reason, automation that executes the safe majority, and human analysts who approve the novel or irreversible minority.
SPEAKER_01So the human's job changes from responder to something more like a supervisor of a fleet.
SPEAKER_00Or an air traffic controller. You're not flying each plane. You've defined the corridors and you're watching for the situation that doesn't fit the pattern. Governed autonomy is the term I'd use. Machine speed on the 80% of cases where the action is safe and reversible. Human judgment routed to the 20% that's novel or irreversible.
SPEAKER_02And I want to make this practical because governed autonomy can sound like a slide title. It means you do the hard work up front when nobody's under fire. You sit down and you decide, in advance, which containment actions your tooling is allowed to take on its own. You write those authorization boundaries down, you define the conditions, you define what's out of bounds, you test it in a mode where it recommends but doesn't execute, so you can measure that error rate against your own environment instead of trusting a vendor's number. And only when you trust the boundaries do you let it act inside them. The pre-authorization is the whole game. You're pre-deciding at human speed and with human judgment, so that execution can happen at machine speed without a human in the path.
SPEAKER_01Let me push on this, because it sounds clean, and I don't trust clean. Marcus, what's the failure mode of governed autonomy? Where does this bite the people who adopt it?
SPEAKER_02Two places. First, the boundaries you set are only as good as your understanding of your own environment, and most organizations understand their environment worse than they think. If you authorize automated isolation, but your asset inventory is garbage, the machine will confidently isolate something critical you forgot was load-bearing. Autonomy amplifies whatever discipline or lack of it you already have. Second, alert fatigue mutates. Instead of drowning in alerts, your analysts drown in approval requests for the irreversible bucket. If 90% of those approvals are routine, people start rubber stamping, and then the human on the loop is a human, asleep at the loop. You've recreated the bottleneck with extra steps.
SPEAKER_00And there's a governance layer above the technical one that I think your audience, the people reporting to a board, need to hear. When you delegate response authority to a machine, you're making a risk acceptance decision, and it needs to be an explicit one. Someone with the authority to accept that risk has to sign off on the statement. We are allowing automated systems to take these specific actions under these conditions, and here is the residual risk that the machine will sometimes be wrong. That's not a SOCI decision. That's a leadership decision. The worst version of this future is the one where autonomy creeps in tool by tool, default by default, and nobody ever consciously decided how much authority the machines have.
SPEAKER_01That's the part that actually keeps me up more than the attack. The attack is legible, a slow, unlogged drift of decision authority from humans to systems, with no one owning the call. That's how you end up somewhere you never chose to go.
SPEAKER_02And the fix is unglamorous. Write it down. Make the delegation explicit and reviewable. Log every autonomous action so there's an audit trail a human can reconstruct after the fact. Keep the residual risk in front of leadership in plain language. Transparency and accountability aren't compliance theater here. They're the thing that keeps governed autonomy from quietly becoming ungoverned autonomy.
SPEAKER_01Let's land this somewhere useful. Someone's listening who runs a real program, maybe a lean one. They can't buy their way out of this with a platform. Marcus, what's the honest first move?
SPEAKER_02Start with the two things that would have stopped Jade Puffer Cold and cost nothing. Patch your internet facing stuff because the initial access here was a known CVE, and kill default credentials because Minio Admin over Minio Admin is why the object store fell in one step. The machine speed conversation is important, but most machine speed attacks are still walking through human speed hygiene failures. Fix those first or the rest is decoration.
SPEAKER_00Then second, instrument for speed. You cannot respond at machine speed to something you detect an hour late. Before you automate response, shorten detection. Know your mean time to detect and drive it down, because automated response on top of slow detection just means you contain the fire after the house is gone.
SPEAKER_02And third, do the pre-authorization exercise even without fancy tooling. Sit down with your team and sort your response actions into reversible and irreversible. Just that. That single conversation tells you where you could safely let automation run today and where a human has to stay. You don't need an agentic SOC to start thinking in terms of governed autonomy. You need a whiteboard and an honest look at what your actions actually cost to undo.
SPEAKER_01So the through line is this. Machine speed attacks don't mean we hand the keys to machines. They mean we do our human thinking earlier, once, deliberately, so that when the 72-minute clock starts, the safe actions are already authorized, and the dangerous ones are the only thing a human has to touch. The human doesn't leave the loop. The human moves up onto it and gets very clear about which decisions are theirs to keep. Elliot. Our job is to get earlier. This is dark perimeter.