Главная / Блог / Race condition в CTF: поиск и эксплуатация TOCTOU

15 мин.01

Race condition в CTF: поиск и эксплуатация TOCTOU

Race condition в CTF: поиск и эксплуатация TOCTOU

Таск goldinospizza2 на m0leCon CTF 2023 решился за три минуты. Сотня параллельных WebSocket-сообщений на эндпоинт order, рефанд каждого заказа — и стартовые 30 евро превратились в бесконечный баланс. Два потока читают balance = 30, оба проходят if balance >= price, оба списывают. А рефанд приходит по каждому заказу отдельно. Race window — единицы миллисекунд, весь эксплойт укладывается в десять строк JavaScript в консоли браузера.

Вот что делает race condition CTF таски такими коварными: уязвимость, которую не найдёшь сканером и не закроешь WAF-ом, потому что каждый отдельный запрос абсолютно легитимен. Разберём механику TOCTOU уязвимости от паттернов в коде до рабочих эксплойтов — Turbo Intruder, asyncio-скрипты на Python и конкретные шаги, по которым забирается флаг.

Механика TOCTOU уязвимости: что происходит между проверкой и действием

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. Два запроса приходят одновременно:

  1. Поток A: читает stock = 1, проходит проверку if stock > 0
  2. Поток B: читает stock = 1 (декремент от A ещё не записан), тоже проходит проверку
  3. Оба потока декрементят: финальное значение stock = -1

Промежуток между чтением и записью — race window. Именно в это окно атакующий вклинивает второй, третий, двадцатый запрос. Чем шире окно — тем надёжнее эксплуатация race condition. Чем уже — тем важнее техника доставки параллельных запросов.

По классификации OWASP, TOCTOU уязвимость затрагивает несколько категорий Top 10: A08 (Software and Data Integrity Failures) — повреждение состояния при конкурентном доступе, A01 (Broken Access Control) — обход проверок через гонку, A04 (Insecure Design) — архитектура без синхронизации.

Бизнес-логика атаки: зачем race condition в CTF-таске

В терминах 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 уязвимостей: паттерны в коде и поведении

Уязвимые паттерны в исходном коде

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 Conflict
  • Баланс уменьшился на цену одного товара, но получено два
  • Промокод применился дважды при параллельной отправке, хотя заявлен как одноразовый
  • Ответы сервера содержат одинаковый исходный баланс в нескольких параллельных ответах — ни один не увидел изменения другого
  • Нет Retry-After, 429 Too Many Requests или других механизмов rate limiting на критичных эндпоинтах

Параллельные запросы: single-packet attack и last-byte sync

Главная проблема при эксплуатации race condition — не «отправить много запросов», а доставить их на сервер одновременно. Сетевой jitter — случайные задержки на каждом хопе — размазывает запросы во времени. Race window в 2-5 мс легко пропустить, если запросы приходят с разницей в 50 мс.

Last-byte sync для HTTP/1.1

Принцип: отправляем несколько HTTP-запросов, удерживая последний байт тела каждого. Веб-сервер не начинает обработку, пока не получит запрос целиком. Когда все запросы «взведены» — одновременно досылаем финальные байты. По сети в критический момент уходит всего несколько байт, а не полные тела запросов.

Ограничение: HTTP/1.1 — один запрос на TCP-соединение. Для 20 параллельных запросов нужно 20 TCP-соединений, каждое вносит свою задержку при установке. Метод заметно снижает разброс по времени доставки, хотя и не устраняет jitter полностью. Для большинства CTF-тасков — хватает.

Single-packet attack через HTTP/2

Технику описал Джеймс Кеттл (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

Эксплуатация race condition: Turbo Intruder, Repeater и Python

Turbo Intruder и gate-механизм

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 и повторяйте попытки.

Burp Repeater: параллельная отправка без скриптов

С 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.

Python asyncio для кастомных сценариев

Когда 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 — принцип тот же, меняется только транспорт.

Пошаговый разбор: limit overrun через гонку состояний

Типовой 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 — критическая техника, превращающая непрактичную гонку в надёжно эксплуатируемую.

Реальные CVE на TOCTOU: от CTF-таска к продакшену

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 комментариев

Пожалуйста, войдите, чтобы оставить комментарий.

Загрузка комментариев...

Читайте также

Форензика памяти с Volatility: разбор дампа в CTF

12 мин.

2

Форензика памяти с Volatility: разбор дампа в CTF

Пошаговый разбор дампа памяти с Volatility 2 и 3: workflow, ключевые плагины, извлечение артефактов и типичные ошибки новичков в CTF-задачах.

21 НОЯБРЬ, 2026

SUID Privilege Escalation Linux: гайд для CTF

14 мин.

3

SUID Privilege Escalation Linux: гайд для CTF

Пошаговая эксплуатация SUID-бинарников в CTF: энумерация через find и linpeas, таблица GTFOBins, PATH hijacking и Sigma-правила детектирования

20 НОЯБРЬ, 2026

Crypto CTF для начинающих: шифры и XOR

14 мин.

5

Crypto CTF для начинающих: шифры и XOR

Пошаговый разбор классических шифров и XOR в CTF: 4-step фреймворк, брутфорс однобайтового ключа, known-plaintext атака. Код, CyberChef, реальные примеры.

20 НОЯБРЬ, 2026