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(firewall): refuse to remove the last rule admitting SSH
Juan Denis7f439e57964b
diff --git a/backend/app/api/firewall.py b/backend/app/api/firewall.pyindex 6fbb5d75..3dee719a 100644--- a/backend/app/api/firewall.py+++ b/backend/app/api/firewall.py@@ -103,10 +103,25 @@ def add_rule():return jsonify(result), 400+@firewall_bp.route('/rules/removal-preflight', methods=['POST'])+@viewer_required+def rule_removal_preflight():+ """Would removing this rule cut off SSH? Lets the UI warn before the click."""+ data = request.get_json() or {}+ rule_type = data.get('type')+ kwargs = {k: v for k, v in data.items() if k not in ('type', 'force')}+ return jsonify(FirewallService.check_ssh_rule_removal(rule_type, **kwargs)), 200++@firewall_bp.route('/rules', methods=['DELETE'])@admin_requireddef remove_rule():- """Remove a firewall rule."""+ """Remove a firewall rule.++ Blocked with 409 when the rule is the last one admitting SSH on a firewall+ that is currently enforcing — deleting it would close the caller's own+ session. Resend with force=true to override.+ """data = request.get_json()if not data:@@ -116,12 +131,15 @@ def remove_rule():if not rule_type:return jsonify({'success': False, 'error': 'Rule type required'}), 400- kwargs = {k: v for k, v in data.items() if k != 'type'}+ force = bool(data.get('force'))+ kwargs = {k: v for k, v in data.items() if k not in ('type', 'force')}- result = FirewallService.remove_rule(rule_type, **kwargs)+ result = FirewallService.remove_rule(rule_type, force=force, **kwargs)if result.get('success'):return jsonify(result), 200+ if result.get('blocked_by') == 'ssh_lockout':+ return jsonify(result), 409return jsonify(result), 400@@ -219,10 +237,15 @@ def deny_port():protocol = data.get('protocol', 'tcp')permanent = data.get('permanent', True)- result = FirewallService.deny_port(port, protocol, permanent)+ # Denying a port is implemented as removing its allow rule, so this shares+ # the SSH-lockout guard with DELETE /rules.+ result = FirewallService.deny_port(port, protocol, permanent,+ force=bool(data.get('force')))if result.get('success'):return jsonify(result), 200+ if result.get('blocked_by') == 'ssh_lockout':+ return jsonify(result), 409return jsonify(result), 400diff --git a/backend/app/services/firewall_service.py b/backend/app/services/firewall_service.pyindex 50d99571..6f67da94 100644--- a/backend/app/services/firewall_service.py+++ b/backend/app/services/firewall_service.py@@ -547,19 +547,234 @@ class FirewallService:except Exception as e:return {'success': False, 'error': str(e)}+ # ------------------------------------------------------------------+ # Removal preflight — the other way to lock yourself out+ # ------------------------------------------------------------------+ #: enable() guards the moment the firewall comes up. This guards every+ #: moment after it: with ufw already active and a default-deny policy,+ #: deleting the rule that admits SSH closes the session executing the+ #: delete. `deny_port()` routes through here too — denying a port is+ #: implemented as removing its allow rule, so it is the same hazard.++ @classmethod+ def _ufw_numbered_rules(cls) -> List[Dict]:+ """Active ufw rules with the numbers `ufw delete <n>` refers to.++ Deleting by number is the dangerous spelling: the caller passes an+ opaque index, so the only way to know what is about to be removed is to+ resolve it here first.+ """+ rules = []+ try:+ result = run_privileged(['ufw', 'status', 'numbered'],+ timeout=PROBE_TIMEOUT)+ except Exception:+ return rules+ if result.returncode != 0:+ return rules++ pattern = re.compile(+ r'^\[\s*(\d+)\]\s+(.+?)\s+(ALLOW|DENY|REJECT|LIMIT)(?:\s+(?:IN|OUT))?\s*(.*)$'+ )+ for line in (result.stdout or '').splitlines():+ match = pattern.match(line.strip())+ if not match:+ continue+ rules.append({+ 'number': int(match.group(1)),+ 'to': match.group(2).strip(),+ 'action': match.group(3).upper(),+ 'from': (match.group(4) or '').strip(),+ })+ return rules++ #: `ufw status numbered` marks IPv6 rows as `22/tcp (v6)`. Left in, the "6"+ #: parses as a port number — harmless for SSH on 22, wrong for anyone whose+ #: sshd listens on 6.+ _ADDRESS_FAMILY_SUFFIX = re.compile(r'\((?:v6|v4)\)')++ @classmethod+ def _ports_in(cls, field: str) -> set:+ """Ports named by a rule's destination, resolving app profiles."""+ field = cls._ADDRESS_FAMILY_SUFFIX.sub('', field or '').strip()+ ports = {int(n) for n in re.findall(r'\b(\d{1,5})(?:/(?:tcp|udp))?\b', field)+ if 0 < int(n) <= 65535}+ # 'Anywhere' is ufw's wildcard destination, not an application profile —+ # looking it up would just cost a subprocess to learn nothing.+ if not ports and field.lower() != 'anywhere' \+ and re.match(r'^[A-Za-z][\w .-]*$', field):+ ports = cls._app_profile_ports(field)+ return ports+@classmethod- def remove_rule(cls, rule_type: str, **kwargs) -> Dict:- """Remove a firewall rule."""+ def _firewalld_ssh_coverage(cls, ssh_ports: List[int]) -> set:+ """What currently admits SSH under firewalld: {'service:ssh', 22, ...}."""+ coverage = set()+ for flag, kind in (('--list-services', 'service'), ('--list-ports', 'port')):+ try:+ result = run_privileged(['firewall-cmd', flag], timeout=PROBE_TIMEOUT)+ except Exception:+ continue+ if result.returncode != 0:+ continue+ for token in (result.stdout or '').split():+ if kind == 'service' and token == 'ssh':+ coverage.add('service:ssh')+ elif kind == 'port':+ for port in cls._ports_in(token):+ if port in ssh_ports:+ coverage.add(port)+ return coverage++ @classmethod+ def check_ssh_rule_removal(cls, rule_type: str = None, **kwargs) -> Dict:+ """Would removing this rule cut off SSH *right now*?++ Only meaningful while the firewall is active — on an inactive one+ nothing is being enforced, and enable() runs its own preflight before+ anything starts being denied.++ Returns ``{'safe', 'reason', 'ssh_ports', 'targets'}``.+ """status = cls.get_status()- firewall = status['active_firewall']+ firewall = status.get('active_firewall')++ if not status.get('any_active'):+ return {'safe': True, 'reason': 'firewall is not active',+ 'ssh_ports': None, 'targets': []}++ if firewall == 'ufw' and cls._ufw_default_incoming_allow():+ return {'safe': True, 'reason': 'default incoming policy is ACCEPT',+ 'ssh_ports': None, 'targets': []}++ ssh = cls.ssh_ports()+ if ssh is None:+ return {+ 'safe': False,+ 'reason': ('Could not determine which port sshd is listening on, '+ 'so there is no way to confirm this removal keeps it '+ 'reachable.'),+ 'ssh_ports': None,+ 'targets': [],+ }+ if firewall == 'ufw':+ return cls._check_ufw_removal(ssh, rule_type, **kwargs)if firewall == 'firewalld':- return cls._remove_firewalld_rule(rule_type, **kwargs)- elif firewall == 'ufw':- return cls._remove_ufw_rule(rule_type, **kwargs)+ return cls._check_firewalld_removal(ssh, rule_type, **kwargs)+ return {'safe': True, 'reason': 'no active firewall',+ 'ssh_ports': ssh, 'targets': []}++ @classmethod+ def _check_ufw_removal(cls, ssh: List[int], rule_type: str, **kwargs) -> Dict:+ rules = cls._ufw_numbered_rules()+ number = kwargs.get('number')++ if number:+ target = next((r for r in rules if r['number'] == int(number)), None)+ if target is None:+ # Unknown index: ufw would reject it anyway, and refusing on a+ # rule we could not read would block harmless deletes.+ return {'safe': True, 'reason': f'no active rule numbered {number}',+ 'ssh_ports': ssh, 'targets': []}+ targets = [target]else:+ port = kwargs.get('port')+ if port is None:+ return {'safe': True, 'reason': 'removal does not name a port',+ 'ssh_ports': ssh, 'targets': []}+ if int(port) not in ssh:+ return {'safe': True, 'reason': 'port is not an SSH port',+ 'ssh_ports': ssh, 'targets': []}+ targets = [r for r in rules if int(port) in cls._ports_in(r['to'])]++ removed_numbers = {r['number'] for r in targets}+ covers_ssh = [r for r in targets+ if r['action'] == 'ALLOW' and cls._ports_in(r['to']) & set(ssh)]+ if not covers_ssh:+ return {'safe': True, 'reason': 'rule does not admit SSH',+ 'ssh_ports': ssh, 'targets': [r['to'] for r in targets]}++ # Another allow rule may still admit SSH after this one goes — deleting+ # a duplicate is harmless and must not be blocked.+ remaining = [r for r in rules+ if r['number'] not in removed_numbers+ and r['action'] == 'ALLOW'+ and cls._ports_in(r['to']) & set(ssh)]+ if remaining:+ return {'safe': True,+ 'reason': f'SSH stays open via rule {remaining[0]["number"]} '+ f'({remaining[0]["to"]})',+ 'ssh_ports': ssh, 'targets': [r['to'] for r in covers_ssh]}++ listed = ', '.join(str(p) for p in ssh)+ return {+ 'safe': False,+ 'reason': (f'This is the only active rule admitting SSH on port {listed}. '+ f'Removing it closes your own session — the firewall is '+ f'active and denying by default.'),+ 'ssh_ports': ssh,+ 'targets': [r['to'] for r in covers_ssh],+ }++ @classmethod+ def _check_firewalld_removal(cls, ssh: List[int], rule_type: str, **kwargs) -> Dict:+ coverage = cls._firewalld_ssh_coverage(ssh)+ removing = set()++ if rule_type == 'service' and kwargs.get('service') == 'ssh':+ removing.add('service:ssh')+ elif rule_type == 'port':+ port = kwargs.get('port')+ if port is not None and int(port) in ssh:+ removing.add(int(port))++ if not removing:+ return {'safe': True, 'reason': 'rule does not admit SSH',+ 'ssh_ports': ssh, 'targets': []}++ if coverage - removing:+ return {'safe': True, 'reason': 'SSH stays open via another rule',+ 'ssh_ports': ssh, 'targets': sorted(str(t) for t in removing)}++ listed = ', '.join(str(p) for p in ssh)+ return {+ 'safe': False,+ 'reason': (f'This is the only rule admitting SSH on port {listed}. '+ f'Removing it closes your own session.'),+ 'ssh_ports': ssh,+ 'targets': sorted(str(t) for t in removing),+ }++ @classmethod+ def remove_rule(cls, rule_type: str, force: bool = False, **kwargs) -> Dict:+ """Remove a firewall rule.++ Refuses when the rule is the last one admitting SSH on a firewall that+ is currently enforcing. ``force=True`` is the operator accepting it.+ """+ status = cls.get_status()+ firewall = status['active_firewall']++ if firewall not in ('firewalld', 'ufw'):return {'success': False, 'error': 'No firewall detected'}+ if not force:+ preflight = cls.check_ssh_rule_removal(rule_type, **kwargs)+ if not preflight['safe']:+ return {+ 'success': False,+ 'error': preflight['reason'],+ 'blocked_by': 'ssh_lockout',+ 'ssh_ports': preflight['ssh_ports'],+ 'targets': preflight['targets'],+ 'override': 'Send force=true to remove it anyway.',+ }++ if firewall == 'firewalld':+ return cls._remove_firewalld_rule(rule_type, **kwargs)+ return cls._remove_ufw_rule(rule_type, **kwargs)+@classmethoddef _remove_firewalld_rule(cls, rule_type: str, **kwargs) -> Dict:"""Remove a firewalld rule."""@@ -648,9 +863,15 @@ class FirewallService:return cls.add_rule('port', port=port, protocol=protocol, permanent=permanent)@classmethod- def deny_port(cls, port: int, protocol: str = 'tcp', permanent: bool = True) -> Dict:- """Quick method to deny a port."""- return cls.remove_rule('port', port=port, protocol=protocol, permanent=permanent)+ def deny_port(cls, port: int, protocol: str = 'tcp', permanent: bool = True,+ force: bool = False) -> Dict:+ """Quick method to deny a port.++ Routes through remove_rule, so denying the SSH port hits the same+ lockout guard as deleting its rule — it is the same outcome.+ """+ return cls.remove_rule('port', force=force, port=port, protocol=protocol,+ permanent=permanent)@classmethoddef get_blocked_ips(cls) -> Dict:diff --git a/backend/tests/test_firewall_rule_removal_guard.py b/backend/tests/test_firewall_rule_removal_guard.pynew file mode 100644index 00000000..c89bef4b--- /dev/null+++ b/backend/tests/test_firewall_rule_removal_guard.py@@ -0,0 +1,330 @@+"""Removing the last rule that admits SSH must not be a one-click lockout.++`enable()` guards the moment the firewall comes up. This guards every moment+after it: with ufw active and denying by default, deleting the rule that admits+SSH severs the very session issuing the delete, and there is no way back in.++Deleting **by number** is the sharp edge — the caller passes an opaque index,+so the only way to know what is about to go is to resolve it against+`ufw status numbered` first.++`deny_port()` is implemented as `remove_rule()`, so it inherits this guard;+denying the SSH port and deleting its allow rule are the same outcome.+"""++import subprocess+from unittest.mock import patch++import pytest++from app.services.firewall_service import FirewallService++NUMBERED = """Status: active++ To Action From+ -- ------ ----+[ 1] 22/tcp ALLOW IN Anywhere+[ 2] 25/tcp ALLOW IN Anywhere+[ 3] 80/tcp ALLOW IN Anywhere+"""++NUMBERED_DUPLICATE_SSH = """Status: active++ To Action From+ -- ------ ----+[ 1] 22/tcp ALLOW IN Anywhere+[ 2] 22/tcp ALLOW IN 10.0.0.0/8+"""++NUMBERED_PROFILE = """Status: active++ To Action From+ -- ------ ----+[ 1] OpenSSH ALLOW IN Anywhere+"""++SSHD_22 = 'port 22\n'+++def _completed(stdout='', returncode=0):+ return subprocess.CompletedProcess([], returncode, stdout=stdout, stderr='')+++def _router(numbered=NUMBERED, sshd=SSHD_22, app_info=''):+ def _run(cmd, *args, **kwargs):+ if cmd[0] == 'sshd':+ return _completed(sshd)+ if cmd[:3] == ['ufw', 'status', 'numbered']:+ return _completed(numbered)+ if cmd[:3] == ['ufw', 'app', 'info']:+ return _completed(app_info)+ return _completed()+ return _run++[email protected](autouse=True)+def _active_ufw():+ """ufw installed, active, default-deny — the state where this matters."""+ with patch.object(FirewallService, 'get_status', return_value={+ 'firewalld': {'installed': False, 'running': False, 'default_zone': None},+ 'ufw': {'installed': True, 'active': True},+ 'active_firewall': 'ufw', 'any_installed': True, 'any_active': True,+ }), patch.object(FirewallService, '_ufw_default_incoming_allow',+ return_value=False):+ yield+++# --------------------------------------------------------------------------- #+# Removal by number — the opaque-index case+# --------------------------------------------------------------------------- #++@patch('app.services.firewall_service.run_privileged')+def test_deleting_the_ssh_rule_by_number_is_refused(run):+ run.side_effect = _router()++ check = FirewallService.check_ssh_rule_removal('port', number=1)++ assert check['safe'] is False+ assert check['ssh_ports'] == [22]+ assert 'only active rule admitting SSH' in check['reason']+++@patch('app.services.firewall_service.run_privileged')+def test_deleting_an_unrelated_rule_by_number_is_allowed(run):+ run.side_effect = _router()++ assert FirewallService.check_ssh_rule_removal('port', number=3)['safe'] is True+++@patch('app.services.firewall_service.run_privileged')+def test_a_duplicate_ssh_rule_may_still_be_deleted(run):+ """Two rules admit 22 — removing one leaves SSH open, so do not block it."""+ run.side_effect = _router(numbered=NUMBERED_DUPLICATE_SSH)++ check = FirewallService.check_ssh_rule_removal('port', number=1)++ assert check['safe'] is True+ assert 'stays open via rule 2' in check['reason']+++@patch('app.services.firewall_service.run_privileged')+def test_app_profile_rule_is_resolved_before_deleting(run):+ """`[1] OpenSSH` admits 22 — but only because app info was read."""+ run.side_effect = _router(+ numbered=NUMBERED_PROFILE,+ app_info='Profile: OpenSSH\n\nPorts:\n 22/tcp\n',+ )++ assert FirewallService.check_ssh_rule_removal('port', number=1)['safe'] is False+++@patch('app.services.firewall_service.run_privileged')+def test_unknown_rule_number_does_not_block(run):+ """ufw would reject it anyway; refusing here blocks harmless deletes."""+ run.side_effect = _router()++ assert FirewallService.check_ssh_rule_removal('port', number=99)['safe'] is True+++# --------------------------------------------------------------------------- #+# Removal by specification+# --------------------------------------------------------------------------- #++@patch('app.services.firewall_service.run_privileged')+def test_ipv6_suffix_does_not_parse_as_a_port(run):+ """`22/tcp (v6)` must not yield port 6 — real `ufw status numbered` output."""+ run.side_effect = _router()++ assert FirewallService._ports_in('22/tcp (v6)') == {22}+ assert FirewallService._ports_in('80,443/tcp') == {80, 443}+++@patch('app.services.firewall_service.run_privileged')+def test_anywhere_is_not_looked_up_as_an_app_profile(run):+ """It is ufw's wildcard destination; the lookup would cost a subprocess."""+ run.side_effect = _router()++ assert FirewallService._ports_in('Anywhere') == set()+ assert not any(call.args[0][:3] == ['ufw', 'app', 'info']+ for call in run.call_args_list)+++@patch('app.services.firewall_service.run_privileged')+def test_ipv6_ssh_row_still_protects_ssh(run):+ """An IPv6-only SSH allow rule is real coverage and must be guarded."""+ numbered = ('Status: active\n\n'+ '[ 1] 22/tcp (v6) ALLOW IN Anywhere (v6)\n')+ run.side_effect = _router(numbered=numbered)++ assert FirewallService.check_ssh_rule_removal('port', number=1)['safe'] is False+++@patch('app.services.firewall_service.run_privileged')+def test_deleting_the_ssh_rule_by_port_is_refused(run):+ run.side_effect = _router()++ assert FirewallService.check_ssh_rule_removal('port', port=22)['safe'] is False+++@patch('app.services.firewall_service.run_privileged')+def test_deleting_a_non_ssh_port_is_allowed(run):+ run.side_effect = _router()++ assert FirewallService.check_ssh_rule_removal('port', port=80)['safe'] is True+++@patch('app.services.firewall_service.run_privileged')+def test_removal_that_names_no_port_is_allowed(run):+ run.side_effect = _router()++ assert FirewallService.check_ssh_rule_removal('block_ip', ip='1.2.3.4')['safe'] is True+++# --------------------------------------------------------------------------- #+# When the guard does not apply+# --------------------------------------------------------------------------- #++@patch('app.services.firewall_service.run_privileged')+def test_inactive_firewall_is_not_guarded(run):+ """Nothing is being enforced; enable() runs its own preflight later."""+ run.side_effect = _router()+ with patch.object(FirewallService, 'get_status', return_value={+ 'ufw': {'installed': True, 'active': False}, 'active_firewall': 'ufw',+ 'firewalld': {'installed': False, 'running': False, 'default_zone': None},+ 'any_installed': True, 'any_active': False,+ }):+ check = FirewallService.check_ssh_rule_removal('port', number=1)++ assert check['safe'] is True+ assert check['reason'] == 'firewall is not active'+++@patch('app.services.firewall_service.run_privileged')+def test_undeterminable_ssh_port_refuses(run):+ """Same rule as enable(): no answer must never become "probably 22"."""+ def _run(cmd, *args, **kwargs):+ if cmd[0] == 'sshd':+ return _completed(returncode=1)+ if cmd[:3] == ['ufw', 'status', 'numbered']:+ return _completed(NUMBERED)+ return _completed()+ run.side_effect = _run++ check = FirewallService.check_ssh_rule_removal('port', number=1)++ assert check['safe'] is False+ assert check['ssh_ports'] is None+++def test_accept_default_policy_cannot_lock_anyone_out():+ with patch.object(FirewallService, '_ufw_default_incoming_allow',+ return_value=True):+ assert FirewallService.check_ssh_rule_removal('port', number=1)['safe'] is True+++# --------------------------------------------------------------------------- #+# remove_rule() and deny_port() honour it+# --------------------------------------------------------------------------- #+[email protected](FirewallService, '_remove_ufw_rule')+@patch('app.services.firewall_service.run_privileged')+def test_remove_rule_refuses_and_never_shells_out(run, remove):+ run.side_effect = _router()++ result = FirewallService.remove_rule('port', number=1)++ assert result['success'] is False+ assert result['blocked_by'] == 'ssh_lockout'+ remove.assert_not_called() # the whole point++[email protected](FirewallService, '_remove_ufw_rule', return_value={'success': True})+@patch('app.services.firewall_service.run_privileged')+def test_force_overrides_the_removal_guard(run, remove):+ run.side_effect = _router()++ assert FirewallService.remove_rule('port', force=True, number=1)['success'] is True+ remove.assert_called_once()++[email protected](FirewallService, '_remove_ufw_rule', return_value={'success': True})+@patch('app.services.firewall_service.run_privileged')+def test_unrelated_removal_proceeds(run, remove):+ run.side_effect = _router()++ assert FirewallService.remove_rule('port', number=3)['success'] is True+ remove.assert_called_once()++[email protected](FirewallService, '_remove_ufw_rule')+@patch('app.services.firewall_service.run_privileged')+def test_deny_port_on_ssh_inherits_the_guard(run, remove):+ """Denying a port IS removing its allow rule — same lockout, same guard."""+ run.side_effect = _router()++ result = FirewallService.deny_port(22)++ assert result['success'] is False+ assert result['blocked_by'] == 'ssh_lockout'+ remove.assert_not_called()++[email protected](FirewallService, '_remove_ufw_rule', return_value={'success': True})+@patch('app.services.firewall_service.run_privileged')+def test_deny_port_on_another_port_is_unaffected(run, remove):+ run.side_effect = _router()++ assert FirewallService.deny_port(80)['success'] is True+++# --------------------------------------------------------------------------- #+# firewalld+# --------------------------------------------------------------------------- #++def _active_firewalld():+ with patch.object(FirewallService, 'get_status', return_value={+ 'firewalld': {'installed': True, 'running': True, 'default_zone': 'public'},+ 'ufw': {'installed': False, 'active': False},+ 'active_firewall': 'firewalld', 'any_installed': True, 'any_active': True,+ }):+ yield+++def _firewalld_router(services='ssh dhcpv6-client', ports=''):+ def _run(cmd, *args, **kwargs):+ if cmd[0] == 'sshd':+ return _completed(SSHD_22)+ if cmd[:2] == ['firewall-cmd', '--list-services']:+ return _completed(services)+ if cmd[:2] == ['firewall-cmd', '--list-ports']:+ return _completed(ports)+ return _completed()+ return _run+++@patch('app.services.firewall_service.run_privileged')+def test_firewalld_removing_the_ssh_service_is_refused(run, _active_firewalld):+ run.side_effect = _firewalld_router()++ check = FirewallService.check_ssh_rule_removal('service', service='ssh')++ assert check['safe'] is False+++@patch('app.services.firewall_service.run_privileged')+def test_firewalld_ssh_service_removal_ok_when_a_port_also_covers_it(+ run, _active_firewalld):+ run.side_effect = _firewalld_router(ports='22/tcp')++ check = FirewallService.check_ssh_rule_removal('service', service='ssh')++ assert check['safe'] is True+++@patch('app.services.firewall_service.run_privileged')+def test_firewalld_unrelated_service_removal_is_allowed(run, _active_firewalld):+ run.side_effect = _firewalld_router()++ assert FirewallService.check_ssh_rule_removal(+ 'service', service='http')['safe'] is True