From b0af17bcb4f3ca7a41ccf53a63c3d4c99e38e106 Mon Sep 17 00:00:00 2001
From: chuan <pchuan98@qq.com>
Date: Thu, 28 May 2026 00:34:54 +0800
Subject: [PATCH] =?UTF-8?q?feat:=20=E5=AE=9E=E7=8E=B0=20fake=20dns?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 pyproject.toml                        |  2 +-
 pyxray/libs/xray_config/generator.py  | 20 +++++++++++++++++++-
 pyxray/libs/xray_config/settings.py   |  1 +
 pyxray/web/templates/configs/dns.html |  4 ++++
 pyxray/web/xray_config.py             |  1 +
 tests/libs/test_xray_config.py        | 26 ++++++++++++++++++++++++++
 tests/web/test_xray_assets_web.py     |  7 ++++++-
 7 files changed, 58 insertions(+), 3 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index 78d143d..6112a27 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "pyxray"
-version = "1.0.4"
+version = "1.0.5"
 description = "A lightweight Linux xray control plane."
 readme = "README.md"
 requires-python = ">=3.14"
diff --git a/pyxray/libs/xray_config/generator.py b/pyxray/libs/xray_config/generator.py
index fa89994..a9cefef 100644
--- a/pyxray/libs/xray_config/generator.py
+++ b/pyxray/libs/xray_config/generator.py
@@ -31,6 +31,8 @@ def generate_xray_config(node: Node, settings: XrayConfigSettings | None = None)
     log = _build_log(settings)
     if log:
         config["log"] = log
+    if _fakedns_enabled(settings):
+        config["fakedns"] = [{"ipPool": "198.18.0.0/15", "poolSize": 65535}]
     config["routing"]["rules"].extend(_build_dns_routing(settings))
     config["routing"]["rules"].append({"type": "field", "inboundTag": _dns_inbound_tags(settings), "outboundTag": "dns-out"})
     config["routing"]["rules"].extend(_build_rule_port_routing(settings))
@@ -157,9 +159,12 @@ def _transparent_inbounds(settings: XrayConfigSettings) -> list[dict[str, Any]]:
 def _with_sniffing(inbound: dict[str, Any], settings: XrayConfigSettings) -> dict[str, Any]:
     if settings.inbounds.inbound_sniffing == "disable":
         return inbound
+    dest_override = settings.inbounds.inbound_sniffing.split(",")
+    if _fakedns_enabled(settings) and "fakedns" not in dest_override:
+        dest_override.append("fakedns")
     inbound["sniffing"] = {
         "enabled": True,
-        "destOverride": settings.inbounds.inbound_sniffing.split(","),
+        "destOverride": dest_override,
         "domainsExcluded": _split_lines(settings.inbounds.domains_excluded),
         "routeOnly": settings.inbounds.route_only,
     }
@@ -207,6 +212,9 @@ def _dns_inbound_tags(settings: XrayConfigSettings) -> list[str]:
 
 def _build_dns(settings: XrayConfigSettings, node: Node) -> dict[str, Any]:
     servers: list[Any] = []
+    fakedns_domains = _fakedns_domains(settings)
+    if fakedns_domains:
+        servers.append({"address": "fakedns", "domains": fakedns_domains})
     routing_domains = _domains_to_lookup(settings, node)
     for rule in settings.dns.rules:
         domains = _split_lines(rule.domains)
@@ -230,6 +238,16 @@ def _build_dns(settings: XrayConfigSettings, node: Node) -> dict[str, Any]:
     return dns
 
 
+def _fakedns_enabled(settings: XrayConfigSettings) -> bool:
+    return settings.dns.special_mode == "fakedns"
+
+
+def _fakedns_domains(settings: XrayConfigSettings) -> list[str]:
+    if not _fakedns_enabled(settings):
+        return []
+    return _split_lines(settings.dns.fakedns_domains) or ["geosite:geolocation-!cn"]
+
+
 def _dns_server(rule: DnsRuleSettings, domains: list[str]) -> Any:
     address, port = _parse_dns_addr(rule.server)
     server_address = rule.server if "://" in rule.server else address
diff --git a/pyxray/libs/xray_config/settings.py b/pyxray/libs/xray_config/settings.py
index 5c8e5c1..1363771 100644
--- a/pyxray/libs/xray_config/settings.py
+++ b/pyxray/libs/xray_config/settings.py
@@ -126,6 +126,7 @@ class DnsSettings:
     )
     antipollution: str = "closed"
     special_mode: str = "none"
+    fakedns_domains: str = "geosite:geolocation-!cn"
 
 
 @dataclass(slots=True)
diff --git a/pyxray/web/templates/configs/dns.html b/pyxray/web/templates/configs/dns.html
index 94d1058..cf7576e 100644
--- a/pyxray/web/templates/configs/dns.html
+++ b/pyxray/web/templates/configs/dns.html
@@ -43,6 +43,10 @@
       </select>
     </label>
   </div>
+  <label class="config-field mt-4">
+    <span>FakeDNS 域名范围，每行一个 domain/geosite/keyword 规则</span>
+    <textarea name="dns.fakedns_domains" placeholder="geosite:geolocation-!cn">{{ settings.dns.fakedns_domains }}</textarea>
+  </label>
   <label class="config-field mt-4">
     <span>DNS 规则，每行 server|domains|outbound</span>
     <textarea name="dns.rules">{% for item in settings.dns.rules %}{{ item.server }}|{{ item.domains }}|{{ item.outbound }}
