critical

CVE

Not assigned

CWE

CWE-668, CWE-269, CWE-284, CWE-522, CWE-798

Affected Surface

  • Railway workspaces whose environment variables or sealed variables were stored on the platform between 20 and 21 October 2026 (at most 1.85% of workspaces, about 100,000; Railway emailed the workspaces it rated high risk)
  • Secrets passed to Railway builds whose histories were read between 13:50 and 15:30 UTC on 20 October 2026 (353 builds, sealed variables included)
  • 1,852 Railway users whose linked-account tokens (GitHub OAuth tokens and bring-your-own-key agent keys) were decrypted; Railway reset all of them
  • AI provider API keys (Anthropic, OpenAI, OpenRouter, Google Gemini, AWS Bedrock, SpaceXSI and others), cloud, database and payment credentials stored as Railway variables

TL;DR

Railway, the deployment platform, published its full incident report on 10 November 2026. Between 07:28 UTC on 20 October and 09:24 UTC on 21 October, an attacker went from a customer build to decrypting other customers’ environment variables. The chain had three weak links: a previously unknown partial filesystem escape on shared build hosts, an internal Temporal cluster that treated the build servers’ registry-push credential as a trusted client, and an OIDC binding in one cloud environment that should not have existed. The attacker found that binding by reading Railway’s own monorepo, which they had pulled out of the build cache.

The impact:

  • At most 1.85% of workspaces (about 100,000) could have had variables decrypted. That’s an upper bound, because Railway’s logs record environments, not individual variables.
  • 353 build histories were read in full on 20 October, sealed variables included.
  • 1,852 users had linked GitHub OAuth tokens or BYOK agent keys decrypted. Railway reset all of them.
  • Database logs show the attacker filtering variable names with regexes for AI provider keys and going after environments with many variables. A second query also matched cloud, database and payment credentials. Railway puts unauthorized AI spend at about $740,000.

What to do now: If you stored secrets in Railway before 22 October 2026, rotate all of them, not just AI keys. Pay particular attention to anything you put in build-time variables. Check usage logs at your AI, cloud and payment providers for 20 October onward, and file unexplained charges through Railway’s refund form. Revoke and reissue any GitHub OAuth grants for the Railway app. Then look at your own pipelines for the same three patterns.

Affected systems

PlatformComponentWhat was exposedWindow (UTC)Status
RailwayShared multi-tenant build hostsHost files, including the build server credential20 Oct 07:28 to 17:28Builds now run on dedicated ephemeral VMs
RailwaySelf-hosted Temporal cluster for buildsStored histories of other builds: variables, a read-only GitHub app token scoped to one repo, build metadata20 Oct 13:50 to 15:30 (353 builds)Shared system retired
RailwayBuild cache snapshotsRailway’s internal monorepo20 OctNo customer repositories downloaded, per Railway
RailwayProduction variable store + KMSEnvelope-encrypted environment variables for up to ~100,000 workspaces21 Oct 04:07 to 07:14Decryption now restricted to the secrets service
RailwayLinked accountsGitHub OAuth tokens and BYOK agent keys for 1,852 users21 OctAll reset

There is no package or version to upgrade. Railway customers fix this by rotating credentials.

Technical analysis

Railway hasn’t published code for the isolation escape and says it is coordinating disclosure with the upstream projects whose bugs it found. What the report does describe is a chain of trust mistakes, and each one appears in plenty of CI/CD setups.

1. Shared build hosts and a credential on disk

Railway ran several customer builds on the same VM, isolated from each other. The attacker had been creating accounts since 18 October and started probing the builder at 06:50 UTC on 20 October. At 07:28 they used an unknown vulnerability to partly escape filesystem isolation and read files on the host. One of those files held the credential that build servers use to authenticate to internal systems, mainly to push finished images to the registry.

