Aller au contenu
🛠️ToolsShed

Générateur de Paire de Clés RSA

Génère des paires de clés RSA-2048 ou RSA-4096 au format PEM.

Les clés sont générées entièrement dans votre navigateur via l'API Web Crypto et ne sont jamais envoyées à un serveur.

À propos de cet outil

Un générateur de paires de clés RSA crée deux clés cryptographiques mathématiquement liées—une clé publique pour le chiffrement et une clé privée pour le déchiffrement—basées sur l'algorithme RSA (Rivest-Shamir-Adleman). Ces clés sont essentielles pour la communication sécurisée, les signatures numériques et l'authentification sur Internet. Que vous construisiez une API sécurisée, implémentez une authentification basée sur des certificats ou configuriez une messagerie chiffrée, un générateur de clés RSA fiable est un outil fondamental pour l'infrastructure de sécurité moderne.

Pour utiliser cet outil, sélectionnez simplement la taille de clé souhaitée (RSA-2048 ou RSA-4096), cliquez sur générer, et l'outil produira les deux clés au format PEM standard, prêtes à être utilisées immédiatement. RSA-2048 convient à la plupart des applications et fournit une sécurité robuste pour l'avenir prévisible, tandis que RSA-4096 offre une marge de sécurité supplémentaire au détriment d'opérations légèrement plus lentes. Après la génération, vous pouvez copier chaque clé séparément pour l'utiliser dans votre application, vos fichiers de configuration ou vos systèmes cryptographiques.

Questions Fréquentes

Implémentation du Code

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.