Exploiting Autoregressive Generation for Resource Exhaustion

48 concepts30 papers1 proposal

Traditional adversarial attacks focus primarily on accuracy—tricking a model into misclassifying an image, leaking sensitive data, or generating toxic text. However, a parallel class of vulnerabilities targets a model's efficiency.

In autoregressive architectures—such as Large Language Models (LLMs), Vision-Language Models (VLMs), and speech synthesizers—the computational cost of an inference pass is not fixed. Instead, it scales linearly with the number of tokens generated. Because these models generate text sequentially, token by token, they rely on an internal stopping mechanism to halt execution. If an attacker can disrupt this mechanism, they can force the model to execute maximum-length generation cycles, transforming a standard query into a devastating resource exhaustion attack.

The Core Mechanism: Suppressing the Termination Signal

To understand how an attacker forces a model to generate endless output, we must look at the probability distribution of the final layer. At each step of autoregressive generation, the model calculates the probability of the next token, including a special End-of-Sentence (EOS) or termination token. When the EOS token becomes the most probable choice (or passes a sampling threshold), generation stops.

By applying carefully optimized perturbations or adversarial prompts, attackers can systematically minimize the probability of this EOS token. Without a clear signal to stop, the model continues to sample other tokens, falling into a state of continuous generation until it hits a hard-coded maximum sequence length limit.

This vulnerability spans multiple modalities:

Weaponizing Test-Time Compute: Induced Overthinking

As the AI landscape shifts toward Large Reasoning Models (LRMs) that utilize test-time compute (such as internal Chain-of-Thought reasoning), the attack surface has evolved. Attackers no longer need to force the model to emit a massive visible response; instead, they can exploit the model's internal reasoning loops.

By fracturing the logical structure of a prompt or appending adversarial suffixes, an attacker can trick a reasoning model into entering recursive or redundant thought processes. The model "overthinks" a trivial question, generating thousands of internal tokens before finally outputting a short, correct answer.

Standard Prompt: "Is 2 prime?" ──> [Reasoning: 2 has only 1 and itself as divisors.] ──> "Yes" (Low Compute)

Adversarial Prompt: "Is 2 prime? [Suffix]" ──> [Reasoning Loop: Check 1... Check 2... Re-verify... Loop 26x...] ──> "Yes" (High Compute)

This creates a highly evasive "Silent Denial-of-Service." As Shuaitong Liu et al. noted, because the final answers remain accurate and safe, these efficiency-draining behaviors easily bypass traditional accuracy-based and safety-focused benchmarks (BadThink: Triggered Overthinking Attacks on Chain-of-Thought Reasoning in Large Language Models).

From Prompt Exploits to Hardware-Level Attacks

While most efficiency attacks rely on transient, prompt-level manipulations, vulnerabilities can also be baked directly into the model's parameters. Prompt-based attacks require the attacker to continuously send malicious inputs and often bear the cost of the generated tokens. To circumvent this, parameter-level attacks alter the underlying hardware or weights to make the resource drain permanent.

The mechanism shifts from manipulating inputs to permanently altering the model's probability distribution at the hardware level. Xiaobei Yan et al. introduced BitHydra, a hardware-level attack that flips as few as 1 to 4 bits in a model's weights (BitHydra: Towards Bit-flip Inference Cost Attack against Large Language Models). By specifically targeting the weights governing the EOS token, the attack permanently suppresses the termination probability across all user prompts, forcing the model into a persistent state of maximum-length generation for every subsequent interaction.

Systemic and Economic Consequences

Why are these attacks so dangerous? In modern cloud-based Machine Learning as a Service (MLaaS) platforms, infrastructure is shared across multiple users. The systemic impacts of resource exhaustion manifest in several ways:

To counter this, researchers are beginning to explore efficiency-aware defenses, such as the energy-oriented alignment datasets proposed by Yiming Chen et al. (Energy-Oriented Alignment for Large Language Models) and edge-cloud detection frameworks designed to catch resource-wasting prompts before they reach expensive cloud GPUs (Joint Optimization of Prompt Security and System Performance in Edge-Cloud LLM Systems).

Key Foundational Work

BERT Lost Patience Won't Be Robust to Adversarial Slowdown (2023) — contributed 1 concept elements to this direction.
NICGSlowDown: Evaluating the Efficiency Robustness of Neural Image Caption Generation Models (2022) — contributed 1 concept elements to this direction.
SlothSpeech: Denial-of-service Attack Against Speech Recognition Models (2023) — contributed 1 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_resource_exhaustion_attack_62029a54,
  title = {resource exhaustion attack},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/resource-exhaustion-attack/rdr_62029a5474234b5b925505896534766c},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-20},
}

This exact version (version 1, frozen text):

@misc{lacuna_resource_exhaustion_attack_62029a54_v1,
  title = {resource exhaustion attack},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/resource-exhaustion-attack/rdr_62029a5474234b5b925505896534766c/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-20},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake