1191 lines
44 KiB
Python
1191 lines
44 KiB
Python
from __future__ import annotations
|
|
|
|
import hashlib
|
|
import hmac
|
|
import ipaddress
|
|
import os
|
|
import re
|
|
import secrets
|
|
import shutil
|
|
import subprocess
|
|
import tempfile
|
|
import threading
|
|
from dataclasses import dataclass
|
|
from datetime import datetime
|
|
from pathlib import Path
|
|
from urllib.parse import urlsplit
|
|
|
|
from flask import Flask, Response, abort, flash, redirect, render_template_string, request, session, url_for
|
|
|
|
|
|
# -----------------------------------------------------------------------------
|
|
# Configuration
|
|
# -----------------------------------------------------------------------------
|
|
|
|
CADDYFILE = Path(os.getenv("CADDYFILE", "/etc/caddy/Caddyfile")).resolve()
|
|
DNSMASQ_CONF = Path(os.getenv("DNSMASQ_CONF", "/etc/dnsmasq.conf")).resolve()
|
|
BACKUP_DIR = Path(os.getenv("BACKUP_DIR", "/var/backups/web-proxy-config"))
|
|
|
|
BEGIN_MARKER = os.getenv("BEGIN_MARKER", "#begin marker")
|
|
END_MARKER = os.getenv("END_MARKER", "#end marker")
|
|
|
|
def env_bool(name: str, default: bool) -> bool:
|
|
raw = os.getenv(name)
|
|
if raw is None:
|
|
return default
|
|
return raw.strip().lower() in {"1", "true", "yes", "on"}
|
|
|
|
|
|
AUTH_ENABLED = env_bool("AUTH_ENABLED", True)
|
|
ADMIN_USER = os.getenv("ADMIN_USER", "admin")
|
|
ADMIN_PASSWORD = os.getenv("ADMIN_PASSWORD", "")
|
|
APP_SECRET = os.getenv("APP_SECRET", secrets.token_urlsafe(48))
|
|
# DNS routing targets. DNSMASQ_TARGET_IP is kept as a compatibility fallback for XRAY.
|
|
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)))
|
|
LAN_NETWORKS = [
|
|
x.strip()
|
|
for x in os.getenv("LAN_NETWORKS", "192.168.7.0/24,10.10.10.0/24").split(",")
|
|
if x.strip()
|
|
]
|
|
MAX_BACKUPS = int(os.getenv("MAX_BACKUPS", "50"))
|
|
|
|
CADDY_VALIDATE_CMD = [
|
|
os.getenv("CADDY_BIN", "/usr/bin/caddy"),
|
|
"validate",
|
|
"--config",
|
|
str(CADDYFILE),
|
|
"--adapter",
|
|
"caddyfile",
|
|
]
|
|
CADDY_APPLY_CMD = ["/usr/bin/systemctl", "reload", "caddy"]
|
|
DNSMASQ_VALIDATE_CMD = [
|
|
os.getenv("DNSMASQ_BIN", "/usr/sbin/dnsmasq"),
|
|
"--test",
|
|
f"--conf-file={DNSMASQ_CONF}",
|
|
]
|
|
DNSMASQ_APPLY_CMD = ["/usr/bin/systemctl", "restart", "dnsmasq"]
|
|
|
|
if AUTH_ENABLED and not ADMIN_PASSWORD:
|
|
raise RuntimeError(
|
|
"AUTH_ENABLED is true, but ADMIN_PASSWORD is not configured. "
|
|
"Set ADMIN_PASSWORD or disable authentication with AUTH_ENABLED=false."
|
|
)
|
|
|
|
app = Flask(__name__)
|
|
app.secret_key = APP_SECRET
|
|
app.config.update(
|
|
SESSION_COOKIE_HTTPONLY=True,
|
|
SESSION_COOKIE_SAMESITE="Strict",
|
|
)
|
|
|
|
CHANGE_LOCK = threading.Lock()
|
|
|
|
|
|
# -----------------------------------------------------------------------------
|
|
# Models / parsing
|
|
# -----------------------------------------------------------------------------
|
|
|
|
|
|
@dataclass
|
|
class CaddyRecord:
|
|
record_id: str
|
|
site: str
|
|
target: str
|
|
comment: str
|
|
lan_only: bool
|
|
start: int
|
|
end: int
|
|
raw: str
|
|
|
|
|
|
@dataclass
|
|
class DnsRecord:
|
|
record_id: str
|
|
domain: str
|
|
ip: str
|
|
service_key: str
|
|
service_name: str
|
|
address_index: int
|
|
local_indices: tuple[int, ...]
|
|
ipv6_blocked: bool
|
|
raw: str
|
|
|
|
|
|
def _hash_id(text: str) -> str:
|
|
return hashlib.sha256(text.encode("utf-8")).hexdigest()[:16]
|
|
|
|
|
|
def _find_marker_line(text: str, marker: str) -> list[re.Match[str]]:
|
|
pattern = re.compile(
|
|
rf"(?im)^[ \t]*{re.escape(marker.strip())}[ \t]*(?:\r\n|\n|\r|$)"
|
|
)
|
|
return list(pattern.finditer(text))
|
|
|
|
|
|
def split_managed_section(text: str) -> tuple[str, str, str, str]:
|
|
"""Return prefix, managed text, suffix and preferred newline.
|
|
|
|
Prefix includes the begin-marker line and its line ending. Suffix starts with
|
|
the end-marker line. Therefore prefix and suffix can be copied byte-for-byte
|
|
(at the decoded text level) without being rebuilt.
|
|
"""
|
|
begins = _find_marker_line(text, BEGIN_MARKER)
|
|
ends = _find_marker_line(text, END_MARKER)
|
|
if len(begins) != 1 or len(ends) != 1:
|
|
raise ValueError(
|
|
f"Expected exactly one '{BEGIN_MARKER}' and one '{END_MARKER}' marker."
|
|
)
|
|
begin = begins[0]
|
|
end = ends[0]
|
|
if end.start() < begin.end():
|
|
raise ValueError("End marker is before the begin marker.")
|
|
|
|
prefix = text[: begin.end()]
|
|
managed = text[begin.end() : end.start()]
|
|
suffix = text[end.start() :]
|
|
|
|
if prefix.endswith("\r\n"):
|
|
newline = "\r\n"
|
|
elif prefix.endswith("\n"):
|
|
newline = "\n"
|
|
elif prefix.endswith("\r"):
|
|
newline = "\r"
|
|
else:
|
|
newline = "\n"
|
|
return prefix, managed, suffix, newline
|
|
|
|
|
|
def get_managed_lines(text: str) -> list[str]:
|
|
_, managed, _, _ = split_managed_section(text)
|
|
return managed.splitlines()
|
|
|
|
|
|
def replace_managed_lines(text: str, managed: list[str]) -> str:
|
|
prefix, _, suffix, newline = split_managed_section(text)
|
|
body = newline.join(managed)
|
|
if body:
|
|
body += newline
|
|
return prefix + body + suffix
|
|
|
|
|
|
def read_text_exact(path: Path) -> str:
|
|
with path.open("r", encoding="utf-8", newline="") as fh:
|
|
return fh.read()
|
|
|
|
|
|
def _brace_delta(line: str) -> int:
|
|
"""Count braces outside double quotes/backticks and before comments."""
|
|
delta = 0
|
|
quote = None
|
|
escaped = False
|
|
for ch in line:
|
|
if escaped:
|
|
escaped = False
|
|
continue
|
|
if ch == "\\" and quote == '"':
|
|
escaped = True
|
|
continue
|
|
if quote:
|
|
if ch == quote:
|
|
quote = None
|
|
continue
|
|
if ch in ('"', "`"):
|
|
quote = ch
|
|
continue
|
|
if ch == "#":
|
|
break
|
|
if ch == "{":
|
|
delta += 1
|
|
elif ch == "}":
|
|
delta -= 1
|
|
return delta
|
|
|
|
|
|
def parse_caddy_records(managed: list[str]) -> list[CaddyRecord]:
|
|
records: list[CaddyRecord] = []
|
|
i = 0
|
|
while i < len(managed):
|
|
stripped = managed[i].strip()
|
|
if not stripped or stripped.startswith("#") or "{" not in managed[i]:
|
|
i += 1
|
|
continue
|
|
|
|
header = managed[i].split("{", 1)[0].strip()
|
|
if not header:
|
|
i += 1
|
|
continue
|
|
|
|
depth = 0
|
|
end = i
|
|
found_open = False
|
|
for j in range(i, len(managed)):
|
|
d = _brace_delta(managed[j])
|
|
if d > 0:
|
|
found_open = True
|
|
depth += d
|
|
end = j
|
|
if found_open and depth == 0:
|
|
break
|
|
else:
|
|
# Let caddy validate report the malformed structure; don't make it deletable.
|
|
i += 1
|
|
continue
|
|
|
|
# Attach immediately preceding comment lines to this record so delete is tidy.
|
|
start = i
|
|
k = i - 1
|
|
while k >= 0 and managed[k].strip().startswith("#"):
|
|
start = k
|
|
k -= 1
|
|
|
|
raw_lines = managed[start : end + 1]
|
|
raw = "\n".join(raw_lines)
|
|
comments = [
|
|
line.strip()[1:].strip()
|
|
for line in managed[start:i]
|
|
if line.strip().startswith("#")
|
|
]
|
|
comment = " / ".join(x for x in comments if x)
|
|
|
|
m = re.search(r"(?m)^\s*reverse_proxy\s+([^\s{]+)", raw)
|
|
target = m.group(1) if m else "—"
|
|
lan_only = bool(re.search(r"(?m)^\s*@\w+\s+remote_ip\s+", raw))
|
|
|
|
records.append(
|
|
CaddyRecord(
|
|
record_id=_hash_id(raw),
|
|
site=header,
|
|
target=target,
|
|
comment=comment,
|
|
lan_only=lan_only,
|
|
start=start,
|
|
end=end,
|
|
raw=raw,
|
|
)
|
|
)
|
|
i = end + 1
|
|
|
|
return records
|
|
|
|
|
|
DNS_ADDRESS_RE = re.compile(r"^\s*address=/([^/]+)/([^/\s]+)\s*$")
|
|
DNS_LOCAL_RE = re.compile(r"^\s*local=/([^/]+)/\s*$")
|
|
|
|
|
|
def parse_dns_local_indices(managed: list[str]) -> dict[str, list[int]]:
|
|
local_indices: dict[str, list[int]] = {}
|
|
for idx, line in enumerate(managed):
|
|
m = DNS_LOCAL_RE.match(line)
|
|
if not m:
|
|
continue
|
|
local_indices.setdefault(m.group(1).lower(), []).append(idx)
|
|
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]:
|
|
records: list[DnsRecord] = []
|
|
local_indices = parse_dns_local_indices(managed)
|
|
for idx, line in enumerate(managed):
|
|
m = DNS_ADDRESS_RE.match(line)
|
|
if not m:
|
|
continue
|
|
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(), []))
|
|
records.append(
|
|
DnsRecord(
|
|
record_id=_hash_id(line),
|
|
domain=domain,
|
|
ip=ip,
|
|
service_key=service_key,
|
|
service_name=service_name,
|
|
address_index=idx,
|
|
local_indices=matching_local,
|
|
ipv6_blocked=bool(matching_local),
|
|
raw=line,
|
|
)
|
|
)
|
|
return records
|
|
|
|
|
|
def append_dns_lines(managed: list[str], lines: list[str]) -> None:
|
|
# Trailing blank lines inside the managed section are cosmetic. Remove them
|
|
# before appending so every logical dnsmasq entry stays compact.
|
|
while managed and not managed[-1].strip():
|
|
managed.pop()
|
|
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
|
|
# -----------------------------------------------------------------------------
|
|
|
|
|
|
HOST_RE = re.compile(
|
|
r"^(?:\*\.)?(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$",
|
|
re.IGNORECASE,
|
|
)
|
|
DOMAIN_RE = re.compile(
|
|
r"^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)*[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$",
|
|
re.IGNORECASE,
|
|
)
|
|
|
|
|
|
def validate_site(value: str) -> str:
|
|
value = value.strip().lower().rstrip(".")
|
|
if not HOST_RE.fullmatch(value):
|
|
raise ValueError("Invalid Caddy hostname.")
|
|
return value
|
|
|
|
|
|
def validate_upstream(value: str) -> str:
|
|
value = value.strip()
|
|
if not value:
|
|
raise ValueError("Upstream не задан.")
|
|
|
|
# Caddy accepts both full URLs (http://host:port) and network addresses
|
|
# 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:
|
|
raise ValueError("Upstream должен содержать имя хоста или IP-адрес.")
|
|
if parsed.username or parsed.password:
|
|
raise ValueError("Логин/пароль в upstream не разрешены.")
|
|
if parsed.path not in {"", "/"} or parsed.query or parsed.fragment:
|
|
raise ValueError("Upstream не должен содержать путь, query или fragment.")
|
|
|
|
try:
|
|
port = parsed.port
|
|
except ValueError as exc:
|
|
raise ValueError("Некорректный порт upstream.") from exc
|
|
|
|
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:
|
|
value = " ".join(value.replace("\r", " ").replace("\n", " ").split()).strip()
|
|
if len(value) > 120:
|
|
raise ValueError("Comment is too long (max 120 characters).")
|
|
return value
|
|
|
|
|
|
def validate_dns_domain(value: str) -> str:
|
|
value = value.strip().lower().rstrip(".")
|
|
leading_dot = value.startswith(".")
|
|
bare = value[1:] if leading_dot else value
|
|
if not DOMAIN_RE.fullmatch(bare):
|
|
raise ValueError("Invalid dnsmasq domain.")
|
|
return ("." if leading_dot else "") + bare
|
|
|
|
|
|
def validate_ip(value: str) -> str:
|
|
value = value.strip()
|
|
try:
|
|
return str(ipaddress.ip_address(value))
|
|
except ValueError as exc:
|
|
raise ValueError("Invalid IP address.") from exc
|
|
|
|
|
|
def build_caddy_block(site: str, upstream: str, comment: str, lan_only: bool) -> list[str]:
|
|
lines: list[str] = []
|
|
if comment:
|
|
lines.append(f"#{comment}")
|
|
lines.append(f"{site} {{")
|
|
if lan_only:
|
|
networks = " ".join(LAN_NETWORKS)
|
|
lines.extend(
|
|
[
|
|
f" @lan remote_ip {networks}",
|
|
"",
|
|
" handle @lan {",
|
|
f" reverse_proxy {upstream}",
|
|
" }",
|
|
"",
|
|
' respond "Forbidden" 403',
|
|
]
|
|
)
|
|
else:
|
|
lines.append(f" reverse_proxy {upstream}")
|
|
lines.append("}")
|
|
return lines
|
|
|
|
|
|
# -----------------------------------------------------------------------------
|
|
# File transaction / commands
|
|
# -----------------------------------------------------------------------------
|
|
|
|
|
|
def run_cmd(cmd: list[str], timeout: int = 20) -> tuple[bool, str]:
|
|
try:
|
|
cp = subprocess.run(
|
|
cmd,
|
|
text=True,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.STDOUT,
|
|
timeout=timeout,
|
|
check=False,
|
|
env={**os.environ, "PATH": "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"},
|
|
)
|
|
output = (cp.stdout or "").strip()
|
|
return cp.returncode == 0, output or f"exit code {cp.returncode}"
|
|
except (OSError, subprocess.TimeoutExpired) as exc:
|
|
return False, str(exc)
|
|
|
|
|
|
def atomic_write(path: Path, content: str, original_stat: os.stat_result | None = None) -> None:
|
|
path.parent.mkdir(parents=True, exist_ok=True)
|
|
if original_stat is None:
|
|
original_stat = path.stat()
|
|
|
|
fd, tmp_name = tempfile.mkstemp(prefix=f".{path.name}.", dir=str(path.parent), text=True)
|
|
tmp = Path(tmp_name)
|
|
try:
|
|
with os.fdopen(fd, "w", encoding="utf-8", newline="") as fh:
|
|
fh.write(content)
|
|
fh.flush()
|
|
os.fsync(fh.fileno())
|
|
os.chmod(tmp, original_stat.st_mode & 0o7777)
|
|
os.chown(tmp, original_stat.st_uid, original_stat.st_gid)
|
|
os.replace(tmp, path)
|
|
dir_fd = os.open(path.parent, os.O_DIRECTORY)
|
|
try:
|
|
os.fsync(dir_fd)
|
|
finally:
|
|
os.close(dir_fd)
|
|
finally:
|
|
if tmp.exists():
|
|
tmp.unlink(missing_ok=True)
|
|
|
|
|
|
def create_backup(path: Path, old_text: str) -> Path:
|
|
BACKUP_DIR.mkdir(parents=True, exist_ok=True)
|
|
stamp = datetime.now().strftime("%Y%m%d-%H%M%S-%f")
|
|
backup = BACKUP_DIR / f"{path.name}.{stamp}.bak"
|
|
with backup.open("w", encoding="utf-8", newline="") as fh:
|
|
fh.write(old_text)
|
|
st = path.stat()
|
|
os.chmod(backup, st.st_mode & 0o7777)
|
|
|
|
prefix = f"{path.name}."
|
|
backups = sorted(
|
|
[p for p in BACKUP_DIR.iterdir() if p.name.startswith(prefix) and p.name.endswith(".bak")],
|
|
key=lambda p: p.stat().st_mtime,
|
|
reverse=True,
|
|
)
|
|
for stale in backups[MAX_BACKUPS:]:
|
|
stale.unlink(missing_ok=True)
|
|
return backup
|
|
|
|
|
|
def apply_transaction(
|
|
path: Path,
|
|
expected_old_text: str,
|
|
new_text: str,
|
|
validate_cmd: list[str],
|
|
apply_cmd: list[str],
|
|
) -> tuple[bool, str]:
|
|
with CHANGE_LOCK:
|
|
old_text = read_text_exact(path)
|
|
if old_text != expected_old_text:
|
|
return False, "Config file changed since the page action started; nothing was written. Reload the page and try again."
|
|
if old_text == new_text:
|
|
return True, "No changes were necessary."
|
|
|
|
# Hard safety boundary: content outside the managed markers must be
|
|
# exactly identical before a write is allowed.
|
|
old_prefix, _, old_suffix, _ = split_managed_section(old_text)
|
|
new_prefix, _, new_suffix, _ = split_managed_section(new_text)
|
|
if old_prefix != new_prefix or old_suffix != new_suffix:
|
|
return False, "Safety check failed: text outside the markers changed; nothing was written."
|
|
|
|
stat = path.stat()
|
|
backup = create_backup(path, old_text)
|
|
atomic_write(path, new_text, stat)
|
|
|
|
valid, validation_output = run_cmd(validate_cmd)
|
|
if not valid:
|
|
atomic_write(path, old_text, stat)
|
|
return (
|
|
False,
|
|
"Validation failed; original file restored.\n"
|
|
f"Validator output:\n{validation_output}",
|
|
)
|
|
|
|
applied, apply_output = run_cmd(apply_cmd)
|
|
if applied:
|
|
return True, f"Applied successfully. Backup: {backup}"
|
|
|
|
# The file was valid, but service action failed. Restore the original
|
|
# config and make a best-effort attempt to reactivate it.
|
|
atomic_write(path, old_text, stat)
|
|
rollback_valid, rollback_validation = run_cmd(validate_cmd)
|
|
rollback_applied, rollback_apply = run_cmd(apply_cmd) if rollback_valid else (False, "rollback validation failed")
|
|
|
|
details = [
|
|
"Service reload/restart failed; original file restored.",
|
|
f"Apply output: {apply_output}",
|
|
f"Rollback validation: {rollback_validation}",
|
|
f"Rollback apply: {rollback_apply}",
|
|
]
|
|
if not rollback_applied:
|
|
details.append("WARNING: automatic rollback activation also failed; check the service immediately.")
|
|
return False, "\n".join(details)
|
|
|
|
|
|
# -----------------------------------------------------------------------------
|
|
# Auth / CSRF
|
|
# -----------------------------------------------------------------------------
|
|
|
|
|
|
def _auth_ok() -> bool:
|
|
auth = request.authorization
|
|
if not auth:
|
|
return False
|
|
return hmac.compare_digest(auth.username or "", ADMIN_USER) and hmac.compare_digest(
|
|
auth.password or "", ADMIN_PASSWORD
|
|
)
|
|
|
|
|
|
@app.before_request
|
|
def require_auth():
|
|
if AUTH_ENABLED and not _auth_ok():
|
|
return (
|
|
"Authentication required",
|
|
401,
|
|
{"WWW-Authenticate": 'Basic realm="Proxy Config"'},
|
|
)
|
|
|
|
|
|
def csrf_token() -> str:
|
|
token = session.get("csrf_token")
|
|
if not token:
|
|
token = secrets.token_urlsafe(32)
|
|
session["csrf_token"] = token
|
|
return token
|
|
|
|
|
|
app.jinja_env.globals["csrf_token"] = csrf_token
|
|
|
|
|
|
def require_csrf() -> None:
|
|
expected = session.get("csrf_token", "")
|
|
supplied = request.form.get("csrf_token", "")
|
|
if not expected or not hmac.compare_digest(expected, supplied):
|
|
abort(400, "Invalid CSRF token")
|
|
|
|
|
|
# -----------------------------------------------------------------------------
|
|
# Routes
|
|
# -----------------------------------------------------------------------------
|
|
|
|
|
|
def load_state():
|
|
caddy_text = read_text_exact(CADDYFILE)
|
|
dns_text = read_text_exact(DNSMASQ_CONF)
|
|
caddy_records = parse_caddy_records(get_managed_lines(caddy_text))
|
|
dns_records = parse_dns_records(get_managed_lines(dns_text))
|
|
caddy_status, caddy_status_text = run_cmd(CADDY_VALIDATE_CMD)
|
|
dns_status, dns_status_text = run_cmd(DNSMASQ_VALIDATE_CMD)
|
|
return caddy_records, dns_records, caddy_status, caddy_status_text, dns_status, dns_status_text
|
|
|
|
|
|
@app.get("/")
|
|
def index():
|
|
try:
|
|
state = load_state()
|
|
except Exception as exc:
|
|
state = ([], [], False, f"Cannot read Caddy config: {exc}", False, f"Cannot read dnsmasq config: {exc}")
|
|
|
|
dns_records = state[1]
|
|
xray_records = sorted(
|
|
(r for r in dns_records if r.service_key == "xray"),
|
|
key=lambda r: r.domain.lower(),
|
|
)
|
|
byedpi_records = sorted(
|
|
(r for r in dns_records if r.service_key == "byedpi"),
|
|
key=lambda r: r.domain.lower(),
|
|
)
|
|
other_dns_records = sorted(
|
|
(r for r in dns_records if r.service_key not in {"xray", "byedpi"}),
|
|
key=lambda r: r.domain.lower(),
|
|
)
|
|
|
|
return render_template_string(
|
|
TEMPLATE,
|
|
caddy_records=state[0],
|
|
xray_records=xray_records,
|
|
byedpi_records=byedpi_records,
|
|
other_dns_records=other_dns_records,
|
|
caddy_ok=state[2],
|
|
caddy_status=state[3],
|
|
dns_ok=state[4],
|
|
dns_status=state[5],
|
|
lan_networks=", ".join(LAN_NETWORKS),
|
|
dns_services=DNS_SERVICES,
|
|
auth_enabled=AUTH_ENABLED,
|
|
)
|
|
|
|
|
|
@app.post("/caddy/add")
|
|
def caddy_add():
|
|
require_csrf()
|
|
try:
|
|
site = validate_site(request.form.get("site", ""))
|
|
upstream = validate_upstream(request.form.get("upstream", ""))
|
|
comment = validate_comment(request.form.get("comment", ""))
|
|
lan_only = request.form.get("lan_only") == "on"
|
|
|
|
old = read_text_exact(CADDYFILE)
|
|
managed = get_managed_lines(old)
|
|
records = parse_caddy_records(managed)
|
|
existing_sites = {r.site.strip().lower() for r in records}
|
|
if site.lower() in existing_sites:
|
|
raise ValueError(f"Caddy entry for {site} already exists in the managed section.")
|
|
|
|
new_block = build_caddy_block(site, upstream, comment, lan_only)
|
|
if managed and managed[-1].strip():
|
|
managed.append("")
|
|
managed.extend(new_block)
|
|
new = replace_managed_lines(old, managed)
|
|
ok, message = apply_transaction(CADDYFILE, old, new, CADDY_VALIDATE_CMD, CADDY_APPLY_CMD)
|
|
flash(message, "success" if ok else "error")
|
|
except Exception as exc:
|
|
flash(str(exc), "error")
|
|
return redirect(url_for("index"))
|
|
|
|
|
|
@app.post("/caddy/delete")
|
|
def caddy_delete():
|
|
require_csrf()
|
|
record_id = request.form.get("record_id", "")
|
|
try:
|
|
old = read_text_exact(CADDYFILE)
|
|
managed = get_managed_lines(old)
|
|
records = parse_caddy_records(managed)
|
|
record = next((r for r in records if r.record_id == record_id), None)
|
|
if record is None:
|
|
raise ValueError("Caddy record not found; reload the page and try again.")
|
|
|
|
del managed[record.start : record.end + 1]
|
|
# Collapse excessive blank lines around the removed block.
|
|
compact: list[str] = []
|
|
for line in managed:
|
|
if line.strip() == "" and compact and compact[-1].strip() == "":
|
|
continue
|
|
compact.append(line)
|
|
while compact and compact[0].strip() == "":
|
|
compact.pop(0)
|
|
while compact and compact[-1].strip() == "":
|
|
compact.pop()
|
|
|
|
new = replace_managed_lines(old, compact)
|
|
ok, message = apply_transaction(CADDYFILE, old, new, CADDY_VALIDATE_CMD, CADDY_APPLY_CMD)
|
|
flash(message, "success" if ok else "error")
|
|
except Exception as exc:
|
|
flash(str(exc), "error")
|
|
return redirect(url_for("index"))
|
|
|
|
|
|
@app.post("/dns/add")
|
|
def dns_add():
|
|
require_csrf()
|
|
try:
|
|
domain = validate_dns_domain(request.form.get("domain", ""))
|
|
service = validate_dns_service(request.form.get("service", "xray"))
|
|
service_cfg = DNS_SERVICES[service]
|
|
ip = service_cfg["ip"]
|
|
|
|
old = read_text_exact(DNSMASQ_CONF)
|
|
managed = get_managed_lines(old)
|
|
result = upsert_dns_domain(managed, domain, ip)
|
|
|
|
if result == "unchanged":
|
|
flash(
|
|
f"{domain} уже направлен через {service_cfg['label']} ({ip}), IPv6 заблокирован.",
|
|
"success",
|
|
)
|
|
return redirect(url_for("index"))
|
|
|
|
new = replace_managed_lines(old, managed)
|
|
ok, message = apply_transaction(DNSMASQ_CONF, old, new, DNSMASQ_VALIDATE_CMD, DNSMASQ_APPLY_CMD)
|
|
if ok:
|
|
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")
|
|
except Exception as exc:
|
|
flash(str(exc), "error")
|
|
return redirect(url_for("index"))
|
|
|
|
@app.post("/dns/delete")
|
|
def dns_delete():
|
|
require_csrf()
|
|
record_id = request.form.get("record_id", "")
|
|
try:
|
|
old = read_text_exact(DNSMASQ_CONF)
|
|
managed = get_managed_lines(old)
|
|
records = parse_dns_records(managed)
|
|
record = next((r for r in records if r.record_id == record_id), None)
|
|
if record is None:
|
|
raise ValueError("dnsmasq record not found; reload the page and try again.")
|
|
|
|
# A domain is one logical record. Remove every managed address/local line
|
|
# for that exact domain so an orphaned IPv4 redirect or local rule cannot remain.
|
|
key = record.domain.lower()
|
|
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)
|
|
|
|
new = replace_managed_lines(old, filtered)
|
|
ok, message = apply_transaction(DNSMASQ_CONF, old, new, DNSMASQ_VALIDATE_CMD, DNSMASQ_APPLY_CMD)
|
|
flash(message, "success" if ok else "error")
|
|
except Exception as exc:
|
|
flash(str(exc), "error")
|
|
return redirect(url_for("index"))
|
|
|
|
|
|
|
|
@app.post("/dns/import")
|
|
def dns_import():
|
|
require_csrf()
|
|
try:
|
|
upload = request.files.get("file")
|
|
if upload is None or not upload.filename:
|
|
raise ValueError("Выберите текстовый файл со списком доменов.")
|
|
|
|
data = upload.stream.read(MAX_IMPORT_BYTES + 1)
|
|
if len(data) > MAX_IMPORT_BYTES:
|
|
raise ValueError(f"Файл слишком большой. Максимальный размер: {MAX_IMPORT_BYTES} байт.")
|
|
try:
|
|
imported_text = data.decode("utf-8-sig")
|
|
except UnicodeDecodeError as exc:
|
|
raise ValueError("Файл импорта должен быть в кодировке UTF-8.") from exc
|
|
|
|
entries: list[tuple[str, str]] = []
|
|
seen_import: set[str] = set()
|
|
errors: list[str] = []
|
|
for lineno, raw_line in enumerate(imported_text.splitlines(), start=1):
|
|
line = raw_line.strip()
|
|
if not line or line.startswith("#"):
|
|
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:
|
|
domain = validate_dns_domain(raw_domain)
|
|
service = validate_dns_service(raw_service)
|
|
except ValueError:
|
|
errors.append(f"строка {lineno}: {line}")
|
|
continue
|
|
|
|
key = domain.lower()
|
|
if key not in seen_import:
|
|
seen_import.add(key)
|
|
entries.append((domain, service))
|
|
|
|
if errors:
|
|
preview = "; ".join(errors[:8])
|
|
if len(errors) > 8:
|
|
preview += f"; ещё {len(errors) - 8}"
|
|
raise ValueError(f"В файле есть некорректные записи: {preview}")
|
|
if not entries:
|
|
raise ValueError("В файле не найдено ни одного домена.")
|
|
|
|
old = read_text_exact(DNSMASQ_CONF)
|
|
managed = get_managed_lines(old)
|
|
added = rerouted = repaired = unchanged = 0
|
|
|
|
for domain, service in entries:
|
|
result = upsert_dns_domain(managed, domain, DNS_SERVICES[service]["ip"])
|
|
if result == "added":
|
|
added += 1
|
|
elif result == "rerouted":
|
|
rerouted += 1
|
|
elif result == "repaired":
|
|
repaired += 1
|
|
else:
|
|
unchanged += 1
|
|
|
|
if not (added or rerouted or repaired):
|
|
flash(f"Изменений нет. Без изменений: {unchanged}.", "success")
|
|
return redirect(url_for("index"))
|
|
|
|
new = replace_managed_lines(old, managed)
|
|
ok, message = apply_transaction(DNSMASQ_CONF, old, new, DNSMASQ_VALIDATE_CMD, DNSMASQ_APPLY_CMD)
|
|
if ok:
|
|
message = (
|
|
f"Импорт завершён: новых {added}, переключено {rerouted}, исправлено {repaired}, "
|
|
f"без изменений {unchanged}.\n{message}"
|
|
)
|
|
flash(message, "success" if ok else "error")
|
|
except Exception as exc:
|
|
flash(str(exc), "error")
|
|
return redirect(url_for("index"))
|
|
|
|
@app.get("/dns/export")
|
|
def dns_export():
|
|
try:
|
|
text = read_text_exact(DNSMASQ_CONF)
|
|
records = parse_dns_records(get_managed_lines(text))
|
|
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:
|
|
content += "\n"
|
|
return Response(
|
|
content,
|
|
mimetype="text/plain; charset=utf-8",
|
|
headers={"Content-Disposition": "attachment; filename=dnsmasq-sites.txt"},
|
|
)
|
|
except Exception as exc:
|
|
flash(str(exc), "error")
|
|
return redirect(url_for("index"))
|
|
|
|
@app.get("/health")
|
|
def health():
|
|
return {"ok": True}
|
|
|
|
|
|
# -----------------------------------------------------------------------------
|
|
# UI
|
|
# -----------------------------------------------------------------------------
|
|
|
|
TEMPLATE = r"""
|
|
<!doctype html>
|
|
<html lang="ru">
|
|
<head>
|
|
<meta charset="utf-8">
|
|
<meta name="viewport" content="width=device-width,initial-scale=1">
|
|
<title>Proxy Config</title>
|
|
<style>
|
|
:root { color-scheme: dark; --bg:#101318; --card:#171b22; --muted:#8f99a8; --line:#2b313c; --good:#35c46a; --bad:#ff5d66; --accent:#5b9cff; }
|
|
* { box-sizing:border-box; }
|
|
body { margin:0; font:14px/1.45 system-ui,-apple-system,Segoe UI,sans-serif; background:var(--bg); color:#edf2f7; }
|
|
main { max-width:1180px; margin:0 auto; padding:28px 18px 60px; }
|
|
h1 { margin:0 0 6px; font-size:26px; }
|
|
h2 { margin:0; font-size:19px; }
|
|
.muted { color:var(--muted); }
|
|
.grid { display:grid; grid-template-columns:1fr 1fr; gap:18px; margin-top:18px; }
|
|
.card { background:var(--card); border:1px solid var(--line); border-radius:14px; padding:18px; box-shadow:0 8px 30px rgba(0,0,0,.16); }
|
|
.head { display:flex; align-items:center; justify-content:space-between; gap:12px; margin-bottom:14px; }
|
|
.status { display:inline-flex; align-items:center; gap:7px; color:var(--muted); font-size:12px; }
|
|
.dot { width:9px; height:9px; border-radius:50%; background:var(--bad); box-shadow:0 0 0 3px rgba(255,93,102,.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; }
|
|
label { display:block; color:var(--muted); font-size:12px; }
|
|
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, select:focus { border-color:var(--accent); }
|
|
.wide { grid-column:1/-1; }
|
|
.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.delete { background:transparent; color:#ff8c92; border:1px solid #65343a; padding:6px 9px; }
|
|
.button-link { display:inline-block; border-radius:8px; padding:9px 12px; color:#fff; background:#394456; text-decoration:none; font-weight:600; text-align:center; }
|
|
input[type=file] { width:100%; margin-top:5px; color:#cdd6e3; }
|
|
.dns-tools { display:grid; grid-template-columns:1fr auto; gap:10px; margin-bottom:16px; padding:13px; background:#12161c; border:1px solid var(--line); border-radius:11px; align-items:end; }
|
|
table { width:100%; border-collapse:collapse; }
|
|
th { text-align:left; font-size:11px; text-transform:uppercase; letter-spacing:.05em; color:var(--muted); padding:8px 7px; border-bottom:1px solid var(--line); }
|
|
td { padding:10px 7px; border-bottom:1px solid #242a33; vertical-align:top; }
|
|
td code { color:#c9dbff; word-break:break-all; }
|
|
.flash { white-space:pre-wrap; padding:12px 14px; margin:0 0 12px; border-radius:9px; border:1px solid; }
|
|
.flash.success { background:rgba(53,196,106,.08); border-color:#2b6740; }
|
|
.flash.error { background:rgba(255,93,102,.08); border-color:#71383d; }
|
|
details { margin-top:10px; color:var(--muted); }
|
|
pre { white-space:pre-wrap; word-break:break-word; font-size:12px; }
|
|
.tag { display:inline-block; padding:2px 7px; border:1px solid #3a4657; border-radius:999px; color:#b8c6d9; font-size:11px; }
|
|
.dns-group { margin-top:18px; border:1px solid var(--line); border-radius:11px; overflow:hidden; background:#12161c; }
|
|
.dns-group-head { display:flex; justify-content:space-between; align-items:center; gap:12px; padding:11px 13px; border-bottom:1px solid var(--line); }
|
|
.dns-group-title { display:flex; align-items:baseline; gap:8px; font-weight:700; }
|
|
.dns-group table { margin:0; }
|
|
.dns-group td:last-child, .dns-group th:last-child { width:1%; white-space:nowrap; }
|
|
.dns-warning { margin-top:18px; border-color:#735b2e; background:rgba(255,190,70,.04); }
|
|
@media (max-width:900px) { .grid { grid-template-columns:1fr; } }
|
|
@media (max-width:560px) { form.add { grid-template-columns:1fr; } .wide { grid-column:auto; } table { display:block; overflow-x:auto; } }
|
|
</style>
|
|
</head>
|
|
<body>
|
|
<main>
|
|
<h1>Proxy Config</h1>
|
|
<div class="muted">Управляемые секции Caddy и dnsmasq. Перед применением конфигурация проверяется, при ошибке выполняется откат.</div>
|
|
<div class="muted">Авторизация: {{ 'включена' if auth_enabled else 'отключена' }}.</div>
|
|
|
|
{% with messages = get_flashed_messages(with_categories=true) %}
|
|
{% for category, message in messages %}<div class="flash {{ category }}">{{ message }}</div>{% endfor %}
|
|
{% endwith %}
|
|
|
|
<div class="grid">
|
|
<section class="card">
|
|
<div class="head">
|
|
<h2>Caddy</h2>
|
|
<span class="status"><span class="dot {{ 'ok' if caddy_ok else '' }}"></span>{{ 'конфигурация OK' if caddy_ok else 'ошибка конфигурации' }}</span>
|
|
</div>
|
|
|
|
<form class="add" method="post" action="{{ url_for('caddy_add') }}">
|
|
<input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
|
|
<label>Имя сайта<input type="text" name="site" required placeholder="grafana.example.ru"></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="check wide"><input type="checkbox" name="lan_only"> Доступ только из LAN ({{ lan_networks }})</label>
|
|
<button class="wide" type="submit">Добавить Caddy proxy</button>
|
|
</form>
|
|
|
|
<table>
|
|
<thead><tr><th>Host</th><th>Upstream</th><th></th></tr></thead>
|
|
<tbody>
|
|
{% for r in caddy_records %}
|
|
<tr>
|
|
<td><strong>{{ r.site }}</strong>{% if r.comment %}<div class="muted">{{ r.comment }}</div>{% endif %}{% if r.lan_only %}<span class="tag">LAN only</span>{% endif %}</td>
|
|
<td><code>{{ r.target }}</code></td>
|
|
<td>
|
|
<form method="post" action="{{ url_for('caddy_delete') }}" onsubmit="return confirm('Удалить {{ r.site }}?')">
|
|
<input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
|
|
<input type="hidden" name="record_id" value="{{ r.record_id }}">
|
|
<button class="delete" type="submit">Удалить</button>
|
|
</form>
|
|
</td>
|
|
</tr>
|
|
{% else %}<tr><td colspan="3" class="muted">Записей не найдено.</td></tr>{% endfor %}
|
|
</tbody>
|
|
</table>
|
|
<details><summary>Результат caddy validate</summary><pre>{{ caddy_status }}</pre></details>
|
|
</section>
|
|
|
|
<section class="card">
|
|
<div class="head">
|
|
<h2>dnsmasq</h2>
|
|
<span class="status"><span class="dot {{ 'ok' if dns_ok else '' }}"></span>{{ 'конфигурация OK' if dns_ok else 'ошибка конфигурации' }}</span>
|
|
</div>
|
|
|
|
<form class="add" method="post" action="{{ url_for('dns_add') }}">
|
|
<input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
|
|
<label>Домен<input type="text" name="domain" required placeholder="example.com или .example.com"></label>
|
|
<label>Сервис
|
|
<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 class="dns-tools" method="post" action="{{ url_for('dns_import') }}" enctype="multipart/form-data">
|
|
<input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
|
|
<label>Импорт (.txt): domain;XRAY или domain;ByeDPI. Старый формат domain = XRAY<input type="file" name="file" accept=".txt,text/plain" required></label>
|
|
<button type="submit">Импортировать</button>
|
|
</form>
|
|
<p><a class="button-link" href="{{ url_for('dns_export') }}">Экспортировать список доменов</a></p>
|
|
|
|
<div class="dns-group">
|
|
<div class="dns-group-head">
|
|
<div class="dns-group-title">
|
|
<span>XRAY</span>
|
|
<span class="tag">{{ xray_records|length }} доменов</span>
|
|
</div>
|
|
<code>{{ dns_services['xray']['ip'] }}</code>
|
|
</div>
|
|
<table>
|
|
<thead><tr><th>Domain</th><th>IPv6</th><th></th></tr></thead>
|
|
<tbody>
|
|
{% for r in xray_records %}
|
|
<tr>
|
|
<td><strong>{{ r.domain }}</strong></td>
|
|
<td>{% if r.ipv6_blocked %}<span class="tag">заблокирован</span>{% else %}<span class="muted">нет local=</span>{% endif %}</td>
|
|
<td>
|
|
<form method="post" action="{{ url_for('dns_delete') }}" onsubmit="return confirm('Удалить {{ r.domain }} из XRAY?')">
|
|
<input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
|
|
<input type="hidden" name="record_id" value="{{ r.record_id }}">
|
|
<button class="delete" type="submit">Удалить</button>
|
|
</form>
|
|
</td>
|
|
</tr>
|
|
{% else %}
|
|
<tr><td colspan="3" class="muted">Нет доменов, направленных через XRAY.</td></tr>
|
|
{% endfor %}
|
|
</tbody>
|
|
</table>
|
|
</div>
|
|
|
|
<div class="dns-group">
|
|
<div class="dns-group-head">
|
|
<div class="dns-group-title">
|
|
<span>ByeDPI</span>
|
|
<span class="tag">{{ byedpi_records|length }} доменов</span>
|
|
</div>
|
|
<code>{{ dns_services['byedpi']['ip'] }}</code>
|
|
</div>
|
|
<table>
|
|
<thead><tr><th>Domain</th><th>IPv6</th><th></th></tr></thead>
|
|
<tbody>
|
|
{% for r in byedpi_records %}
|
|
<tr>
|
|
<td><strong>{{ r.domain }}</strong></td>
|
|
<td>{% if r.ipv6_blocked %}<span class="tag">заблокирован</span>{% else %}<span class="muted">нет local=</span>{% endif %}</td>
|
|
<td>
|
|
<form method="post" action="{{ url_for('dns_delete') }}" onsubmit="return confirm('Удалить {{ r.domain }} из ByeDPI?')">
|
|
<input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
|
|
<input type="hidden" name="record_id" value="{{ r.record_id }}">
|
|
<button class="delete" type="submit">Удалить</button>
|
|
</form>
|
|
</td>
|
|
</tr>
|
|
{% else %}
|
|
<tr><td colspan="3" class="muted">Нет доменов, направленных через ByeDPI.</td></tr>
|
|
{% endfor %}
|
|
</tbody>
|
|
</table>
|
|
</div>
|
|
|
|
{% if other_dns_records %}
|
|
<div class="dns-group dns-warning">
|
|
<div class="dns-group-head">
|
|
<div class="dns-group-title">
|
|
<span>Другие маршруты</span>
|
|
<span class="tag">{{ other_dns_records|length }}</span>
|
|
</div>
|
|
<span class="muted">IP не соответствует XRAY/ByeDPI</span>
|
|
</div>
|
|
<table>
|
|
<thead><tr><th>Domain</th><th>IPv4</th><th>IPv6</th><th></th></tr></thead>
|
|
<tbody>
|
|
{% for r in other_dns_records %}
|
|
<tr>
|
|
<td><strong>{{ r.domain }}</strong></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>
|
|
<form method="post" action="{{ url_for('dns_delete') }}" onsubmit="return confirm('Удалить {{ r.domain }}?')">
|
|
<input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
|
|
<input type="hidden" name="record_id" value="{{ r.record_id }}">
|
|
<button class="delete" type="submit">Удалить</button>
|
|
</form>
|
|
</td>
|
|
</tr>
|
|
{% endfor %}
|
|
</tbody>
|
|
</table>
|
|
</div>
|
|
{% endif %}
|
|
<details><summary>Результат dnsmasq --test</summary><pre>{{ dns_status }}</pre></details>
|
|
</section>
|
|
</div>
|
|
</main>
|
|
</body>
|
|
</html>
|
|
"""
|
|
|
|
|
|
if __name__ == "__main__":
|
|
# For manual testing only. The systemd unit uses gunicorn.
|
|
app.run(host="127.0.0.1", port=8090, debug=False)
|