Обход антифрод системы HTB: разбор серверной логики чекера транзакций

На учебном стенде с платёжной логикой velocity check срезал четвёртую транзакцию с одной карты — 403 Forbidden. Обход занял 40 минут: три пробела в номере карты и Python-скрипт на десять строк. Антифрод-чекер считал скоринг честно, но «повторную карту» определял через хэш сырого ввода без нормализации — и на этом сломался. Ниже — пошаговый разбор подхода к HTB-машинам с серверной антифрод-логикой: от разведки правил до конкретного bypass.
HTB machine антифрод: зачем атакующему обходить чекер транзакций
Прежде чем ковырять код — разберёмся с мотивацией. В терминологии MITRE ATT&CK (открытая база тактик и техник атак; T-коды вроде T1190 — её идентификаторы, каждый описывает конкретную технику с привязкой к этапу атаки) конечная цель здесь — Financial Theft (T1657, тактика Impact): атакующий проводит максимум транзакций с украденных карт до момента блокировки. Карты используются в режиме card-not-present (физическая карта не предъявляется, нужен только номер, срок и CVV).
Антифрод-система стоит между атакующим и деньгами. Серверный чекер анализирует каждую транзакцию и выносит вердикт: пропустить (approve), отправить на ручную проверку (review) или заблокировать (block). Конвейер решений работает по цепочке: коллектор данных → извлечение признаков → проверка правил → ML-скоринг → решение. На HTB-машинах ML-часть обычно урезана до набора if/else в Python-скрипте, но логика та же.
Задача пентестера (и CTF-игрока) — найти слепое пятно в rule engine. По классификации OWASP Top 10 (рейтинг десяти самых критичных рисков веб-приложений, обновляется раз в несколько лет) это попадает под A01:2021 — Broken Access Control: система не ограничивает действия пользователя так, как должна. По данным OWASP, 94% протестированных приложений содержали уязвимости этой категории.
Масштаб за пределами учебных стендов ощутимый: по Verizon DBIR 2025, 38% утечек связаны с кражей учётных данных, а карточные данные — один из самых ликвидных товаров на теневых площадках.
Анализ транзакций HTB: разведка и декомпозиция скоринговых правил
Что ищем на машине
Первый шаг — найти платёжный endpoint (адрес API, куда уходят данные транзакции). На HTB-машинах с бизнес-логикой это обычно POST-запрос к /api/transaction, /checkout или /pay. Находится стандартно: Nmap для портов, затем ручной обход приложения через браузер с открытым Burp Suite (прокси для перехвата и модификации HTTP-запросов между браузером и сервером).
Зачем: без точной структуры запроса манипулировать параметрами не получится. Нужно увидеть, какие поля отправляются (card_number, amount, cvv, session_id) и как сервер реагирует на каждый.
Второй шаг — вытащить серверную логику чекера. Это техника Exploit Public-Facing Application (T1190, тактика Initial Access). На HTB извлечение кода идёт через:
- LFI (Local File Inclusion — уязвимость, позволяющая прочитать файл на сервере через подстановку пути в параметр запроса). Если приложение читает файлы по пользовательскому вводу, можно дотянуться до исходного кода чекера.
- Открытый каталог — иногда
.pyили.jsфайл лежит в директории с листингом. Это File and Directory Discovery (T1083, тактика Discovery). - Credentials In Files (T1552.001, тактика Credential Access) — после доступа к файловой системе ищем конфиги с паролями от БД, чтобы напрямую посмотреть таблицу транзакций и логику проверки.
Фрод-паттерны повторного использования карты: что проверяет чекер
Типичный серверный чекер транзакций на учебном стенде проверяет три вещи:
| Правило | Что проверяет | Типичный порог |
|---|---|---|
| Velocity check | Количество транзакций с одного card_number за N минут | 3–5 за 10 минут |
| Amount pattern | Суммы транзакций: круглые суммы повышают risk score | Круглые суммы +15 к скору |
| Card reuse detection | Повторное использование номера карты через хэш-сравнение | Блок после 3 уникальных совпадений |
Risk score (числовая оценка вероятности фрода от 0.0 до 1.0) вычисляется по совокупности этих правил. Решение по порогам: ниже 0.3 — approve, 0.3–0.7 — review, выше 0.7 — block.
Штука в том, что реализация каждой проверки может содержать логическую ошибку. Именно business logic vulnerability (ошибка в бизнес-логике приложения, а не в обработке данных) — основной вектор на таких машинах. Не SQL-инъекция, не RCE — а неверная логика «что считать повторной картой».
Обход правил скоринга при повторном использовании карты
Три техники, которые работают против серверных антифрод-чекеров на учебных стендах. Каждая бьёт в отдельный класс ошибок.
Нормализация ввода: пробел, который ломает хэш
Большинство чекеров хранят card_number как хэш (необратимое преобразование данных фиксированной длины, например SHA-256) для сравнения с историей. Но если код не нормализует ввод до хэширования, один и тот же номер в разных форматах даёт разные хэши.
Номер 4111111111111111 и 4111 1111 1111 1111 — для платёжной системы одна карта. Но если чекер делает hashlib.sha256(card_number.encode()) без предварительного card_number.replace(' ', '').strip(), хэши будут разные. Система решит, что это две разные карты, и velocity check обнулится.
Это Stored Data Manipulation (T1565.001, тактика Impact): атакующий манипулирует тем, как данные сохраняются в системе. Проверяется просто: отправляем транзакцию с номером без пробелов, вторую — с пробелами через четыре цифры, третью — с дефисами. Все три прошли? Чекер уязвим.
Race condition: обгоняем счётчик
Race condition (состояние гонки — результат зависит от порядка выполнения одновременных операций) — классика для обхода velocity checks. Если чекер работает так: проверяет счётчик, проводит транзакцию, потом увеличивает счётчик — между проверкой и обновлением есть окно. Несколько одновременных запросов пройдут проверку до того, как счётчик обновится.
Это Runtime Data Manipulation (T1565.003, тактика Impact): атакующий эксплуатирует зазор между проверкой данных и их обновлением. Окно — миллисекунды, но хватает: 10 одновременных запросов через threading проверяют гипотезу за секунду.
Манипуляция session_id: один пользователь, десять сессий
Если velocity check привязан не к card_number, а к session_id (идентификатору текущей сессии), обход тривиален: новая сессия для каждой транзакции. Каждая начинает с нулевого счётчика. Ошибка привязки: чекер считает транзакции не по карте, а по сессии. Встречается реже, но на CTF-стендах бывает — проверяется за минуту через curl без Cookie-заголовка.
Практика: bypass карточного фрода HTB — делай раз, делай два, делай три
Предпосылки: Kali Linux (или любая система с curl и Python 3), доступ к целевой машине по сети, Burp Suite для перехвата запросов (можно без него, но удобнее с ним).
Шаг 1: находим endpoint и определяем порог
Зачем: узнать структуру запроса и точное количество транзакций до блокировки.
Перехватываем легитимную транзакцию через Burp или DevTools браузера (вкладка Network → отправить платёж → найти POST-запрос). Типичный запрос:
curl -X POST http://TARGET:8080/api/transaction \
-H "Content-Type: application/json" \
-H "Cookie: session=abc123" \
-d '{"card_number":"4111111111111111","amount":100,"cvv":"123"}'
При успехе: {"status":"approved","tx_id":"TX-0001"}. При блокировке: {"status":"blocked","reason":"velocity_exceeded"} с кодом 403. Если в ответе есть поле risk_score — чекер показывает оценку, и разведка скоринговых правил упрощается.
Отправляем одинаковые запросы один за другим. Считаем, на каком приходит 403. Порог velocity check — это число. Ждём 10–15 минут, повторяем: если после паузы запросы снова проходят — окно временного сброса найдено.
Как понять, что получилось: первые N запросов дают 200, (N+1)-й — 403. Значение N — порог.
Шаг 2: проверяем нормализацию
Зачем: определить, считает ли чекер карту с пробелами и без пробелов одной и той же.
После блокировки (счётчик исчерпан) отправляем запрос с тем же номером, но с пробелами: "card_number":"4111 1111 1111 1111". Ответ approved вместо blocked? Чекер не нормализует ввод. Дальше чередуем форматы: с дефисами (4111-1111-1111-1111), с ведущим пробелом (4111111111111111), с табуляцией.
Как понять, что получилось: каждый новый формат проходит с approved, хотя по логике должна быть блокировка. Подтверждение — Stored Data Manipulation работает.
Шаг 3: проверяем race condition
Нормализация есть и пробелы не помогают? Пробуем race condition. Скрипт на Python (стандартная библиотека threading + requests):
import threading, requests
url = "http://TARGET:8080/api/transaction"
payload = {"card_number": "4111111111111111", "amount": 100, "cvv": "123"}
results = []
def send():
r = requests.post(url, json=payload, cookies={"session": "abc123"})
results.append(r.status_code)
threads = [threading.Thread(target=send) for _ in range(10)]
for t in threads: t.start()
for t in threads: t.join()
print(f"Approved: {results.count(200)}, Blocked: {results.count(403)}")
Если из 10 одновременных запросов прошли 5–8 вместо 3 (порога) — race condition подтверждён. Чекер не использует атомарную (неделимую) операцию «проверить + обновить счётчик». На уровне SQLite это значит, что между SELECT count(*) FROM transactions WHERE card_hash=? и INSERT INTO transactions ... есть зазор, куда проскальзывают параллельные запросы.
Server-side антифрод логика: где детект слеп и как защититься
Три слабых места, которые повторяются на учебных стендах и всплывают в реальных антифрод-системах:
| Проблема | Почему возникает | Исправление |
|---|---|---|
| Нет нормализации ввода | Разработчик хэширует raw input | strip() и replace() перед хэшированием |
| Неатомарный velocity check | Проверка и обновление — два отдельных SQL-запроса | SELECT ... FOR UPDATE или атомарный инкремент |
| Привязка к session вместо card | Ошибка архитектуры — считают по сессии | Дедупликация по хэшу card_number |
По OWASP это A05:2021 — Security Misconfiguration: скоринговые правила есть, но реализация допускает bypass через несоответствие между логикой и кодом.
Для детекта со стороны защиты: мониторить одинаковые суммы с разных «карт» за короткий период, логировать параллельно сырой и нормализованный card_number, использовать idempotency key (уникальный идентификатор операции, предотвращающий дубли). Это перекликается с A09:2021 — Security Logging and Monitoring Failures: без логирования нормализованных данных обход не заметен ни в реальном времени, ни при разборе инцидента постфактум.
Антифрод на HTB-машинах — упрощённая модель реальности, но паттерны те же. На пентестах финтех-сервисов раз за разом всплывает одна ошибка: команда разработки пишет скоринговые правила, которые работают в документации, но сыпятся при проверке нормализацией ввода. Три пробела в номере карты — velocity check обнуляется. Race condition в проверке счётчика — лимит в 3 транзакции превращается в 8.
Корень глубже отдельного бага. Антифрод проектирует Data Science-команда, а реализует backend. Между «модель штрафует повторное использование карты» и «код корректно определяет повторное использование» — пропасть размером в один вызов strip(). ML-движок может быть идеальным, но если feature extraction (извлечение признаков из сырых данных для подачи в модель) пропускает варианты форматирования — модель атаку не увидит, потому что атака происходит до неё.
По опыту, 80% обходов антифрода на учебных стендах — не атака на ML, а атака на логику до ML: нормализация, тайминг, привязка к не тому идентификатору. Не нужно понимать градиентный спуск или adversarial ML. Хватает curl, внимательного чтения ответов и понимания того, как сервер хранит и сравнивает данные. Если хочешь разобраться в таких уязвимостях от фундамента, а не по отдельным writeup’ам — на IB Basics эту базу закрывают за пару месяцев, от сетей до первых пентестов.
Эту тему и смежные навыки разбирают на практике в курсе «Антифрод-аналитик» Codeby Academy.
