Add NPM certificate selection and read-only VDS certificate renewal sync
This commit is contained in:
311
tests/test_certificates.py
Normal file
311
tests/test_certificates.py
Normal 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)
|
||||
Reference in New Issue
Block a user