Initial Homegate 0.4.0 with web UI, Compose and Gitea Actions
This commit is contained in:
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()
|
||||
Reference in New Issue
Block a user