Paires de clés RSA et ECDSA en Python
Générez, sérialisez et utilisez des clés RSA et EC pour signer et chiffrer.
Paires de clés RSA et ECDSA en Python est une leçon Cryptology Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Cryptology Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Cryptology Academy comprend 4 leçons au total.
Vue d'ensemble des opérations sur les paires de clés
La bibliothèque cryptography de Python prend en charge RSA et ECDSA pour générer, signer, vérifier, sérialiser et charger des clés. Ces éléments constituent la base des certificats TLS, de la signature de code et des JWT.
Générer une paire de clés RSA
Minimum recommandé : 2048 bits pour la compatibilité, 4096 bits pour les clés conservées longtemps :
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")Signer avec RSA-PSS
Utilisez toujours le remplissage PSS pour les signatures, et non 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], "...")Vérifier une signature RSA
La vérification lève InvalidSignature en cas d'échec :
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")Générer une paire de clés ECDSA
ECDSA avec NIST P-256 (secp256r1) offre une sécurité de 128 bits avec des clés bien plus petites que 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)Signer et vérifier avec ECDSA
ECDSA utilise par défaut des signatures encodées en DER :
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")Sérialiser des clés en PEM
Enregistrez les clés dans des fichiers PEM pour les stocker ou les distribuer :
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])Charger des clés depuis PEM
Rechargez les clés persistantes dans des objets :
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)Accord de clé ECDH
Utilisez ECDH pour dériver un secret partagé destiné au chiffrement symétrique :
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())Chiffrement RSA avec OAEP
Pour chiffrer de petites données, par exemple un DEK, avec RSA, utilisez toujours 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)Choisir entre RSA et ECDSA
ECDSA : signatures plus petites (environ 71 octets pour P-256 contre environ 256 octets pour RSA-2048), signature plus rapide et même niveau de sécurité. RSA : prise en charge plus large des systèmes anciens et modèle mental plus simple. Pour les nouveaux systèmes, utilisez ECDSA P-256 ou Ed25519.
Vérification des connaissances
Pourquoi RSA-PSS doit-il être préféré à PKCS#1 v1.5 pour les signatures numériques ?
Récapitulatif de la leçon
Utilisez rsa.generate_private_key pour RSA et ec.generate_private_key pour ECDSA. Signez avec PSS (RSA) ou avec ECDSA + SHA-256. Sérialisez les clés en PEM au format PKCS8 et protégez-les par chiffrement avec une phrase secrète. Utilisez ECDH pour l'accord de clé. Pour les nouveaux systèmes, privilégiez ECDSA P-256 ou Ed25519.
Questions Fréquemment Posées
La leçon « Paires de clés RSA et ECDSA en Python » est-elle gratuite ?
Oui — le texte complet de « Paires de clés RSA et ECDSA en Python » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Cryptology Academy, passe à CoddyKit PRO. Le cours Cryptology Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Paires de clés RSA et ECDSA en Python » ?
Générez, sérialisez et utilisez des clés RSA et EC pour signer et chiffrer. Tu pratiques Cryptology Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Cryptology Academy ?
Aucune expérience préalable n'est requise. Cryptology Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.
Combien de temps prend la leçon « Paires de clés RSA et ECDSA en Python » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Cryptology Academy ?
Oui. Chaque leçon Cryptology Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Présentation de la bibliothèque de cryptographie Python
- Chiffrer et déchiffrer avec AES-GCM en Python
- Paires de clés RSA et ECDSA en Python
- Pièges courants de la cryptographie Python et pratiques sécurisées