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.

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.py
index 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
@classmethod
def encrypt_value(cls, value):
- """Encrypt a value for storage."""
+ """Encrypt a value for storage (the ONE key path)."""
+ from app.utils.crypto import encrypt_secret
if value is None:
value = ''
- fernet = cls._get_fernet()
- return fernet.encrypt(value.encode()).decode()
+ return encrypt_secret(value)
@classmethod
def 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_secret
try:
- 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.py
index 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_secret
try:
- 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 None
diff --git a/backend/tests/test_crypto_fold_in.py b/backend/tests/test_crypto_fold_in.py
new file mode 100644
index 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'