Hafta 13: Kriptografi Temelleri

🎯 Öğrenme Hedefleri

Bu haftanın sonunda:

• Simetrik şifreleme (AES) uygulayabileceksiniz
• Asimetrik şifreleme (RSA, ECC) anlayacaksınız
• Otomotiv kriptografi uygulamalarını kavrayacaksınız

---

1. Simetrik Şifreleme (AES)

#!/usr/bin/env python3
"""
AES Şifreleme - Otomotiv Uygulaması
"""

from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.backends import default_backend
import os

class AESCrypto:
    """AES-GCM şifreleme sınıfı."""
    
    def __init__(self, key: bytes = None):
        self.key = key or os.urandom(32)  # AES-256
    
    def encrypt(self, plaintext: bytes) -> tuple:
        """AES-GCM ile şifrele."""
        nonce = os.urandom(12)  # 96-bit nonce
        cipher = Cipher(
            algorithms.AES(self.key),
            modes.GCM(nonce),
            backend=default_backend()
        )
        encryptor = cipher.encryptor()
        ciphertext = encryptor.update(plaintext) + encryptor.finalize()
        return nonce, ciphertext, encryptor.tag
    
    def decrypt(self, nonce: bytes, ciphertext: bytes, tag: bytes) -> bytes:
        """AES-GCM ile çöz."""
        cipher = Cipher(
            algorithms.AES(self.key),
            modes.GCM(nonce, tag),
            backend=default_backend()
        )
        decryptor = cipher.decryptor()
        return decryptor.update(ciphertext) + decryptor.finalize()

# Demo
if __name__ == "__main__":
    print("🔐 AES-256-GCM Demo")
    print("=" * 50)
    
    crypto = AESCrypto()
    
    # Firmware verisi simülasyonu
    firmware_chunk = b"ECU_FIRMWARE_V2.4.1_BUILD_20260224"
    
    # Şifrele
    nonce, ciphertext, tag = crypto.encrypt(firmware_chunk)
    print(f"Plaintext: {firmware_chunk}")
    print(f"Ciphertext: {ciphertext.hex()[:40]}...")
    print(f"Tag: {tag.hex()}")
    
    # Çöz
    decrypted = crypto.decrypt(nonce, ciphertext, tag)
    print(f"Decrypted: {decrypted}")
    print(f"
✅ Başarılı: {firmware_chunk == decrypted}")

---

2. Asimetrik Şifreleme (RSA/ECC)

#!/usr/bin/env python3
"""
RSA ve ECC - Dijital İmzalar
"""

from cryptography.hazmat.primitives.asymmetric import rsa, ec, padding
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.backends import default_backend

class RSACrypto:
    """RSA imzalama."""
    
    def __init__(self, key_size: int = 2048):
        self.private_key = rsa.generate_private_key(
            public_exponent=65537,
            key_size=key_size,
            backend=default_backend()
        )
        self.public_key = self.private_key.public_key()
    
    def sign(self, data: bytes) -> bytes:
        """Veriyi imzala."""
        return self.private_key.sign(
            data,
            padding.PSS(
                mgf=padding.MGF1(hashes.SHA256()),
                salt_length=padding.PSS.MAX_LENGTH
            ),
            hashes.SHA256()
        )
    
    def verify(self, data: bytes, signature: bytes) -> bool:
        """Imzayı doğrula."""
        try:
            self.public_key.verify(
                signature, data,
                padding.PSS(
                    mgf=padding.MGF1(hashes.SHA256()),
                    salt_length=padding.PSS.MAX_LENGTH
                ),
                hashes.SHA256()
            )
            return True
        except Exception:
            return False

class ECCCrypto:
    """ECDSA imzalama (daha hızlı, kısa anahtar)."""
    
    def __init__(self):
        self.private_key = ec.generate_private_key(
            ec.SECP256R1(),  # P-256 curve
            default_backend()
        )
        self.public_key = self.private_key.public_key()
    
    def sign(self, data: bytes) -> bytes:
        return self.private_key.sign(data, ec.ECDSA(hashes.SHA256()))
    
    def verify(self, data: bytes, signature: bytes) -> bool:
        try:
            self.public_key.verify(signature, data, ec.ECDSA(hashes.SHA256()))
            return True
        except Exception:
            return False

# Demo
if __name__ == "__main__":
    print("🔑 RSA vs ECDSA Karşılaştırma")
    print("=" * 50)
    
    firmware = b"FIRMWARE_HASH_" + os.urandom(32)
    
    # RSA
    import time
    rsa_crypto = RSACrypto(2048)
    start = time.time()
    rsa_sig = rsa_crypto.sign(firmware)
    rsa_time = time.time() - start
    print(f"RSA-2048 imza: {len(rsa_sig)} bytes, {rsa_time*1000:.2f}ms")
    
    # ECDSA
    ecc_crypto = ECCCrypto()
    start = time.time()
    ecc_sig = ecc_crypto.sign(firmware)
    ecc_time = time.time() - start
    print(f"ECDSA P-256 imza: {len(ecc_sig)} bytes, {ecc_time*1000:.2f}ms")
    
    print(f"
✅ ECDSA {len(rsa_sig)//len(ecc_sig)}x daha kısa imza üretir")

---

📚 Kaynaklar

• Python cryptography
• NIST SP 800-38D (GCM)