HTTP Flood: как отличить ботов от реальных пользователей

┌─────────────────────────────────────────────────────────────┐
│                    HTTP FLOOD TAXONOMY                       │
├──────────────────┬──────────────────┬───────────────────────┤
│   GET Flood      │   POST Flood     │   Slowloris / Slow    │
│                  │                  │   POST                │
├──────────────────┼──────────────────┼───────────────────────┤
│ Простые GET      │ POST с payload   │ Держит соединения     │
│ на тяжёлые       │ на формы,        │ открытыми, медленно   │
│ эндпоинты        │ API, загрузку    │ отправляя данные      │
├──────────────────┼──────────────────┼───────────────────────┤
│ /search?q=*      │ /api/upload      │ Connection: keep-alive│
│ /catalog?page=   │ /login           │ Content-Length: big   │
│ /export?format=  │ /checkout        │ ... slow body ...     │
└──────────────────┴──────────────────┴───────────────────────┘

# Топ IP по количеству запросов (последний час)
awk -v date="$(date '+%d/%b/%Y:%H' -d '1 hour ago')" \
  '$4 ~ date {print $1}' /var/log/nginx/access.log | \
  sort | uniq -c | sort -rn | head -20

# Если один IP делает > 1000 req/min — подозрительно

# Запросы без User-Agent или с подозрительными
grep -E '"[^"]*" "-"' /var/log/nginx/access.log | wc -l
grep -i 'python\|curl\|wget\|scanner' /var/log/nginx/access.log | wc -l

# Аномальное распределение по эндпоинтам
awk '{print $7}' /var/log/nginx/access.log | \
  sort | uniq -c | sort -rn | head -10

# Если 90% трафика на один URL — атака или проблема

# nginx.conf

# Зоны для разных типов лимитов
limit_req_zone $binary_remote_addr zone=ip_limit:10m rate=10r/s;
limit_req_zone $binary_remote_addr$uri zone=uri_limit:10m rate=5r/s;
limit_req_zone $http_authorization zone=api_limit:10m rate=100r/s;

# Лимит соединений
limit_conn_zone $binary_remote_addr zone=conn_limit:10m;

server {
    # Общий лимит: 10 req/s с burst 20
    limit_req zone=ip_limit burst=20 nodelay;
    
    # Лимит соединений: max 50 с одного IP
    limit_conn conn_limit 50;
    
    # Для API — отдельный лимит по токену
    location /api/ {
        limit_req zone=api_limit burst=50;
    }
    
    # Для тяжёлых эндпоинтов — строже
    location /search {
        limit_req zone=uri_limit burst=5;
    }
    
    location /export {
        limit_req zone=uri_limit burst=2;
    }
}

<!-- Простой challenge (не для продакшена, для понимания) -->
<script>
  // Вычислить и отправить proof-of-work
  const challenge = document.body.dataset.challenge;
  let nonce = 0;
  
  async function solve() {
    while (true) {
      const hash = await sha256(challenge + nonce);
      if (hash.startsWith('0000')) {
        // Отправить решение
        document.cookie = `pow=${nonce}; path=/`;
        location.reload();
        return;
      }
      nonce++;
    }
  }
  solve();
</script>

// Собираем fingerprint браузера
const fp = {
  // Canvas fingerprint
  canvas: getCanvasFingerprint(),
  
  // WebGL renderer
  webgl: getWebGLRenderer(),
  
  // Fonts
  fonts: detectFonts(),
  
  // Screen
  screen: `${screen.width}x${screen.height}x${screen.colorDepth}`,
  
  // Timezone
  tz: Intl.DateTimeFormat().resolvedOptions().timeZone,
  
  // Language
  lang: navigator.language,
  
  // Platform
  platform: navigator.platform,
  
  // Hardware concurrency
  cores: navigator.hardwareConcurrency,
  
  // Device memory
  memory: navigator.deviceMemory,
  
  // Touch support
  touch: 'ontouchstart' in window,
};

// Hash и отправить на сервер
const hash = sha256(JSON.stringify(fp));

# Пример ML-модели для классификации (псевдокод)

features = [
    'requests_per_minute',
    'unique_urls_ratio',
    'avg_time_on_page',
    'mouse_events_per_request',
    'scroll_depth',
    'js_execution_time',
    'cookie_acceptance',
    'session_duration',
    'referer_chain_length',
    'request_timing_variance',  # Ключевой признак
]

# Variance of timing — главный сигнал
# Люди: высокая вариативность (std > 5 сек)
# Боты: низкая вариативность (std < 0.5 сек)

