Add NPM certificate selection and read-only VDS certificate renewal sync
All checks were successful
Test and publish Homegate / checks (push) Successful in 28s
Test and publish Homegate / publish (push) Successful in 12m47s

This commit is contained in:
2026-10-15 05:12:03 +03:00
parent b305cc1ba8
commit eeffcfb616
18 changed files with 838 additions and 49 deletions

311
tests/test_certificates.py Normal file
View File

@@ -0,0 +1,311 @@
"""Existing NPM certificates, read-only VDS copying and renewal failure behavior."""
import copy
import io
import json
from datetime import timedelta
from pathlib import Path
import tempfile
import unittest
from unittest.mock import patch
from urllib.parse import urlsplit
import zipfile
import requests
import homegate as h
from test_homegate import Transport
import test_setup
def archive(bundle, root, **extra):
output = io.BytesIO()
with zipfile.ZipFile(output, 'w') as z:
z.writestr('fullchain2.pem', bundle['cert'] + root)
z.writestr('privkey2.pem', bundle['key'])
for name, value in extra.items():
z.writestr(name, value)
return output.getvalue()
class CertificateTests(unittest.TestCase):
def setUp(self):
temp = tempfile.TemporaryDirectory()
self.addCleanup(temp.cleanup)
self.state = Path(temp.name)
self.ca = h.Authority(self.state / 'local')
self.source_ca = h.Authority(self.state / 'source', ['example.com'])
self.bundle = self.source_ca.leaf('disk.example.com')
self.root = self.source_ca.cert.public_bytes(h.serialization.Encoding.PEM).decode()
self.source = {'id': 42, 'provider': 'letsencrypt', 'nice_name': 'Nextcloud',
'domain_names': ['disk.example.com'], 'expires_on': self.expires(),
'meta': {'dns_provider_credentials': 'PRIVATE_DNS_TOKEN', 'certificate_key': 'PRIVATE_KEY'}}
self.content = archive(self.bundle, self.root)
self.remote_requests = []
self.offline = False
self.transport = Transport()
def send(session, request, **kwargs):
if urlsplit(request.url).hostname != 'vds.example.com':
return self.transport.send(session, request, **kwargs)
self.remote_requests.append((request.method, urlsplit(request.url).path))
if self.offline:
raise requests.ConnectionError('SECRET_NOT_TO_LOG')
response = requests.Response()
response.status_code = 200
response._content_consumed = True
if request.method == 'POST' and request.url.endswith('/tokens'):
response._content = b'{"token":"REMOTE_TOKEN"}'
elif request.method == 'GET' and request.url.endswith('/nginx/certificates'):
response._content = json.dumps([self.source]).encode()
elif request.method == 'GET' and request.url.endswith('/42/download'):
response._content = self.content
else:
raise AssertionError('Unexpected production request: ' + request.method + ' ' + request.url)
return response
self.mock = patch.object(requests.Session, 'send', send)
self.mock.start()
self.addCleanup(self.mock.stop)
self.npm = h.NPM('http://home-npm:81', 'NPM')
self.npm.login('local', 'test-local')
self.remote = h.RemoteNPM('https://vds.example.com', 'Remote NPM')
self.addCleanup(self.npm.close)
self.addCleanup(self.remote.close)
self.settings = {'remote_npm_identity': 'source', 'remote_npm_password': 'test-source'}
self.registry = {'instance': 'test', 'routes': {}}
self.config = h.validate_config({'proxy_ip': '192.168.0.10', 'allowed_networks': ['192.168.0.0/24'],
'domain_zones': ['home', 'example.com'], 'dns_mode': 'manual', 'services': [
{'hostname': 'disk.example.com', 'upstream': 'http://192.168.0.20:80',
'certificate_mode': 'remote_npm', 'remote_certificate_id': 42}]})
self.transport.writes.clear()
def expires(self):
return h.x509.load_pem_x509_certificate(self.bundle['cert'].encode()).not_valid_after_utc.isoformat()
def sync(self):
with patch.object(self.ca, 'leaf', side_effect=AssertionError('Must not issue a local CA certificate')):
h.reconcile(self.config, self.state, self.ca, self.registry, self.npm, None, self.remote, self.settings)
def renew(self):
(self.state / 'source/issued/disk.example.com.json').unlink()
with patch.object(h, 'now', return_value=h.now() + timedelta(days=1)):
self.bundle = self.source_ca.leaf('disk.example.com')
# Use a valid-from time in the past while extending expiry for the test clock.
self.content = archive(self.bundle, self.root)
self.source['expires_on'] = self.expires()
def test_initial_copy_and_existing_selection_do_not_use_local_ca(self):
self.sync()
self.assertEqual(len(self.transport.certs), 1)
self.assertEqual(self.transport.hosts[0]['certificate_id'], 1)
self.assertEqual(self.transport.certs[0]['provider'], 'other')
self.assertIn('intermediate_certificate', self.transport.uploads[1])
self.transport.writes.clear()
self.sync()
self.assertEqual(self.transport.writes, [])
self.assertEqual(sum(path.endswith('/download') for _, path in self.remote_requests), 1)
self.config['services'][0].update(certificate_mode='npm', npm_certificate_id=1)
del self.config['services'][0]['remote_certificate_id']
self.remote_requests.clear()
self.sync()
self.assertEqual(self.remote_requests, [])
self.assertFalse(any(path.endswith('/upload') for _, path in self.transport.writes))
def test_renewal_updates_same_local_certificate_and_reloads_proxy(self):
self.sync()
old = self.transport.uploads[1]['certificate']
self.renew()
self.transport.writes.clear()
with patch.object(h, 'now', return_value=h.now() + timedelta(days=2)):
self.sync()
self.assertNotEqual(old, self.transport.uploads[1]['certificate'])
self.assertEqual(len(self.transport.certs), 1)
self.assertEqual(self.transport.writes, [('POST', '/nginx/certificates/1/upload'), ('PUT', '/nginx/proxy-hosts/1')])
def test_read_only_production_client_rejects_every_mutation_except_login(self):
for method, path in [('POST', '/nginx/certificates/42/renew'), ('POST', '/nginx/certificates/42/upload'),
('PUT', '/nginx/proxy-hosts/1'), ('DELETE', '/nginx/certificates/42'),
('POST', '/nginx/certificates'), ('GET', '/nginx/proxy-hosts')]:
with self.assertRaisesRegex(h.Error, 'read-only'):
self.remote.call(method, path)
self.assertEqual(self.remote_requests, [])
self.sync()
self.assertEqual(self.remote_requests, [('POST', '/api/tokens'), ('GET', '/api/nginx/certificates'),
('GET', '/api/nginx/certificates/42/download')])
def test_outage_keeps_certificate_and_still_maintains_local_proxy(self):
self.sync()
old = copy.deepcopy(self.transport.uploads)
self.offline = True
self.config['services'][0]['forward_port'] = 8080
self.transport.writes.clear()
with self.assertRaisesRegex(h.Error, 'Routes failed'):
self.sync()
self.assertEqual(old, self.transport.uploads)
self.assertEqual(self.transport.hosts[0]['forward_port'], 8080)
self.assertEqual(self.transport.writes, [('PUT', '/nginx/proxy-hosts/1')])
info = self.registry['routes']['disk.example.com']['certificate']
self.assertIn('unavailable', info['sync_error'])
def test_bad_download_preserves_existing_copy_and_does_not_upload(self):
self.sync()
old = copy.deepcopy(self.transport.uploads)
self.source['modified_on'] = 'changed'
for bad in [b'not a zip', archive(self.bundle, self.root, **{'../key.pem': 'bad'}),
archive(dict(self.bundle, key=h.pem_key(h.ec.generate_private_key(h.ec.SECP256R1()))), self.root)]:
self.content = bad
self.transport.writes.clear()
with self.assertRaises(h.Error):
self.sync()
self.assertEqual(old, self.transport.uploads)
self.assertEqual(self.transport.writes, [])
def test_failed_reload_retried_after_restart_without_redownloading(self):
self.transport.fail_nginx = True
with self.assertRaises(h.Error):
self.sync()
self.assertNotIn('disk.example.com', self.registry['routes'])
self.registry = h.read_json(self.state / 'registry.json')
self.transport.fail_nginx = False
self.transport.writes.clear()
self.sync()
self.assertEqual(self.transport.writes, [('PUT', '/nginx/proxy-hosts/1')])
self.assertEqual(sum(p.endswith('/download') for _, p in self.remote_requests), 1)
def test_missing_local_cert_does_not_silently_create_replacement(self):
self.config['services'][0].update(certificate_mode='npm', npm_certificate_id=99)
del self.config['services'][0]['remote_certificate_id']
with self.assertRaises(h.Error):
self.sync()
self.assertEqual(self.transport.writes, [])
self.assertEqual(self.remote_requests, [])
def test_existing_public_certificate_creates_local_dns_without_uploading(self):
self.transport.certs = [dict(self.source, id=1)]
self.transport.uploads[1] = {'existing': True}
self.config['services'][0].update(certificate_mode='npm', npm_certificate_id=1)
del self.config['services'][0]['remote_certificate_id']
dns = h.PiHole('http://pihole', 'PIHOLE')
self.addCleanup(dns.close)
dns.login('test')
self.transport.writes.clear()
with patch.object(self.ca, 'leaf', side_effect=AssertionError('No local CA issuance')):
h.reconcile(self.config, self.state, self.ca, self.registry, self.npm, dns)
self.assertIn('192.168.0.10 disk.example.com', self.transport.records)
self.assertEqual(self.transport.hosts[0]['certificate_id'], 1)
self.assertFalse(any('/nginx/certificates' in p for _, p in self.transport.writes))
def test_source_unavailable_on_first_copy_makes_no_local_changes(self):
self.offline = True
with self.assertRaises(h.Error):
self.sync()
self.assertEqual(self.transport.writes, [])
self.assertEqual(self.transport.hosts, [])
def test_wrong_domain_is_rejected_before_download_or_local_upload(self):
self.source['domain_names'] = ['unrelated.example.com']
with self.assertRaises(h.Error):
self.sync()
self.assertFalse(any(p.endswith('/download') for _, p in self.remote_requests))
self.assertEqual(self.transport.writes, [])
def test_malformed_renewal_does_not_block_an_unrelated_service(self):
self.sync()
self.offline = True
route = copy.deepcopy(self.config['services'][0])
route.update(hostname='other.example.com', certificate_mode='npm', npm_certificate_id=2)
del route['remote_certificate_id']
self.config['services'].append(route)
self.transport.certs.append(dict(self.source, id=2, domain_names=['other.example.com']))
self.transport.uploads[2] = {'existing': True}
with self.assertRaises(h.Error):
self.sync()
self.assertEqual(self.transport.hosts[1]['domain_names'], ['other.example.com'])
def test_offline_shared_copy_cannot_publish_an_uncovered_domain(self):
self.sync()
self.offline = True
self.config['services'].append(dict(self.config['services'][0], hostname='uncovered.example.com'))
with self.assertRaises(h.Error):
self.sync()
self.assertEqual(len(self.transport.hosts), 1)
def test_explicit_and_automatic_targets_cannot_assign_different_sources(self):
self.sync()
self.config['services'].append(dict(self.config['services'][0], hostname='other.example.com',
npm_certificate_id=1, remote_certificate_id=43))
self.transport.writes.clear()
self.remote_requests.clear()
with self.assertRaises(h.Error):
self.sync()
self.assertEqual(self.transport.writes, [])
self.assertEqual(self.remote_requests, [])
def test_sync_never_overwrites_local_letsencrypt_certificate(self):
self.transport.certs = [dict(self.source, id=1)]
self.config['services'][0]['npm_certificate_id'] = 1
with self.assertRaises(h.Error):
self.sync()
self.assertEqual(self.transport.writes, [])
def test_public_metadata_and_status_never_expose_keys_or_dns_tokens(self):
self.assertNotIn('PRIVATE_', json.dumps(h.certificate_info(self.source)))
self.sync()
h.publish_panel_status(self.state / 'control', 'revision', self.config, self.state, self.ca, True, None)
status = h.read_json(self.state / 'control/status.json')
self.assertEqual(status['certificates'][0]['mode'], 'remote_npm')
self.assertNotIn('PRIVATE KEY', json.dumps(status))
self.assertNotIn(self.bundle['key'], (self.state / 'registry.json').read_text())
def test_wildcard_only_covers_one_label_and_expired_certificates_fail(self):
info = {'domains': ['*.example.com'], 'expires': self.expires()}
h.check_certificate(info, ['disk.example.com'])
for hostname in ['example.com', 'a.disk.example.com', 'other.example.net']:
with self.assertRaises(h.Error):
h.check_certificate(info, [hostname])
with patch.object(h, 'now', return_value=h.now() + timedelta(days=91)), self.assertRaises(h.Error):
h.check_certificate(info, ['disk.example.com'])
class CertificateUITests(unittest.TestCase):
setUp = test_setup.SetupTests.setUp
request = test_setup.SetupTests.request
connect = test_setup.SetupTests.connect
install = test_setup.SetupTests.install
def test_remote_settings_and_certificate_list_are_redacted(self):
self.settings['connections'].update(remote_npm_url='https://vds.example.com',
remote_npm_identity='reader@example.com', remote_npm_password='vds-secret')
state = self.install()
self.assertTrue(state['connections']['remote_npm_password_set'])
self.assertNotIn('vds-secret', json.dumps(state))
self.assertEqual(h.read_json(self.connections)['remote_npm_password'], 'vds-secret')
self.settings['revision'] = state['revision']
self.settings['connections']['remote_npm_password'] = ''
self.assertEqual(self.request('/api/settings', self.settings)[0], 200)
self.assertEqual(h.read_json(self.connections)['remote_npm_password'], 'vds-secret')
with patch.object(h.RemoteNPM, 'login') as login, patch.object(h.RemoteNPM, 'call', return_value=[
{'id': 42, 'provider': 'letsencrypt', 'domain_names': ['disk.example.com'],
'meta': {'certificate_key': 'private-key', 'dns_provider_credentials': 'dns-token'}}]) as call:
code, body, _ = self.request('/api/remote-certificates')
self.assertEqual(code, 200)
self.assertNotIn('private-key', json.dumps(body))
self.assertNotIn('dns-token', json.dumps(body))
login.assert_called_once_with('reader@example.com', 'vds-secret')
call.assert_called_once_with('GET', '/nginx/certificates')
self.cookie = ''
self.assertEqual(self.request('/api/remote-certificates')[0], 401)
def test_public_domain_existing_certificate_can_be_saved_in_ui(self):
state = self.install()
config = state['config']
config['domain_zones'].append('example.com')
config['services'] = [{'hostname': 'disk.example.com', 'upstream': 'http://192.168.0.20',
'certificate_mode': 'npm', 'npm_certificate_id': 7}]
code, saved, _ = self.request('/api/config', {'revision': state['revision'], 'config': config})
self.assertEqual(code, 200)
self.assertEqual(saved['config']['services'][0]['npm_certificate_id'], 7)
def test_conflicting_sources_rejected_before_saving(self):
state = self.install()
config = state['config']
config['services'] = [{'hostname': name + '.home', 'upstream': 'http://192.168.0.20',
'certificate_mode': 'remote_npm', 'npm_certificate_id': 7, 'remote_certificate_id': source}
for name, source in [('a', 1), ('b', 2)]]
self.assertEqual(self.request('/api/config', {'revision': state['revision'], 'config': config})[0], 400)