
Black October: Nine Platforms Breached, One Target. Your AI Keys.
In October 2026, attackers breached nine AI developer platforms in a single month. Fireworks AI, Andromeda, Zeabur, Lightning AI, OpenCode, Railway, Warp, Command Code and Northflank all disclosed incidents between October 6 and October 30. The entry points differed. The prize mostly did not. Attackers went after the OpenAI, Anthropic and Google keys that developers had stored on these platforms, and three of the companies tie their incidents to model distillation.
On November 2 Google's Threat Intelligence Group and Mandiant published what that market looks like. Fraudulent charges above $100,000 in a single day. Cumulative bills reaching $1 million before access was revoked. Resellers routing other people's prompts through stolen keys, with the victim paying for every token.
In March we wrote about the LiteLLM supply chain attack and argued that AI credentials need envelope encryption, not environment variables. October showed the limits of that argument. Railway had envelope encryption. The attacker decrypted the secrets anyway.
A month of breaches
The disclosures below are the companies' own, compiled by Helix. No breach has been publicly tied to a named group.
| Platform | Disclosed | What the company says happened |
|---|---|---|
| Fireworks AI | Oct 9 | Stolen internal credentials exposed environment variables for evaluation jobs in a limited number of accounts |
| Andromeda | Oct 20 | Some company and customer credentials exposed in what it calls "an industry-wide attack" |
| Zeabur | Oct 15 | 3.2 million environment variable records across 321,810 accounts. Admin tokens and cloud keys sat in plaintext in a configuration repository |
| Lightning AI | Oct 15 | Unauthorized credential access. Studio taken offline |
| OpenCode | Oct 17 | Attackers reached an older system behind its hosted Console and may have read provider keys belonging to about 1.4% of Console users |
| Railway | Oct 20 | Customer environment variables decrypted for up to 1.85% of workspaces |
| Warp | Oct 26 | Agent decision logs and telemetry for about 1% of users, through a third-party vendor |
| Command Code | Oct 28 | All API keys revoked after what it calls a large-scale distillation attack |
| Northflank | Oct 30 | Environment variables possibly decrypted. Users confirmed their AI keys were used |
Every platform on that list stored customer secrets on behalf of developers. For an attacker who wants AI capacity, that is the most efficient place to look. One breach yields thousands of keys, each belonging to a team that has already done the work of getting approved for high rate limits.
Railway: the anatomy
Railway published the most detailed account, and it is worth reading in full. The short version is a chain of five links, each ordinary on its own.
- A shared build machine. Railway ran builds from different customers on the same VM. The attacker used a previously unknown vulnerability to partially escape filesystem isolation and read a host credential the build servers used to authenticate to internal systems.
- A credential trusted too widely. Railway's internal workflow cluster accepted that build credential as a trusted client. Its stored build histories contained build secrets and GitHub app tokens. The same credential could fetch repository snapshots used for caching, which gave the attacker a copy of Railway's internal monorepo.
- The codebase as a map. With the source in hand, the attacker probed long-dormant endpoints and found an incorrectly defined OIDC binding in a cloud environment. It issued short-lived cloud credentials.
- A path to the decrypt key. Those credentials led to a longer-lived one with access to an internal network, then to an SSH key used by the deployment system, then to an orchestration machine. On that machine was a credential that could unwrap the envelope-encrypted variables.
- A query by name. Each environment's data key was wrapped by a root key in the cloud provider's KMS. The attacker queried the variables database with regular expressions on variable names, prioritizing AI provider keys, and decrypted what matched.
Railway estimates about $740,000 in unauthorized AI spend. It notified GitHub, GitLab, Anthropic, OpenAI, OpenRouter, Google and Stripe among others, and reset tokens for 1,852 users.
Notice what did not fail. The encryption held. AES did not break, and nobody extracted a master key from KMS. The attacker never needed to. They found a principal that was allowed to call Decrypt and became it.
The market behind it
Google's report explains why anyone would go to this much trouble. Stolen keys are pooled behind an OpenAI-compatible endpoint and resold through what Google calls LLM mixers. One operator ran more than 500,000 model calls in under eight hours to power a token routing service called Jet Night, passing nearly a million dollars in token costs to the victim organization. Jet Night advertised "unlimited" plans for $60 a month, according to BleepingComputer.
The operators are careful. One group validated stolen keys with single-token requests (max_tokens=1), small enough to stay under the victim's volume alerts. Often the way in was not the AI key itself but stolen cloud identity: IAM credentials, service account keys, GitHub tokens and session tokens. From there attackers searched logs, databases and secret managers for anything that looked like a provider key.
Gateways are targets too. Google observed attackers exploiting CVE-2026-40217 in LiteLLM, a flaw in its key regeneration endpoint that let them turn ordinary virtual keys into full administrator credentials. Whoever holds the keys holds the risk.
Encryption at rest is not a control over who can decrypt
Envelope encryption answers one question well. If someone copies your database, do they get your secrets? With a KMS-held root key, they get ciphertext.
It does not answer the question Railway's attacker asked. Which identities in this environment are allowed to unwrap a data key, and how many hops away is the nearest one?
Every organization that holds secrets for others should be able to answer that with a list, not an assumption. Count the principals with Decrypt permission on the keys that protect customer credentials. Include the ones that are easy to forget:
- The deployment pipeline. A role that can deploy a service can usually run code as that service. If that service can decrypt, so can the pipeline.
- Bastions and operations hosts. A machine built for debugging that holds database credentials and a decrypt grant is the orchestration machine from step four.
- Build and preview infrastructure. Anything that runs code from more than one tenant is an entry point, not just a workload.
- Static master keys. A key that lives in configuration or infrastructure state rather than in KMS bypasses both the access policy and the audit log.
Railway's remediation is the right target. Only the secrets service can reach the keys that unwrap data keys. Each service can decrypt only the credentials it needs. Every encrypt and decrypt is centrally logged. A decrypt by any other principal should page someone, because the attacker's decrypt calls at Railway ran for more than two and a half hours.
Your CI pipeline is a decrypt path
Railway's third link was an OIDC binding. GitHub Actions OIDC is a real improvement over long-lived cloud keys in CI secrets, but it moves the security decision into the trust policy. A role that trusts repo:org/app:environment:production trusts any workflow that can declare that environment. If the environment has no required reviewers and no branch restriction, that means any branch.
Three checks take an afternoon:
- Require reviewers on production environments and restrict them to protected branches or release tags. This is the equivalent of the approval step Railway added to critical CI paths.
- Give each repository its own role. A repository that deploys a front end does not need read access to every service's secrets.
- Scope role passing. A deploy role allowed to pass any role in the account can launch a task as your most privileged service.
The better fix: stop handing applications the provider key
The deeper problem in every October breach is architectural. Each affected developer had a raw provider key sitting in an application's environment, where a platform breach could reach it. A raw provider key has no spending ceiling, no expiry and no owner other than the account that issued it. When it leaks, the only control left is revoking it at the provider and redeploying everything that used it.
An AI gateway changes what the application holds. With Ferentin, applications and agents authenticate with a gateway key instead of a provider key. That changes what a breach yields:
- Gateway keys are stored as hashes. A copy of the database is not a copy of the keys.
- Every gateway key can carry its own ceilings on tokens per minute, tokens per day and dollars per minute and per day. A stolen key spends what its ceiling allows and then stops. That turns a $1 million night into a bounded incident.
- Gateway keys expire and can be revoked in one place, without touching provider accounts or redeploying applications.
- Provider credentials live in one place, encrypted and audited, or in a Ferentin edge inside your own network where they are decrypted locally.
- Every request is attributed to a key, a user or agent and a policy. A sweep of single-token requests from an unfamiliar network is visible in one audit trail rather than scattered across provider dashboards.
This does not remove risk. It concentrates it. A gateway that holds provider credentials for many applications is a better target than any one of them, which is exactly why the questions above apply to us first. If you are evaluating gateways, ask the vendor to show you who can call Decrypt on the keys that protect your credentials. If you are comparing Ferentin with LiteLLM, Portkey or Helicone, our side-by-side comparison covers credential handling in detail.
What to do this week
- If you stored provider keys on any platform on the list above, revoke them at the provider and issue new ones. Deleting a secret on the platform does not invalidate it.
- Set spending limits and usage alerts with every provider you use. Treat any unexpected enablement of an AI service in a cloud account as a security event, as Google recommends.
- Search for provider keys in application environments, CI secrets and repositories. Each one is a place a breach can reach.
- List the principals that can decrypt your customer secrets. If the list includes your CI pipeline, a bastion or a static key, shorten it.
- Protect your production CI environments with required reviewers and branch restrictions.
- Move applications onto keys you control. A key with a ceiling, an expiry and an audit trail is a different risk from a key without one.
October will not be the last month like this. Attackers have discovered that the companies holding AI keys on behalf of others are the cheapest way to buy frontier capacity. The defense is not a stronger cipher. It is fewer identities that can decrypt, fewer places a raw key can live and a ceiling on what any one key can spend.
Ferentin's controls are audited under our SOC 2 Type II certification. The report is available under NDA through our Trust Center.
Stay in the loop
Get the latest on enterprise AI security delivered to your inbox.