Initial Homegate 0.4.0 with web UI, Compose and Gitea Actions
Some checks failed
Test and publish Homegate / checks (push) Has been cancelled
Test and publish Homegate / publish (push) Has been cancelled

This commit is contained in:
2026-10-14 01:40:14 +03:00
commit 357daa8915
33 changed files with 4032 additions and 0 deletions

258
tests/test_ssh_and_zones.py Normal file
View File

@@ -0,0 +1,258 @@
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()