zapretgui/scripts/tspu_reply_window_stand.py
loop-uh 7d853a0de4
All checks were successful
Zapret source guards / validate (push) Successful in 22s
Подбор: малое окно через wssize_ramp — без падения скорости в десятки раз
Профиль малого окна по адресам теперь ставит wssize_ramp (lua/custom_funcs.lua,
private f8fd6c2): окно мало только до первых байт ответа сервера, дальше — почти
настоящее (не больше 128 КБ). В преамбулу добавляется --wf-tcp-empty=1, у самого
окна — --out-range=a --payload=all, стратегия после него — со своими
диапазонами.

Стенд scripts/tspu_reply_window_stand.py (8 МБ, speed.cloudflare.com):
без окна — обрыв; wssize 1:1 — 1,9 Мбит/с; профиль программы с одним окном —
20 Мбит/с, окно + multisplit — 57 Мбит/с; напрямую — 61–81.

Тексты BlockCheck, подбора и совета видеосервера говорят о реальном пределе
скорости вместо «в десятки раз медленнее». Аргумент open описан в каталоге
Lua. Стенд: берёт очередь до того, как трогать таблицу (не удаляет чужую),
пропускает через себя только первые пакеты соединения и не падает на
переполнении очереди.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-01 10:07:09 -05:00

269 lines
12 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.

