LLMJacking Can Drive Enterprise AI API Costs Above $1 Million in Hours

Nov 02, 2026 607 views

LLMJacking can turn stolen model access into a seven-figure bill

The striking feature of LLMJacking is how quickly its costs can land. In incidents Mandiant investigated in 2026, attackers hijacked enterprise access to large language models across several cloud and model providers. The affected organizations spanned North and South America and Asia Pacific, and worked in financial services, retail, technology, and transportation. In some cases, unauthorized usage topped $100,000 in a day; at some organizations, charges reached $1 million before access was cut off.

That pace sets LLMJacking apart from cryptojacking, where costs typically build through sustained resource use. Here, a burst of API activity can create a huge bill in hours. Figure 1 captures the pattern: a sharp spike in API requests.

Usage chart showing LLMJacking generating a spike in API requests
Figure 1: Usage chart showing LLMJacking generating a spike in API requests

Google Threat Intelligence Group (GTIG) says the activity sits within a growing underground market for LLM credentials, building on its previous reporting. The ecosystem has begun to divide into specialists: some attackers break into organizations, while others run “LLM Mixers”—illicit gateways that pool, route, and resell unauthorized model access. In one investigation, GTIG saw two distinct groups coordinate the compromise and monetization of enterprise LLM infrastructure. That division of labor suggests the market is becoming more organized.

The report traces the attack lifecycle, from initial access through monetization, and offers detection, hardening, and remediation guidance. The authors are Christopher Romano, Codi Starks, Garrett Mahoney, John Wolfram, Josh Murchie, K Singh, Mathew Potaczek, Mike Lombardi, and Rik Dolfing.

Initial access starts with identities and exposed services

LLMJacking targets backend model resources directly. Attackers look for publicly exposed LLM endpoints or valid API keys, bypassing front-end interfaces such as customer support chatbots that have been manipulated for unauthorized tasks like code generation. A public endpoint can let an attacker run their own models on someone else’s infrastructure—and leave the organization paying the hosting costs.

Figure 1 shows one example of automated testing: an attacker calls the /api/create endpoint to check whether a publicly accessible service will accept requests and let them register models. Figure 2 shows attempts to find exposed Ollama endpoints.

Threat Actor tests publicly exposed Ollama endpoints and attempts to register their own models
Figure 2: Threat Actor tests publicly exposed Ollama endpoints and attempts to register their own models

More often, investigators found attackers using exposed or stolen cloud identity tokens: IAM credentials, Service Account keys, GitHub Personal Access Tokens (PATs), and active session tokens. In mid-2026, UNC6993 entered a cloud instance through a misconfigured Service Account key, then used that foothold to obtain access to an LLM API. The group also set up a fake application portal to steal active session tokens. It directed users to the legitimate LLM website and asked them to paste a raw JSON payload containing the token; the backend then used it to bypass passwords and multifactor authentication (MFA).

Other routes combined stolen code credentials with weaknesses in cloud applications. One attacker used a stolen PAT to reach private code repositories and exploited a suspected vulnerability in a package running inside a containerized cloud environment. Another used compromised corporate IAM credentials and cloud federation tokens to generate fresh access keys, sidestepping MFA. In a separate case, a compromised Service Account key had broad project permissions.

Attackers also searched public GitHub repositories for corporate LLM API keys. One group validated stolen keys with minimal requests, setting max_tokens=1 to keep activity low enough to evade endpoint detection and response (EDR) and SIEM volume anomaly alerts. The data does not explain how reliably that approach evades monitoring, but it shows why small test requests deserve scrutiny.

From a foothold to lasting control

After getting in, attackers looked for more credentials and ways to expand their access. They mapped cloud services, identity policies, code repositories, and data stores across regions. In a containerized environment, one actor cloned sensitive repositories to search for hardcoded secrets, configuration variables, and developer credentials, then reviewed access logs for credentials to other cloud environments. Attackers also queried cloud data warehouse metadata for database credentials, administrator passwords, and sensitive columns, alongside object storage activity associated with targeted data theft.

Cloud permissions and virtual machine settings gave attackers several paths to persistence. One used a compromised workload’s service account to create temporary credentials for high-privilege service accounts, then took infrastructure credentials, internal database passwords, and third-party API keys from cloud secret managers. Others created unauthorized IAM or service accounts and inserted SSH keys into compute instances. One actor attached administrative policies to service roles, created IAM accounts with full administrative rights, and opened interactive management sessions to add SSH keys to host configuration files. Another disguised backdoor service accounts as internal billing optimization utilities and placed environment-wide SSH keys in compute instance metadata.

Attackers also went after LLM routing software itself. In one case, a follow-on group used pre-validated Virtual Keys obtained from the initial-access group, then exploited a user ID rebind flaw in LiteLLM’s /key/regenerate endpoint, CVE-2026-40217. The flaw let the group turn standard Virtual Keys into PROXY_ADMIN master credentials, giving it deep and persistent control of the environment.

