Criptografía en Python - RSA

Instalación de pycryptodome

python3 -m pip install pycryptodome 

También es recomendable no tener instalado pycrypto, que como se
mencionó pycryptodome, es una bifurcación mucho mejor de él. En
caso de tenerlo instalado, igualmente con un simple comando se debería
desinstalar:

python3 -m pip uninstall pycrypto

OJO: Todo el tutorial estará hecho para la versión 3 y se debe
tener instalado el paquete python-dev y
build-essential para su versión de python correspondiente, use su
gestor de paquetes en caso de no tenerlo instalado. Como generalmente se
usan distribuciones basadas en Debian o Arch Linux, aquí unos simples
comandos orientativos:

# Debian
sudo apt-get install build-essential python3-dev
# Arch Linux
sudo pacman -S base-devel

# General
python3 -m pip install pycryptodome

Generando el par de claves

import sys
from Crypto.PublicKey import RSA # Importamos el módulo RSA

# El usuario (o sea nosotros) tiene que pasar un número mayor
# o igual 1024 y usando el objeto 'int' convertirmos un string
# a un entero.
bit_size = int(sys.argv[1])
key_format = sys.argv[2]

# Generamos el par de claves. Dependiendo del tamaño y el
# procesamiento de nuestro computador es lo que podrá tardar.
keys = RSA.generate(bit_size)

print("Clave Pública:")
# Exportamos la clave pública y la imprimimos. Colocamos como
# argumento 'nn' en el parámetro 'end' de la función 'print'
# para imprimir dos saltos de líneas y se vea más legible.
#
# 'key_format' se explicará en unos instantes
#
# Usamos el método '.decode(...)' porque al exportarlos estarán
# en 'bytes' y es mejor (para volverlo legible) tenerlo en 'utf-8'.
print(keys.publickey().export_key(key_format).decode(), end='nn')

print("Clave Privada:")
# Hacemos prácticamente lo mismo que lo anterior, pero a diferencia
# de la exportación de la clave pública, no se necesita explicitar
# ningún método.
print(keys.export_key(key_format).decode())

El código está comentado para que vayan comprendiendo cada cosa. Ahora
pasemos a ejecutar el script para verlo detenidamente.

No solo es recomendable, es un deber el usar claves mayor o igual que
2048, 1024 ya se considera inseguro, tampoco hay que abusar del tamaño, yo
recomiendo 2048 o 3072 bits, aunque la siguiente tabla enumera el tamaño
de algunos algoritmos para mantener una seguridad mayor a 2030:

Sobre los formatos, existen tres formatos para usar con pycryptodome: PEM
(el predeterminado) que es la codificación basada en texto (útil si se
quiere compartir por algún servicio como correo electrónico); OpenSSH,
también es una codificación textual que sigue la especificación OpenSSH;
por último, DER, codificación binaria.

En la última imagen se puede apreciar claramente un error, un carácter
inválido para 'utf-8', pero simplemente quitando el método
'.decode(...)' de la línea 13 y 17, permitiría mostrar los datos:

Cifrado con RSA

Aquí el script:

import sys
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP

bit_size = int(sys.argv[1])
key_format = sys.argv[2]
# El usuario (o sea nosotros) pasaremos un texto
# arbitrario para después cifrarlo y descifrarlo.
text2cipher = sys.argv[3]

keys = RSA.generate(bit_size)

# Importamos la clave pública para cifrar los datos
cipher_rsa = PKCS1_OAEP.new(keys.publickey())
# Importamos la clave privada para descifrar los datos
decipher_rsa = PKCS1_OAEP.new(keys)

# Ciframos los datos.
#
# Se deben codificar los datos a 'utf-8', por eso está
# presente el método '.encode(...)'
enc_data = cipher_rsa.encrypt(text2cipher.encode())
# Desciframos los datos
dec_data = decipher_rsa.decrypt(enc_data)

print("Encriptado:")
print(enc_data, end='nn')

print("Desencriptado:")
print(dec_data)

Básicamente es el mismo que el primero, y se comentó solo lo necesario para que se tenga una mejor compresión. Por cierto, el script no es muy realista en cuanto a lo que se hace en la vida real, ya que cada vez que lo ejecutemos se va a generar el par de claves y luego se va a cifrar y descifrar el dato. En las próximas entregas se mostrarán algunos trucos para realizar un script realista a lo que se hace en la vida real (como almacenar claves, importarlas, etcétera).

También tengo que aclarar que no se puede cifrar o descifrar datos que fueron codificados con una clave de tamaño superior a la de su generación, pero no ha de haber preocupaciones, en las próximas entregas se enseñará cómo quitar esa limitación.

Lecturas recomendadas

Los siguientes enlaces les servirán si quieren aprender mucho más y prepararse fluidamente para lo que vendrán en las siguientes partes:

• https://pycryptodome.readthedocs.io
• https://es.wikipedia.org/wiki/RSA
• https://es.qwe.wiki/wiki/Key_size

Me despido, espero hayan aprendido tanto como yo lo hice.

~ DtxdF