Product

OpenCode Console Breach Exposed Third-Party API Keys in a Distillation Attack

OpenCode says 1.4% of Console users had OpenAI, Anthropic, or Google keys stolen from a legacy system being retired, then used to harvest model output at volume. Affected users were emailed.

Kevin HuangKevin Huang
Heat: 1,480
OpenCode Console Breach Exposed Third-Party API Keys in a Distillation Attack

OpenCode described the incident as a large-scale distillation attack. The phrase sounds academic. In practice it means someone ran a machine in a loop, spending other people's API credits to harvest model output at volume.

What OpenCode confirmed about the Console breach

The open-source coding agent disclosed the incident on October 17 and 18 and started emailing users the same weekend. Its Console product, the hosted side of the project, had been compromised.

The company put the exposure at 1.4% of Console users. It also narrowed the group further: only accounts that had connected a third-party AI provider to Console were affected. Everyone else got nothing, and OpenCode says anyone who didn't receive an email wasn't in the affected set.

No email, no exposed key.

That's a useful detail for the worried. It's also the kind of statement that only covers what the company knows so far.

Why the blast radius stopped at 1.4% of OpenCode users

The stolen material was API keys, not passwords and not chat history. Those keys lived in a legacy system that OpenCode was in the middle of retiring, and the company says an attacker got unauthorized access to it.

Third-party keys for OpenAI, Anthropic, and Google sat in that system because Console needed them to route requests on a user's behalf. Anyone who never linked a provider account had no key stored there.

That explains the narrow percentage without making it reassuring. A key is a bearer credential. Whoever holds it can spend the account's money until someone rotates it.

OpenCode says it has found no signs that user data was exposed. Treat that as the company's current assessment, not a verified finding. No outside firm has published an audit.

The distillation attack behind the stolen keys

Distillation is how smaller models learn from bigger ones: feed the big model's answers into training for a cheaper system, then repeat until the student stops needing the teacher. Do it through an API and you're paying per token, which is why labs watch for it.

An attacker with a pile of stolen keys doesn't pay. They run high-volume automated queries, collect outputs, and walk away with a training set billed to someone else. OpenCode used the term "distillation attack" for exactly this pattern.

The victims got two problems at once. Their provider bills spiked, and their keys stopped working when the providers cut them off.

Rescana's write-up on the incident cites user reports of losses ranging from hundreds to thousands of dollars. That's a third-party roundup of self-reported figures, not an OpenCode count, and it shouldn't be read as a total. Rescana also maps the activity to known credential-theft techniques, which is analysis rather than attribution.

OpenCode's timeline starts at 00:30 UTC on October 17

BleepingComputer, citing OpenCode, puts the earliest possible key exposure at 00:30 UTC on October 17. Disclosure followed within a day or so, which is fast by the standards of these events.

Fast disclosure doesn't mean the window was short. What's missing is when the legacy system was first breached, how long the attacker had access before that timestamp, and how many keys were pulled.

OpenCode says it's working with Anthropic, OpenAI, and Google to revoke the affected credentials. Provider-side revocation is the right move, because it kills the credential at the source instead of trusting a vendor to police usage after the fact. It also means some users will see requests fail before they ever read the email.

What OpenCode still won't say

Three gaps stand out, and all three matter to anyone doing incident response on their own account.

The company hasn't published how long the attacker operated inside the legacy system. It hasn't given a count of stolen keys, only a percentage of users. And it hasn't released indicators of compromise, which would let security teams check their own logs for signs of the same traffic.

None of those omissions is unusual a few days into an incident. They do mean the current picture is a floor, not a ceiling.

There's also the structural question nobody has answered. A system being retired still held live credentials for three major providers. That's a decommissioning problem, and it usually comes from credentials outliving the service that needed them.

What OpenCode users should do with their API keys today

If you connected a provider account to OpenCode Console, assume the key is burned. Rotate it.

Revoke first in the provider dashboard, then issue a new one. Rotation without revocation leaves the old key alive.

Then check usage graphs and billing for the period after October 17. What counts as a spike? Volume that doesn't match your traffic, requests from regions you don't operate in, or spend on models you never call. Detection is where most credential theft gets caught, and a bill that triples in a week while nobody shipped anything new is the plainest signal you'll get.

Third, update every app and script that used that key. A rotated key breaks anything still holding the old string, and discovering that during a deploy is worse than discovering it now.

The broader habit is worth adopting regardless of this incident. Long-lived keys stored in someone else's workspace are a standing liability, and scoped, short-lived credentials shrink the damage when a vendor's legacy system turns out to still be holding them.

OpenCode's next update will be the one to watch. A timeline, a key count, and a set of indicators would turn a percentage into something users can actually check against their own logs.

Share This Story

Sources

Related AI News

A search bar with an assistant sidebar sliding in from the left and shortcut chips underneath
Product

Google Put Your Chat History on the Search Homepage

The box in the middle of google.com still takes a query. What changed is the furniture around it, and the reasoning behind the change is about how many questions you're supposed to ask in a row.

Heat: 1,790
An outlined app window in the foreground with a second window working behind it and a cursor path running between them
Product

Gemini Can Now Drive Your Mac, in a Window You Don't Have to Watch

Google's Mac app can now take a multistep job and finish it in apps it was never connected to, inside a window you don't have to watch. The part worth reading is where it stops and asks.

Heat: 1,740
Chat bubbles sealed inside a vault door with a retention dial and two faded 72-hour timers
Product

Gemini Now Lets You Keep Your Chats and Still Say No to AI Training

One switch used to decide two things at once, and now it decides one. The second change runs the other way and keeps more of what you assumed was gone.

Heat: 1,500
A stack of library layers on a plinth with a locked version tag on top and streams feeding in from above
Product

llama.cpp Reaches v1.0.0 and Promises to Stop Breaking Your Build

llama.cpp reached v1.0.0 after three and a half years, and the release is about a promise rather than a feature. The promise is that the next breaking change to the C API gets a number before it breaks anybody's build.

Heat: 1,200