← Назад в базу знаний

Как TLS-фрагментация маскирует SNI при работе через прокси

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. Это косвенный признак, что фрагментация жива.

✔️Купить прокси