"""DNS-01 issuance is local, asynchronous, secret-free in state, and retry-safe.""" import copy from datetime import timedelta import json import threading import unittest from unittest.mock import Mock, patch import homegate as h import homegate_ui as ui import dns_challenge as dc import test_setup class DNSChallengeTests(unittest.TestCase): setUpPanel = test_setup.SetupTests.setUp request = test_setup.SetupTests.request connect = test_setup.SetupTests.connect install = test_setup.SetupTests.install def setUp(self): self.setUpPanel() self.install() self.rows = [] self.posts = [] self.legacy = False self.fail_after_create = False self.block = None self.entered = threading.Event() self.client = Mock(base='http://home-npm:81/api') self.client.call.side_effect = self.call self.panel.dns_challenge.connect = lambda: self.client self.input = {'domains':['disk.example.com'], 'provider':'cloudflare', 'credentials':'dns_cloudflare_api_token=DNS_PRIVATE_TOKEN', 'agree':True, 'email':'admin@example.com', 'propagation_seconds':None} def call(self, method, path, **kwargs): if method == 'GET' and path == '/nginx/certificates/dns-providers': if self.legacy: raise h.APIError('Not found', 404) return [{'id':'cloudflare','name':'Cloudflare','credentials':'dns_cloudflare_api_token=EXAMPLE'}] if method == 'GET' and path == '/nginx/certificates': return copy.deepcopy(self.rows) if method == 'POST' and path == '/nginx/certificates': payload = copy.deepcopy(kwargs['json']) self.posts.append(payload) self.assertEqual(kwargs['timeout'], (5, dc.ISSUE_TIMEOUT)) self.entered.set() if self.block: self.block.wait(3) row = dict(payload, id=len(self.rows)+1, nice_name=', '.join(payload['domain_names']), expires_on=(h.now()+timedelta(days=90)).isoformat()) self.rows.append(row) if self.fail_after_create: raise h.APIError('NPM: connection or TLS error') return copy.deepcopy(row) raise AssertionError((method,path)) def finish(self): self.panel.dns_challenge.thread.join(4) self.assertFalse(self.panel.dns_challenge.thread.is_alive()) return self.request('/api/dns-challenge')[1] def start(self): code, body, _ = self.request('/api/dns-challenge', copy.deepcopy(self.input)) self.assertEqual(code, 202, body) return self.finish() def test_modern_npm_issues_dns_certificate_and_exports_only_public_metadata(self): self.input['domains'] = ['example.com','*.example.com'] result = self.start() self.assertEqual(result['status'], 'success') self.assertEqual(self.posts[0], {'provider':'letsencrypt','domain_names':self.input['domains'], 'meta':{'dns_challenge':True,'dns_provider':'cloudflare', 'dns_provider_credentials':self.input['credentials']}}) self.assertTrue(result['certificate']['dns_challenge']) for path in self.root.rglob('*'): if path.is_file(): self.assertNotIn('DNS_PRIVATE_TOKEN', path.read_text()) for path in ['/api/dns-challenge','/api/state','/downloads/services.yaml']: self.assertNotIn('DNS_PRIVATE_TOKEN', str(self.request(path)[1])) with patch.object(h.RemoteNPM, 'call', side_effect=AssertionError('No VDS calls')): self.assertEqual(self.start()['status'], 'success') self.assertEqual(len(self.posts), 1) # valid certificate is reused def test_old_npm_receives_email_and_agreement_with_propagation_delay(self): self.legacy = True self.input['propagation_seconds'] = 120 self.assertEqual(self.start()['status'], 'success') meta = self.posts[0]['meta'] self.assertEqual(meta['letsencrypt_email'], 'admin@example.com') self.assertIs(meta['letsencrypt_agree'], True) self.assertEqual(meta['propagation_seconds'], 120) def test_issuance_is_background_and_duplicate_posts_are_blocked(self): self.block = threading.Event() self.addCleanup(self.block.set) code, _, _ = self.request('/api/dns-challenge', self.input) self.assertEqual(code, 202) self.assertTrue(self.entered.wait(2)) self.assertEqual(self.request('/api/state')[0], 200) self.assertEqual(self.request('/api/dns-challenge')[1]['status'], 'running') self.assertEqual(self.request('/api/dns-challenge', self.input)[0], 400) self.block.set() self.assertEqual(self.finish()['status'], 'success') self.assertEqual(len(self.posts), 1) def test_timeout_recovers_existing_certificate_without_another_acme_order(self): self.fail_after_create = True self.assertEqual(self.start()['status'], 'unknown') self.assertEqual(self.request('/api/dns-challenge', self.input)[0], 400) self.assertEqual(self.request('/api/dns-challenge/check', {})[0], 202) self.assertEqual(self.finish()['status'], 'success') self.assertEqual(len(self.posts), 1) def test_restart_does_not_repeat_pending_order(self): dc.h.save_json(self.panel.dns_challenge.path, {'status':'running','domains':['disk.example.com'], 'provider':'cloudflare','started_at':dc.time.time(),'issued_at':dc.time.time(),'npm_base':self.client.base}) restarted = dc.DNSChallenge(self.control, lambda:self.client) self.assertEqual(restarted.status()['status'], 'unknown') with self.assertRaises(h.Error): restarted.start(self.input) self.assertEqual(self.posts, []) def test_clear_api_failure_is_reported_without_retry_or_response_secrets(self): original = self.client.call.side_effect self.client.call.side_effect = lambda method,path,**kw: ( (_ for _ in ()).throw(h.APIError('NPM: HTTP 400',400)) if method == 'POST' else original(method,path,**kw)) result = self.start() self.assertEqual(result['status'], 'error') self.assertIn('HTTP 400', result['message']) self.assertEqual(sum(c.args[0]=='POST' for c in self.client.call.call_args_list), 1) def test_provider_and_email_are_validated_before_submitting(self): self.input['provider'] = 'unknown_provider' self.assertEqual(self.start()['status'], 'error') self.input['provider'] = 'cloudflare' self.legacy = True self.input['email'] = '' self.assertEqual(self.start()['status'], 'error') self.assertEqual(self.posts, []) def test_invalid_requests_do_not_start_background_work(self): for field, value in [('agree',False),('domains',['pve.home']),('domains',['a.local']), ('domains',['192.168.0.1']),('domains',['*.example.com','*.example.com']), ('domains',['a.example.com;rm']),('credentials',''),('email',None), ('propagation_seconds',True),('propagation_seconds',601)]: with self.subTest(field=field,value=value): request = dict(self.input, **{field:value}) self.assertEqual(self.request('/api/dns-challenge',request)[0],400) self.assertIsNone(self.panel.dns_challenge.thread) def test_dns_endpoints_enforce_session_origin_csrf_and_lan(self): for headers in [{'X-Homegate-CSRF':''},{'Origin':'https://attacker.example'}]: self.assertEqual(self.request('/api/dns-challenge',self.input,headers=headers)[0],403) self.assertEqual(self.request('/api/dns-challenge',self.input,peer='8.8.8.8')[0],403) self.cookie = '' for path in ['/api/dns-providers','/api/dns-challenge']: self.assertEqual(self.request(path)[0],401) self.assertEqual(self.posts,[]) def test_provider_catalog_uses_only_local_connection_and_safe_fields(self): with patch.object(self.panel,'connect_npm',return_value=self.client) as connect: code, body, _ = self.request('/api/dns-providers') self.assertEqual(code,200) self.assertFalse(body['email_required']) self.assertEqual(body['providers'][0]['id'],'cloudflare') connect.assert_called_once_with() self.client.call.side_effect = h.APIError('Forbidden',403) with self.assertRaises(h.APIError): dc.providers(self.client) # authentication/permission errors must not become legacy fallback def test_old_api_bad_certificate_id_path_uses_legacy_catalog(self): self.client.call.side_effect = h.APIError('Invalid certificate id',400) catalog = dc.providers(self.client) self.assertTrue(catalog['email_required']) self.assertTrue(any(p['id']=='cloudflare' for p in catalog['providers'])) def test_result_can_be_selected_without_changing_certificate_or_vds(self): result = self.start() state = self.request('/api/state')[1] config = state['config'] config['domain_zones'].append('example.com') config['services'] = [{'hostname':'disk.example.com','upstream':'http://192.168.0.20:8080', 'certificate_mode':'npm','npm_certificate_id':result['certificate']['id']}] self.assertEqual(self.request('/api/config',{'config':config,'revision':state['revision']})[0],200) self.assertNotIn('DNS_PRIVATE_TOKEN',self.config.read_text()) self.assertEqual(len(self.posts),1) def test_real_transport_timeout_can_be_extended_only_for_issuance(self): client = h.NPM('http://home-npm:81','NPM') self.addCleanup(client.close) response = Mock(status_code=201, content=b'{}') response.json.return_value = {} with patch.object(client.session,'request',return_value=response) as request: client.call('POST','/nginx/certificates',json={},timeout=(5,900)) self.assertEqual(request.call_args.kwargs['timeout'],(5,900)) client.call('GET','/nginx/certificates') self.assertEqual(request.call_args.kwargs['timeout'],(5,30)) source = h.RemoteNPM('https://vds.example.com','Remote NPM') self.addCleanup(source.close) for method,path in [('GET','/nginx/certificates/dns-providers'),('POST','/nginx/certificates')]: with self.assertRaisesRegex(h.Error,'read-only'): source.call(method,path)