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(firewall): refuse to remove the last rule admitting SSH

Juan Denis7f439e57964b
diff --git a/backend/app/api/firewall.py b/backend/app/api/firewall.py
index 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_required
def 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), 409
return 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), 409
return jsonify(result), 400
diff --git a/backend/app/services/firewall_service.py b/backend/app/services/firewall_service.py
index 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)
+
@classmethod
def _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)
@classmethod
def get_blocked_ips(cls) -> Dict:
diff --git a/backend/tests/test_firewall_rule_removal_guard.py b/backend/tests/test_firewall_rule_removal_guard.py
new file mode 100644
index 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