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

112
tests/test_distribution.py Normal file
View File

@@ -0,0 +1,112 @@
"""First-install/update safety and release destination validation."""
import os
from pathlib import Path
import tempfile
import unittest
import yaml
import homegate as h
from bootstrap import initialize
from ci.image_metadata import metadata
BASE = Path(__file__).resolve().parents[1]
class BootstrapTests(unittest.TestCase):
def setUp(self):
temp = tempfile.TemporaryDirectory()
self.addCleanup(temp.cleanup)
self.root = Path(temp.name)
self.seed = self.root / 'seed.yaml'
value = yaml.safe_load((BASE / 'config/services.yaml').read_bytes())
value['services'] = []
self.seed.write_text(yaml.safe_dump(value))
self.config = self.root / 'config/services.yaml'
self.state = self.root / 'state'
self.control = self.root / 'control'
def run_init(self):
return initialize(self.seed, self.config, self.state, self.control, os.getuid(), os.getgid())
def test_empty_volume_creates_valid_config_with_private_permissions(self):
self.assertTrue(self.run_init())
self.assertEqual(h.load_config(self.config)['services'], [])
self.assertEqual(self.config.stat().st_mode & 0o777, 0o600)
for directory in (self.config.parent, self.state, self.control):
self.assertEqual(directory.stat().st_mode & 0o777, 0o700)
self.assertFalse((self.state / 'ca.json').exists())
def test_upgrade_preserves_edits_and_ca_even_with_changed_seed(self):
self.run_init()
config = yaml.safe_load(self.config.read_bytes())
config['services'] = [{'hostname': 'notes.home', 'display_name': 'Мои заметки',
'upstream': 'http://192.168.0.150:3000'}]
self.config.write_text(yaml.safe_dump(config, allow_unicode=True))
ca = h.Authority(self.state, config['domain_zones'])
before = self.config.read_bytes()
ca_before = (self.state / 'ca.json').read_bytes()
self.seed.write_text('invalid: new seed must not overwrite config')
self.assertFalse(self.run_init())
self.assertEqual(self.config.read_bytes(), before)
self.assertEqual((self.state / 'ca.json').read_bytes(), ca_before)
self.assertEqual(ca.cert.subject, h.Authority(self.state, config['domain_zones']).cert.subject)
def test_invalid_first_seed_does_not_install_configuration(self):
self.seed.write_text('proxy_ip: 8.8.8.8')
with self.assertRaises((h.Error, KeyError)):
self.run_init()
self.assertFalse(self.config.exists())
def test_invalid_existing_file_is_not_replaced(self):
self.run_init()
self.config.write_text('do not erase this file')
with self.assertRaises(h.Error):
self.run_init()
self.assertEqual(self.config.read_text(), 'do not erase this file')
def test_symlink_config_and_volume_are_refused(self):
self.config.parent.mkdir()
self.config.symlink_to(self.seed)
with self.assertRaises(h.Error):
self.run_init()
self.assertEqual(self.config.resolve(), self.seed.resolve())
self.config.unlink()
self.state.rmdir()
self.state.symlink_to(self.config.parent, target_is_directory=True)
with self.assertRaises(h.Error):
self.run_init()
class ReleaseMetadataTests(unittest.TestCase):
def values(self, **overrides):
fields = {'server_url': 'https://git.example.home:3000', 'repository': 'HomeLab/Homegate',
'ref': 'refs/tags/v0.4.0', 'revision': 'a' * 40, 'version_file': '0.4.0\n'}
fields.update(overrides)
return metadata(**fields)
def test_registry_and_owner_come_from_gitea_repository(self):
value = self.values()
self.assertEqual(value['registry'], 'git.example.home:3000')
self.assertEqual(value['image'], 'git.example.home:3000/homelab/homegate')
self.assertEqual(value['version'], '0.4.0')
def test_registry_override_and_prerelease(self):
value = self.values(registry_override='registry.example.home', ref='refs/tags/v0.4.0-rc.1',
version_file='0.4.0-rc.1')
self.assertEqual(value['image'], 'registry.example.home/homelab/homegate')
self.assertEqual(value['source'], 'https://git.example.home:3000/homelab/homegate')
def test_wrong_tag_commit_or_destination_is_rejected(self):
for change in ({'ref': 'refs/heads/main'}, {'ref': 'refs/tags/v0.5.0'},
{'ref': 'refs/tags/v0.4.0;bad'}, {'revision': 'bad\nvalue'},
{'repository': 'owner/repo\nnew-output=x'}, {'repository': '../repo'},
{'registry_override': 'https://registry.example.home'},
{'registry_override': 'gitea'},
{'registry_override': 'registry.example.home:99999'},
{'registry_override': 'registry.example.home/path'}):
with self.subTest(change=change), self.assertRaises(ValueError):
self.values(**change)
if __name__ == '__main__':
unittest.main()

