ad6cdab418
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).
99 lines
5.7 KiB
Python
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()
|