Phase 0 Complete: Tasks 0.7-0.20

- 0.7: UI-Design-Richtlinien (docs/ui-design-guidelines.md, 535 lines)
- 0.8: Theme-Customization Backend (4 theme fields, migration 0023)
- 0.9: Theme-Customization Frontend (SettingsTheme.tsx, themeStore.ts, live preview)
- 0.10: RBAC-Audit (4 plugins secured, 53 routes with require_permission)
- 0.11: LiteLLM-Cleanup (llm_client.py migrated from httpx to litellm)
- 0.12: KI-Agent-Framework docs (plugin-development-guide.md, agent_capabilities field)
- 0.13: Heartbeat configurable (ProactiveSettings, migration 0024, frontend UI)
- 0.14: Unified Search Field-Level RBAC (resolve_permissions + filter_fields_by_permission)
- 0.15: Undo/History-System (EntityHistory model, service, routes, migration 0025, HistoryViewer)
- 0.16: Storage Backend (LocalStorage + S3Storage, DMS/attachments/mail updated)
- 0.17: Import/Export unified Contact fields (firstname, surname, email_1, phone_1)
- 0.18: .gitignore & Config-Cleanup (webui→frontend, python-jose removed, .env untracked)
- 0.19: Mail-Salt Security-Fix (per-account random salt, migration 0026)
- 0.20: AGPL replaced (PyMuPDF→pypdf, OnlyOffice→Collabora, LICENSE + THIRD_PARTY_LICENSES.md)

app/plugins/builtins/mail/services.py

@@ -134,9 +134,12 @@ def attachment_to_response(att: MailAttachment) -> dict:
 
 MAIL_ENCRYPTION_KEY = os.environ.get("MAIL_ENCRYPTION_KEY", "leocrm-mail-encryption-key-2024")
 
+# Legacy salt for backward compatibility with existing encrypted passwords
+_LEGACY_SALT = b"leocrm-mail-salt"
 
-def _derive_key(password: str, salt: bytes = b"leocrm-mail-salt") -> bytes:
-    """Derive a 32-byte Fernet key from a password using PBKDF2."""
+
+def _derive_key(password: str, salt: bytes) -> bytes:
+    """Derive a 32-byte Fernet key from a password using PBKDF2 with the given salt."""
     kdf = PBKDF2HMAC(
         algorithm=hashes.SHA256(),
         length=32,
@@ -146,17 +149,39 @@ def _derive_key(password: str, salt: bytes = b"leocrm-mail-salt") -> bytes:
     return base64.urlsafe_b64encode(kdf.derive(password.encode()))
 
 
-_fernet = Fernet(_derive_key(MAIL_ENCRYPTION_KEY))
+def generate_salt() -> str:
+    """Generate a random 32-byte salt and return as base64 string."""
+    salt = os.urandom(32)
+    return base64.urlsafe_b64encode(salt).decode()
 
 
-def encrypt_password(plaintext: str) -> str:
-    """Encrypt a password using AES-256 (Fernet). Returns base64 ciphertext."""
-    return _fernet.encrypt(plaintext.encode()).decode()
+def _get_fernet(salt_b64: str | None = None) -> Fernet:
+    """Get a Fernet instance. If salt_b64 is provided, use it; otherwise use legacy salt."""
+    if salt_b64:
+        salt = base64.urlsafe_b64decode(salt_b64.encode())
+    else:
+        salt = _LEGACY_SALT
+    return Fernet(_derive_key(MAIL_ENCRYPTION_KEY, salt))
 
 
-def decrypt_password(ciphertext: str) -> str:
-    """Decrypt a password encrypted with encrypt_password."""
-    return _fernet.decrypt(ciphertext.encode()).decode()
+def encrypt_password(plaintext: str, salt_b64: str | None = None) -> str:
+    """Encrypt a password using AES-256 (Fernet). Returns base64 ciphertext.
+
+    If salt_b64 is provided, uses that salt for key derivation.
+    If not, uses the legacy hardcoded salt (for backward compatibility).
+    """
+    fernet = _get_fernet(salt_b64)
+    return fernet.encrypt(plaintext.encode()).decode()
+
+
+def decrypt_password(ciphertext: str, salt_b64: str | None = None) -> str:
+    """Decrypt a password encrypted with encrypt_password.
+
+    If salt_b64 is provided, uses that salt for key derivation.
+    If not, uses the legacy hardcoded salt (for backward compatibility).
+    """
+    fernet = _get_fernet(salt_b64)
+    return fernet.decrypt(ciphertext.encode()).decode()
 
 
 # ─── HTML Sanitization (F-MAIL: no script tags) ───
@@ -255,6 +280,7 @@ async def create_mail_account(
     db: AsyncSession, *, tenant_id: uuid.UUID, user_id: uuid.UUID, data: dict
 ) -> MailAccount:
     """Create a new mail account with encrypted password."""
+    salt = generate_salt()
     account = MailAccount(
         tenant_id=tenant_id,
         user_id=user_id,
@@ -267,7 +293,8 @@ async def create_mail_account(
         smtp_port=data.get("smtp_port", 587),
         smtp_tls=data.get("smtp_tls", True),
         username=data.get("username") or data["email_address"],
-        encrypted_password=encrypt_password(data["password"]),
+        encrypted_password=encrypt_password(data["password"], salt),
+        password_salt=salt,
         is_shared=data.get("is_shared", False),
         is_active=True,
         sent_folder_imap_name=data.get("sent_folder_imap_name"),
@@ -333,15 +360,20 @@ async def update_mail_account(db: AsyncSession, account: MailAccount, data: dict
         if api_field in data and data[api_field] is not None:
             setattr(account, model_field, data[api_field])
     if "password" in data and data["password"] is not None:
-        account.encrypted_password = encrypt_password(data["password"])
+        new_salt = generate_salt()
+        account.password_salt = new_salt
+        account.encrypted_password = encrypt_password(data["password"], new_salt)
     await db.flush()
     await db.refresh(account)
     return account
 
 
 async def get_account_password(account: MailAccount) -> str:
-    """Decrypt and return the account password (internal use only)."""
-    return decrypt_password(account.encrypted_password)
+    """Decrypt and return the account password (internal use only).
+
+    Uses per-account salt if available, falls back to legacy salt for old accounts.
+    """
+    return decrypt_password(account.encrypted_password, account.password_salt or None)
 
 
 def account_to_response(account: MailAccount) -> dict: