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.
Python astracloudflarecontrol-panelcyberpaneldnsfablehosting-control-panelhosting-panelkimi-k3server-managementserverkitubuntu-web-panelwebserver
feat(cloudflare): WAF custom rules (Phase 3)
Juan Denis5ec5be4b31ba
diff --git a/backend/app/api/cloudflare.py b/backend/app/api/cloudflare.pyindex 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)}), 400return _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.pyindex 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.pyindex 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.pyindex 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.jsxnew file mode 100644index 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.jsxindex 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.jsindex 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.scssindex 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;+ }+}