Turning stolen access into a business

The goal is to monetize model access and computing resources. Attackers generated tokens through proxies, streamed requests automatically, and provisioned GPU hardware. UNC6993 tried to create additional API keys and enable services in victim cloud projects; the resulting charges passed $100,000. Another attacker put victim accounts on Pay-As-You-Go plans, selected premium models, and ran high-volume inference. To get around rate limits, it repeatedly created and deleted short-lived service accounts—a “burn and rotate” approach—while checking the cloud billing interface.

Some groups built services around the stolen access. One enabled agents, exposed reverse proxies, and used custom Node.js proxy bundles to offer access to multiple frontier models under the name D1337-KAIROS. It deployed a containerized backdoor using the Manus agent framework. The backdoor sent instructions to an upstream LLM, then ran the resulting commands locally, with SearXNG metasearch and agent-infra/sandbox execution environments. The operator also sought powerful GPUs across multiple regions, requested quota increases through the cloud provider’s API, and hosted LiteLLM gateways on external servers to route traffic.

GTIG also saw attackers sell access through LLM Mixers. These services use open-source gateways and custom relays to pool credentials, meter requests, and hide where traffic originates. UNC6993 used new-api, a centralized model hub and gateway, and gcli2api, which converts command-line interface (CLI) tools into standard frontier-model endpoints. GTIG assesses that UNC6993 likely used them to combine stolen keys, balance requests across accounts, and sell access through underground storefronts.

One routing service, jet-night.com, made more than 500,000 LLM API calls in under eight hours using stolen third-party keys. The service passed nearly $1 million in token costs to its victim. GTIG believes stolen keys help explain Jet Night’s low prices: it advertised an unlimited plan for about $60 a month with access to frontier models, while comparable consumer service would typically cost $100 to $250 monthly. Its public Telegram channel has also announced outages, which GTIG says likely followed victims discovering the compromises and revoking keys.

Screenshot of Jet Night Plans and Pricing Structure
Figure 3: Screenshot of Jet Night Plans and Pricing Structure

In another case, an attacker ran custom ai-relay proxy infrastructure on deceptive lookalike domains, including one registered to resemble the victim’s legitimate internal host. The relays fed commercial LLM access into the newapi[.]pro resale network, drawing directly on the victim’s corporate quotas.

What defenders should watch

GTIG expects LLMJacking to attract more attackers than traditional resource theft such as cryptojacking, because underground mixers offer a fast route to revenue. As organizations put premium models and agentic workflows into production, attackers are likely to automate searches for exposed tokens and target flaws in model-routing software. The risk is straightforward: enterprise quotas can be drained before defenders recognize the compromise.

That makes changes to cloud LLM accounts and services an early warning worth treating seriously. Mandiant found incidents where LLM services were disabled before the compromise; attackers used stolen keys to enable services such as Bedrock or the Gemini API, then generated large bills within minutes or hours. Unauthorized enablement should trigger investigation.

Google Security Operations customers can find related rules in the Cloud Threats, Mandiant Frontline Threats, and Mandiant Hunting Rules rule packs. The listed rule name is AWS Account Key Creation.

What to watch for—and how to reduce the risk

The activity described here leaves useful clues in cloud and host logs: AWS key creation and user account creation or deletion; base64 encoded shell command execution; firewall creation or deletion in the default network; GCE project SSH key changes; GCP service account key creation and new service account creation; GCP firewall rule creation; Linux archive exfiltration using curl or wget; and persistence through Compute instance or project metadata startup scripts or URLs. These events can help defenders spot attempts to turn cloud access into lasting control or use it to move data. The practical lesson is that LLM services inherit familiar cloud security problems. IAM and software supply chain controls deserve early attention because both can give attackers a route into cloud environments or let them abuse access once they have it.

Reduce opportunities for abuse

Start with credentials and permissions. Keep keys and secrets in a centralized secrets management platform, and automate rotation to shorten the useful life of leaked credentials. Give users and service accounts only the permissions their roles require; explicitly deny unnecessary access, including access to cloud LLM services. Scan repositories such as GitHub and GitLab for exposed secrets so API keys can be found and removed quickly. Then look for exposure and unexpected usage. Audit cloud configurations regularly for unintended endpoints and attack paths. Use a web application firewall such as Google Cloud Armor to rate limit individual client connections, and restrict outbound traffic from cloud services to known IP addresses with VPC firewall rules where feasible. Set granular API quotas by model and spending caps to limit request volume and cost. Some controls need to account for how attackers test access. Enforce phishing-resistant MFA across cloud identity providers, management consoles, and developer platforms; this makes stolen credentials or session tokens harder to exploit. Use security posture management tools to find unauthorized or unmonitored models, tools, and infrastructure across hybrid cloud environments. Scope API keys to specific model endpoints and environments, such as development or production, and set usage limits so a token for a basic utility model cannot invoke a more expensive, high-tier model. Watch for small signals as well as large bills. Low-volume requests such as `max_tokens=1` or zero-temperature pings can be used to validate credentials before an attacker ramps up infrastructure abuse. Monitor model gateway and API logs for these patterns. Scan application code, containers, and machine learning dependencies—including PyTorch and Hugging Face libraries—with SAST, DAST, and SCA tools to catch vulnerabilities that could provide initial access. The model serving stack itself needs attention. Patch centralized model proxy and routing gateways such as LiteLLM quickly, including against privilege escalation and authentication bypass flaws such as CVE-2026-40217. If an LLM application runs generated code or database queries dynamically, isolate that work in highly virtualized, process-isolated serverless sandboxes. Limit model downloads and pipeline dependencies to trusted internal registries or approved enterprise catalogs, since compromised models can contain preconfigured backdoors. Graph-based risk prioritization can map cloud assets, application code, and data flows to surface multi-step attack paths; automated offensive agents can continuously probe external attack surfaces, exposed endpoints, and credential validation patterns.

