Тот же класс ошибки, что на Android: у sequential с бюджетом 6 с потерянная UDP-датаграмма держала каждое новое имя 3 с до начала TCP. Оба транспорта ведут к одному resolver узла, поэтому parallel не смешивает политики. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
212 lines
11 KiB
Python
212 lines
11 KiB
Python
from __future__ import annotations
|
||
|
||
import json
|
||
from ipaddress import ip_address
|
||
from pathlib import Path
|
||
import unittest
|
||
|
||
from xray_fluent.constants import HYSTERIA_PATH_DEFAULT
|
||
from xray_fluent.engines.singbox.runtime_planner import (
|
||
parse_singbox_document,
|
||
plan_singbox_proxy_runtime,
|
||
plan_singbox_runtime,
|
||
)
|
||
from xray_fluent.importer.link_parser import parse_single
|
||
|
||
|
||
ROOT = Path(__file__).resolve().parents[1]
|
||
|
||
# Узел перенаправляет любой plaintext DNS туннеля на собственный resolver, кроме
|
||
# своих канонических upstream (1.1.1.1/1.0.0.1). Поэтому адрес-указатель обязан
|
||
# быть отличным от них.
|
||
NODE_DNS_SENTINEL = "8.8.8.8"
|
||
|
||
|
||
def _reachable(servers: dict, tag: str) -> set[str]:
|
||
"""Теги-листья, до которых доходит цепочка fallback-резолверов."""
|
||
|
||
seen: set[str] = set()
|
||
pending = [tag]
|
||
while pending:
|
||
current = pending.pop()
|
||
server = servers[current]
|
||
children = server.get("servers")
|
||
if children:
|
||
pending.extend(child for child in children if child not in seen)
|
||
continue
|
||
seen.add(current)
|
||
return seen
|
||
|
||
|
||
class SingboxTemplateDnsContractTests(unittest.TestCase):
|
||
def test_all_templates_define_the_runtime_dns_contract(self) -> None:
|
||
template_dir = ROOT / "data" / "templates" / "sing-box"
|
||
|
||
for path in sorted(template_dir.glob("*.json")):
|
||
with self.subTest(template=path.name):
|
||
payload = json.loads(path.read_text(encoding="utf-8"))
|
||
dns = payload["dns"]
|
||
servers = {server["tag"]: server for server in dns["servers"]}
|
||
|
||
self.assertEqual(servers["bootstrap-dns"]["servers"], ["direct-doh", "local-system-dns"])
|
||
self.assertEqual(servers["local-system-dns"]["type"], "local")
|
||
|
||
# Имена внутри туннеля резолвит DNS узла: обычный 53 через
|
||
# outbound `proxy`. Узел перехватывает его своим resolver'ом и
|
||
# отдаёт управляемые адреса. DoH через туннель этого перехвата
|
||
# не видит и возвращает настоящий origin.
|
||
self.assertEqual(
|
||
servers["proxy-dns"]["servers"],
|
||
["vpn-node-dns-udp", "vpn-node-dns-tcp"],
|
||
)
|
||
self.assertEqual(servers["proxy-dns"]["strategy"], "parallel")
|
||
for tag, transport in (
|
||
("vpn-node-dns-udp", "udp"),
|
||
("vpn-node-dns-tcp", "tcp"),
|
||
):
|
||
server = servers[tag]
|
||
self.assertEqual(server["type"], transport)
|
||
self.assertEqual(server["server"], NODE_DNS_SENTINEL)
|
||
self.assertEqual(server["server_port"], 53)
|
||
self.assertEqual(server["detour"], "proxy")
|
||
self.assertNotIn("tls", server)
|
||
|
||
# Туннельная цепочка не имеет выхода наружу: ни один резолвер,
|
||
# достижимый из `proxy-dns`, не ходит мимо outbound `proxy`.
|
||
for tag in _reachable(servers, "proxy-dns"):
|
||
self.assertEqual(
|
||
servers[tag].get("detour"),
|
||
"proxy",
|
||
msg=f"{tag} резолвит мимо туннеля",
|
||
)
|
||
|
||
# bootstrap остаётся защищённым DoH напрямую: он поднимает
|
||
# туннель и обязан пережить подмену DNS провайдером.
|
||
group = servers["direct-doh"]
|
||
self.assertEqual(group["strategy"], "parallel")
|
||
self.assertEqual(len(group["servers"]), 5)
|
||
addresses: set[str] = set()
|
||
for tag in group["servers"]:
|
||
self.assertEqual(servers[tag]["type"], "https")
|
||
self.assertIsNone(servers[tag].get("detour"))
|
||
self.assertTrue(servers[tag]["tls"]["enabled"])
|
||
self.assertNotIn("insecure", servers[tag]["tls"])
|
||
# Имя DoH-сервера (dns.google, cloudflare-dns.com, …) ТСПУ
|
||
# рвёт по SNI. Адрес — литеральный IP, а имя остаётся только
|
||
# для проверки сертификата: в ClientHello его нет.
|
||
ip_address(servers[tag]["server"])
|
||
self.assertIs(servers[tag]["tls"]["disable_sni"], True)
|
||
self.assertTrue(servers[tag]["tls"]["server_name"])
|
||
addresses.add(servers[tag]["server"])
|
||
# Пять разных адресов: блокировка одного IP (как TCP у 8.8.8.8
|
||
# в июле 2026) не оставляет bootstrap без защищённого пути.
|
||
self.assertEqual(len(addresses), 5)
|
||
self.assertEqual(dns["final"], "proxy-dns")
|
||
|
||
route = payload["route"]
|
||
self.assertEqual(route["default_domain_resolver"], "proxy-dns")
|
||
self.assertEqual(route["rules"][0], {"action": "sniff"})
|
||
self.assertEqual(
|
||
route["rules"][1],
|
||
{"protocol": "dns", "action": "hijack-dns"},
|
||
)
|
||
# DoT приложений обошёл бы и hijack-dns, и resolver узла.
|
||
self.assertEqual(
|
||
route["rules"][2],
|
||
{
|
||
"network": "tcp",
|
||
"port": 853,
|
||
"action": "reject",
|
||
"method": "default",
|
||
},
|
||
)
|
||
|
||
direct = next(
|
||
outbound
|
||
for outbound in payload["outbounds"]
|
||
if outbound.get("tag") == "direct"
|
||
)
|
||
self.assertEqual(direct["domain_resolver"], "bootstrap-dns")
|
||
|
||
def test_dns_rules_mirror_the_domain_part_of_the_route(self) -> None:
|
||
"""Имена, которые маршрут шлёт напрямую, не зависят от узла.
|
||
|
||
Без ``dns.rules`` единственный ``dns.final = proxy-dns`` отправлял в туннель
|
||
каждое имя, в том числе российские домены (login.mos.ru). Пока узел не
|
||
отвечал, они не резолвились, хотя сам трафик к ним шёл бы мимо VPN.
|
||
Правила DNS повторяют доменные условия маршрута в том же порядке:
|
||
direct → ``bootstrap-dns``, proxy → ``proxy-dns``.
|
||
"""
|
||
|
||
domain_keys = ("domain", "domain_suffix", "domain_keyword", "domain_regex")
|
||
servers_by_outbound = {"direct": "bootstrap-dns", "proxy": "proxy-dns"}
|
||
template_dir = ROOT / "data" / "templates" / "sing-box"
|
||
|
||
for path in sorted(template_dir.glob("*.json")):
|
||
with self.subTest(template=path.name):
|
||
payload = json.loads(path.read_text(encoding="utf-8"))
|
||
expected = []
|
||
for rule in payload["route"]["rules"]:
|
||
outbound = rule.get("outbound")
|
||
if rule.get("action") != "route" or outbound not in servers_by_outbound:
|
||
continue
|
||
if set(rule) - set(domain_keys) - {"rule_set", "action", "outbound"}:
|
||
continue # условия по процессу, порту и IP в DNS не повторяются
|
||
matcher = {key: rule[key] for key in domain_keys if key in rule}
|
||
domain_sets = [tag for tag in rule.get("rule_set", []) if tag.startswith("geosite-")]
|
||
if domain_sets:
|
||
matcher["rule_set"] = domain_sets
|
||
if matcher:
|
||
expected.append(
|
||
{**matcher, "action": "route", "server": servers_by_outbound[outbound]}
|
||
)
|
||
|
||
self.assertEqual(payload["dns"]["rules"], expected)
|
||
self.assertTrue(
|
||
any(rule["server"] == "bootstrap-dns" for rule in expected),
|
||
msg="в шаблоне нет прямых доменных правил: проверка ничего не защищает",
|
||
)
|
||
# Порядок важен: ru-blocked (proxy) стоит раньше category-ru (direct),
|
||
# иначе заблокированный домен ушёл бы на локальный резолвер.
|
||
sets = [tuple(rule.get("rule_set", ())) for rule in payload["dns"]["rules"]]
|
||
self.assertLess(
|
||
sets.index(("geosite-ru-blocked",)),
|
||
sets.index(("geosite-category-ru",)),
|
||
)
|
||
self.assertEqual(payload["dns"]["final"], "proxy-dns")
|
||
|
||
def test_discord_template_accepts_a_domain_based_proxy_node(self) -> None:
|
||
path = ROOT / "data" / "templates" / "sing-box" / "discord-folder-example.json"
|
||
document = parse_singbox_document(path, path.read_text(encoding="utf-8"))
|
||
|
||
node = parse_single("hy2://secret@example.com:443/?insecure=1&pinSHA256=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
|
||
plans = (
|
||
plan_singbox_runtime(document, node),
|
||
plan_singbox_proxy_runtime(
|
||
document,
|
||
node,
|
||
allowed_proxy_ports={1390, 1391},
|
||
),
|
||
)
|
||
|
||
for plan in plans:
|
||
with self.subTest(mode="proxy" if plan.socks_port else "tun"):
|
||
proxy = next(
|
||
outbound
|
||
for outbound in plan.singbox_config["outbounds"]
|
||
if outbound.get("tag") == "proxy"
|
||
)
|
||
self.assertEqual(proxy["type"], "socks")
|
||
self.assertEqual(proxy["server"], "127.0.0.1")
|
||
self.assertNotIn("domain_resolver", proxy)
|
||
self.assertEqual(
|
||
plan.singbox_config["route"]["rules"][0],
|
||
{
|
||
"process_path": [str(HYSTERIA_PATH_DEFAULT.resolve())],
|
||
"outbound": "direct",
|
||
},
|
||
)
|
||
|
||
|
||
if __name__ == "__main__":
|
||
unittest.main()
|