PyCrypto problème à l'aide d'AES+CTR

La counter doivent retourner le même sur le déchiffrement comme il l'a fait sur le cryptage, comme vous intuit, donc, un (PAS SÉCURISÉ À TOUS les) façon de le faire est:

>>> secret = os.urandom(16)
>>> crypto = AES.new(os.urandom(32), AES.MODE_CTR, counter=lambda: secret)
>>> encrypted = crypto.encrypt("aaaaaaaaaaaaaaaa")
>>> print crypto.decrypt(encrypted)
aaaaaaaaaaaaaaaa

CTR est une bloc de chiffrement, de sorte que le "16-à-un-temps" contrainte qui semble vous surprendre est assez naturel.

Bien sûr, un soi-disant "contre" le retour de la même valeur à chaque appel est extrêmement précaire. Ne prend pas beaucoup de faire mieux, de l'e.g....:

import array

class Secret(object):
  def __init__(self, secret=None):
    if secret is None: secret = os.urandom(16)
    self.secret = secret
    self.reset()
  def counter(self):
    for i, c in enumerate(self.current):
      self.current[i] = c + 1
      if self.current: break
    return self.current.tostring()
  def reset(self):
    self.current = array.array('B', self.secret)

secret = Secret()
crypto = AES.new(os.urandom(32), AES.MODE_CTR, counter=secret.counter)
encrypted = crypto.encrypt(16*'a' + 16*'b' + 16*'c')
secret.reset()
print crypto.decrypt(encrypted)

OriginalL'auteur Alex Martelli

pourquoi il faut qu'elle soit 16 octets lors de ma clé est de 32 octets

Il doit être de la même longueur que le chiffre de la taille de bloc. CTR mode crypte le comptoir et XORs le texte en clair avec la chiffré bloc compteur.

Notes:

1. la valeur du compteur DOIT être unique -- si JAMAIS vous utilisez la même valeur de compteur pour chiffrer les deux plaintexts sous la même clé, vous venez de donner suite à votre clé.
2. comme l'an IV, le compteur n'est PAS secret -- envoyez-le avec le texte chiffré. Si vous rendre le code plus compliqué en essayant de le garder secret, vous aurez probablement se tirer dans le pied.
3. la valeur du compteur n'a pas besoin d'être imprévisible-à partir de zéro et en ajoutant un pour chaque bloc est parfaitement bien. Mais notez que si vous chiffrer plusieurs messages, vous avez besoin de garder une trace de la contre-valeurs qui ont déjà été consommés, c'est à dire vous avez besoin de garder une trace de la façon dont de nombreux blocs ont déjà été chiffrés avec cette clé (et vous ne pouvez pas utiliser la même clé dans les différentes instances de votre programme ou sur des machines différentes).
4. le texte brut peut être n'importe quelle longueur -- CTR mode tourne un algorithme de chiffrement par bloc dans un algorithme de chiffrement par flux.

Standard avertissement: Crypto est dur. Si vous ne comprenez pas ce que vous faites, vous sera se tromper.

Je veux juste stocker des mots de passe à travers des sessions.

Utilisation scrypt. scrypt comprend encrypt et decrypt qui utilise AES-CTR avec un mot-clé dérivée.

$ pip install scrypt

$ python
>>> import scrypt
>>> import getpass
>>> pw = getpass.getpass("enter password:")
enter password:
>>> encrypted = scrypt.encrypt("Guido is a space alien.",pw)
>>> out = scrypt.decrypt(encrypted,pw)
>>> out
'Guido is a space alien.'

OriginalL'auteur Terrel Shumway

J'ai peut-être certainement en retard et j'ai peut-être négligé les réponses précédentes, mais je n'ai pas trouvé une déclaration claire de la façon dont cela devrait (au moins à mon humble avis) être fait selon les PyCrypto paquets.

La Crypto.Util.Compteur paquet fournit appelable dynamique des compteurs, qui sont très utiles, mais il était facile pour moi de les utiliser de manière inappropriée.

Vous devez créer un compteur, par exemple, de ctr = Counter.new('parameters here'). Chaque fois que votre compteur est appelé par votre mode compteur objet de chiffrement pour chiffrer le message, il est incrémenté. Ceci est nécessaire pour de bonnes pratiques de la cryptographie, sinon d'informations sur l'égalité des blocs peuvent avoir des fuites à partir du texte chiffré.

Maintenant, vous ne pouvez pas appeler la fonction de déchiffrement sur le même chiffrement de l'objet, car il appelle de nouveau le même compteur qui dans l'intervalle a été incrémenté, éventuellement plusieurs fois. Ce que vous devez faire est de créer un nouveau chiffrement objet avec un autre compteur initialisé avec les mêmes paramètres. De cette façon, le déchiffrement fonctionne correctement, le démarrage du compteur à partir du même point que le chiffrement a été fait.

Exemple ci-dessous:

# Import modules
from Crypto.Cipher import AES
from Crypto import Random
from Crypto.Util import Counter


# Pad for short keys
pad = '# constant pad for short keys ##'

# Generate a random initialization vector, to be used by both encryptor and decryptor
# This may be sent in clear in a real communication

random_generator = Random.new()
IV = random_generator.read(8)


# Encryption steps

# Ask user for input and pad or truncate to a 32 bytes (256 bits) key
prompt = 'Input your key. It will padded or truncated at 32 bytes (256 bits).\n-: '
user_keye = raw_input(prompt)
keye = (user_keye + pad)[:32]

# Create counter for encryptor
ctr_e = Counter.new(64, prefix=IV)

# Create encryptor, ask for plaintext to encrypt, then encrypt and print ciphertext
encryptor = AES.new(keye, AES.MODE_CTR, counter=ctr_e)
plaintext = raw_input('Enter message to cipher: ')
ciphertext = encryptor.encrypt(plaintext)
print ciphertext
print


# Decryption steps

# Ask user for key: it must be equal to that used for encryption
prompt = 'Input your key. It will padded or truncated at 32 bytes (256 bits).\n-: '
user_keyd = raw_input(prompt)
keyd = (user_keyd + pad)[:32]

# Create counter for decryptor: it is equal to the encryptor, but restarts from the beginning

ctr_d = Counter.new(64, prefix=IV)

# Create decryptor, then decrypt and print decoded text
decryptor = AES.new(keyd, AES.MODE_CTR, counter=ctr_d)
decoded_text = decryptor.decrypt(ciphertext)
print decoded_text

OriginalL'auteur Halberdier