utils/encryption_utils.py

"""
Flare – Fernet şifreleme yardımcıları
- encrypt(): düz string → "enc:<blob>"
- decrypt(): enc:<blob> → düz string (veya enc: yoksa aynen döner)
Anahtar: FLARE_TOKEN_KEY (32-bayt, base64, URL-safe)

CLI Kullanımı:
  python encryption_utils.py enc "şifrelenecek metin" [--key KEY]
  python encryption_utils.py dec "enc:..." [--key KEY]
"""

import os
import sys
import argparse
from typing import Optional
from cryptography.fernet import Fernet, InvalidToken
from .logger import log_error, log_warning

_ENV_KEY = "FLARE_TOKEN_KEY"


def _get_key() -> Fernet:
    """Get encryption key with better error messages"""
    # Direkt environment variable kullan
    key = os.getenv(_ENV_KEY)
    
    # .env dosyasından yüklemeyi dene
    if not key:
        try:
            from dotenv import load_dotenv
            load_dotenv()
            key = os.getenv(_ENV_KEY)
        except ImportError:
            pass
    
    if not key:
        error_msg = (
            f"{_ENV_KEY} ortam değişkeni tanımlanmadı. "
            f"Lütfen 32-byte base64 key oluşturun: python generate_key.py"
        )
        log_error(error_msg)
        raise RuntimeError(error_msg)
    
    # Key formatını kontrol et
    try:
        return Fernet(key.encode())
    except Exception as e:
        error_msg = (
            f"{_ENV_KEY} geçersiz format. "
            f"32-byte base64 URL-safe key olmalı. "
            f"Yeni key için: python generate_key.py"
        )
        log_error(error_msg, error=str(e))
        raise RuntimeError(error_msg)


def encrypt(plain: str, key: Optional[str] = None) -> str:
    """düz string → enc:..."""
    if not plain:
        log_warning("Empty string passed to encrypt")
        return ""
    
    try:
        if key:
            f = Fernet(key.encode())
        else:
            f = _get_key()
        
        encrypted = f.encrypt(plain.encode()).decode()
        return "enc:" + encrypted
    except Exception as e:
        log_error("Encryption failed", error=str(e))
        raise


def decrypt(value: Optional[str], key: Optional[str] = None) -> Optional[str]:
    """enc:... ise çözer, değilse aynen döndürür"""
    if value is None or not isinstance(value, str):
        return value
    
    if not value.startswith("enc:"):
        return value
    
    token = value.split("enc:", 1)[1]
    
    try:
        if key:
            f = Fernet(key.encode())
        else:
            f = _get_key()
        
        decrypted = f.decrypt(token.encode()).decode()
        return decrypted
    except InvalidToken:
        error_msg = (
            "Şifre çözme başarısız. Muhtemel sebepler:\n"
            "1. FLARE_TOKEN_KEY değişti\n"
            "2. Şifreli veri bozuldu\n"
            "3. Farklı bir key ile şifrelendi"
        )
        log_error(error_msg)
        raise RuntimeError(error_msg)
    except Exception as e:
        log_error("Decryption error", error=str(e))
        raise


def main():
    """CLI entry point"""
    parser = argparse.ArgumentParser(
        description="Fernet encryption/decryption utility",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
  # Encrypt with environment key
  python encryption_utils.py enc "secret message"
  
  # Encrypt with custom key
  python encryption_utils.py enc "secret message" --key "your-32-byte-base64-key"
  
  # Decrypt
  python encryption_utils.py dec "enc:gAAAAABh..."
  
  # Generate new key
  python -c "from cryptography.fernet import Fernet; print(Fernet.generate_key().decode())"
        """
    )
    
    parser.add_argument(
        "command",
        choices=["enc", "dec"],
        help="Command to execute: 'enc' for encrypt, 'dec' for decrypt"
    )
    
    parser.add_argument(
        "text",
        help="Text to encrypt or decrypt"
    )
    
    parser.add_argument(
        "--key",
        help="Optional Fernet key (32-byte base64). If not provided, uses FLARE_TOKEN_KEY env var"
    )
    
    args = parser.parse_args()
    
    try:
        if args.command == "enc":
            result = encrypt(args.text, args.key)
            print(result)
        else:  # dec
            result = decrypt(args.text, args.key)
            print(result)
    except Exception as e:
        print(f"Error: {e}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()