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
refactor(security): generalize the Fail2ban jail engine beyond WordPress
Juan Denisb6692b798fbf
diff --git a/backend/app/services/fail2ban_jail_service.py b/backend/app/services/fail2ban_jail_service.pyindex fa139778..ded484f3 100644--- a/backend/app/services/fail2ban_jail_service.py+++ b/backend/app/services/fail2ban_jail_service.py@@ -70,7 +70,7 @@ ignoreregex =enabled = truefilter = {filter}logpath = {logpath}-port = http,https+port = {port}maxretry = {maxretry}findtime = {findtime}bantime = {bantime}@@ -103,25 +103,36 @@ bantime = {bantime}return re.sub(r'[^a-zA-Z0-9_-]', '-', (name or '')).strip('-') or 'site'@classmethod- def jail_name(cls, app):- """``serverkit-<key>`` jail name for an application."""- return cls.JAIL_PREFIX + cls._sanitize(getattr(app, 'name', None))+ def jail_name_for_key(cls, key):+ """``serverkit-<key>`` jail name for any sanitized key (site name, game+ server id, …). The generic naming primitive under jail_name(app)."""+ return cls.JAIL_PREFIX + cls._sanitize(key)@classmethod- def _jail_filename(cls, app):- return f'{cls.jail_name(app)}.conf'+ def jail_name(cls, app):+ """``serverkit-<key>`` jail name for an application."""+ return cls.jail_name_for_key(getattr(app, 'name', None))@classmethod- def _jail_path(cls, app):- """Absolute path of the per-site jail file, guarded so it can only ever be- a ServerKit-owned file inside JAIL_DIR."""- filename = cls._jail_filename(app)+ def _jail_path_for_name(cls, jail):+ """Absolute path of a jail file by full jail name, guarded so it can only+ ever be a ServerKit-owned file inside JAIL_DIR."""+ filename = f'{jail}.conf'if (not filename.startswith(cls.JAIL_PREFIX)or '/' in filename or '\\' in filename or '..' in filename):# Unreachable given _sanitize, but refuse rather than risk a stray path.raise ValueError(f'refusing to target non-ServerKit jail file: {filename!r}')return os.path.join(cls.JAIL_DIR, filename)+ @classmethod+ def _jail_filename(cls, app):+ return f'{cls.jail_name(app)}.conf'++ @classmethod+ def _jail_path(cls, app):+ """Absolute path of the per-site jail file (guarded)."""+ return cls._jail_path_for_name(cls.jail_name(app))+# ---------- file helpers ----------@staticmethod@@ -156,15 +167,26 @@ bantime = {bantime}# ---------- filter ----------@classmethod- def ensure_filter(cls):- """Write the ServerKit WP-login filter if missing or out of date."""+ def ensure_filter(cls, filter_name=None, filter_content=None):+ """Write a ServerKit-owned Fail2ban filter if missing or out of date.++ Generic: any vertical can supply its own ``serverkit-*`` filter (e.g. a+ game-server console-login filter). Defaults to the WordPress login/xmlrpc+ filter for back-compat. Ownership-guarded — the name must be a+ ``serverkit-`` filter, so this never touches an operator's own filters."""if not cls.available():return cls._unavailable()- path = os.path.join(cls.FILTER_DIR, f'{cls.WP_FILTER}.conf')+ filter_name = filter_name or cls.WP_FILTER+ filter_content = filter_content if filter_content is not None else cls.FILTER_CONTENT+ if not filter_name.startswith(cls.JAIL_PREFIX):+ return {'success': False,+ 'error': f'filter name must start with {cls.JAIL_PREFIX!r}'}+ safe = cls._sanitize(filter_name)+ path = os.path.join(cls.FILTER_DIR, f'{safe}.conf')existing = cls._read_text(path)- if existing is not None and existing.strip() == cls.FILTER_CONTENT.strip():+ if existing is not None and existing.strip() == filter_content.strip():return {'success': True, 'path': path, 'changed': False}- res = cls._write_file(path, cls.FILTER_CONTENT)+ res = cls._write_file(path, filter_content)if not res.get('success'):return resreturn {'success': True, 'path': path, 'changed': True}@@ -172,59 +194,91 @@ bantime = {bantime}# ---------- jail lifecycle ----------@classmethod- def _render_jail(cls, app, logpath, maxretry, findtime, bantime):+ def _render_jail_config(cls, *, jail, site, filter_name, logpath,+ maxretry, findtime, bantime, port='http,https'):return cls.JAIL_TEMPLATE.format(- jail=cls.jail_name(app), site=getattr(app, 'name', ''), filter=cls.WP_FILTER,- logpath=logpath,+ jail=jail, site=site, filter=filter_name, logpath=logpath,maxretry=maxretry or cls.MAXRETRY,findtime=findtime or cls.FINDTIME,bantime=bantime or cls.BANTIME,+ port=port,)@classmethod- def enable_wp_jail(cls, app, *, maxretry=None, findtime=None, bantime=None):- """Create/refresh a WP brute-force jail for *app* and reload fail2ban.+ def _render_jail(cls, app, logpath, maxretry, findtime, bantime):+ """WP-flavored back-compat renderer (serverkit-wp-login filter, web ports)."""+ return cls._render_jail_config(+ jail=cls.jail_name(app), site=getattr(app, 'name', ''),+ filter_name=cls.WP_FILTER, logpath=logpath,+ maxretry=maxretry, findtime=findtime, bantime=bantime, port='http,https')- Idempotent (regenerates the jail file). Best-effort: returns a ``skipped``- descriptor when fail2ban is unavailable rather than raising, so callers in- the site-create path never fail because of it."""+ @classmethod+ def enable_jail(cls, key, *, filter_name, filter_content, logpath,+ maxretry=None, findtime=None, bantime=None,+ port='http,https', site_label=None):+ """Create/refresh an arbitrary ServerKit-owned brute-force jail; reload.++ The generic engine behind enable_wp_jail, reusable by other verticals+ (e.g. a game-server login/RCON jail). ``key`` names the jail+ (``serverkit-<sanitized key>``); ``filter_name``/``filter_content`` define+ the ``serverkit-*`` filter to (re)write; ``logpath`` is the log to watch;+ ``port`` sets the jail's ports. Idempotent and best-effort: returns a+ ``skipped`` descriptor when fail2ban is unavailable rather than raising."""if not cls.available():return cls._unavailable()- if not getattr(app, 'name', None):- return {'success': False, 'error': 'application has no name'}+ if not key:+ return {'success': False, 'error': 'jail key is required'}- flt = cls.ensure_filter()+ flt = cls.ensure_filter(filter_name, filter_content)if not flt.get('success'):return flt- logpath = NginxService.site_access_log_path(app.name)cls._ensure_logpath(logpath)-+ jail = cls.jail_name_for_key(key)try:- jail_path = cls._jail_path(app)+ jail_path = cls._jail_path_for_name(jail)except ValueError as e:return {'success': False, 'error': str(e)}- written = cls._write_file(jail_path, cls._render_jail(- app, logpath, maxretry, findtime, bantime))+ written = cls._write_file(jail_path, cls._render_jail_config(+ jail=jail, site=site_label or key, filter_name=cls._sanitize(filter_name),+ logpath=logpath, maxretry=maxretry, findtime=findtime, bantime=bantime,+ port=port))if not written.get('success'):return writtenreloaded = cls.reload()return {- 'success': True, 'enabled': True, 'jail': cls.jail_name(app),+ 'success': True, 'enabled': True, 'jail': jail,'path': jail_path, 'logpath': logpath,'reloaded': reloaded.get('success'), 'reload_message': reloaded.get('message'),}@classmethod- def disable_jail(cls, app):- """Remove a site's ServerKit jail file and reload fail2ban. No-op (success)+ def enable_wp_jail(cls, app, *, maxretry=None, findtime=None, bantime=None):+ """Create/refresh a WP brute-force jail for *app* and reload fail2ban.++ Thin wrapper over the generic enable_jail engine with the WordPress+ login/xmlrpc filter and the site's nginx access log."""+ if not cls.available():+ return cls._unavailable()+ if not getattr(app, 'name', None):+ return {'success': False, 'error': 'application has no name'}+ logpath = NginxService.site_access_log_path(app.name)+ return cls.enable_jail(+ app.name, filter_name=cls.WP_FILTER, filter_content=cls.FILTER_CONTENT,+ logpath=logpath, maxretry=maxretry, findtime=findtime, bantime=bantime,+ port='http,https', site_label=app.name)++ @classmethod+ def remove_jail(cls, key):+ """Remove a ServerKit jail by key and reload fail2ban. No-op (success)when the jail does not exist or fail2ban is unavailable."""if not cls.available():return cls._unavailable()+ jail = cls.jail_name_for_key(key)try:- jail_path = cls._jail_path(app)+ jail_path = cls._jail_path_for_name(jail)except ValueError as e:return {'success': False, 'error': str(e)}@@ -238,9 +292,15 @@ bantime = {bantime}return {'success': False, 'error': str(e)}reloaded = cls.reload()- return {'success': True, 'removed': True, 'jail': cls.jail_name(app),+ return {'success': True, 'removed': True, 'jail': jail,'reloaded': reloaded.get('success')}+ @classmethod+ def disable_jail(cls, app):+ """Remove a site's ServerKit jail file and reload fail2ban. Thin wrapper+ over remove_jail keyed by the application name."""+ return cls.remove_jail(getattr(app, 'name', None))+@classmethoddef reload(cls):"""``fail2ban-client reload`` (keeps existing bans), falling back to adiff --git a/backend/tests/test_fail2ban_jail_service.py b/backend/tests/test_fail2ban_jail_service.pyindex 1f2c9d04..8cf71815 100644--- a/backend/tests/test_fail2ban_jail_service.py+++ b/backend/tests/test_fail2ban_jail_service.py@@ -170,6 +170,67 @@ def test_get_status_shape_when_jail_absent():assert st['fail2ban_running'] is False+# ---------- generic jail engine (plan 52 — reusable beyond WordPress) ----------++def test_enable_jail_generic_writes_custom_filter_jail_and_port():+ """The generic engine any vertical can use (e.g. a game-server login jail):+ an arbitrary serverkit-* filter, a custom logpath, and a non-web port."""+ writes = {}++ def fake_run(cmd, **kwargs):+ if cmd[:1] == ['tee'] and 'input' in kwargs:+ writes[cmd[1]] = kwargs['input']+ return _ok()++ custom_filter = ('# ServerKit game-server login filter.\n[Definition]\n'+ 'failregex = ^.*Failed login from <HOST>\nignoreregex =\n')+ with patch.object(F2B, 'available', return_value=True), \+ patch.object(F2B, '_read_text', return_value=None), \+ patch('app.services.fail2ban_jail_service.run_privileged', side_effect=fake_run):+ res = F2B.enable_jail(+ 'mc survival', filter_name='serverkit-mc-login',+ filter_content=custom_filter, logpath='/var/log/mc/console.log',+ maxretry=4, findtime=300, bantime=1800, port='25565', site_label='MC Survival')++ assert res['success'] is True and res['enabled'] is True+ # key is sanitized + prefixed like any jail+ assert res['jail'] == 'serverkit-mc-survival'++ filter_path = os.path.join(F2B.FILTER_DIR, 'serverkit-mc-login.conf')+ jail_path = os.path.join(F2B.JAIL_DIR, 'serverkit-mc-survival.conf')+ assert filter_path in writes and 'Failed login from <HOST>' in writes[filter_path]+ jail = writes[jail_path]+ assert '[serverkit-mc-survival]' in jail+ assert 'filter = serverkit-mc-login' in jail+ assert 'logpath = /var/log/mc/console.log' in jail+ assert 'port = 25565' in jail+ assert 'maxretry = 4' in jail and 'findtime = 300' in jail and 'bantime = 1800' in jail+++def test_ensure_filter_rejects_non_serverkit_name():+ with patch.object(F2B, 'available', return_value=True):+ res = F2B.ensure_filter('evil-filter', '[Definition]\n')+ assert res['success'] is False+ assert 'serverkit-' in res['error']+++def test_remove_jail_by_key_targets_serverkit_file():+ removed = {}++ def fake_run(cmd, **kwargs):+ if cmd[:1] == ['rm']:+ removed['path'] = cmd[-1]+ return _ok()++ with patch.object(F2B, 'available', return_value=True), \+ patch('app.services.fail2ban_jail_service.os.path.exists', return_value=True), \+ patch('app.services.fail2ban_jail_service.run_privileged', side_effect=fake_run):+ res = F2B.remove_jail('mc survival')++ assert res['success'] is True and res['removed'] is True+ assert removed['path'] == os.path.join(F2B.JAIL_DIR, 'serverkit-mc-survival.conf')++# ---------- WpSecurityService wrapper ----------def test_wp_security_set_brute_force_delegates_to_jail_service():