diff --git a/pyxray/web/xray_config.py b/pyxray/web/xray_config.py
index dc341a1..466f1fb 100644
--- a/pyxray/web/xray_config.py
+++ b/pyxray/web/xray_config.py
@@ -203,6 +203,7 @@ def _settings_from_request() -> XrayConfigSettings:
     settings.dns.local_dns_listen = _bool("dns.local_dns_listen")
     settings.dns.antipollution = form.get("dns.antipollution", settings.dns.antipollution)
     settings.dns.special_mode = form.get("dns.special_mode", settings.dns.special_mode)
+    settings.dns.fakedns_domains = form.get("dns.fakedns_domains", settings.dns.fakedns_domains)
     settings.dns.rules = [
         DnsRuleSettings(server=parts[0], domains=parts[1], outbound=parts[2])
         for parts in _split_table("dns.rules", 3)
diff --git a/tests/libs/test_xray_config.py b/tests/libs/test_xray_config.py
index c7c3dd9..1355109 100644
--- a/tests/libs/test_xray_config.py
+++ b/tests/libs/test_xray_config.py
@@ -89,6 +89,8 @@ def test_settings_defaults_match_v2raya_core_values() -> None:
     assert settings.transparent.docker_transparent_cidrs == "172.16.0.0/12"
     assert settings.transparent.output_bypass_rules == ""
     assert settings.dns.query_strategy == "UseIPv4"
+    assert settings.dns.special_mode == "none"
+    assert settings.dns.fakedns_domains == "geosite:geolocation-!cn"
     assert settings.dns.rules == [
         DnsRuleSettings(server="localhost", domains="geosite:private", outbound="direct"),
         DnsRuleSettings(server="223.5.5.5", domains="geosite:cn", outbound="direct"),
@@ -403,6 +405,30 @@ def test_generate_dns_rules_and_dns_routing() -> None:
     assert any(rule.get("domain") == ["dns.google"] and rule.get("outboundTag") == "proxy" for rule in config["routing"]["rules"])
 
 
+def test_generate_fakedns_adds_dns_server_pool_and_sniffing() -> None:
+    settings = XrayConfigSettings()
+    settings.transparent.mode = "gfwlist"
+    settings.transparent.type = "redirect"
+    settings.dns.special_mode = "fakedns"
+
+    config = generate_xray_config(parse_node_link(_ss_link()), settings)
+
+    assert config["fakedns"] == [{"ipPool": "198.18.0.0/15", "poolSize": 65535}]
+    assert {"address": "fakedns", "domains": ["geosite:geolocation-!cn"]} in config["dns"]["servers"]
+    assert "fakedns" in _inbound(config, "transparent")["sniffing"]["destOverride"]
+    assert "fakedns" in _inbound(config, "rule-mixed")["sniffing"]["destOverride"]
+
+
+def test_generate_fakedns_uses_custom_domain_scope() -> None:
+    settings = XrayConfigSettings()
+    settings.dns.special_mode = "fakedns"
+    settings.dns.fakedns_domains = "geosite:gfw\nkeyword:example"
+
+    config = generate_xray_config(parse_node_link(_ss_link()), settings)
+
+    assert {"address": "fakedns", "domains": ["geosite:gfw", "keyword:example"]} in config["dns"]["servers"]
+
+
 def test_validate_settings_rejects_invalid_values() -> None:
     settings = XrayConfigSettings()
     settings.transparent.type = "bad"
diff --git a/tests/web/test_xray_assets_web.py b/tests/web/test_xray_assets_web.py
index 9353c0b..af3a676 100644
--- a/tests/web/test_xray_assets_web.py
+++ b/tests/web/test_xray_assets_web.py
@@ -667,7 +667,8 @@ def test_xray_config_api_saves_settings_from_form_controls(tmp_path: Path) -> No
             "dns.query_strategy": "UseIPv4",
             "dns.local_dns_listen": "on",
             "dns.antipollution": "closed",
-            "dns.special_mode": "none",
+            "dns.special_mode": "fakedns",
+            "dns.fakedns_domains": "geosite:gfw\nkeyword:example",
             "dns.rules": "localhost|geosite:private|direct\n8.8.8.8||proxy",
             "outbounds.0.tag": "proxy",
             "outbounds.0.probe_url": "https://www.gstatic.com/generate_204",
@@ -691,6 +692,8 @@ def test_xray_config_api_saves_settings_from_form_controls(tmp_path: Path) -> No
     assert "auth_password = \"secret\"" in saved.get_json()["settings_toml"]
     assert "route_only = true" in saved.get_json()["settings_toml"]
     assert "output_bypass_rules = \"tcp 117.72.47.28:33010\"" in saved.get_json()["settings_toml"]
+    assert "special_mode = \"fakedns\"" in saved.get_json()["settings_toml"]
+    assert "fakedns_domains = \"geosite:gfw\\nkeyword:example\"" in saved.get_json()["settings_toml"]
     assert generated.status_code == 200
     assert config["log"]["loglevel"] == "error"
     assert any(inbound["tag"] == "rule-mixed" and inbound["port"] == 20181 for inbound in config["inbounds"])
@@ -699,6 +702,8 @@ def test_xray_config_api_saves_settings_from_form_controls(tmp_path: Path) -> No
     ]
     assert config["outbounds"][0]["mux"] == {"enabled": True, "concurrency": 16}
     assert config["dns"]["queryStrategy"] == "UseIPv4"
+    assert config["fakedns"] == [{"ipPool": "198.18.0.0/15", "poolSize": 65535}]
+    assert {"address": "fakedns", "domains": ["geosite:gfw", "keyword:example"]} in config["dns"]["servers"]
 
 
 def test_xray_config_api_mux_zero_disables_mux(tmp_path: Path) -> None: