todo/scripts/wiki-anim-specs.py
loop-uh 911497ce90
Some checks failed
Published content check / validate (push) Failing after 7s
Xray: заметки сверены вторым кругом с кодом v26.11.9, добавлена схема-обзор в начало карты слоёв
В начале xray-core/vless-stack-map появилась схема «Что где лежит в конфиге»: протокол, транспорт и слой безопасности как три разных поля, flow и encryption внутри протокола VLESS, то, что слоем не является, и примеры связок.

Правки по итогам независимой сверки девяти заметок с кодом и первоисточниками:
- vless-stack-map: пара hysteria односторонняя (протоколу нужен транспорт, транспорту с auth протокол не нужен), у masque двусторонняя; Vision работает и на kcp с TLS, а на xdrive flow запрещён; при concurrency -1 TCP идёт мимо Mux, но xudpProxyUDP443 по умолчанию режет UDP/443; направление слоёв в таблице splice; история запрета VLESS без защиты и PR #6640 и #6741.
- vless-flow-mux-russia: слова «for now» добавил RPRX, а не M03ED; выводы вынесены из блока подтверждённого; добавлен код v2rayN, Happ и Throne; точнее цитаты и статусы.
- vless, xtls-vision, reality, vless-encryption, xhttp: убрана выдуманная строка ошибки для старых flow, исправлены оговорки про транспорты, FEC в mKCP, третье условие REALITY (X25519MLKEM768), SNI в XHTTP, USENIX про Vision, актуальность пре-релизов.
- components и changes-26-11-9: исправлены xray lua и ed25519, PR XDNS, blackhole, WireGuard, DNS и добавлены тихие поломки конфига (proxySettings, freedom и обратный прокси, version 2 у входящего hysteria и другие).
- Схема vless-encryption-layers перерисована: шифрование показано полем протокола VLESS, а не слоем.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-18 18:32:37 +03:00

562 lines
63 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

