TL;DR

Barracuda’s November breach had no zero-day. An AI vendor finished a project and kept a valid cloud key, the vendor got breached, and an AI-driven attacker used that key to cross about 10 cloud accounts, a CI pipeline and Kubernetes clusters in roughly 44 hours. Nobody noticed until two days later. When the attacker runs at machine speed, detection can’t be your main defense. The control that would have stopped it was boring: retire the key when the contract ends, or better, never issue a long-lived key at all.

Originally published at portfolio.hagzag.com.

04:33 on a Saturday

On November 1 at 04:33 UTC, someone made an API call with a Barracuda cloud access key. It was a real key that worked. Barracuda had given it to an AI company for an earlier project and never revoked it when the work ended. In October the vendor’s own dev environment was compromised, and according to BleepingComputer the key sat in a config file in the vendor’s GitHub repository.

Barracuda’s CISO wrote the post-mortem himself, and one line stands out: “We did not retire the key when the vendor … finished that work. That is on us.” Credit to him for that. Most incident reports bury their root cause in passive voice.

Within minutes the attacker was mapping what the key could reach. That is the part that should change how we think about offboarding.

How one key turned into ten accounts

The intrusion, which press and the CSA link to the ARTEX AI attack tooling, followed a chain any red-teamer would recognize. ARTEX just ran it without stopping to sleep:

  1. Vendor key → stored secrets. The key could read stored AWS access keys and Azure service principal secrets. Each secret opened the next system.
  2. Cloud → data platform → source control. A data analytics system turned up a source-code access token.
  3. Source control → CI. In under four hours it pushed short-lived branches to a few repositories. They triggered a build workflow that printed build secrets into the job log, encoded so log masking wouldn’t catch them. As CSA put it, it didn’t need to compromise the build platform. Push access was enough.
  4. CI → Kubernetes. It ran a container that mounted the host filesystem and collected that node’s credentials from metadata services, service accounts and decrypted IaC state.
  5. Persistence attempt. It tried to create its own admin cloud identity. A preventive policy blocked that, not a person.

Last activity was November 2 at 23:31. An engineer reported strange activity on their own account on November 4. By then the attacker had been finished for more than a day.

This wasn’t a one-off. Barracuda says the October Railway incident, which ran up about $740K in unauthorized AI compute, “closely resembled” theirs. CSA’s Nov 17 briefing describes another ARTEX case that started with a CI/CD API token, probably obtained through a third party.

The contrarian part: your SOC was never going to catch this

Barracuda’s own conclusion is blunt: “Detect-and-respond, as the primary strategy, is dead.” I agree, and I think most platform teams haven’t absorbed what that means.

The usual offboarding process is a calendar item. The contract ends, someone files a ticket to “remove vendor access,” and the ticket waits behind sprint work. That was acceptable when the attacker was a person who needed days to understand your environment. It isn’t acceptable when the attacker maps your permissions in minutes and is done before your Monday standup.

So the question isn’t “how fast can we detect?” It’s “what can this credential do at 04:33 on a Saturday when nobody is watching?” If the answer is “read every secret in the account,” you have already lost. You just don’t know it yet.

What I’d actually change on Monday

None of this is new. That’s the uncomfortable part.

1. No long-lived keys for third parties. Vendors get federated, short-lived access: an IAM role they assume through OIDC or a cross-account trust with an external ID, with session lengths in hours. Barracuda says it directly: “Short-lived, narrowly scoped credentials would have stopped this intrusion at its first step.” It’s the same idea as the 120-second permits in Driving Permits, applied to companies instead of agents.

2. Every vendor credential has an expiry date tied to the contract. If you can’t do federation yet, put the end date on the credential itself, not in a spreadsheet. Then run this weekly:

# List every active access key and when it was last used.
# A vendor key that went quiet when the contract ended shows up here.
aws iam generate-credential-report >/dev/null && sleep 5
aws iam get-credential-report --query Content --output text | base64 -d \
  | awk -F, 'NR>1 && $9=="true" {print $1, "key1_last_used:", $11}'

Unused keys are the cheapest finding in cloud security, and they’re also the ones attackers like most.

3. Make push access less powerful. If anyone with push access can trigger a workflow that has production secrets, then push access means secret access. Gate secret-bearing jobs on protected branches or environments with required reviewers, and don’t give them to arbitrary short-lived branches.

4. Deny the moves that turn a foothold into ownership. Block hostPath mounts with admission policy (Kyverno, Gatekeeper or Pod Security restricted). Deny creating admin identities outside a break-glass path. Barracuda’s one clean win in this whole timeline was a preventive policy, which tells you where to spend effort.

5. Log data access on secret stores. Barracuda couldn’t fully rule out access to some credentials because logging in one environment “was not detailed enough.” You can’t recover cleanly from something you can’t scope.

What actually goes wrong (including for me)

Item 1 is harder than it sounds. Many SaaS and AI vendors still ask for an access key pair in their onboarding wizard, and “we only support static keys” is a common answer. When that happens, the honest trade-off is a scoped key, an expiry on your side, and a named owner who gets paged when it’s still active a day after the contract ends.

The other failure is ownership. The engineer who created the vendor key moved teams, procurement closed the contract, and security never knew the key existed. Offboarding fails in that gap between teams. That’s why the fix has to be technical, with credentials that expire by default, and not another process step.

Conclusion

Barracuda didn’t lose to a novel exploit. It lost to a key that outlived the reason it was created. As attackers get faster, the time between “the vendor got breached” and “you got breached” shrinks toward zero. The only credential that’s safe at machine speed is one that has already expired.

This week, pull your credential report and filter for keys held by anyone who no longer works with you. That list is where an attacker would start.