295
tests/test_homegate.py Normal file
View File

@@ -0,0 +1,295 @@
"""Behavior tests using real X.509/TLS and a simulated NPM/Pi-hole HTTP transport."""
import copy
from datetime import timedelta
from email.parser import BytesParser
from email.policy import default
import json
from pathlib import Path
import ssl
import tempfile
import unittest
from unittest.mock import patch
from urllib.parse import unquote, urlsplit
import requests
import yaml
from cryptography import x509
import homegate as h
BASE = Path(__file__).resolve().parents[1]
class Transport:
def __init__(self):
self.hosts = []
self.certs = []
self.records = ["192.168.0.9 unrelated.home"]
self.cnames = []
self.writes = []
self.fail_upload = False
self.fail_nginx = False
self.fail_dns = False
self.uploads = {}
def send(self, session, request, **kwargs):
path = unquote(urlsplit(request.url).path.removeprefix("/api"))
method = request.method
data = json.loads(request.body) if request.body and "application/json" in request.headers.get("Content-Type", "") else None
body, status = None, 200
if method != "GET":
self.writes.append((method, path))
if path == "/tokens":
body = {"token": "TEST_TOKEN"}
elif path == "/auth":
if method == "POST":
body = {"session": {"valid": True, "sid": "TEST_SID", "csrf": "TEST_CSRF"}}
else:
status = 204
elif path.startswith("/nginx/"):
assert request.headers["Authorization"] == "Bearer TEST_TOKEN"
if path == "/nginx/proxy-hosts":
if method == "GET":
body = self.hosts
else:
assert self.uploads[data["certificate_id"]]
body = dict(data, id=len(self.hosts) + 1, meta={"nginx_online": not self.fail_nginx})
self.hosts.append(body)
elif path.startswith("/nginx/proxy-hosts/"):
index = int(path.split("/")[-1]) - 1
body = dict(data, id=index + 1, meta={"nginx_online": not self.fail_nginx})
self.hosts[index] = body
elif path == "/nginx/certificates":
if method == "GET":
body = self.certs
else:
body = dict(data, id=len(self.certs) + 1, meta={})
self.certs.append(body)
elif path.endswith("/upload"):
cert_id = int(path.split("/")[-2])
if self.fail_upload:
status = 500
else:
raw = ("Content-Type: " + request.headers["Content-Type"] + "\r\n\r\n").encode() + request.body
message = BytesParser(policy=default).parsebytes(raw)
fields = {p.get_param("name", header="content-disposition"): p.get_payload(decode=True)
for p in message.iter_parts()}
assert set(fields) == {"certificate", "certificate_key"}
x509.load_pem_x509_certificate(fields["certificate"])
self.uploads[cert_id] = fields
self.certs[cert_id - 1]["meta"] = {"certificate": True, "certificate_key": True}
body = {"certificate_key": "SECRET_NOT_TO_LOG"}
else:
raise AssertionError(path)
elif path == "/config/dns":
assert request.headers["X-FTL-SID"] == "TEST_SID"
if self.fail_dns:
status = 503
else:
body = {"config": {"dns": {"hosts": self.records, "cnameRecords": self.cnames}}}
elif path.startswith("/config/dns/hosts/"):
assert method == "PUT"
assert request.headers["X-FTL-SID"] == "TEST_SID"
entry = path.removeprefix("/config/dns/hosts/")
assert entry not in self.records
assert self.hosts[0]["meta"]["nginx_online"]
self.records.append(entry)
status = 201
else:
raise AssertionError((method, path))
response = requests.Response()
response.status_code = status
response._content = json.dumps(body).encode() if body is not None else b""
return response
class HomegateTests(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.addCleanup(self.tmp.cleanup)
self.state = Path(self.tmp.name)
self.ca = h.Authority(self.state)
self.config = h.load_config(BASE / "config/services.yaml")
self.registry = {"instance": "test-instance", "routes": {}}
self.transport = Transport()
transport = self.transport
self.patch = patch.object(requests.Session, "send", lambda session, request, **kw: transport.send(session, request, **kw))
self.patch.start()
self.addCleanup(self.patch.stop)
self.npm = h.NPM("http://npm:81", "NPM")
self.npm.login("test@example.com", "password")
self.dns = h.PiHole("http://pihole", "PIHOLE")
self.dns.login("password")
self.addCleanup(self.npm.close)
self.addCleanup(self.dns.close)
self.transport.writes.clear()
def sync(self):
h.reconcile(self.config, self.state, self.ca, self.registry, self.npm, self.dns)
def test_first_sync_and_idempotent_second_sync(self):
self.sync()
self.assertIn("192.168.0.10 pve.home", self.transport.records)
self.assertIn("192.168.0.9 unrelated.home", self.transport.records)
host = self.transport.hosts[0]
self.assertTrue(host["ssl_forced"])
self.assertTrue(host["allow_websocket_upgrade"])
self.assertIn("allow 192.168.0.0/24;\ndeny all;", host["advanced_config"])
self.assertIn("proxy_ssl_verify off;", host["advanced_config"])
self.transport.writes.clear()
self.sync()
self.assertEqual([], self.transport.writes)
def test_renewal_uploads_and_reloads_existing_host(self):
self.sync()
old = self.transport.uploads[1]["certificate"]
future = h.now() + timedelta(days=61)
self.transport.writes.clear()
with patch.object(h, "now", return_value=future):
self.sync()
self.assertNotEqual(old, self.transport.uploads[1]["certificate"])
self.assertEqual([("POST", "/nginx/certificates/1/upload"), ("PUT", "/nginx/proxy-hosts/1")], self.transport.writes)
self.assertEqual(1, len(self.transport.certs))
def test_failed_upload_retries_without_duplicate_certificate(self):
self.transport.fail_upload = True
with self.assertRaises(h.Error):
self.sync()
self.assertEqual({}, self.registry["routes"])
self.assertEqual([], self.transport.hosts)
self.transport.fail_upload = False
self.sync()
self.assertEqual(1, len(self.transport.certs))
def test_failed_reload_is_retried_and_does_not_publish_dns(self):
self.transport.fail_nginx = True
with self.assertRaises(h.Error):
self.sync()
self.assertNotIn("192.168.0.10 pve.home", self.transport.records)
self.assertEqual({}, self.registry["routes"])
self.transport.fail_nginx = False
self.sync()
self.assertIn("192.168.0.10 pve.home", self.transport.records)
def test_unmanaged_proxy_is_not_overwritten(self):
self.transport.hosts.append({"id": 1, "domain_names": ["pve.home"], "advanced_config": "# existing"})
with self.assertRaises(h.Error):
self.sync()
self.assertEqual([], self.transport.writes)
def test_conflicting_dns_is_not_overwritten(self):
self.transport.records.append("192.168.0.137 pve.home alias.home")
with self.assertRaises(h.Error):
self.sync()
self.assertEqual([], self.transport.writes)
def test_cname_conflict_is_not_overwritten(self):
self.transport.cnames.append("pve.home,other.home")
with self.assertRaises(h.Error):
self.sync()
self.assertEqual([], self.transport.writes)
def test_dns_outage_does_not_stop_certificate_renewal(self):
self.sync()
self.transport.fail_dns = True
future = h.now() + timedelta(days=61)
with patch.object(h, "now", return_value=future), self.assertRaises(h.Error):
self.sync()
self.assertEqual(1, len(self.transport.certs))
self.assertIn(("PUT", "/nginx/proxy-hosts/1"), self.transport.writes)
def test_removed_service_is_not_deleted(self):
self.sync()
self.config["services"] = []
self.transport.writes.clear()
self.sync()
self.assertEqual([], self.transport.writes)
self.assertEqual(1, len(self.transport.hosts))
def test_disabled_service_disables_proxy(self):
self.sync()
self.config["services"][0]["enabled"] = False
self.sync()
self.assertFalse(self.transport.hosts[0]["enabled"])
def test_invalid_input_cannot_inject_nginx_or_expand_access(self):
base = yaml.safe_load((BASE / "config/services.yaml").read_text())
for field, value in [("hostname", "pve.home;return 200;"), ("upstream", "http://8.8.8.8:80"),
("upstream", "https://192.168.0.137:8006/path"), ("websocket", "false"),
("upstream_ca_file", "/tmp/ca;return 200;"), ("upstream_tls_name", "pve;#")]:
c = copy.deepcopy(base)
c["services"][0][field] = value
p = self.state / "invalid.yaml"
p.write_text(yaml.safe_dump(c))
with self.subTest(field=field, value=value), self.assertRaises((h.Error, ValueError)):
h.load_config(p)
base["allowed_networks"] = ["0.0.0.0/0"]
p.write_text(yaml.safe_dump(base))
with self.assertRaises(h.Error):
h.load_config(p)
def test_ca_survives_restart_and_private_files_are_restricted(self):
original = (self.state / "root-ca.crt").read_bytes()
h.Authority(self.state)
self.assertEqual(original, (self.state / "root-ca.crt").read_bytes())
self.assertEqual(0o600, (self.state / "ca.json").stat().st_mode & 0o777)
with self.assertRaises(h.Error):
self.ca.leaf("example.com")
def test_missing_ca_does_not_silently_replace_trust(self):
(self.state / "registry.json").write_text("{}")
(self.state / "ca.json").unlink()
with self.assertRaises(h.Error):
h.Authority(self.state)
def tls_handshake(self, hostname, trust=True):
bundle = self.ca.leaf("pve.home")
certpath, keypath = self.state / "tls.pem", self.state / "tls.key"
certpath.write_text(bundle["cert"])
keypath.write_text(bundle["key"])
server_ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
server_ctx.load_cert_chain(certpath, keypath)
client_ctx = ssl.create_default_context(cafile=str(self.state / "root-ca.crt") if trust else None)
ci, co, si, so = ssl.MemoryBIO(), ssl.MemoryBIO(), ssl.MemoryBIO(), ssl.MemoryBIO()
client = client_ctx.wrap_bio(ci, co, server_hostname=hostname)
server = server_ctx.wrap_bio(si, so, server_side=True)
finished = set()
for _ in range(20):
for name, obj in (("client", client), ("server", server)):
try:
obj.do_handshake()
finished.add(name)
except ssl.SSLWantReadError:
pass
if co.pending:
si.write(co.read())
if so.pending:
ci.write(so.read())
if len(finished) == 2:
return client.getpeercert()
self.fail("TLS handshake did not complete")
def test_real_tls_accepts_correct_hostname_and_trusted_ca(self):
cert = self.tls_handshake("pve.home")
self.assertIn(("DNS", "pve.home"), cert["subjectAltName"])
def test_real_tls_rejects_wrong_hostname(self):
with self.assertRaises(ssl.SSLCertVerificationError):
self.tls_handshake("wrong.home")
def test_real_tls_rejects_untrusted_ca(self):
with self.assertRaises(ssl.SSLCertVerificationError):
self.tls_handshake("pve.home", trust=False)
def test_upstream_verification_is_default_for_other_https_services(self):
c = yaml.safe_load((BASE / "config/services.yaml").read_text())
c["services"] = [{"hostname": "nas.home.arpa", "upstream": "https://192.168.0.130"}]
p = self.state / "config.yaml"
p.write_text(yaml.safe_dump(c))
config = h.load_config(p)
result = h.payload(config, config["services"][0], 1, "# test")
self.assertIn("proxy_ssl_verify on;", result["advanced_config"])
if __name__ == "__main__":
unittest.main()

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

182
tests/test_ui.py Normal file
View File

@@ -0,0 +1,182 @@
"""HTTP/session/config integration tests without external APIs or listening ports."""
import copy
import hashlib
import json
from pathlib import Path
import tempfile
import time
import unittest
from unittest.mock import patch
import yaml
import homegate as h
import homegate_ui as ui
from test_ssh_and_zones import MemorySocket
BASE = Path(__file__).resolve().parents[1]
class PanelTests(unittest.TestCase):
def setUp(self):
temp = tempfile.TemporaryDirectory()
self.addCleanup(temp.cleanup)
self.root = Path(temp.name)
self.config = self.root / 'config/services.yaml'
self.config.parent.mkdir()
self.config.write_bytes((BASE / 'config/services.yaml').read_bytes())
self.control = self.root / 'control'
self.password = self.root / 'password'
self.password.write_text('local-test-password')
self.panel = ui.Panel(self.config, self.control, 'http://192.168.0.10:8098',
password_file=self.password)
self.cookie = ''
self.csrf = ''
def request(self, path='/api/state', body=None, peer='192.168.0.20', headers=None):
method = 'GET' if body is None else 'POST'
payload = b'' if body is None else json.dumps(body).encode()
heads = {'Host': self.panel.authority, 'Cookie': self.cookie}
if body is not None:
heads.update({'Origin': self.panel.origin, 'Content-Type': 'application/json',
'Content-Length': str(len(payload)), 'X-Homegate-CSRF': self.csrf})
heads.update(headers or {})
raw = f'{method} {path} HTTP/1.1\r\n' + ''.join(f'{k}: {v}\r\n' for k, v in heads.items()) + '\r\n'
sock = MemorySocket(raw.encode() + payload)
ui.handler_for(self.panel)(sock, (peer, 5000), None)
header, data = sock.output.split(b'\r\n\r\n', 1)
status = int(header.split()[1])
response_headers = dict(line.decode().split(': ', 1) for line in header.split(b'\r\n')[1:])
if 'application/json' in response_headers.get('Content-Type', ''):
data = json.loads(data)
return status, data, response_headers
def login(self):
code, body, headers = self.request('/api/login', {'password': 'local-test-password'})
self.assertEqual(code, 200)
self.cookie = headers['Set-Cookie'].split(';')[0]
self.csrf = body['csrf']
return headers
def test_login_cookie_and_logout(self):
self.assertEqual(self.request()[0], 401)
headers = self.login()
self.assertIn('HttpOnly; SameSite=Strict', headers['Set-Cookie'])
self.assertEqual(self.request()[0], 200)
self.assertEqual(self.request('/api/logout', {})[0], 200)
self.assertEqual(self.request()[0], 401)
def test_wrong_password_rate_limited(self):
for _ in range(5):
self.assertEqual(self.request('/api/login', {'password': 'incorrect'})[0], 401)
self.assertEqual(self.request('/api/login', {'password': 'incorrect'})[0], 429)
def test_origin_csrf_and_host_required(self):
self.login()
for headers in ({'Origin': 'https://attacker.example'}, {'X-Homegate-CSRF': ''}, {'Host': 'attacker.example'}):
with self.subTest(headers=headers):
self.assertEqual(self.request('/api/sync', {}, headers=headers)[0], 403)
self.assertFalse((self.control / 'sync-request.json').exists())
self.assertEqual(self.request('/api/sync', {})[0], 202)
self.assertTrue((self.control / 'sync-request.json').exists())
def test_lan_acl_and_local_mode(self):
for peer in ('8.8.8.8', '192.168.1.5'):
self.assertEqual(self.request('/', peer=peer)[0], 403)
self.assertEqual(self.request('/', peer='::ffff:192.168.0.20')[0], 200)
self.panel = ui.Panel(self.config, self.control, 'http://127.0.0.1:8787', local=True)
self.assertEqual(self.request('/api/session', peer='192.168.0.20')[0], 403)
code, body, _ = self.request('/api/session', peer='127.0.0.1')
self.assertEqual(code, 200)
self.assertTrue(body['authenticated'])
def test_config_write_backups_and_conflicts(self):
self.login()
original = self.config.read_bytes()
_, data, _ = self.request()
new = copy.deepcopy(data['config'])
new['domain_zones'].append('test.internal')
code, saved, _ = self.request('/api/config', {'config': new, 'revision': data['revision']})
self.assertEqual(code, 200)
self.assertNotEqual(saved['revision'], data['revision'])
self.assertIn('test.internal', h.load_config(self.config)['domain_zones'])
backup = list((self.config.parent / 'backups').glob('*.yaml'))
self.assertEqual(len(backup), 1)
self.assertEqual(backup[0].read_bytes(), original)
self.assertEqual(self.request('/api/config', {'config': new, 'revision': data['revision']})[0], 409)
def test_invalid_config_is_not_written(self):
self.login()
before = self.config.read_bytes()
data = self.panel.status()
data['config']['services'][0]['hostname'] = 'outside.example'
code, _, _ = self.request('/api/config', {'config': data['config'], 'revision': data['revision']})
self.assertEqual(code, 400)
self.assertEqual(self.config.read_bytes(), before)
def test_malformed_json_and_missing_fields_return_400(self):
self.login()
for body in ([], None, 'string', {'revision': 'x'}):
if body is not None:
self.assertEqual(self.request('/api/config', body)[0], 400)
def test_downloads_require_login_and_no_private_files(self):
for name in ('services.yaml', 'root-ca.crt', 'ssh-config'):
self.assertEqual(self.request('/downloads/' + name)[0], 401)
self.login()
self.assertEqual(self.request('/downloads/root-ca.crt')[0], 404)
self.assertIn(b'Host pve pve.home', self.request('/downloads/ssh-config')[1])
for path in ('/downloads/../state/ca.json', '/state/ca.json', '/downloads/ui_password'):
self.assertEqual(self.request(path)[0], 404)
def test_secure_cookie_expiry_and_static_csp(self):
self.panel.origin = 'https://panel.home'
self.panel.authority = 'panel.home'
headers = self.login()
self.assertIn('; Secure', headers['Set-Cookie'])
self.assertIn("frame-ancestors 'none'", self.request('/')[2]['Content-Security-Policy'])
with patch.object(ui.time, 'time', return_value=time.time() + 13 * 3600):
self.assertEqual(self.request()[0], 401)
def test_freshness_reflects_controller_heartbeat(self):
h.save_json(self.control / 'status.json', {'time': time.time()-200, 'max_age': 180, 'ok': True})
self.assertFalse(self.panel.status()['controller']['fresh'])
h.save_json(self.control / 'status.json', {'time': time.time(), 'max_age': 180, 'ok': False})
self.assertTrue(self.panel.status()['controller']['fresh'])
self.assertFalse(self.panel.status()['controller']['ok'])
def test_config_validation_does_not_mutate_ui_input(self):
original, _ = self.panel.config_data()
other = copy.deepcopy(original)
h.validate_config(other)
self.assertEqual(other, original)
self.panel.save(other, self.panel.status()['revision'])
self.assertNotIn('forward_host', yaml.safe_load(self.config.read_bytes())['services'][0])
def test_public_status_uses_applied_revision_without_keys(self):
state = self.root / 'state'
state.mkdir()
config = h.load_config(self.config)
ca = h.Authority(state, config['domain_zones'])
ca.leaf('pve.home')
applied = hashlib.sha256(self.config.read_bytes()).hexdigest()
self.config.write_bytes(self.config.read_bytes() + b'\n# Edited while syncing\n')
h.publish_panel_status(self.control, applied, config, state, ca, True, None)
status = h.read_json(self.control / 'status.json')
self.assertEqual(status['applied_revision'], applied)
self.assertNotEqual(status['applied_revision'], self.panel.status()['revision'])
self.assertIn('BEGIN CERTIFICATE', status['root']['pem'])
self.assertEqual(status['certificates'][0]['hostname'], 'pve.home')
self.assertNotIn('PRIVATE KEY', json.dumps(status))
h.publish_panel_status(self.control, 'failed-revision', config, state, ca, False, 'API unavailable')
self.assertEqual(h.read_json(self.control / 'status.json')['applied_revision'], applied)
def test_weak_password_or_invalid_origin_refused(self):
self.password.write_text('short')
with self.assertRaises(ui.UIError):
ui.Panel(self.config, self.control, 'http://panel.home', password_file=self.password)
with self.assertRaises(ui.UIError):
ui.Panel(self.config, self.control, 'http://panel.home/path', local=True)
if __name__ == '__main__':
unittest.main()