RSA- und ECDSA-Schlüsselpaare in Python
Erzeugen, serialisieren und verwenden Sie RSA- und EC-Schlüssel zum Signieren und Verschlüsseln.
RSA- und ECDSA-Schlüsselpaare in Python ist eine kostenlose Cryptology Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Cryptology Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Cryptology Academy-Kurs umfasst insgesamt 4 Lektionen.
Überblick über Schlüsselpa operationen
Die Python-Bibliothek cryptography unterstützt RSA und ECDSA zum Generieren, Signieren, Verifizieren, Serialisieren und Laden von Schlüsseln. Diese Verfahren bilden die Grundlage für TLS-Zertifikate, Codesignierung und JWTs.
RSA-Schlüsselpaar generieren
Mindestens empfohlen: 2048 Bit für Kompatibilität, 4096 Bit für langlebige Schlüssel:
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")RSA-Signierung mit PSS
Verwenden Sie für Signaturen immer PSS-Padding (nicht PKCS#1 v1.5):
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], "...")RSA-Signatur verifizieren
Bei einem Fehler löst die Verifizierung InvalidSignature aus:
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")ECDSA-Schlüsselpaar generieren
ECDSA mit NIST P-256 (secp256r1) bietet 128 Bit Sicherheit und benötigt deutlich kleinere Schlüssel als RSA-3072:
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)ECDSA-Signierung und -Verifizierung
ECDSA verwendet standardmäßig DER-kodierte Signaturen:
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")Schlüssel in PEM serialisieren
Speichern Sie Schlüssel zur Aufbewahrung oder Verteilung in PEM-Dateien:
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])Schlüssel aus PEM laden
Laden Sie gespeicherte Schlüssel wieder in Objekte:
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)ECDH-Schlüsselvereinbarung
Verwenden Sie ECDH, um ein gemeinsames Geheimnis für die symmetrische Verschlüsselung abzuleiten:
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())RSA-Verschlüsselung mit OAEP
Verwenden Sie zum Verschlüsseln kleiner Nutzdaten (z. B. eines DEK) mit RSA immer OAEP:
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)RSA oder ECDSA auswählen
ECDSA: kleinere Signaturen (etwa 71 Byte bei P-256 gegenüber etwa 256 Byte bei RSA-2048), schnelleres Signieren, gleiches Sicherheitsniveau. RSA: breitere Unterstützung in Altsystemen, einfacheres Verständnis. Verwenden Sie für neue Systeme ECDSA P-256 oder Ed25519.
Wissenscheck
Warum sollte RSA-PSS gegenüber PKCS#1 v1.5 für digitale Signaturen bevorzugt werden?
Zusammenfassung der Lektion
Verwenden Sie rsa.generate_private_key für RSA und ec.generate_private_key für ECDSA. Signieren Sie mit PSS (RSA) oder ECDSA + SHA-256. Serialisieren Sie Schlüssel im PKCS8-Format mit Passphrasenverschlüsselung in PEM. Verwenden Sie ECDH zur Schlüsselvereinbarung. Bevorzugen Sie für neue Systeme ECDSA P-256 oder Ed25519.
Häufig gestellte Fragen
Ist die Lektion „RSA- und ECDSA-Schlüsselpaare in Python“ kostenlos?
Ja — der vollständige Text von „RSA- und ECDSA-Schlüsselpaare in Python“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Cryptology Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Cryptology Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „RSA- und ECDSA-Schlüsselpaare in Python“?
Erzeugen, serialisieren und verwenden Sie RSA- und EC-Schlüssel zum Signieren und Verschlüsseln. Du übst Cryptology Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Cryptology Academy zu starten?
Keine Vorkenntnisse erforderlich. Cryptology Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.
Wie lange dauert die Lektion „RSA- und ECDSA-Schlüsselpaare in Python“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Cryptology Academy-Lektion Code schreiben und ausführen?
Ja. Jede Cryptology Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Überblick über die Python-cryptography-Bibliothek
- AES-GCM in Python ver- und entschlüsseln
- RSA- und ECDSA-Schlüsselpaare in Python
- Häufige Python-Krypto-Fallen und sichere Muster