work: Добавил возможность направления через byedpi и через xray.

This commit is contained in:
2026-10-18 22:05:49 +03:00
parent 5994892509
commit d2c809c216
+181 -81
View File
@@ -40,9 +40,22 @@ AUTH_ENABLED = env_bool("AUTH_ENABLED", True)
ADMIN_USER = os.getenv("ADMIN_USER", "admin") ADMIN_USER = os.getenv("ADMIN_USER", "admin")
ADMIN_PASSWORD = os.getenv("ADMIN_PASSWORD", "") ADMIN_PASSWORD = os.getenv("ADMIN_PASSWORD", "")
APP_SECRET = os.getenv("APP_SECRET", secrets.token_urlsafe(48)) APP_SECRET = os.getenv("APP_SECRET", secrets.token_urlsafe(48))
DNSMASQ_TARGET_IP = str( # DNS routing targets. DNSMASQ_TARGET_IP is kept as a compatibility fallback for XRAY.
ipaddress.ip_address(os.getenv("DNSMASQ_TARGET_IP", "192.168.7.251").strip()) XRAY_TARGET_IP = str(
ipaddress.ip_address(
os.getenv(
"XRAY_TARGET_IP",
os.getenv("DNSMASQ_TARGET_IP", "192.168.7.251"),
).strip()
) )
)
BYEDPI_TARGET_IP = str(
ipaddress.ip_address(os.getenv("BYEDPI_TARGET_IP", "192.168.7.252").strip())
)
DNS_SERVICES = {
"xray": {"label": "XRAY", "ip": XRAY_TARGET_IP},
"byedpi": {"label": "ByeDPI", "ip": BYEDPI_TARGET_IP},
}
MAX_IMPORT_BYTES = int(os.getenv("MAX_IMPORT_BYTES", str(256 * 1024))) MAX_IMPORT_BYTES = int(os.getenv("MAX_IMPORT_BYTES", str(256 * 1024)))
LAN_NETWORKS = [ LAN_NETWORKS = [
x.strip() x.strip()
@@ -105,6 +118,8 @@ class DnsRecord:
record_id: str record_id: str
domain: str domain: str
ip: str ip: str
service_key: str
service_name: str
address_index: int address_index: int
local_indices: tuple[int, ...] local_indices: tuple[int, ...]
ipv6_blocked: bool ipv6_blocked: bool
@@ -282,6 +297,20 @@ def parse_dns_local_indices(managed: list[str]) -> dict[str, list[int]]:
return local_indices return local_indices
def dns_service_for_ip(ip: str) -> tuple[str, str]:
for key, cfg in DNS_SERVICES.items():
if cfg["ip"] == ip:
return key, cfg["label"]
return "other", f"Другой ({ip})"
def validate_dns_service(value: str) -> str:
key = value.strip().lower()
if key not in DNS_SERVICES:
raise ValueError("Неизвестный DNS-сервис. Разрешены XRAY и ByeDPI.")
return key
def parse_dns_records(managed: list[str]) -> list[DnsRecord]: def parse_dns_records(managed: list[str]) -> list[DnsRecord]:
records: list[DnsRecord] = [] records: list[DnsRecord] = []
local_indices = parse_dns_local_indices(managed) local_indices = parse_dns_local_indices(managed)
@@ -290,12 +319,16 @@ def parse_dns_records(managed: list[str]) -> list[DnsRecord]:
if not m: if not m:
continue continue
domain = m.group(1) domain = m.group(1)
ip = m.group(2)
service_key, service_name = dns_service_for_ip(ip)
matching_local = tuple(local_indices.get(domain.lower(), [])) matching_local = tuple(local_indices.get(domain.lower(), []))
records.append( records.append(
DnsRecord( DnsRecord(
record_id=_hash_id(line), record_id=_hash_id(line),
domain=domain, domain=domain,
ip=m.group(2), ip=ip,
service_key=service_key,
service_name=service_name,
address_index=idx, address_index=idx,
local_indices=matching_local, local_indices=matching_local,
ipv6_blocked=bool(matching_local), ipv6_blocked=bool(matching_local),
@@ -313,6 +346,60 @@ def append_dns_lines(managed: list[str], lines: list[str]) -> None:
managed.extend(lines) managed.extend(lines)
def upsert_dns_domain(managed: list[str], domain: str, ip: str) -> str:
"""Create, repair, or reroute one logical dnsmasq domain entry.
A logical entry is always the pair:
address=/domain/IP
local=/domain/
"""
key = domain.lower()
address_matches: list[tuple[int, str]] = []
local_matches: list[int] = []
for idx, line in enumerate(managed):
address_match = DNS_ADDRESS_RE.match(line)
if address_match and address_match.group(1).lower() == key:
address_matches.append((idx, address_match.group(2)))
continue
local_match = DNS_LOCAL_RE.match(line)
if local_match and local_match.group(1).lower() == key:
local_matches.append(idx)
canonical_address = f"address=/{domain}/{ip}"
canonical_local = f"local=/{domain}/"
already_exact = (
len(address_matches) == 1
and len(local_matches) == 1
and managed[address_matches[0][0]].strip() == canonical_address
and managed[local_matches[0]].strip() == canonical_local
)
if already_exact:
return "unchanged"
had_any = bool(address_matches or local_matches)
old_ips = {old_ip for _, old_ip in address_matches}
filtered: list[str] = []
for line in managed:
address_match = DNS_ADDRESS_RE.match(line)
local_match = DNS_LOCAL_RE.match(line)
if address_match and address_match.group(1).lower() == key:
continue
if local_match and local_match.group(1).lower() == key:
continue
filtered.append(line)
append_dns_lines(filtered, [canonical_address, canonical_local])
managed[:] = filtered
if not had_any:
return "added"
if old_ips and old_ips != {ip}:
return "rerouted"
return "repaired"
# ----------------------------------------------------------------------------- # -----------------------------------------------------------------------------
# Validation helpers # Validation helpers
# ----------------------------------------------------------------------------- # -----------------------------------------------------------------------------
@@ -337,27 +424,38 @@ def validate_site(value: str) -> str:
def validate_upstream(value: str) -> str: def validate_upstream(value: str) -> str:
value = value.strip() value = value.strip()
try: if not value:
parsed = urlsplit(value) raise ValueError("Upstream не задан.")
except ValueError as exc:
raise ValueError("Invalid upstream URL.") from exc
if parsed.scheme not in {"http", "https"}: # Caddy accepts both full URLs (http://host:port) and network addresses
raise ValueError("Upstream must start with http:// or https://") # without a scheme (for example 127.0.0.1:8000).
has_scheme = "://" in value
try:
parsed = urlsplit(value if has_scheme else f"//{value}")
except ValueError as exc:
raise ValueError("Некорректный upstream.") from exc
if has_scheme and parsed.scheme not in {"http", "https"}:
raise ValueError("Upstream должен использовать http://, https:// или формат host:port.")
if not parsed.hostname: if not parsed.hostname:
raise ValueError("Upstream must contain a hostname or IP address.") raise ValueError("Upstream должен содержать имя хоста или IP-адрес.")
if parsed.username or parsed.password: if parsed.username or parsed.password:
raise ValueError("Credentials in upstream URL are not allowed.") raise ValueError("Логин/пароль в upstream не разрешены.")
if parsed.path not in {"", "/"} or parsed.query or parsed.fragment: if parsed.path not in {"", "/"} or parsed.query or parsed.fragment:
raise ValueError("Upstream must not contain a path, query, or fragment.") raise ValueError("Upstream не должен содержать путь, query или fragment.")
try: try:
port = parsed.port port = parsed.port
except ValueError as exc: except ValueError as exc:
raise ValueError("Invalid upstream port.") from exc raise ValueError("Некорректный порт upstream.") from exc
if port is not None and not (1 <= port <= 65535):
raise ValueError("Invalid upstream port.")
return value.rstrip("/")
if port is None:
if not has_scheme:
raise ValueError("Для upstream без http:// или https:// необходимо указать порт, например 127.0.0.1:8000.")
elif not (1 <= port <= 65535):
raise ValueError("Некорректный порт upstream.")
return value.rstrip("/")
def validate_comment(value: str) -> str: def validate_comment(value: str) -> str:
value = " ".join(value.replace("\r", " ").replace("\n", " ").split()).strip() value = " ".join(value.replace("\r", " ").replace("\n", " ").split()).strip()
@@ -601,7 +699,7 @@ def index():
dns_ok=state[4], dns_ok=state[4],
dns_status=state[5], dns_status=state[5],
lan_networks=", ".join(LAN_NETWORKS), lan_networks=", ".join(LAN_NETWORKS),
dns_target_ip=DNSMASQ_TARGET_IP, dns_services=DNS_SERVICES,
auth_enabled=AUTH_ENABLED, auth_enabled=AUTH_ENABLED,
) )
@@ -671,36 +769,38 @@ def dns_add():
require_csrf() require_csrf()
try: try:
domain = validate_dns_domain(request.form.get("domain", "")) domain = validate_dns_domain(request.form.get("domain", ""))
ip = DNSMASQ_TARGET_IP service = validate_dns_service(request.form.get("service", "xray"))
service_cfg = DNS_SERVICES[service]
ip = service_cfg["ip"]
old = read_text_exact(DNSMASQ_CONF) old = read_text_exact(DNSMASQ_CONF)
managed = get_managed_lines(old) managed = get_managed_lines(old)
records = parse_dns_records(managed) result = upsert_dns_domain(managed, domain, ip)
address_domains = {r.domain.lower() for r in records}
local_domains = set(parse_dns_local_indices(managed))
key = domain.lower()
lines_to_add: list[str] = [] if result == "unchanged":
if key not in address_domains: flash(
lines_to_add.append(f"address=/{domain}/{ip}") f"{domain} уже направлен через {service_cfg['label']} ({ip}), IPv6 заблокирован.",
if key not in local_domains: "success",
lines_to_add.append(f"local=/{domain}/")
if not lines_to_add:
raise ValueError(
f"dnsmasq entry for {domain} already exists and IPv6 blocking is already enabled."
) )
return redirect(url_for("index"))
append_dns_lines(managed, lines_to_add)
new = replace_managed_lines(old, managed) new = replace_managed_lines(old, managed)
ok, message = apply_transaction(DNSMASQ_CONF, old, new, DNSMASQ_VALIDATE_CMD, DNSMASQ_APPLY_CMD) ok, message = apply_transaction(DNSMASQ_CONF, old, new, DNSMASQ_VALIDATE_CMD, DNSMASQ_APPLY_CMD)
if ok and len(lines_to_add) == 1: if ok:
message = f"Запись {domain} приведена к новой схеме address + local.\n{message}" action = {
"added": "добавлен",
"rerouted": "переключён",
"repaired": "исправлен",
}[result]
message = (
f"{domain}: {action}; сервис {service_cfg['label']}, IPv4 {ip}, IPv6 заблокирован.\n"
f"{message}"
)
flash(message, "success" if ok else "error") flash(message, "success" if ok else "error")
except Exception as exc: except Exception as exc:
flash(str(exc), "error") flash(str(exc), "error")
return redirect(url_for("index")) return redirect(url_for("index"))
@app.post("/dns/delete") @app.post("/dns/delete")
def dns_delete(): def dns_delete():
require_csrf() require_csrf()
@@ -751,86 +851,78 @@ def dns_import():
except UnicodeDecodeError as exc: except UnicodeDecodeError as exc:
raise ValueError("Файл импорта должен быть в кодировке UTF-8.") from exc raise ValueError("Файл импорта должен быть в кодировке UTF-8.") from exc
domains: list[str] = [] entries: list[tuple[str, str]] = []
seen_import: set[str] = set() seen_import: set[str] = set()
errors: list[str] = [] errors: list[str] = []
for lineno, raw_line in enumerate(imported_text.splitlines(), start=1): for lineno, raw_line in enumerate(imported_text.splitlines(), start=1):
line = raw_line.strip() line = raw_line.strip()
if not line or line.startswith("#"): if not line or line.startswith("#"):
continue continue
parts = [part.strip() for part in line.split(";", 1)]
raw_domain = parts[0]
raw_service = parts[1] if len(parts) == 2 and parts[1] else "xray"
try: try:
domain = validate_dns_domain(line) domain = validate_dns_domain(raw_domain)
service = validate_dns_service(raw_service)
except ValueError: except ValueError:
errors.append(f"строка {lineno}: {line}") errors.append(f"строка {lineno}: {line}")
continue continue
key = domain.lower() key = domain.lower()
if key not in seen_import: if key not in seen_import:
seen_import.add(key) seen_import.add(key)
domains.append(domain) entries.append((domain, service))
if errors: if errors:
preview = "; ".join(errors[:8]) preview = "; ".join(errors[:8])
if len(errors) > 8: if len(errors) > 8:
preview += f"; ещё {len(errors) - 8}" preview += f"; ещё {len(errors) - 8}"
raise ValueError(f"В файле есть некорректные домены: {preview}") raise ValueError(f"В файле есть некорректные записи: {preview}")
if not domains: if not entries:
raise ValueError("В файле не найдено ни одного домена.") raise ValueError("В файле не найдено ни одного домена.")
old = read_text_exact(DNSMASQ_CONF) old = read_text_exact(DNSMASQ_CONF)
managed = get_managed_lines(old) managed = get_managed_lines(old)
records = parse_dns_records(managed) added = rerouted = repaired = unchanged = 0
address_domains = {r.domain.lower() for r in records}
local_domains = set(parse_dns_local_indices(managed))
added = 0 for domain, service in entries:
repaired = 0 result = upsert_dns_domain(managed, domain, DNS_SERVICES[service]["ip"])
skipped = 0 if result == "added":
for domain in domains:
key = domain.lower()
missing_address = key not in address_domains
missing_local = key not in local_domains
if not missing_address and not missing_local:
skipped += 1
continue
lines_to_add: list[str] = []
if missing_address:
lines_to_add.append(f"address=/{domain}/{DNSMASQ_TARGET_IP}")
address_domains.add(key)
if missing_local:
lines_to_add.append(f"local=/{domain}/")
local_domains.add(key)
append_dns_lines(managed, lines_to_add)
if missing_address and missing_local:
added += 1 added += 1
else: elif result == "rerouted":
rerouted += 1
elif result == "repaired":
repaired += 1 repaired += 1
else:
unchanged += 1
if not added and not repaired: if not (added or rerouted or repaired):
flash(f"Изменений нет. Полностью существующих доменов: {skipped}.", "success") flash(f"Изменений нет. Без изменений: {unchanged}.", "success")
return redirect(url_for("index")) return redirect(url_for("index"))
new = replace_managed_lines(old, managed) new = replace_managed_lines(old, managed)
ok, message = apply_transaction(DNSMASQ_CONF, old, new, DNSMASQ_VALIDATE_CMD, DNSMASQ_APPLY_CMD) ok, message = apply_transaction(DNSMASQ_CONF, old, new, DNSMASQ_VALIDATE_CMD, DNSMASQ_APPLY_CMD)
if ok: if ok:
message = ( message = (
f"Импорт завершён: новых доменов {added}, дополнено до address + local {repaired}, " f"Импорт завершён: новых {added}, переключено {rerouted}, исправлено {repaired}, "
f"без изменений {skipped}.\n{message}" f"без изменений {unchanged}.\n{message}"
) )
flash(message, "success" if ok else "error") flash(message, "success" if ok else "error")
except Exception as exc: except Exception as exc:
flash(str(exc), "error") flash(str(exc), "error")
return redirect(url_for("index")) return redirect(url_for("index"))
@app.get("/dns/export") @app.get("/dns/export")
def dns_export(): def dns_export():
try: try:
text = read_text_exact(DNSMASQ_CONF) text = read_text_exact(DNSMASQ_CONF)
records = parse_dns_records(get_managed_lines(text)) records = parse_dns_records(get_managed_lines(text))
content = "\n".join(r.domain for r in records) lines: list[str] = []
for r in records:
service = r.service_name if r.service_key != "other" else r.ip
lines.append(f"{r.domain};{service}")
content = "\n".join(lines)
if content: if content:
content += "\n" content += "\n"
return Response( return Response(
@@ -874,8 +966,8 @@ TEMPLATE = r"""
.dot.ok { background:var(--good); box-shadow:0 0 0 3px rgba(53,196,106,.12); } .dot.ok { background:var(--good); box-shadow:0 0 0 3px rgba(53,196,106,.12); }
form.add { display:grid; grid-template-columns:1fr 1fr; gap:10px; padding:13px; margin-bottom:16px; background:#12161c; border:1px solid var(--line); border-radius:11px; } form.add { display:grid; grid-template-columns:1fr 1fr; gap:10px; padding:13px; margin-bottom:16px; background:#12161c; border:1px solid var(--line); border-radius:11px; }
label { display:block; color:var(--muted); font-size:12px; } label { display:block; color:var(--muted); font-size:12px; }
input[type=text] { width:100%; margin-top:5px; padding:9px 10px; border-radius:8px; border:1px solid #343b47; background:#0e1116; color:#fff; outline:none; } input[type=text], select { width:100%; margin-top:5px; padding:9px 10px; border-radius:8px; border:1px solid #343b47; background:#0e1116; color:#fff; outline:none; }
input[type=text]:focus { border-color:var(--accent); } input[type=text]:focus, select:focus { border-color:var(--accent); }
.wide { grid-column:1/-1; } .wide { grid-column:1/-1; }
.check { display:flex; gap:8px; align-items:center; color:#dce3eb; } .check { display:flex; gap:8px; align-items:center; color:#dce3eb; }
button { border:0; border-radius:8px; padding:9px 12px; color:#fff; background:var(--accent); cursor:pointer; font-weight:600; } button { border:0; border-radius:8px; padding:9px 12px; color:#fff; background:var(--accent); cursor:pointer; font-weight:600; }
@@ -917,7 +1009,7 @@ TEMPLATE = r"""
<form class="add" method="post" action="{{ url_for('caddy_add') }}"> <form class="add" method="post" action="{{ url_for('caddy_add') }}">
<input type="hidden" name="csrf_token" value="{{ csrf_token() }}"> <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
<label>Имя сайта<input type="text" name="site" required placeholder="grafana.example.ru"></label> <label>Имя сайта<input type="text" name="site" required placeholder="grafana.example.ru"></label>
<label>Upstream<input type="text" name="upstream" required placeholder="http://nas.local:3000"></label> <label>Upstream<input type="text" name="upstream" required placeholder="127.0.0.1:8000 или http://nas.local:3000"></label>
<label class="wide">Комментарий<input type="text" name="comment" placeholder="Grafana"></label> <label class="wide">Комментарий<input type="text" name="comment" placeholder="Grafana"></label>
<label class="check wide"><input type="checkbox" name="lan_only"> Доступ только из LAN ({{ lan_networks }})</label> <label class="check wide"><input type="checkbox" name="lan_only"> Доступ только из LAN ({{ lan_networks }})</label>
<button class="wide" type="submit">Добавить Caddy proxy</button> <button class="wide" type="submit">Добавить Caddy proxy</button>
@@ -952,24 +1044,32 @@ TEMPLATE = r"""
<form class="add" method="post" action="{{ url_for('dns_add') }}"> <form class="add" method="post" action="{{ url_for('dns_add') }}">
<input type="hidden" name="csrf_token" value="{{ csrf_token() }}"> <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
<label class="wide">Домен<input type="text" name="domain" required placeholder="example.com или .example.com"></label> <label>Домен<input type="text" name="domain" required placeholder="example.com или .example.com"></label>
<div class="wide muted">Для каждого домена создаются две строки: address → {{ dns_target_ip }} и local для блокировки внешнего IPv6.</div> <label>Сервис
<button class="wide" type="submit">Добавить DNS-запись</button> <select name="service" required>
{% for key, cfg in dns_services.items() %}
<option value="{{ key }}">{{ cfg.label }} — {{ cfg.ip }}</option>
{% endfor %}
</select>
</label>
<div class="wide muted">XRAY → {{ dns_services['xray']['ip'] }}, ByeDPI → {{ dns_services['byedpi']['ip'] }}. Для домена также создаётся local= для блокировки внешнего IPv6.</div>
<button class="wide" type="submit">Добавить / изменить DNS-запись</button>
</form> </form>
<form class="dns-tools" method="post" action="{{ url_for('dns_import') }}" enctype="multipart/form-data"> <form class="dns-tools" method="post" action="{{ url_for('dns_import') }}" enctype="multipart/form-data">
<input type="hidden" name="csrf_token" value="{{ csrf_token() }}"> <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
<label>Импорт списка доменов (.txt, один домен на строку)<input type="file" name="file" accept=".txt,text/plain" required></label> <label>Импорт (.txt): domain;XRAY или domain;ByeDPI. Старый формат domain = XRAY<input type="file" name="file" accept=".txt,text/plain" required></label>
<button type="submit">Импортировать</button> <button type="submit">Импортировать</button>
</form> </form>
<p><a class="button-link" href="{{ url_for('dns_export') }}">Экспортировать список доменов</a></p> <p><a class="button-link" href="{{ url_for('dns_export') }}">Экспортировать список доменов</a></p>
<table> <table>
<thead><tr><th>Domain</th><th>IPv4</th><th>IPv6</th><th></th></tr></thead> <thead><tr><th>Domain</th><th>Сервис</th><th>IPv4</th><th>IPv6</th><th></th></tr></thead>
<tbody> <tbody>
{% for r in dns_records %} {% for r in dns_records %}
<tr> <tr>
<td><strong>{{ r.domain }}</strong></td> <td><strong>{{ r.domain }}</strong></td>
<td><span class="tag">{{ r.service_name }}</span></td>
<td><code>{{ r.ip }}</code></td> <td><code>{{ r.ip }}</code></td>
<td>{% if r.ipv6_blocked %}<span class="tag">заблокирован</span>{% else %}<span class="muted">нет local=</span>{% endif %}</td> <td>{% if r.ipv6_blocked %}<span class="tag">заблокирован</span>{% else %}<span class="muted">нет local=</span>{% endif %}</td>
<td> <td>
@@ -980,7 +1080,7 @@ TEMPLATE = r"""
</form> </form>
</td> </td>
</tr> </tr>
{% else %}<tr><td colspan="4" class="muted">Записей не найдено.</td></tr>{% endfor %} {% else %}<tr><td colspan="5" class="muted">Записей не найдено.</td></tr>{% endfor %}
</tbody> </tbody>
</table> </table>
<details><summary>Результат dnsmasq --test</summary><pre>{{ dns_status }}</pre></details> <details><summary>Результат dnsmasq --test</summary><pre>{{ dns_status }}</pre></details>