Cryptage et décryptage avec PyCrypto AES 256

Question

J'essaie de construire deux fonctions utilisant PyCrypto qui acceptent deux paramètres : le message et la clé, puis chiffrent/déchiffrent le message.

J'ai trouvé plusieurs liens sur le web pour m'aider, mais chacun d'entre eux a des défauts :

Celui-ci à codekoala utilise os.urandom, ce qui est déconseillé par PyCrypto.

De plus, la clé que je donne à la fonction n'est pas garantie d'avoir la longueur exacte attendue. Que puis-je faire pour que cela se produise ?

De plus, il existe plusieurs modes, lequel est recommandé ? Je ne sais pas quoi utiliser :/

Enfin, qu'est-ce que l'IV exactement ? Puis-je fournir un IV différent pour le cryptage et le décryptage, ou cela donnera-t-il un résultat différent ?

Modifier : Suppression de la partie code car elle n'était pas sécurisée.

Answer 1

Voici ma mise en œuvre et fonctionne pour moi avec quelques corrections et améliore l'alignement de la clé et la phrase secrète avec 32 octets et iv à 16 octets :

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 self._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:])]

Answer 2

Vous pouvez avoir besoin des deux fonctions suivantes : pad - pour le remplissage (lors du cryptage) et unpad - pour décompacter (lors du décryptage) lorsque la longueur de l'entrée n'est pas un multiple de BLOCK_SIZE.

BS = 16
pad = lambda s: s + (BS - len(s) % BS) * chr(BS - len(s) % BS) 
unpad = lambda s : s[:-ord(s[len(s)-1:])]

Donc vous demandez la longueur de la clé ? Vous pouvez utiliser le md5sum de la clé plutôt que de l'utiliser directement.

De plus, selon ma petite expérience de l'utilisation de PyCrypto, l'IV est utilisé pour mélanger la sortie d'un cryptage lorsque l'entrée est la même, donc l'IV est choisi comme une chaîne aléatoire, et l'utiliser comme une partie de la sortie de cryptage, et ensuite l'utiliser pour décrypter le message.

Et voici ma mise en œuvre, j'espère qu'elle vous sera utile :

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

class AESCipher:
    def __init__( self, key ):
        self.key = key

    def encrypt( self, raw ):
        raw = 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 ) ) 

    def decrypt( self, enc ):
        enc = base64.b64decode(enc)
        iv = enc[:16]
        cipher = AES.new(self.key, AES.MODE_CBC, iv )
        return unpad(cipher.decrypt( enc[16:] ))

Answer 3

Vous pouvez obtenir une phrase de passe à partir d'un mot de passe arbitraire en utilisant une fonction de hachage cryptographique ( PAS La fonction intégrée de Python hash ) comme SHA-1 ou SHA-256. Python inclut le support des deux dans sa bibliothèque standard :

import hashlib

hashlib.sha1("this is my awesome password").digest() # => a 20 byte string
hashlib.sha256("another awesome password").digest() # => a 32 byte string

Vous pouvez tronquer une valeur de hachage cryptographique en utilisant simplement [:16] ou [:24] et il conservera sa sécurité jusqu'à la longueur que vous indiquez.

Answer 4

Pour le bénéfice des autres, voici mon implémentation de décryptage à laquelle j'ai abouti en combinant les réponses de @Cyril et @Marcus. Cela suppose que le message arrive via une requête HTTP avec le texte crypté cité et encodé en base64.

import base64
import urllib2
from Crypto.Cipher import AES

def decrypt(quotedEncodedEncrypted):
    key = 'SecretKey'

    encodedEncrypted = urllib2.unquote(quotedEncodedEncrypted)

    cipher = AES.new(key)
    decrypted = cipher.decrypt(base64.b64decode(encodedEncrypted))[:16]

    for i in range(1, len(base64.b64decode(encodedEncrypted))/16):
        cipher = AES.new(key, AES.MODE_CBC, base64.b64decode(encodedEncrypted)[(i-1)*16:i*16])
        decrypted += cipher.decrypt(base64.b64decode(encodedEncrypted)[i*16:])[:16]

    return decrypted.strip()

Answer 5

Les fonctions pad et unpad, telles que décrites ci-dessus, ne fonctionnent que pour les entrées de type octet. Si l'entrée est une chaîne unicode, elle doit d'abord être convertie en type octet.