Monitor native cloud audit logs

Cloud audit records can show both model use and the steps around it: discovery, configuration changes, and attempts to conceal activity. Coverage depends on the provider, and in some cases the relevant logs are off by default. For AWS, inspect CloudTrail events from `bedrock.amazonaws.com`. Track direct model calls through `Converse`, `InvokeModel`, and `InvokeModelWithResponseStream`. Spikes in `ThrottlingException`, `ValidationException`, or `ResourceNotFoundException` may indicate automated spraying against cloud infrastructure. Watch for model discovery through `ListFoundationModels`, `ListInferenceProfiles`, and `GetFoundationModelAvailability`, as well as attempts to unlock models with `PutUseCaseForModelAccess` or `CreateFoundationModelAgreement`. Logging changes deserve particular scrutiny. Review `GetModelInvocationLoggingConfiguration`, `PutModelInvocationLoggingConfiguration`, and `DeleteModelInvocationLoggingConfiguration` for attempts to inspect, change, or disable logging that could expose prompt contents or evade detection. Treat logging disablement by principals outside infrastructure as code workflows as high severity. User-Agent strings can also help identify automated tools and SDKs, including `claude-cli`, `aws-sdk-rust`, and `aws-sdk-go-v2`, connecting directly to the target infrastructure. For Azure, use Activity Logs for the control plane and Diagnostic Logs for the data plane, focusing on the `Microsoft.CognitiveServices` namespace. Model invocations happen on the data plane, so Diagnostic Logs must be enabled; look for high volumes of POST requests to inference endpoints such as Completions and Chat Completions. On the management plane, watch for unauthorized instance creation through `Microsoft.CognitiveServices/accounts/deployments/write`. Reconnaissance may appear in `Microsoft.CognitiveServices/accounts/read` and `Microsoft.CognitiveServices/accounts/deployments/read`. Check `Microsoft.Insights/diagnosticSettings/read`, `Microsoft.Insights/diagnosticSettings/write`, and `Microsoft.Insights/diagnosticSettings/delete` for attempts to inspect or alter whether data plane invocations are recorded. For GCP, monitor Cloud Audit Logging for Gemini Enterprise Agent Platform calls to `aiplatform.googleapis.com`. Inference events are recorded in Data Access logs, which are disabled by default because of volume and ingestion costs; IAM audit policies must be configured manually to capture them. Alert when services are enabled through the service usage audit logging method `google.api.serviceusage.v1.ServiceUsage.EnableService`. With Data Access logging enabled, monitor model execution through `google.cloud.aiplatform.v1.PredictionService.Predict`, `google.cloud.aiplatform.v1.PredictionService.GenerateContent`, and `google.cloud.aiplatform.v1.PredictionService.StreamGenerateContent`. Look for model and endpoint discovery through `google.cloud.aiplatform.v1.ModelService.ListModels`, `google.cloud.aiplatform.v1.EndpointService.ListEndpoints`, and `google.cloud.aiplatform.v1.PublisherModelService.ListPublisherModels`.

Watch for signs of log tampering

An attacker checking whether activity will be visible may leave clues in cloud audit logs. Investigate calls to google.iam.v1.IAMPolicy.GetIamPolicy, which can reveal whether Data Access logs are enabled for a project or resource. Requests to google.logging.v2.ConfigServiceV2.ListSinks or google.logging.v2.ConfigServiceV2.GetSink may indicate someone is inspecting log exports. These calls can have legitimate uses, so their context matters.

Indicators for threat hunting

The post provides indicators of compromise in a GTI Collection available to registered users. The listed network indicators are both described as LLM Mixers: | Indicator | Description | |---|---| | jet-night.com | LLM Mixer | | newapi.pro | LLM Mixer | Treat these domains as leads for investigation, alongside the audit activity above; the fragment provides no further detail about how they were used.
Source: Google Threat Intelligence Group · cloud.google.com

Comments

Sign in to comment.
No comments yet. Be the first to comment.

Related Articles

The Rise of LLMJacking: How Threat Actors Monetize Compro...