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"), "not a config", 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()