Python'da RSA ve ECDSA Anahtar Çiftleri

from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.backends import default_backend

private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048,
    backend=default_backend()
)
public_key = private_key.public_key()
print("RSA key generated, size:", private_key.key_size, "bits")

from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import padding

message = b"document to sign"
signature = private_key.sign(
    message,
    padding.PSS(
        mgf=padding.MGF1(hashes.SHA256()),
        salt_length=padding.PSS.MAX_LENGTH
    ),
    hashes.SHA256()
)
print("RSA-PSS signature:", signature.hex()[:32], "...")

from cryptography.exceptions import InvalidSignature

try:
    public_key.verify(
        signature,
        message,
        padding.PSS(
            mgf=padding.MGF1(hashes.SHA256()),
            salt_length=padding.PSS.MAX_LENGTH
        ),
        hashes.SHA256()
    )
    print("Signature valid!")
except InvalidSignature:
    print("Signature INVALID")

from cryptography.hazmat.primitives.asymmetric import ec

private_key = ec.generate_private_key(ec.SECP256R1())
public_key = private_key.public_key()
print("EC private key generated on curve:", private_key.curve.name)

from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives import hashes
from cryptography.exceptions import InvalidSignature

# Sign
sig = private_key.sign(b"my data", ec.ECDSA(hashes.SHA256()))
print("ECDSA signature bytes:", len(sig))

# Verify
try:
    public_key.verify(sig, b"my data", ec.ECDSA(hashes.SHA256()))
    print("ECDSA signature valid")
except InvalidSignature:
    print("Invalid")

from cryptography.hazmat.primitives import serialization

# Private key — encrypted with passphrase
private_pem = private_key.private_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PrivateFormat.PKCS8,
    encryption_algorithm=serialization.BestAvailableEncryption(b"strong-passphrase")
)

# Public key — no encryption
public_pem = public_key.public_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PublicFormat.SubjectPublicKeyInfo
)
print(public_pem.decode()[:64])

from cryptography.hazmat.primitives.serialization import (
    load_pem_private_key, load_pem_public_key
)

with open("ec_private.pem", "rb") as f:
    priv = load_pem_private_key(f.read(), password=b"strong-passphrase")

with open("ec_public.pem", "rb") as f:
    pub = load_pem_public_key(f.read())

print("Loaded EC key curve:", priv.curve.name)

from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.hkdf import HKDF

alice_priv = ec.generate_private_key(ec.SECP256R1())
bob_priv = ec.generate_private_key(ec.SECP256R1())

# Alice computes shared secret
shared = alice_priv.exchange(ec.ECDH(), bob_priv.public_key())
aes_key = HKDF(hashes.SHA256(), 32, None, b"app-context").derive(shared)
print("Derived AES key:", aes_key.hex())

from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.hazmat.primitives import hashes

# Encrypt with public key
ciphertext = public_key.encrypt(
    b"small secret",
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)

# Decrypt with private key
plaintext = private_key.decrypt(ciphertext, padding.OAEP(
    mgf=padding.MGF1(algorithm=hashes.SHA256()),
    algorithm=hashes.SHA256(), label=None
))
print("Decrypted:", plaintext)