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(cloudflare): restore Round 2 engine — DNSSEC, Origin CA, rules, activity (plan 42 ph2)

Juan Denisb9ee243ba202
diff --git a/backend/app/models/__init__.py b/backend/app/models/__init__.py
index 8af90415..08e31c91 100644
--- a/backend/app/models/__init__.py
+++ b/backend/app/models/__init__.py
@@ -44,6 +44,7 @@ from app.models.workspace import Workspace, WorkspaceMember, WorkspaceApiKey, Re
from app.models.dns_zone import DNSZone, DNSRecord
from app.models.managed_dns_record import ManagedDnsRecord
from app.models.dns_change import DnsChange
+from app.models.cf_ops_change import CfOpsChange
from app.models.tunnel import Tunnel
from app.models.exposed_service import ExposedService
from app.models.status_page import StatusPage, StatusComponent, HealthCheck, StatusIncident, StatusIncidentUpdate
@@ -63,6 +64,7 @@ from app.models.backup_run import BackupRun
from app.models.restore_drill import RestoreDrill
from app.queue_bus.models import QueueGroup, Queue, QueueMessage
from app.notifications.models import Notification, NotificationDelivery
+from app.models.email_bounce import EmailBounceState
from app.models.email_provider import EmailProviderConnection
from app.models.chat_webhook import ChatWebhookConnection
from app.models.system_event import SystemEvent
@@ -91,7 +93,7 @@ __all__ = [
'AgentPlugin', 'AgentPluginInstall',
'ServerTemplate', 'ServerTemplateAssignment',
'Workspace', 'WorkspaceMember', 'WorkspaceApiKey', 'ResourceGrant',
- 'DNSZone', 'DNSRecord', 'ManagedDnsRecord', 'DnsChange',
+ 'DNSZone', 'DNSRecord', 'ManagedDnsRecord', 'DnsChange', 'CfOpsChange',
'Tunnel', 'ExposedService',
'StatusPage', 'StatusComponent', 'HealthCheck', 'StatusIncident', 'StatusIncidentUpdate',
'CloudProvider', 'CloudServer', 'CloudSnapshot',
@@ -107,6 +109,7 @@ __all__ = [
'BackupPolicy', 'BackupRun', 'RestoreDrill',
'QueueGroup', 'Queue', 'QueueMessage',
'Notification', 'NotificationDelivery',
+ 'EmailBounceState',
'EmailProviderConnection',
'ChatWebhookConnection',
'SystemEvent',
diff --git a/backend/app/models/cf_ops_change.py b/backend/app/models/cf_ops_change.py
new file mode 100644
index 00000000..bc4a841a
--- /dev/null
+++ b/backend/app/models/cf_ops_change.py
@@ -0,0 +1,45 @@
+from datetime import datetime
+
+from app import db
+
+
+class CfOpsChange(db.Model):
+ """Audit trail of every Cloudflare *operations* write ServerKit makes to a zone
+ (settings, DNSSEC, WAF, redirect/transform rules, Origin CA, Workers, Tunnels,
+ R2/KV/D1) — the ops-layer sibling of :class:`DnsChange`, which only covers DNS
+ *record* writes.
+
+ Powers the per-zone Activity tab so an operator can see exactly what the panel
+ changed on a Cloudflare zone (and what failed) without leaving ServerKit.
+ Written best-effort at the extension's service layer via
+ :meth:`CfOpsChangeService.record`, which never raises — an audit write must not
+ break the operation it describes. Keyed by ``provider_zone_id`` for per-zone
+ filtering.
+ """
+ __tablename__ = 'cf_ops_changes'
+
+ id = db.Column(db.Integer, primary_key=True)
+ dns_provider_config_id = db.Column(
+ db.Integer, db.ForeignKey('dns_provider_configs.id'), nullable=True, index=True)
+ provider_zone_id = db.Column(db.String(128), index=True)
+ product = db.Column(db.String(32), nullable=False)
+ action = db.Column(db.String(32), nullable=False)
+ target = db.Column(db.String(256))
+ result = db.Column(db.String(16), nullable=False, default='ok')
+ error = db.Column(db.Text)
+ user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=True)
+ created_at = db.Column(db.DateTime, default=datetime.utcnow, index=True)
+
+ def to_dict(self):
+ return {
+ 'id': self.id,
+ 'dns_provider_config_id': self.dns_provider_config_id,
+ 'provider_zone_id': self.provider_zone_id,
+ 'product': self.product,
+ 'action': self.action,
+ 'target': self.target,
+ 'result': self.result,
+ 'error': self.error,
+ 'user_id': self.user_id,
+ 'created_at': self.created_at.isoformat() if self.created_at else None,
+ }
diff --git a/backend/app/services/cf_ops_change_service.py b/backend/app/services/cf_ops_change_service.py
new file mode 100644
index 00000000..ca1173dd
--- /dev/null
+++ b/backend/app/services/cf_ops_change_service.py
@@ -0,0 +1,64 @@
+"""The Cloudflare-ops activity ledger — every zone-operations write ServerKit
+makes (settings, DNSSEC, WAF, redirect/transform rules, Origin CA, Workers,
+Tunnels, storage) is recorded here, keyed by ``provider_zone_id``.
+
+The ops-layer sibling of :class:`DnsChangeService` (which covers DNS *record*
+writes). Recording is best-effort and **never raises** — an audit write must not
+break the operation it describes. The current user is captured opportunistically
+from the JWT when called inside a request.
+"""
+import logging
+
+from app import db
+from app.models.cf_ops_change import CfOpsChange
+
+logger = logging.getLogger(__name__)
+
+
+class CfOpsChangeService:
+
+ @staticmethod
+ def _current_user_id():
+ """Best-effort current user id (None outside a request/JWT context)."""
+ try:
+ from flask_jwt_extended import get_jwt_identity
+ return get_jwt_identity()
+ except Exception:
+ return None
+
+ @staticmethod
+ def record(*, provider_zone_id, product, action, target=None, result='ok',
+ error=None, config_id=None, user_id=None):
+ """Append a Cloudflare-ops change to the ledger. Never raises."""
+ try:
+ row = CfOpsChange(
+ provider_zone_id=provider_zone_id,
+ product=product,
+ action=action,
+ target=str(target)[:256] if target is not None else None,
+ result=result,
+ error=error,
+ dns_provider_config_id=config_id,
+ user_id=user_id if user_id is not None
+ else CfOpsChangeService._current_user_id(),
+ )
+ db.session.add(row)
+ db.session.commit()
+ return row
+ except Exception as e:
+ db.session.rollback()
+ logger.warning('Failed to record Cloudflare ops change: %s', e)
+ return None
+
+ @staticmethod
+ def list(provider_zone_id=None, config_id=None, product=None, result=None, limit=100):
+ q = CfOpsChange.query
+ if provider_zone_id:
+ q = q.filter_by(provider_zone_id=provider_zone_id)
+ if config_id:
+ q = q.filter_by(dns_provider_config_id=config_id)
+ if product:
+ q = q.filter_by(product=product)
+ if result:
+ q = q.filter_by(result=result)
+ return q.order_by(CfOpsChange.created_at.desc(), CfOpsChange.id.desc()).limit(limit).all()
diff --git a/backend/app/services/dns/cloudflare.py b/backend/app/services/dns/cloudflare.py
index 3213367d..aced7f85 100644
--- a/backend/app/services/dns/cloudflare.py
+++ b/backend/app/services/dns/cloudflare.py
@@ -252,14 +252,18 @@ class CloudflareClient:
# helper rather than a bespoke method per call. It normalizes the envelope so
# every caller can rely on ``{success, error?, result?}``.
def request(self, method: str, path: str, json: dict = None,
- params: dict = None, timeout: int = 20) -> dict:
+ params: dict = None, timeout: int = 20, headers: dict = None) -> dict:
"""Make a Cloudflare v4 call. ``path`` is relative to the API base (a
leading slash is optional). Returns the parsed envelope dict (always with
a ``success`` key and, on failure, a human ``error``), or a normalized
- ``{success: False, error}`` on a transport error."""
+ ``{success: False, error}`` on a transport error.
+
+ ``headers`` overrides the default auth headers — used by the Origin CA
+ endpoints, which authenticate with the account-level Origin CA service key
+ (``X-Auth-User-Service-Key``) rather than the zone token."""
try:
url = f'{API_BASE}/{path.lstrip("/")}'
- resp = requests.request(method.upper(), url, headers=self._headers(),
+ resp = requests.request(method.upper(), url, headers=headers or self._headers(),
json=json, params=params, timeout=timeout)
try:
data = resp.json()
@@ -293,6 +297,57 @@ class CloudflareClient:
``{purge_everything: true}`` or ``{files|hosts|prefixes|tags: [...]}``."""
return self.request('POST', f'/zones/{zone_id}/purge_cache', json=payload)
+ # ── DNSSEC ────────────────────────────────────────────────────────────────
+ # DNSSEC is a per-zone toggle; enabling it returns the DS record payload the
+ # operator must place at their registrar. No registrar automation — display.
+ def get_dnssec(self, zone_id: str) -> dict:
+ """The zone's DNSSEC status + DS record fields (``result`` carries ``status``,
+ ``ds``, ``digest``, ``key_tag``, …)."""
+ return self.request('GET', f'/zones/{zone_id}/dnssec')
+
+ def set_dnssec(self, zone_id: str, status: str) -> dict:
+ """Enable (``status='active'``) or disable (``status='disabled'``) DNSSEC."""
+ return self.request('PATCH', f'/zones/{zone_id}/dnssec', json={'status': status})
+
+ # ── Origin CA certificates ────────────────────────────────────────────────
+ # Origin CA certs are valid ONLY behind the Cloudflare proxy. They authenticate
+ # with the account-level Origin CA *service key* (``X-Auth-User-Service-Key``)
+ # OR a token carrying the SSL and Certificates permission. The CSR is generated
+ # panel-side; the private key never leaves the box.
+ ORIGIN_CA_BASE = 'certificates'
+
+ def _origin_ca_headers(self, service_key: str = None) -> dict:
+ """Auth headers for the Origin CA endpoints. Prefer the dedicated service
+ key when present; otherwise fall back to the zone's normal token headers
+ (a suitably-scoped token also authenticates these calls)."""
+ if service_key:
+ return {'X-Auth-User-Service-Key': service_key,
+ 'Content-Type': 'application/json'}
+ return self._headers()
+
+ def create_origin_certificate(self, *, csr: str, hostnames: list,
+ requested_validity: int = 5475,
+ request_type: str = 'origin-rsa',
+ service_key: str = None) -> dict:
+ """Sign a panel-generated CSR into an Origin CA certificate for ``hostnames``
+ (``result.certificate`` is the signed PEM). ``requested_validity`` is in days
+ (7, 30, 90, 365, 730, 1095 or 5475)."""
+ return self.request(
+ 'POST', f'/{self.ORIGIN_CA_BASE}',
+ json={'csr': csr, 'hostnames': hostnames,
+ 'requested_validity': requested_validity, 'request_type': request_type},
+ headers=self._origin_ca_headers(service_key))
+
+ def list_origin_certificates(self, zone_id: str, *, service_key: str = None) -> dict:
+ """List Origin CA certificates for a zone (``result`` is a list)."""
+ return self.request('GET', f'/{self.ORIGIN_CA_BASE}', params={'zone_id': zone_id},
+ headers=self._origin_ca_headers(service_key))
+
+ def revoke_origin_certificate(self, certificate_id: str, *, service_key: str = None) -> dict:
+ """Revoke an Origin CA certificate by id."""
+ return self.request('DELETE', f'/{self.ORIGIN_CA_BASE}/{certificate_id}',
+ headers=self._origin_ca_headers(service_key))
+
# ── WAF / rulesets ────────────────────────────────────────────────────────
# Custom firewall rules live in the zone's ``http_request_firewall_custom``
# phase entry-point ruleset. We list rulesets to find it (cleanly telling
diff --git a/backend/app/services/ssl_service.py b/backend/app/services/ssl_service.py
index 37d5bb8f..65c2809d 100644
--- a/backend/app/services/ssl_service.py
+++ b/backend/app/services/ssl_service.py
@@ -14,6 +14,9 @@ class SSLService:
CERTBOT_BIN = os.environ.get('CERTBOT_BIN', '/usr/bin/certbot')
CERTS_DIR = '/etc/letsencrypt/live'
RENEWAL_DIR = '/etc/letsencrypt/renewal'
+ # Custom-cert install location (e.g. issued Cloudflare Origin CA certs, written
+ # by AdvancedSSLService.upload_custom_cert). certbot doesn't know about these.
+ SERVERKIT_CERTS_DIR = '/etc/ssl/serverkit'
@classmethod
def is_certbot_installed(cls) -> bool:
@@ -159,45 +162,85 @@ class SSLService:
try:
result = run_privileged([cls.CERTBOT_BIN, 'certificates'], timeout=60)
- if result.returncode != 0:
- return certificates
-
- # Parse certbot output
- current_cert = None
- for line in result.stdout.split('\n'):
- line = line.strip()
-
- if line.startswith('Certificate Name:'):
- if current_cert:
- certificates.append(current_cert)
- current_cert = {'name': line.split(':', 1)[1].strip()}
-
- elif current_cert:
- if line.startswith('Domains:'):
- current_cert['domains'] = line.split(':', 1)[1].strip().split()
- elif line.startswith('Expiry Date:'):
- expiry_str = line.split(':', 1)[1].strip()
- # Parse expiry date
- try:
- # Format: 2024-03-15 12:00:00+00:00
- expiry_part = expiry_str.split(' (')[0]
- current_cert['expiry'] = expiry_part
- current_cert['expiry_valid'] = 'VALID' in expiry_str
- except Exception:
- current_cert['expiry'] = expiry_str
- elif line.startswith('Certificate Path:'):
- current_cert['cert_path'] = line.split(':', 1)[1].strip()
- elif line.startswith('Private Key Path:'):
- current_cert['key_path'] = line.split(':', 1)[1].strip()
-
- if current_cert:
- certificates.append(current_cert)
+ # Parse certbot output (skip on a non-zero exit, but still surface the
+ # custom-installed certs below).
+ if result.returncode == 0:
+ current_cert = None
+ for line in result.stdout.split('\n'):
+ line = line.strip()
+
+ if line.startswith('Certificate Name:'):
+ if current_cert:
+ certificates.append(current_cert)
+ current_cert = {'name': line.split(':', 1)[1].strip()}
+
+ elif current_cert:
+ if line.startswith('Domains:'):
+ current_cert['domains'] = line.split(':', 1)[1].strip().split()
+ elif line.startswith('Expiry Date:'):
+ expiry_str = line.split(':', 1)[1].strip()
+ # Parse expiry date
+ try:
+ # Format: 2024-03-15 12:00:00+00:00
+ expiry_part = expiry_str.split(' (')[0]
+ current_cert['expiry'] = expiry_part
+ current_cert['expiry_valid'] = 'VALID' in expiry_str
+ except Exception:
+ current_cert['expiry'] = expiry_str
+ elif line.startswith('Certificate Path:'):
+ current_cert['cert_path'] = line.split(':', 1)[1].strip()
+ elif line.startswith('Private Key Path:'):
+ current_cert['key_path'] = line.split(':', 1)[1].strip()
+
+ if current_cert:
+ certificates.append(current_cert)
except Exception:
pass
+ # Also surface custom-installed certs (e.g. Cloudflare Origin CA), which
+ # certbot doesn't track. Parse the x509 issuer to badge them.
+ certificates.extend(cls._list_serverkit_certificates())
+
return certificates
+ @classmethod
+ def _list_serverkit_certificates(cls) -> List[Dict]:
+ """Walk the custom-cert install dir (``/etc/ssl/serverkit/<domain>/cert.pem``)
+ and describe each cert, badging Cloudflare Origin CA certs as proxy-only."""
+ import glob
+ out: List[Dict] = []
+ try:
+ from cryptography import x509
+ from cryptography.hazmat.backends import default_backend
+ except Exception:
+ return out
+
+ for cert_path in sorted(glob.glob(f'{cls.SERVERKIT_CERTS_DIR}/*/cert.pem')):
+ try:
+ domain = os.path.basename(os.path.dirname(cert_path))
+ with open(cert_path, 'rb') as fh:
+ cert = x509.load_pem_x509_certificate(fh.read(), default_backend())
+ issuer = cert.issuer.rfc4514_string()
+ is_origin_ca = 'origin' in issuer.lower() and 'cloudflare' in issuer.lower()
+ try:
+ expiry = cert.not_valid_after_utc
+ except AttributeError: # cryptography < 42
+ expiry = cert.not_valid_after
+ out.append({
+ 'name': domain,
+ 'domains': [domain],
+ 'cert_path': cert_path,
+ 'key_path': os.path.join(os.path.dirname(cert_path), 'key.pem'),
+ 'issuer': issuer,
+ 'source': 'custom',
+ 'badge': 'Origin CA (proxy-only)' if is_origin_ca else None,
+ 'expiry': expiry.strftime('%Y-%m-%d %H:%M:%S%z') if expiry else None,
+ })
+ except Exception:
+ continue
+ return out
+
@classmethod
def get_certificate_info(cls, domain: str) -> Optional[Dict]:
"""Get detailed information about a specific certificate."""
diff --git a/backend/tests/test_cloudflare_round2.py b/backend/tests/test_cloudflare_round2.py
new file mode 100644
index 00000000..6db54adf
--- /dev/null
+++ b/backend/tests/test_cloudflare_round2.py
@@ -0,0 +1,566 @@
+"""Proving tests for Cloudflare Round 2 (plan 36): DNSSEC, Origin CA, redirect/
+transform rules, the per-zone activity ledger, and token scope diagnostics.
+
+Reconstructed after the 2026-07-08 data loss (migrations 073/074 survived; the
+model/service/routes/client code + this suite did not). Mirrors the conventions of
+``test_cloudflare_zone_settings.py``: Cloudflare HTTP is stubbed by monkeypatching
+``requests`` on the shared client module, and the extension's ``CloudflareService``
+is reached through the ``cloudflare_ops_bridge`` importlib helper.
+"""
+import types
+
+import pytest
+
+
+class _Resp:
+ def __init__(self, js, status=200):
+ self._js = js
+ self.status_code = status
+
+ def json(self):
+ return self._js
+
+
+def _client(token='tok'):
+ from app.services.dns import cloudflare as cf
+ from app.services.dns.base import DnsCredential
+ return cf.CloudflareClient(DnsCredential(provider='cloudflare', token=token))
+
+
+def _make_cf_zone(domain='example.com', provider='cloudflare', zid='zoneABC', token='tok'):
+ from app import db
+ from app.models.dns_zone import DNSZone
+ zone = DNSZone(domain=domain, provider=provider, provider_zone_id=zid)
+ if token:
+ zone.provider_config = {'api_token': token}
+ db.session.add(zone)
+ db.session.commit()
+ return zone
+
+
+# ── DNSSEC — client ───────────────────────────────────────────────────────────
+
+def test_client_get_dnssec(monkeypatch):
+ from app.services.dns import cloudflare as cf
+ seen = {}
+
+ def cap(method, url, headers=None, json=None, params=None, timeout=None):
+ seen.update(method=method, url=url)
+ return _Resp({'success': True, 'result': {'status': 'active'}})
+ monkeypatch.setattr(cf.requests, 'request', cap)
+ res = _client().get_dnssec('zoneA')
+ assert res['success'] is True
+ assert seen['method'] == 'GET' and seen['url'].endswith('/zones/zoneA/dnssec')
+
+
+def test_client_set_dnssec_patches_status(monkeypatch):
+ from app.services.dns import cloudflare as cf
+ seen = {}
+
+ def cap(method, url, headers=None, json=None, params=None, timeout=None):
+ seen.update(method=method, url=url, json=json)
+ return _Resp({'success': True, 'result': {'status': 'pending'}})
+ monkeypatch.setattr(cf.requests, 'request', cap)
+ _client().set_dnssec('zoneA', 'active')
+ assert seen['method'] == 'PATCH'
+ assert seen['url'].endswith('/zones/zoneA/dnssec')
+ assert seen['json'] == {'status': 'active'}
+
+
+# ── DNSSEC — service ──────────────────────────────────────────────────────────
+
+def test_service_get_dnssec_normalizes(app, monkeypatch):
+ from app.services.dns import cloudflare as cf
+ from app.services import cloudflare_ops_bridge as _cfb
+ CloudflareService = _cfb.cloudflare_service()
+ zone = _make_cf_zone()
+ monkeypatch.setattr(cf.requests, 'request',
+ lambda *a, **k: _Resp({'success': True, 'result': {
+ 'status': 'active', 'ds': 'DSRECORD', 'key_tag': 42,
+ 'digest_type': 2}}))
+ res = CloudflareService.get_dnssec(zone.id)
+ assert res['success'] is True
+ assert res['dnssec']['status'] == 'active'
+ assert res['dnssec']['ds'] == 'DSRECORD'
+ assert res['dnssec']['key_tag'] == 42
+
+
+def test_service_set_dnssec_enables_and_records(app, monkeypatch):
+ from app.services.dns import cloudflare as cf
+ from app.services import cloudflare_ops_bridge as _cfb
+ from app.models.cf_ops_change import CfOpsChange
+ CloudflareService = _cfb.cloudflare_service()
+ zone = _make_cf_zone()
+ monkeypatch.setattr(cf.requests, 'request',
+ lambda *a, **k: _Resp({'success': True,
+ 'result': {'status': 'pending'}}))
+ res = CloudflareService.set_dnssec(zone.id, True)
+ assert res['success'] is True and res['dnssec']['status'] == 'pending'
+ row = CfOpsChange.query.filter_by(provider_zone_id='zoneABC', product='dnssec').first()
+ assert row is not None and row.action == 'enable' and row.result == 'ok'
+
+
+def test_service_set_dnssec_error_records_failure(app, monkeypatch):
+ from app.services.dns import cloudflare as cf
+ from app.services import cloudflare_ops_bridge as _cfb
+ from app.models.cf_ops_change import CfOpsChange
+ CloudflareService = _cfb.cloudflare_service()
+ zone = _make_cf_zone()
+ monkeypatch.setattr(cf.requests, 'request',
+ lambda *a, **k: _Resp({'success': False,
+ 'errors': [{'message': 'zone is not full'}]}))
+ res = CloudflareService.set_dnssec(zone.id, True)
+ assert res['success'] is False and 'not full' in res['error']
+ row = CfOpsChange.query.filter_by(provider_zone_id='zoneABC', product='dnssec').first()
+ assert row is not None and row.result == 'error' and 'not full' in (row.error or '')
+
+
+# ── Origin CA — client ────────────────────────────────────────────────────────
+
+def test_client_origin_ca_uses_service_key_header(monkeypatch):
+ from app.services.dns import cloudflare as cf
+ seen = {}
+
+ def cap(method, url, headers=None, json=None, params=None, timeout=None):
+ seen.update(method=method, url=url, headers=headers, json=json)
+ return _Resp({'success': True, 'result': {'id': 'c1', 'certificate': 'PEM'}})
+ monkeypatch.setattr(cf.requests, 'request', cap)
+ res = _client().create_origin_certificate(csr='CSR', hostnames=['a.example.com'],
+ service_key='v1.0-SVCKEY')
+ assert res['success'] is True
+ assert seen['method'] == 'POST' and seen['url'].endswith('/certificates')
+ assert seen['headers']['X-Auth-User-Service-Key'] == 'v1.0-SVCKEY'
+ assert 'Authorization' not in seen['headers']
+ assert seen['json']['csr'] == 'CSR' and seen['json']['hostnames'] == ['a.example.com']
+
+
+def test_client_origin_ca_falls_back_to_token(monkeypatch):
+ from app.services.dns import cloudflare as cf
+ seen = {}
+
+ def cap(method, url, headers=None, json=None, params=None, timeout=None):
+ seen.update(headers=headers, params=params)
+ return _Resp({'success': True, 'result': []})
+ monkeypatch.setattr(cf.requests, 'request', cap)
+ _client().list_origin_certificates('zoneA')
+ assert seen['headers']['Authorization'] == 'Bearer tok'
+ assert 'X-Auth-User-Service-Key' not in seen['headers']
+ assert seen['params'] == {'zone_id': 'zoneA'}
+
+
+def test_client_revoke_origin_certificate(monkeypatch):
+ from app.services.dns import cloudflare as cf
+ seen = {}
+
+ def cap(method, url, headers=None, json=None, params=None, timeout=None):
+ seen.update(method=method, url=url)
+ return _Resp({'success': True, 'result': {'id': 'c1'}})
+ monkeypatch.setattr(cf.requests, 'request', cap)
+ _client().revoke_origin_certificate('c1')
+ assert seen['method'] == 'DELETE' and seen['url'].endswith('/certificates/c1')
+
+
+# ── Origin CA — service ───────────────────────────────────────────────────────
+
+def test_issue_origin_cert_returns_cert_and_warns_unproxied(app, monkeypatch):
+ from app.services.dns import cloudflare as cf
+ from app.services import cloudflare_ops_bridge as _cfb
+ from app.models.cf_ops_change import CfOpsChange
+ CloudflareService = _cfb.cloudflare_service()
+ zone = _make_cf_zone()
+
+ def req(method, url, headers=None, json=None, params=None, timeout=None):
+ if method == 'POST' and url.endswith('/certificates'):
+ # the CSR is generated panel-side and sent; the key is NOT
+ assert 'csr' in (json or {}) and 'key' not in (json or {})
+ return _Resp({'success': True, 'result': {
+ 'id': 'cert1', 'certificate': 'CERTPEM', 'expires_on': '2027-01-01'}})
+ return _Resp({'success': False})
+
+ def get(url, headers=None, params=None, timeout=None):
+ # DNS records lookup for the proxied-hostname warning: grey-cloud record
+ return _Resp({'success': True, 'result': [
+ {'id': 'r', 'type': 'A', 'name': 'app.example.com',
+ 'content': '1.2.3.4', 'proxied': False}]})
+ monkeypatch.setattr(cf.requests, 'request', req)
+ monkeypatch.setattr(cf.requests, 'get', get)
+
+ res = CloudflareService.issue_origin_certificate(
+ zone.id, ['app.example.com'], validity_days=5475, install=False)
+ assert res['success'] is True
+ assert res['certificate'] == 'CERTPEM' and res['certificate_id'] == 'cert1'
+ assert res['proxy_only'] is True
+ assert any('not proxied' in w for w in res['warnings'])
+ row = CfOpsChange.query.filter_by(provider_zone_id='zoneABC', product='origin_ca').first()
+ assert row is not None and row.action == 'issue' and row.result == 'ok'
+
+
+def test_issue_origin_cert_validates_hostnames(app):
+ from app.services import cloudflare_ops_bridge as _cfb
+ CloudflareService, CloudflareError = _cfb.cloudflare_service(), _cfb.cloudflare_error()
+ zone = _make_cf_zone()
+ with pytest.raises(CloudflareError):
+ CloudflareService.issue_origin_certificate(zone.id, [], install=False)
+
+
+def test_issue_origin_cert_validates_validity(app):
+ from app.services import cloudflare_ops_bridge as _cfb
+ CloudflareService, CloudflareError = _cfb.cloudflare_service(), _cfb.cloudflare_error()
+ zone = _make_cf_zone()
+ with pytest.raises(CloudflareError):
+ CloudflareService.issue_origin_certificate(
+ zone.id, ['a.example.com'], validity_days=999, install=False)
+
+
+def test_issue_origin_cert_scope_error_raises_400_not_502(app, monkeypatch):
+ from app.services.dns import cloudflare as cf
+ from app.services import cloudflare_ops_bridge as _cfb
+ CloudflareService, CloudflareError = _cfb.cloudflare_service(), _cfb.cloudflare_error()
+ zone = _make_cf_zone()
+ monkeypatch.setattr(cf.requests, 'request',
+ lambda *a, **k: _Resp({'success': False, 'errors': [
+ {'message': 'You do not have permission to use Origin CA'}]}))
+ with pytest.raises(CloudflareError):
+ CloudflareService.issue_origin_certificate(
+ zone.id, ['a.example.com'], install=False)
+
+
+def test_list_origin_certificates_maps(app, monkeypatch):
+ from app.services.dns import cloudflare as cf
+ from app.services import cloudflare_ops_bridge as _cfb
+ CloudflareService = _cfb.cloudflare_service()
+ zone = _make_cf_zone()
+ monkeypatch.setattr(cf.requests, 'request',
+ lambda *a, **k: _Resp({'success': True, 'result': [
+ {'id': 'c1', 'hostnames': ['a.example.com'],
+ 'expires_on': '2027-01-01', 'requested_validity': 5475}]}))
+ res = CloudflareService.list_origin_certificates(zone.id)
+ assert res['success'] is True and res['proxy_only'] is True
+ assert res['certificates'][0]['id'] == 'c1'
+ assert res['certificates'][0]['hostnames'] == ['a.example.com']
+
+
+def test_list_origin_certificates_scope_error_raises(app, monkeypatch):
+ from app.services.dns import cloudflare as cf
+ from app.services import cloudflare_ops_bridge as _cfb
+ CloudflareService, CloudflareError = _cfb.cloudflare_service(), _cfb.cloudflare_error()
+ zone = _make_cf_zone()
+ monkeypatch.setattr(cf.requests, 'request',
+ lambda *a, **k: _Resp({'success': False, 'errors': [
+ {'message': 'Authentication error'}]}))
+ with pytest.raises(CloudflareError):
+ CloudflareService.list_origin_certificates(zone.id)
+
+
+def test_revoke_origin_certificate_records(app, monkeypatch):
+ from app.services.dns import cloudflare as cf
+ from app.services import cloudflare_ops_bridge as _cfb
+ from app.models.cf_ops_change import CfOpsChange
+ CloudflareService = _cfb.cloudflare_service()
+ zone = _make_cf_zone()
+ monkeypatch.setattr(cf.requests, 'request',
+ lambda *a, **k: _Resp({'success': True, 'result': {'id': 'c1'}}))
+ res = CloudflareService.revoke_origin_certificate(zone.id, 'c1')
+ assert res['success'] is True and res['certificate_id'] == 'c1'
+ row = CfOpsChange.query.filter_by(provider_zone_id='zoneABC', product='origin_ca',
+ action='revoke').first()
+ assert row is not None and row.result == 'ok'
+
+
+def test_install_origin_cert_uses_upload_seam(app, monkeypatch):
+ from app.services import advanced_ssl_service as adv
+ from app.services import cloudflare_ops_bridge as _cfb
+ CloudflareService = _cfb.cloudflare_service()
+ captured = {}
+
+ def fake_upload(domain, cert_pem, key_pem, chain_pem=None):
+ captured.update(domain=domain, cert=cert_pem, key=key_pem)
+ return {'domain': domain, 'cert_path': f'/etc/ssl/serverkit/{domain}/cert.pem',
+ 'key_path': f'/etc/ssl/serverkit/{domain}/key.pem'}
+ monkeypatch.setattr(adv.AdvancedSSLService, 'upload_custom_cert',
+ staticmethod(fake_upload))
+ out = CloudflareService._install_origin_cert(['app.example.com'], 'CERTPEM', 'KEYPEM')
+ assert out['success'] is True
+ assert captured['domain'] == 'app.example.com'
+ assert captured['cert'] == 'CERTPEM' and captured['key'] == 'KEYPEM'
+
+
+# ── SSL list: custom certs surfaced with Origin CA badge ──────────────────────
+
+def _write_origin_cert(directory, domain):
+ import os
+ from datetime import datetime, timedelta
+ from cryptography import x509
+ from cryptography.x509.oid import NameOID
+ from cryptography.hazmat.primitives import hashes, serialization
+ from cryptography.hazmat.primitives.asymmetric import rsa
+
+ key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
+ issuer = x509.Name([
+ x509.NameAttribute(NameOID.ORGANIZATION_NAME, 'CloudFlare, Inc.'),
+ x509.NameAttribute(NameOID.COMMON_NAME, 'CloudFlare Origin SSL Certificate Authority'),
+ ])
+ subject = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, domain)])
+ cert = (x509.CertificateBuilder()
+ .subject_name(subject).issuer_name(issuer)
+ .public_key(key.public_key())
+ .serial_number(x509.random_serial_number())
+ .not_valid_before(datetime.utcnow() - timedelta(days=1))
+ .not_valid_after(datetime.utcnow() + timedelta(days=365))
+ .sign(key, hashes.SHA256()))
+ cert_dir = os.path.join(directory, domain)
+ os.makedirs(cert_dir, exist_ok=True)
+ with open(os.path.join(cert_dir, 'cert.pem'), 'wb') as fh:
+ fh.write(cert.public_bytes(serialization.Encoding.PEM))
+
+
+def test_ssl_list_certificates_includes_origin_ca_badge(app, monkeypatch, tmp_path):
+ from app.services import ssl_service as sslmod
+ _write_origin_cert(str(tmp_path), 'app.example.com')
+ monkeypatch.setattr(sslmod.SSLService, 'SERVERKIT_CERTS_DIR', str(tmp_path))
+ # Force the certbot branch to yield nothing so only the serverkit walk runs.
+ monkeypatch.setattr(sslmod, 'run_privileged',
+ lambda *a, **k: types.SimpleNamespace(returncode=1, stdout='', stderr=''))
+ certs = sslmod.SSLService.list_certificates()
+ origin = next((c for c in certs if c.get('name') == 'app.example.com'), None)
+ assert origin is not None
+ assert origin['source'] == 'custom'
+ assert origin['badge'] == 'Origin CA (proxy-only)'
+
+
+# ── Redirect + Transform rules ────────────────────────────────────────────────
+
+def test_rules_unknown_slug_raises(app):
+ from app.services import cloudflare_ops_bridge as _cfb
+ CloudflareService, CloudflareError = _cfb.cloudflare_service(), _cfb.cloudflare_error()
+ zone = _make_cf_zone()
+ with pytest.raises(CloudflareError):
+ CloudflareService.list_rules(zone.id, 'bogus')
+
+
+def test_rules_list_empty_when_no_ruleset(app, monkeypatch):
+ from app.services.dns import cloudflare as cf
+ from app.services import cloudflare_ops_bridge as _cfb
+ CloudflareService = _cfb.cloudflare_service()
+ zone = _make_cf_zone()
+ monkeypatch.setattr(cf.requests, 'request',
+ lambda method, url, **k:
+ _Resp({'success': True, 'result': []})
+ if url.endswith('/rulesets') else _Resp({'success': False}))
+ res = CloudflareService.list_rules(zone.id, 'redirect')
+ assert res['success'] is True and res['ruleset_id'] is None and res['rules'] == []
+ assert any(p['key'] == 'force_www' for p in res['presets'])
+
+
+def test_rules_add_creates_phase_ruleset(app, monkeypatch):
+ from app.services.dns import cloudflare as cf
+ from app.services import cloudflare_ops_bridge as _cfb
+ CloudflareService = _cfb.cloudflare_service()
+ zone = _make_cf_zone()
+ seen = {}
+
+ def stub(method, url, headers=None, json=None, params=None, timeout=None):
+ if method == 'GET' and url.endswith('/rulesets'):
+ return _Resp({'success': True, 'result': []})
+ if method == 'PUT' and url.endswith('/phases/http_request_dynamic_redirect/entrypoint'):
+ seen.update(json=json)
+ return _Resp({'success': True, 'result': {'id': 'rsNew'}})
+ return _Resp({'success': False})
+ monkeypatch.setattr(cf.requests, 'request', stub)
+ res = CloudflareService.add_rule(zone.id, 'redirect', description='d',
+ expression='(http.host eq "example.com")',
+ action='redirect')
+ assert res['success'] is True
+ assert seen['json']['rules'][0]['action'] == 'redirect'
+
+
+def test_rules_add_rejects_bad_action(app):
+ from app.services import cloudflare_ops_bridge as _cfb
+ CloudflareService, CloudflareError = _cfb.cloudflare_service(), _cfb.cloudflare_error()
+ zone = _make_cf_zone()
+ with pytest.raises(CloudflareError):
+ CloudflareService.add_rule(zone.id, 'redirect', description='d',
+ expression='x', action='block')
+
+
+def test_rules_preset_force_www_builds_expression(app, monkeypatch):
+ from app.services.dns import cloudflare as cf
+ from app.services import cloudflare_ops_bridge as _cfb
+ from app.models.cf_ops_change import CfOpsChange
+ CloudflareService = _cfb.cloudflare_service()
+ zone = _make_cf_zone()
+ seen = {}
+
+ def stub(method, url, headers=None, json=None, params=None, timeout=None):
+ if method == 'GET' and url.endswith('/rulesets'):
+ return _Resp({'success': True, 'result': [
+ {'id': 'rs1', 'phase': 'http_request_dynamic_redirect', 'kind': 'zone'}]})
+ if method == 'POST' and url.endswith('/rulesets/rs1/rules'):
+ seen.update(json=json)
+ return _Resp({'success': True, 'result': {'id': 'rs1'}})
+ return _Resp({'success': False})
+ monkeypatch.setattr(cf.requests, 'request', stub)
+ res = CloudflareService.apply_rule_preset(zone.id, 'redirect', 'force_www')
+ assert res['success'] is True
+ assert 'http.host eq "example.com"' in seen['json']['expression']
+ assert seen['json']['action'] == 'redirect'
+ assert 'www.example.com' in seen['json']['action_parameters']['from_value']['target_url']['expression']
+ row = CfOpsChange.query.filter_by(provider_zone_id='zoneABC', product='redirect').first()
+ assert row is not None and row.action == 'add-rule'
+
+
+def test_rules_preset_transform_strip_tracking(app, monkeypatch):
+ from app.services.dns import cloudflare as cf
+ from app.services import cloudflare_ops_bridge as _cfb
+ CloudflareService = _cfb.cloudflare_service()
+ zone = _make_cf_zone()
+ seen = {}
+
+ def stub(method, url, headers=None, json=None, params=None, timeout=None):
+ if method == 'GET' and url.endswith('/rulesets'):
+ return _Resp({'success': True, 'result': []})
+ if method == 'PUT' and url.endswith('/phases/http_request_transform/entrypoint'):
+ seen.update(json=json)
+ return _Resp({'success': True, 'result': {'id': 'rsT'}})
+ return _Resp({'success': False})
+ monkeypatch.setattr(cf.requests, 'request', stub)
+ res = CloudflareService.apply_rule_preset(zone.id, 'transform', 'strip_tracking')
+ assert res['success'] is True
+ assert seen['json']['rules'][0]['action'] == 'rewrite'
+ assert 'utm_' in seen['json']['rules'][0]['action_parameters']['uri']['query']['expression']
+
+
+def test_rules_update_validates_action(app):
+ from app.services import cloudflare_ops_bridge as _cfb
+ CloudflareService, CloudflareError = _cfb.cloudflare_service(), _cfb.cloudflare_error()
+ zone = _make_cf_zone()
+ with pytest.raises(CloudflareError):
+ CloudflareService.update_rule(zone.id, 'redirect', 'rs1', 'r1', {'action': 'block'})
+
+
+def test_rules_delete_calls_delete(app, monkeypatch):
+ from app.services.dns import cloudflare as cf
+ from app.services import cloudflare_ops_bridge as _cfb
+ CloudflareService = _cfb.cloudflare_service()
+ zone = _make_cf_zone()
+ deleted = {}
+
+ def stub(method, url, headers=None, json=None, params=None, timeout=None):
+ if method == 'DELETE':
+ deleted.update(url=url)
+ return _Resp({'success': True})
+ return _Resp({'success': False})
+ monkeypatch.setattr(cf.requests, 'request', stub)
+ res = CloudflareService.delete_rule(zone.id, 'transform', 'rs1', 'r1')
+ assert res['success'] is True
+ assert deleted['url'].endswith('/rulesets/rs1/rules/r1')
+
+
+# ── Activity ledger ───────────────────────────────────────────────────────────
+
+def test_activity_records_success_and_lists(app, monkeypatch):
+ from app.services.dns import cloudflare as cf
+ from app.services import cloudflare_ops_bridge as _cfb
+ CloudflareService = _cfb.cloudflare_service()
+ zone = _make_cf_zone()
+ monkeypatch.setattr(cf.requests, 'request',
+ lambda *a, **k: _Resp({'success': True,
+ 'result': {'id': 'ssl', 'value': 'strict'}}))
+ CloudflareService.update_setting(zone.id, 'ssl', 'strict')
+ res = CloudflareService.list_activity(zone.id)
+ assert res['success'] is True
+ assert any(c['product'] == 'settings' and c['action'] == 'update'
+ for c in res['changes'])
+
+
+def test_activity_records_failure_row(app, monkeypatch):
+ from app.services.dns import cloudflare as cf
+ from app.services import cloudflare_ops_bridge as _cfb
+ CloudflareService = _cfb.cloudflare_service()
+ zone = _make_cf_zone()
+ monkeypatch.setattr(cf.requests, 'request',
+ lambda *a, **k: _Resp({'success': False,
+ 'errors': [{'message': 'nope'}]}))
+ CloudflareService.update_setting(zone.id, 'ssl', 'strict')
+ res = CloudflareService.list_activity(zone.id, result='error')
+ assert any(c['result'] == 'error' and c['product'] == 'settings'
+ for c in res['changes'])
+
+
+def test_activity_filters_by_product(app, monkeypatch):
+ from app.services.dns import cloudflare as cf
+ from app.services import cloudflare_ops_bridge as _cfb
+ CloudflareService = _cfb.cloudflare_service()
+ zone = _make_cf_zone()
+ monkeypatch.setattr(cf.requests, 'request',
+ lambda *a, **k: _Resp({'success': True, 'result': {}}))
+ CloudflareService.update_setting(zone.id, 'ssl', 'strict')
+ CloudflareService.set_dnssec(zone.id, True)
+ res = CloudflareService.list_activity(zone.id, product='dnssec')
+ assert res['changes'] and all(c['product'] == 'dnssec' for c in res['changes'])
+
+
+# ── Scope diagnostics ─────────────────────────────────────────────────────────
+
+def test_scope_check_classifies_per_product(app, monkeypatch):
+ from app.services.dns import cloudflare as cf
+ from app.services import cloudflare_ops_bridge as _cfb
+ CloudflareService = _cfb.cloudflare_service()
+ zone = _make_cf_zone()
+
+ def req(method, url, headers=None, json=None, params=None, timeout=None):
+ # account resolution
+ if url.endswith('/zones/zoneABC'):
+ return _Resp({'success': True, 'result': {'account': {'id': 'acct1'}}})
+ if url.endswith('/zones/zoneABC/settings'):
+ return _Resp({'success': True, 'result': []})
+ if url.endswith('/zones/zoneABC/dnssec'):
+ return _Resp({'success': False, 'errors': [{'message': 'permission denied'}]})
+ if url.endswith('/zones/zoneABC/rulesets'):
+ return _Resp({'success': True, 'result': []})
+ if url.endswith('/certificates'):
+ return _Resp({'success': True, 'result': []})
+ if url.endswith('/accounts/acct1/workers/scripts'):
+ return _Resp({'success': True, 'result': []})
+ if url.endswith('/accounts/acct1/cfd_tunnel'):
+ return _Resp({'success': False, 'errors': [{'message': 'insufficient scope'}]})
+ if url.endswith('/accounts/acct1/r2/buckets'):
+ return _Resp({'success': True, 'result': {'buckets': []}})
+ return _Resp({'success': False, 'errors': [{'message': 'boom'}]})
+
+ def get(url, headers=None, params=None, timeout=None):
+ # list_records (dns probe) uses requests.get
+ return _Resp({'success': True, 'result': []})
+ monkeypatch.setattr(cf.requests, 'request', req)
+ monkeypatch.setattr(cf.requests, 'get', get)
+
+ res = CloudflareService.scope_check(zone.id)
+ p = res['products']
+ assert p['settings'] == 'ok'
+ assert p['dns'] == 'ok'
+ assert p['dnssec'] == 'missing_scope'
+ assert p['waf'] == 'ok'
+ assert p['tunnels'] == 'missing_scope'
+ assert p['storage'] == 'ok'
+
+
+def test_scope_check_account_unresolved_marks_missing(app, monkeypatch):
+ from app.services.dns import cloudflare as cf
+ from app.services import cloudflare_ops_bridge as _cfb
+ CloudflareService = _cfb.cloudflare_service()
+ zone = _make_cf_zone()
+
+ def req(method, url, headers=None, json=None, params=None, timeout=None):
+ if url.endswith('/zones/zoneABC'):
+ return _Resp({'success': False, 'errors': [{'message': 'no access'}]})
+ if url.endswith('/zones/zoneABC/settings'):
+ return _Resp({'success': True, 'result': []})
+ return _Resp({'success': True, 'result': []})
+
+ monkeypatch.setattr(cf.requests, 'request', req)
+ monkeypatch.setattr(cf.requests, 'get', lambda *a, **k: _Resp({'success': True, 'result': []}))
+ res = CloudflareService.scope_check(zone.id)
+ p = res['products']
+ assert p['workers'] == 'missing_scope'
+ assert p['tunnels'] == 'missing_scope'
+ assert p['storage'] == 'missing_scope'
diff --git a/builtin-extensions/serverkit-cloudflare-ops/backend/cloudflare.py b/builtin-extensions/serverkit-cloudflare-ops/backend/cloudflare.py
index 225c172b..b2a579e4 100644
--- a/builtin-extensions/serverkit-cloudflare-ops/backend/cloudflare.py
+++ b/builtin-extensions/serverkit-cloudflare-ops/backend/cloudflare.py
@@ -410,3 +410,173 @@ def delete_d1_database(zone_id, database_id):
except CloudflareError as e:
return jsonify({'error': str(e)}), 400
return _service_response(res)
+
+
+# ── DNSSEC ────────────────────────────────────────────────────────────────────
+
+@cloudflare_bp.route('/zones/<int:zone_id>/dnssec', methods=['GET'])
+@jwt_required()
+def get_dnssec(zone_id):
+ try:
+ res = CloudflareService.get_dnssec(zone_id)
+ except CloudflareError as e:
+ return jsonify({'error': str(e)}), 400
+ return _service_response(res)
+
+
+@cloudflare_bp.route('/zones/<int:zone_id>/dnssec', methods=['PATCH'])
+@jwt_required()
+def set_dnssec(zone_id):
+ if not _require_admin():
+ return jsonify({'error': 'Admin access required'}), 403
+ data = request.get_json(silent=True) or {}
+ if 'enabled' not in data:
+ return jsonify({'error': 'An "enabled" boolean is required'}), 400
+ try:
+ res = CloudflareService.set_dnssec(zone_id, bool(data['enabled']))
+ except CloudflareError as e:
+ return jsonify({'error': str(e)}), 400
+ return _service_response(res)
+
+
+# ── Origin CA certificates ─────────────────────────────────────────────────────
+
+@cloudflare_bp.route('/zones/<int:zone_id>/origin-certificates', methods=['GET'])
+@jwt_required()
+def list_origin_certificates(zone_id):
+ try:
+ res = CloudflareService.list_origin_certificates(zone_id)
+ except CloudflareError as e:
+ return jsonify({'error': str(e)}), 400
+ return _service_response(res)
+
+
+@cloudflare_bp.route('/zones/<int:zone_id>/origin-certificates', methods=['POST'])
+@jwt_required()
+def issue_origin_certificate(zone_id):
+ if not _require_admin():
+ return jsonify({'error': 'Admin access required'}), 403
+ data = request.get_json(silent=True) or {}
+ try:
+ res = CloudflareService.issue_origin_certificate(
+ zone_id,
+ hostnames=data.get('hostnames'),
+ validity_days=int(data.get('validity_days', 5475)),
+ install=bool(data.get('install', True)))
+ except CloudflareError as e:
+ return jsonify({'error': str(e)}), 400
+ except (TypeError, ValueError):
+ return jsonify({'error': 'validity_days must be a number'}), 400
+ return _service_response(res)
+
+
+@cloudflare_bp.route('/zones/<int:zone_id>/origin-certificates/<certificate_id>',
+ methods=['DELETE'])
+@jwt_required()
+def revoke_origin_certificate(zone_id, certificate_id):
+ if not _require_admin():
+ return jsonify({'error': 'Admin access required'}), 403
+ try:
+ res = CloudflareService.revoke_origin_certificate(zone_id, certificate_id)
+ except CloudflareError as e:
+ return jsonify({'error': str(e)}), 400
+ return _service_response(res)
+
+
+# ── Redirect + Transform rules ─────────────────────────────────────────────────
+
+@cloudflare_bp.route('/zones/<int:zone_id>/rules/<slug>', methods=['GET'])
+@jwt_required()
+def list_rules(zone_id, slug):
+ try:
+ res = CloudflareService.list_rules(zone_id, slug)
+ except CloudflareError as e:
+ return jsonify({'error': str(e)}), 400
+ return _service_response(res)
+
+
+@cloudflare_bp.route('/zones/<int:zone_id>/rules/<slug>', methods=['POST'])
+@jwt_required()
+def add_rule(zone_id, slug):
+ if not _require_admin():
+ return jsonify({'error': 'Admin access required'}), 403
+ data = request.get_json(silent=True) or {}
+ try:
+ res = CloudflareService.add_rule(
+ zone_id, slug,
+ description=data.get('description'),
+ expression=data.get('expression'),
+ action=data.get('action'),
+ action_parameters=data.get('action_parameters'),
+ enabled=data.get('enabled', True))
+ except CloudflareError as e:
+ return jsonify({'error': str(e)}), 400
+ return _service_response(res)
+
+
+@cloudflare_bp.route('/zones/<int:zone_id>/rules/<slug>/presets/<preset_key>', methods=['POST'])
+@jwt_required()
+def apply_rule_preset(zone_id, slug, preset_key):
+ if not _require_admin():
+ return jsonify({'error': 'Admin access required'}), 403
+ data = request.get_json(silent=True) or {}
+ try:
+ res = CloudflareService.apply_rule_preset(zone_id, slug, preset_key, data.get('params') or {})
+ except CloudflareError as e:
+ return jsonify({'error': str(e)}), 400
+ return _service_response(res)
+
+
+@cloudflare_bp.route('/zones/<int:zone_id>/rules/<slug>/rulesets/<ruleset_id>/rules/<rule_id>',
+ methods=['PATCH'])
+@jwt_required()
+def update_rule(zone_id, slug, ruleset_id, rule_id):
+ if not _require_admin():
+ return jsonify({'error': 'Admin access required'}), 403
+ data = request.get_json(silent=True) or {}
+ try:
+ res = CloudflareService.update_rule(zone_id, slug, ruleset_id, rule_id, data)
+ except CloudflareError as e:
+ return jsonify({'error': str(e)}), 400
+ return _service_response(res)
+
+
+@cloudflare_bp.route('/zones/<int:zone_id>/rules/<slug>/rulesets/<ruleset_id>/rules/<rule_id>',
+ methods=['DELETE'])
+@jwt_required()
+def delete_rule(zone_id, slug, ruleset_id, rule_id):
+ if not _require_admin():
+ return jsonify({'error': 'Admin access required'}), 403
+ try:
+ res = CloudflareService.delete_rule(zone_id, slug, ruleset_id, rule_id)
+ except CloudflareError as e:
+ return jsonify({'error': str(e)}), 400
+ return _service_response(res)
+
+
+# ── Activity + scope diagnostics ───────────────────────────────────────────────
+
+@cloudflare_bp.route('/zones/<int:zone_id>/activity', methods=['GET'])
+@jwt_required()
+def list_activity(zone_id):
+ try:
+ res = CloudflareService.list_activity(
+ zone_id,
+ product=request.args.get('product'),
+ result=request.args.get('result'),
+ limit=min(int(request.args.get('limit', 100) or 100), 500))
+ except CloudflareError as e:
+ return jsonify({'error': str(e)}), 400
+ except (TypeError, ValueError):
+ return jsonify({'error': 'limit must be a number'}), 400
+ return _service_response(res)
+
+
+@cloudflare_bp.route('/zones/<int:zone_id>/scope-check', methods=['GET'])
+@jwt_required()
+def scope_check(zone_id):
+ try:
+ res = CloudflareService.scope_check(zone_id)
+ except CloudflareError as e:
+ return jsonify({'error': str(e)}), 400
+ return _service_response(res)
diff --git a/builtin-extensions/serverkit-cloudflare-ops/backend/cloudflare_service.py b/builtin-extensions/serverkit-cloudflare-ops/backend/cloudflare_service.py
index 13e0c59e..a397b11c 100644
--- a/builtin-extensions/serverkit-cloudflare-ops/backend/cloudflare_service.py
+++ b/builtin-extensions/serverkit-cloudflare-ops/backend/cloudflare_service.py
@@ -12,6 +12,7 @@ the ``/dns`` API uses); credential + Cloudflare zone id are resolved server-side
via :meth:`DNSZoneService._resolve_credential`, the canonical resolver.
"""
import logging
+import os
import re
logger = logging.getLogger(__name__)
@@ -178,6 +179,20 @@ class CloudflareService:
return {'id': zone.id, 'domain': zone.domain,
'provider_zone_id': zone.provider_zone_id}
+ @staticmethod
+ def _record(zone, product, action, target=None, result='ok', error=None):
+ """Best-effort append to the Cloudflare-ops activity ledger. Never raises —
+ an audit write must not break the operation it describes."""
+ try:
+ from app.services.cf_ops_change_service import CfOpsChangeService
+ CfOpsChangeService.record(
+ provider_zone_id=getattr(zone, 'provider_zone_id', None),
+ product=product, action=action, target=target,
+ result=result, error=error,
+ config_id=getattr(zone, 'dns_provider_config_id', None))
+ except Exception: # pragma: no cover - ledger writes are best-effort
+ pass
+
@classmethod
def get_settings(cls, zone_id):
"""Live zone settings, indexed by id, plus the UI grouping metadata."""
@@ -202,7 +217,9 @@ class CloudflareService:
zone, client = cls._zone_and_client(zone_id)
res = client.update_zone_setting(zone.provider_zone_id, setting_id, value)
if not res.get('success'):
+ cls._record(zone, 'settings', 'update', setting_id, 'error', res.get('error'))
return {'success': False, 'error': res.get('error', 'Update failed')}
+ cls._record(zone, 'settings', 'update', setting_id)
return {'success': True, 'setting': res.get('result')}
@classmethod
@@ -217,6 +234,9 @@ class CloudflareService:
'success': bool(res.get('success')),
'error': None if res.get('success') else res.get('error')})
applied = sum(1 for r in results if r['success'])
+ cls._record(zone, 'settings', 'apply-preset', 'recommended',
+ 'ok' if applied else 'error',
+ None if applied else 'No settings applied')
return {'success': applied > 0, 'applied': applied,
'total': len(results), 'results': results}
@@ -249,8 +269,11 @@ class CloudflareService:
'provide files, hosts, prefixes, or tags')
res = client.purge_cache(zone.provider_zone_id, payload)
+ target = 'everything' if everything else 'files'
if not res.get('success'):
+ cls._record(zone, 'cache', 'purge', target, 'error', res.get('error'))
return {'success': False, 'error': res.get('error', 'Cache purge failed')}
+ cls._record(zone, 'cache', 'purge', target)
return {'success': True, 'purged': payload}
# ── WAF custom rules ─────────────────────────────────────────────────────
@@ -333,15 +356,16 @@ class CloudflareService:
raise CloudflareError(f'Unknown WAF preset: {key}')
@classmethod
- def _find_custom_ruleset(cls, client, provider_zone_id):
+ def _find_custom_ruleset(cls, client, provider_zone_id, phase=None):
"""Return ``(ruleset_dict, listing_error)``. ``ruleset_dict`` is the zone's
custom-firewall entry-point ruleset or ``None`` when it doesn't exist yet;
``listing_error`` is set only when the list call itself failed (auth/scope)."""
+ phase = phase or cls.WAF_PHASE
listing = client.list_rulesets(provider_zone_id)
if not listing.get('success'):
return None, listing.get('error', 'Failed to list rulesets')
custom = next((rs for rs in (listing.get('result') or [])
- if rs.get('phase') == cls.WAF_PHASE and rs.get('kind') == 'zone'), None)
+ if rs.get('phase') == phase and rs.get('kind') == 'zone'), None)
return custom, None
@staticmethod
@@ -388,7 +412,9 @@ class CloudflareService:
else:
res = client.create_phase_ruleset(zone.provider_zone_id, cls.WAF_PHASE, [rule])
if not res.get('success'):
+ cls._record(zone, 'waf', 'add-rule', rule['description'], 'error', res.get('error'))
return {'success': False, 'error': res.get('error', 'Failed to add rule')}
+ cls._record(zone, 'waf', 'add-rule', rule['description'])
return {'success': True, 'result': res.get('result')}
@classmethod
@@ -412,7 +438,9 @@ class CloudflareService:
raise CloudflareError('No updatable fields provided')
res = client.update_ruleset_rule(zone.provider_zone_id, ruleset_id, rule_id, rule)
if not res.get('success'):
+ cls._record(zone, 'waf', 'update-rule', rule_id, 'error', res.get('error'))
return {'success': False, 'error': res.get('error', 'Failed to update rule')}
+ cls._record(zone, 'waf', 'update-rule', rule_id)
return {'success': True, 'result': res.get('result')}
@classmethod
@@ -420,7 +448,9 @@ class CloudflareService:
zone, client = cls._zone_and_client(zone_id)
res = client.delete_ruleset_rule(zone.provider_zone_id, ruleset_id, rule_id)
if not res.get('success'):
+ cls._record(zone, 'waf', 'delete-rule', rule_id, 'error', res.get('error'))
return {'success': False, 'error': res.get('error', 'Failed to delete rule')}
+ cls._record(zone, 'waf', 'delete-rule', rule_id)
return {'success': True}
# ── Workers (edge hosting) ───────────────────────────────────────────────
@@ -488,6 +518,7 @@ class CloudflareService:
account_id = cls._account_id(zone, client)
res = client.upload_worker_module(account_id, name, code, compat)
if not res.get('success'):
+ cls._record(zone, 'workers', 'deploy', name, 'error', res.get('error'))
return {'success': False, 'error': res.get('error', 'Worker upload failed')}
rec = CloudflareWorker.query.filter_by(account_id=account_id, name=name).first()
@@ -504,6 +535,7 @@ class CloudflareService:
rr = client.add_worker_route(zone.provider_zone_id, route_pattern.strip(), name)
route = {'success': bool(rr.get('success')),
'error': None if rr.get('success') else rr.get('error')}
+ cls._record(zone, 'workers', 'deploy', name)
return {'success': True, 'worker': rec.to_dict(), 'route': route}
@classmethod
@@ -514,11 +546,13 @@ class CloudflareService:
account_id = cls._account_id(zone, client)
res = client.delete_worker_script(account_id, name)
if not res.get('success'):
+ cls._record(zone, 'workers', 'delete', name, 'error', res.get('error'))
return {'success': False, 'error': res.get('error', 'Failed to delete worker')}
rec = CloudflareWorker.query.filter_by(account_id=account_id, name=name).first()
if rec:
db.session.delete(rec)
db.session.commit()
+ cls._record(zone, 'workers', 'delete', name)
return {'success': True}
@classmethod
@@ -528,7 +562,9 @@ class CloudflareService:
zone, client = cls._zone_and_client(zone_id)
res = client.add_worker_route(zone.provider_zone_id, pattern.strip(), script.strip())
if not res.get('success'):
+ cls._record(zone, 'workers', 'add-route', pattern.strip(), 'error', res.get('error'))
return {'success': False, 'error': res.get('error', 'Failed to add route')}
+ cls._record(zone, 'workers', 'add-route', pattern.strip())
return {'success': True, 'result': res.get('result')}
@classmethod
@@ -536,7 +572,9 @@ class CloudflareService:
zone, client = cls._zone_and_client(zone_id)
res = client.delete_worker_route(zone.provider_zone_id, route_id)
if not res.get('success'):
+ cls._record(zone, 'workers', 'delete-route', route_id, 'error', res.get('error'))
return {'success': False, 'error': res.get('error', 'Failed to delete route')}
+ cls._record(zone, 'workers', 'delete-route', route_id)
return {'success': True}
# ── Tunnels (cloudflared) ────────────────────────────────────────────────
@@ -583,6 +621,7 @@ class CloudflareService:
account_id = cls._account_id(zone, client)
res = client.create_tunnel(account_id, name)
if not res.get('success'):
+ cls._record(zone, 'tunnels', 'create', name, 'error', res.get('error'))
return {'success': False, 'error': res.get('error', 'Failed to create tunnel')}
result = res.get('result') or {}
tunnel_id = result.get('id')
@@ -597,6 +636,7 @@ class CloudflareService:
token_encrypted=encrypt_secret(token) if token else None)
db.session.add(rec)
db.session.commit()
+ cls._record(zone, 'tunnels', 'create', name)
return {'success': True, 'tunnel': rec.to_dict(),
'token': token, 'install': cls._install_command(token)}
@@ -619,11 +659,13 @@ class CloudflareService:
account_id = cls._account_id(zone, client)
res = client.delete_tunnel(account_id, tunnel_id)
if not res.get('success'):
+ cls._record(zone, 'tunnels', 'delete', tunnel_id, 'error', res.get('error'))
return {'success': False, 'error': res.get('error', 'Failed to delete tunnel')}
rec = CloudflareTunnel.query.filter_by(account_id=account_id, tunnel_id=tunnel_id).first()
if rec:
db.session.delete(rec)
db.session.commit()
+ cls._record(zone, 'tunnels', 'delete', tunnel_id)
return {'success': True}
@classmethod
@@ -662,8 +704,10 @@ class CloudflareService:
res = client.put_tunnel_configuration(account_id, tunnel_id, config)
if not res.get('success'):
+ cls._record(zone, 'tunnels', 'add-hostname', hostname, 'error', res.get('error'))
return {'success': False, 'error': res.get('error', 'Failed to set tunnel route')}
dns = cls._ensure_tunnel_cname(zone, client, hostname, tunnel_id)
+ cls._record(zone, 'tunnels', 'add-hostname', hostname)
return {'success': True, 'dns': dns}
@classmethod
@@ -681,7 +725,9 @@ class CloudflareService:
config['ingress'] = ingress
res = client.put_tunnel_configuration(account_id, tunnel_id, config)
if not res.get('success'):
+ cls._record(zone, 'tunnels', 'remove-hostname', hostname, 'error', res.get('error'))
return {'success': False, 'error': res.get('error', 'Failed to remove tunnel route')}
+ cls._record(zone, 'tunnels', 'remove-hostname', hostname)
return {'success': True}
@staticmethod
@@ -753,7 +799,9 @@ class CloudflareService:
account_id = cls._account_id(zone, client)
res = client.create_r2_bucket(account_id, name)
if not res.get('success'):
+ cls._record(zone, 'storage', 'create-r2', name, 'error', res.get('error'))
return {'success': False, 'error': res.get('error', 'Failed to create bucket')}
+ cls._record(zone, 'storage', 'create-r2', name)
return {'success': True, 'bucket': name}
@classmethod
@@ -762,7 +810,9 @@ class CloudflareService:
account_id = cls._account_id(zone, client)
res = client.delete_r2_bucket(account_id, name)
if not res.get('success'):
+ cls._record(zone, 'storage', 'delete-r2', name, 'error', res.get('error'))
return {'success': False, 'error': res.get('error', 'Failed to delete bucket')}
+ cls._record(zone, 'storage', 'delete-r2', name)
return {'success': True}
@classmethod
@@ -774,7 +824,9 @@ class CloudflareService:
account_id = cls._account_id(zone, client)
res = client.create_kv_namespace(account_id, title)
if not res.get('success'):
+ cls._record(zone, 'storage', 'create-kv', title, 'error', res.get('error'))
return {'success': False, 'error': res.get('error', 'Failed to create namespace')}
+ cls._record(zone, 'storage', 'create-kv', title)
return {'success': True, 'namespace': res.get('result')}
@classmethod
@@ -783,7 +835,9 @@ class CloudflareService:
account_id = cls._account_id(zone, client)
res = client.delete_kv_namespace(account_id, namespace_id)
if not res.get('success'):
+ cls._record(zone, 'storage', 'delete-kv', namespace_id, 'error', res.get('error'))
return {'success': False, 'error': res.get('error', 'Failed to delete namespace')}
+ cls._record(zone, 'storage', 'delete-kv', namespace_id)
return {'success': True}
@classmethod
@@ -795,7 +849,9 @@ class CloudflareService:
account_id = cls._account_id(zone, client)
res = client.create_d1_database(account_id, name)
if not res.get('success'):
+ cls._record(zone, 'storage', 'create-d1', name, 'error', res.get('error'))
return {'success': False, 'error': res.get('error', 'Failed to create database')}
+ cls._record(zone, 'storage', 'create-d1', name)
return {'success': True, 'database': res.get('result')}
@classmethod
@@ -804,5 +860,473 @@ class CloudflareService:
account_id = cls._account_id(zone, client)
res = client.delete_d1_database(account_id, database_id)
if not res.get('success'):
+ cls._record(zone, 'storage', 'delete-d1', database_id, 'error', res.get('error'))
return {'success': False, 'error': res.get('error', 'Failed to delete database')}
+ cls._record(zone, 'storage', 'delete-d1', database_id)
+ return {'success': True}
+
+ # ── DNSSEC ────────────────────────────────────────────────────────────────
+ # Display-only: enabling DNSSEC returns the DS record the operator must place
+ # at their registrar. No registrar automation.
+
+ @staticmethod
+ def _normalize_dnssec(r):
+ """Flatten Cloudflare's DNSSEC ``result`` to the fields the DS card needs."""
+ r = r or {}
+ return {
+ 'status': r.get('status'), # active | pending | pending-disabled | disabled
+ 'ds': r.get('ds'),
+ 'digest': r.get('digest'),
+ 'digest_type': r.get('digest_type'),
+ 'digest_algorithm': r.get('digest_algorithm'),
+ 'algorithm': r.get('algorithm'),
+ 'key_tag': r.get('key_tag'),
+ 'key_type': r.get('key_type'),
+ 'public_key': r.get('public_key'),
+ 'flags': r.get('flags'),
+ }
+
+ @classmethod
+ def get_dnssec(cls, zone_id):
+ zone, client = cls._zone_and_client(zone_id)
+ res = client.get_dnssec(zone.provider_zone_id)
+ if not res.get('success'):
+ return {'success': False, 'error': res.get('error', 'Failed to load DNSSEC status')}
+ return {'success': True, 'zone': cls._zone_dict(zone),
+ 'dnssec': cls._normalize_dnssec(res.get('result'))}
+
+ @classmethod
+ def set_dnssec(cls, zone_id, enabled):
+ """Enable or disable DNSSEC. Returns the DS record payload on enable."""
+ zone, client = cls._zone_and_client(zone_id)
+ action = 'enable' if enabled else 'disable'
+ res = client.set_dnssec(zone.provider_zone_id, 'active' if enabled else 'disabled')
+ if not res.get('success'):
+ cls._record(zone, 'dnssec', action, zone.domain, 'error', res.get('error'))
+ return {'success': False, 'error': res.get('error', 'Failed to update DNSSEC')}
+ cls._record(zone, 'dnssec', action, zone.domain)
+ return {'success': True, 'dnssec': cls._normalize_dnssec(res.get('result'))}
+
+ # ── Origin CA certificates ────────────────────────────────────────────────
+ # Issue-and-install, honest about trust: Origin CA certs are valid ONLY behind
+ # the Cloudflare proxy. The CSR is generated panel-side; the private key never
+ # leaves the box (only the CSR is sent to Cloudflare). Install reuses the
+ # existing custom-cert seam (Linux-only). A credential lacking the Origin CA
+ # permission is surfaced as an actionable 400 (CloudflareError), never a 502.
+
+ # Cloudflare's accepted Origin CA validity windows, in days (7d … 15y).
+ ORIGIN_CA_VALIDITY_DAYS = [7, 30, 90, 365, 730, 1095, 5475]
+
+ # Substrings that mark a provider error as a credential/scope problem rather
+ # than a transient provider failure — surfaced as a scoped 400.
+ _SCOPE_ERROR_MARKERS = (
+ 'permission', 'not authorized', 'unauthorized', 'authentication',
+ 'not allowed', 'insufficient', 'invalid api', 'access denied',
+ 'forbidden', 'origin ca', 'service key', 'scope',
+ )
+
+ @classmethod
+ def _is_scope_error(cls, error):
+ e = (error or '').lower()
+ return any(m in e for m in cls._SCOPE_ERROR_MARKERS)
+
+ @staticmethod
+ def _origin_ca_service_key(zone):
+ """The optional account-level Origin CA service key stored (Fernet) on the
+ zone's DNS provider connection, or ``None`` (a suitably-scoped token also
+ authenticates the Origin CA endpoints)."""
+ try:
+ from app.models.email import DNSProviderConfig
+ from app.utils.crypto import decrypt_secret_safe
+ cfg_id = getattr(zone, 'dns_provider_config_id', None)
+ cfg = DNSProviderConfig.query.get(cfg_id) if cfg_id else None
+ if cfg and getattr(cfg, 'origin_ca_key', None):
+ return decrypt_secret_safe(cfg.origin_ca_key)
+ except Exception:
+ pass
+ return None
+
+ @staticmethod
+ def _generate_csr(hostnames):
+ """Generate an RSA private key + CSR for ``hostnames`` panel-side. Returns
+ ``(csr_pem, key_pem)``; the key is kept locally for install and never sent
+ to Cloudflare."""
+ from cryptography import x509
+ from cryptography.x509.oid import NameOID
+ from cryptography.hazmat.primitives import hashes, serialization
+ from cryptography.hazmat.primitives.asymmetric import rsa
+
+ key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
+ builder = x509.CertificateSigningRequestBuilder().subject_name(
+ x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, hostnames[0])]))
+ builder = builder.add_extension(
+ x509.SubjectAlternativeName([x509.DNSName(h) for h in hostnames]), critical=False)
+ csr = builder.sign(key, hashes.SHA256())
+ csr_pem = csr.public_bytes(serialization.Encoding.PEM).decode()
+ key_pem = key.private_bytes(
+ serialization.Encoding.PEM,
+ serialization.PrivateFormat.TraditionalOpenSSL,
+ serialization.NoEncryption()).decode()
+ return csr_pem, key_pem
+
+ @staticmethod
+ def _proxy_warnings(zone, client, hostnames):
+ """Best-effort: warn when a covered hostname isn't proxied (grey cloud) or
+ has no DNS record — an Origin CA cert is only valid behind the proxy."""
+ warnings = []
+ try:
+ rec = client.list_records(zone.provider_zone_id)
+ records = (rec.get('records') or []) if rec.get('success') else []
+ by_name = {}
+ for r in records:
+ by_name.setdefault((r.get('name') or '').lower().rstrip('.'), []).append(r)
+ for h in hostnames:
+ base = h[2:] if h.startswith('*.') else h
+ matches = by_name.get(base, [])
+ if not matches:
+ warnings.append(
+ f'{h}: no DNS record found — an Origin CA certificate is only '
+ 'valid when traffic is proxied through Cloudflare.')
+ elif not any(m.get('proxied') for m in matches):
+ warnings.append(
+ f'{h}: the DNS record is not proxied (grey cloud). This '
+ 'certificate only works when traffic goes through Cloudflare.')
+ except Exception:
+ pass
+ return warnings
+
+ @staticmethod
+ def _install_origin_cert(hostnames, cert_pem, key_pem):
+ """Install the issued cert + panel-generated key via the existing custom-cert
+ seam (writes PEMs to ``/etc/ssl/serverkit/<domain>/``, Linux-only)."""
+ try:
+ from app.services.advanced_ssl_service import AdvancedSSLService
+ install_domain = next((h for h in hostnames if not h.startswith('*.')), None)
+ if not install_domain:
+ install_domain = hostnames[0][2:] if hostnames[0].startswith('*.') else hostnames[0]
+ info = AdvancedSSLService.upload_custom_cert(install_domain, cert_pem, key_pem)
+ return {'success': True, **info}
+ except Exception as e:
+ return {'success': False, 'error': str(e)}
+
+ @classmethod
+ def issue_origin_certificate(cls, zone_id, hostnames, validity_days=5475, install=True):
+ """Issue an Origin CA certificate for ``hostnames`` and (optionally) install
+ it on the origin. The private key is generated panel-side and never sent to
+ Cloudflare."""
+ zone, client = cls._zone_and_client(zone_id)
+ hostnames = [h.strip().lower().rstrip('.') for h in (hostnames or []) if h and h.strip()]
+ if not hostnames:
+ raise CloudflareError('At least one hostname is required')
+ if validity_days not in cls.ORIGIN_CA_VALIDITY_DAYS:
+ raise CloudflareError(
+ 'Unsupported validity — choose one of: '
+ + ', '.join(str(v) for v in cls.ORIGIN_CA_VALIDITY_DAYS) + ' days')
+
+ csr_pem, key_pem = cls._generate_csr(hostnames)
+ res = client.create_origin_certificate(
+ csr=csr_pem, hostnames=hostnames, requested_validity=validity_days,
+ service_key=cls._origin_ca_service_key(zone))
+ if not res.get('success'):
+ err = res.get('error', 'Failed to issue Origin CA certificate')
+ cls._record(zone, 'origin_ca', 'issue', hostnames[0], 'error', err)
+ if cls._is_scope_error(err):
+ raise CloudflareError(
+ 'This Cloudflare credential lacks the Origin CA permission. Add the '
+ '"SSL and Certificates: Edit" scope to the token, or set an Origin CA '
+ f'key on the connection. ({err})')
+ return {'success': False, 'error': err}
+
+ result = res.get('result') or {}
+ cert_pem = result.get('certificate')
+ out = {
+ 'success': True,
+ 'certificate_id': result.get('id'),
+ 'certificate': cert_pem,
+ 'hostnames': hostnames,
+ 'expires_on': result.get('expires_on'),
+ 'proxy_only': True,
+ 'warnings': cls._proxy_warnings(zone, client, hostnames),
+ }
+ if install and cert_pem and os.name != 'nt':
+ out['install'] = cls._install_origin_cert(hostnames, cert_pem, key_pem)
+ cls._record(zone, 'origin_ca', 'issue', hostnames[0])
+ return out
+
+ @classmethod
+ def list_origin_certificates(cls, zone_id):
+ zone, client = cls._zone_and_client(zone_id)
+ res = client.list_origin_certificates(
+ zone.provider_zone_id, service_key=cls._origin_ca_service_key(zone))
+ if not res.get('success'):
+ err = res.get('error', 'Failed to list Origin CA certificates')
+ if cls._is_scope_error(err):
+ raise CloudflareError(
+ 'This Cloudflare credential lacks the Origin CA permission. Add the '
+ f'"SSL and Certificates: Read" scope to the token. ({err})')
+ return {'success': False, 'error': err}
+ certs = [{
+ 'id': c.get('id'),
+ 'hostnames': c.get('hostnames'),
+ 'expires_on': c.get('expires_on'),
+ 'requested_validity': c.get('requested_validity'),
+ 'certificate': c.get('certificate'),
+ } for c in (res.get('result') or [])]
+ return {'success': True, 'certificates': certs, 'proxy_only': True}
+
+ @classmethod
+ def revoke_origin_certificate(cls, zone_id, certificate_id):
+ zone, client = cls._zone_and_client(zone_id)
+ res = client.revoke_origin_certificate(
+ certificate_id, service_key=cls._origin_ca_service_key(zone))
+ if not res.get('success'):
+ err = res.get('error', 'Failed to revoke certificate')
+ cls._record(zone, 'origin_ca', 'revoke', certificate_id, 'error', err)
+ if cls._is_scope_error(err):
+ raise CloudflareError(
+ 'This Cloudflare credential lacks the Origin CA permission. '
+ f'({err})')
+ return {'success': False, 'error': err}
+ cls._record(zone, 'origin_ca', 'revoke', certificate_id)
+ return {'success': True, 'certificate_id': certificate_id}
+
+ # ── Redirect + Transform rules ────────────────────────────────────────────
+ # The same ruleset machinery as WAF, in different phases, with per-phase action
+ # allowlists + the shared expression-injection guard.
+
+ RULE_PHASES = {
+ 'redirect': 'http_request_dynamic_redirect',
+ 'transform': 'http_request_transform',
+ }
+ RULE_ACTIONS = {
+ 'redirect': {'redirect'},
+ 'transform': {'rewrite'},
+ }
+
+ # Preset library per rule type (plan §Phase 3). Presets take no free-form user
+ # input that lands in an expression — the only interpolated value is the zone's
+ # own (validated) domain — so there is no injection surface.
+ RULE_PRESETS = {
+ 'redirect': [
+ {'key': 'force_www', 'label': 'Redirect apex to www',
+ 'description': 'Send https://example.com/* to https://www.example.com/*.',
+ 'params': []},
+ {'key': 'www_to_apex', 'label': 'Redirect www to apex',
+ 'description': 'Send https://www.example.com/* to https://example.com/*.',
+ 'params': []},
+ {'key': 'strip_trailing_slash', 'label': 'Remove trailing slash',
+ 'description': 'Redirect /path/ to /path (except the root).',
+ 'params': []},
+ ],
+ 'transform': [
+ {'key': 'strip_tracking', 'label': 'Strip tracking parameters',
+ 'description': 'Remove utm_*, gclid and fbclid query parameters.',
+ 'params': []},
+ ],
+ }
+
+ _SAFE_HOST_RE = re.compile(r'^[a-z0-9.-]+$')
+
+ @classmethod
+ def _resolve_rule_phase(cls, slug):
+ phase = cls.RULE_PHASES.get(slug)
+ if not phase:
+ raise CloudflareError(
+ f'Unknown rule type "{slug}". Use one of: '
+ + ', '.join(sorted(cls.RULE_PHASES)))
+ return phase
+
+ @classmethod
+ def _validate_rule_action(cls, slug, action):
+ allowed = cls.RULE_ACTIONS.get(slug, set())
+ if action not in allowed:
+ raise CloudflareError(
+ f'Unsupported action "{action}" for {slug} rules. '
+ f'Use one of: {", ".join(sorted(allowed))}')
+
+ @staticmethod
+ def _full_rule_dict(r):
+ return {'id': r.get('id'), 'description': r.get('description'),
+ 'expression': r.get('expression'), 'action': r.get('action'),
+ 'action_parameters': r.get('action_parameters'),
+ 'enabled': r.get('enabled', True), 'ref': r.get('ref')}
+
+ @classmethod
+ def list_rules(cls, zone_id, slug):
+ """Rules for a phase (redirect|transform), plus the preset catalog. A zone
+ with no ruleset in that phase yet returns an empty list (not an error)."""
+ phase = cls._resolve_rule_phase(slug)
+ zone, client = cls._zone_and_client(zone_id)
+ custom, err = cls._find_custom_ruleset(client, zone.provider_zone_id, phase)
+ if err:
+ return {'success': False, 'error': err}
+ presets = cls.RULE_PRESETS.get(slug, [])
+ if not custom:
+ return {'success': True, 'ruleset_id': None, 'rules': [], 'presets': presets}
+ detail = client.get_ruleset(zone.provider_zone_id, custom['id'])
+ if not detail.get('success'):
+ return {'success': False, 'error': detail.get('error', 'Failed to load ruleset')}
+ result = detail.get('result') or {}
+ rules = [cls._full_rule_dict(r) for r in (result.get('rules') or [])]
+ return {'success': True, 'ruleset_id': result.get('id'),
+ 'rules': rules, 'presets': presets}
+
+ @classmethod
+ def add_rule(cls, zone_id, slug, *, description, expression, action,
+ action_parameters=None, enabled=True):
+ """Append a rule to the phase's entry-point ruleset, creating it on first use."""
+ phase = cls._resolve_rule_phase(slug)
+ cls._validate_rule_action(slug, action)
+ if not (expression or '').strip():
+ raise CloudflareError('A rule expression is required')
+ zone, client = cls._zone_and_client(zone_id)
+ rule = {'description': description or 'ServerKit rule', 'expression': expression,
+ 'action': action, 'enabled': bool(enabled)}
+ if action_parameters:
+ rule['action_parameters'] = action_parameters
+
+ custom, err = cls._find_custom_ruleset(client, zone.provider_zone_id, phase)
+ if err:
+ return {'success': False, 'error': err}
+ if custom:
+ res = client.add_ruleset_rule(zone.provider_zone_id, custom['id'], rule)
+ else:
+ res = client.create_phase_ruleset(zone.provider_zone_id, phase, [rule])
+ if not res.get('success'):
+ cls._record(zone, slug, 'add-rule', rule['description'], 'error', res.get('error'))
+ return {'success': False, 'error': res.get('error', 'Failed to add rule')}
+ cls._record(zone, slug, 'add-rule', rule['description'])
+ return {'success': True, 'result': res.get('result')}
+
+ @classmethod
+ def _build_rule_preset(cls, slug, key, domain, params):
+ """Turn a preset key + the zone domain into a concrete rule dict. The domain
+ is validated before interpolation so a preset can't inject expression syntax."""
+ domain = (domain or '').strip().lower().rstrip('.')
+ if not cls._SAFE_HOST_RE.match(domain or ''):
+ raise CloudflareError('The zone domain is not a valid hostname')
+ if slug == 'redirect':
+ if key == 'force_www':
+ return {'description': 'ServerKit: redirect apex to www',
+ 'expression': f'(http.host eq "{domain}")',
+ 'action': 'redirect',
+ 'action_parameters': {'from_value': {
+ 'status_code': 301,
+ 'target_url': {'expression':
+ f'concat("https://www.{domain}", http.request.uri.path)'},
+ 'preserve_query_string': True}}}
+ if key == 'www_to_apex':
+ return {'description': 'ServerKit: redirect www to apex',
+ 'expression': f'(http.host eq "www.{domain}")',
+ 'action': 'redirect',
+ 'action_parameters': {'from_value': {
+ 'status_code': 301,
+ 'target_url': {'expression':
+ f'concat("https://{domain}", http.request.uri.path)'},
+ 'preserve_query_string': True}}}
+ if key == 'strip_trailing_slash':
+ return {'description': 'ServerKit: remove trailing slash',
+ 'expression': ('(ends_with(http.request.uri.path, "/") and '
+ 'http.request.uri.path ne "/")'),
+ 'action': 'redirect',
+ 'action_parameters': {'from_value': {
+ 'status_code': 301,
+ 'target_url': {'expression':
+ 'concat("https://", http.host, '
+ 'substring(http.request.uri.path, 0, -1))'},
+ 'preserve_query_string': True}}}
+ elif slug == 'transform':
+ if key == 'strip_tracking':
+ return {'description': 'ServerKit: strip tracking parameters',
+ 'expression': '(http.request.uri.query ne "")',
+ 'action': 'rewrite',
+ 'action_parameters': {'uri': {'query': {'expression':
+ 'regex_replace(http.request.uri.query, '
+ '"(^|&)(utm_[a-z]+|gclid|fbclid)=[^&]*", "")'}}}}
+ raise CloudflareError(f'Unknown {slug} preset: {key}')
+
+ @classmethod
+ def apply_rule_preset(cls, zone_id, slug, preset_key, params=None):
+ cls._resolve_rule_phase(slug) # validates slug up front
+ zone, _ = cls._zone_and_client(zone_id)
+ rule = cls._build_rule_preset(slug, preset_key, zone.domain, params or {})
+ return cls.add_rule(zone_id, slug, description=rule['description'],
+ expression=rule['expression'], action=rule['action'],
+ action_parameters=rule.get('action_parameters'))
+
+ @classmethod
+ def update_rule(cls, zone_id, slug, ruleset_id, rule_id, fields):
+ cls._resolve_rule_phase(slug)
+ zone, client = cls._zone_and_client(zone_id)
+ rule = {}
+ for k in ('description', 'expression', 'action', 'enabled', 'action_parameters'):
+ if k in fields:
+ rule[k] = fields[k]
+ if 'action' in rule:
+ cls._validate_rule_action(slug, rule['action'])
+ if not rule:
+ raise CloudflareError('No updatable fields provided')
+ res = client.update_ruleset_rule(zone.provider_zone_id, ruleset_id, rule_id, rule)
+ if not res.get('success'):
+ cls._record(zone, slug, 'update-rule', rule_id, 'error', res.get('error'))
+ return {'success': False, 'error': res.get('error', 'Failed to update rule')}
+ cls._record(zone, slug, 'update-rule', rule_id)
+ return {'success': True, 'result': res.get('result')}
+
+ @classmethod
+ def delete_rule(cls, zone_id, slug, ruleset_id, rule_id):
+ cls._resolve_rule_phase(slug)
+ zone, client = cls._zone_and_client(zone_id)
+ res = client.delete_ruleset_rule(zone.provider_zone_id, ruleset_id, rule_id)
+ if not res.get('success'):
+ cls._record(zone, slug, 'delete-rule', rule_id, 'error', res.get('error'))
+ return {'success': False, 'error': res.get('error', 'Failed to delete rule')}
+ cls._record(zone, slug, 'delete-rule', rule_id)
return {'success': True}
+
+ # ── Activity (local ops ledger) ───────────────────────────────────────────
+
+ @classmethod
+ def list_activity(cls, zone_id, product=None, result=None, limit=100):
+ """The per-zone Cloudflare-ops change ledger, newest first."""
+ zone, _ = cls._zone_and_client(zone_id)
+ from app.services.cf_ops_change_service import CfOpsChangeService
+ rows = CfOpsChangeService.list(
+ provider_zone_id=zone.provider_zone_id,
+ product=product, result=result, limit=limit)
+ return {'success': True, 'zone': cls._zone_dict(zone),
+ 'changes': [r.to_dict() for r in rows]}
+
+ # ── Token scope diagnosability ────────────────────────────────────────────
+
+ @classmethod
+ def scope_check(cls, zone_id):
+ """Probe each product with a cheap read and report
+ ``{product: ok|missing_scope|error}`` — round 2 is exactly where DNS-only
+ tokens start failing."""
+ zone, client = cls._zone_and_client(zone_id)
+
+ def classify(res):
+ if res.get('success'):
+ return 'ok'
+ return 'missing_scope' if cls._is_scope_error(res.get('error')) else 'error'
+
+ products = {
+ 'dns': classify(client.list_records(zone.provider_zone_id)),
+ 'settings': classify(client.get_zone_settings(zone.provider_zone_id)),
+ 'dnssec': classify(client.get_dnssec(zone.provider_zone_id)),
+ 'waf': classify(client.list_rulesets(zone.provider_zone_id)),
+ 'origin_ca': classify(client.list_origin_certificates(
+ zone.provider_zone_id, service_key=cls._origin_ca_service_key(zone))),
+ }
+ try:
+ account_id = cls._account_id(zone, client)
+ except CloudflareError:
+ account_id = None
+ if account_id:
+ products['workers'] = classify(client.list_worker_scripts(account_id))
+ products['tunnels'] = classify(client.list_tunnels(account_id))
+ products['storage'] = classify(client.list_r2_buckets(account_id))
+ else:
+ products['workers'] = products['tunnels'] = products['storage'] = 'missing_scope'
+ return {'success': True, 'zone': cls._zone_dict(zone), 'products': products}