Files
pipelines/scripts/test_web_access.py
alan ad6cdab418 Listen on loopback and tailnet by default; make the plain-HTTP LAN opt-in
The web proxy binds the wildcard and drops connections that are not
loopback or Tailscale at both ends. A LAN listener is opt-in (web.lan) and
refuses sign-in and signed-in pages over plain HTTP unless
web.lan_plain_login is set. Existing installs keep their bind address with
a warning. Without the LAN the mDNS advert carries only the tailnet and
public routes (lan=0).
2026-11-10 01:02:02 +00:00

99 lines
5.7 KiB
Python

import importlib.util
from pathlib import Path
import subprocess
import unittest
from unittest.mock import patch
spec = importlib.util.spec_from_file_location("web_access", Path(__file__).with_name("web_access.py"))
web_access = importlib.util.module_from_spec(spec)
spec.loader.exec_module(web_access)
manage_spec = importlib.util.spec_from_file_location("manage_web", Path(__file__).with_name("manage.py"))
manage = importlib.util.module_from_spec(manage_spec)
manage_spec.loader.exec_module(manage)
def reply(stdout="", code=0):
return subprocess.CompletedProcess([], code, stdout=stdout, stderr="")
class ResolveTests(unittest.TestCase):
def test_fresh_install_defaults_to_loopback_and_tailnet(self):
self.assertEqual(web_access.resolve(None, None, None, set()),
({"host": "tailnet", "lan": False, "lan_plain_login": False}, []))
def test_an_existing_all_interfaces_host_is_kept_with_a_warning(self):
listen, warnings = web_access.resolve("0.0.0.0", None, None, set())
self.assertEqual(listen["host"], "0.0.0.0")
self.assertEqual(len(warnings), 1)
self.assertIn("cross it unencrypted", warnings[0])
self.assertIn("--web-host tailnet", warnings[0])
self.assertEqual(web_access.resolve("127.0.0.1", None, None, set())[1], [])
def test_lan_is_opt_in_and_plain_login_needs_lan(self):
listen, warnings = web_access.resolve("0.0.0.0", True, None, {"--web-lan"})
self.assertEqual(listen, {"host": "tailnet", "lan": True, "lan_plain_login": False})
self.assertEqual(warnings, [])
listen, warnings = web_access.resolve("tailnet", True, True, set())
self.assertTrue(listen["lan_plain_login"])
self.assertIn("lan_plain_login is on", warnings[0])
self.assertFalse(web_access.resolve("tailnet", False, True, set())[0]["lan_plain_login"])
with self.assertRaisesRegex(ValueError, "applies to --web-host tailnet"):
web_access.resolve("0.0.0.0", True, None, {"--web-host", "--web-lan"})
with self.assertRaisesRegex(ValueError, "Invalid --web-host"):
web_access.resolve("0.0.0.0\nX=1", None, None, {"--web-host"})
def test_urls_follow_where_a_browser_can_sign_in(self):
tailnet = {"host": "tailnet", "lan": False}
self.assertEqual(web_access.default_url_host(tailnet, "192.168.1.20", "100.85.25.33"), "100.85.25.33")
self.assertEqual(web_access.default_url_host(tailnet, "192.168.1.20", None), "127.0.0.1")
self.assertEqual(web_access.default_url_host({"host": "tailnet", "lan": True, "lan_plain_login": True},
"192.168.1.20", None), "192.168.1.20")
self.assertEqual(web_access.default_url_host({"host": "0.0.0.0"}, "192.168.1.20", None), "192.168.1.20")
self.assertIsNotNone(web_access.public_url_warning("http://192.168.1.20:8083", tailnet))
for url in ("https://box.tail1.ts.net:8443", "http://100.85.25.33:8083", "http://127.0.0.1:8083", ""):
self.assertIsNone(web_access.public_url_warning(url, tailnet), url)
self.assertIsNone(web_access.public_url_warning("http://192.168.1.20:8083", {"host": "0.0.0.0"}))
def test_tailnet_address_and_firewall_are_read_only_probes(self):
calls = []
def runner(command, **_):
calls.append(command)
return reply("100.85.25.33\n") if command[-1] == "-4" else reply("Firewall is disabled. (State = 0)\n")
with patch.object(web_access.shutil, "which", return_value="/usr/bin/tailscale"):
self.assertEqual(web_access.tailnet_ipv4(runner), "100.85.25.33")
self.assertIsNone(web_access.tailnet_ipv4(lambda *a, **k: reply("10.0.0.5\n")))
self.assertIsNone(web_access.tailnet_ipv4(lambda *a, **k: reply("", 1)))
with patch.object(web_access.shutil, "which", return_value=None):
self.assertIsNone(web_access.tailnet_ipv4(runner))
with patch.object(web_access.platform, "system", return_value="Darwin"), \
patch.object(web_access, "FIREWALL", Path(__file__)):
self.assertIn("firewall is off", web_access.firewall_note(runner))
self.assertIsNone(web_access.firewall_note(lambda *a, **k: reply("Firewall is enabled. (State = 1)\n")))
self.assertEqual(calls[-1], [__file__, "--getglobalstate"])
class ManageWebTests(unittest.TestCase):
def test_proxy_flags_follow_the_manifest(self):
self.assertEqual(manage.web_listen_args({"host": "0.0.0.0"}), ["--host", "0.0.0.0"])
self.assertEqual(manage.web_listen_args({"host": "tailnet"}),
["--host", "::", "--allow", "loopback,tailnet"])
self.assertEqual(manage.web_listen_args({"host": "tailnet", "lan": True}),
["--host", "::", "--allow", "loopback,tailnet,lan"])
self.assertEqual(manage.web_listen_args({"host": "tailnet", "lan": True, "lan_plain_login": True}),
["--host", "::", "--allow", "loopback,tailnet,lan", "--lan-plain-login"])
self.assertEqual(manage.web_listen_args({"host": "tailnet", "lan_plain_login": True}),
["--host", "::", "--allow", "loopback,tailnet"])
def test_mdns_omits_the_lan_route_when_the_proxy_refuses_the_lan(self):
port = {"port": 8083}
self.assertEqual(manage.mdns_args({"web": {**port, "host": "tailnet"}}), ["-mdns-port", "8083", "-mdns-lan=false"])
self.assertEqual(manage.mdns_args({"web": {**port, "host": "tailnet", "lan": True}}), ["-mdns-port", "8083"])
self.assertEqual(manage.mdns_args({"web": {**port, "host": "0.0.0.0"}}), ["-mdns-port", "8083"])
self.assertEqual(manage.mdns_args({"web": {**port, "host": "127.0.0.1"}}), [])
if __name__ == "__main__":
unittest.main()