Comment AES dans la CTR de travaux pour Python avec PyCrypto?

Selon @gertvdijk, AES_CTR est un chiffrement de flux qui ne pas besoin de rembourrage. J'ai donc supprimé les codes.

Voici quelque chose que je sais.

1. Vous devez utiliser une même clé(le premier paramètre dans AES.new(...)) dans le chiffrement et le déchiffrement, et de garder la clé privée.

2. Le chiffrement/déchiffrement des méthodes sont stateful, cela signifie que crypto.en(de)crypt("abcd")==crypto.en(de)crypt("abcd") est pas toujours vrai. Dans votre CTR, votre compteur de rappel renvoie toujours la même chose, de sorte qu'il devient apatride quand chiffrer (je ne suis pas 100% sûr que c'est la raison), mais nous trouvons qu'il est un peu dynamique dans le déchiffrement. En conclusion, il faut toujours utiliser un nouvel objet pour le faire.

3. La counter callback fonction de chiffrement et de déchiffrement doit se comporter de la même. Dans votre cas, c'est de faire les deux d'entre eux de retourner le même secret. Pourtant, je ne pense pas que le secret est un "secret". Vous pouvez utiliser un aléatoire généré "secret" et le passer à travers la communication des pairs sans cryptage de sorte que l'autre partie peut l'utiliser directement, tant que le secret est pas prévisible.

Donc je voudrais écrire ma chiffrement comme ça, j'espère qu'elle va offrir de l'aide.

import os
import hashlib
import Crypto.Cipher.AES as AES
class Cipher:
@staticmethod
def md5sum( raw ):
m = hashlib.md5()
m.update(raw)
return m.hexdigest()
BS = AES.block_size
@staticmethod 
def pad( s ):
"""note that the padding is no necessary"""
"""return s + (Cipher.BS - len(s) % Cipher.BS) * chr(Cipher.BS - len(s) % Cipher.BS)"""
return s
@staticmethod
def unpad( s ):
"""return s[0:-ord(s[-1])]"""
return s
def __init__(self, key):
self.key = Cipher.md5sum(key)
#the state of the counter callback 
self.cnter_cb_called = 0 
self.secret = None
def _reset_counter_callback_state( self, secret ):
self.cnter_cb_called = 0
self.secret = secret
def _counter_callback( self ):
"""
this function should be stateful
"""
self.cnter_cb_called += 1
return self.secret[self.cnter_cb_called % Cipher.BS] * Cipher.BS
def encrypt(self, raw):
secret = os.urandom( Cipher.BS ) #random choose a "secret" which is not secret
self._reset_counter_callback_state( secret )
cipher = AES.new( self.key, AES.MODE_CTR, counter = self._counter_callback )
raw_padded = Cipher.pad( raw )
enc_padded = cipher.encrypt( raw_padded )
return secret+enc_padded #yes, it is not secret
def decrypt(self, enc):
secret = enc[:Cipher.BS]
self._reset_counter_callback_state( secret )
cipher = AES.new( self.key, AES.MODE_CTR, counter = self._counter_callback )
enc_padded = enc[Cipher.BS:] #we didn't encrypt the secret, so don't decrypt it
raw_padded = cipher.decrypt( enc_padded )
return Cipher.unpad( raw_padded )

Quelques test:

>>> from Cipher import Cipher
>>> x = Cipher("this is key")
>>> "a"==x.decrypt(x.encrypt("a"))
True
>>> "b"==x.decrypt(x.encrypt("b"))
True
>>> "c"==x.decrypt(x.encrypt("c"))
True
>>> x.encrypt("a")==x.encrypt("a")
False #though the input is same, the outputs are different

Référence: http://packages.python.org/pycrypto/Crypto.Cipher.blockalgo-module.html#MODE_CTR

OriginalL'auteur Marcus

Commencer avec une nouvelle crypto objet de nouvelles opérations

La raison pour laquelle il se comporte comme décrit dans la question c'est parce que votre texte (4 octets (32 bits) est quatre fois plus petite que la taille du moteur cryptographique de travaux sur de votre choix de mode AES (128 bits) et aussi la réutilisation de la même instance de la crypto objet. Suffit de ne pas réutiliser le même objet, si vous effectuez une opération sur un nouveau flux de données (ou d'une autre opération). Votre problème sera résolu par l'instanciation d'un nouveau crypto objet pour le déchiffrement, comme ceci:

# *NEVER* USE A FIXED LIKE COUNTER BELOW IN PRODUCTION CODE. READ THE DOCS.
counter = os.urandom(16)
key = os.urandom(32)  # 256 bits key
# Instantiate a crypto object first for encryption
encrypto = AES.new(key, AES.MODE_CTR, counter=lambda: counter)
encrypted = encrypto.encrypt("asdk")
# Instantiate a new crypto object for decryption
decrypto = AES.new(key, AES.MODE_CTR, counter=lambda: counter)
print decrypto.decrypt(encrypted) # prints "asdk"

Pourquoi il n'est pas à propos de rembourrage avec AES-CTR

Cette réponse qui a commencé comme une réponse sur la réponse par Marcus, dans laquelle il a d'abord indiqué que l'utilisation de rembourrage en résoudrait. Bien que je comprenne qu'il regarde comme des symptômes d'un problème de remplissage, il ne l'est certainement pas.

Le point de l'ensemble de l'AES-CTR est que vous n'avez pas besoin de rembourrage, c'est un de chiffrement de flux (à la différence de la BCE/CBC et ainsi de suite)! Chiffrements de flux de travail sur un flux de données, segmentation des données dans des blocs et de la chaîne dans le calcul cryptographique.

OriginalL'auteur gertvdijk