
Таск goldinospizza2 на m0leCon CTF 2023 решился за три минуты. Сотня параллельных WebSocket-сообщений на эндпоинт order, рефанд каждого заказа — и стартовые 30 евро превратились в бесконечный баланс. Два потока читают balance = 30, оба проходят if balance >= price, оба списывают. А рефанд приходит по каждому заказу отдельно. Race window — единицы миллисекунд, весь эксплойт укладывается в десять строк JavaScript в консоли браузера.
Вот что делает race condition CTF таски такими коварными: уязвимость, которую не найдёшь сканером и не закроешь WAF-ом, потому что каждый отдельный запрос абсолютно легитимен. Разберём механику TOCTOU уязвимости от паттернов в коде до рабочих эксплойтов — Turbo Intruder, asyncio-скрипты на Python и конкретные шаги, по которым забирается флаг.
Race condition — CWE-362 по каталогу MITRE: «Concurrent Execution using Shared Resource with Improper Synchronization». Если коротко: код содержит конкурентную последовательность, которая требует временного эксклюзивного доступа к общему ресурсу, но существует окно, в котором этот ресурс может быть изменён параллельной последовательностью. Последствия — DoS через потребление CPU, аварийное завершение процесса, утечка данных. Платформы, где CWE-362 чаще всего всплывает по данным MITRE: C, C++, Java, Python, Mobile. Но веб-приложения на любом стеке точно так же подвержены этой слабости.
TOCTOU (Time-of-Check to Time-of-Use) — CWE-367, дочерний элемент CWE-362. Описывает конкретный паттерн: продукт проверяет состояние ресурса перед использованием, но между проверкой и использованием состояние меняется, и результат проверки становится мусором. Последствия по CWE-367: нарушение целостности — изменение логики исполнения и модификация данных приложения.
На практике гонка состояний в веб-приложениях выглядит одинаково. CTF-таск — интернет-магазин. Переменная stock = 1. Два запроса приходят одновременно:
stock = 1, проходит проверку if stock > 0stock = 1 (декремент от A ещё не записан), тоже проходит проверкуstock = -1Промежуток между чтением и записью — race window. Именно в это окно атакующий вклинивает второй, третий, двадцатый запрос. Чем шире окно — тем надёжнее эксплуатация race condition. Чем уже — тем важнее техника доставки параллельных запросов.
По классификации OWASP, TOCTOU уязвимость затрагивает несколько категорий Top 10: A08 (Software and Data Integrity Failures) — повреждение состояния при конкурентном доступе, A01 (Broken Access Control) — обход проверок через гонку, A04 (Insecure Design) — архитектура без синхронизации.
В терминах MITRE ATT&CK эксплуатация race condition в веб-приложениях — Exploit Public-Facing Application (T1190, Initial Access). Последствия ложатся на Stored Data Manipulation (T1565.001, Impact) при модификации записей в БД и Financial Theft (T1657, Impact) при double-spend сценариях.
CTF-авторы закладывают гонку состояний в несколько типовых сценариев. Мотивация атакующего в каждом — предельно конкретная:
Double spending race condition — один платёж порождает два результата. Проверка баланса и списание — два отдельных шага без атомарности операций. Атакующий получает товар (или флаг) дважды за одну оплату. Тот самый goldinospizza2 на m0leCon CTF 2023 — именно этот паттерн через WebSocket.
Limit overrun — многократное применение одноразового промокода. Скидка 20% применяется пять раз, потому что счётчик использований не инкрементирован атомарно. На тасках PortSwigger Web Security Academy куртка за $1337 покупается за $37 — двадцатью параллельными POST-запросами к одному эндпоинту. Красота.
Account takeover — подмена email через гонку в OAuth-потоке. Одновременная отправка запроса на привязку нового email и его верификацию — атакующий получает доступ к чужому аккаунту.
Privilege escalation — одновременное назначение роли и проверка прав. Поток A получает привилегии до того, как поток B завершит валидацию текущего уровня доступа.
Маркеры race condition CTF таска: в описании фигурируют слова balance, coupon, redeem, transfer, vote, stock. Любая операция, где пользователь повторно влияет на числовое значение — потенциальная мишень. Видите эндпоинт с бизнес-логикой без идемпотентности запросов — проверяйте на гонку первым делом.
Race condition веб-уязвимости возникают при одном архитектурном антипаттерне: check-then-act без атомарной гарантии. Вот что искать при анализе CTF-таска:
Раздельные read и update. Код читает состояние из БД (SELECT), проверяет условие в логике приложения, затем обновляет (UPDATE) — два отдельных запроса без транзакции. Пример: эндпоинт /redeem читает is_used из таблицы купонов, проверяет if !is_used, затем ставит is_used = true. Между SELECT и UPDATE — race window, в который можно вклиниться параллельным запросом.
Отсутствие идемпотентности запросов. Эндпоинт не принимает идемпотентный ключ и не дедуплицирует повторные вызовы. Каждый запрос к /api/apply-coupon обрабатывается как уникальный — даже если это один и тот же купон от одного пользователя в пределах одной миллисекунды.
Инкременты/декременты вне транзакции. Баланс или счётчик читается в переменную приложения, меняется в памяти и записывается обратно. Операция balance = balance - price на уровне ORM не атомарна: если между чтением и записью другой поток делает то же самое, оба видят исходное значение.
Файловая проверка перед открытием. Классический time-of-check time-of-use: stat() / access() проверяет файл, затем open() / readFile() его читает. Между проверкой и чтением атакующий подменяет файл через symlink. По данным Offensive360, паттерн fs.stat(filePath) с последующим fs.readFile(filePath) — прямой индикатор filesystem TOCTOU в Node.js-приложении.
Когда исходный код недоступен — а на CTF с black-box тасками это частая ситуация — race condition выявляется по косвенным признакам:
200 OK на оба параллельных запроса вместо 200 + 409 ConflictRetry-After, 429 Too Many Requests или других механизмов rate limiting на критичных эндпоинтахГлавная проблема при эксплуатации race condition — не «отправить много запросов», а доставить их на сервер одновременно. Сетевой jitter — случайные задержки на каждом хопе — размазывает запросы во времени. Race window в 2-5 мс легко пропустить, если запросы приходят с разницей в 50 мс.
Принцип: отправляем несколько HTTP-запросов, удерживая последний байт тела каждого. Веб-сервер не начинает обработку, пока не получит запрос целиком. Когда все запросы «взведены» — одновременно досылаем финальные байты. По сети в критический момент уходит всего несколько байт, а не полные тела запросов.
Ограничение: HTTP/1.1 — один запрос на TCP-соединение. Для 20 параллельных запросов нужно 20 TCP-соединений, каждое вносит свою задержку при установке. Метод заметно снижает разброс по времени доставки, хотя и не устраняет jitter полностью. Для большинства CTF-тасков — хватает.
Технику описал Джеймс Кеттл (James Kettle, PortSwigger Research) в работе «The single-packet attack: making remote race-conditions local». HTTP/2 поддерживает мультиплексирование — несколько запросов через одно TCP-соединение. Атакующий отправляет фрагменты каждого запроса, удерживая финальный фрагмент. Затем все финальные фрагменты уходят в одном TCP-пакете.
Результат: все запросы приходят одновременно — сетевой jitter полностью исключён. Удалённая гонка состояний фактически становится локальной. В один пакет реально упаковать 20-30 запросов. Для race condition CTF таска single-packet attack — основной метод.
| Параметр | Last-byte sync (HTTP/1.1) | Single-packet attack (HTTP/2) |
|---|---|---|
| Соединения | Отдельное на каждый запрос | Одно мультиплексированное |
| Jitter | Снижается, не устраняется | Устраняется полностью |
| Запросов в пачке | До ~20 | До 20-30 |
| Engine в Turbo Intruder | Engine.THREADED | Engine.BURP2 |
| Когда использовать | Сервер не поддерживает HTTP/2 | Основной метод для CTF |
| Техника | Предусловия | Инструмент |
|---|---|---|
| Single-packet attack | Сервер поддерживает HTTP/2 | Turbo Intruder (Engine.BURP2) |
| Last-byte sync | HTTP/1.1, возможность открыть 20+ TCP-соединений | Turbo Intruder (Engine.THREADED), Burp Repeater |
| Python asyncio | WebSocket, нестандартный протокол, многошаговый сценарий | aiohttp + asyncio.Barrier (Python 3.11+) |
| Filesystem symlink race | Доступ к ФС, SUID-программа с раздельным check/use | Bash-цикл + renameat2 binary |
Turbo Intruder — расширение Burp Suite с Jython-движком, поддерживающее и last-byte sync, и single-packet attack. Ключевая штука — gate: запросы ставятся в очередь с меткой и не отправляются до вызова openGate(). Когда все запросы в очереди — gate сбрасывает их одновременно.
def queueRequests(target, wordlists):
engine = RequestEngine(endpoint=target.endpoint,
concurrentConnections=1,
engine=Engine.BURP2)
for i in range(20):
engine.queue(target.req, gate='race1')
engine.openGate('race1')
def handleResponse(req, interesting):
table.add(req)
Параметры, от которых зависит результат:
Engine.BURP2 включает HTTP/2 single-packet mode. Если цель поддерживает только HTTP/1.1, нужен Engine.THREADED (last-byte sync) или Engine.BURP. Неправильный выбор engine — самая частая ошибка на CTF. Скрипт скопирован, запущен, не сработал. Потому что сервер на HTTP/1.1, а в скрипте BURP2. Встречал это десятки раз на живых соревнованиях.
concurrentConnections=1 — для HTTP/2 достаточно одного соединения (мультиплексирование). Для HTTP/1.1 с Engine.THREADED ставьте 10-30.
gate='race1' — маркер группы. Все запросы с одинаковым gate уходят вместе при openGate('race1'). Можно использовать несколько gate для многофазных атак: например, race_buy и race_refund для double spending race condition.
range(20) — количество параллельных запросов. Для CTF обычно достаточно 10-30. Если race window узкий — увеличивайте до 50 и повторяйте попытки.
С 2023 года Burp Suite Professional поддерживает параллельную отправку нативно. Перехватите запрос через Proxy, отправьте в Repeater, создайте tab group с 10-20 дубликатами и выберите Send group in parallel. Burp отправит запросы через last-byte synchronization.
Проще Turbo Intruder — не нужны Jython-скрипты. Но менее гибко: нет HTTP/2 single-packet, сложнее масштабировать до 50+ запросов, нельзя варьировать payload между запросами. Для быстрой проверки гипотезы на CTF — за глаза. Увидели подозрительный эндпоинт — за 30 секунд можно проверить, есть ли race condition.
Когда Burp неудобен — WebSocket, нестандартные протоколы, многошаговые сценарии — race condition эксплуатируется кастомным скриптом. Шаблон на asyncio/aiohttp (Python 3.11+):
import asyncio, aiohttp
async def fire(session, url, data, barrier):
await barrier.wait() # все корутины ждут здесь
async with session.post(url, json=data) as r:
return r.status, await r.text()
async def race(url, data, n=20):
barrier = asyncio.Barrier(n)
async with aiohttp.ClientSession() as s:
return await asyncio.gather(
*[fire(s, url, data, barrier) for _ in range(n)])
asyncio.Barrier(n) синхронизирует корутины: все n задач ждут на barrier.wait(), пока последняя не дойдёт до этой точки, после чего все отправляют запрос одновременно. Это Python-аналог gate-механизма Turbo Intruder. Не заменяет single-packet attack на уровне TCP, но для race window в десятки миллисекунд отрабатывает стабильно. Для WebSocket-тасков (как goldinospizza2) адаптируется заменой session.post на websocket.send — принцип тот же, меняется только транспорт.
Типовой CTF-таск: интернет-магазин, промокод DISCOUNT20 даёт скидку 20%, товар стоит $1337, промокод одноразовый. Цель — применить промокод многократно и купить товар за копейки.
Шаг 1: анализ эндпоинта. Перехватываем запрос на применение промокода: POST /api/apply-coupon с телом {"code": "DISCOUNT20"}. Ответ — 200 OK, цена уменьшилась на 20%. Повторная отправка — 400 Bad Request: coupon already used. Одноразовость проверяется — но вопрос в том, атомарна ли проверка.
Шаг 2: формулировка гипотезы. Код предположительно выполняет: прочитать used_count, проверить if used_count == 0, применить скидку, установить used_count = 1. Между чтением used_count и записью нового значения — race window. Если 20 запросов прочитают used_count = 0 до того, как хотя бы один запишет 1, все 20 пройдут проверку.
Шаг 3: подготовка атаки. В Turbo Intruder: отправляем перехваченный запрос в расширение, выбираем скрипт с gate-механизмом (см. код выше). Проверяем, поддерживает ли сервер HTTP/2 — если да, ставим Engine.BURP2; если нет — Engine.THREADED с concurrentConnections=20. Количество запросов: range(20) для первой попытки.
Шаг 4: запуск и анализ. openGate('race1') сбрасывает все 20 запросов одновременно. В результатах ищем: сколько вернули 200 OK вместо одного. Если 5 из 20 прошли — промокод применился пять раз, итоговая скидка 100%. Ключевой индикатор попадания в race window: несколько ответов показывают одинаковый исходный баланс — запросы обработались до записи результата любого из них.
Шаг 5: покупка и флаг. Товар в корзине — цена после кумулятивных скидок стала нулевой или отрицательной. Оформляем заказ, флаг в подтверждении. Если скидок недостаточно — повторяем шаги 3-4 с другим промокодом или увеличиваем range до 50.
Нюанс, на котором многие спотыкаются: если ни один из параллельных запросов не прошёл — race window, вероятно, слишком узкий для текущей техники. Переключитесь с Engine.THREADED на Engine.BURP2 (если доступен HTTP/2), или увеличьте количество попыток — запускайте gate 10-20 раз подряд. Гонка состояний — вероятностная атака, одной попытки часто мало.
Filesystem TOCTOU — отдельная категория race condition в CTF-тасках, чаще в категории pwn/misc, чем web. Вместо HTTP-запросов два потока работают с одним файлом. Типичный сценарий: SUID-программа проверяет права на файл через access(), затем открывает его через open(). Между проверкой и открытием атакующий подменяет файл symlink-ом на /flag или /etc/shadow.
Каноническая уязвимая конструкция на C: access("/tmp/report.txt", W_OK) проверяет, есть ли у пользователя, запустившего программу, право записи, а open("/tmp/report.txt", O_WRONLY) открывает файл с привилегиями SUID-программы. Между этими двумя вызовами атакующий удаляет /tmp/report.txt и создаёт symlink на целевой файл.
Классический эксплойт: в одном терминале бесконечный цикл запускает целевую программу на обычном файле. Во втором — цикл, который создаёт обычный файл (проходящий проверку) и тут же заменяет его symlink-ом на /flag.
Для ускорения используется syscall renameat2 с флагом RENAME_EXCHANGE: два файла атомарно меняются местами. По данным Jorian Woltjer, подход достигает десятков тысяч подмен в секунду — на порядки быстрее цикла с rm + ln -s. Подготовка: заранее создаётся обычный файл и файл-symlink, затем скомпилированная C-программа с renameat2 свапает их в бесконечном цикле, пока целевая программа не прочитает содержимое по symlink-у.
Filesystem maze — техника расширения race window. Путь к файлу прокладывается через глубоко вложенные директории и цепочки symlink-ов. Linux ограничивает до 40 symlink-ов в пути при максимальной длине 4096 байт. Каждый переход по директории и разыменование symlink-а занимает время — разрешение пути удлиняется на миллисекунды. Для тасков с узким race window — критическая техника, превращающая непрактичную гонку в надёжно эксплуатируемую.
TOCTOU уязвимости в реальном софте эксплуатируются по тем же паттернам, что и в CTF. Три кейса, чтобы оценить масштаб.
CVE-2016-5195 — Dirty COW. Race condition в mm/gup.c ядра Linux версий 2.x — 4.x (до 4.8.3). CVSS 7.0 (HIGH), вектор CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H, CWE-362. Гонка в обработке copy-on-write при вызове madvise(MADV_DONTNEED) позволяла локальному пользователю записывать в read-only memory mapping — включая /etc/passwd для эскалации привилегий. Дыра сидела в ядре с версии 2.6.22 (июль 2007) — девять лет до публичного раскрытия в октябре 2016, обнаружена Phil Oester. По данным CISA KEV, CVE-2016-5195 эксплуатировалась in the wild; SSVC-решение CISA — Act (патчить немедленно); EPSS — 0.8352, Top 1%. Верифицированные PoC на Exploit-DB: EDB-40616 (метод /proc/self/mem через SUID, автор Robin Verton), EDB-40847 (модификация /etc/passwd, автор Gabriele Bonacini), EDB-40611 (write access method, автор Phil Oester). Для CTF-игрока Dirty COW — эталон: паттерн (бесконечный цикл с madvise в одном потоке, запись в /proc/self/mem в другом) практически идентичен symlink-гонке из filesystem-тасков.
CVE-2019-5736 — runc container breakout (пограничный случай). runc до версии 1.0-rc6, Docker до 18.09.2. CVSS 8.6 (HIGH), вектор CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H. Атакующий перезаписывал бинарник runc на хосте через race с file descriptor /proc/self/exe во время docker exec. Тут важный момент: несмотря на наличие race-элемента, NVD классифицирует уязвимость как CWE-78 (OS Command Injection) из-за file-descriptor mishandling, а не как CWE-362 или CWE-367. Включаю этот кейс как иллюстрацию смежного паттерна — подмены ресурса между шагами операции, — но формально это не TOCTOU по классификации MITRE/NVD. EPSS — 0.9845, Top 1%. PoC на Exploit-DB: EDB-46359 и EDB-46369. Фикс показателен: runc стал клонировать себя в sealed memfd перед исполнением — окно для подмены исчезло. Тот же принцип, что и на CTF: заменить check-then-use на атомарную операцию.
CVE-2024-0132 (NVIDIA Container Toolkit версии 1.16.1 и ранее): CVSS 9.0 (CRITICAL), вектор CVSS:3.1/AV:N/AC:L/PR:L/UI:R/S:C/C:H/I:H/A:H, CWE-367 — специально сформированный образ контейнера получал доступ к файловой системе хоста при дефолтной конфигурации. Не затрагивает сценарии с CDI. CVE-2025-23359 (NVIDIA Container Toolkit для Linux, дефолтная конфигурация): CVSS 8.3 (HIGH), вектор CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:C/C:H/I:H/A:H, CWE-367 — аналогичный TOCTOU-паттерн, специально сформированный образ контейнера получал доступ к ФС хоста. Обе уязвимости затрагивают nvidia_container_toolkit и nvidia_gpu_operator. Публичный PoC доступен только для CVE-2024-0132 (ssst0n3/poc-cve-2024-0132); для CVE-2025-23359 публичного PoC на момент публикации нет. По данным SecureFlag, TOCTOU в контейнерных рантаймах — не случайность: настройка контейнерного окружения включает множество отдельных шагов (монтирование ФС, запуск контейнера), и если между проверкой и использованием не обеспечена атомарность операций — race window гарантирован.
Паттерн один и тот же на CTF и в продакшене: проверка ресурса (файл, образ, конфигурация, баланс) и его использование — два шага, между которыми атакующий вклинивает подмену.
Race condition — одна из немногих категорий уязвимостей, где разрыв между теорией и практикой определяется не знанием, а навыком тайминга. Можно прочитать десять writeup-ов и всё равно не забрать флаг — engine в скрипте выбран неправильно, запросы идут через HTTP/1.1 вместо HTTP/2, или race window настолько узкий, что нужны не 20, а 200 попыток по 50 запросов.
На CTF-соревнованиях за последний год авторы тасков всё чаще комбинируют гонку с другими уязвимостями — race condition + IDOR, race condition + path traversal, race condition + deserialization. Чистый double-spend без второго вектора встречается реже, потому что CTF-сообщество разобрало этот паттерн. И всё же на каждом крупном CTF хотя бы один таск с гонкой остаётся нерешённым большинством команд. Не потому что сложная теория — потому что люди не тренируют руки.
Прочитать, как работает single-packet attack, и реально собрать рабочий эксплойт с правильным engine и количеством запросов — разные задачи. Идемпотентность запросов, атомарность операций, транзакции с SELECT FOR UPDATE — защита со стороны разработчика. Со стороны атакующего задача проще: найти точку, где два шага не связаны атомарно, и влезть между ними. Если хочется довести механику до автоматизма — на WAPT race condition в веб-модулях разбирается с лабами, где race window настроен от «широкого учебного» до реалистично узкого.
🚀 Хочешь закрепить на практике? Реши задачи по теме на HackerLab — категория «pentest-machines».
0 комментариев
Пожалуйста, войдите, чтобы оставить комментарий.
Загрузка комментариев...