mirror of
https://github.com/lintsinghua/DeepAudit.git
synced 2026-11-21 20:56:55 +08:00
145 lines
4.0 KiB
Python
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)
|
|
|