Cryptage RSA en Python

1. Cryptage RSA en Python à l’aide du cryptage simple
2. Chiffrement RSA en Python à l’aide du rembourrage cryptographique

Cet article explique différentes méthodes pour chiffrer et déchiffrer des données en Python à l’aide du module RSA.

La méthode de cryptographie asymétrique utilise une paire de clés (clé publique et clé privée) pour une conversation sécurisée entre deux personnes. L’avantage de la cryptographie asymétrique ou à clé publique est qu’elle fournit également une méthode pour garantir que le message n’est pas falsifié et qu’il est authentique.

Nous pouvons utiliser la cryptographie asymétrique en Python en utilisant le module RSA des manières suivantes.

Cryptage RSA en Python à l’aide du cryptage simple

Il existe deux manières d’effectuer un chiffrement asymétrique à l’aide du module RSA en Python : le chiffrement RSA simple et une méthode plus appropriée et sécurisée par remplissage cryptographique.

Dans le chiffrement RSA simple, nous pouvons générer une paire de clés et chiffrer les données à l’aide de la clé publique. Nous pouvons chiffrer les données à l’aide de la méthode _RSAobj.encrypt(), puis déchiffrer le message chiffré à l’aide de la méthode _RSAobj.decrypt().

Les deux méthodes _RSAobj.encrypt() et _RSAobj.decrypt() prennent une chaîne d’octets ou aussi longue que l’entrée et effectuent respectivement le chiffrement et le déchiffrement RSA en clair sur l’entrée.

L’exemple de code ci-dessous montre comment chiffrer et déchiffrer les données à l’aide du chiffrement RSA simple en Python.

import Crypto
from Crypto.PublicKey import RSA
import ast

keyPair = RSA.generate(1024)

pubKey = keyPair.publickey()

encryptedMsg = pubKey.encrypt(b"This is my secret msg", 32)
decryptedMsg = keyPair.decrypt(ast.literal_eval(str(encryptedMsg)))

print("Decrypted message:", decryptedMsg)

Remarque : En cas d’erreur lors de l’importation du module Crypto, vous pouvez l’installer à l’aide de la commande pip install pycrypto.

Chiffrement RSA en Python à l’aide du rembourrage cryptographique

Nous pouvons effectuer le chiffrement et le déchiffrement PKCS#1 OAEP en utilisant le module PKCS1_OAEP de Python. L’OAEP est un schéma de rembourrage de chiffrement asymétrique optimal publié par RSA et est plus sécurisé que le chiffrement RSA simple et primitif.

Pour réaliser le schéma OAEP, nous allons d’abord devoir générer l’objet PKCS1OAEP_Cipher puis appeler les méthodes PKCS1OAEP_Cipher.encrypt() et PKCS1OAEP_Cipher.decrypt() pour chiffrer ou déchiffrer le texte à l’aide de ce schéma. Si le texte d’entrée est de type chaîne, nous devrons d’abord le convertir en chaîne d’octets, car le type de chaîne n’est pas un type d’entrée valide.

Le code ci-dessous montre le cryptage OAEP en utilisant le module PKCS1_OAEP en Python.

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

key = RSA.generate(2048)
privateKey = key.exportKey("PEM")
publicKey = key.publickey().exportKey("PEM")

message = "this is a top secret message!"
message = str.encode(message)

RSApublicKey = RSA.importKey(publicKey)
OAEP_cipher = PKCS1_OAEP.new(RSApublicKey)
encryptedMsg = OAEP_cipher.encrypt(message)

print("Encrypted text:", encryptedMsg)

RSAprivateKey = RSA.importKey(privateKey)
OAEP_cipher = PKCS1_OAEP.new(RSAprivateKey)
decryptedMsg = OAEP_cipher.decrypt(encryptedMsg)

print("The original text:", decryptedMsg)

Remarque : En cas d’erreur lors de l’importation du module Crypto, vous pouvez l’installer à l’aide de la commande pip install pycrypto.