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): WAF custom rules (Phase 3)

Juan Denis5ec5be4b31ba
diff --git a/backend/app/api/cloudflare.py b/backend/app/api/cloudflare.py
index 5c122d19..e3e6828a 100644
--- a/backend/app/api/cloudflare.py
+++ b/backend/app/api/cloudflare.py
@@ -98,3 +98,73 @@ def purge_cache(zone_id):
except CloudflareError as e:
return jsonify({'error': str(e)}), 400
return _service_response(res)
+
+
+# ── WAF custom rules ─────────────────────────────────────────────────────────
+
+@cloudflare_bp.route('/zones/<int:zone_id>/waf/rules', methods=['GET'])
+@jwt_required()
+def list_waf_rules(zone_id):
+ try:
+ res = CloudflareService.list_waf_rules(zone_id)
+ except CloudflareError as e:
+ return jsonify({'error': str(e)}), 400
+ return _service_response(res)
+
+
+@cloudflare_bp.route('/zones/<int:zone_id>/waf/rules', methods=['POST'])
+@jwt_required()
+def add_waf_rule(zone_id):
+ if not _require_admin():
+ return jsonify({'error': 'Admin access required'}), 403
+ data = request.get_json(silent=True) or {}
+ try:
+ res = CloudflareService.add_waf_rule(
+ zone_id,
+ description=data.get('description'),
+ expression=data.get('expression'),
+ action=data.get('action'),
+ 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>/waf/presets/<preset_key>', methods=['POST'])
+@jwt_required()
+def apply_waf_preset(zone_id, preset_key):
+ if not _require_admin():
+ return jsonify({'error': 'Admin access required'}), 403
+ data = request.get_json(silent=True) or {}
+ try:
+ res = CloudflareService.apply_waf_preset(zone_id, 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>/waf/rulesets/<ruleset_id>/rules/<rule_id>',
+ methods=['PATCH'])
+@jwt_required()
+def update_waf_rule(zone_id, 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_waf_rule(zone_id, 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>/waf/rulesets/<ruleset_id>/rules/<rule_id>',
+ methods=['DELETE'])
+@jwt_required()
+def delete_waf_rule(zone_id, ruleset_id, rule_id):
+ if not _require_admin():
+ return jsonify({'error': 'Admin access required'}), 403
+ try:
+ res = CloudflareService.delete_waf_rule(zone_id, ruleset_id, rule_id)
+ except CloudflareError as e:
+ return jsonify({'error': str(e)}), 400
+ return _service_response(res)
diff --git a/backend/app/services/cloudflare_service.py b/backend/app/services/cloudflare_service.py
index 9d87ce41..8b7d1449 100644
--- a/backend/app/services/cloudflare_service.py
+++ b/backend/app/services/cloudflare_service.py
@@ -251,3 +251,173 @@ class CloudflareService:
if not res.get('success'):
return {'success': False, 'error': res.get('error', 'Cache purge failed')}
return {'success': True, 'purged': payload}
+
+ # ── WAF custom rules ─────────────────────────────────────────────────────
+
+ WAF_PHASE = 'http_request_firewall_custom'
+ # Actions ServerKit lets you set on a custom rule (a safe subset of
+ # Cloudflare's). Terminal actions only — no "skip", which can disable WAF.
+ WAF_ACTIONS = {'block', 'managed_challenge', 'js_challenge', 'challenge', 'log'}
+
+ # One-click rule templates (plan §Phase 3). ``params`` are collected from the
+ # admin and validated before being interpolated into a Cloudflare expression.
+ WAF_PRESETS = [
+ {
+ 'key': 'lock_wp_admin',
+ 'label': 'Lock WordPress admin to an IP',
+ 'description': 'Block /wp-admin and /wp-login.php for everyone except a '
+ 'trusted IP address (e.g. your office or home).',
+ 'action': 'block',
+ 'params': [{'key': 'ip', 'label': 'Allowed IP address',
+ 'placeholder': 'e.g. 203.0.113.7'}],
+ },
+ {
+ 'key': 'block_exploit_paths',
+ 'label': 'Block common exploit paths',
+ 'description': 'Block requests probing for /xmlrpc.php, dotfiles like '
+ '/.env and /.git, and exposed config files.',
+ 'action': 'block',
+ 'params': [],
+ },
+ {
+ 'key': 'challenge_bad_bots',
+ 'label': 'Challenge suspicious bots',
+ 'description': 'Show a managed challenge to traffic with a low bot score. '
+ 'Requires Cloudflare Bot Management on some plans.',
+ 'action': 'managed_challenge',
+ 'params': [],
+ },
+ ]
+
+ @classmethod
+ def _validate_action(cls, action):
+ if action not in cls.WAF_ACTIONS:
+ raise CloudflareError(
+ f'Unsupported action "{action}". Use one of: {", ".join(sorted(cls.WAF_ACTIONS))}')
+
+ @classmethod
+ def _build_preset_rule(cls, key, params):
+ """Turn a preset key + admin-supplied params into a concrete rule dict.
+ Validates any user input that lands inside a Cloudflare expression (the IP)
+ so a preset can't be used to inject expression syntax."""
+ import ipaddress
+ if key == 'lock_wp_admin':
+ ip = (params.get('ip') or '').strip()
+ try:
+ ipaddress.ip_address(ip)
+ except ValueError:
+ raise CloudflareError('A valid IP address is required for this rule')
+ return {
+ 'description': 'ServerKit: lock WordPress admin to a trusted IP',
+ 'expression': ('(http.request.uri.path contains "/wp-admin" or '
+ 'http.request.uri.path contains "/wp-login.php") '
+ f'and ip.src ne {ip}'),
+ 'action': 'block',
+ }
+ if key == 'block_exploit_paths':
+ return {
+ 'description': 'ServerKit: block common exploit paths',
+ 'expression': ('(http.request.uri.path contains "/xmlrpc.php") or '
+ '(http.request.uri.path contains "/.env") or '
+ '(http.request.uri.path contains "/.git/") or '
+ '(http.request.uri.path contains "/wp-config.php")'),
+ 'action': 'block',
+ }
+ if key == 'challenge_bad_bots':
+ return {
+ 'description': 'ServerKit: challenge suspicious bots',
+ 'expression': '(cf.bot_management.score lt 30)',
+ 'action': 'managed_challenge',
+ }
+ raise CloudflareError(f'Unknown WAF preset: {key}')
+
+ @classmethod
+ def _find_custom_ruleset(cls, client, provider_zone_id):
+ """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)."""
+ 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)
+ return custom, None
+
+ @staticmethod
+ def _rule_dict(r):
+ return {'id': r.get('id'), 'description': r.get('description'),
+ 'expression': r.get('expression'), 'action': r.get('action'),
+ 'enabled': r.get('enabled', True), 'ref': r.get('ref')}
+
+ @classmethod
+ def list_waf_rules(cls, zone_id):
+ """Custom firewall rules for the zone, plus the preset catalog. A zone with
+ no custom ruleset yet returns an empty list (not an error)."""
+ zone, client = cls._zone_and_client(zone_id)
+ custom, err = cls._find_custom_ruleset(client, zone.provider_zone_id)
+ if err:
+ return {'success': False, 'error': err}
+ if not custom:
+ return {'success': True, 'ruleset_id': None, 'rules': [],
+ 'presets': cls.WAF_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._rule_dict(r) for r in (result.get('rules') or [])]
+ return {'success': True, 'ruleset_id': result.get('id'),
+ 'rules': rules, 'presets': cls.WAF_PRESETS}
+
+ @classmethod
+ def add_waf_rule(cls, zone_id, *, description, expression, action, enabled=True):
+ """Append a custom firewall rule, creating the zone's custom ruleset on first
+ use. Returns the created rule's ruleset on success."""
+ cls._validate_action(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)}
+
+ custom, err = cls._find_custom_ruleset(client, zone.provider_zone_id)
+ 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, cls.WAF_PHASE, [rule])
+ if not res.get('success'):
+ return {'success': False, 'error': res.get('error', 'Failed to add rule')}
+ return {'success': True, 'result': res.get('result')}
+
+ @classmethod
+ def apply_waf_preset(cls, zone_id, preset_key, params=None):
+ rule = cls._build_preset_rule(preset_key, params or {})
+ return cls.add_waf_rule(zone_id, description=rule['description'],
+ expression=rule['expression'], action=rule['action'])
+
+ @classmethod
+ def update_waf_rule(cls, zone_id, ruleset_id, rule_id, fields):
+ """Patch a custom rule. Only known fields are forwarded; an ``action``, if
+ present, is validated."""
+ zone, client = cls._zone_and_client(zone_id)
+ rule = {}
+ for key in ('description', 'expression', 'action', 'enabled'):
+ if key in fields:
+ rule[key] = fields[key]
+ if 'action' in rule:
+ cls._validate_action(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'):
+ return {'success': False, 'error': res.get('error', 'Failed to update rule')}
+ return {'success': True, 'result': res.get('result')}
+
+ @classmethod
+ def delete_waf_rule(cls, zone_id, ruleset_id, rule_id):
+ 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'):
+ return {'success': False, 'error': res.get('error', 'Failed to delete rule')}
+ return {'success': True}
diff --git a/backend/app/services/dns/cloudflare.py b/backend/app/services/dns/cloudflare.py
index fc737588..dfd587d1 100644
--- a/backend/app/services/dns/cloudflare.py
+++ b/backend/app/services/dns/cloudflare.py
@@ -261,3 +261,35 @@ class CloudflareClient:
"""Purge the zone's Cloudflare cache. ``payload`` is one of
``{purge_everything: true}`` or ``{files|hosts|prefixes|tags: [...]}``."""
return self.request('POST', f'/zones/{zone_id}/purge_cache', json=payload)
+
+ # ── 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
+ # "no custom ruleset yet" apart from an auth error), then read/append rules
+ # by id; the first rule is created by PUTting the phase entry point.
+ def list_rulesets(self, zone_id: str) -> dict:
+ return self.request('GET', f'/zones/{zone_id}/rulesets')
+
+ def get_ruleset(self, zone_id: str, ruleset_id: str) -> dict:
+ return self.request('GET', f'/zones/{zone_id}/rulesets/{ruleset_id}')
+
+ def create_phase_ruleset(self, zone_id: str, phase: str, rules: list) -> dict:
+ """Create/replace a phase entry-point ruleset with ``rules`` (used to seed the
+ first custom rule when no ruleset exists yet)."""
+ return self.request(
+ 'PUT', f'/zones/{zone_id}/rulesets/phases/{phase}/entrypoint',
+ json={'rules': rules})
+
+ def add_ruleset_rule(self, zone_id: str, ruleset_id: str, rule: dict) -> dict:
+ return self.request('POST', f'/zones/{zone_id}/rulesets/{ruleset_id}/rules',
+ json=rule)
+
+ def update_ruleset_rule(self, zone_id: str, ruleset_id: str, rule_id: str,
+ rule: dict) -> dict:
+ return self.request('PATCH',
+ f'/zones/{zone_id}/rulesets/{ruleset_id}/rules/{rule_id}',
+ json=rule)
+
+ def delete_ruleset_rule(self, zone_id: str, ruleset_id: str, rule_id: str) -> dict:
+ return self.request('DELETE',
+ f'/zones/{zone_id}/rulesets/{ruleset_id}/rules/{rule_id}')
diff --git a/backend/tests/test_cloudflare_zone_settings.py b/backend/tests/test_cloudflare_zone_settings.py
index 79348e29..57d7ae23 100644
--- a/backend/tests/test_cloudflare_zone_settings.py
+++ b/backend/tests/test_cloudflare_zone_settings.py
@@ -220,3 +220,149 @@ def test_service_purge_surfaces_provider_error(app, monkeypatch):
'errors': [{'message': 'rate limited'}]}))
res = CloudflareService.purge_cache(zone.id, everything=True)
assert res['success'] is False and 'rate limited' in res['error']
+
+
+# ── WAF custom rules (Phase 3) ───────────────────────────────────────────────
+
+def test_waf_list_no_ruleset_is_empty(app, monkeypatch):
+ from app.services.dns import cloudflare as cf
+ from app.services.cloudflare_service import CloudflareService
+ 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_waf_rules(zone.id)
+ assert res['success'] is True
+ assert res['ruleset_id'] is None and res['rules'] == []
+ assert any(p['key'] == 'lock_wp_admin' for p in res['presets'])
+
+
+def test_waf_list_surfaces_listing_error(app, monkeypatch):
+ from app.services.dns import cloudflare as cf
+ from app.services.cloudflare_service import CloudflareService
+ zone = _make_cf_zone()
+ monkeypatch.setattr(cf.requests, 'request',
+ lambda *a, **k: _Resp({'success': False,
+ 'errors': [{'message': 'token lacks WAF scope'}]}))
+ res = CloudflareService.list_waf_rules(zone.id)
+ assert res['success'] is False and 'WAF scope' in res['error']
+
+
+def test_waf_list_with_ruleset(app, monkeypatch):
+ from app.services.dns import cloudflare as cf
+ from app.services.cloudflare_service import CloudflareService
+ zone = _make_cf_zone()
+
+ def stub(method, url, headers=None, json=None, params=None, timeout=None):
+ if url.endswith('/rulesets'):
+ return _Resp({'success': True, 'result': [
+ {'id': 'rs1', 'phase': 'http_request_firewall_custom', 'kind': 'zone'}]})
+ if url.endswith('/rulesets/rs1'):
+ return _Resp({'success': True, 'result': {'id': 'rs1', 'rules': [
+ {'id': 'r1', 'description': 'd', 'expression': 'e',
+ 'action': 'block', 'enabled': True}]}})
+ return _Resp({'success': False})
+ monkeypatch.setattr(cf.requests, 'request', stub)
+ res = CloudflareService.list_waf_rules(zone.id)
+ assert res['ruleset_id'] == 'rs1'
+ assert res['rules'][0]['id'] == 'r1' and res['rules'][0]['action'] == 'block'
+
+
+def test_waf_add_creates_phase_ruleset_when_absent(app, monkeypatch):
+ from app.services.dns import cloudflare as cf
+ from app.services.cloudflare_service import CloudflareService
+ 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_firewall_custom/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_waf_rule(zone.id, description='d',
+ expression='ip.src eq 1.1.1.1', action='block')
+ assert res['success'] is True
+ assert seen['json']['rules'][0]['action'] == 'block'
+
+
+def test_waf_add_posts_to_existing_ruleset(app, monkeypatch):
+ from app.services.dns import cloudflare as cf
+ from app.services.cloudflare_service import CloudflareService
+ 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_firewall_custom', 'kind': 'zone'}]})
+ if method == 'POST' and url.endswith('/rulesets/rs1/rules'):
+ seen.update(json=json, url=url)
+ return _Resp({'success': True, 'result': {'id': 'rs1'}})
+ return _Resp({'success': False})
+ monkeypatch.setattr(cf.requests, 'request', stub)
+ res = CloudflareService.add_waf_rule(zone.id, description='d',
+ expression='x', action='log')
+ assert res['success'] is True and seen['json']['action'] == 'log'
+
+
+def test_waf_add_rejects_bad_action(app):
+ from app.services.cloudflare_service import CloudflareService, CloudflareError
+ zone = _make_cf_zone()
+ with pytest.raises(CloudflareError):
+ CloudflareService.add_waf_rule(zone.id, description='d', expression='x', action='nuke')
+
+
+def test_waf_preset_lock_requires_valid_ip(app):
+ from app.services.cloudflare_service import CloudflareService, CloudflareError
+ zone = _make_cf_zone()
+ with pytest.raises(CloudflareError):
+ CloudflareService.apply_waf_preset(zone.id, 'lock_wp_admin', {'ip': 'not-an-ip'})
+
+
+def test_waf_preset_lock_builds_safe_expression(app, monkeypatch):
+ from app.services.dns import cloudflare as cf
+ from app.services.cloudflare_service import CloudflareService
+ 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_firewall_custom', '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_waf_preset(zone.id, 'lock_wp_admin', {'ip': '203.0.113.7'})
+ assert res['success'] is True
+ assert 'ip.src ne 203.0.113.7' in seen['json']['expression']
+ assert seen['json']['action'] == 'block'
+
+
+def test_waf_update_validates_action(app):
+ from app.services.cloudflare_service import CloudflareService, CloudflareError
+ zone = _make_cf_zone()
+ with pytest.raises(CloudflareError):
+ CloudflareService.update_waf_rule(zone.id, 'rs1', 'r1', {'action': 'nuke'})
+
+
+def test_waf_delete_calls_delete(app, monkeypatch):
+ from app.services.dns import cloudflare as cf
+ from app.services.cloudflare_service import CloudflareService
+ 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_waf_rule(zone.id, 'rs1', 'r1')
+ assert res['success'] is True
+ assert deleted['url'].endswith('/rulesets/rs1/rules/r1')
diff --git a/frontend/src/components/cloudflare/WafPanel.jsx b/frontend/src/components/cloudflare/WafPanel.jsx
new file mode 100644
index 00000000..85f17589
--- /dev/null
+++ b/frontend/src/components/cloudflare/WafPanel.jsx
@@ -0,0 +1,336 @@
+import { useState, useEffect, useCallback } from 'react';
+import { ShieldAlert } from 'lucide-react';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import { Textarea } from '@/components/ui/textarea';
+import { Switch } from '@/components/ui/switch';
+import { Badge } from '@/components/ui/badge';
+import { Select, SelectTrigger, SelectContent, SelectItem, SelectValue } from '@/components/ui/select';
+import EmptyState from '../EmptyState';
+import { useToast } from '../../contexts/ToastContext';
+import api from '../../services/api';
+
+const ACTION_OPTIONS = [
+ { value: 'block', label: 'Block' },
+ { value: 'managed_challenge', label: 'Managed Challenge' },
+ { value: 'js_challenge', label: 'JS Challenge' },
+ { value: 'log', label: 'Log' },
+];
+
+const EXPRESSION_PLACEHOLDER = '(http.request.uri.path contains "/admin")';
+
+export default function WafPanel({ zoneId, isAdmin }) {
+ const toast = useToast();
+
+ const [loading, setLoading] = useState(true);
+ const [error, setError] = useState(null);
+ const [rulesetId, setRulesetId] = useState(null);
+ const [rules, setRules] = useState([]);
+ const [presets, setPresets] = useState([]);
+
+ // Preset form state
+ const [selectedPreset, setSelectedPreset] = useState('');
+ const [presetParams, setPresetParams] = useState({});
+
+ // Custom rule form state
+ const [customDescription, setCustomDescription] = useState('');
+ const [customExpression, setCustomExpression] = useState('');
+ const [customAction, setCustomAction] = useState('block');
+
+ // Tracks any in-flight write so buttons can disable
+ const [applying, setApplying] = useState(false);
+
+ const loadRules = useCallback(async () => {
+ try {
+ const data = await api.getCloudflareWafRules(zoneId);
+ setRulesetId(data.ruleset_id ?? null);
+ setRules(data.rules || []);
+ setPresets(data.presets || []);
+ setError(null);
+ } catch (err) {
+ setError(err.message);
+ }
+ }, [zoneId]);
+
+ useEffect(() => {
+ let active = true;
+ setLoading(true);
+ (async () => {
+ try {
+ const data = await api.getCloudflareWafRules(zoneId);
+ if (!active) return;
+ setRulesetId(data.ruleset_id ?? null);
+ setRules(data.rules || []);
+ setPresets(data.presets || []);
+ setError(null);
+ } catch (err) {
+ if (active) setError(err.message);
+ } finally {
+ if (active) setLoading(false);
+ }
+ })();
+ return () => {
+ active = false;
+ };
+ }, [zoneId]);
+
+ const activePreset = presets.find((p) => p.key === selectedPreset) || null;
+ const presetParamDefs = activePreset?.params || [];
+
+ const handleSelectPreset = (key) => {
+ setSelectedPreset(key);
+ setPresetParams({});
+ };
+
+ const handleParamChange = (key, value) => {
+ setPresetParams((prev) => ({ ...prev, [key]: value }));
+ };
+
+ const handleApplyPreset = async () => {
+ if (!activePreset) return;
+ setApplying(true);
+ try {
+ await api.applyCloudflareWafPreset(zoneId, activePreset.key, presetParams);
+ await loadRules();
+ setPresetParams({});
+ toast.success(`Added quick rule: ${activePreset.label}`);
+ } catch (err) {
+ toast.error(err.message);
+ } finally {
+ setApplying(false);
+ }
+ };
+
+ const handleAddCustomRule = async () => {
+ setApplying(true);
+ try {
+ await api.addCloudflareWafRule(zoneId, {
+ description: customDescription,
+ expression: customExpression,
+ action: customAction,
+ enabled: true,
+ });
+ await loadRules();
+ setCustomDescription('');
+ setCustomExpression('');
+ setCustomAction('block');
+ toast.success('Custom rule added');
+ } catch (err) {
+ toast.error(err.message);
+ } finally {
+ setApplying(false);
+ }
+ };
+
+ const handleToggleRule = async (rule) => {
+ setApplying(true);
+ try {
+ await api.updateCloudflareWafRule(zoneId, rulesetId, rule.id, {
+ enabled: !rule.enabled,
+ });
+ await loadRules();
+ } catch (err) {
+ toast.error(err.message);
+ } finally {
+ setApplying(false);
+ }
+ };
+
+ const handleDeleteRule = async (rule) => {
+ setApplying(true);
+ try {
+ await api.deleteCloudflareWafRule(zoneId, rulesetId, rule.id);
+ await loadRules();
+ toast.success('Rule deleted');
+ } catch (err) {
+ toast.error(err.message);
+ } finally {
+ setApplying(false);
+ }
+ };
+
+ if (loading) {
+ return <div className="cf-waf__loading">Loading firewall rules…</div>;
+ }
+
+ if (error) {
+ return (
+ <EmptyState
+ icon={ShieldAlert}
+ title="Firewall rules unavailable"
+ description={error}
+ />
+ );
+ }
+
+ const writeDisabled = !isAdmin || applying;
+
+ return (
+ <div className="cf-waf">
+ {/* Presets / quick rules */}
+ <section className="cf-waf__section">
+ <h3 className="cf-waf__heading">Quick rules</h3>
+ <p className="cf-waf__hint">
+ Apply a curated Cloudflare rule without writing an expression by hand.
+ </p>
+
+ <div className="cf-waf__field">
+ <Select
+ value={selectedPreset}
+ onValueChange={handleSelectPreset}
+ disabled={writeDisabled}
+ >
+ <SelectTrigger className="cf-waf__select">
+ <SelectValue placeholder="Choose a quick rule…" />
+ </SelectTrigger>
+ <SelectContent>
+ {presets.map((preset) => (
+ <SelectItem key={preset.key} value={preset.key}>
+ {preset.label}
+ </SelectItem>
+ ))}
+ </SelectContent>
+ </Select>
+ </div>
+
+ {activePreset && (
+ <p className="cf-waf__preset-desc">{activePreset.description}</p>
+ )}
+
+ {presetParamDefs.length > 0 && (
+ <div className="cf-waf__params">
+ {presetParamDefs.map((param) => (
+ <div className="cf-waf__field" key={param.key}>
+ <label className="cf-waf__label">{param.label}</label>
+ <Input
+ value={presetParams[param.key] || ''}
+ placeholder={param.placeholder}
+ onChange={(e) => handleParamChange(param.key, e.target.value)}
+ disabled={writeDisabled}
+ />
+ </div>
+ ))}
+ </div>
+ )}
+
+ <div className="cf-waf__actions">
+ <Button
+ size="sm"
+ onClick={handleApplyPreset}
+ disabled={writeDisabled || !activePreset}
+ >
+ Add rule
+ </Button>
+ </div>
+ </section>
+
+ {/* Custom rule */}
+ <section className="cf-waf__section">
+ <h3 className="cf-waf__heading">Custom rule</h3>
+ <p className="cf-waf__hint">
+ Write your own Cloudflare firewall expression for full control.
+ </p>
+
+ <div className="cf-waf__field">
+ <label className="cf-waf__label">Description</label>
+ <Input
+ value={customDescription}
+ placeholder="Block admin from outside the office"
+ onChange={(e) => setCustomDescription(e.target.value)}
+ disabled={writeDisabled}
+ />
+ </div>
+
+ <div className="cf-waf__field">
+ <label className="cf-waf__label">Expression</label>
+ <Textarea
+ rows={3}
+ value={customExpression}
+ placeholder={EXPRESSION_PLACEHOLDER}
+ onChange={(e) => setCustomExpression(e.target.value)}
+ disabled={writeDisabled}
+ />
+ </div>
+
+ <div className="cf-waf__field">
+ <label className="cf-waf__label">Action</label>
+ <Select
+ value={customAction}
+ onValueChange={setCustomAction}
+ disabled={writeDisabled}
+ >
+ <SelectTrigger className="cf-waf__select">
+ <SelectValue />
+ </SelectTrigger>
+ <SelectContent>
+ {ACTION_OPTIONS.map((opt) => (
+ <SelectItem key={opt.value} value={opt.value}>
+ {opt.label}
+ </SelectItem>
+ ))}
+ </SelectContent>
+ </Select>
+ </div>
+
+ <div className="cf-waf__actions">
+ <Button
+ size="sm"
+ onClick={handleAddCustomRule}
+ disabled={writeDisabled || !customExpression.trim()}
+ >
+ Add custom rule
+ </Button>
+ </div>
+ </section>
+
+ {/* Active rules list */}
+ <section className="cf-waf__section">
+ <h3 className="cf-waf__heading">Active rules ({rules.length})</h3>
+
+ {rules.length === 0 ? (
+ <EmptyState
+ icon={ShieldAlert}
+ title="No custom firewall rules"
+ description="Add a quick rule or a custom rule above."
+ />
+ ) : (
+ <ul className="cf-waf__list">
+ {rules.map((rule) => (
+ <li className="cf-waf__rule" key={rule.id}>
+ <div className="cf-waf__rule-main">
+ <div className="cf-waf__rule-head">
+ <Badge
+ variant={rule.action === 'block' ? 'destructive' : 'secondary'}
+ >
+ {rule.action}
+ </Badge>
+ <span className="cf-waf__rule-desc">
+ {rule.description || 'Untitled rule'}
+ </span>
+ </div>
+ <code className="cf-waf__rule-expr">{rule.expression}</code>
+ </div>
+
+ <div className="cf-waf__rule-actions">
+ <Switch
+ checked={rule.enabled}
+ onCheckedChange={() => handleToggleRule(rule)}
+ disabled={writeDisabled}
+ />
+ <Button
+ variant="destructive"
+ size="sm"
+ onClick={() => handleDeleteRule(rule)}
+ disabled={writeDisabled}
+ >
+ Delete
+ </Button>
+ </div>
+ </li>
+ ))}
+ </ul>
+ )}
+ </section>
+ </div>
+ );
+}
diff --git a/frontend/src/pages/CloudflareZoneSettings.jsx b/frontend/src/pages/CloudflareZoneSettings.jsx
index 60983bf1..4a3c08c6 100644
--- a/frontend/src/pages/CloudflareZoneSettings.jsx
+++ b/frontend/src/pages/CloudflareZoneSettings.jsx
@@ -1,7 +1,8 @@
import { useState, useEffect, useCallback } from 'react';
import { useParams, Link } from 'react-router-dom';
-import { Cloud, ShieldCheck, Lock, Gauge, Database, Wand2, Eraser } from 'lucide-react';
+import { Cloud, ShieldCheck, Lock, Gauge, Database, Wand2, Eraser, Flame } from 'lucide-react';
import { PageTopbar } from '@/components/ds';
+import WafPanel from '../components/cloudflare/WafPanel';
import { Tabs, TabsList, TabsTrigger, TabsContent } from '@/components/ui/tabs';
import { Switch } from '@/components/ui/switch';
import { Button } from '@/components/ui/button';
@@ -185,6 +186,7 @@ const CloudflareZoneSettings = () => {
{TAB_ICONS[g.key]}{g.label}
</TabsTrigger>
))}
+ <TabsTrigger value="waf"><Flame size={15} />WAF</TabsTrigger>
<TabsTrigger value="actions"><Wand2 size={15} />Actions</TabsTrigger>
</TabsList>
@@ -205,6 +207,12 @@ const CloudflareZoneSettings = () => {
</TabsContent>
))}
+ <TabsContent value="waf">
+ <div className="cf-panel">
+ <WafPanel zoneId={zoneId} isAdmin={isAdmin} />
+ </div>
+ </TabsContent>
+
<TabsContent value="actions">
<div className="cf-panel cf-actions">
<div className="cf-action">
diff --git a/frontend/src/services/api/cloudflare.js b/frontend/src/services/api/cloudflare.js
index 71bb182a..da72e209 100644
--- a/frontend/src/services/api/cloudflare.js
+++ b/frontend/src/services/api/cloudflare.js
@@ -31,3 +31,35 @@ export async function purgeCloudflareCache(zoneId, payload) {
body: payload,
});
}
+
+// WAF custom firewall rules (http_request_firewall_custom phase).
+export async function getCloudflareWafRules(zoneId) {
+ return this.request(`/cloudflare/zones/${zoneId}/waf/rules`);
+}
+
+export async function addCloudflareWafRule(zoneId, rule) {
+ return this.request(`/cloudflare/zones/${zoneId}/waf/rules`, {
+ method: 'POST',
+ body: rule,
+ });
+}
+
+export async function applyCloudflareWafPreset(zoneId, presetKey, params = {}) {
+ return this.request(`/cloudflare/zones/${zoneId}/waf/presets/${presetKey}`, {
+ method: 'POST',
+ body: { params },
+ });
+}
+
+export async function updateCloudflareWafRule(zoneId, rulesetId, ruleId, fields) {
+ return this.request(`/cloudflare/zones/${zoneId}/waf/rulesets/${rulesetId}/rules/${ruleId}`, {
+ method: 'PATCH',
+ body: fields,
+ });
+}
+
+export async function deleteCloudflareWafRule(zoneId, rulesetId, ruleId) {
+ return this.request(`/cloudflare/zones/${zoneId}/waf/rulesets/${rulesetId}/rules/${ruleId}`, {
+ method: 'DELETE',
+ });
+}
diff --git a/frontend/src/styles/pages/_cloudflare-zone.scss b/frontend/src/styles/pages/_cloudflare-zone.scss
index efb598ac..3b473e16 100644
--- a/frontend/src/styles/pages/_cloudflare-zone.scss
+++ b/frontend/src/styles/pages/_cloudflare-zone.scss
@@ -155,3 +155,120 @@
margin-top: $spacing-sm;
}
}
+
+// WAF tab — preset picker, custom-rule form, and the active-rules list.
+.cf-waf {
+ &__loading {
+ padding: $spacing-lg;
+ color: $text-muted;
+ }
+
+ &__section {
+ padding: $spacing-md 0;
+ border-bottom: 1px solid $border-color;
+
+ &:last-child { border-bottom: none; }
+ }
+
+ &__heading {
+ margin: 0 0 4px;
+ font-size: 0.95rem;
+ }
+
+ &__hint {
+ margin: 0 0 $spacing-sm;
+ color: $text-muted;
+ font-size: 0.85rem;
+ }
+
+ &__field {
+ margin-bottom: $spacing-sm;
+ }
+
+ &__label {
+ display: block;
+ font-size: 0.82rem;
+ color: $text-secondary;
+ margin-bottom: 4px;
+ }
+
+ &__select {
+ max-width: 320px;
+ }
+
+ &__preset-desc {
+ margin: 0 0 $spacing-sm;
+ color: $text-secondary;
+ font-size: 0.85rem;
+ line-height: 1.4;
+ }
+
+ &__params {
+ display: flex;
+ flex-wrap: wrap;
+ gap: $spacing-md;
+ }
+
+ &__actions {
+ display: flex;
+ justify-content: flex-end;
+ margin-top: $spacing-sm;
+ }
+
+ &__list {
+ list-style: none;
+ margin: $spacing-sm 0 0;
+ padding: 0;
+ display: flex;
+ flex-direction: column;
+ gap: $spacing-sm;
+ }
+
+ &__rule {
+ display: flex;
+ align-items: flex-start;
+ justify-content: space-between;
+ gap: $spacing-md;
+ padding: $spacing-md;
+ background: $bg-elevated;
+ border: 1px solid $border-color;
+ border-radius: $radius-md;
+ }
+
+ &__rule-main {
+ min-width: 0;
+ flex: 1;
+ }
+
+ &__rule-head {
+ display: flex;
+ align-items: center;
+ gap: $spacing-sm;
+ margin-bottom: $spacing-xs;
+ }
+
+ &__rule-desc {
+ font-weight: 600;
+ color: $text-primary;
+ }
+
+ &__rule-expr {
+ display: block;
+ font-family: $font-mono;
+ font-size: 0.8rem;
+ color: $text-secondary;
+ background: $bg-code;
+ padding: $spacing-xs $spacing-sm;
+ border-radius: $radius-sm;
+ overflow-x: auto;
+ white-space: pre-wrap;
+ word-break: break-word;
+ }
+
+ &__rule-actions {
+ display: flex;
+ align-items: center;
+ gap: $spacing-sm;
+ flex-shrink: 0;
+ }
+}