zapretgui/tests/test_zapret_dns_server.py
loop-uh 6e4053111d
All checks were successful
Zapret source guards / validate (push) Successful in 11s
Zapret DNS только через DoH за Cloudflare; адрес посредника — от самого сервера
Адрес сервера 38.180.241.191 закрыт в России по IP (02.11), и с 03.11 сервер стоит за Cloudflare и
отвечает только по DoH (решения пользователя). Посредник для нейросетей остаётся, но живёт на отдельном
адресе, который знает только сам сервер.
- config.zapret_dns: встроенные адреса — адреса Cloudflare для dns.zapret.moe; 38.180.241.191 — в
  FORMER_IPV4 (адаптеры уходят с него); DoT больше нет; RELAY_NAME = relay.check.<имя>;
- плитка «Zapret DNS» только шифрованная (encrypted_only): обычный DNS на адреса Cloudflare не пишется,
  Windows 10 идёт через локальный движок; узнанный адрес, который выпуск числит прежним, не используется;
- refresh раз в сутки спрашивает у самого сервера по DoH адрес посредника (learn_relay) и хранит его в
  dns.zapret_dns_server.relay_ipv4; профиль hosts «Zapret DNS» подставляет его на место метки, а пока он не
  узнан — строки не пишутся (раньше туда попал бы адрес Cloudflare); смена посредника переписывает hosts;
- отметка обычным DNS (hello.check, шлюз ZAPRET_DNS_CHECK_IN) убрана: адреса Cloudflare обычный DNS не слушают.
Тесты: test_zapret_dns_server, test_dns_providers_catalog, test_hosts_catalog_sqlite, test_hosts_relay_check,
test_dns_page и ближайшие — 305 прошли.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 06:09:40 -05:00

257 lines
13 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.

