Skip to content

ServerKit is a lightweight, modern server control panel for managing web applications, databases, and services on your VPS or dedicated server. Built with Python/Flask backend and React frontend.

feat(security): Cloudflare-aware auto-CAA on certificate issuance

Juan Denis49611a38f3ce
diff --git a/backend/app/services/dns_provider_service.py b/backend/app/services/dns_provider_service.py
index f25ddf9a..05973ec7 100644
--- a/backend/app/services/dns_provider_service.py
+++ b/backend/app/services/dns_provider_service.py
@@ -253,6 +253,51 @@ class DNSProviderService:
return {'created': False, 'reason': 'api_error', 'error': res.get('error'),
'provider': config.name, 'record': record}
+ @staticmethod
+ def parse_caa_value(value: str) -> Dict:
+ """Parse a BIND-style CAA value (``0 issue "letsencrypt.org"``) into the
+ ``{flags, tag, value}`` object that Cloudflare/DigitalOcean expect. The
+ CA value is returned unquoted."""
+ parts = (value or '').strip().split(None, 2)
+ flags = int(parts[0]) if parts and parts[0].lstrip('-').isdigit() else 0
+ tag = parts[1] if len(parts) > 1 else 'issue'
+ ca = parts[2].strip().strip('"') if len(parts) > 2 else ''
+ return {'flags': flags, 'tag': tag, 'value': ca}
+
+ @classmethod
+ def ensure_caa_record(cls, domain: str, ca: str = 'letsencrypt.org') -> Dict:
+ """Ensure a CAA record authorizing ``ca`` (default Let's Encrypt) exists at
+ the apex of whichever connected provider zone covers ``domain``. CAA is
+ evaluated by walking up to the zone apex, so an apex ``0 issue "<ca>"``
+ record protects the domain and all subdomains.
+
+ Idempotent (re-applying the same authorization is a harmless upsert) and
+ degrades to manual instructions (``created: False`` + the record to add)
+ when no connected provider manages the domain — so the caller can always
+ tell the user what to do. Never raises.
+ """
+ domain = (domain or '').strip().lower().rstrip('.')
+ value = f'0 issue "{ca}"'
+ record = {'type': 'CAA', 'name': domain, 'value': value}
+ if not domain:
+ return {'created': False, 'reason': 'no_domain', 'record': record}
+ try:
+ config, zone = cls.find_zone_for_domain(domain)
+ except Exception as e: # provider listing blew up — fall back to manual
+ return {'created': False, 'reason': 'api_error', 'error': str(e), 'record': record}
+ if not config:
+ return {'created': False, 'reason': 'no_provider', 'record': record,
+ 'message': f'No connected DNS provider manages {domain} — add '
+ f'this CAA record manually: {domain} CAA {value}'}
+
+ apex = (zone.get('name') or domain).strip().lower().rstrip('.')
+ record = {'type': 'CAA', 'name': apex, 'value': value}
+ res = cls.set_record(config.id, zone['id'], 'CAA', apex, value)
+ if res.get('success'):
+ return {'created': True, 'provider': config.name, 'zone': apex, 'record': record}
+ return {'created': False, 'reason': 'api_error', 'error': res.get('error'),
+ 'provider': config.name, 'record': record}
+
# ── Cloudflare Implementation ──
@classmethod
@@ -311,15 +356,31 @@ class DNSProviderService:
headers = cls._cloudflare_headers(config)
base = f'https://api.cloudflare.com/client/v4/zones/{zone_id}/dns_records'
- # Check if record exists
+ # CAA records need Cloudflare's structured `data` object, not a flat
+ # `content` string — sending `content` for a CAA record is rejected.
+ caa = cls.parse_caa_value(value) if record_type == 'CAA' else None
+ payload = {'type': record_type, 'name': name, 'ttl': ttl}
+ if caa is not None:
+ payload['data'] = caa
+ else:
+ payload['content'] = value
+
+ # Check if a matching record exists. For CAA there can legitimately be
+ # several records at the same name (one per CA), so match on tag+value
+ # to avoid overwriting a *different* CA's authorization.
resp = requests.get(
f'{base}?type={record_type}&name={name}',
headers=headers, timeout=15,
)
data = resp.json()
existing = data.get('result', [])
-
- payload = {'type': record_type, 'name': name, 'content': value, 'ttl': ttl}
+ if caa is not None:
+ existing = [
+ r for r in existing
+ if (r.get('data') or {}).get('tag') == caa['tag']
+ and str((r.get('data') or {}).get('value', '')).strip('"').rstrip('.').lower()
+ == caa['value'].rstrip('.').lower()
+ ]
if existing:
# Update existing record
@@ -554,6 +615,12 @@ class DNSProviderService:
if len(parts) == 2 and parts[0].isdigit():
payload['priority'] = int(parts[0])
payload['data'] = parts[1]
+ elif record_type == 'CAA':
+ # DigitalOcean wants flags/tag as separate fields, data = CA value.
+ caa = cls.parse_caa_value(value)
+ payload['flags'] = caa['flags']
+ payload['tag'] = caa['tag']
+ payload['data'] = caa['value']
# Find an existing record of the same type/host to update.
resp = requests.get(
diff --git a/backend/app/services/dns_zone_service.py b/backend/app/services/dns_zone_service.py
index 6d769486..5ebf9640 100644
--- a/backend/app/services/dns_zone_service.py
+++ b/backend/app/services/dns_zone_service.py
@@ -269,6 +269,7 @@ class DNSZoneService:
def _cloudflare_sync(zone, record, action, config):
"""Sync record to Cloudflare API."""
import requests
+ from app.services.dns_provider_service import DNSProviderService
api_token = config.get('api_token')
if not api_token:
@@ -277,17 +278,21 @@ class DNSZoneService:
headers = {'Authorization': f'Bearer {api_token}', 'Content-Type': 'application/json'}
base_url = f'https://api.cloudflare.com/client/v4/zones/{zone.provider_zone_id}/dns_records'
- if action == 'create':
- payload = {
- 'type': record.record_type,
- 'name': record.name,
- 'content': record.content,
- 'ttl': record.ttl,
- 'proxied': record.proxied,
- }
+ def _payload():
+ # CAA needs Cloudflare's structured `data` object, not a flat
+ # `content` string (and `proxied` is meaningless for it).
+ p = {'type': record.record_type, 'name': record.name, 'ttl': record.ttl}
+ if record.record_type == 'CAA':
+ p['data'] = DNSProviderService.parse_caa_value(record.content)
+ else:
+ p['content'] = record.content
+ p['proxied'] = record.proxied
if record.priority is not None:
- payload['priority'] = record.priority
- resp = requests.post(base_url, json=payload, headers=headers, timeout=10)
+ p['priority'] = record.priority
+ return p
+
+ if action == 'create':
+ resp = requests.post(base_url, json=_payload(), headers=headers, timeout=10)
if resp.ok:
data = resp.json()
record.provider_record_id = data.get('result', {}).get('id')
@@ -295,14 +300,7 @@ class DNSZoneService:
elif action == 'update' and record.provider_record_id:
url = f'{base_url}/{record.provider_record_id}'
- payload = {
- 'type': record.record_type,
- 'name': record.name,
- 'content': record.content,
- 'ttl': record.ttl,
- 'proxied': record.proxied,
- }
- requests.put(url, json=payload, headers=headers, timeout=10)
+ requests.put(url, json=_payload(), headers=headers, timeout=10)
elif action == 'delete' and record.provider_record_id:
url = f'{base_url}/{record.provider_record_id}'
diff --git a/backend/app/services/ssl_service.py b/backend/app/services/ssl_service.py
index 9ea73f63..37d5bb8f 100644
--- a/backend/app/services/ssl_service.py
+++ b/backend/app/services/ssl_service.py
@@ -77,13 +77,25 @@ class SSLService:
cert_path = f'{cls.CERTS_DIR}/{primary_domain}/fullchain.pem'
key_path = f'{cls.CERTS_DIR}/{primary_domain}/privkey.pem'
- return {
+ response = {
'success': True,
'message': 'Certificate obtained successfully',
'certificate_path': cert_path,
'private_key_path': key_path,
'domains': domains
}
+
+ # Best-effort: authorize Let's Encrypt via a CAA record on whichever
+ # connected DNS provider manages the domain. This satisfies CAA
+ # security scanners and pins issuance to our CA. Never let a CAA
+ # hiccup fail an otherwise-successful certificate.
+ try:
+ from app.services.dns_provider_service import DNSProviderService
+ response['caa'] = DNSProviderService.ensure_caa_record(primary_domain)
+ except Exception as e:
+ response['caa'] = {'created': False, 'reason': 'error', 'error': str(e)}
+
+ return response
else:
return {'success': False, 'error': result.stderr}
diff --git a/backend/tests/test_dns_caa.py b/backend/tests/test_dns_caa.py
new file mode 100644
index 00000000..2cc9ad37
--- /dev/null
+++ b/backend/tests/test_dns_caa.py
@@ -0,0 +1,150 @@
+"""Proving tests — Cloudflare-aware auto-CAA on certificate issuance.
+
+When a cert is issued for a domain whose zone is managed by a connected DNS
+provider, ServerKit auto-creates a ``CAA 0 issue "letsencrypt.org"`` record at
+the zone apex so issuance is pinned to our CA and CAA scanners are satisfied.
+The Cloudflare API needs a *structured* ``data`` object for CAA (not the flat
+``content`` string used by A/CNAME/TXT), which these tests pin down.
+"""
+
+
+def _mk_cloudflare_provider(db, api_key='tok'):
+ from app.models.email import DNSProviderConfig
+ c = DNSProviderConfig(name='cf', provider='cloudflare', api_key=api_key)
+ db.session.add(c)
+ db.session.commit()
+ return c
+
+
+class _Resp:
+ def __init__(self, js):
+ self._js = js
+
+ def json(self):
+ return self._js
+
+
+# ── pure parsing ────────────────────────────────────────────────────────────
+
+def test_parse_caa_value():
+ from app.services.dns_provider_service import DNSProviderService as S
+ assert S.parse_caa_value('0 issue "letsencrypt.org"') == {
+ 'flags': 0, 'tag': 'issue', 'value': 'letsencrypt.org'}
+ assert S.parse_caa_value('128 issuewild "pki.goog"') == {
+ 'flags': 128, 'tag': 'issuewild', 'value': 'pki.goog'}
+ assert S.parse_caa_value('0 iodef "mailto:[email protected]"') == {
+ 'flags': 0, 'tag': 'iodef', 'value': 'mailto:[email protected]'}
+
+
+# ── ensure_caa_record ───────────────────────────────────────────────────────
+
+def test_ensure_caa_record_no_provider_degrades(app):
+ """With no connected provider, degrade to manual instructions (never raise)."""
+ from app.services.dns_provider_service import DNSProviderService as S
+ r = S.ensure_caa_record('panel.example.com')
+ assert r['created'] is False and r['reason'] == 'no_provider'
+ assert r['record'] == {'type': 'CAA', 'name': 'panel.example.com',
+ 'value': '0 issue "letsencrypt.org"'}
+ assert 'manually' in r['message']
+
+
+def test_ensure_caa_record_writes_at_zone_apex(app, monkeypatch):
+ """CAA is placed at the (lower-cased) zone apex, covering all subdomains."""
+ from app.services.dns_provider_service import DNSProviderService as S
+ calls = {}
+ monkeypatch.setattr(S, 'find_zone_for_domain', classmethod(
+ lambda cls, d: (type('C', (), {'id': 1, 'name': 'cf'})(),
+ {'id': 'zoneABC', 'name': 'Example.COM'})))
+ monkeypatch.setattr(S, 'set_record', classmethod(
+ lambda cls, pid, zid, rtype, name, value, ttl=3600:
+ (calls.update(zid=zid, rtype=rtype, name=name, value=value) or {'success': True})))
+
+ r = S.ensure_caa_record('panel.example.com')
+ assert r['created'] is True and r['zone'] == 'example.com'
+ assert calls == {'zid': 'zoneABC', 'rtype': 'CAA',
+ 'name': 'example.com', 'value': '0 issue "letsencrypt.org"'}
+
+
+# ── Cloudflare wire format (the actual bug this feature fixes) ───────────────
+
+def test_cloudflare_caa_uses_structured_data(app, monkeypatch):
+ """A CAA record must POST a `data` object to Cloudflare, never `content`."""
+ from app import db
+ from app.services import dns_provider_service as dps
+ cfg = _mk_cloudflare_provider(db)
+
+ captured = {}
+ monkeypatch.setattr(dps.requests, 'get',
+ lambda url, headers=None, timeout=None: _Resp({'result': []}))
+
+ def fake_post(url, headers=None, json=None, timeout=None):
+ captured['json'] = json
+ return _Resp({'success': True})
+ monkeypatch.setattr(dps.requests, 'post', fake_post)
+
+ res = dps.DNSProviderService.set_record(
+ cfg.id, 'zoneABC', 'CAA', 'example.com', '0 issue "letsencrypt.org"')
+ assert res['success'] is True
+ assert captured['json']['type'] == 'CAA'
+ assert 'content' not in captured['json']
+ assert captured['json']['data'] == {'flags': 0, 'tag': 'issue', 'value': 'letsencrypt.org'}
+
+
+def test_cloudflare_caa_does_not_clobber_other_ca(app, monkeypatch):
+ """An existing CAA for a *different* CA must be left alone (POST a new one),
+ not overwritten via PUT."""
+ from app import db
+ from app.services import dns_provider_service as dps
+ cfg = _mk_cloudflare_provider(db)
+
+ existing = {'result': [{'id': 'rec1', 'data': {'tag': 'issue', 'value': 'digicert.com'}}]}
+ monkeypatch.setattr(dps.requests, 'get',
+ lambda url, headers=None, timeout=None: _Resp(existing))
+ verb = {}
+ monkeypatch.setattr(dps.requests, 'post',
+ lambda url, headers=None, json=None, timeout=None:
+ (verb.update(m='post') or _Resp({'success': True})))
+ monkeypatch.setattr(dps.requests, 'put',
+ lambda url, headers=None, json=None, timeout=None:
+ (verb.update(m='put') or _Resp({'success': True})))
+
+ dps.DNSProviderService.set_record(
+ cfg.id, 'z', 'CAA', 'example.com', '0 issue "letsencrypt.org"')
+ assert verb.get('m') == 'post' # created alongside, did not PUT over digicert
+
+
+# ── cert issuance hook ──────────────────────────────────────────────────────
+
+def test_obtain_certificate_invokes_caa_hook(app, monkeypatch):
+ """A successful certbot run triggers ensure_caa_record and surfaces its result."""
+ from app.services.ssl_service import SSLService
+ from app.services.dns_provider_service import DNSProviderService
+
+ monkeypatch.setattr(SSLService, 'is_certbot_installed', classmethod(lambda cls: True))
+ monkeypatch.setattr('app.services.ssl_service.run_privileged',
+ lambda *a, **k: type('R', (), {'returncode': 0, 'stdout': '', 'stderr': ''})())
+ sentinel = {'created': True, 'provider': 'cf', 'zone': 'example.com'}
+ monkeypatch.setattr(DNSProviderService, 'ensure_caa_record',
+ classmethod(lambda cls, domain, ca='letsencrypt.org': sentinel))
+
+ res = SSLService.obtain_certificate(['example.com'], '[email protected]')
+ assert res['success'] is True
+ assert res['caa'] == sentinel
+
+
+def test_obtain_certificate_caa_failure_is_non_fatal(app, monkeypatch):
+ """A CAA hiccup must never fail an otherwise-successful certificate."""
+ from app.services.ssl_service import SSLService
+ from app.services.dns_provider_service import DNSProviderService
+
+ monkeypatch.setattr(SSLService, 'is_certbot_installed', classmethod(lambda cls: True))
+ monkeypatch.setattr('app.services.ssl_service.run_privileged',
+ lambda *a, **k: type('R', (), {'returncode': 0, 'stdout': '', 'stderr': ''})())
+
+ def boom(cls, domain, ca='letsencrypt.org'):
+ raise RuntimeError('cloudflare down')
+ monkeypatch.setattr(DNSProviderService, 'ensure_caa_record', classmethod(boom))
+
+ res = SSLService.obtain_certificate(['example.com'], '[email protected]')
+ assert res['success'] is True
+ assert res['caa']['created'] is False and 'cloudflare down' in res['caa']['error']