Как антибот-системы ловят прокси по TLS JA3/JA4 fingerprint
Содержание
- Что вообще такое JA3 и JA4
- Почему прокси палится на ровном месте
- 3b5074b1b5d032e432b9761947de44c2 — это OpenSSL, не Chrome
- Как антибот использует отпечаток
- Почему прокси-серверы ломают отпечаток
- Плохо: nginx отдаёт свой JA3, антибот видит несоответствие
- Лучше: явно задать шифры и кривые под Chrome
- Что делать: подмена отпечатка на клиенте
- curl-impersonate: JA3 как у Chrome 120
- curl_cffi из Python
- cd08e31494f9531f560d64c695473da9
- Кейс: парсер маркетплейса и Cloudflare
- Кейс: nginx-прокси перед API
- Кейс: мобильные прокси и JA4
- Где взять базу отпечатков для сверки
- Подводные камни
- Что в итоге
Прокси палится не по IP. Точнее, не только по IP. Антибот смотрит на TLS-рукопожатие — и там остаётся след клиента. Даже если трафик идёт через чужой сервер, отпечаток ClientHello выдаёт, чем именно вы ходите на сайт. Разбираем, как это работает и что с этим делать.
Что вообще такое JA3 и JA4
JA3 — это хеш от параметров TLS ClientHello. Salesforce придумала его в 2017-м, чтобы ловить малварь по TLS. Идея простая: браузер Chrome 120 всегда отправляет ClientHello с одним и тем же набором шифров, расширений, эллиптических кривых и форматов точек. Собери их в строку, посчитай MD5 — получишь 32-символьный отпечаток.
JA4 — переработка той же идеи, вышедшая в 2023-м. Вместо MD5 — SHA256, но урезанный до 12 hex-символов в основной части. Плюс разделение на части: `t13d1516h2_8daaf6152771_02713d6af862`. Первая часть — версия TLS, SNI, число шифров, число расширений, ALPN. Вторая — хеш шифров. Третья — хеш расширений и сигнатур. Читается глазами, отлаживать проще.
```
JA3: 771,4865-4866-4867-49195-49199-49196-49200-52393-52392-49171-49172-156-157-47-53,0-23-65281-10-11-35-16-5-13-18-51-45-43-27-17513,29-23-24,0
JA4: t13d1516h2_8daaf6152771_02713d6af862
```
Разница принципиальная. JA3 ломается от любого изменения порядка расширений — Chrome обновляется, хеш меняется, все антибот-правила сыпятся. JA4 сортирует расширения и шифры перед хешированием, поэтому стабильнее. И ещё JA4 умеет кодировать ALPN прямо в первой части (`h2` = HTTP/2, `h1` = HTTP/1.1).
Почему прокси палится на ровном месте
Клиент идёт на сайт через прокси. Прокси терминирует TCP, читает HTTP, коннектится к цели. Если это HTTP-прокси — TLS вообще не проходит через прокси, его устанавливает клиент напрямую. Тогда JA3/JA4 — отпечаток клиента. Если это HTTPS-прокси с CONNECT — то же самое, прокси видит только зашифрованный поток.
А вот если прокси сам делает TLS-хендшейк с целевым сервером (reverse proxy, CDN, MITM-прокси) — тогда JA3/JA4 будет отпечатком прокси, а не клиента. И тут начинается зоопарк.
Python-requests по умолчанию ходит через OpenSSL 3.x с дефолтным набором шифров. Chrome — через BoringSSL с другим набором, другим порядком, другими расширениями. Отпечатки не совпадают вообще. Антибот видит: заявлен Chrome в User-Agent, а JA3 — от python-requests. Бан.
```python
import requests
r = requests.get(
"https://tls.browserleaks.com/json",
headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
"AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"}
)
print(r.json()["ja3_hash"])
3b5074b1b5d032e432b9761947de44c2 — это OpenSSL, не Chrome
```
Chrome 120 на Windows отдаёт `cd08e31494f9531f560d64c695473da9`. Разница видна невооружённым глазом, если у тебя есть база отпечатков. У Cloudflare, DataDome, PerimeterX такая база есть. И у них же есть правила: «если JA3 = 3b5074b1... и UA содержит Chrome — это бот».
Как антибот использует отпечаток
Сам по себе JA3 ничего не доказывает. Мало ли, у человека старый Firefox. Поэтому антиботы смотрят на согласованность. Четыре сигнала должны совпадать:
| Сигнал | Где берётся | Пример (Chrome 120 / Win) |
|---|---|---|
| User-Agent | HTTP-заголовок | `Mozilla/5.0 ... Chrome/120.0.0.0` |
| JA3/JA4 | TLS ClientHello | `cd08e31494f9531f560d64c695473da9` |
| HTTP/2 fingerprint | SETTINGS-фрейм | `1:65536;2:0;4:6291456;6:262144` |
| Header order | Порядок заголовков | `Host, Connection, sec-ch-ua, ...` |
Если три из четырёх совпадают, а четвёртый — нет, это подозрительно. Если совпадают все — пускают. Если клиент заявил Chrome, а JA3 от Go-клиента — режут на CAPTCHA или 403.
HTTP/2 fingerprint (иногда зовут Akamai fingerprint) — отдельная песня. Это хеш от SETTINGS-фрейма и WINDOW_UPDATE. Chrome отправляет `SETTINGS_INITIAL_WINDOW_SIZE=6291456`, Go — `1048576`, curl — `2147483647`. Плюс порядок псевдозаголовков `:method, :authority, :scheme, :path` у Chrome и `:method, :scheme, :authority, :path` у Go. Всё это видно ещё до первого байта тела запроса.
Почему прокси-серверы ломают отпечаток
Классический HTTP-прокси работает на уровне приложения. Клиент шлёт `CONNECT example.com:443`, прокси открывает TCP-туннель и перекладывает байты. TLS-хендшейк идёт end-to-end, JA3 остаётся клиентским. Тут прокси не при делах.
Но многие «прокси» на деле — reverse proxy или MITM. Squid с `ssl_bump`, nginx с `proxy_ssl_*`, mitmproxy — все они терминируют TLS и делают свой хендшейк к цели. И тут отпечаток становится отпечатком прокси-сервера. А он у nginx 1.24 с дефолтным `ssl_protocols TLSv1.2 TLSv1.3` и `ssl_ciphers HIGH:!aNULL:!MD5` — совсем не Chrome.
```nginx
Плохо: nginx отдаёт свой JA3, антибот видит несоответствие
location / {
proxy_pass https://backend;
proxy_ssl_server_name on;
}
Лучше: явно задать шифры и кривые под Chrome
location / {
proxy_pass https://backend;
proxy_ssl_server_name on;
proxy_ssl_protocols TLSv1.2 TLSv1.3;
proxy_ssl_ciphers "ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305";
proxy_ssl_conf_command Curves X25519:P-256:P-384;
}
```
Даже с этими настройками JA3 не совпадёт идеально. Порядок расширений у OpenSSL другой. Chrome ставит `server_name` (SNI) на позицию 0, `extended_master_secret` на 23, `session_ticket` на 35. OpenSSL — иначе. Хеш разный, хоть ты тресни.
Что делать: подмена отпечатка на клиенте
Самый рабочий путь — не прокси мучить, а клиент. Есть инструменты, которые говорят на TLS как браузер. `curl-impersonate` — патченный curl с BoringSSL и набором профилей Chrome/Firefox/Safari. `requests` с биндингом `curl_cffi` — то же самое из Python.
```bash
curl-impersonate: JA3 как у Chrome 120
curl-impersonate-chrome https://tls.browserleaks.com/json
curl_cffi из Python
python3 -c "
from curl_cffi import requests
r = requests.get('https://tls.browserleaks.com/json', impersonate='chrome120')
print(r.json()['ja3_hash'])
"
cd08e31494f9531f560d64c695473da9
```
`curl_cffi` под капотом держит BoringSSL и переставляет расширения в порядке Chrome. JA3, JA4, HTTP/2 fingerprint — всё совпадает. Скорость — примерно как у обычного curl, накладные расходы в пределах 5-10 мс на хендшейк.
Если работаешь через прокси, схема такая: `curl_cffi` (клиент с правильным JA3) → HTTP CONNECT-прокси (не терминирует TLS) → цель. Прокси видит только зашифрованный поток, JA3 остаётся клиентским. Прокси нужен только чтобы подменить IP.
Кейс: парсер маркетплейса и Cloudflare
Задача — собирать цены с сайта за Cloudflare. Прокси-пул на 500 IPv4, ротация каждые 10 запросов. Клиент — python-requests 2.31. Результат: 90% запросов получают 403 с `cf-mitigated: challenge`.
Причина — не в IP. Cloudflare смотрел на JA3. У python-requests он `3b5074b1b5d032e432b9761947de44c2`, у Chrome — `cd08e31494f9531f560d64c695473da9`. Плюс HTTP/2 fingerprint от Python-клиента (через `httpx` с h2) не совпадал с заявленным Chrome 120.
Решение: переписали на `curl_cffi` с `impersonate="chrome120"`. Прокси оставили, но перевели на SOCKS5 — чтобы гарантированно не терминировать TLS. Через две недели — 4% блокировок вместо 90%. Оставшиеся 4% — это уже поведенческий анализ и rate limiting, не отпечатки.
Кейс: nginx-прокси перед API
Внутренний сервис ходил на партнёрский API через nginx `proxy_pass`. Партнёр начал отдавать 403 на часть запросов. Логи nginx чистые, код 200 от upstream. Партнёр на вопрос отвечает: «у вас TLS-отпечаток не как у браузера».
Разбор: nginx 1.24 на Ubuntu 22.04 с OpenSSL 3.0.2. JA3 — `9e10692f1b7f78228b2d4e424e06584d`. Партнёр ждал Chrome или Firefox, потому что их API по документации «только для браузерных клиентов». Nginx отдавал свой отпечаток, партнёрский WAF его резал.
Костыль: поставили перед nginx маленький Go-сервис на `utls` с профилем Chrome. Он делал исходящие запросы к партнёру, nginx проксировал уже к нему по HTTP. Накладные расходы — 2-3 мс на запрос, зато 403 пропали. Другой вариант — `curl-impersonate` как subprocess, но там fork на каждый запрос, дороже.
Кейс: мобильные прокси и JA4
Парсер соцсети через мобильные прокси (LTE, операторы РФ). Антибот соцсети пускал первые 20 запросов, потом — CAPTCHA. IP менялся, а бан возвращался. Причём с новым IP — снова 20 запросов и снова бан.
Причина оказалась в JA4. Клиент — Node.js с `undici`. JA4 у него `t13d1516h2_8daaf6152771_02713d6af862` — стабильный, не меняется от запроса к запросу. Антибот видел: 500 разных IP, но один и тот же JA4. Это не 500 пользователей, это один бот с пулом прокси. Логика простая: если отпечаток один, а IP разные — режем по отпечатку.
Решение — рандомизация JA4. Взяли `utls` с профилями Chrome 118, 119, 120, Firefox 120, Safari 17. Распределили запросы по профилям: 60% Chrome (разные версии), 30% Firefox, 10% Safari. Плюс привязали профиль к IP — один IP = один профиль на сессию. CAPTCHA сократилась с 80% до 12%. Остальное — уже вопросы к качеству мобильных IP.
Где взять базу отпечатков для сверки
Отладка без базы бессмысленна. Нужно знать, какой JA3 у какого браузера. Источники:
- `tls.browserleaks.com/json` — отдаёт JA3, JA4, HTTP/2 fingerprint, header order для твоего клиента.
- `ja3er.com` — база JA3 с привязкой к клиентам (частично устарела).
- `github.com/FoxIO-LLC/ja4` — референсная имплементация JA4, там же примеры.
- `github.com/lwthiker/curl-impersonate` — профили Chrome/Firefox/Safari с точными параметрами.
Сверять надо не только JA3, но и HTTP/2 fingerprint, и порядок заголовков. Chrome 120 на Windows отправляет заголовки в порядке: `Host, Connection, sec-ch-ua, sec-ch-ua-mobile, sec-ch-ua-platform, Upgrade-Insecure-Requests, User-Agent, Accept, Sec-Fetch-Site, Sec-Fetch-Mode, Sec-Fetch-User, Sec-Fetch-Dest, Accept-Encoding, Accept-Language`. Firefox — совсем другой порядок. Если клиент заявил Chrome, а порядок заголовков от Firefox — палево.
Подводные камни
Первый грабли — TLS 1.3 session resumption. Chrome после первого хендшейка шлёт PSK, и JA3 второй сессии короче. Антиботы это знают и либо игнорируют, либо наоборот — режут клиентов без resumption как подозрительных. `curl_cffi` resumption не поддерживает по умолчанию, надо включать явно.
Второй — ALPN. Chrome предлагает `h2, http/1.1`. Если клиент говорит только `http/1.1`, а UA заявлен Chrome — вопрос. HTTP/2 fingerprint при этом отсутствует, и это тоже сигнал.
Третий — SNI. Chrome всегда шлёт SNI для HTTPS. Если клиент коннектится по IP без SNI, а UA — браузерный, это несоответствие. Некоторые антиботы на этом ловят.
Четвёртый — GREASE. Chrome вставляет GREASE-значения (0x0a0a, 0x1a1a и т.д.) в шифры и расширения. Они игнорируются сервером, но меняют JA3. `curl_cffi` их воспроизводит. А вот самописный клиент на `ssl.SSLContext` — нет, и JA3 получается другой.
Что в итоге
Отпечаток TLS — это не про IP и не про User-Agent. Это про то, как именно ваш клиент начинает разговор. Прокси, который терминирует TLS, ломает отпечаток. Прокси, который пропускает TLS насквозь (CONNECT, SOCKS5), отпечаток сохраняет — но тогда нужен клиент с правильным JA3.
Схема, которая работает: `curl_cffi` или `curl-impersonate` на клиенте, SOCKS5-прокси для смены IP, профиль браузера привязан к IP на сессию. Для распределённых задач — рандомизация профилей, чтобы не было одного JA4 на сотни IP. Для внутренних сервисов, которым нужен исходящий трафик «как браузер» — `utls` в Go-обёртке перед nginx. Прокси-пул на lexic.ml как раз держит SOCKS5 без терминации TLS — отпечаток клиента доходит до цели нетронутым, что для парсинга с антибот-сайтов часто и нужно.
Главное — не забывать: JA3/JA4 это только один слой. Поведение, тайминги, cookie-сессии, canvas fingerprint — всё это тоже проверяется. Маскировка отпечатка снимает часть блокировок, но не все. Если запросы идут строго каждые 100 мс с одного профиля — никакой JA3 не спасёт.