Files
2025-11-09 12:35:20 +00:00

145 lines
4.0 KiB
Python

"""Encryption utilities for sensitive data like API keys"""
import base64
import os
from cryptography.fernet import Fernet
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
from cryptography.hazmat.backends import default_backend
from loguru import logger
from app.config import settings
class EncryptionService:
"""Service for encrypting and decrypting sensitive data"""
_instance = None
_fernet = None
def __new__(cls):
if cls._instance is None:
cls._instance = super().__new__(cls)
return cls._instance
def __init__(self):
if self._fernet is None:
self._initialize_encryption()
def _initialize_encryption(self):
"""Initialize Fernet encryption with a key derived from settings"""
# Get encryption key from environment or generate one
encryption_key = getattr(settings, 'ENCRYPTION_KEY', None)
if not encryption_key:
# Use SECRET_KEY as fallback
secret_key = settings.SECRET_KEY
# Derive a 32-byte key using PBKDF2HMAC
kdf = PBKDF2HMAC(
algorithm=hashes.SHA256(),
length=32,
salt=b'xcodereview_salt_v1', # Static salt for key derivation
iterations=100000,
backend=default_backend()
)
key = base64.urlsafe_b64encode(kdf.derive(secret_key.encode()))
self._fernet = Fernet(key)
logger.info("🔐 Initialized encryption service using derived key")
else:
self._fernet = Fernet(encryption_key.encode())
logger.info("🔐 Initialized encryption service using ENCRYPTION_KEY")
def encrypt(self, plaintext: str) -> str:
"""
Encrypt plaintext string.
Args:
plaintext: String to encrypt
Returns:
Encrypted string (base64 encoded)
"""
if not plaintext:
return ""
try:
encrypted_bytes = self._fernet.encrypt(plaintext.encode())
return encrypted_bytes.decode('utf-8')
except Exception as e:
logger.error(f"Encryption error: {e}")
raise
def decrypt(self, encrypted_text: str) -> str:
"""
Decrypt encrypted string.
Args:
encrypted_text: Encrypted string (base64 encoded)
Returns:
Decrypted plaintext string
"""
if not encrypted_text:
return ""
try:
decrypted_bytes = self._fernet.decrypt(encrypted_text.encode())
return decrypted_bytes.decode('utf-8')
except Exception as e:
logger.error(f"Decryption error: {e}")
raise
def encrypt_api_key(self, api_key: str) -> str:
"""
Encrypt API key for storage.
Args:
api_key: API key to encrypt
Returns:
Encrypted API key
"""
return self.encrypt(api_key)
def decrypt_api_key(self, encrypted_api_key: str) -> str:
"""
Decrypt API key from storage.
Args:
encrypted_api_key: Encrypted API key
Returns:
Decrypted API key
"""
return self.decrypt(encrypted_api_key)
# Singleton instance
encryption_service = EncryptionService()
def encrypt_api_key(api_key: str) -> str:
"""
Encrypt API key for storage.
Args:
api_key: Plain API key
Returns:
Encrypted API key
"""
return encryption_service.encrypt_api_key(api_key)
def decrypt_api_key(encrypted_api_key: str) -> str:
"""
Decrypt API key from storage.
Args:
encrypted_api_key: Encrypted API key
Returns:
Plain API key
"""
return encryption_service.decrypt_api_key(encrypted_api_key)