The isolation bug was the way in, but the credential sitting on a shared host is what turned one escape into access to the whole platform. An hour after Railway patched the original bug, its own hardening team found a variant. That’s a big part of why Railway moved everyone onto the new per-build VM builder early instead of rolling it out gradually.

2. A push credential that Temporal treated as a trusted client

Railway’s builds were driven by a self-hosted Temporal cluster. Each Temporal task carried the build’s secrets: environment variables, a read-only GitHub app token for one repository, and execution metadata. The push credential was only supposed to authorize registry pushes, but Temporal accepted it as a client. That gave the attacker Temporal client APIs, which they used to read workflow histories for other customers’ builds.

One of those histories was for station.railway.com, Railway’s support platform, which deploys out of the internal monorepo onto Railway itself. The same credential could fetch the repository snapshots used for build caching, so the attacker took a copy of the monorepo. Railway noticed only later, when the attacker started probing endpoints that hadn’t been used in weeks or years.

The general lesson: workflow engines like Temporal, Airflow or Argo store task inputs, secrets included, in their history. Any identity that can read history can read those secrets.

3. An OIDC binding found in source, then a key on an orchestration host

Railway rotated the build credential at 17:28 UTC on 20 October and re-enabled builds. The attacker went back to the monorepo and found an incorrectly defined OIDC binding between Railway’s CI/CD and one cloud environment. At 03:26 UTC on 21 October they used it to get a short-lived cloud credential.

From that cloud environment they pulled two longer-lived secrets: a credential that, from inside the internal VPC, could read encrypted variables out of the production database, and the SSH private key the CD system uses to push binaries. They used the key to log in to an orchestration machine. That machine had a file on disk holding a credential that could call the key management service and decrypt per-environment data keys, because it needed them to provision workloads.

Railway uses envelope encryption, so each environment has its own data key and the root key never leaves the cloud KMS. That limited the blast radius, but it didn’t stop decryption: the attacker had both the ciphertext and a principal allowed to unwrap keys. Between 04:07 and 05:21 UTC they pulled envelopes from the database, and between 04:42 and 07:15 UTC they decrypted some of them. Railway disabled all active cloud credentials at 07:14, cut off the decryption service, and halted builds for every customer again at 07:22.

The weakness to look for in your own setup is OIDC trust policies that don’t pin sub (repository, branch or environment) and aud. A binding that accepts any token from your CI issuer lets anyone who can run a job assume that role.

4. What the attacker wanted

Railway believes the goal was AI provider keys for resale. The report says the attacker used abliterated models, with what Wiz described to Railway as a harness similar to ARTEX, to move quickly. It also notes that other developer platforms (OpenCode, Warp and Fireworks AI) disclosed similar thefts between 6 and 23 October. Wiz’s “Black October” research documents the same pattern of stolen AI keys being validated and resold, but neither Railway nor Wiz attributes all of it to one operator.

IOCs

Railway says it is sharing IOCs privately with affected customers and law enforcement and will publish them once cleared. We haven’t seen any public network indicators, hashes or attacker IPs for this incident, so we’re not listing any. What customers can check is their own usage:

  • Requests to AI provider APIs from IPs or user agents that don’t match your workloads, starting 20 October 2026.
  • Spend spikes on Anthropic, OpenAI, OpenRouter, Gemini, Bedrock or SpaceXSI keys that were stored in Railway.
  • GitHub audit log entries for the Railway OAuth app or tokens created from it after 20 October.

Detection and remediation

# 1. Inventory every variable you stored in Railway (run per project/environment)
railway variables --json > railway-vars-$(date +%F).json
jq -r 'keys[]' railway-vars-*.json | sort -u

# 2. Prioritize keys that match what the attacker queried for
jq -r 'keys[]' railway-vars-*.json | rg -i 'openai|anthropic|claude|openrouter|gemini|google|bedrock|aws_|xai|spacex|stripe|database_url|postgres|mongo|redis'