"""Стенд: подражание фильтру ТСПУ «TLS с адреса режут по ответу сервера, но только в пределах окна».
Только для хоста Proxmox, на котором живёт виртуальная машина win10, и только от root. Нужен,
чтобы проверить BlockCheck (пробу малого окна, ``diagnostics.block_cause``) и подбор стратегии с
``wssize`` от начала до конца, не имея линии с настоящим фильтром.
Как устроен настоящий фильтр (вики: DPI/tspu-tls-ip-filter-tcp-window-october-2026): для адресов
из списка он узнаёт TLS по первым трём байтам ответа сервера (``16 03 0x``), но читает ответ только
в пределах окна приёма, которое объявил клиент. Окно в 1–2 байта он не может разобрать и пропускает
соединение; иначе соединение глохнет.
Что делает стенд:
- своя таблица nftables ``inet tspu_reply_stand`` на пересылке хоста, только трафик ``--client`` ↔
``--server`` по TCP 443 и только первые ``EARLY_PACKETS`` пакетов соединения, через очередь
``--queue`` с ``bypass``: если программа упала, пакеты идут как обычно;
- по пакетам клиента помнит его окно (множитель из SYN, окно из последнего пакета);
- первый пакет ответа сервера с данными решает судьбу соединения: видно 3 байта и больше и это
начало записи TLS — соединение глушится до конца, иначе — пропускается;
- ``--blind`` — контроль без учёта окна: любой ответ, начинающийся с ``16 03``, глушится;
- при выходе (Ctrl+C, SIGTERM, ``--seconds``) таблица удаляется.
Пример::
sudo python3 scripts/tspu_reply_window_stand.py --server 74.125.110.106 --seconds 900
Это модель по описанию фильтра, а не сам фильтр: вывод «работает у пользователя» по стенду делать
нельзя, только «механика пробы и подбора верна».
"""
from __future__ import annotations
import argparse
import ctypes
import ctypes.util
import ipaddress
import signal
import socket
import struct
import subprocess
import sys
import time
TABLE = "tspu_reply_stand"
# Через программу идут только первые пакеты соединения: решение принимается на первом пакете ответа
# сервера, а дальше на полной скорости медленная программа на Python сама стала бы узким местом (и
# переполняла очередь). Заглушённое соединение сервер повторяет с растущей паузой: за эти пакеты оно
# успевает упереться в срок пробы.
EARLY_PACKETS = 24
NF_DROP, NF_ACCEPT = 0, 1
NFQNL_COPY_PACKET = 2
TLS_RECORD_START = (0x14, 0x15, 0x16, 0x17)
def nft(script: str) -> None:
subprocess.run(["nft", "-f", "-"], input=script.encode(), check=True)
def install(client: str, servers: list[str], queue: int) -> None:
elements = ", ".join(servers)
nft(
f"""
table inet {TABLE} {{
set servers {{ type ipv4_addr; elements = {{ {elements} }} }}
chain forward {{
type filter hook forward priority -5; policy accept;
ip saddr {client} ip daddr @servers tcp dport 443 ct original packets 1-{EARLY_PACKETS} queue flags bypass to {queue}
ip daddr {client} ip saddr @servers tcp sport 443 ct reply packets 1-{EARLY_PACKETS} queue flags bypass to {queue}
}}
}}
"""
)
def uninstall() -> None:
subprocess.run(["nft", "delete", "table", "inet", TABLE], check=False, stderr=subprocess.DEVNULL)
def window_scale(options: bytes) -> int | None:
index = 0
while index < len(options):
kind = options[index]
if kind == 0:
break
if kind == 1:
index += 1
continue
if index + 1 >= len(options):
break
length = options[index + 1]
if kind == 3 and length == 3 and index + 2 < len(options):
return options[index + 2]
index += max(length, 2)
return None
class Flow:
__slots__ = ("scale", "ack", "window", "verdict")
def __init__(self) -> None:
self.scale = 0
self.ack = None
self.window = None
self.verdict = ""
class Filter:
def __init__(self, client: str, *, blind: bool) -> None:
self.client = socket.inet_aton(client)
self.blind = blind
self.flows: dict[tuple[int, bytes], Flow] = {}
self.stats = {"blocked": 0, "passed": 0}
def judge(self, packet: bytes) -> int:
if len(packet) < 40 or packet[0] >> 4 != 4 or packet[9] != 6:
return NF_ACCEPT
ihl = (packet[0] & 15) * 4
tcp = packet[ihl:]
sport, dport, seq, ack = struct.unpack("!HHII", tcp[:12])
offset = (tcp[12] >> 4) * 4
flags = tcp[13]
window = struct.unpack("!H", tcp[14:16])[0]
data = tcp[offset:]
syn = bool(flags & 0x02)
if packet[12:16] == self.client:
flow = self.flows.setdefault((sport, packet[16:20]), Flow())
if syn:
flow.__init__()
flow.scale = window_scale(tcp[20:offset]) or 0
flow.window = window # в SYN окно без множителя
else:
flow.window = window << flow.scale
flow.ack = ack
return NF_ACCEPT
flow = self.flows.get((dport, packet[12:16]))
if flow is None:
return NF_ACCEPT
if syn or not data:
return NF_ACCEPT
if flow.verdict == "blocked":
return NF_DROP
if flow.verdict == "passed":
return NF_ACCEPT
is_tls = len(data) >= 2 and data[0] in TLS_RECORD_START and data[1] == 0x03
if self.blind:
visible = len(data)
elif flow.ack is None or flow.window is None:
visible = len(data)
else:
room = (flow.ack + flow.window - seq) & 0xFFFFFFFF
visible = 0 if room >= 1 << 31 else min(len(data), room)
if visible >= 3 and is_tls:
flow.verdict = "blocked"
self.stats["blocked"] += 1
print(f"blocked: client port {dport}, window {flow.window}, visible {visible}", flush=True)
return NF_DROP
flow.verdict = "passed"
self.stats["passed"] += 1
print(f"passed: client port {dport}, window {flow.window}, visible {visible}", flush=True)
return NF_ACCEPT
class PacketHeader(ctypes.Structure):
_pack_ = 1
_fields_ = [("packet_id", ctypes.c_uint32), ("hw_protocol", ctypes.c_uint16), ("hook", ctypes.c_uint8)]
def run(queue: int, verdict_of, seconds: float, on_bound) -> None:
"""Слушать очередь ``seconds`` секунд. ``on_bound`` — вызывается, когда очередь уже наша."""
lib = ctypes.CDLL(ctypes.util.find_library("netfilter_queue") or "libnetfilter_queue.so.1", use_errno=True)
lib.nfq_open.restype = ctypes.c_void_p
lib.nfq_create_queue.restype = ctypes.c_void_p
lib.nfq_get_msg_packet_hdr.restype = ctypes.POINTER(PacketHeader)
lib.nfq_bind_pf.argtypes = [ctypes.c_void_p, ctypes.c_uint16]
lib.nfq_fd.argtypes = [ctypes.c_void_p]
lib.nfq_set_mode.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint32]
lib.nfq_handle_packet.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_int]
lib.nfq_get_payload.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.POINTER(ctypes.c_char))]
lib.nfq_get_msg_packet_hdr.argtypes = [ctypes.c_void_p]
lib.nfq_set_verdict.argtypes = [ctypes.c_void_p, ctypes.c_uint32, ctypes.c_uint32, ctypes.c_uint32, ctypes.c_void_p]
lib.nfq_destroy_queue.argtypes = [ctypes.c_void_p]
lib.nfq_close.argtypes = [ctypes.c_void_p]
callback_type = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p)
lib.nfq_create_queue.argtypes = [ctypes.c_void_p, ctypes.c_uint16, callback_type, ctypes.c_void_p]
def on_packet(queue_handle, _message, nfa, _data):
header = lib.nfq_get_msg_packet_hdr(nfa)
packet_id = socket.ntohl(header.contents.packet_id)
pointer = ctypes.POINTER(ctypes.c_char)()
length = lib.nfq_get_payload(nfa, ctypes.byref(pointer))
packet = ctypes.string_at(pointer, length) if length > 0 else b""
try:
verdict = verdict_of(packet)
except Exception as error: # стенд не должен глушить трафик из-за своей ошибки
print(f"error: {error}", file=sys.stderr, flush=True)
verdict = NF_ACCEPT
return lib.nfq_set_verdict(queue_handle, packet_id, verdict, 0, None)
callback = callback_type(on_packet)
handle = lib.nfq_open()
if not handle:
raise OSError("nfq_open failed")
lib.nfq_bind_pf(handle, socket.AF_INET)
queue_handle = lib.nfq_create_queue(handle, queue, callback, None)
if not queue_handle:
lib.nfq_close(handle)
raise OSError(f"queue {queue} is busy")
lib.nfq_set_mode(queue_handle, NFQNL_COPY_PACKET, 0xFFFF)
on_bound()
fd = lib.nfq_fd(handle)
sock = socket.socket(fileno=fd)
sock.settimeout(1.0)
deadline = time.monotonic() + seconds
try:
while time.monotonic() < deadline:
try:
data = sock.recv(65536)
except TimeoutError:
continue
except OSError as error:
if error.errno == 105: # очередь переполнилась: пакеты с bypass уже прошли мимо
continue
raise
lib.nfq_handle_packet(handle, data, len(data))
finally:
sock.detach()
lib.nfq_destroy_queue(queue_handle)
lib.nfq_close(handle)
def main() -> int:
parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
parser.add_argument("--client", default="10.20.0.20", help="адрес win10 за NAT хоста")
parser.add_argument("--server", action="append", required=True, help="адрес сервера под фильтром (можно несколько)")
parser.add_argument("--queue", type=int, default=4242)
parser.add_argument("--seconds", type=float, default=900.0, help="сколько работать; затем таблица удаляется")
parser.add_argument("--blind", action="store_true", help="контроль: глушить ответ TLS без учёта окна")
args = parser.parse_args()
servers = [str(ipaddress.IPv4Address(item)) for item in args.server]
ipaddress.IPv4Address(args.client)
def stop(_signum, _frame):
raise KeyboardInterrupt
signal.signal(signal.SIGTERM, stop)
flt = Filter(args.client, blind=args.blind)
installed = []
def bound() -> None:
# Таблицу трогаем, только когда очередь наша: иначе работает другой стенд, и его таблицу не удалять.
uninstall()
install(args.client, servers, args.queue)
installed.append(True)
print(f"stand up: {args.client} <-> {', '.join(servers)}, queue {args.queue}, blind={args.blind}", flush=True)
try:
run(args.queue, flt.judge, args.seconds, bound)
except KeyboardInterrupt:
pass
finally:
if installed:
uninstall()
print(f"stand down: {flt.stats}", flush=True)
return 0
if __name__ == "__main__":
raise SystemExit(main())