Model Denial of Service

Description

Attackers exploit resource-intensive LLM operations to cause excessive costs, performance degradation, or service outages. Attacks target compute, memory, or API rate limits.

Risk

LLM inference is computationally expensive and can be exploited for resource exhaustion. Attackers can submit crafted inputs that maximize processing time, memory usage, or token generation to degrade service availability or inflate costs. This impacts legitimate users through slow responses, timeouts, or complete service unavailability.

Attack Scenarios

Attacker floods an LLM API with maximum-length prompts requesting extremely long outputs, consuming GPU resources and blocking other users' requests.

Malicious actor discovers input patterns that trigger worst-case model performance, submitting automated requests that cause 10x longer processing times and exhaust compute budget.

Mitigations

Rate Limiting

Implement per-user and per-IP rate limits for LLM API calls. Use token bucket or sliding window algorithms to prevent burst abuse.

Resource Quotas

Set maximum token limits for inputs and outputs. Enforce timeouts on inference operations to prevent runaway processing.

Request Validation

Validate request complexity before processing. Reject obviously malicious patterns like excessive repetition or nested structures.

Load Balancing

Distribute requests across multiple model instances. Implement queuing and circuit breakers to gracefully handle overload conditions.

Code Examples

# Good: Request validation and resource limits
from functools import wraps
import time
from collections import defaultdict

class LLMRateLimiter:
    def __init__(self, max_requests=100, window=60):
        self.max_requests = max_requests
        self.window = window
        self.requests = defaultdict(list)
    
    def check_limit(self, user_id: str) -> bool:
        now = time.time()
        # Clean old requests
        self.requests[user_id] = [
            t for t in self.requests[user_id]
            if now - t < self.window
        ]
        # Check limit
        if len(self.requests[user_id]) >= self.max_requests:
            return False
        self.requests[user_id].append(now)
        return True

def validate_request(prompt: str, max_tokens: int = 4000):
    if len(prompt) > max_tokens:
        raise ValueError("Prompt exceeds token limit")
    if prompt.count(prompt[:10]) > 5:  # Detect repetition
        raise ValueError("Excessive repetition detected")
    return True

Evidence Requirements

Rate limiting configuration and enforcement logs
Resource quota policies and monitoring dashboards
Load testing results demonstrating DoS resistance
Incident response records for resource exhaustion attempts
API usage metrics showing per-user limits