Zum Inhalt springen
🛠️ToolsShed

RSA-Schlüsselpaar-Generator

Generiert RSA-2048 oder RSA-4096 Schlüsselpaare im PEM-Format.

Schlüssel werden vollständig in Ihrem Browser mit der Web Crypto API generiert und nie an einen Server gesendet.

Über dieses Tool

Ein RSA-Schlüsselpaar-Generator erstellt zwei mathematisch verknüpfte kryptographische Schlüssel—einen öffentlichen Schlüssel zum Verschlüsseln und einen privaten Schlüssel zum Entschlüsseln—basierend auf dem RSA-Algorithmus (Rivest-Shamir-Adleman). Diese Schlüssel sind für sichere Kommunikation, digitale Signaturen und Authentifizierung im Internet unverzichtbar. Unabhängig davon, ob Sie eine sichere API entwickeln, zertifikatbasierte Authentifizierung implementieren oder verschlüsselte Nachrichten einrichten, ist ein zuverlässiger RSA-Schlüsselgenerator ein grundlegendes Werkzeug für moderne Sicherheitsinfrastruktur.

Um dieses Werkzeug zu nutzen, wählen Sie einfach die gewünschte Schlüsselgröße (RSA-2048 oder RSA-4096), klicken Sie auf Generieren, und das Werkzeug erstellt beide Schlüssel im Standard-PEM-Format, sofort einsatzbereit. RSA-2048 ist für die meisten Anwendungen geeignet und bietet starke Sicherheit für die absehbare Zukunft, während RSA-4096 auf Kosten etwas langsamerer Operationen einen zusätzlichen Sicherheitsspielraum bietet. Nach der Generierung können Sie jeden Schlüssel separat kopieren, um ihn in Ihrer Anwendung, Konfigurationsdateien oder kryptographischen Systemen zu verwenden.

Häufig gestellte Fragen

Code-Implementierung

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

# Generate RSA key pair
def generate_rsa_key_pair(
    key_size: int = 2048,
    public_exponent: int = 65537,
) -> tuple[rsa.RSAPrivateKey, rsa.RSAPublicKey]:
    private_key = rsa.generate_private_key(
        public_exponent=public_exponent,
        key_size=key_size,
        backend=default_backend(),
    )
    return private_key, private_key.public_key()

# Serialize to PEM
def private_key_to_pem(key: rsa.RSAPrivateKey, password: bytes | None = None) -> str:
    encryption = (
        serialization.BestAvailableEncryption(password)
        if password else serialization.NoEncryption()
    )
    return key.private_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PrivateFormat.PKCS8,
        encryption_algorithm=encryption,
    ).decode()

def public_key_to_pem(key: rsa.RSAPublicKey) -> str:
    return key.public_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PublicFormat.SubjectPublicKeyInfo,
    ).decode()

# Sign and verify
def sign(message: bytes, private_key: rsa.RSAPrivateKey) -> bytes:
    return private_key.sign(message, padding.PKCS1v15(), hashes.SHA256())

def verify(message: bytes, signature: bytes, public_key: rsa.RSAPublicKey) -> bool:
    try:
        public_key.verify(signature, message, padding.PKCS1v15(), hashes.SHA256())
        return True
    except Exception:
        return False


if __name__ == "__main__":
    priv, pub = generate_rsa_key_pair(2048)
    print(private_key_to_pem(priv))
    print(public_key_to_pem(pub))

    msg = b"Hello, RSA!"
    sig = sign(msg, priv)
    print("Signature valid:", verify(msg, sig, pub))

Comments & Feedback

Comments are powered by Giscus. Sign in with GitHub to leave a comment.