"""Свой сервер Zapret DNS: адрес в одном месте, адрес по имени, замена на адаптерах, адрес посредника."""
from __future__ import annotations
import sqlite3
import tempfile
import unittest
from pathlib import Path
from types import SimpleNamespace
from unittest.mock import patch
from config import zapret_dns
from dns import dns_providers, zapret_dns_server
from dns.address_migration import outdated_address_plan, plan_dns_server_migration
from settings import store
NEW = "198.51.100.7" # документационный адрес не годится: он не глобальный
GLOBAL_NEW = "1.2.3.4"
RELAY = "5.6.7.8"
def _relay_answer(*values: str, answered: bool = True):
"""Поддельный query_doh для вопроса об адресе посредника: отвечает values (пусто — «такого имени нет»)."""
asked: list = []
def query(server, name, rtype, **kwargs):
asked.append((server, name, kwargs.get("tls_host")))
return SimpleNamespace(answered=answered, values=lambda _rtype: tuple(values))
query.asked = asked
return query
SILENT = _relay_answer(answered=False)
class _Settings:
"""Раздел настроек dns.zapret_dns_server в памяти вместо settings.sqlite3."""
def __init__(self, value: dict | None = None) -> None:
self.value = dict(value or {"ipv4": [], "former_ipv4": [], "checked_at": 0.0, "relay_ipv4": []})
self.writes: list[dict] = []
def get(self) -> dict:
return dict(self.value)
def set(self, *, ipv4, former_ipv4, checked_at, relay_ipv4=()) -> None:
self.value = {"ipv4": list(ipv4), "former_ipv4": list(former_ipv4), "checked_at": checked_at,
"relay_ipv4": list(relay_ipv4)}
self.writes.append(dict(self.value))
def patch(self):
return patch.multiple(store, get_zapret_dns_server=self.get, set_zapret_dns_server=self.set)
class ZapretDnsServerTests(unittest.TestCase):
def setUp(self) -> None:
self._tile = list(dns_providers.zapret_dns_provider()["ipv4"])
self._active = zapret_dns_server._ACTIVE_IPV4
self._relay = zapret_dns_server._ACTIVE_RELAY
invalidate = patch("hosts.proxy_domains.invalidate_hosts_catalog_cache")
self.invalidate = invalidate.start()
self.addCleanup(invalidate.stop)
def tearDown(self) -> None:
dns_providers.zapret_dns_provider()["ipv4"][:] = self._tile
zapret_dns_server._ACTIVE_IPV4 = self._active
zapret_dns_server._ACTIVE_RELAY = self._relay
def test_the_tile_takes_everything_from_the_one_definition(self) -> None:
entry = dns_providers.zapret_dns_provider()
self.assertEqual(tuple(entry["ipv4"]), zapret_dns.IPV4)
self.assertEqual(tuple(entry["ipv6"]), zapret_dns.IPV6)
self.assertEqual(entry["doh"], zapret_dns.DOH_URL)
def test_the_tile_is_encrypted_only_behind_cloudflare(self) -> None:
# С 2026-11-03 сервер за Cloudflare: на его адресах нет ни обычного DNS, ни DoT.
entry = dns_providers.zapret_dns_provider()
self.assertTrue(dns_providers.is_encrypted_only(entry))
self.assertNotIn("dot", entry)
def test_a_learned_address_the_release_calls_former_is_dropped(self) -> None:
settings = _Settings({"ipv4": ["38.180.241.191"], "former_ipv4": [], "checked_at": 1.0})
with settings.patch():
self.assertEqual(zapret_dns_server.current_ipv4(), zapret_dns.IPV4)
def test_without_a_learned_address_the_built_in_one_is_current(self) -> None:
settings = _Settings()
with settings.patch():
self.assertEqual(zapret_dns_server.current_ipv4(), zapret_dns.IPV4)
self.assertEqual(zapret_dns_server.former_ipv4(), zapret_dns.FORMER_IPV4)
pairs = zapret_dns_server.address_replacements()
self.assertEqual(pairs, {old: zapret_dns.IPV4[0] for old in zapret_dns.FORMER_IPV4})
def test_a_learned_address_moves_everyone_off_the_built_in_one(self) -> None:
settings = _Settings({"ipv4": [GLOBAL_NEW], "former_ipv4": [], "checked_at": 1.0})
with settings.patch():
self.assertEqual(zapret_dns_server.current_ipv4(), (GLOBAL_NEW,))
pairs = zapret_dns_server.address_replacements()
self.assertEqual(zapret_dns_server.adopt(), (GLOBAL_NEW,))
self.assertEqual(pairs[zapret_dns.IPV4[0]], GLOBAL_NEW)
self.assertEqual(pairs["83.217.211.149"], GLOBAL_NEW)
self.assertEqual(dns_providers.zapret_dns_provider()["ipv4"], [GLOBAL_NEW])
self.assertEqual(zapret_dns_server.active_ipv4(), (GLOBAL_NEW,))
self.invalidate.assert_called_once()
def test_a_stored_non_global_address_is_never_used(self) -> None:
settings = _Settings({"ipv4": [NEW, "10.0.0.1", "garbage"], "former_ipv4": [], "checked_at": 1.0})
with settings.patch():
self.assertEqual(zapret_dns_server.current_ipv4(), zapret_dns.IPV4)
def test_refresh_adopts_only_a_verified_new_address(self) -> None:
settings = _Settings()
found = SimpleNamespace(ipv4=(GLOBAL_NEW,), error="")
asked: list = []
def lookup(template, **kwargs):
asked.append((template.host, kwargs))
return found
with settings.patch():
change = zapret_dns_server.refresh(lookup=lookup, relay_query=SILENT, now=5.0)
self.assertTrue(change.changed)
self.assertEqual(asked[0][0], zapret_dns.HOST)
self.assertFalse(asked[0][1]["ipv6"])
self.assertEqual(settings.value["ipv4"], [GLOBAL_NEW])
# Встроенный адрес становится прежним: с него переведут адаптеры.
self.assertIn(zapret_dns.IPV4[0], settings.value["former_ipv4"])
self.assertEqual(dns_providers.zapret_dns_provider()["ipv4"], [GLOBAL_NEW])
def test_a_failed_question_never_changes_the_server(self) -> None:
settings = _Settings()
with settings.patch():
change = zapret_dns_server.refresh(lookup=lambda *_a, **_k: SimpleNamespace(ipv4=(), error="молчит"), relay_query=SILENT)
self.assertFalse(change.changed)
self.assertEqual(change.detail, "молчит")
self.assertEqual(settings.writes, [])
self.assertEqual(dns_providers.zapret_dns_provider()["ipv4"], list(zapret_dns.IPV4))
def test_the_same_address_only_records_the_check(self) -> None:
settings = _Settings()
with settings.patch():
change = zapret_dns_server.refresh(
lookup=lambda *_a, **_k: SimpleNamespace(ipv4=zapret_dns.IPV4), relay_query=SILENT, now=9.0
)
self.assertFalse(change.changed)
self.assertEqual(settings.writes[-1]["checked_at"], 9.0)
self.invalidate.assert_not_called()
def test_the_relay_address_is_asked_of_the_server_itself_by_doh(self) -> None:
query = _relay_answer(RELAY)
self.assertEqual(zapret_dns_server.learn_relay(zapret_dns.IPV4, query=query), (RELAY,))
# Вопрос — к адресу сервера, с проверкой сертификата его имени, об имени, которого нет в общем DNS.
self.assertEqual(query.asked, [(zapret_dns.IPV4[0], zapret_dns.RELAY_NAME, zapret_dns.HOST)])
def test_a_server_without_relay_and_a_silent_server_differ(self) -> None:
self.assertEqual(zapret_dns_server.learn_relay(zapret_dns.IPV4, query=_relay_answer()), ())
self.assertIsNone(zapret_dns_server.learn_relay(zapret_dns.IPV4, query=SILENT))
def test_refresh_learns_the_relay_and_rewrites_hosts(self) -> None:
settings = _Settings()
with settings.patch():
change = zapret_dns_server.refresh(
lookup=lambda *_a, **_k: SimpleNamespace(ipv4=zapret_dns.IPV4), relay_query=_relay_answer(RELAY), now=3.0
)
self.assertFalse(change.changed)
self.assertTrue(change.relay_changed)
self.assertEqual(settings.value["relay_ipv4"], [RELAY])
self.assertEqual(zapret_dns_server.active_relay_ipv4(), (RELAY,))
self.invalidate.assert_called_once()
def test_a_silent_server_keeps_the_known_relay(self) -> None:
settings = _Settings({"ipv4": list(zapret_dns.IPV4), "former_ipv4": [], "checked_at": 1.0, "relay_ipv4": [RELAY]})
with settings.patch():
change = zapret_dns_server.refresh(lookup=lambda *_a, **_k: SimpleNamespace(ipv4=zapret_dns.IPV4), relay_query=SILENT)
self.assertFalse(change.relay_changed)
self.assertEqual(settings.value["relay_ipv4"], [RELAY])
class AddressMigrationTests(unittest.TestCase):
def test_former_ipv6_without_a_successor_is_removed(self) -> None:
self.assertEqual(zapret_dns.IPV6, ())
replacements, removals = outdated_address_plan()
self.assertEqual(set(removals), set(zapret_dns.FORMER_IPV6))
self.assertIsNone(plan_dns_server_migration(["2001:4860:4860::8888"], replacements, removals))
self.assertEqual(plan_dns_server_migration(["2A03:AFC0:9:0:0:0:0:235D"], replacements, removals), [])
self.assertEqual(
plan_dns_server_migration(["2a03:afc0:9::235d", "2606:4700:4700::1111"], replacements, removals),
["2606:4700:4700::1111"],
)
def test_every_former_ipv4_leads_to_the_current_server(self) -> None:
replacements, _removals = outdated_address_plan()
for former in zapret_dns.FORMER_IPV4:
self.assertEqual(
plan_dns_server_migration([former, "1.1.1.1"], replacements), [zapret_dns_server.current_ipv4()[0], "1.1.1.1"]
)
# Сторонние замены (Xbox → DNS-AI) остаются в общем плане.
self.assertIn("111.88.96.54", replacements)
class CatalogMarkerTests(unittest.TestCase):
def test_the_marker_becomes_the_relay_address_only_in_its_profile(self) -> None:
from hosts import catalog_repository
marker = zapret_dns.CATALOG_ADDRESS_MARKER
saved = zapret_dns_server._ACTIVE_RELAY
try:
zapret_dns_server._ACTIVE_RELAY = (RELAY,)
self.assertEqual(catalog_repository._answer_address("zapret_dns", marker), RELAY)
# Посредник не узнан — пусто: строка не попадает в hosts, а не ведёт на адрес Cloudflare.
zapret_dns_server._ACTIVE_RELAY = ()
self.assertEqual(catalog_repository._answer_address("zapret_dns", marker), "")
finally:
zapret_dns_server._ACTIVE_RELAY = saved
self.assertEqual(catalog_repository._answer_address("geohide", "193.233.112.67"), "193.233.112.67")
with self.assertRaises(catalog_repository.HostsCatalogError):
catalog_repository._answer_address("geohide", marker)
def test_the_shipped_catalog_carries_no_server_address(self) -> None:
database = Path(__file__).resolve().parents[2] / "private_zapretgui/resources/system/hosts_catalog.sqlite3"
if not database.is_file():
self.skipTest("нет закрытой части проекта")
with tempfile.TemporaryDirectory():
connection = sqlite3.connect(f"file:{database}?mode=ro", uri=True)
try:
addresses = {row[0] for row in connection.execute("SELECT DISTINCT ip_address FROM dns_answers")}
finally:
connection.close()
self.assertFalse(addresses & set(zapret_dns.IPV4 + zapret_dns.FORMER_IPV4))
self.assertIn(zapret_dns.CATALOG_ADDRESS_MARKER, addresses)
class HostsRefreshGuardTests(unittest.TestCase):
def test_an_unloaded_catalog_never_wipes_the_written_block(self) -> None:
from hosts import commands
manager = SimpleNamespace(refresh_applied_service_selection=lambda *a, **k: self.fail("блок переписан"))
with patch("hosts.proxy_domains.get_all_services", return_value=[]):
result = commands.refresh_applied_selection(manager)
self.assertFalse(result.success)
self.assertFalse(result.changed)
self.assertIn("не трогается", result.message)
class SettingsNormalizeTests(unittest.TestCase):
def test_only_global_ipv4_and_a_sane_time_are_kept(self) -> None:
from settings.normalize import normalize_dns
value = normalize_dns(
{"zapret_dns_server": {"ipv4": ["1.2.3.4", "10.0.0.1", "::1", "x", "1.2.3.4"], "checked_at": "bad"}}
)["zapret_dns_server"]
self.assertEqual(value, {"ipv4": ["1.2.3.4"], "former_ipv4": [], "checked_at": 0.0, "relay_ipv4": []})
if __name__ == "__main__":
unittest.main()