0Pricing
Cryptology Academy · Lección

Pares de claves RSA y ECDSA en Python

Genere, serialice y use claves RSA y EC para firmar y cifrar.

Pares de claves RSA y ECDSA en Python es una lección gratuita de Cryptology Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Cryptology Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Cryptology Academy incluye 4 lecciones en total.

Descripción general de las operaciones con pares de claves

La biblioteca cryptography de Python admite RSA y ECDSA para generar, firmar, verificar, serializar y cargar claves. Estos son los componentes básicos de los certificados TLS, la firma de código y los JWT.

Generación de un par de claves RSA

Mínimo recomendado: 2048 bits para obtener compatibilidad y 4096 bits para claves de larga duración:

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")

Firma RSA con PSS

Utilice siempre el relleno PSS para las firmas (no 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], "...")

Verificación de firmas RSA

La verificación genera InvalidSignature si falla:

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")

Generación de un par de claves ECDSA

ECDSA con NIST P-256 (secp256r1) proporciona una seguridad de 128 bits con claves mucho más pequeñas 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)

Firma y verificación ECDSA

ECDSA utiliza firmas codificadas en DER de forma predeterminada:

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")

Serialización de claves en PEM

Guarde las claves en archivos PEM para almacenarlas o distribuirlas:

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])

Carga de claves desde PEM

Cargue las claves persistidas de nuevo en objetos:

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)

Acuerdo de claves ECDH

Utilice ECDH para derivar un secreto compartido destinado al cifrado simétrico:

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())

Cifrado RSA con OAEP

Para cifrar cargas pequeñas (por ejemplo, una DEK) con RSA, utilice siempre 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)

Elección entre RSA y ECDSA

ECDSA: firmas más pequeñas (~71 bytes para P-256 frente a ~256 bytes para RSA-2048), firma más rápida y el mismo nivel de seguridad. RSA: mayor compatibilidad con sistemas heredados y un modelo mental más sencillo. Utilice ECDSA P-256 o Ed25519 en los sistemas nuevos.

Comprobación de conocimientos

¿Por qué debe preferirse RSA-PSS a PKCS#1 v1.5 para las firmas digitales?

Resumen de la lección

Utilice rsa.generate_private_key para RSA y ec.generate_private_key para ECDSA. Firme con PSS (RSA) o ECDSA + SHA-256. Serialice en PEM con el formato PKCS8 y cifrado mediante contraseña. Utilice ECDH para el acuerdo de claves. Prefiera ECDSA P-256 o Ed25519 en los sistemas nuevos.

Preguntas frecuentes

¿La lección «Pares de claves RSA y ECDSA en Python» es gratis?

Sí — el texto completo de «Pares de claves RSA y ECDSA en Python» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Cryptology Academy, actualiza a CoddyKit PRO. El curso de Cryptology Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Pares de claves RSA y ECDSA en Python»?

Genere, serialice y use claves RSA y EC para firmar y cifrar. Practicas Cryptology Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Cryptology Academy?

No se requiere experiencia previa. Cryptology Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Pares de claves RSA y ECDSA en Python»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Cryptology Academy?

Sí. Cada lección de Cryptology Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Introducción a la biblioteca cryptography de Python
  2. Cifrado y descifrado AES-GCM en Python
  3. Pares de claves RSA y ECDSA en Python
  4. Errores habituales de criptografía en Python y patrones seguros
← Volver a Cryptology Academy