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