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(security): encrypt system-setting secrets at rest

Juan Denis31b613ade160
diff --git a/backend/app/__init__.py b/backend/app/__init__.py
index 69338b63..e4d16a76 100644
--- a/backend/app/__init__.py
+++ b/backend/app/__init__.py
@@ -339,11 +339,13 @@ def create_app(config_name=None):
n_dns = DNSProviderService.encrypt_legacy_secrets()
n_store = StorageProviderService.encrypt_legacy_secrets()
n_cloud = CloudProvisioningService.encrypt_legacy_secrets()
- if n_dns or n_store or n_cloud:
+ n_settings = SettingsService.migrate_legacy_secrets()
+ if n_dns or n_store or n_cloud or n_settings:
import logging as _logging
_logging.getLogger(__name__).info(
f'Encrypted legacy secrets at rest: {n_dns} DNS provider(s), '
- f'{n_store} storage field(s), {n_cloud} cloud provider(s)')
+ f'{n_store} storage field(s), {n_cloud} cloud provider(s), '
+ f'{n_settings} system setting(s)')
except Exception as e:
import logging as _logging
_logging.getLogger(__name__).warning(f'Legacy secret encryption skipped: {e}')
diff --git a/backend/app/services/settings_service.py b/backend/app/services/settings_service.py
index e33a48cc..efb5553d 100644
--- a/backend/app/services/settings_service.py
+++ b/backend/app/services/settings_service.py
@@ -1,6 +1,7 @@
"""Service for system settings operations."""
from app import db
from app.models import SystemSettings, User
+from app.utils.crypto import encrypt_secret, decrypt_secret_safe, is_encrypted
class SettingsService:
@@ -115,19 +116,54 @@ class SettingsService:
# Settings that must never be returned through the API (only "is it set?").
SECRET_AI_KEYS = {'ai_api_key_encrypted'}
+ # Settings stored encrypted at rest (auto-encrypt on write, decrypt on read).
+ # The API only exposes a boolean "is_set" / masked placeholder for these.
+ SECRET_KEYS = {
+ 'sso_google_client_secret',
+ 'sso_github_client_secret',
+ 'sso_oidc_client_secret',
+ 'source_github_client_secret',
+ 'ai_api_key_encrypted',
+ }
+
+ @staticmethod
+ def _is_secret_key(key: str) -> bool:
+ return key in SettingsService.SECRET_KEYS
+
+ @staticmethod
+ def _mask_secret(value) -> str:
+ """Return a masked placeholder for any non-empty secret."""
+ if value:
+ return '••••••••'
+ return ''
+
@staticmethod
def get(key, default=None):
- """Get a setting value by key."""
- return SystemSettings.get(key, default)
+ """Get a setting value by key. Secret values are decrypted."""
+ value = SystemSettings.get(key, default)
+ if SettingsService._is_secret_key(key) and value:
+ return decrypt_secret_safe(value)
+ return value
@staticmethod
def set(key, value, user_id=None):
- """Set a setting value by key."""
+ """Set a setting value by key. Secret values are encrypted at rest."""
# Get the expected type from defaults
default_config = SettingsService.DEFAULT_SETTINGS.get(key, {})
value_type = default_config.get('type', 'string')
description = default_config.get('description')
+ # Encrypt secret values before storage. Treat an unchanged masked
+ # placeholder as a no-op so the UI doesn't overwrite the real secret.
+ if SettingsService._is_secret_key(key):
+ if value == SettingsService._mask_secret(value) or value == '••••••••':
+ existing = SystemSettings.get(key)
+ if existing is not None:
+ return SystemSettings.query.filter_by(key=key).first()
+ value = ''
+ elif value:
+ value = encrypt_secret(value)
+
setting = SystemSettings.set(
key=key,
value=value,
@@ -139,19 +175,44 @@ class SettingsService:
return setting
@staticmethod
- def get_all():
- """Get all settings as a dictionary."""
+ def get_all(mask_secrets=True):
+ """Get all settings as a dictionary. Secrets are masked unless requested."""
settings = SystemSettings.query.all()
result = {}
for setting in settings:
- result[setting.key] = setting.get_typed_value()
+ value = setting.get_typed_value()
+ if mask_secrets and SettingsService._is_secret_key(setting.key):
+ result[setting.key] = SettingsService._mask_secret(value)
+ else:
+ result[setting.key] = value
return result
@staticmethod
- def get_all_with_metadata():
- """Get all settings with full metadata."""
+ def get_all_with_metadata(mask_secrets=True):
+ """Get all settings with full metadata. Secrets are masked unless requested."""
settings = SystemSettings.query.all()
- return [setting.to_dict() for setting in settings]
+ result = []
+ for setting in settings:
+ data = setting.to_dict()
+ if mask_secrets and SettingsService._is_secret_key(setting.key):
+ data['value'] = SettingsService._mask_secret(data['value'])
+ result.append(data)
+ return result
+
+ @staticmethod
+ def migrate_legacy_secrets() -> int:
+ """One-time, idempotent: encrypt system-setting secrets still stored in plaintext."""
+ changed = 0
+ for key in SettingsService.SECRET_KEYS:
+ setting = SystemSettings.query.filter_by(key=key).first()
+ if not setting or not setting.value:
+ continue
+ if not is_encrypted(setting.value):
+ setting.value = encrypt_secret(setting.value)
+ changed += 1
+ if changed:
+ db.session.commit()
+ return changed
@staticmethod
def initialize_defaults():