def is_bot(session_data):
    timing_std = np.std(session_data['request_intervals'])
    if timing_std < 0.5:
        return True  # Слишком ритмично — бот
    
    if session_data['js_executed'] == False:
        return True  # Не выполнил JS — бот
    
    if session_data['mouse_events'] == 0:
        return True  # Нет mouse events — бот
    
    # Для остального — ML модель
    return model.predict(extract_features(session_data)) > 0.7

                    ┌──────────────────────────────────┐
                    │         Входящий трафик          │
                    │         (100% requests)          │
                    └────────────────┬─────────────────┘
                                     │
                                     ▼
┌────────────────────────────────────────────────────────────┐
│  CDN / Edge (Cloudflare, Fastly)                           │
│  ├── Кеширование статики                                   │
│  ├── Rate limiting L7                                      │
│  ├── Managed Bot Challenge                                 │
│  └── IP reputation scoring                                 │
│                                                            │
│  Пропускает: ~60% (кешированные + прошедшие challenge)     │
└────────────────────────────┬───────────────────────────────┘
                             │ 40%
                             ▼
┌────────────────────────────────────────────────────────────┐
│  WAF (ModSecurity / AWS WAF / собственный)                 │
│  ├── Сигнатурные правила (SQL injection, XSS)              │
│  ├── Rate limiting по session/fingerprint                  │
│  └── Блокировка известных bad actors                       │
│                                                            │
│  Пропускает: ~25%                                          │
└────────────────────────────┬───────────────────────────────┘
                             │ 25%
                             ▼
┌────────────────────────────────────────────────────────────┐
│  Application Layer                                         │
│  ├── Fingerprinting в middleware                           │
│  ├── Session scoring                                       │
│  ├── Behavioral analysis                                   │
│  └── Business-logic rate limits (per user, per action)     │
│                                                            │
│  Пропускает: ~20% (легитимные пользователи)                │
└────────────────────────────┬───────────────────────────────┘
                             │ 20%
                             ▼
┌────────────────────────────────────────────────────────────┐
│  Backend / Database                                        │
│  ├── Query optimization                                    │
│  ├── Caching (Redis)                                       │
│  └── Circuit breakers                                      │
└────────────────────────────────────────────────────────────┘

# FastAPI middleware для защиты от HTTP Flood

from fastapi import FastAPI, Request, HTTPException
from collections import defaultdict
import time
import hashlib

app = FastAPI()

# Хранилище rate limiting (в продакшене — Redis)
request_counts = defaultdict(list)
fingerprints = defaultdict(set)

def get_client_fingerprint(request: Request) -> str:
    """Генерирует fingerprint клиента"""
    data = f"{request.headers.get('user-agent', '')}" \
           f"{request.headers.get('accept-language', '')}" \
           f"{request.headers.get('accept-encoding', '')}"
    return hashlib.sha256(data.encode()).hexdigest()[:16]

def check_rate_limit(client_id: str, limit: int = 100, window: int = 60) -> bool:
    """Проверяет rate limit"""
    now = time.time()
    # Очищаем старые записи
    request_counts[client_id] = [
        t for t in request_counts[client_id] 
        if now - t < window
    ]
    # Проверяем лимит
    if len(request_counts[client_id]) >= limit:
        return False
    request_counts[client_id].append(now)
    return True

def detect_timing_anomaly(client_id: str) -> bool:
    """Детектирует подозрительно ритмичные запросы"""
    times = request_counts.get(client_id, [])
    if len(times) < 10:
        return False
    
    intervals = [times[i+1] - times[i] for i in range(len(times)-1)]
    variance = sum((x - sum(intervals)/len(intervals))**2 for x in intervals) / len(intervals)
    
    # Низкая вариативность = бот
    return variance < 0.01

@app.middleware("http")
async def anti_flood_middleware(request: Request, call_next):
    client_ip = request.client.host
    fingerprint = get_client_fingerprint(request)
    client_id = f"{client_ip}:{fingerprint}"
    
    # Rate limiting
    if not check_rate_limit(client_id, limit=100, window=60):
        raise HTTPException(status_code=429, detail="Too many requests")
    
    # Timing anomaly detection
    if detect_timing_anomaly(client_id):
        raise HTTPException(status_code=403, detail="Suspicious activity")
    
    # Проверка User-Agent
    ua = request.headers.get('user-agent', '')
    if not ua or len(ua) < 10:
        raise HTTPException(status_code=403, detail="Invalid User-Agent")
    
    response = await call_next(request)
    return response