📋 Genel Bakış

crypto modülü, modern kriptografi algoritmaları ile veri şifreleme, karma fonksiyonları, dijital imzalar ve güvenli anahtar yönetimi için kapsamlı araçlar sağlar. AES, RSA, SHA, HMAC ve daha fazlasını destekler.

💡 Kullanım Örnekleri

kullan crypto
kullan encoding

// AES-256-GCM şifreleme (kimlik doğrulamalı)
değer mesaj = "Bu çok gizli bir mesajdır!"
değer anahtar = crypto.rastgele_bayt(32)  // 256-bit anahtar
değer nonce = crypto.rastgele_bayt(12)    // 96-bit nonce

yazdır("Orijinal mesaj: " + mesaj)

// Şifreleme
değer şifreli = crypto.aes_gcm_şifrele(
    veri: mesaj.bayt(),
    anahtar: anahtar,
    nonce: nonce
)

değer şifreli_base64 = encoding.base64_kodla(şifreli)
yazdır(f"\nŞifreli (Base64): {şifreli_base64}")

// Şifre çözme
değer çözülmüş = crypto.aes_gcm_çöz(
    veri: şifreli,
    anahtar: anahtar,
    nonce: nonce
).aç()

değer çözülmüş_metin = Dize.bayttan(çözülmüş)
yazdır(f"Çözülmüş mesaj: {çözülmüş_metin}")

// Anahtar ve nonce'ı güvenli sakla
yazdır(f"\nAnahtar (hex): {encoding.hex_kodla(anahtar)}")
yazdır(f"Nonce (hex): {encoding.hex_kodla(nonce)}")

kullan crypto

// RSA anahtar çifti oluşturma (2048-bit)
değer (açık_anahtar, özel_anahtar) = crypto.rsa_anahtar_çifti_oluştur(2048)

yazdır("RSA anahtar çifti oluşturuldu!")

// Açık anahtarla şifreleme
değer mesaj = "Gizli veriler: hesap bakiyesi = 10000 TL"
değer şifreli = crypto.rsa_şifrele(mesaj.bayt(), açık_anahtar)

yazdır(f"\nMesaj şifrelendi ({şifreli.uzunluk} bayt)")

// Özel anahtarla şifre çözme
değer çözülmüş = crypto.rsa_çöz(şifreli, özel_anahtar).aç()
değer çözülmüş_metin = Dize.bayttan(çözülmüş)

yazdır(f"Çözülmüş: {çözülmüş_metin}")

// Dijital imza oluşturma
değer imza = crypto.rsa_imzala(mesaj.bayt(), özel_anahtar)
yazdır(f"\nDijital imza oluşturuldu ({imza.uzunluk} bayt)")

// İmza doğrulama
değer geçerli = crypto.rsa_doğrula(mesaj.bayt(), imza, açık_anahtar)
eğer geçerli {
    yazdır("✓ İmza geçerli!")
} yoksa {
    yazdır("✗ İmza geçersiz!")
}

kullan crypto
kullan time

sınıf ParolaYöneticisi {
    değer parola_karmaları: Sözlük<Dize, Dize>
    
    fonksiyon yeni() -> ParolaYöneticisi {
        dön ParolaYöneticisi {
            parola_karmaları: {}
        }
    }
    
    fonksiyon kullanıcı_ekle(kullanıcı_adı: Dize, parola: Dize) -> Sonuç<Boş, Hata> {
        // Parola gücünü kontrol et
        eğer parola.uzunluk < 8 {
            dön Hata("Parola en az 8 karakter olmalı")
        }
        
        // Argon2id ile güvenli karma oluştur
        değer başlangıç = time.şimdi()
        değer karma = crypto.parola_karma(parola, maliyet: 15)
        değer süre = time.şimdi() - başlangıç
        
        bu.parola_karmaları[kullanıcı_adı] = karma
        yazdır(f"Parola karması oluşturuldu ({süre.milisaniye}ms)")
        
        dön Tamam(boş)
    }
    
    fonksiyon giriş_yap(kullanıcı_adı: Dize, parola: Dize) -> Mantıksal {
        eğer kullanıcı_adı !içinde bu.parola_karmaları {
            dön yanlış
        }
        
        değer karma = bu.parola_karmaları[kullanıcı_adı]
        değer başlangıç = time.şimdi()
        değer geçerli = crypto.parola_doğrula(parola, karma)
        değer süre = time.şimdi() - başlangıç
        
        yazdır(f"Parola doğrulama: {süre.milisaniye}ms")
        dön geçerli
    }
}

// Kullanım
değer yönetici = ParolaYöneticisi.yeni()

// Kullanıcı ekleme
yönetici.kullanıcı_ekle("ahmet", "Güçlü_P@rol@_123").aç()
yönetici.kullanıcı_ekle("ayşe", "Başka_Güçlü_P@ss").aç()

