Permettez-moi de répondre à votre question sur les «modes». AES256 est une sorte de chiffrement par blocs . Il prend en entrée une clé de 32 octets et une chaîne de 16 octets, appelée le bloc et génère un bloc. Nous utilisons AES dans un mode de fonctionnement afin de crypter. Les solutions ci-dessus suggèrent d'utiliser CBC, qui en est un exemple. Un autre est appelé CTR, et il est un peu plus facile à utiliser:
from Crypto.Cipher import AES
from Crypto.Util import Counter
from Crypto import Random
# AES supports multiple key sizes: 16 (AES128), 24 (AES192), or 32 (AES256).
key_bytes = 32
# Takes as input a 32-byte key and an arbitrary-length plaintext and returns a
# pair (iv, ciphtertext). "iv" stands for initialization vector.
def encrypt(key, plaintext):
assert len(key) == key_bytes
# Choose a random, 16-byte IV.
iv = Random.new().read(AES.block_size)
# Convert the IV to a Python integer.
iv_int = int(binascii.hexlify(iv), 16)
# Create a new Counter object with IV = iv_int.
ctr = Counter.new(AES.block_size * 8, initial_value=iv_int)
# Create AES-CTR cipher.
aes = AES.new(key, AES.MODE_CTR, counter=ctr)
# Encrypt and return IV and ciphertext.
ciphertext = aes.encrypt(plaintext)
return (iv, ciphertext)
# Takes as input a 32-byte key, a 16-byte IV, and a ciphertext, and outputs the
# corresponding plaintext.
def decrypt(key, iv, ciphertext):
assert len(key) == key_bytes
# Initialize counter for decryption. iv should be the same as the output of
# encrypt().
iv_int = int(iv.encode('hex'), 16)
ctr = Counter.new(AES.block_size * 8, initial_value=iv_int)
# Create AES-CTR cipher.
aes = AES.new(key, AES.MODE_CTR, counter=ctr)
# Decrypt and return the plaintext.
plaintext = aes.decrypt(ciphertext)
return plaintext
(iv, ciphertext) = encrypt(key, 'hella')
print decrypt(key, iv, ciphertext)
Ceci est souvent appelé AES-CTR. Je conseillerais la prudence en utilisant AES-CBC avec PyCrypto . La raison en est qu'il vous oblige à spécifier le schéma de remplissage , comme illustré par les autres solutions données. En général, si vous ne faites pas très attention au rembourrage, il existe des attaques qui cassent complètement le cryptage!
Maintenant, il est important de noter que la clé doit être une chaîne aléatoire de 32 octets ; un mot de passe ne suffit pas . Normalement, la clé est générée comme ceci:
# Nominal way to generate a fresh key. This calls the system's random number
# generator (RNG).
key1 = Random.new().read(key_bytes)
Une clé peut également être dérivée d'un mot de passe :
# It's also possible to derive a key from a password, but it's important that
# the password have high entropy, meaning difficult to predict.
password = "This is a rather weak password."
# For added # security, we add a "salt", which increases the entropy.
#
# In this example, we use the same RNG to produce the salt that we used to
# produce key1.
salt_bytes = 8
salt = Random.new().read(salt_bytes)
# Stands for "Password-based key derivation function 2"
key2 = PBKDF2(password, salt, key_bytes)
Certaines solutions ci-dessus suggèrent d'utiliser SHA256 pour dériver la clé, mais cela est généralement considéré comme une mauvaise pratique cryptographique . Consultez wikipedia pour en savoir plus sur les modes de fonctionnement.