Files
homegate/tests/test_ssh_and_zones.py
DizelBadCoder 357daa8915
Some checks failed
Test and publish Homegate / checks (push) Has been cancelled
Test and publish Homegate / publish (push) Has been cancelled
Initial Homegate 0.4.0 with web UI, Compose and Gitea Actions
2026-10-14 01:40:14 +03:00

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()