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(crypto): fold the parallel Fernet stacks into utils/crypto (plan 77 C2)
Juan Denis9860c6f34454
diff --git a/backend/app/models/env_variable.py b/backend/app/models/env_variable.pyindex 133b2b0b..b81f7198 100644--- a/backend/app/models/env_variable.py+++ b/backend/app/models/env_variable.py@@ -38,36 +38,44 @@ class EnvironmentVariable(TimestampMixin, JsonColumnMixin, db.Model):db.UniqueConstraint('application_id', 'key', name='unique_app_env_key'),)- # Class-level encryption key (generated from SECRET_KEY)- _fernet = None+ # One crypto path (plan 77 C2): new writes encrypt via utils/crypto+ # (SERVERKIT_ENCRYPTION_KEY). Reads dual-read: the one path first, then+ # the legacy SECRET_KEY-derived Fernet this model historically used —+ # rows written before the fold-in decrypt forever without a bulk+ # re-encrypt pass (the PR #94 postmortem records a decrypt-all→+ # re-encrypt-all attempt double-wrapping credentials; never again).+ # Rotating SECRET_KEY still bricks only legacy rows, exactly as before.+ _legacy_fernet = None@classmethod- def _get_fernet(cls):- """Get or create the Fernet encryption instance."""- if cls._fernet is None:- # Derive a 32-byte key from SECRET_KEY using SHA256+ def _get_legacy_fernet(cls):+ """The pre-C2 Fernet (key derived from SECRET_KEY via SHA256)."""+ if cls._legacy_fernet is None:secret_key = os.environ.get('SECRET_KEY', 'dev-secret-key-change-in-production')key = hashlib.sha256(secret_key.encode()).digest()- fernet_key = base64.urlsafe_b64encode(key)- cls._fernet = Fernet(fernet_key)- return cls._fernet+ cls._legacy_fernet = Fernet(base64.urlsafe_b64encode(key))+ return cls._legacy_fernet@classmethoddef encrypt_value(cls, value):- """Encrypt a value for storage."""+ """Encrypt a value for storage (the ONE key path)."""+ from app.utils.crypto import encrypt_secretif value is None:value = ''- fernet = cls._get_fernet()- return fernet.encrypt(value.encode()).decode()+ return encrypt_secret(value)@classmethoddef decrypt_value(cls, encrypted_value):- """Decrypt a stored value."""+ """Decrypt a stored value: one path first, legacy key second."""if not encrypted_value:return ''- fernet = cls._get_fernet()+ from app.utils.crypto import decrypt_secrettry:- return fernet.decrypt(encrypted_value.encode()).decode()+ return decrypt_secret(encrypted_value)+ except Exception:+ pass+ try:+ return cls._get_legacy_fernet().decrypt(encrypted_value.encode()).decode()except Exception:return '[DECRYPTION_ERROR]'diff --git a/backend/app/services/sso_service.py b/backend/app/services/sso_service.pyindex 4917cfbf..7455c9ac 100644--- a/backend/app/services/sso_service.py+++ b/backend/app/services/sso_service.py@@ -36,24 +36,33 @@ PROVIDER_ENDPOINTS = {}-def _get_fernet():- """Derive a Fernet key from SECRET_KEY."""+def _legacy_fernet():+ """The pre-C2 Fernet (key derived from app SECRET_KEY) — read-only,+ kept so tokens written before the fold-in still decrypt (plan 77 C2)."""key_bytes = current_app.config['SECRET_KEY'].encode('utf-8')digest = hashlib.sha256(key_bytes).digest()return Fernet(base64.urlsafe_b64encode(digest))def encrypt_token(token):+ """Encrypt via the ONE crypto path (utils/crypto)."""if not token:return None- return _get_fernet().encrypt(token.encode('utf-8')).decode('utf-8')+ from app.utils.crypto import encrypt_secret+ return encrypt_secret(token)def decrypt_token(encrypted):+ """Dual-read: the one path first, the legacy SECRET_KEY Fernet second."""if not encrypted:return None+ from app.utils.crypto import decrypt_secrettry:- return _get_fernet().decrypt(encrypted.encode('utf-8')).decode('utf-8')+ return decrypt_secret(encrypted)+ except Exception:+ pass+ try:+ return _legacy_fernet().decrypt(encrypted.encode('utf-8')).decode('utf-8')except Exception:return Nonediff --git a/backend/tests/test_crypto_fold_in.py b/backend/tests/test_crypto_fold_in.pynew file mode 100644index 00000000..67a44981--- /dev/null+++ b/backend/tests/test_crypto_fold_in.py@@ -0,0 +1,69 @@+"""Plan 77 C2 — the parallel Fernet stacks fold into utils/crypto.++New writes use the ONE key path (SERVERKIT_ENCRYPTION_KEY); reads dual-read+so rows/tokens written under the legacy SECRET_KEY-derived Fernet decrypt+forever — never a bulk decrypt-all -> re-encrypt-all pass (the PR #94+postmortem records that exact approach double-wrapping credentials).+"""+import base64+import hashlib++from cryptography.fernet import Fernet++from app.models.env_variable import EnvironmentVariable+from app.utils.crypto import decrypt_secret, is_encrypted+++def _legacy_ciphertext(plaintext, secret_key='dev-secret-key-change-in-production'):+ key = hashlib.sha256(secret_key.encode()).digest()+ return Fernet(base64.urlsafe_b64encode(key)).encrypt(plaintext.encode()).decode()+++def test_env_variable_new_writes_use_the_one_path(app):+ ciphertext = EnvironmentVariable.encrypt_value('hunter2')+ # decryptable by the ONE path directly — proof it is not the legacy key+ assert decrypt_secret(ciphertext) == 'hunter2'+ assert EnvironmentVariable.decrypt_value(ciphertext) == 'hunter2'+++def test_env_variable_legacy_rows_still_decrypt(app, monkeypatch):+ monkeypatch.setenv('SECRET_KEY', 'dev-secret-key-change-in-production')+ EnvironmentVariable._legacy_fernet = None # re-derive under the known key+ legacy = _legacy_ciphertext('old-value')+ assert not is_encrypted(legacy), 'sanity: legacy ciphertext is not one-path'+ assert EnvironmentVariable.decrypt_value(legacy) == 'old-value'+++def test_env_variable_corrupt_value_keeps_sentinel(app):+ assert EnvironmentVariable.decrypt_value('garbage') == '[DECRYPTION_ERROR]'+ assert EnvironmentVariable.decrypt_value('') == ''+++def test_env_variable_property_round_trip(app):+ var = EnvironmentVariable(key='K')+ var.value = 'plain'+ assert var.encrypted_value != 'plain'+ assert var.value == 'plain'+++def test_sso_tokens_fold_in(app, monkeypatch):+ from app.services import sso_service+ ciphertext = sso_service.encrypt_token('tok-123')+ assert decrypt_secret(ciphertext) == 'tok-123'+ assert sso_service.decrypt_token(ciphertext) == 'tok-123'++ with app.app_context():+ secret = app.config['SECRET_KEY']+ legacy = _legacy_ciphertext('tok-legacy', secret_key=secret)+ assert sso_service.decrypt_token(legacy) == 'tok-legacy'+ assert sso_service.decrypt_token('garbage') is None+ assert sso_service.decrypt_token(None) is None+++def test_shared_resources_ride_the_same_path(app):+ """shared_resource reuses EnvironmentVariable.encrypt/decrypt_value, so+ the fold-in covers it automatically — pin that indirection."""+ from app.models.shared_resource import SharedVariable+ sv = SharedVariable.__new__(SharedVariable)+ ciphertext = EnvironmentVariable.encrypt_value('shared-secret')+ assert decrypt_secret(ciphertext) == 'shared-secret'