Add UI DNS challenge issuance and automatic home NPM renewal
All checks were successful
Test and publish Homegate / checks (push) Successful in 29s
Test and publish Homegate / publish (push) Successful in 12m43s

This commit is contained in:
2026-10-15 05:42:15 +03:00
parent eeffcfb616
commit 5661de72b7
22 changed files with 1051 additions and 43 deletions

204
tests/test_dns_challenge.py Normal file
View File

@@ -0,0 +1,204 @@
"""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)