Comment implémenter le cryptage et le déchiffrement sécurisés AES-256 en Python ?

Cryptage et déchiffrement avec PyCrypto AES-256

Pour construire des fonctions de cryptage et de déchiffrement efficaces à l'aide de PyCrypto qui opèrent sur un message et une clé, certaines considérations doivent être prises en compte.

Alignement des clés et Entropie :

Il est crucial de s'assurer que la clé fournie a la longueur attendue. PyCrypto suggère d'utiliser une clé forte d'une longueur de 32 octets. Pour y parvenir, hachez la clé avec SHA-256 et utilisez le résumé obtenu comme clé de cryptage.

Modes de cryptage :

Pour le cryptage AES, Cipher Block Chaining ( Le mode CBC) est couramment utilisé. Il offre une sécurité supplémentaire en combinant des blocs successifs de texte chiffré avec un vecteur d'initialisation (IV).

Vecteur d'initialisation (IV) :

Le IV est une valeur aléatoire qui est ajouté au texte chiffré lors du chiffrement. Il garantit le caractère unique de chaque message chiffré et empêche les attaquants d'utiliser des modèles dans le texte chiffré. Vous pouvez fournir différents IV pour le cryptage et le déchiffrement, mais il est essentiel d'utiliser un IV unique pour chaque opération de cryptage.

Implémentation :

L'exemple d'implémentation ci-dessous intègre ces considérations :

import base64
import hashlib
from Crypto import Random
from Crypto.Cipher import AES

class AESCipher(object):

    def __init__(self, key):
        self.bs = AES.block_size
        self.key = hashlib.sha256(key.encode()).digest()

    def encrypt(self, raw):
        raw = self._pad(raw)
        iv = Random.new().read(AES.block_size)
        cipher = AES.new(self.key, AES.MODE_CBC, iv)
        return base64.b64encode(iv + cipher.encrypt(raw.encode()))

    def decrypt(self, enc):
        enc = base64.b64decode(enc)
        iv = enc[:AES.block_size]
        cipher = AES.new(self.key, AES.MODE_CBC, iv)
        return AESCipher._unpad(cipher.decrypt(enc[AES.block_size:])).decode('utf-8')

    def _pad(self, s):
        return s + (self.bs - len(s) % self.bs) * chr(self.bs - len(s) % self.bs)

    @staticmethod
    def _unpad(s):
        return s[:-ord(s[len(s)-1:])]

Cette implémentation garantit que la clé est hachée en toute sécurité sur 32 octets, utilise le mode CBC pour le cryptage et génère un IV aléatoire pendant le cryptage. La fonction de décryptage récupère le IV du texte chiffré et l'utilise pour inverser le processus de cryptage.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!