.jpg)
Fireworks AI Breach: How to Check Keys, Cursor and Notion AI
The Fireworks AI breach is two security incidents at Fireworks AI, a platform developers use to run and fine-tune open AI models. Fireworks disclosed them on October 9 and November 9, and Notion, Cursor and Uber have since said their own data was exposed through Fireworks. At Cursor, an attacker went on to use a credential taken from the exposed data to plant malicious copies of the Claude Code extension, which as many as 5,000 Cursor users may have received.
Prophet AI Threat Hunter has a hunt for those malicious Claude Code extension copies. A team can use it to check its endpoints for the backdoor the copies try to install, without writing a query.
After a breach at a vendor like this, leadership usually asks whether the organization was affected and how fast the team can tell. From what has been disclosed so far, the Fireworks AI breach can reach an organization by three routes, and only the first requires doing business with Fireworks. Those routes are keys and data an organization stored at Fireworks, its developers' Cursor installs and keys, and what its employees typed into Notion AI.
Alerts on an organization's own vendor account may not fire for access like this. Uber said it had alerts in place for unauthorized access to its Fireworks environment, but because the hackers used Fireworks' own internal credentials, “no alerts were triggered,” TechCrunch reported.
Answering leadership's question means checking each route where its evidence is kept: the logs of every provider that issued an exposed key, developers' endpoints, and the transcripts Notion makes available to affected workspaces. For the keys and the endpoints, each check is a directed threat hunt, which an AI threat hunting agent can run across connected sources.
Vendor risk programs, contract terms and advice for affected Uber drivers are out of scope. The method for hunting poisoned npm and PyPI packages is in our guide to supply chain attack detection.
{{ebook-cta}}
What happened in the Fireworks AI breach
Fireworks identified the first incident on October 6: unauthorized use of internal Fireworks credentials. An unauthorized third party accessed environment variables in evaluation jobs in a limited number of customer accounts. In some of those accounts, it captured API keys and tokens that customers had stored as secrets.
Fireworks began notifying affected customers on October 7. In its last update to the bulletin, on October 10, it said it had found no evidence of unauthorized access to customer models, datasets, training data, personal information or inference traffic within its security perimeter or control.
The November 9 update describes a second way in, which Fireworks lists as further activity in its October 2026 security incident. A third-party cloud provider that hosted Fireworks' research and development machines had a security incident on October 23. On October 24, an unauthorized third party used that provider to reach Fireworks development machines and run an unauthorized workload. Fireworks says it detected the activity the same day, and that the workload “led to additional customer data impact.”
The update lists what “the affected internal application provided access to”: resource metadata such as identifiers and display names, and billing information such as addresses, invoice and payment history, balances and credit usage. For a limited set of accounts, the update adds secrets, datasets and incomplete model weights.
Fireworks says it does not store payment card numbers. The update does not say which incident exposed which data.
Fireworks says it has not detected any impact on its inference service, Training SDK or Nexus, which run with zero data retention by default. As of October 25, the company has not detected further evidence of successful unauthorized access by the attacker on the platform its customers use.
Fireworks links the evidence to a financially motivated cybercriminal group that sells tokens obtained through unauthorized access to large language models, a practice known as LLMjacking. No group has been publicly named in the Fireworks AI hack.
Stolen model access is worth money because it can be resold. In a November 2 report that Fireworks cites, Google Threat Intelligence Group and Mandiant describe how that works. In several incidents it describes, attackers used stolen cloud credentials and API keys to switch on AI model services and run them at the victim's expense.
Operators of what the report calls LLM Mixers pool that stolen access and resell it to subscribers. In individual incidents, Mandiant saw fraudulent charges above $100,000 in a single day, and cumulative charges reached $1 million at some organizations before access was revoked.
Which companies have confirmed exposure through Fireworks
Notion published its advisory on November 12. The exposed dataset at Fireworks held Notion AI chat transcripts used for Notion's Insights feature, from fewer than 1% of Notion workspaces, and Notion contacted affected customers on November 9. For most affected workspaces, Notion says, nothing beyond what is in a transcript itself ties it to a specific user, company or workspace.
Notion disconnected from Fireworks, deleted its data there and turned off Insights while it investigates.
The Cursor breach started with an access key Cursor had issued to Fireworks. In its November 13 update, Cursor says Fireworks exposed that key, and an attacker used it to copy data from a read-only storage bucket Cursor used to share data with Fireworks. The bucket held limited coding-agent traces, mostly from 2025, from sessions not using Privacy Mode.
Some traces held credentials that had not been redacted, and Cursor says fewer than 0.01% of customers had API credentials exposed. Starting with those credentials, the attacker reached some SaaS tools Cursor uses and accessed archived non-production source code, some customer support data and email, and some credentials users had sent to Cursor support. The attacker also accessed product usage metrics, contact details and summaries of some coding agent conversations.
On October 29, the attacker placed malicious copies of Anthropic's Claude Code extension on the cache that serves Cursor's VS Code extension marketplace. Cursor says the attacker did it “using a stolen credential from the exposed data from our internal system.” Anthropic did not publish those copies, Cursor adds, and Open VSX, the marketplace's source, never had the malware.
As many as 5,000 users who requested the affected versions that day may have received the malicious build, which stayed up for about 11 hours. Cursor says the last attacker activity it saw was on November 1, and that it was blocked.
Uber confirmed to TechCrunch on November 16 that notices it sent drivers relate to Fireworks, and it has filed breach notices with several state attorneys general. Its Oregon filing says it notified 149,346 people, and the stolen data includes names, addresses, dates of birth and driver's license numbers. Uber says Fireworks told it on October 9 that hackers had broken in and stolen internal credentials, which were then used to access Uber's data.
Neither Notion nor Cursor says which Fireworks incident exposed its data. Fireworks says it is notifying the customers whose data was affected, so more companies may yet disclose exposure from the Fireworks AI breach.
How to check credentials you stored at or issued to Fireworks
This check is for Fireworks customers, and the same steps apply to any AI vendor that holds your keys. Start with a list of what Fireworks held: secrets you stored there, including those your evaluation jobs used, and any keys you issued Fireworks to reach your storage or services, as Cursor did. Fireworks says it can give notified customers secret names and credential fingerprints through a secure channel.
Rotate each credential with the provider that issued it. Fireworks warns that “removing a stored secret alone does not invalidate the underlying credential,” and asks customers to rotate the identified credentials even if they find no suspicious activity.
A long-lived key stays valid until its issuer revokes it or it expires. A short-lived token runs out on its own, though it may have been used to create longer-lived credentials first. In AWS, rotating an access key leaves temporary credentials obtained with it valid for up to 36 hours, unless you revoke them, for example with a deny policy conditioned on aws:TokenIssueTime.
Then search each issuer's records for the key's use. Fireworks identified the activity on October 6 but has not said when the unauthorized use began, so search as far back as your retention allows rather than starting on that date:
- AWS: CloudTrail events where
userIdentity.accessKeyIdmatches the exposed key ID, searched across all Regions. Temporary credentials that the key obtained through STS calls, such asGetSessionToken,GetFederationTokenorAssumeRole, sign later calls with their own key IDs. Take those IDs fromresponseElements.credentials.accessKeyIdin the STS events and search for them too. Bedrock API keys are bearer tokens whose value CloudTrail does not record, so search for a long-term key's calls under the IAM user it belongs to. - Google Cloud: Cloud Audit Logs entries where
protoPayload.authenticationInfo.serviceAccountKeyNamenames the exposed service account key. Search every project the account could reach, or an organization-level aggregated sink's destination, since audit logs such as Data Access logs are written to the project whose data was read. - Azure: service principal sign-ins for the app whose secret was exposed (the
AADServicePrincipalSignInLogstable in Log Analytics, filtered on that secret'sServicePrincipalCredentialKeyId), then that service principal's activity in the Azure Activity Log and, where it called Microsoft Graph, inMicrosoftGraphActivityLogs. - Other model providers and SaaS APIs: the provider's usage, billing or audit views, broken out by key where the provider offers that.
Flag source addresses, user agents and actions that don't match the key's normal callers. Access you granted Fireworks without a key, such as an IAM role trust or federated credential for its Bring Your Own Bucket datasets, stays active until you remove it. Search its use the same way, and flag any outside the jobs you ran.
Because Fireworks ties the evidence to an LLMjacking group, check AI model services closely. In accounts that already use Bedrock, Gemini Enterprise Agent Platform (formerly Vertex AI) or Azure OpenAI, inference calls are routine, so filter the inference searches below to the exposed keys and any credentials they created. Azure OpenAI's request and token metrics have no key or caller dimension, so compare them with each resource's normal volume instead. Google's report lists events worth searching:
- AWS: Bedrock calls in CloudTrail such as
InvokeModelandConverse, and model access requests such asPutUseCaseForModelAccess. Inference through Bedrock'sbedrock-mantleendpoint, which accepts OpenAI and Anthropic SDK calls, is logged instead asCreateInferencedata events frombedrock-mantle.amazonaws.com, which CloudTrail records only where data events were enabled. - Google Cloud:
google.api.serviceusage.v1.ServiceUsage.EnableServicecalls that switch on Vertex AI or the Gemini API (generativelanguage.googleapis.com), and inference calls such asgoogle.cloud.aiplatform.v1.PredictionService.GenerateContent. - Azure:
Microsoft.CognitiveServices/accounts/deployments/writein the Activity Log for new or changed deployments. Inference calls to an existing deployment are not recorded there: check the resource's request and token metrics, which Azure collects by default, and its diagnostic logs where those were enabled.
The report also flags tiny validation requests in gateway and API logs, such as calls with max_tokens=1, that attackers send to test a stolen key. CloudTrail's InvokeModel entries record the model ID but not the request body, and Bedrock model invocation logging, which records the full request, is off by default. The report also names operations that check whether model calls are logged or turn that logging off, such as GetModelInvocationLoggingConfiguration and DeleteModelInvocationLoggingConfiguration on AWS and Microsoft.Insights/diagnosticSettings/delete on Azure.
Some of this evidence exists only if logging was on before the breach. Bulk object reads by an exposed key can be a sign of data exfiltration, though they are often routine for a key you issued so a vendor could read your data, as Cursor did. CloudTrail records S3 object reads only where data events were enabled, and Azure Storage records reads only where its read logging was turned on.
Google Cloud's Data Access audit logs, which cover reads of stored data and Vertex AI inference calls, are off by default except for BigQuery. In Azure, Entra ID keeps sign-in logs for 30 days at most, and the AADServicePrincipalSignInLogs and MicrosoftGraphActivityLogs tables hold only what a diagnostic setting was already sending to Log Analytics. Where logging was off, say so in the findings instead of reporting the key as clean.
In the Fireworks account, replace any Fireworks API keys that Fireworks revoked, and review API keys, users, evaluators, training jobs and datasets for anything you don't recognize. Fireworks asks customers to send it the names or IDs of anything unfamiliar. Enterprise accounts can also pull their audit logs, including data access, with firectl audit-logs list, setting --start explicitly because the default window is the last 30 days.
Check model usage and spend in the account as well, because LLMjacking runs up charges on the account whose keys were taken. If Fireworks held your datasets or model weights, its notice to affected customers describes the impact and the steps it recommends. Billing addresses and invoice history were in the exposed data, so tell whoever pays the Fireworks bill to watch for invoice-themed phishing.
How to check Cursor installs for the malicious Claude Code extension copies
Cursor's exposure calls for two checks: one for keys that were exposed, and one for endpoints that may have installed the malicious extension copies.
If Cursor emailed your team admins a list of keys to rotate, rotate them, then search each issuer's records for their use the same way as for Fireworks keys. Cursor also notified affected users directly, so ask developers whether they received a notice; on a personal Cursor account, theirs may be the only notice that company keys sat in exposed traces. Cursor has not said when the bucket was copied, so search as far back as retention allows here too. Rotate any credential your users sent to Cursor support as well, since Cursor says the attacker accessed some of those.
The endpoint check applies to anyone who installed or updated Anthropic.claude-code to version 2.1.312 or 2.1.313 from Cursor's marketplace on October 29, between about 2:27 a.m. and 1:35 p.m. PT. Cursor lists modified packages for macOS on Apple silicon and for 64-bit Windows. Find those machines with extension-installation telemetry, as Cursor advises, rather than by the version installed now, since the payload installs persistence that keeps running after the malicious version is gone.
Cursor's security notice says the payload reports host and user details to the attacker, including the hostname, username, environment variable names and public IP address. It also tries to add an attacker SSH key to authorized_keys, turn on the local SSH service and open a reverse SSH tunnel. It then tries to keep the tunnel running through a LaunchAgent on macOS or, on Windows, a scheduled task with a Startup-folder script as the fallback.
Turning on SSH needs admin rights, which the extension lacks on most Macs and Windows machines, so Cursor expects that step to fail on most hosts. The exception Cursor names is the highly unusual case where Cursor itself was started with administrator privileges. Where the step failed, Cursor says the attacker could not have logged in through the tunnel, but the key and persistence were still installed, so remediate those hosts too.
Check whether each affected host was running an SSH server, whoever turned it on: Remote Login on macOS, the sshd service on Windows. Where one was, search its logs since October 29 for a login with the attacker key's fingerprint, listed below, which OpenSSH records by default. On a Mac, that entry is an info-level unified log message, which macOS normally keeps only in memory, so an empty search there does not rule out a login. On Macs, also check EDR telemetry for a process the SSH server started.
Cursor's notice lists indicators for each platform, including these (addresses defanged):
- An SSH key with the fingerprint
SHA256:0Z6R+DF64Do2nwQic8a7kkfDLNNk4IiK+2U2Rci4htkor the commentsvc-telemetryin~/.ssh/authorized_keys, or on Windows in%USERPROFILE%\.ssh\authorized_keysorC:\ProgramData\ssh\administrators_authorized_keys - On macOS, the LaunchAgent
~/Library/LaunchAgents/com.apple.sysmond.plist(labelcom.apple.sysmond) and the files~/.config/.smt,~/.config/.smtkand$TMPDIR/.stk_<10 hex>. macOS ships its ownsysmondsystem monitor daemon, so match on the plist's path under the user's~/Library/LaunchAgentsrather than on the name or label alone. - On Windows, a scheduled task named
SysMonthat attempts to run as SYSTEM, a Startup fallback at%APPDATA%\Microsoft\Windows\Start Menu\Programs\Startup\sysmon.cmd, and the files%USERPROFILE%\.config\smt.cmd,%USERPROFILE%\.config\smtkand%TEMP%\.stk_<10 hex> - Reverse SSH to
tunnel@134[.]209[.]82[.]225on TCP 22, and a beacon sent by HTTP POST tohxxp://134[.]209[.]82[.]225:8099/beacon - SHA-256 of the payload file
extension.js:ecb58cb29078d9646ad1dcdbe51526f2d9cfea06be5fb2ab183e8ecc3ab6bf15 - SHA-256 of the 2.1.312 package for macOS on Apple silicon:
fcbb327e38e61c4fec795e0d0591f52cd1014b813d20a5912104953c3a17c364 - SHA-256 of the 2.1.312 package for Windows x64:
3de1722901165769893bef57c72594e9a54459faa23f3091b136b79966edd081 - SHA-256 of the 2.1.313 package for macOS on Apple silicon:
80402fdcad8799285fd93044976973ca000da7995fb93363f819bb8e4f84ee6c - SHA-256 of the 2.1.313 package for Windows x64:
6786ec90cbd45949695bd7805c9fbb26cfc91bc5fc897de0183d9bcb9cb21731
Cursor's own check looks for the svc-telemetry key. It reads authorized_keys in the home directory of whoever runs it, so run it as each user who ran Cursor. From a management tool that runs as root or SYSTEM, point it at every user's home directory. On macOS:
grep -qs svc-telemetry ~/.ssh/authorized_keys && echo "svc-telemetry key found" || echo "No key found; machine not impacted"
On Windows, in PowerShell opened with Run as Administrator when the user has local admin rights, since administrators_authorized_keys is normally readable only by administrators and SYSTEM:
$files = "$HOME\.ssh\authorized_keys", "C:\ProgramData\ssh\administrators_authorized_keys" | Where-Object { Test-Path $_ }if ($files -and (Select-String svc-telemetry $files)) { "svc-telemetry key found" } else { "No key found; machine not impacted" }
That check looks only for the key, so pair it with endpoint searches. Microsoft Defender for Endpoint usually leaves the SHA256 column empty in DeviceFileEvents, so an empty SHA-256 search there does not clear a host; search the MD5 hashes Cursor's notice also lists. In your EDR, search for writes to the files above and for these command lines from Cursor's indicator list:
ssh -N -R '*:0:localhost:22'andautossh -M 0, searched as fragments such as*:0:localhost:22, since a recorded command line may lack the quotes and carry other options in betweenschtasks /create /tn SysMonon Windowssystemsetup -setremotelogin onon macOSAdd-WindowsCapability -Online -Name OpenSSH.Server~~~~0.0.1.0on Windows
Connections from an endpoint to 134[.]209[.]82[.]225 on port 22 or 8099 around October 29 are strong evidence on their own. Cursor says the attacker's server has since been taken offline, and hosting addresses can be reassigned, so weigh a single later connection with that in mind. Repeated attempts on port 22 about every 60 seconds match the payload's tunnel retries and point to persistence that is still running.
The payload also looks up the host's public IP through ifconfig.me or api.ipify.org, which Cursor notes are legitimate services, so a lookup alone is not an indicator. Admins also turn on SSH with the systemsetup and Add-WindowsCapability commands above and add keys to authorized_keys, so confirm such a hit against other indicators on the host. If an EDR alert fires on any of these, the usual steps for investigating EDR alerts apply.
How to check what went into Notion AI and other SaaS AI features
If your workspace received Notion's notice, follow the instructions in Notion's email to retrieve the affected transcripts securely inside your workspace, and treat everything in them as exposed. Rotate any password, API key or other credential that appears in them, then search the logs of the service it belongs to for its use, as with the Fireworks keys.
Notion has revoked exposed Notion API keys it found in affected messages and reported exposed third-party keys to the vendors that issued them. An issuer that gets a report may not revoke the key, so rotate those yourself. Notion says it will contact any workspace it later finds was affected.
The broader check is an inventory of which SaaS tools send your data to which model providers. Vendors' subprocessor lists and the admin settings for their AI features are the places to start. Finding the AI features and connections nobody approved is part of shadow AI detection.
For each provider, ask which features store your data. Fireworks says its open-model inference runs with zero data retention by default, but a few features store content by design, such as batch jobs and training. Notion's exposed transcripts were in a dataset stored at Fireworks.
What to do if a check finds a hit
For a misused key, revoke and rotate it at the issuer, then work out what the key could reach and search those services for the same activity. Look for credentials created while the key worked: Google's report describes attackers creating IAM users, service accounts and new access keys, and using federation tokens to mint fresh keys. The report also describes attackers attaching administrative policies to service roles, injecting SSH keys into compute instances and pulling secrets from secret managers; rotate any secret the key could read.
For a host with the backdoor, isolate it and preserve its logs before cleanup. Cursor's remediation scripts remove the malicious extension, the key, the persistence and the tunnel: run remediate-macos.sh as the affected user rather than root, and remediate-windows.ps1 from PowerShell opened with Run as Administrator. Both exit with a non-zero status if anything remains, but they remove only what Cursor lists, so rebuild any host where someone logged in with the attacker's key. Uninstalling the extension alone may not be enough, because the payload drops standalone persistence scripts, and Cursor suggests considering a rebuild.
Then, from a trusted system, rotate the credentials and sessions reachable from the host, such as SSH keys, cloud CLI and Git credentials, and API keys held in environment variables. Cursor notes that the payload's limited collection “does not rule out later credential access over the backdoor.” Where someone logged in with the attacker's key, scope that session from EDR telemetry and the preserved logs: the commands it ran, and the files and credential stores it read where file access was logged. Then search each issuer's records for use of credentials from the host since that session. A stolen session token can often be replayed until it expires or is revoked, which is how session hijacking gets around MFA.
Google, Fireworks and Cursor each point to changes that limit what a breach like this can expose, even if every check comes back clean. Google's report recommends scoping model API keys by model, environment and usage limits, setting budget alerts and spending caps on LLM services, and keeping secrets in a manager that rotates them automatically. Fireworks lets enterprise admins turn on a zero data retention policy that rejects training jobs and dataset uploads, and Cursor says prompts and code from users in Privacy Mode were not affected.
How Prophet AI runs these checks
Prophet AI Threat Hunter turns an indicator list or a plain-language question into a hunt across the data sources a team has connected, with no query language to learn. A question can be as direct as whether any endpoint ran the malicious extension copies tied to the Fireworks AI breach. For emerging threats like this one and others as they come up, expert-curated emerging-threat hunts land in the hunt library, ready to run or schedule.
Suspicious leads go to Prophet AI SOC Analyst for a full investigation, which returns a determination with every query and piece of evidence behind it. When an investigation confirms a threat, Prophet AI Threat Hunter scopes it, showing when the attack started as well as how far it reached. Its block-user response action also revokes the sessions and refresh tokens already issued to the blocked user.
Validated findings become detection opportunities for Prophet AI Detection Engineer, the loop described in our post on detection engineering in an AI-driven SOC. To run these checks without writing the queries by hand, see how Prophet AI Threat Hunter handles emerging threats.
The Fireworks AI breach is two security incidents at Fireworks AI, a platform for running and fine-tuning open AI models. On October 6, Fireworks identified unauthorized use of internal credentials that exposed secrets stored in some customers' evaluation jobs. On October 24, an attacker reached Fireworks development machines through a third-party cloud provider. Fireworks says its investigation found impact to billing information and, for a limited set of accounts, secrets, datasets and incomplete model weights.
Notion, Cursor and Uber have each said their data was exposed through Fireworks. Notion reported exposed Notion AI chat transcripts from fewer than 1% of its workspaces. Cursor reported an exposed access key, copied coding-agent traces and a follow-on attack that placed malicious copies of the Claude Code extension in its marketplace cache. Uber notified 149,346 people, according to its Oregon filing. Fireworks says it is notifying affected customers directly.
Cursor says its breach began with an access key it had issued to Fireworks, which Fireworks exposed. An attacker used the key to copy coding-agent traces from a storage bucket Cursor shared with Fireworks. The attacker then worked from credentials in that data to reach Cursor's SaaS tools and plant malicious copies of the Claude Code extension on October 29. Cursor does not say which Fireworks incident exposed the key.
No. Fireworks says removing a stored secret alone does not invalidate the underlying credential. A long-lived key stays valid until the provider that issued it revokes it or it expires, so rotate each exposed credential with its issuer and review that issuer's logs for its use. Fireworks asks customers to rotate the identified credentials even if they find no suspicious activity.
Start with machines that installed or updated Anthropic.claude-code to version 2.1.312 or 2.1.313 from Cursor's marketplace on October 29. Look for an SSH key with the comment svc-telemetry in authorized_keys, a com.apple.sysmond.plist file in a macOS user's LaunchAgents folder, a Windows scheduled task named SysMon or its Startup-folder fallback, sysmon.cmd, and connections to the attacker address Cursor published on ports 22 and 8099. Cursor's notice includes check commands and remediation scripts.
A poisoned npm or PyPI package runs on the machines and build systems that install it. The Fireworks AI breach hit a vendor that held customers' keys and data, so exposure depends on what each organization stored there or sent there through tools like Notion and Cursor. The malicious extension copies in Cursor's marketplace cache worked more like a package attack, reaching the machines that installed them.
Insights
Definitive Guide to Detection Engineering
Where detection engineering falls short, how to close those gaps, and what it looks like in an AI-enabled SOC.



.avif)
