Как TLS-фрагментация маскирует SNI при работе через прокси
Содержание
- Почему SNI вообще видно
- Что именно режет фрагментация
- Практика: фрагментация в Python
- Ограничения метода
- Сравнение подходов к маскировке SNI
- Кейс: корпоративный фаервол с Palo Alto
- Кейс: провайдер с DPI на ТСПУ
- Кейс: nginx как фрагментирующий прокси
- Что делать, если фрагментация не помогает
- Проверка результата
SNI расшифровывается как Server Name Indication. Клиент говорит серверу: «я иду на example.com». Проблема в том, что этот кусок ClientHello летит открытым текстом. Любой посредник — DPI, корпоративный фаервол, провайдер — видит, куда вы собрались. Фрагментация разбивает ClientHello на куски так, чтобы имя хоста не попало в один TCP-сегмент целиком.
Почему SNI вообще видно
TLS 1.2 и 1.3 держат хостнейм в расширении `server_name` внутри первого сообщения рукопожатия. ClientHello — это структура с заголовком `0x16 0x03 0x01` (handshake, TLS 1.0 legacy-версия) и длиной. Дальше идёт список шифров, расширения, и где-то среди них — открытая строка вроде `api.example.org`.
DPI-системы извлекают её регуляркой по смещениям. Им не нужен полный парсинг TLS — достаточно найти байты `0x00 0x00` (идентификатор расширения server_name) и прочитать длину следом. Это дёшево по CPU, поэтому включено почти везде, где есть инспекция трафика.
Фрагментация ломает эту схему. Если первый TCP-сегмент обрывается посреди имени, парсер DPI видит неполное расширение и часто просто пропускает пакет. Второй сегмент без начала ClientHello уже не распознаётся как TLS handshake. Собрать обратно DPI может, но не всегда хочет — это дорого.
Что именно режет фрагментация
Есть три уровня, где можно вмешаться. Первый — TCP-сегментация: клиент отправляет ClientHello двумя write() с разными размерами. Второй — TLS-уровень: ClientHello собирается из нескольких handshake-записей. Третий — на уровне прокси, который переупаковывает поток.
Первый вариант самый распространённый. Работает через `setsockopt` с `TCP_NODELAY` и принудительным разбиением буфера. Второй чище с точки зрения TLS, но требует доработки клиента. Третий — то, чем занимаются прокси вроде lexic.ml: соединение до целевого сервера устанавливается с их стороны, и SNI фрагментируется уже в их исходящем потоке.
Ключевой момент: фрагментация должна попадать точно в имя хоста. Если порезать ClientHello в случайном месте — DPI соберёт его из двух сегментов по sequence-номерам и всё равно прочитает. Резать надо так, чтобы граница пришлась на середину строки `server_name`.
Практика: фрагментация в Python
Самый простой способ — обернуть сокет и отправлять ClientHello частями. Ниже рабочий пример с `ssl.MemoryBIO`, который даёт контроль над байтами до шифрования.
```python
import socket, ssl
def fragmented_connect(host, port, sni, split_at=5):
ctx = ssl.create_default_context()
incoming = ssl.MemoryBIO()
outgoing = ssl.MemoryBIO()
obj = ctx.wrap_bio(incoming, outgoing, server_hostname=sni)
sock = socket.create_connection((host, port))
sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
try:
obj.do_handshake()
except ssl.SSLWantReadError:
pass
hello = outgoing.read()
idx = hello.find(sni.encode())
if idx == -1:
sock.sendall(hello)
else:
cut = idx + split_at
sock.sendall(hello[:cut])
sock.sendall(hello[cut:])
while True:
try:
obj.do_handshake()
break
except ssl.SSLWantReadError:
data = sock.recv(65536)
if not data:
raise ConnectionError("closed during handshake")
incoming.write(data)
chunk = outgoing.read()
if chunk:
sock.sendall(chunk)
return sock, obj
```
Здесь `split_at=5` означает: порезать через пять байт после начала имени. DPI видит `exam` в первом сегменте и остаток `ple.com` во втором. Ни один из кусков не содержит полного расширения с валидной длиной. Проверить эффект можно через `tcpdump`:
```bash
tcpdump -i eth0 -A 'tcp port 443 and tcp[tcpflags] & tcp-push != 0' -c 10
```
В выводе увидите два PSH-пакета подряд с разрывом внутри ASCII-строки.
Ограничения метода
Фрагментация не панацея. Продвинутые DPI умеют собирать TCP-поток и парсить его целиком — тогда разбиение не поможет. Некоторые системы ставят таймаут на сборку: если второй сегмент приходит позже 100-200 мс, поток сбрасывается, и соединение рвётся. Поэтому задержку между сегментами надо держать минимальной, в идеале — нулевой.
Ещё одна грабля — middlebox'ы, которые переупаковывают TCP. Прокси, балансировщики, NAT с ALG могут склеить сегменты обратно перед отправкой. Тогда фрагментация теряется где-то посередине пути. Проверять надо на конкретном маршруте, а не абстрактно.
С TLS 1.3 ситуация чуть сложнее: ClientHello шифруется частично (EncryptedExtensions и дальше), но `server_name` всё ещё открыт. Так что метод работает и там. ECH (Encrypted Client Hello) решает проблему радикально, но поддержка в 2024-2025 годах всё ещё пятнистая.
Сравнение подходов к маскировке SNI
| Метод | Уровень | Поддержка клиентов | Устойчивость к DPI со сборкой потока | Накладные расходы |
|---|---|---|---|---|
| TCP-фрагментация | L4 | Все | Низкая | Минимальные |
| TLS record splitting | L5 | Требует доработки | Средняя | Низкие |
| Domain fronting | L7 | Зависит от CDN | Высокая | Средние |
| ECH | L5 | Chrome 117+, Firefox 118+ | Высокая | Низкие |
| Прокси с фрагментацией | L4-L5 | Прозрачно | Средняя | Зависит от прокси |
TCP-фрагментация выигрывает по простоте. ECH — по надёжности, но требует поддержки на стороне сервера. Domain fronting работает, пока CDN не прикрыл лавочку (Cloudflare это сделал для большинства тарифов ещё в 2015-м, потом ужесточил).
Кейс: корпоративный фаервол с Palo Alto
Пример: разработчик в офисе не может достучаться до `registry.npmjs.org` — фаервол режет по SNI-категории «software repositories». Прямое подключение падает с `SSL_ERROR_SYSCALL` на этапе handshake. Причина — PA-5220 с включённым SSL Decryption и SNI-фильтрацией.
Решение через локальный прокси с фрагментацией: клиент подключается к `127.0.0.1:8443`, прокси открывает соединение до цели и режет ClientHello. Фаервол видит два сегмента, второй без начала handshake. Соединение проходит. Задержка выросла на 8-12 мс — это цена двух лишних round-trip'ов на установку.
Кейс: провайдер с DPI на ТСПУ
Российский провайдер с DPI-системой на уровне ТСПУ блокирует ряд доменов по SNI. Клиент с фрагментацией через `split_at=3` проходит примерно в 70% случаев. Оставшиеся 30% — те, где DPI успевает собрать поток до истечения таймаута в 150 мс.
Что помогло: уменьшение задержки между сегментами до нуля (отправка через `sendall` дважды подряд без sleep) и снижение `TCP_NODELAY`-эффекта. Плюс переход на фрагментацию в двух местах ClientHello — не только в SNI, но и в начале handshake. Это ломает эвристики, которые ищут `0x16 0x03` в первых байтах потока.
Кейс: nginx как фрагментирующий прокси
Сервер на nginx 1.24 с `stream`-модулем, настроенный как TCP-прокси до апстрима. Проблема: nginx по умолчанию буферизует и склеивает пакеты, фрагментация клиента теряется. Решение — отключить буферизацию и выставить `proxy_buffer_size` в минимум.
```nginx
stream {
upstream backend {
server 10.0.0.5:443;
}
server {
listen 443;
proxy_pass backend;
proxy_buffer_size 4k;
proxy_buffering off;
proxy_socket_keepalive on;
proxy_ssl_server_name off;
}
}
```
С `proxy_buffering off` nginx передаёт данные как есть, сегменты клиента сохраняются. Проверка: `tcpdump` на исходящем интерфейсе показал два PSH-пакета с разрывом в SNI, как и ожидалось. Задержка на проксирование — 2-4 мс, приемлемо.
Что делать, если фрагментация не помогает
Первое — проверить, не собирает ли DPI поток. Это можно косвенно определить по времени разрыва: если соединение падает через 100-300 мс после начала handshake, скорее всего работает таймаут сборки. Второе — попробовать фрагментацию на уровне TLS-записей, а не TCP. Третье — уйти на ECH или на протоколы с обфускацией вроде того, что делают Shadowsocks и VLESS.
Ещё вариант — использовать прокси, который сам фрагментирует исходящий поток. Тогда клиент вообще не думает о SNI, а просто ходит через `HTTPS_PROXY`. Это удобно для приложений, которые не умеют в кастомную фрагментацию (старые JDK, Go-бинарники с дефолтным crypto/tls).
Проверка результата
Быстрый способ убедиться, что SNI не утекает — `curl` с флагом `--trace` на клиенте и `tcpdump` на промежуточном хосте. В трассе видно, как ClientHello разбивается на два write. Если в дампе видите полный `server_name` в одном пакете — фрагментация не сработала, ищите, кто склеил.
```bash
curl -v --trace-ascii trace.log https://target.example/ 2>&1 | head -50
```
В `trace.log` ищите строки `=> Send data` — их должно быть минимум две перед получением ServerHello. Это косвенный признак, что фрагментация жива.