| Path : /var/www/html/yedekledb24/DatabaseBackupMasterv7/ |
|
B-Con CMD Config cPanel C-Rdp D-Log Info Jump Mass Ransom Symlink vHost Zone-H |
| Current File : /var/www/html/yedekledb24/DatabaseBackupMasterv7/encryption_utils.py |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Veritabanı yedekleri için şifreleme yardımcı fonksiyonları.
Güncellenmiş GPG kütüphanesi uyumlu versiyon.
"""
import os
import logging
import tempfile
import gnupg
from pathlib import Path
# Logging yapılandırması
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)
def generate_gpg_key(name, email, passphrase=None, key_type="RSA", key_length=2048):
"""
GPG anahtar çifti oluşturur.
Args:
name (str): Anahtar sahibinin adı
email (str): Anahtar sahibinin e-posta adresi
passphrase (str, optional): Özel anahtar için şifre
key_type (str): Anahtar türü (RSA veya DSA)
key_length (int): Anahtar uzunluğu (bit cinsinden)
Returns:
dict: Oluşturulan anahtar bilgileri veya None (başarısız olursa)
"""
try:
# GPG home dizini oluştur (yoksa) - Uygulama konumunda
base_path = os.environ.get('GPG_HOME_DIR', os.path.dirname(os.path.abspath(__file__)))
gpg_home = os.path.join(base_path, 'gpg_keys')
os.makedirs(gpg_home, exist_ok=True)
# GnuPG nesnesi oluştur (basit yöntem)
gpg = gnupg.GPG(homedir=gpg_home)
gpg.ignore_homedir_permissions = True # İzin hataları için gerekli
# Anahtar üretim parametreleri
key_params = {
'key_type': key_type,
'key_length': key_length,
'name_real': name,
'name_email': email,
}
if passphrase:
key_params['passphrase'] = passphrase
# Anahtar üret
input_data = gpg.gen_key_input(**key_params)
key = gpg.gen_key(input_data)
if key:
# Anahtar bilgilerini döndür
fingerprint = key.fingerprint
pubkey = gpg.export_keys(fingerprint)
# Bazı GPG sürümlerinde passphrase parametresi desteklenmiyor
try:
privkey = gpg.export_keys(fingerprint, secret=True, passphrase=passphrase)
except TypeError:
# Eski GPG sürümleri için alternatif (passphrase parametresi olmadan)
privkey = gpg.export_keys(fingerprint, secret=True)
logger.info(f"GPG anahtar çifti oluşturuldu: {fingerprint}")
return {
'fingerprint': fingerprint,
'public_key': pubkey,
'private_key': privkey,
'name': name,
'email': email
}
else:
logger.error("GPG anahtar çifti oluşturulamadı")
return None
except Exception as e:
logger.error(f"GPG anahtar oluşturma hatası: {str(e)}")
return None
def encrypt_file(input_file, recipients=None, output_file=None, passphrase=None):
"""
Bir dosyayı GPG ile şifreler.
Args:
input_file (str): Şifrelenecek dosyanın yolu
recipients (list, optional): Alıcı e-posta adresleri listesi (anahtar ID'leri)
output_file (str, optional): Çıktı dosyasının yolu (belirtilmezse input_file + .gpg)
passphrase (str, optional): Şifreleme için şifre (symmetric encryption için)
Returns:
str: Şifrelenmiş dosyanın yolu veya None (başarısız olursa)
"""
try:
# Çıktı dosyası belirtilmemişse varsayılan kullan
if not output_file:
output_file = f"{input_file}.gpg"
# GPG home dizini - Çevre değişkeninden
base_path = os.environ.get('GPG_HOME_DIR', os.path.dirname(os.path.abspath(__file__)))
gpg_home = os.path.join(base_path, 'gpg_keys')
os.makedirs(gpg_home, exist_ok=True)
# GnuPG nesnesi (basit yöntem)
gpg = gnupg.GPG(homedir=gpg_home)
gpg.ignore_homedir_permissions = True # İzin hataları için gerekli
# Dosya içeriğini oku
with open(input_file, 'rb') as f:
data = f.read()
# Şifreleme yöntemi seç
if recipients:
# Asimetrik şifreleme (public key)
encrypted_data = gpg.encrypt(data, recipients, always_trust=True)
else:
# Simetrik şifreleme (passphrase)
encrypted_data = gpg.encrypt(data, None, passphrase=passphrase, symmetric=True)
# Şifreleme başarılı mı kontrol et
if encrypted_data.ok:
# Şifrelenmiş veriyi dosyaya yaz
with open(output_file, 'wb') as f:
f.write(encrypted_data.data)
logger.info(f"Dosya başarıyla şifrelendi: {output_file}")
return output_file
else:
logger.error(f"Dosya şifreleme hatası: {encrypted_data.status}")
if hasattr(encrypted_data, 'stderr'):
logger.error(f"Şifreleme hatası detayı: {encrypted_data.stderr}")
return None
except Exception as e:
logger.error(f"Dosya şifreleme işlemi sırasında hata: {str(e)}")
return None
def decrypt_file(input_file, output_file=None, passphrase=None):
"""
GPG ile şifrelenmiş bir dosyayı çözer.
Args:
input_file (str): Şifresi çözülecek dosyanın yolu
output_file (str, optional): Çıktı dosyasının yolu
passphrase (str, optional): Şifre çözme için şifre
Returns:
str: Şifresi çözülmüş dosyanın yolu veya None (başarısız olursa)
"""
try:
# Çıktı dosyası belirtilmemişse varsayılan kullan
if not output_file:
output_file = input_file.replace('.gpg', '')
if output_file == input_file: # .gpg uzantısı yoksa
output_file = f"{input_file}.decrypted"
# GPG home dizini - Çevre değişkeninden
base_path = os.environ.get('GPG_HOME_DIR', os.path.dirname(os.path.abspath(__file__)))
gpg_home = os.path.join(base_path, 'gpg_keys')
os.makedirs(gpg_home, exist_ok=True)
# GnuPG nesnesi (basit yöntem)
gpg = gnupg.GPG(homedir=gpg_home)
gpg.ignore_homedir_permissions = True # İzin hataları için gerekli
# Şifreli dosya içeriğini oku
with open(input_file, 'rb') as f:
encrypted_data = f.read()
# Şifreyi çöz
decrypted_data = gpg.decrypt(encrypted_data, passphrase=passphrase, always_trust=True)
# Şifre çözme başarılı mı kontrol et
if decrypted_data.ok:
# Çözülmüş veriyi dosyaya yaz
with open(output_file, 'wb') as f:
f.write(decrypted_data.data)
logger.info(f"Dosya şifresi başarıyla çözüldü: {output_file}")
return output_file
else:
logger.error(f"Dosya şifre çözme hatası: {decrypted_data.status}")
if hasattr(decrypted_data, 'stderr'):
logger.error(f"Şifre çözme hatası detayı: {decrypted_data.stderr}")
return None
except Exception as e:
logger.error(f"Şifre çözme sırasında hata oluştu: {str(e)}")
return None
def list_gpg_keys():
"""
Mevcut GPG anahtarlarını listeler.
Returns:
tuple: (public_keys, private_keys)
"""
try:
# GPG home dizini - Çevre değişkeninden
base_path = os.environ.get('GPG_HOME_DIR', os.path.dirname(os.path.abspath(__file__)))
gpg_home = os.path.join(base_path, 'gpg_keys')
os.makedirs(gpg_home, exist_ok=True)
# GnuPG nesnesi (basit yöntem)
gpg = gnupg.GPG(homedir=gpg_home)
gpg.ignore_homedir_permissions = True # İzin hataları için gerekli
# Anahtarları listele
public_keys = gpg.list_keys()
private_keys = gpg.list_keys(True)
return (public_keys, private_keys)
except Exception as e:
logger.error(f"GPG anahtarları listelenirken hata oluştu: {str(e)}")
return ([], [])
def import_gpg_key(key_data, private=False):
"""
GPG anahtarını içe aktarır.
Args:
key_data (str): Anahtar verisi (ASCII-armored)
private (bool): Özel anahtar mı?
Returns:
str: İçe aktarılan anahtarın parmak izi veya None
"""
try:
# GPG home dizini - Çevre değişkeninden
base_path = os.environ.get('GPG_HOME_DIR', os.path.dirname(os.path.abspath(__file__)))
gpg_home = os.path.join(base_path, 'gpg_keys')
os.makedirs(gpg_home, exist_ok=True)
# GnuPG nesnesi (basit yöntem)
gpg = gnupg.GPG(homedir=gpg_home)
gpg.ignore_homedir_permissions = True # İzin hataları için gerekli
# Anahtarı içe aktar
import_result = gpg.import_keys(key_data)
if import_result.count > 0:
logger.info(f"GPG anahtarı başarıyla içe aktarıldı: {import_result.fingerprints[0]}")
return import_result.fingerprints[0]
else:
logger.error("GPG anahtarı içe aktarılamadı")
return None
except Exception as e:
logger.error(f"GPG anahtarı içe aktarılırken hata oluştu: {str(e)}")
return None
def export_gpg_key(fingerprint, private=False, passphrase=None):
"""
GPG anahtarını dışa aktarır.
Args:
fingerprint (str): Dışa aktarılacak anahtarın parmak izi
private (bool): Özel anahtarı da dahil et
passphrase (str, optional): Özel anahtar için şifre
Returns:
str: Dışa aktarılan anahtar verisi (ASCII-armored) veya None
"""
try:
# GPG home dizini - Çevre değişkeninden
base_path = os.environ.get('GPG_HOME_DIR', os.path.dirname(os.path.abspath(__file__)))
gpg_home = os.path.join(base_path, 'gpg_keys')
os.makedirs(gpg_home, exist_ok=True)
# GnuPG nesnesi (basit yöntem)
gpg = gnupg.GPG(homedir=gpg_home)
gpg.ignore_homedir_permissions = True # İzin hataları için gerekli
# Anahtarı dışa aktar
try:
if private:
# Özel anahtar için şifre gerekebilir
key_data = gpg.export_keys(fingerprint, True, passphrase=passphrase)
else:
# Genel anahtar
key_data = gpg.export_keys(fingerprint)
if key_data:
logger.info(f"GPG anahtarı başarıyla dışa aktarıldı: {fingerprint}")
return key_data
else:
logger.error("GPG anahtarı dışa aktarılamadı")
return None
except TypeError:
# Bazı GPG sürümlerinde passphrase parametresi desteklenmiyor
if private:
key_data = gpg.export_keys(fingerprint, True)
else:
key_data = gpg.export_keys(fingerprint)
if key_data:
logger.info(f"GPG anahtarı başarıyla dışa aktarıldı: {fingerprint}")
return key_data
else:
logger.error("GPG anahtarı dışa aktarılamadı")
return None
except Exception as e:
logger.error(f"GPG anahtarı dışa aktarılırken hata oluştu: {str(e)}")
return None
def delete_gpg_key(fingerprint, private=False):
"""
GPG anahtarını siler.
Args:
fingerprint (str): Silinecek anahtarın parmak izi
private (bool): Özel anahtarı sil
Returns:
bool: Başarılı ise True, değilse False
"""
try:
# GPG home dizini - Çevre değişkeninden
base_path = os.environ.get('GPG_HOME_DIR', os.path.dirname(os.path.abspath(__file__)))
gpg_home = os.path.join(base_path, 'gpg_keys')
os.makedirs(gpg_home, exist_ok=True)
# GnuPG nesnesi (basit yöntem)
gpg = gnupg.GPG(homedir=gpg_home)
gpg.ignore_homedir_permissions = True # İzin hataları için gerekli
# Anahtarı sil
result = gpg.delete_keys(fingerprint, private)
if result.status == 'ok':
logger.info(f"GPG anahtarı başarıyla silindi: {fingerprint}")
return True
else:
logger.error(f"GPG anahtarı silinemedi: {result.status}")
return False
except Exception as e:
logger.error(f"GPG anahtarı silinirken hata oluştu: {str(e)}")
return False
# Geçici dosyaları temizleme fonksiyonu
def clean_gpg_temp_files():
"""
GPG ile ilgili geçici dosyaları temizler.
Returns:
int: Temizlenen dosya sayısı
"""
try:
count = 0
# Şifrelenmiş geçici dosyaları kontrol et
for file in Path(tempfile.gettempdir()).glob("*.gpg"):
try:
file.unlink()
count += 1
except:
pass
# Şifresi çözülmüş geçici dosyaları kontrol et
for file in Path(tempfile.gettempdir()).glob("*.decrypted"):
try:
file.unlink()
count += 1
except:
pass
logger.info(f"{count} geçici GPG dosyası temizlendi")
return count
except Exception as e:
logger.error(f"Geçici dosyalar temizlenirken hata oluştu: {str(e)}")
return 0
# Test fonksiyonu
def test_encryption():
"""
Şifreleme/şifre çözme işlevlerini test eder.
Returns:
bool: Test başarılı ise True, değilse False
"""
try:
# Geçici dosya oluştur
with tempfile.NamedTemporaryFile(delete=False) as temp:
temp.write(b"Bu bir test dosyasidir.")
temp_file = temp.name
# Simetrik şifreleme testi
password = "test123"
encrypted_file = encrypt_file(temp_file, passphrase=password)
if not encrypted_file:
logger.error("Şifreleme testi başarısız: Dosya şifrelenemedi")
return False
# Şifre çözme testi
decrypted_file = decrypt_file(encrypted_file, passphrase=password)
if not decrypted_file:
logger.error("Şifre çözme testi başarısız: Dosya şifresi çözülemedi")
return False
# Orijinal ve şifresi çözülmüş dosyaları karşılaştır
with open(temp_file, 'rb') as f1, open(decrypted_file, 'rb') as f2:
if f1.read() == f2.read():
logger.info("Şifreleme/şifre çözme testi başarılı")
# Temizlik
if os.path.exists(temp_file):
os.remove(temp_file)
if os.path.exists(encrypted_file):
os.remove(encrypted_file)
if os.path.exists(decrypted_file):
os.remove(decrypted_file)
return True
else:
logger.error("Şifre çözme testi başarısız: Dosya içeriği eşleşmiyor")
return False
except Exception as e:
logger.error(f"Şifreleme testi sırasında hata oluştu: {str(e)}")
return False
# Ana fonksiyon (doğrudan çalıştırılırsa)
if __name__ == "__main__":
print("GPG şifreleme modülü test ediliyor...")
success = test_encryption()
print(f"Test sonucu: {'Başarılı' if success else 'Başarısız'}")