// Giriş denemeleri
yazdır("\n--- Giriş Denemeleri ---")

eğer yönetici.giriş_yap("ahmet", "Güçlü_P@rol@_123") {
    yazdır("✓ Ahmet başarıyla giriş yaptı")
} yoksa {
    yazdır("✗ Giriş başarısız")
}

eğer yönetici.giriş_yap("ahmet", "yanlış_parola") {
    yazdır("✓ Giriş başarılı")
} yoksa {
    yazdır("✗ Yanlış parola!")
}

kullan crypto
kullan fs
kullan encoding

sınıf DosyaŞifreleyici {
    fonksiyon dosya_şifrele(
        kaynak: Dize,
        hedef: Dize,
        parola: Dize
    ) -> Sonuç<Boş, Hata> {
        // Dosyayı oku
        değer içerik = fs.dosya_oku(kaynak)?
        
        // Parola'dan anahtar türet
        değer tuz = crypto.rastgele_bayt(16)
        değer anahtar = crypto.pbkdf2(
            parola.bayt(),
            tuz,
            iterasyon: 100000,
            uzunluk: 32
        )
        
        // Şifreleme için nonce oluştur
        değer nonce = crypto.rastgele_bayt(12)
        
        // AES-GCM ile şifrele
        değer şifreli = crypto.aes_gcm_şifrele(
            veri: içerik,
            anahtar: anahtar,
            nonce: nonce
        )
        
        // Dosya formatı: [TUZ:16][NONCE:12][ŞİFRELİ_VERİ]
        değer çıktı = tuz + nonce + şifreli
        fs.dosya_yaz(hedef, çıktı)?
        
        yazdır(f"✓ Dosya şifrelendi: {kaynak} -> {hedef}")
        yazdır(f"  Boyut: {içerik.uzunluk} -> {çıktı.uzunluk} bayt")
        
        dön Tamam(boş)
    }
    
    fonksiyon dosya_çöz(
        kaynak: Dize,
        hedef: Dize,
        parola: Dize
    ) -> Sonuç<Boş, Hata> {
        // Şifreli dosyayı oku
        değer veri = fs.dosya_oku(kaynak)?
        
        // Tuz ve nonce'ı ayıkla
        değer tuz = veri[0..16]
        değer nonce = veri[16..28]
        değer şifreli = veri[28..]
        
        // Parola'dan anahtar türet
        değer anahtar = crypto.pbkdf2(
            parola.bayt(),
            tuz,
            iterasyon: 100000,
            uzunluk: 32
        )
        
        // Şifreyi çöz
        değer içerik = crypto.aes_gcm_çöz(
            veri: şifreli,
            anahtar: anahtar,
            nonce: nonce
        )?
        
        // Dosyaya yaz
        fs.dosya_yaz(hedef, içerik)?
        
        yazdır(f"✓ Dosya çözüldü: {kaynak} -> {hedef}")
        yazdır(f"  Boyut: {veri.uzunluk} -> {içerik.uzunluk} bayt")
        
        dön Tamam(boş)
    }
}

// Kullanım
değer şifreleyici = DosyaŞifreleyici {}

// Dosya şifreleme
şifreleyici.dosya_şifrele(
    "gizli_belgeler.pdf",
    "gizli_belgeler.pdf.enc",
    "çok_güçlü_parola_123"
).aç()

// Dosya çözme
şifreleyici.dosya_çöz(
    "gizli_belgeler.pdf.enc",
    "gizli_belgeler_çözülmüş.pdf",
    "çok_güçlü_parola_123"
).aç()

🎯 İyi Uygulamalar

• Asla özel anahtarları veya parolaları sabit kodlamayın
• Kimlik doğrulamalı şifreleme için AES-GCM kullanın
• Parola karması için Argon2id veya bcrypt tercih edin
• Rastgele sayı üretimi için crypto.rastgele_bayt() kullanın
• RSA için en az 2048-bit anahtar boyutu kullanın
• Anahtarları güvenli anahtar yönetim sistemlerinde saklayın
• Düzenli olarak anahtarları döndürün
• Eski kriptografi algoritmalarından (MD5, SHA1, DES) kaçının

⚠️ Güvenlik Uyarıları

• 🔴 Özel anahtarları asla paylaşmayın veya kaynak koduna eklemeyin
• 🔴 Parola veya anahtar üretiminde standart random kullanmayın
• 🔴 Şifreli verileri değiştirme saldırılarına karşı HMAC veya GCM kullanın
• 🔴 Hassas verileri bellekte tutarken dikkatli olun (bellek dökümleri)

🔗 İlgili Modüller

• encoding - Base64, Hex kodlama
• fs - Dosya sistemi işlemleri
• random - Rastgele sayı üretimi
• http - HTTPS ve TLS