Cryptology Academy · Lección

Errores habituales de criptografía en Python y patrones seguros

Evite las claves codificadas directamente, el modo ECB, las comparaciones que no son de tiempo constante y otros errores.

Errores habituales de criptografía en Python y patrones seguros es una lección gratuita de Cryptology Academy en CoddyKit. Esta es la lección 4 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.

Los errores criptográficos más peligrosos

Es fácil utilizar la criptografía de forma incorrecta. Los errores más comunes en Python son: claves codificadas de forma fija, modo ECB, comparaciones que no son de tiempo constante, aleatoriedad débil, reutilización de claves o nonces e implementación de criptografía propia.

Error 1: claves codificadas de forma fija

Nunca incluya claves en el código fuente. Terminan en el historial de git, los registros y los mensajes de error. Utilice variables de entorno o un KMS:

# WRONG
SECRET_KEY = b"my_secret_key_12"  # visible in git!

# RIGHT
import os
SECRET_KEY = os.environb.get(b"SECRET_KEY") or os.urandom(32)
# Or load from KMS at startup

Error 2: modo ECB

AES-ECB cifra cada bloque de forma independiente; los bloques de texto sin cifrar idénticos producen bloques de texto cifrado idénticos. El ataque del «pingüino de ECB» revela patrones en imágenes y datos estructurados. Utilice siempre GCM o CBC con un IV aleatorio.

# WRONG — never use ECB
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
cipher = Cipher(algorithms.AES(key), modes.ECB())  # insecure!

# RIGHT
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
aesgcm = AESGCM(key)  # authenticated encryption

Error 3: comparación de MAC que no es de tiempo constante

Utilizar == para comparar MAC filtra información temporal. Utilice siempre hmac.compare_digest:

import hmac

# WRONG — leaks timing
if received_mac == expected_mac:
    pass

# RIGHT — constant-time
if hmac.compare_digest(received_mac, expected_mac):
    pass

Error 4: generación débil de números aleatorios

Nunca utilice el módulo random con fines criptográficos; no es un CSPRNG. Utilice secrets o os.urandom:

import random, secrets, os

# WRONG
key = bytes([random.randint(0, 255) for _ in range(32)])  # predictable!

# RIGHT
key = os.urandom(32)          # OS CSPRNG
token = secrets.token_bytes(32)  # secrets module wrapper

Error 5: reutilización de IV o nonce

Reutilizar un IV con CBC o un nonce con GCM rompe la seguridad. Genere un IV o nonce aleatorio nuevo para cada cifrado y almacénelo junto al texto cifrado:

import os
from cryptography.hazmat.primitives.ciphers.aead import AESGCM

key = AESGCM.generate_key(bit_length=256)
aesgcm = AESGCM(key)

# WRONG — fixed nonce
nonce = b"\x00" * 12  # reuse breaks GCM!

# RIGHT — fresh nonce every time
nonce = os.urandom(12)
ciphertext = aesgcm.encrypt(nonce, b"data", None)

Error 6: utilizar MD5 o SHA-1 para la seguridad

MD5 y SHA-1 están criptográficamente obsoletos para la resistencia a colisiones. Nunca los utilice para firmas digitales, huellas digitales de certificados o HMAC. Utilice SHA-256 o SHA-3-256.

Error 7: implementar criptografía propia

Implementar primitivas criptográficas desde cero casi siempre introduce errores sutiles. Utilice los paquetes cryptography, PyNaCl o PyCA. Nunca implemente AES, RSA o ECDSA por su cuenta.

Patrón seguro: PyNaCl para criptografía de alto nivel

PyNaCl encapsula la biblioteca NaCl/libsodium, una API basada en opiniones y difícil de utilizar incorrectamente:

# pip install PyNaCl
import nacl.secret
import nacl.utils

key = nacl.utils.random(nacl.secret.SecretBox.KEY_SIZE)
box = nacl.secret.SecretBox(key)

encrypted = box.encrypt(b"my secret message")
decrypted = box.decrypt(encrypted)
print("Decrypted:", decrypted)  # Uses XSalsa20-Poly1305

Patrón seguro: hash de contraseñas con Argon2

Utilice argon2-cffi para aplicar hash a las contraseñas; nunca utilice SHA-256 ni bcrypt directamente:

# pip install argon2-cffi
from argon2 import PasswordHasher

ph = PasswordHasher(time_cost=3, memory_cost=65536, parallelism=4)
hash_val = ph.hash("user_password")
print("Hash:", hash_val[:40], "...")

# Verify
try:
    ph.verify(hash_val, "user_password")
    print("Password correct")
except Exception:
    print("Wrong password")

Puesta a cero de claves

Después de utilizar una clave en memoria, ponga sus datos a cero para reducir el intervalo de exposición a ataques de volcado de memoria. El recolector de basura de Python lo dificulta; utilice ctypes o PyNaCl, que lo gestiona automáticamente.

Comprobación de conocimientos

¿Qué función de Python debe utilizarse en lugar de == al comparar MAC criptográficos?

Resumen de la lección

Evite las claves codificadas de forma fija, el modo ECB, == para comparar MAC, el módulo random y la reutilización de nonces. Utilice os.urandom/secrets para la aleatoriedad, AESGCM para el cifrado y hmac.compare_digest para la verificación. PyNaCl y argon2-cffi proporcionan API seguras de alto nivel para la criptografía simétrica y las contraseñas.

Preguntas frecuentes

¿La lección «Errores habituales de criptografía en Python y patrones seguros» es gratis?

Sí — el texto completo de «Errores habituales de criptografía en Python y patrones seguros» 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 «Errores habituales de criptografía en Python y patrones seguros»?

Evite las claves codificadas directamente, el modo ECB, las comparaciones que no son de tiempo constante y otros errores. 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 4 de 4.

¿Cuánto tiempo toma la lección «Errores habituales de criptografía en Python y patrones seguros»?

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

Introducción a la biblioteca cryptography de Python
Cifrado y descifrado AES-GCM en Python
Pares de claves RSA y ECDSA en Python
Errores habituales de criptografía en Python y patrones seguros

← Volver a Cryptology Academy