Initial Homegate 0.4.0 with web UI, Compose and Gitea Actions
This commit is contained in:
112
tests/test_distribution.py
Normal file
112
tests/test_distribution.py
Normal 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
295
tests/test_homegate.py
Normal 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
258
tests/test_ssh_and_zones.py
Normal 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
182
tests/test_ui.py
Normal 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()
|
||||
Reference in New Issue
Block a user