259 lines
12 KiB
Python
259 lines
12 KiB
Python
import io
|
|
from pathlib import Path
|
|
import shutil
|
|
import ssl
|
|
import subprocess
|
|
import tempfile
|
|
import unittest
|
|
from unittest.mock import patch
|
|
|
|
from cryptography import x509
|
|
import yaml
|
|
|
|
import homegate as h
|
|
import sync_ssh as s
|
|
|
|
BASE = Path(__file__).resolve().parents[1]
|
|
|
|
|
|
class MemorySocket:
|
|
"""Feed an actual BaseHTTPRequestHandler without binding a network port."""
|
|
def __init__(self, data):
|
|
self.input = io.BytesIO(data)
|
|
self.output = b""
|
|
|
|
def makefile(self, *args):
|
|
return self.input
|
|
|
|
def sendall(self, data):
|
|
self.output += data
|
|
|
|
def settimeout(self, value):
|
|
pass
|
|
|
|
|
|
class SSHAndZonesTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.temp = tempfile.TemporaryDirectory(prefix="homegate test ")
|
|
self.addCleanup(self.temp.cleanup)
|
|
self.root = Path(self.temp.name)
|
|
self.path = self.root / "services.yaml"
|
|
self.raw = yaml.safe_load((BASE / "config/services.yaml").read_text())
|
|
self.write()
|
|
|
|
def write(self):
|
|
self.path.write_text(yaml.safe_dump(self.raw))
|
|
|
|
def config(self):
|
|
return h.load_config(self.path)
|
|
|
|
def rendered(self):
|
|
return s.render_ssh(h.ssh_entries(self.config()))
|
|
|
|
def test_service_ssh_uses_vm_address_and_fqdn_alias(self):
|
|
rendered = self.rendered()
|
|
self.assertIn("Host pve pve.home\n HostName 192.168.0.137\n Port 22\n User root", rendered)
|
|
self.assertNotIn("192.168.0.10", rendered)
|
|
self.assertEqual(rendered, s.validate_download(rendered.encode()))
|
|
|
|
def test_separate_ssh_hosts_and_custom_ports(self):
|
|
self.raw["ssh_hosts"] = [{"aliases": ["backup", "backup.lab.internal"], "host": "192.168.0.150",
|
|
"port": 2222, "user": "admin"}]
|
|
self.write()
|
|
self.assertIn("Host backup backup.lab.internal\n HostName 192.168.0.150\n Port 2222", self.rendered())
|
|
|
|
def test_disabled_entries_disappear_and_empty_inventory_is_valid(self):
|
|
self.raw["services"][0]["ssh"]["enabled"] = False
|
|
self.write()
|
|
self.assertNotIn("Host pve", self.rendered())
|
|
self.assertEqual(self.rendered(), s.validate_download(self.rendered().encode()))
|
|
|
|
def test_duplicate_alias_and_malicious_user_are_rejected(self):
|
|
self.raw["ssh_hosts"] = [{"aliases": ["pve"], "host": "192.168.0.150", "port": 22}]
|
|
self.write()
|
|
with self.assertRaises(ValueError):
|
|
self.config()
|
|
self.raw.pop("ssh_hosts")
|
|
self.raw["services"][0]["ssh"]["user"] = "root\nProxyCommand touch /tmp/not-allowed"
|
|
self.write()
|
|
with self.assertRaises(ValueError):
|
|
self.config()
|
|
|
|
def test_ssh_ipv6_accepts_ula_without_scope_or_tokens(self):
|
|
entry = {"aliases": ["ipv6-vm"], "host": "fd12:3456::1", "port": 22}
|
|
self.assertIn("HostName fd12:3456::1", s.render_ssh([entry]))
|
|
for host in ("fd12:3456::1%h", "fd12:3456::1%eth0\nProxyCommand bad", "fe80::1"):
|
|
with self.subTest(host=host), self.assertRaises(ValueError):
|
|
s.render_ssh([dict(entry, host=host)])
|
|
def test_export_acl_and_no_arbitrary_files(self):
|
|
for peer, code in [("192.168.0.20", 200), ("192.168.1.20", 403), ("8.8.8.8", 403),
|
|
("::ffff:192.168.0.20", 200), ("127.0.0.1", 403)]:
|
|
with self.subTest(peer=peer):
|
|
self.assertEqual(code, h.export_response("/ssh-config", peer, self.path)[0])
|
|
for path in ("/ca.json", "/root-ca.crt", "/../state/ca.json", "/ssh-config?file=ca.json", "/"):
|
|
self.assertEqual(404, h.export_response(path, "192.168.0.20", self.path)[0])
|
|
self.assertEqual(200, h.export_response("/healthz", "127.0.0.1", self.path)[0])
|
|
|
|
def request(self, target="/ssh-config", peer="192.168.0.20", headers=""):
|
|
sock = MemorySocket((f"GET {target} HTTP/1.1\r\nHost: test\r\n{headers}\r\n").encode())
|
|
h.export_handler(self.path)(sock, (peer, 5000), None)
|
|
return sock.output
|
|
|
|
def test_http_handler_download_and_forwarded_header_cannot_bypass_acl(self):
|
|
response = self.request()
|
|
self.assertIn(b"200 OK", response)
|
|
self.assertEqual(self.rendered(), s.validate_download(response.split(b"\r\n\r\n", 1)[1]))
|
|
denied = self.request(peer="8.8.8.8", headers="X-Forwarded-For: 192.168.0.20\r\n")
|
|
self.assertIn(b"403 Forbidden", denied)
|
|
self.assertNotIn(b"192.168.0.137", denied)
|
|
|
|
def test_http_export_fails_closed_on_invalid_config(self):
|
|
self.path.write_text("invalid: [\n")
|
|
self.assertIn(b"503 Service Unavailable", self.request())
|
|
|
|
def test_dangerous_downloaded_directives_are_rejected(self):
|
|
original = self.rendered()
|
|
candidates = [original.replace(" Port 22", " ProxyCommand touch /tmp/forbidden\n Port 22"),
|
|
original.replace(" Port 22", " Include /tmp/other\n Port 22"),
|
|
original.replace(" Port 22", "Match exec echo bad\n Port 22"),
|
|
original.replace("Host pve pve.home", "Host *"),
|
|
original.replace(" StrictHostKeyChecking ask", " StrictHostKeyChecking no"),
|
|
original.replace("192.168.0.137", "8.8.8.8"),
|
|
original + " ProxyCommand bad\n",
|
|
original.replace(" Port 22", " Port 22\x00"),
|
|
"<html>not a config</html>", original * 10000]
|
|
for text in candidates:
|
|
with self.subTest(text=text[:40]), self.assertRaises(ValueError):
|
|
s.validate_download(text.encode())
|
|
|
|
def test_install_preserves_existing_config_and_is_idempotent(self):
|
|
sshdir = self.root / ".ssh"
|
|
sshdir.mkdir()
|
|
original = b"Host work\n HostName 10.1.2.3\nHost pve\n User operator\n"
|
|
(sshdir / "config").write_bytes(original)
|
|
target = s.install_config(self.rendered(), sshdir, add_include=True)
|
|
installed = (sshdir / "config").read_bytes()
|
|
self.assertTrue(installed.startswith(original))
|
|
self.assertEqual(1, installed.count(s.BEGIN.encode()))
|
|
backups = list(sshdir.glob("config.before-homegate-*"))
|
|
self.assertEqual(1, len(backups))
|
|
self.assertEqual(original, backups[0].read_bytes())
|
|
s.install_config(self.rendered(), sshdir, add_include=True)
|
|
self.assertEqual(installed, (sshdir / "config").read_bytes())
|
|
self.assertEqual(1, len(list(sshdir.glob("config.before-homegate-*"))))
|
|
self.assertEqual(0o600, target.stat().st_mode & 0o777)
|
|
if shutil.which("ssh"):
|
|
result = subprocess.run(["ssh", "-G", "-F", str(sshdir / "config"), "pve"],
|
|
capture_output=True, text=True, check=True)
|
|
self.assertIn("hostname 192.168.0.137\n", result.stdout)
|
|
self.assertIn("user operator\n", result.stdout)
|
|
self.assertIn("port 22\n", result.stdout)
|
|
|
|
def test_invalid_download_never_replaces_local_files(self):
|
|
sshdir = self.root / ".ssh"
|
|
target = s.install_config(self.rendered(), sshdir, add_include=True)
|
|
previous = target.read_bytes()
|
|
with self.assertRaises(ValueError):
|
|
s.install_config("Match exec evil\n", sshdir, add_include=True)
|
|
self.assertEqual(previous, target.read_bytes())
|
|
|
|
def test_download_failure_leaves_file_unchanged_and_no_redirects(self):
|
|
sshdir = self.root / ".ssh"
|
|
target = s.install_config(self.rendered(), sshdir)
|
|
previous = target.read_bytes()
|
|
with patch.object(s, "build_opener") as build:
|
|
build.return_value.open.side_effect = OSError("offline")
|
|
with self.assertRaises(OSError):
|
|
s.download("http://192.168.0.10:8099/ssh-config")
|
|
self.assertEqual(previous, target.read_bytes())
|
|
with self.assertRaises(ValueError):
|
|
s.NoRedirect().redirect_request(None, None, 302, "", {}, "http://other")
|
|
|
|
def test_symlink_target_is_not_overwritten(self):
|
|
sshdir = self.root / ".ssh"
|
|
target = s.install_config(self.rendered(), sshdir)
|
|
elsewhere = self.root / "elsewhere"
|
|
elsewhere.write_text("preserved")
|
|
target.unlink()
|
|
target.symlink_to(elsewhere)
|
|
with self.assertRaises(ValueError):
|
|
s.install_config(self.rendered(), sshdir)
|
|
self.assertEqual("preserved", elsewhere.read_text())
|
|
|
|
def test_multiple_custom_zones_and_label_boundaries(self):
|
|
self.raw["domain_zones"] = [".LAB.Internal.", "example.test", "home"]
|
|
self.raw["services"][0]["hostname"] = "pve.lab.internal"
|
|
self.write()
|
|
self.assertEqual(["lab.internal", "example.test", "home"], self.config()["domain_zones"])
|
|
self.raw["services"][0]["hostname"] = "evilhome"
|
|
self.write()
|
|
with self.assertRaises(h.Error):
|
|
self.config()
|
|
self.raw["services"][0]["hostname"] = "pve.evilhome"
|
|
self.write()
|
|
with self.assertRaises(h.Error):
|
|
self.config()
|
|
|
|
def test_old_config_without_domain_zones_still_loads(self):
|
|
self.raw.pop("domain_zones")
|
|
self.write()
|
|
self.assertEqual(h.DEFAULT_ZONES, self.config()["domain_zones"])
|
|
|
|
def test_ca_zone_expansion_requires_explicit_rotation(self):
|
|
state = self.root / "state"
|
|
state.mkdir()
|
|
ca = h.Authority(state)
|
|
original = (state / "ca.json").read_bytes()
|
|
original_leaf = ca.leaf("pve.home")["cert"]
|
|
registry = {"instance": "keep-me", "routes": {"pve.home": {"host_id": 1}}}
|
|
h.save_json(state / "registry.json", registry)
|
|
ca = h.Authority(state, ["home", "lab.internal"])
|
|
with self.assertRaises(h.Error):
|
|
ca.leaf("pve.lab.internal")
|
|
self.assertEqual(original, (state / "ca.json").read_bytes())
|
|
history = h.rotate_ca(state, ["home", "lab.internal"])
|
|
self.assertEqual(original, (history / "ca.json").read_bytes())
|
|
self.assertEqual(registry, h.read_json(state / "registry.json"))
|
|
ca = h.Authority(state, ["home", "lab.internal"])
|
|
self.assertNotEqual(original_leaf, ca.leaf("pve.home")["cert"])
|
|
ca.leaf("pve.lab.internal")
|
|
with self.assertRaises(h.Error):
|
|
ca.leaf("pve.home.arpa")
|
|
|
|
def test_real_tls_with_custom_zone_certificate(self):
|
|
state = self.root / "state"
|
|
state.mkdir()
|
|
ca = h.Authority(state, ["lab.internal", "example.test"])
|
|
bundle = ca.leaf("pve.lab.internal")
|
|
certpath, keypath = state / "leaf.crt", state / "leaf.key"
|
|
certpath.write_text(bundle["cert"])
|
|
keypath.write_text(bundle["key"])
|
|
cert = x509.load_pem_x509_certificate(bundle["cert"].encode())
|
|
self.assertIn("pve.lab.internal", cert.extensions.get_extension_for_class(x509.SubjectAlternativeName).value
|
|
.get_values_for_type(x509.DNSName))
|
|
serverctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
|
|
serverctx.load_cert_chain(certpath, keypath)
|
|
clientctx = ssl.create_default_context(cafile=str(state / "root-ca.crt"))
|
|
ci, co, si, so = ssl.MemoryBIO(), ssl.MemoryBIO(), ssl.MemoryBIO(), ssl.MemoryBIO()
|
|
client = clientctx.wrap_bio(ci, co, server_hostname="pve.lab.internal")
|
|
server = serverctx.wrap_bio(si, so, server_side=True)
|
|
done = set()
|
|
for _ in range(20):
|
|
for name, obj in (("client", client), ("server", server)):
|
|
try:
|
|
obj.do_handshake()
|
|
done.add(name)
|
|
except ssl.SSLWantReadError:
|
|
pass
|
|
if co.pending:
|
|
si.write(co.read())
|
|
if so.pending:
|
|
ci.write(so.read())
|
|
if len(done) == 2:
|
|
break
|
|
self.assertEqual({"client", "server"}, done)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|