Почему IPv6-прокси «палится» на сайтах с двойным стеком: анализ утечки через Happy Eyeballs
Содержание
- Как работает гонка
- Где именно рвётся
- Анатомия утечки: тайминги
- Что видит сайт
- Кейс: nginx как reverse proxy с двойным стеком
- Кейс: curl и Happy Eyeballs
- Кейс: Python requests и его слепые зоны
- Почему IPv6-прокси хуже IPv4 в этой гонке
- Как проверить свою конфигурацию
- !/bin/bash
- Что делать с Happy Eyeballs на клиенте
Браузер открывает сайт. Сайт живёт на двойном стеке — A-запись на IPv4, AAAA на IPv6. Прокси настроен, трафик идёт через него. Казалось бы, всё чисто. Но сайт видит настоящий IPv6 клиента. Или того хуже — видит оба адреса и понимает, что они не совпадают по геолокации.
Причина в RFC 8305. Happy Eyeballs v2 — механизм, который заставляет браузер гонять параллельные соединения по обоим протоколам и выбирать победителя по задержке. Прокси в этой гонке участвует не всегда. Точнее — участвует, но не так, как вы думаете.
Как работает гонка
Классический Happy Eyeballs (RFC 6555, 2011) был простым: резолвим и A, и AAAA, стартуем IPv6 первым, через 300 мс — IPv4, кто ответит быстрее, того и тапки. Версия v2 (RFC 8305, 2017) уточнила тайминги и добавила сортировку по RTT.
Ключевая цифра — `Connection Attempt Delay`. По умолчанию 250 мс. Chrome использует 300 мс, Firefox — 250 мс, curl — 200 мс через `--happy-eyeballs-timeout-ms`. Safari исторически агрессивнее, стартует второй сокет через 150 мс.
Что происходит, когда вы сидите за HTTP-прокси:
1. Браузер резолвит `example.com` локально (или через прокси, зависит от настроек).
2. Получает A и AAAA.
3. Начинает гонку — но гонка идёт не к сайту, а к прокси.
4. Прокси принимает оба соединения и сам решает, куда их отправить.
Вот здесь и начинается зоопарк. Если прокси IPv4-only, а браузер пытается открыть IPv6-сокет к прокси — соединение падает с `ENETUNREACH`. Браузер помечает IPv6 как недоступный и уходит на IPv4. Чисто. Но недолго.
Где именно рвётся
Первая дыра — DNS. Если браузер резолвит имя сам (а он резолвит, если прокси настроен через `CONNECT` для HTTPS или как SOCKS5 с `socks5h` отключённым), то DNS-запрос уходит от вашего реального IP. Сайт получает AAAA-запись, а вместе с ней — префикс /64, который легко сопоставить с ASN провайдера.
Вторая дыра — WebRTC. Даже при полностью настроенном прокси STUN-запросы уходят напрямую. Chrome по умолчанию использует `srflx`-кандидатов, и в SDP утекает реальный IPv6. Проверяется за две секунды:
```javascript
const pc = new RTCPeerConnection({iceServers:[{urls:'stun:stun.l.google.com:19302'}]});
pc.createDataChannel('');
pc.onicecandidate = e => e.candidate && console.log(e.candidate.candidate);
pc.createOffer().then(o => pc.setLocalDescription(o));
```
В консоли увидите что-то вроде `candidate:1 1 udp 2113937151 2a02:6b8::2:242 54321 typ srflx`. Это ваш настоящий адрес.
Третья дыра — самое интересное. Прокси, который формально IPv6-совместим, но не умеет `CONNECT` на IPv6-адреса. Клиент пытается, получает отказ, откатывается на IPv4. Сайт видит IPv4-соединение с одного ASN и IPv6-запрос DNS с другого. Несовпадение.
Анатомия утечки: тайминги
Разберём реальный сценарий. Пользователь за прокси `2001:db8::1`. Сайт `dual.example.com` имеет `A 203.0.113.10` и `AAAA 2001:db8:cafe::10`.
Браузер стартует гонку. Первый сокет — IPv6 к прокси. Прокси принимает, открывает upstream-соединение к `2001:db8:cafe::10`. RTT до сайта — 40 мс. Второй сокет через 300 мс — IPv4 к прокси, дальше к `203.0.113.10`, RTT — 120 мс.
Победил IPv6. Сайт видит соединение с `2001:db8::1`. Всё нормально, утечки нет.
Теперь ломаем. Прокси не поддерживает IPv6-upstream, только IPv4. Первый сокет принимается, но upstream падает через 2 секунды по таймауту. Второй сокет стартует через 300 мс, IPv4-upstream работает, RTT 120 мс. Побеждает IPv4. Сайт видит `203.0.113.10` — то есть IP прокси. Но браузер уже отправил DNS-запрос по IPv6-транспорту до того, как понял, что upstream не работает.
В логах сайта:
```
10:42:11.203 AAAA query from 2001:db8::1 (user's real prefix)
10:42:11.512 TCP connect from 203.0.113.10 (proxy IPv4)
10:42:12.847 TCP connect from 203.0.113.10 (proxy IPv4, retry)
```
Два разных адреса, два разных ASN, интервал 300 мс. Fingerprint как на ладони.
Что видит сайт
Серверная сторона собирает не только `REMOTE_ADDR`. Современные антифрод-системы смотрят на:
| Сигнал | Что выдаёт | Как чинится |
|---|---|---|
| DNS-запрос с реального IP | Префикс /64, ASN | Резолв на стороне прокси |
| WebRTC srflx-кандидат | Реальный IPv6 | Отключить WebRTC или spoof через `--force-webrtc-ip-handling-policy` |
| TLS fingerprint (JA3/JA4) | Совпадение с браузером, но не с заявленным UA | Использовать реальный браузер, не headless |
| TCP timestamps | Разные ядра ОС | Прокси должен терминировать TCP |
| MTU в SYN | 1500 vs 1280 (IPv6 min) | Настраивать MTU на прокси |
| TTL/hop limit | 64 vs 128 | Нормализовать на прокси |
Последние две строки — самые недооценённые. IPv6 требует минимальный MTU 1280 байт. Если вы гоните IPv6 через туннель с MTU 1400, а сайт видит MSS 1360 в SYN — это уже сигнал. IPv4-клиенты обычно показывают MSS 1460.
Кейс: nginx как reverse proxy с двойным стеком
Сервер на nginx 1.24, слушает `[::]:443` с `ipv6only=on`. Апстрим — бэкенд на `127.0.0.1:8080`. Пользователи за IPv6-прокси жалуются на «странные» проверки капчи.
Причина: nginx по умолчанию резолвит upstream-имена и на A, и на AAAA. Если бэкенд имеет AAAA-запись, nginx пойдёт по IPv6. Но `proxy_pass http://backend;` без явного резолвера кэширует результат на TTL из DNS. При смене адреса — 502.
Хуже: `X-Forwarded-For` заполняется IPv6-адресом клиента. Бэкенд видит `2001:db8::1`, а сессия в Redis привязана к IPv4. Разлогин.
Фикс:
```nginx
resolver 127.0.0.1 valid=10s ipv6=off;
upstream backend {
server 127.0.0.1:8080;
keepalive 32;
}
server {
listen [::]:443 ssl http2;
listen 443 ssl http2;
ipv6only on;
proxy_set_header X-Forwarded-For \$proxy_add_x_forwarded_for;
proxy_set_header X-Real-IP \$remote_addr;
proxy_http_version 1.1;
proxy_set_header Connection "";
location / {
proxy_pass http://backend;
}
}
```
`ipv6=off` в резолвере — критично. Без него nginx может пойти в IPv6-upstream, где бэкенд не слушает, и получить таймаут вместо быстрого IPv4-коннекта.
Кейс: curl и Happy Eyeballs
Тестируете прокси через curl. Команда:
```bash
curl -6 -x http://[2001:db8::1]:3128 https://ifconfig.co
```
Возвращает IPv6-адрес прокси. Отлично. Но если убрать `-6`:
```bash
curl -x http://[2001:db8::1]:3128 https://ifconfig.co --happy-eyeballs-timeout-ms 200
```
curl стартует гонку. Если прокси принимает только IPv4-соединения (типичная ошибка конфигурации Squid), IPv6-попытка падает, IPv4 проходит. `ifconfig.co` показывает IPv4 прокси. Но DNS-запрос к `ifconfig.co` ушёл раньше — с вашего реального адреса, если `socks5h` не используется.
Для HTTP-прокси DNS всегда резолвится локально. Для SOCKS5 — зависит от флага. Проверяйте:
```bash
curl -x socks5h://[2001:db8::1]:1080 https://ifconfig.co
```
`h` в схеме означает «резолвить на стороне прокси». Без него — утечка DNS гарантирована.
Кейс: Python requests и его слепые зоны
`requests` не поддерживает Happy Eyeballs вообще. Он берёт первый адрес из `getaddrinfo()` и идёт по нему. На Linux `getaddrinfo` сортирует по RFC 3484, и IPv6 обычно первый. Если прокси IPv6-only — работает. Если dual-stack — работает, но без фолбэка.
Проблема в другом. `requests` с прокси по умолчанию резолвит имя локально:
```python
import requests
proxies = {"https": "http://[2001:db8::1]:3128"}
r = requests.get("https://ifconfig.co/json", proxies=proxies, timeout=10)
print(r.json())
```
DNS-запрос уходит от вашего IP. Сайт логирует `AAAA`-запрос с реального префикса. Через 200 мс приходит соединение с прокси. Несовпадение.
Решение — принудительный резолв на стороне прокси через SOCKS5:
```python
import requests
from requests.adapters import HTTPAdapter
session = requests.Session()
session.proxies = {"https": "socks5h://[2001:db8::1]:1080"}
session.mount("https://", HTTPAdapter(max_retries=3))
r = session.get("https://ifconfig.co/json", timeout=10)
```
`requests[socks]` обязателен. И `socks5h`, не `socks5`. Разница в одной букве — разница между утечкой и её отсутствием.
Почему IPv6-прокси хуже IPv4 в этой гонке
IPv4-прокси проще. Один протокол, одна гонка, никаких фолбэков. Happy Eyeballs не участвует — нечего гонять.
IPv6-прокси обязан поддерживать оба протокола на входе и оба на выходе. Четыре комбинации. Каждая — потенциальная дыра.
| Вход | Выход | Утечка | Частота |
|---|---|---|---|
| IPv6 | IPv6 | Нет | Редко (мало провайдеров) |
| IPv6 | IPv4 | DNS, WebRTC | Часто |
| IPv4 | IPv6 | Редко | Редко |
| IPv4 | IPv4 | Нет | Часто (это просто IPv4-прокси) |
Строка «IPv6 in, IPv4 out» — самая проблемная. Клиент думает, что он в IPv6-мире, а прокси его выкидывает в IPv4. Все IPv6-специфичные проверки (prefer-ipv6 в DNS, AAAA-логи, WebRTC) срабатывают на реальный адрес клиента.
Именно здесь помогает lexic.ml — прокси с 2015 года держит IPv6-транспорт на обеих сторонах, и upstream-соединение идёт по тому же протоколу, что и downstream. Это убирает рассинхрон, из-за которого антифрод видит два разных адреса.
Как проверить свою конфигурацию
Минимальный чек-лист. Открываете в браузере за прокси:
1. `https://ifconfig.co/json` — должен показать IPv6 прокси, не ваш.
2. `https://browserleaks.com/ip` — проверка WebRTC-кандидатов.
3. `https://dnsleaktest.com` — extended test, смотрите ASN резолверов.
4. `https://ipv6-test.com` — покажет, доступен ли IPv6 и через кого.
Если хоть один показывает ваш реальный префикс — конфигурация дырявая. Не «может быть дырявая», а точно.
Для автоматизации — простой скрипт:
```bash
!/bin/bash
PROXY="http://[2001:db8::1]:3128"
REAL=\$(curl -s -6 https://ifconfig.co)
VIA=\$(curl -s -x "\$PROXY" https://ifconfig.co)
if [ "\$REAL" = "\$VIA" ]; then
echo "LEAK: proxy returns real IP"
exit 1
fi
echo "OK: \$VIA"
```
Запускать на каждой машине перед работой. Тридцать секунд — дешевле, чем разбор инцидента.
Что делать с Happy Eyeballs на клиенте
Иногда проще выключить гонку, чем чинить прокси. Chrome:
```
chrome://flags/#enable-quic — disable
--disable-features=HappyEyeballsV3
```
Firefox: `network.dns.disableIPv6 = true` в `about:config`. Убивает IPv6 целиком, зато утечек нет.
curl: `--ipv4` или `--ipv6`. Явно, без гонки.
Python: `socket.has_ipv6 = False` перед импортом `requests`. Костыль, но работает.
Радикально — да. Но если прокси не тянет dual-stack честно, лучше резать на клиенте, чем ловить бан на сайте через неделю.