#!/usr/bin/env python3
"""Описания схем, заменяющих ASCII-блоки в заметках вне Zapret2/desync.
Подключается из wiki-anim.py: register(FIGS, hub, wrapped, B), где B — построители
chain, stack, seq, compare, fields из wiki-anim-more.py."""
def register(FIGS, hub, wrapped, B):
Fig = hub.Fig
chain, stack, seq, compare, fields = B["chain"], B["stack"], B["seq"], B["compare"], B["fields"]
def add(name, folder, fn):
FIGS[name] = (fn, folder)
# ═══ AmneziaWG 2.0 ═══════════════════════════════════════════════
add("awg-messages", "amnezia-2-0/attachments", lambda: fields(
"awg-messages", "Четыре сообщения AmneziaWG: размеры полей по масштабу",
"Handshake Initiation 148 байт, Handshake Response 92 байта, Cookie Reply 64 байта и Transport от 16 байт. Ширина поля пропорциональна его размеру в байтах; "
"первое поле каждого сообщения — тип, в котором стоит магический заголовок H1, H2, H3 или H4.",
[("Handshake Initiation", [("Type · H1", 4, ""), ("Sender", 4, ""), ("Ephemeral", 32, ""), ("Static: 32 + тег 16", 48, ""),
("Timestamp: 12 + тег 16", 28, ""), ("MAC1", 16, ""), ("MAC2", 16, "")], "148 байт"),
("Handshake Response", [("Type · H2", 4, ""), ("Sender", 4, ""), ("Receiver", 4, ""), ("Ephemeral", 32, ""), ("Empty: тег", 16, ""),
("MAC1", 16, ""), ("MAC2", 16, "")], "92 байта"),
("Cookie Reply", [("Type · H3", 4, ""), ("Receiver", 4, ""), ("Nonce", 24, ""), ("Cookie: 16 + тег 16", 32, "")], "64 байта"),
("Transport", [("Type · H4", 4, ""), ("Receiver", 4, ""), ("Counter", 8, ""), ("Ciphertext + тег Poly1305 16", (60, "переменный"), "")], "от 16 байт")],
"amnezia-2-0/attachments", foot="Числа внутри полей — размер в байтах. Перед сообщением может стоять S1, S2, S3 или S4 случайных байт."))
def awg_handshake():
f = Fig("awg-handshake", 452, 16, "Что уходит в сеть при handshake и передаче данных в AmneziaWG 2.0",
"Init: сигнатурные пакеты i1–i5, затем Jc мусорных пакетов, затем сообщение Init с префиксом S1; всё одним вызовом SendBuffers. "
"Response: префикс S2 и 92 байта. Cookie Reply под нагрузкой: S3 и 64 байта. Transport: S4, заголовок 16 байт, шифртекст и тег; у keepalive S4 не применяется.")
rows = [("Init", "каждые ~2 минуты", [("i1", 44), ("i2", 44), ("i3", 44), ("i4", 44), ("i5", 44), ("Junk × Jc", 110), ("S1 random", 90), ("Init · 148 Б", 120)], "всё одним вызовом peer.SendBuffers"),
("Response", "ответ на Init", [("S2 random", 100), ("Response · 92 Б", 150)], "i1–i5 и junk с Response не отправляются"),
("Cookie Reply", "под нагрузкой", [("S3 random", 100), ("Cookie · 64 Б", 140)], "уходит напрямую, не через peer queue"),
("Transport", "данные", [("S4 random", 100), ("заголовок 16 Б", 150), ("шифртекст", 170), ("тег 16 Б", 90)], "у keepalive S4 не применяется")]
for r, (name, sub, chips, note) in enumerate(rows):
y = 20 + r * 102
t0 = 0.4 + r * 3.4
f.g(f.text(2, y + 18, name, "tk") + f.text(2, y + 38, sub, "mu sm"), f.vis(t0, fade=0.3))
x = 160
for k, (lab, w) in enumerate(chips):
t = t0 + 0.3 + k * 0.3
kind = "bxd" if ("random" in lab or lab.startswith("Junk") or lab.startswith("i")) else "bxa"
f.g(f.chip(x + w / 2, y + 28, w - 6, 40, lab, kind, "mk sm"), f.go([(0, -16, 0, 0), (t, -16, 0, 0), (t + 0.15, -16, 0, 1), (t + 0.5, 0, 0, 1)]))
x += w
f.g(f.text(160, y + 72, note, "mu sm"), f.vis(t0 + 1.8, fade=0.3))
f.g(f.text(2, 436, "Пунктирные блоки — маскировка (случайные байты и мусор), сплошные — настоящие сообщения WireGuard.", "mu sm"), f.vis(13.6))
return f
add("awg-handshake", "amnezia-2-0/attachments", awg_handshake)
add("awg2-wire", "amnezia-2-0/attachments", lambda: fields(
"awg2-wire", "Transport-пакет AmneziaWG 2.0 на проводе",
"Пакет состоит из S4 случайных байт, заголовка WireGuard Transport в 16 байт (H4, получатель, nonce), зашифрованной нагрузки с выравниванием и тега Poly1305 16 байт.",
[("Итоговый пакет", [("S4 random", (50, "S4")), ("H4 + recv + nonce: заголовок", (16, "16")), ("encrypted(payload + выравнивание)", (60, "перем.")), ("Poly1305", (16, "16"))], "S4 + 16 + payload + 16")],
"amnezia-2-0/attachments", foot="Заголовок записывается в LittleEndian; сдвиг на S4 байт делается, только если пакет не keepalive."))
add("awg3-wire", "amnezia-3-0/attachments", lambda: fields(
"awg3-wire", "Пакеты AmneziaWG 3.0 на проводе: nonce и псевдослучайность",
"В 3.0 пакет открывается 12 байтами nonce, остаток префикса S случайный, а заголовок и сообщение зашифрованы ChaCha20: на проводе сплошная псевдослучайность. "
"Размер Init всегда S1 + 148 байт для данной конфигурации.",
[("Transport", [("nonce", (12, "12")), ("остаток S4 (S4−12)", (30, "S4−12")), ("заголовок, ChaCha20: тип · получатель · счётчик", (16, "16")), ("шифртекст + content padding", (60, "перем.")), ("Poly1305", (16, "16"))], ""),
("Init", [("nonce", (12, "12")), ("остаток S1 (S1−12)", (30, "S1−12")), ("148 Б сообщения, зашифровано целиком", (110, "148"))], "S1 + 148 байт")],
"amnezia-3-0/attachments"))
# ═══ Локальный трекинг и SOCKS5 ═══════════════════════════════════
def loopback():
f = Fig("loopback", 320, 11, "127.0.0.1 общий для всех процессов устройства",
"Яндекс, шпионское приложение и браузер обращаются к одному и тому же 127.0.0.1. Этот адрес общий для всех процессов, не маршрутизируется через VPN или TUN, "
"не изолирован между профилями и не требует специальных разрешений.")
apps = [("Приложение A", "Яндекс"), ("Приложение B", "шпион"), ("Браузер", "Chrome")]
for k, (a, b) in enumerate(apps):
x = 40 + k * 300
t = 0.4 + k * 0.7
f.g(f.rect(x, 20, 220, 62, "bxr" if k == 1 else "bx", rx=8) + f.text(x + 110, 48, a, ("rej tk c sm" if k == 1 else "tk c sm")) + f.text(x + 110, 68, b, "mu sm c") +
f.arrow(x + 110, 86, x + 110, 124, "r" if k == 1 else "f"), f.vis(t, dy=-8))
f.g(f.rect(20, 128, 920, 120, "bxa", rx=10) + f.text(480, 156, "127.0.0.1 (loopback)", "tk c") +
f.text(60, 190, "общий для всех процессов устройства", "t sm") + f.text(60, 214, "не маршрутизируется через VPN или TUN", "t sm") +
f.text(500, 190, "не изолирован между профилями", "t sm") + f.text(500, 214, "не требует специальных разрешений", "t sm"), f.vis(3.0))
f.g(f.text(2, 284, "Любое приложение может постучаться на порт другого приложения и получить ответ.", "tk sm"), f.vis(5.0))
return f
add("loopback", "attachments", loopback)
add("yandex-metrica", "attachments", lambda: seq(
"yandex-metrica", "Яндекс.Метрика: браузер узнаёт идентификаторы у приложения по localhost",
"JavaScript Яндекс.Метрики в браузере обращается по HTTP на локальные порты 29009 и 30102 (HTTPS — 29010 и 30103), где слушает SDK Метрики в нативном приложении Яндекса. "
"Приложение отвечает 200 OK с AAID и зашифрованными ID, а браузер отправляет их на mc.yango.com.",
[("Браузер", "Яндекс.Метрика JS"), ("Приложение Яндекса", "SDK Метрики слушает порты"), ("mc.yango.com", "сервер Яндекса")],
[(0, 1, "HTTP на localhost", "порты 29009, 30102 (HTTP) и 29010, 30103 (HTTPS)", "a"),
(1, 0, "200 OK + идентификаторы", "AAID и зашифрованные ID", "r"),
(0, 2, "отправляет ID", "связка веб-сессии с идентификатором устройства", "r")],
"attachments", aw=210))
add("meta-pixel", "attachments", lambda: seq(
"meta-pixel", "Meta Pixel: веб-сессия связывается с устройством и аккаунтом через localhost",
"Meta Pixel в браузере кладёт значение cookie _fbp в поле ice-ufrag (SDP Munging) и шлёт STUN-запрос на порты 12580–12585 фонового сервиса Facebook или Instagram. "
"Приложение получает _fbp и отправляет в graph.facebook.com GraphQL-запрос с _fbp, Device ID и Facebook Account ID; сам браузер шлёт _fbp на facebook.com/tr.",
[("Браузер", "Meta Pixel JS"), ("Facebook / Instagram", "фоновый сервис в приложении"), ("Серверы Meta", "серверы facebook.com")],
[(0, 1, "WebRTC STUN: ice-ufrag = _fbp", "SDP Munging; TCP 12387, 12388; UDP 12580–12585 (STUN), 12586–12591 (TURN)", "a"),
(0, 2, "_fbp + URL, событие, метаданные", "браузер шлёт на facebook.com/tr", "f"),
(1, 2, "GraphQL: _fbp + Device ID + Account ID", "graph.facebook.com/graphql", "r")],
"attachments", foot="Итог: веб-сессия, устройство и аккаунт Facebook оказываются связаны.", aw=220))
add("socks5-spy", "attachments", lambda: chain(
"socks5-spy", "Как шпионский модуль получает выходной IP через открытый SOCKS5",
"Модуль в приложении сканирует порты localhost, находит SOCKS5 без аутентификации на 127.0.0.1:10808, проводит handshake с методом 0x00, открывает CONNECT на ifconfig.me:80 "
"и получает ответ с выходным IP VPN-сервера.",
[("Шпионский модуль в приложении", "Яндекс, WB, Ozon, государственное приложение"),
("127.0.0.1:10808", "1. сканирование портов localhost занимает секунды; xray-core inbound, SOCKS5 без аутентификации"),
("xray-core outbound", "2. SOCKS5 handshake: method 0x00, NO AUTH. 3. CONNECT ifconfig.me:80"),
("VPN-сервер → ifconfig.me", "ответ: «185.xxx.xxx.xxx»"),
("Шпион получает выходной IP", "4. выходной адрес VPN раскрыт")],
"attachments", vertical=True, warn=(4,)))
def socks5_bypass():
f = Fig("socks5-bypass", 330, 14, "Шпион идёт мимо VpnService, поэтому per-app split tunneling не помогает",
"Обычное приложение проходит VpnService, tun2socks и SOCKS5 xray до VPN-сервера и интернета. Шпион обращается прямо на 127.0.0.1:10808 минуя VpnService, "
"поэтому исключение приложений из туннеля его не останавливает.")
steps = [("Приложение", "обычное"), ("VpnService", "Android, TUN"), ("tun2socks", "TUN → SOCKS"), ("SOCKS5 xray", "localhost:10808"), ("VPN-сервер", "VLESS/Trojan/SS"), ("Интернет", "freedom")]
W = 134
f.add(f.text(2, 26, "обычный путь трафика", "cap"))
for k, (a, b) in enumerate(steps):
x = 2 + k * (W + 30)
t = 0.4 + k * 0.7
kind = "bxa" if k == 3 else "bx"
f.g(f.rect(x, 40, W, 70, kind, rx=8) + f.text(x + W / 2, 70, a, "tk c sm") + f.text(x + W / 2, 92, b, "mu sm c") + (f.arrow(x + W + 4, 75, x + W + 26, 75, "f") if k < 5 else ""), f.vis(t, dy=8))
x3 = 2 + 3 * (W + 30) + W / 2
f.add(f.text(2, 168, "путь шпиона", "cap"))
f.g(f.rect(2, 184, W, 70, "bxr", rx=8) + f.text(2 + W / 2, 214, "Шпион", "rej tk c sm") + f.text(2 + W / 2, 236, "приложение", "mu sm c"), f.vis(6.0, dy=8))
f.g(f'<path class="{f.c("sl-r")}" d="M{2 + W + 4} 219H{x3}V{114}"/>' + f.head(x3, 114, -1.5708, "r") + f.text(300, 210, "прямо на 127.0.0.1:10808, минуя VpnService", "rej tk sm"), f.vis(7.0))
f.g(f.text(2, 312, "Исключение приложений из VPN на уровне VpnService шпиона не останавливает: он ходит на localhost.", "tk sm"), f.vis(10.0))
return f
add("socks5-bypass", "attachments", socks5_bypass)
add("grpc-chain", "attachments", lambda: chain(
"grpc-chain", "Цепочка атаки через открытый gRPC API прокси-ядра",
"Шпион сканирует порты, находит gRPC API без авторизации, через ReflectionService узнаёт список методов, через HandlerService выгружает конфиг outbound и получает ключ шифрования, "
"IP сервера и SNI; вместе со второй уязвимостью конфигурации это позволяет расшифровать трафик.",
[("Шпион", "сканирует порты"), ("gRPC API", "без аутентификации"), ("ReflectionService", "список методов"), ("HandlerService", "дамп outbound-конфига"),
("Ключ, IP сервера, SNI", "+ вторая уязвимость → расшифровка трафика")],
"attachments", warn=(4,)))
add("uid-isolation", "attachments", lambda: compare(
"uid-isolation", "Пароль на localhost защищён изоляцией процессов Android",
"VPN-клиент с UID 10150 подключается к 127.0.0.1:10808 с паролем открытым текстом, но данные видит только ядро и этот UID. Шпион с UID 10200 может сделать connect к порту, "
"но ему нужен пароль, а читать чужой сокет он не может.",
("VPN-клиент (UID 10150)", ["TCP → 127.0.0.1:10808", "«user=abc pass=xyz» — открытым текстом", "ядро: только UID 10150 видит эти данные"]),
("Шпион (UID 10200)", ["connect() к :10808 проходит, но нужен пароль — отказ", "read() чужого сокета невозможен"]),
"attachments", lk="bxa", rk="bxr"))
add("android-localhost", "attachments", lambda: compare(
"android-localhost", "Без root блокировщики не видят localhost",
"Приложение A обращается на 127.0.0.1:10808 к xray или sing-box: это localhost, он не проходит через VPN API. NetGuard и RethinkDNS как VPN перехватывают только реальные интерфейсы "
"eth0, wlan0 и rmnet0, поэтому трафик приложения B к google.com они видят, а локальные обращения нет.",
("Приложение A → 127.0.0.1:10808", ["это localhost: не проходит через VPN API", "блокировщики локальный трафик не видят"]),
("Приложение B → google.com", ["VPN перехватывает: eth0, wlan0, rmnet0", "NetGuard и RethinkDNS видят только реальные интерфейсы"]),
"attachments", lk="bxr", rk="bxa"))
add("own-socks5", "attachments", lambda: compare(
"own-socks5", "Где включать пароль, если вы не владелец подписки",
"Сервер VLESS Reality принадлежит владельцу подписки, и вы его не контролируете. Локальный SOCKS5 inbound на localhost:10808 находится на вашем устройстве: именно там вы меняете настройку auth: password.",
("Сервер (владелец подписки)", ["VLESS Reality inbound", "вы его не контролируете"]),
("Ваше устройство (вы контролируете)", ["xray outbound (VLESS) — туннель к серверу", "SOCKS5 inbound localhost:10808 — ваш", "auth: password — менять здесь"]),
"attachments", lk="bx", rk="bxa"))
# ═══ DPI и протоколы ══════════════════════════════════════════════
add("olcrtc-chain", "DPI/attachments", lambda: chain(
"olcrtc-chain", "Как olcrtc прячет трафик в звонок WebRTC",
"Приложение отправляет трафик в SOCKS5 на 127.0.0.1:8808, клиент olcrtc cnc передаёт его через WebRTC и SFU-сервис вроде Jitsi, Телемоста или WbStream на сервер olcrtc srv, который выходит в интернет.",
[("Приложение", ""), ("SOCKS5", "127.0.0.1:8808"), ("olcrtc cnc", "клиент"), ("WebRTC / SFU", "Jitsi, Телемост, WbStream"), ("olcrtc srv", "сервер"), ("Интернет", "")],
"DPI/attachments", accent=(3,)))
add("telegram-wss-stack", "mtproxy/attachments", lambda: stack(
"telegram-wss-stack", "Из каких слоёв состоит соединение Telegram по WebSocket",
"Соединение открывается на TCP 443 к адресу релея, поверх идёт настоящий TLS с именем сервера kwsN.web.telegram.org, затем HTTP/1.1 Upgrade до WebSocket, бинарные кадры, "
"obfuscated2 с шифром AES-256-CTR и внутри MTProto с шифрованием ключом авторизации.",
[("TCP :443", "соединение с адресом релея"), ("TLS 1.2+", "настоящий TLS, имя сервера kwsN.web.telegram.org"), ("HTTP/1.1 Upgrade", "GET /apiws → 101 Switching Protocols"),
("кадры WebSocket", "бинарные, каждый замаскирован клиентом"), ("obfuscated2", "64-байтный заголовок и шифр AES-256-CTR"), ("MTProto", "шифрование клиент ↔ Telegram ключом авторизации")],
"mtproxy/attachments"))
add("vless-encryption-layers", "xray/attachments", lambda: chain(
"vless-encryption-layers", "VLESS Encryption — шифрование внутри протокола VLESS",
"Приложение со своим TLS до сайта передаёт данные протоколу VLESS. Поле encryption включает собственное шифрование протокола: оно закрывает и заголовок VLESS (версия, UUID, адрес назначения), "
"и данные ещё до того, как они попадут в транспорт и слой безопасности.",
[("приложение", "браузер, его собственный TLS до сайта"), ("протокол VLESS", "заголовок: версия, UUID, адрес назначения"), ("поле encryption", "шифрует заголовок и данные внутри протокола"),
("транспорт", "поле method: raw, xhttp, ws, grpc, kcp и другие"), ("слой безопасности", "поле security: tls, reality или none")],
"xray/attachments", vertical=True, accent=(2,)))
add("xray-lineage", "xray/attachments", lambda: chain(
"xray-lineage", "От Shadowsocks до Xray: родословная",
"Shadowsocks 2012 года стал идейным предшественником V2Ray 2015 года, который написан с нуля. После исчезновения автора V2Ray продолжило сообщество как v2fly в 2020, "
"а в ноябре 2020 из-за лицензионного спора об XTLS от коммита 9a03cc5 отделился Xray-core с VLESS, XTLS-Vision, REALITY и XHTTP.",
[("Shadowsocks", "2012, clowwindy"), ("V2Ray / Project V", "2015, написан с нуля"), ("v2fly/v2ray-core", "2020, сообщество; сегодня это «V2Ray»"), ("XTLS/Xray-core", "2020, RPRX; VLESS, Vision, REALITY, XHTTP")],
"xray/attachments", edges={0: "идейный преемник, не форк", 1: "форк кода, 2019", 2: "форк от 9a03cc5, ноябрь 2020"}, accent=(3,)))
add("vless-flow-chain", "xray/attachments", lambda: chain(
"vless-flow-chain", "Зачем в ноябре 2025 советовали убрать flow",
"В ноябре 2025 у части провайдеров соединения замирали при большом числе TLS-соединений к одному адресу. Mux.Cool сокращает число соединений, но для TCP он несовместим с Vision, "
"поэтому совет включал пустой flow. Отдельной проверки одного лишь отказа от flow нет, а эффект помогал не всем и недолго.",
[("блокировка", "замирание при многих TLS-соединениях к адресу"), ("Mux.Cool", "поле mux исходящего: потоки в одном соединении"),
("несовместим с Vision", "TCP внутри Mux: сервер рвёт всё соединение"), ("flow пустой", "условие для Mux, а не отдельное средство")],
"xray/attachments", vertical=True, accent=(3,)))
add("dpi-funnel", "DPI/attachments", lambda: chain(
"dpi-funnel", "Анализ трафика идёт воронкой: чем дальше, тем дороже",
"DPI проверяет поток по ступеням: первые пакеты дают отпечаток ОС, первые байты — протокольный маркер, ClientHello — JA3 и JA4, далее сертификат, метаанализ потока и после 16 КБ "
"поведенческий ML-классификатор. Итог — пропустить, RST, drop или throttle.",
[("пакеты 1–5 (TCP/IP)", "TTL, TCP-опции (MSS/WS/SACK/TS) → отпечаток ОС"), ("байты 0–5 (сигнатура)", "протокольный маркер: 16 03 01… / SSH-2.0- / …"),
("байты 6–300 (TLS hello)", "ClientHello → JA3 / JA4, фингерпринт клиента"), ("байты 300–3000", "сертификат: CT-логи, ASN, CN/SAN ↔ SNI; в TLS 1.3 он шифруется, остаются SNI и ASN"),
("байты 3000–16000", "метаанализ потока: размеры, тайминги, соотношение in/out, длительность"), ("после 16 КБ", "поведенческий ML-классификатор"),
("вердикт", "пропустить, RST, drop или throttle")],
"DPI/attachments", vertical=True, accent=(6,), lw=300))
add("faketls-handshake", "Zapret/attachments", lambda: seq(
"faketls-handshake", "FakeTLS handshake в MTProxy: клиент и сервер изображают обычный TLS",
"Клиент отправляет фейковый TLS ClientHello на 517 байт с SNI из секрета и HMAC-SHA256 в поле Random. Сервер отвечает фейковым ServerHello и ChangeCipherSpec, копируя размер ответа реального сертификата. "
"Дальше идут записи Application Data с зашифрованным MTProto до 16408 байт.",
[("Клиент", "Telegram"), ("Сервер", "MTProxy")],
[(0, 1, "Фейковый TLS ClientHello, 517 байт", "SNI — домен из секрета (например, google.com); Random содержит HMAC-SHA256 для проверки секрета", "a"),
(1, 0, "Фейковый ServerHello + ChangeCipherSpec", "имитирует ответ реального TLS-сервера; размер ответа копирует настоящий сертификат домена", "f"),
(0, 1, "Application Data, тип 0x17", "внутри зашифрованный MTProto; максимальный размер записи 16408 байт", "a")],
"Zapret/attachments", aw=180))
add("zig-wire", "mtproxy/attachments", lambda: seq(
"zig-wire", "Что происходит на проводе: карта защит mtproto.zig",
"ClientHello несёт почерк клиента, ТСПУ снимает отпечаток, сервер тоже пишет его в лог. ServerHello сервер дробит desync. Затем идёт 64-байтный MTProto-хендшейк, и если соединение живо, сервер проксирует его в DC.",
[("Клиент", "Telegram"), ("ТСПУ", "наблюдатель"), ("Сервер", "mtproto.zig")],
[(0, 1, "ClientHello (почерк!)", "ТСПУ снимает фингерпринт; здесь же и блокировка", "r"),
(1, 2, "ClientHello", "сервер снимает fp в лог", "f"),
(2, 0, "ServerHello, дроблёный desync", "защиты: mask, desync, drs", "a"),
(0, 2, "64-байтный MTProto-хендшейк", "если соединение живо: proxy → DC", "a")],
"mtproxy/attachments", aw=170))
add("ja4-sni-order", "mtproxy/attachments", lambda: chain(
"ja4-sni-order", "Почему JA4 и SNI меняются только на стороне клиента",
"Telegram сам генерирует ClientHello с JA4 и SNI, цензор видит этот почерк, и только после этого пакет приходит на сервер-прокси, который ничего изменить уже не может.",
[("Telegram", "генерирует ClientHello: JA4 + SNI"), ("Цензор", "видит почерк"), ("Сервер-прокси", "пакет приходит уже после цензора")],
"mtproxy/attachments", warn=(1,)))
add("ja4-parts", "DPI/attachments", lambda: fields(
"ja4-parts", "Как читается JA4: t13d1516h2",
"t — транспорт TCP, 13 — версия TLS 1.3, d — SNI присутствует, 15 — число шифров, 16 — число расширений, h2 — ALPN HTTP/2.",
[("t13d1516h2", [("транспорт: TCP", (10, "t")), ("версия TLS: 1.3", (14, "13")), ("SNI есть (d = domain)", (10, "d")), ("шифров: 15", (14, "15")), ("расширений: 16", (14, "16")), ("ALPN: http/2", (14, "h2"))], "")],
"DPI/attachments", W=640))
def nginx_split():
f = Fig("nginx-split", 330, 10, "nginx stream разводит трафик по SNI: сайт отдельно, MTProto отдельно",
"Порт 443 принимает nginx stream или haproxy на уровне L4 с ssl_preread. Если SNI равен example.com, соединение уходит на настоящий HTTPS-сайт на 127.0.0.1:8443; "
"если SNI пустой или неизвестный (iOS, Android, Desktop), на MTProto Proxy с FakeTLS на 127.0.0.1:2443.")
f.add(f.rect(280, 8, 400, 66, "bxa") + f.text(480, 34, "порт 443 → nginx stream / haproxy", "tk c") + f.text(480, 56, "L4 TCP: ssl_preread / inspect", "mu sm c"))
for k, (x, sni, sub, dest, d2, kind) in enumerate([(30, "SNI = example.com", "", "127.0.0.1:8443", "Nginx HTTPS: реальный сайт", "bx"),
(500, "SNI пустой или неизвестный", "iOS, Android, Desktop", "127.0.0.1:2443", "MTProto Proxy (FakeTLS)", "bxa")]):
t = 1.0 + k * 2.2
f.g(f.arrow(480, 78, x + 210, 130, "f"), f.vis(t, fade=0.2))
f.g(f.rect(x, 134, 420, 58, "bx", rx=8) + f.text(x + 14, 160, sni, "tk sm") + f.text(x + 14, 180, sub, "mu sm"), f.vis(t + 0.3))
f.g(f.arrow(x + 210, 196, x + 210, 226, "a" if k else "f"), f.vis(t + 0.8, fade=0.2))
f.g(f.rect(x, 230, 420, 62, kind, rx=8) + f.text(x + 14, 256, dest, "mk sm") + f.text(x + 14, 278, d2, "tk sm"), f.vis(t + 1.1))
return f
add("nginx-split", "Zapret/attachments", nginx_split)
add("asn-match", "Zapret/attachments", lambda: compare(
"asn-match", "SNI и IP сервера должны принадлежать одному ASN",
"Плохо: VPS в сети Hetzner (AS24940), а SNI указывает на www.google.com (AS15169): ASN не совпадают, это подозрительно. Хорошо: SNI на другом сайте в Hetzner (AS24940): один ASN выглядит как обычный shared hosting.",
("Плохо", ["VPS IP: 167.235.x.x (Hetzner, AS24940)", "SNI: www.google.com (AS15169)", "ASN не совпадают — подозрительно"]),
("Хорошо", ["VPS IP: 167.235.x.x (Hetzner, AS24940)", "SNI: some-site.de (тоже Hetzner, AS24940)", "один ASN — нормально, shared hosting"]),
"Zapret/attachments"))
add("bot-apply", "Zapret/attachments", lambda: compare(
"bot-apply", "Как бот меняет секреты прокси: сейчас и в цели",
"Сейчас бот по SSH дописывает секрет в secrets.conf и перезапускает mtproxy. Цель — отправлять HTTP POST на /v1/users, и telemt применяет пользователя на лету без перезапуска.",
("Сейчас", ["Бот → SSH", "echo secret >> secrets.conf", "systemctl restart mtproxy"]),
("Цель", ["Бот → HTTP POST /v1/users", "telemt применяет на лету", "перезапуск не нужен"]),
"Zapret/attachments"))
add("wf-pipeline", "Zapret2/attachments", lambda: chain(
"wf-pipeline", "Порядок фильтрации: сначала WinDivert, потом фильтры nfqws",
"Все пакеты сетевого стека сначала проходят фильтр WinDivert --wf-* на уровне драйвера: остальные идут мимо nfqws напрямую в сеть. Захваченные пакеты проходят фильтры nfqws по портам, IP и доменам, и к ним применяются desync-действия.",
[("Сетевой стек", "все пакеты"), ("1. WinDivert-фильтр --wf-*", "уровень драйвера; остальные пакеты идут мимо nfqws напрямую в сеть"),
("2. --filter-tcp/udp", "фильтр по портам"), ("3. --ipset", "фильтр по IP"), ("4. --hostlist", "фильтр по доменам (из payload)"), ("5. desync actions", "применение обхода DPI")],
"Zapret2/attachments", vertical=True, accent=(5,)))
def mtproto_conntrack():
f = Fig("mtproto-conntrack", 330, 14, "Как распознаётся MTProto: протокол запоминается, тип пакета нет",
"Первые три пакета TCP не несут данных. Первый пакет с данными даёт payload mtproto_initial и протокол MTProto. Последующие пакеты выглядят как зашифрованный мусор, payload у них unknown, "
"но протокол потока MTProto уже сохранён в conntrack.")
pk = [("SYN", "empty", "bx"), ("SYN+ACK", "empty", "bx"), ("ACK", "empty", "bx"), ("DATA #1", "mtproto_initial", "bxa"), ("DATA #2", "unknown", "bx"), ("DATA #3", "unknown", "bx")]
f.add(f.arrow(2, 40, 950, 40, "f"))
f.add(f.text(2, 28, "время", "cap"))
for k, (a, b, kind) in enumerate(pk):
x = 76 + k * 150
t = 0.5 + k * 1.0
f.g(f.chip(x, 90, 110, 40, a, kind, "mk sm") + f.text(x, 134, "payload=", "mu sm c") + f.text(x, 154, b, "tk sm c" if b != "empty" else "mu sm c"), f.go([(0, -20, 0, 0), (t, -20, 0, 0), (t + 0.15, -20, 0, 1), (t + 0.5, 0, 0, 1)]))
f.g(f.line(76 + 3 * 150 - 60, 176, 76 + 3 * 150 - 60, 196, "la") + f.text(76 + 3 * 150, 196, "proto = mtproto: определён и сохранён", "acc tk sm") +
f.text(76 + 3 * 150, 218, "seq_last − seq0 = 1", "m mu sm"), f.vis(6.2))
f.g(f.text(76 + 4 * 150 - 60, 250, "payload = unknown,", "rej tk sm") + f.text(76 + 4 * 150 - 60, 270, "proto = mtproto (сохранён)", "mu sm") + f.text(76 + 4 * 150 - 60, 290, "seq_last − seq0 > 1", "m mu sm"), f.vis(8.0))
f.g(f.text(2, 316, "Поэтому desync нужен именно на пакете mtproto_initial: дальше он выглядит как мусор.", "tk sm"), f.vis(10.0))
return f
add("mtproto-conntrack", "Zapret2/attachments", mtproto_conntrack)
add("mtproto-l7-cache", "Zapret2/attachments", lambda: compare(
"mtproto-l7-cache", "Conntrack запоминает протокол: на втором пакете детекция не нужна",
"На первом пакете mtproto_initial conntrack-запись по ip:port имеет l7proto UNKNOWN, срабатывает IsMTProto() и сохраняется l7proto = MTPROTO. На втором пакете, зашифрованном мусоре, l7proto уже MTPROTO, детекция не нужна.",
("Пакет 1 (mtproto_initial)", ["conntrack lookup по (ip:port)", "ctrack->l7proto = UNKNOWN", "детекция: IsMTProto() = true", "сохранение: ctrack->l7proto = MTPROTO"]),
("Пакет 2 (зашифрованный мусор)", ["conntrack lookup по (ip:port)", "ctrack->l7proto = MTPROTO — уже!", "детекция не нужна", "l7proto = MTPROTO"]),
"Zapret2/attachments", lk="bx", rk="bxa"))
add("dpi-tls-gates", "VLESS/attachments", lambda: chain(
"dpi-tls-gates", "Правило срабатывает, только если выполнены все три условия",
"TLS-соединение попадает под заморозку на 120 секунд, если подсеть сервера в списке, фингерпринт подозрительный и к одному SNI больше трёх соединений за короткое время. Достаточно разорвать любое одно звено.",
[("подсеть в списке?", "Selectel, Яндекс.Облако…"), ("фингерпринт подозрительный?", "Chrome, Safari, iOS"), (">3 соединений на SNI", "интервал меньше ~350–400 мс, за 60 с"), ("заморозка", "120 секунд")],
"VLESS/attachments", edges={0: "И", 1: "И", 2: "→"}, warn=(3,), foot="Разорвите любое одно звено — правило на вас не сработает."))
add("tls-in-tls", "VLESS/attachments", lambda: stack(
"tls-in-tls", "«TLS в TLS»: два вложенных соединения",
"Внешний TLS или REALITY-туннель идёт от вас к вашему VPS, а внутри него идёт внутренний TLS от браузера до google.com; эта вложенность и называется TLS в TLS.",
[("внешний TLS / REALITY-туннель", "вы ↔ ваш VPS"), ("внутренний TLS", "браузер ↔ google.com: это и есть «TLS в TLS»")],
"VLESS/attachments", accent=(1,)))
def mux():
f = Fig("mux", 250, 9, "Mux: одно внешнее TLS-соединение несёт несколько подпотоков",
"Внутри одного внешнего TLS-соединения идут подпотоки к разным сайтам, у каждого внутри свой TLS. Снаружи цензор видит только одно соединение.")
f.add(f.rect(2, 10, 940, 220, "bxa", rx=12) + f.text(18, 38, "ОДНО внешнее TLS-соединение", "tk"))
for k, s in enumerate(["подпоток 1 → сайт A", "подпоток 2 → сайт B", "подпоток 3 → сайт C"]):
y = 64 + k * 54
f.g(f.rect(40, y, 560, 40, "bx", rx=8) + f.text(56, y + 25, s, "tk sm") + f.text(620, y + 25, "внутри свой TLS", "mu sm"), f.vis(0.6 + k * 0.9, dx=-10))
return f
add("mux", "VLESS/attachments", mux)
# ═══ Списки: hostlist и ipset (Zapret/hostlist, Zapret/ipset, Zapret2/filter) ═══
# Правила сверены с zapret2 nfq2/hostlist.c (SearchHostList, HostlistCheck_),
# nfq2/ipset.c (IpsetCheck_) и nfq2/desync.c (dp_match), ноябрь 2026.
def hostlist_walk():
f = Fig("hostlist-walk", 470, 20, "Как движок ищет сайт в списке: от точного имени к общему",
"Движок проверяет сам домен, затем родителей по очереди. Решает первая найденная запись: обычная — сайт в списке, "
"с восклицательным знаком — сайт не в этом списке, запись с крышкой на родительском уровне пропускается.")
lines = ["ru", "!torrents.ru", "^vk.com"]
f.add(f.text(2, 30, "файл списка", "cap"))
f.add(f.rect(2, 44, 250, 160, "bx", rx=10))
for k, ln in enumerate(lines):
f.add(f.text(24, 84 + k * 44, ln, "mk"))
f.add(f.text(300, 30, "сайт и шаги поиска", "cap"))
scen = [
("mail.ru", [("mail.ru", "записи нет — дальше", "mu", None), ("ru", "запись «ru» — сайт в списке", "acc", 0)],
"mail.ru в списке: его поймала запись «ru»", "acc"),
("www.torrents.ru", [("www.torrents.ru", "записи нет — дальше", "mu", None),
("torrents.ru", "«!torrents.ru» — исключение, поиск окончен", "rej", 1)],
"не в этом списке: «!torrents.ru» найдено раньше, чем «ru»", "rej"),
("m.vk.com", [("m.vk.com", "записи нет — дальше", "mu", None), ("vk.com", "«^vk.com» ловит только сам vk.com — дальше", "mu", 2),
("com", "записи нет — поиск окончен", "mu", None)],
"не в списке: «^» не распространяется на поддомены", "rej"),
("vk.com", [("vk.com", "«^vk.com» — точное совпадение", "acc", 2)],
"vk.com в списке: для самого домена «^» совпадает", "acc"),
]
for si, (host, steps, verdict, tone) in enumerate(scen):
t0 = 0.4 + si * 4.8
t1 = t0 + 4.5
f.g(f.chip(470, 66, 260, 34, host, "bxa", "mk sm"), f.vis(t0, t1))
for k, (name, what, cls, line) in enumerate(steps):
t = t0 + 0.6 + k * 0.9
y = 108 + k * 60
f.g(f.rect(300, y, 650, 48, "bx" if cls == "mu" else ("bxa" if cls == "acc" else "bxr"), rx=8)
+ f.text(318, y + 30, name, "mk sm") + f.text(520, y + 30, what, (cls + " sm") if cls != "mu" else "t sm"),
f.vis(t, t1, dx=-10, fade=0.25))
if line is not None:
f.g(f.rect(8, 58 + line * 44, 238, 38, "bxa" if cls != "rej" else "bxr", rx=6), f.vis(t, t1, fade=0.25))
f.g(f.text(300, 312, verdict, tone + " tk"), f.vis(t0 + 0.8 + len(steps) * 0.9, t1))
f.g(wrapped(f, 2, 360, "Порядок строк в файле не важен: «!torrents.ru» сильнее «ru», потому что поиск идёт от точного имени к общему "
"и упирается в исключение раньше.", "t", 92), f.vis(0.2))
f.g(f.text(2, 440, "Пример из описания автора движка: «ru» и «!torrents.ru» — все сайты .ru, кроме torrents.ru.", "mu sm"), f.vis(0.2))
return f
add("hostlist-walk", "Zapret/attachments", hostlist_walk)
def hostlist_layers():
f = Fig("hostlist-layers", 440, 13, "Ваши записи идут первыми — поэтому они перебивают встроенные",
"Программа собирает итоговый файл списка: сначала строки пользователя из lists/user, затем встроенные из lists/base. "
"Домен в одном файле учитывается один раз, по первой записи, поэтому повтор встроенной строки отбрасывается вместе с префиксом.")
user = ["!youtube.com", "^vk.com"]
base = ["youtube.com", "vk.com", "ru"]
f.add(f.text(2, 30, "ваши записи · lists/user", "cap"))
f.add(f.text(2, 200, "встроенные · lists/base", "cap"))
f.add(f.text(560, 30, "итоговый файл для движка", "cap"))
f.add(f.rect(2, 44, 300, 110, "bx", rx=10) + f.rect(2, 214, 300, 150, "bx", rx=10) + f.rect(560, 44, 396, 320, "bx", rx=10))
for k, s in enumerate(user):
f.add(f.text(22, 84 + k * 44, s, "mk"))
for k, s in enumerate(base):
f.add(f.text(22, 254 + k * 44, s, "mk"))
order = [(s, "acc", "ваша запись — работает") for s in user] + [
("youtube.com", "rej", "повтор — отброшен"), ("vk.com", "rej", "повтор — отброшен"), ("ru", "t", "новый — работает")]
for k, (s, cls, note) in enumerate(order):
y = 84 + k * 52
t = 0.8 + k * 1.3
f.g(f.text(582, y, s, "mk") + f.text(760, y, note, (cls + " sm") if cls != "t" else "mu sm"), f.go([(0, -300, 0, 0), (t, -300, 0, 0), (t + 0.1, -300, 0, 1), (t + 0.7, 0, 0, 1)]))
if cls == "rej":
f.g(f.line(578, y - 6, 578 + 9 * len(s) + 8, y - 6, "lr"), f.vis(t + 0.8, fade=0.2))
f.g(wrapped(f, 2, 398, "Вывод: ваша строка «!youtube.com» отключает встроенную «youtube.com», «^vk.com» сужает встроенную «vk.com» до самого домена.", "tk", 96), f.vis(8.0))
return f
add("hostlist-layers", "Zapret/attachments", hostlist_layers)
def ipset_check():
f = Fig("ipset-check", 450, 18, "Сначала исключения, потом включения: так профиль проверяет адрес",
"Профиль с --ipset-exclude=10.1.0.0/16 и --ipset=10.0.0.0/8,1.2.3.4. Адрес из исключений профиль не берёт, даже если он входит "
"во включающий список. Адрес вне включающего списка профиль тоже не берёт. Остальные профили проверяются дальше.")
f.add(f.text(2, 30, "условия профиля", "cap"))
f.add(f.rect(2, 44, 430, 70, "bx", rx=10) + f.text(20, 72, "1. исключения", "tk sm") + f.text(20, 98, "--ipset-exclude = 10.1.0.0/16", "m sm"))
f.add(f.rect(2, 132, 430, 70, "bx", rx=10) + f.text(20, 160, "2. включения", "tk sm") + f.text(20, 186, "--ipset = 10.0.0.0/8, 1.2.3.4", "m sm"))
f.add(f.text(480, 30, "адрес сервера", "cap"))
scen = [("10.5.6.7", [(0, "нет", "mu"), (1, "входит в 10.0.0.0/8", "acc")], "профиль берёт соединение", "acc"),
("10.1.2.3", [(0, "входит в 10.1.0.0/16", "rej")], "профиль НЕ берёт: исключение сильнее, хотя адрес есть и в 10.0.0.0/8", "rej"),
("1.2.3.4", [(0, "нет", "mu"), (1, "точное совпадение", "acc")], "профиль берёт соединение", "acc"),
("8.8.8.8", [(0, "нет", "mu"), (1, "нет", "mu")], "профиль НЕ берёт: адреса нет во включающем списке", "rej")]
for si, (ip, steps, verdict, tone) in enumerate(scen):
t0 = 0.4 + si * 4.3
t1 = t0 + 4.0
f.g(f.chip(600, 66, 220, 34, ip, "bxa", "mk sm"), f.vis(t0, t1))
for k, (row, what, cls) in enumerate(steps):
t = t0 + 0.6 + k * 0.9
y = 44 + row * 88
f.g(f.rect(2, y, 430, 70, "bxa" if cls == "acc" else ("bxr" if cls == "rej" else "bxd"), rx=10), f.vis(t, t1, fade=0.2))
f.g(f.text(480, y + 62, ("✓ " if cls != "mu" else "✕ ") + what, (cls + " sm") if cls != "mu" else "mu sm"), f.vis(t, t1, fade=0.2))
f.g(wrapped(f, 2, 262, verdict, tone + " tk", 90), f.vis(t0 + 0.8 + len(steps) * 0.9, t1))
f.g(wrapped(f, 2, 330, "Адрес сервера известен с первого пакета соединения, поэтому решение по списку адресов принимается сразу, "
"ещё до того, как движок узнает имя сайта. Если файлов несколько, хватит совпадения в любом.", "t", 92), f.vis(0.2))
return f
add("ipset-check", "Zapret/attachments", ipset_check)
def profile_lists_timing():
f = Fig("profile-lists-timing", 480, 16, "Профиль со списком сайтов ждёт имя сайта, профиль по адресам — нет",
"Пока в соединении не пришло приветствие TLS с именем сайта, профиль со списком сайтов в выборе не участвует, и первые пакеты достаются "
"профилю ниже. Когда имя появилось, движок пересматривает выбор, и соединение переходит к профилю со списком сайтов.")
prof = [("Профиль 1 · YouTube", "--hostlist=youtube.txt"), ("Профиль 2 · Все сайты (айпи)", "--ipset-exclude=ipset-ru.txt")]
for k, (a, b) in enumerate(prof):
y = 50 + k * 80
f.add(f.rect(2, y, 380, 64, "bx", rx=10) + f.text(18, y + 26, a, "tk sm") + f.text(18, y + 50, b, "m mu sm"))
f.add(f.text(2, 30, "профили пресета", "cap"))
f.add(f.text(420, 30, "пакеты одного соединения с youtube.com", "cap"))
pk = [("SYN", "имени нет"), ("SYN-ACK", "имени нет"), ("ACK", "имени нет"), ("TLS ClientHello", "имя: youtube.com"), ("данные", "имя известно")]
for k, (p, s) in enumerate(pk):
t = 0.6 + k * 2.6
y = 60 + k * 52
f.g(f.chip(520, y + 10, 190, 34, p, "bxa" if k >= 3 else "bx", "mk sm") + f.text(630, y + 16, s, "mu sm"), f.vis(t, dx=-10, fade=0.25))
owner = 0 if k >= 3 else 1
f.g(f.rect(2, 50 + owner * 80, 380, 64, "bxa", rx=10), f.vis(t + 0.4, t + 2.4 if k < 4 else None, fade=0.2))
f.g(f.text(800, y + 16, "→ профиль " + str(owner + 1), ("acc" if owner == 0 else "t") + " sm"), f.vis(t + 0.4, fade=0.2))
f.g(wrapped(f, 2, 360, "Пока имени нет, профиль 1 пропускается целиком, и первые пакеты обрабатывает профиль 2 своей стратегией. "
"С приветствия TLS движок знает имя и отдаёт соединение профилю 1 — выбор пересматривается не больше двух раз.", "t", 92), f.vis(10.6))
f.g(f.text(2, 456, "Профиль по адресам (ipset) решает с первого пакета: адрес сервера известен сразу.", "mu sm"), f.vis(0.2))
return f
add("profile-lists-timing", "Zapret2/attachments", profile_lists_timing)
# ═══ Исключения: pass против exclude-списка, спасение сайта через «!» (Zapret2/exclusions) ═══
def excl_pass_vs_exclude():
f = Fig("excl-pass-vs-exclude", 470, 19, "pass забирает соединение, exclude-список только выпускает его из одного профиля",
"Сцена 1: профиль со стратегией pass и списком ru забирает mail.ru, поиск останавливается, пакеты идут без изменений. "
"Сцена 2: широкий профиль с --hostlist-exclude=ru не совпал, поиск идёт ниже, и второй широкий профиль применяет к mail.ru своё дурение. "
"Сцена 3: ниже никого нет, соединение достаётся скрытому no_action и тоже идёт без изменений.")
scenes = [
("Сцена 1 · профиль pass", [("Исключения · pass", "--hostlist=ru-list.txt (ru)", "acc", "✓ совпал — забрал, ничего не делает"),
("Все сайты · fake", "--filter-tcp=443", "mu", "до него поиск не дошёл")],
"mail.ru идёт без изменений: поиск остановился на первом профиле", "acc"),
("Сцена 2 · exclude-список, ниже есть широкий профиль", [("Все сайты · fake", "--hostlist-exclude=ru-list.txt", "mu", "✕ не совпал: mail.ru в исключениях"),
("Весь TLS · multisplit", "--filter-tcp=443", "rej", "✓ совпал — применяет дурение")],
"mail.ru всё равно «дурится»: исключение действовало только в одном профиле", "rej"),
("Сцена 3 · exclude-список, ниже никого", [("Все сайты · fake", "--hostlist-exclude=ru-list.txt", "mu", "✕ не совпал: mail.ru в исключениях"),
("№ 0 · no_action (скрытый)", "фильтров нет", "acc", "✓ совпал — ничего не делает")],
"mail.ru идёт без изменений — его подобрал скрытый профиль в конце пресета", "acc"),
]
for si, (title, rows, verdict, tone) in enumerate(scenes):
t0 = 0.4 + si * 6.0
t1 = t0 + 5.7
f.g(f.text(2, 30, title, "tk"), f.vis(t0, t1))
f.g(f.chip(800, 26, 230, 34, "mail.ru:443", "bxa", "mk sm"), f.vis(t0, t1))
for k, (a, b, cls, note) in enumerate(rows):
y = 66 + k * 92
t = t0 + 0.8 + k * 1.3
dashed = a.startswith("№ 0")
f.g(f.rect(2, y, 470, 70, "bxd" if dashed else "bx", rx=10) + f.text(20, y + 30, a, "tk sm") + f.text(20, y + 54, b, "m mu sm"), f.vis(t0, t1))
kind = "bxa" if cls == "acc" else ("bxr" if cls == "rej" else None)
if kind:
f.g(f.rect(2, y, 470, 70, kind, rx=10), f.vis(t, t1, fade=0.2))
f.g(f.text(500, y + 42, note, (cls + " sm") if cls != "mu" else "mu sm"), f.vis(t, t1, fade=0.2))
f.g(wrapped(f, 2, 290, verdict, tone + " tk", 90), f.vis(t0 + 3.6, t1))
f.g(wrapped(f, 2, 372, "pass-профиль — жёсткая точка: соединение остаётся за ним. Exclude-список — мягкая: он выводит трафик только из своего профиля, "
"и следующий подходящий профиль заберёт его со своей стратегией.", "t", 92), f.vis(0.2))
return f
add("excl-pass-vs-exclude", "Zapret2/attachments", excl_pass_vs_exclude)
def excl_bang_rescue():
f = Fig("excl-bang-rescue", 430, 14, "«!» возвращает заблокированный сайт из профиля-исключения в обход",
"Профиль «Исключения домены» со стратегией pass ловит всю зону ru, кроме строки !torrents.ru. mail.ru попадает в pass и идёт без изменений. "
"torrents.ru из этого списка исключён, поэтому профиль его не берёт, и соединение достаётся профилю «Все сайты» с обходом.")
rows = [("Исключения домены · pass", "ru · su · рф · !torrents.ru"), ("Все сайты · стратегия обхода", "--filter-tcp=443")]
for k, (a, b) in enumerate(rows):
y = 50 + k * 92
f.add(f.rect(2, y, 470, 70, "bx", rx=10) + f.text(20, y + 30, a, "tk sm") + f.text(20, y + 54, b, "m mu sm"))
f.add(f.text(2, 30, "профили пресета", "cap"))
scen = [("mail.ru", 0, "✓ совпал через «ru» — pass, без изменений", "acc", "mail.ru не трогаем: он открывается и так"),
("torrents.ru", 1, "✓ профиль 1 пропустил: «!torrents.ru» — обход", "acc", "torrents.ru заблокирован — и получает обход")]
for si, (host, win, note, cls, verdict) in enumerate(scen):
t0 = 0.4 + si * 6.5
t1 = t0 + 6.2
f.g(f.chip(800, 26, 230, 34, host + ":443", "bxa", "mk sm"), f.vis(t0, t1))
if win == 1:
f.g(f.rect(2, 50, 470, 70, "bxd", rx=10) + f.text(500, 92, "✕ «!torrents.ru» — не в этом списке", "rej sm"), f.vis(t0 + 0.8, t1, fade=0.2))
y = 50 + win * 92
f.g(f.rect(2, y, 470, 70, "bxa", rx=10) + f.text(500, y + 42, note if win == 0 else "✓ совпал — стратегия обхода", "acc sm"), f.vis(t0 + 0.8 + win * 1.3, t1, fade=0.2))
f.g(wrapped(f, 2, 270, verdict, "tk", 90), f.vis(t0 + 3.0, t1))
f.g(wrapped(f, 2, 330, "Строку «!torrents.ru» пишут в список самого профиля-исключения: исключение действует только внутри своего файла, "
"поэтому дописывать её в другие профили не нужно.", "t", 92), f.vis(0.2))
f.g(f.text(2, 410, "Префикс «!» понимает движок winws2 с версии 1.0.7 (31 октября 2026); старый winws (Zapret 1) — нет.", "mu sm"), f.vis(0.2))
return f
add("excl-bang-rescue", "Zapret2/attachments", excl_bang_rescue)
# ═══ payload: тип пакета против протокола соединения (Zapret2/payload) ═══
def payload_types():
f = Fig("payload-types", 470, 16, "Тип пакета меняется, протокол соединения — нет",
"Пакеты одного TLS-соединения: SYN и пустые ACK имеют тип empty, приветствие браузера — tls_client_hello, ответ сервера — tls_server_hello, "
"зашифрованные данные — unknown. Протокол соединения tls ставится на первом распознанном пакете и не меняется. "
"С --payload=tls_client_hello стратегия получает только приветствие браузера.")
pk = [("SYN", "→", "empty"), ("ClientHello", "→", "tls_client_hello"), ("ServerHello", "←", "tls_server_hello"),
("данные", "→", "unknown"), ("данные", "←", "unknown"), ("ACK", "→", "empty")]
f.add(f.text(2, 30, "пакеты одного соединения с сайтом", "cap"))
f.add(f.text(430, 30, "тип пакета (l7payload)", "cap"))
f.add(f.text(720, 30, "протокол (l7proto)", "cap"))
for k, (name, d, typ) in enumerate(pk):
y = 50 + k * 54
t = 0.5 + k * 1.2
f.g(f.chip(150, y + 20, 260, 38, f"{d} {name}", "bxa" if typ.startswith("tls") else "bx", "mk sm"), f.vis(t, dx=-10, fade=0.25))
f.g(f.text(430, y + 26, typ, ("acc" if typ.startswith("tls") else "mu") + " m sm"), f.vis(t + 0.3, fade=0.2))
f.g(f.text(720, y + 26, "unknown" if k == 0 else "tls", ("mu" if k == 0 else "acc") + " m sm"), f.vis(t + 0.4, fade=0.2))
# выделение того, что попадёт в стратегию при --payload=tls_client_hello
f.g(f.rect(14, 50 + 54 - 2, 900, 44, "bxa", rx=8), f.vis(8.4, fade=0.3))
f.g(f.text(2, 392, "--payload=tls_client_hello: стратегия получает только выделенный пакет", "tk"), f.vis(8.4, fade=0.3))
f.g(wrapped(f, 2, 424, "Протокол tls держится на всём соединении, поэтому --filter-l7=tls выбирает профиль для всех его пакетов, "
"а --payload внутри профиля отбирает из них нужные.", "mu sm", 110, 19), f.vis(9.2))
return f
add("payload-types", "Zapret2/attachments", payload_types)
# ═══ Пресет: правка встроенного пресета и его обновление (Zapret2/preset) ═══
def preset_builtin_update():
f = Fig("preset-builtin-update", 450, 16, "Правка встроенного пресета живёт копией — до первого обновления этого пресета",
"Встроенный пресет лежит в presets\\winws2_builtin. Правка сохраняется копией в presets\\winws2, и дальше работает копия. "
"Если после обновления программы номер BuiltinVersion у встроенного пресета стал больше, копия заменяется новой версией, "
"а прежняя копия сохраняется в presets\\replaced.")
cols = [(2, "presets\\winws2_builtin", "приходит с программой"),
(330, "presets\\winws2", "ваши пресеты и копии правок"),
(658, "presets\\replaced", "последняя заменённая копия")]
for x, a, b in cols:
f.add(f.rect(x, 40, 300, 260, "bx", rx=10) + f.text(x + 16, 68, a, "m tk sm") + f.text(x + 16, 92, b, "mu sm"))
steps = [
(0.5, f.chip(152, 140, 260, 40, "Default v1 · 2.49", "bx", "mk sm"), "1. Встроенный пресет версии 2.49"),
(2.5, f.chip(480, 140, 260, 40, "2.49 + ваша правка", "bxa", "mk sm"), "2. Вы меняете стратегию — программа сохраняет копию, дальше работает она"),
(5.0, f.chip(152, 200, 260, 40, "Default v1 · 2.50", "bxa", "mk sm"), "3. Обновление программы: встроенный пресет стал версии 2.50"),
(7.5, f.chip(808, 140, 260, 40, "2.49 + ваша правка", "bxd", "mk sm"), "4. Старая копия уходит в replaced"),
(9.5, f.chip(480, 200, 260, 40, "Default v1 · 2.50", "bxa", "mk sm"), "5. Копию заменяет новая версия; вы получаете уведомление"),
]
for k, (t, chip, cap) in enumerate(steps):
# копия с правкой исчезает из winws2, когда её заменяет новая версия
f.g(chip, f.vis(t, 9.3 if k == 1 else None, dy=-8, fade=0.3))
f.g(f.text(2, 340, cap, "tk"), f.vis(t, t + 2.3 if t < 9.5 else None, fade=0.2))
f.g(f.rect(330, 120, 300, 40, "bxr", rx=6), f.vis(7.5, 9.4, fade=0.2))
f.g(wrapped(f, 2, 378, "Номер растёт только у правок, которые должны дойти до всех (стратегии, списки, профили). Переименование профиля номер не меняет. "
"Пресеты с другими именами файлов и пресеты по ссылке программа не трогает.", "mu sm", 110, 19), f.vis(0.2))
return f
add("preset-builtin-update", "Zapret2/attachments", preset_builtin_update)