# 3. GitHub: review OAuth app grants and audit log for the Railway app (org admins)
gh api /orgs/<org>/audit-log -X GET -f phrase='action:oauth_access created:>=2026-10-20' --paginate | jq '.[] | {action, actor, created_at}'
gh api /orgs/<org>/credential-authorizations --paginate | jq '.[] | {login, credential_type, authorized_credential_note, credential_accessed_at}'

# 4. AWS: look for API calls with access keys that were stored in Railway
aws cloudtrail lookup-events --lookup-attributes AttributeKey=AccessKeyId,AttributeValue=<AKIA...> \
  --start-time 2026-10-20T00:00:00Z --query 'Events[].{t:EventTime,n:EventName,ip:CloudTrailEvent}' --output text
  1. Rotate everything stored in Railway before 22 October 2026. That means AI keys, cloud keys, database passwords, payment keys (Stripe and others), webhook secrets and third-party API tokens. Do the build-time variables first, since those were in Temporal history.
  2. Revoke and reauthorize GitHub. Revoke the Railway OAuth grant and any GitHub app tokens, then reconnect. Check for deploy keys or webhooks you didn’t create.
  3. Report unauthorized spend. Railway says AWS and Google refund fraud through their account teams, OpenAI and SpaceXSI review cases through a shared bridge with Railway, and Railway is covering Anthropic and OpenRouter losses itself.
  4. Check your own pipelines for the same patterns. Look for builds sharing hosts with long-lived credentials on disk, workflow engines whose history holds secrets and accepts broad client identities, and OIDC trust policies without sub/aud conditions:
# AWS IAM roles trusting a CI OIDC provider without a sub condition
for r in $(aws iam list-roles --query 'Roles[].RoleName' --output text); do
  aws iam get-role --role-name "$r" --query 'Role.AssumeRolePolicyDocument' --output json \
  | jq -e --arg r "$r" '.Statement[] | select(.Principal.Federated? // "" | test("oidc|token.actions")) |
      select((.Condition // {} | tostring | test(":sub")) | not) | $r' 2>/dev/null
done

Timeline

  • 2026-10-18: The attacker starts creating accounts on Railway. Early probing fails.
  • 2026-10-20 06:50 UTC: Probing of build infrastructure begins.
  • 2026-10-20 07:28 UTC: Partial filesystem isolation escape; the build credential is read from the host.
  • 2026-10-20 13:50 to 15:30 UTC: 353 build histories are read through Temporal; the monorepo is retrieved from cache snapshots.
  • 2026-10-20 13:58 UTC: An alert on anomalous registry API calls pages Railway’s on-call engineer.
  • 2026-10-20 17:03 UTC: Railway halts builds. The credential is rotated at 17:28 and builds are re-enabled.
  • 2026-10-21 03:26 UTC: The attacker obtains a short-lived cloud credential through the misconfigured OIDC binding.
  • 2026-10-21 04:07 to 07:15 UTC: Encrypted variables are read from the production database and some are decrypted through KMS.
  • 2026-10-21 07:14 / 07:22 UTC: All cloud credentials disabled; builds halted for every customer.
  • 2026-10-21 09:24 to 09:25 UTC: Attacker evicted. Railway asks GitHub, GitLab, Anthropic, OpenAI, OpenRouter, SpaceXSI, Google and Stripe to revoke keys.
  • 2026-10-21 20:19 UTC: Every Railway user session and token is invalidated.
  • 2026-10-22 01:22 UTC: Remediation guides published. Builds return gradually, finishing at 22:49 UTC.
  • 2026-11-02: New signups reopen.
  • 2026-11-10: Railway publishes the full incident report (last updated 18:02 UTC). StepSecurity publishes its CI/CD analysis the same day.

References

From research to remediation

Check whether this pattern exists in your codebase

Turn this research into a remediation workflow. Scan dependencies and package manifests for similar supply-chain risk, then prioritize fixes with reachability context.

References