PyCrypto - Comment fonctionne le vecteur d'initialisation?

J'essaie de comprendre comment PyCrypto fonctionne à utiliser dans un projet mais je ne suis pas entièrement comprendre l'importance du Vecteur d'Initialisation (IV). J'ai trouvé que je puisse utiliser les mauvaises IV lors du décodage d'une chaîne et je n'ai toujours semble pour obtenir le message de retour, sauf pour les 16 premiers octets (la taille de bloc). Suis simplement à l'aide de tromper ou de ne pas comprendre quelque chose?

Voici un exemple de code pour illustrer:

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

def pad_data(data):
    if len(data) % 16 == 0:
        return data
    databytes = bytearray(data)
    padding_required = 15 - (len(databytes) % 16)
    databytes.extend(b'\x80')
    databytes.extend(b'\x00' * padding_required)
    return bytes(databytes)

def unpad_data(data):
    if not data:
        return data

    data = data.rstrip(b'\x00')
    if data[-1] == 128: # b'\x80'[0]:
        return data[:-1]
    else:
        return data


def generate_aes_key():
    rnd = Crypto.Random.OSRNG.posix.new().read(AES.block_size)
    return rnd

def encrypt(key, iv, data):
    aes = AES.new(key, AES.MODE_CBC, iv)
    data = pad_data(data)
    return aes.encrypt(data)

def decrypt(key, iv, data):
    aes = AES.new(key, AES.MODE_CBC, iv)
    data = aes.decrypt(data)
    return unpad_data(data)

def test_crypto ():
    key = generate_aes_key()
    iv = generate_aes_key() # get some random value for IV
    msg = b"This is some super secret message.  Please don't tell anyone about it or I'll have to shoot you."
    code = encrypt(key, iv, msg)

    iv = generate_aes_key() # change the IV to something random

    decoded = decrypt(key, iv, code)

    print(decoded)

if __name__ == '__main__':
    test_crypto()

Je suis à l'aide de Python 3.3.

De sortie varient en fonction de l'exécution, mais j'obtiens quelque chose comme ceci: b"1^,Kp}Vl\x85\x8426M\xd2b\x1aer secret message. Please don't tell anyone about it or I'll have to shoot you."

source d'informationauteur Tim Tisdall

18

Le comportement que vous voyez est spécifique à la mode CBC. Avec CBC, le décryptage peut être visualisé de la manière suivante (article de wikipédia):

Vous pouvez constater que IV ne contribue que les 16 premiers octets de texte en clair. Si le IV est endommagé alors qu'il est en transit vers le récepteur, CBC /radio-canada toujours correctement décrypter tous les blocs, mais le premier. Dans la CBC, le but de la IV est de vous permettre de chiffrer le même message avec la même clé, et encore obtenir un totalement différent du texte chiffré à chaque fois (même si la longueur du message peut donner quelque chose de loin).

Autres modes sont moins indulgent. Si vous obtenez le IV de mal, l'ensemble du message est déformé au déchiffrement. Prendre le CTR de la mode, par exemple, où nonce prend presque le même sens de l' IV:
1

Le développeur de PyCrypto retiré le cahier des charges pour l'AES en Mode CBC par le NIST:

AES Mode_CBC -> référencement NIST 800-38a (La Recommandation pour le Mode de Chiffrement des Opérations)

Page 8:

5.3 Initialisation Des Vecteurs

L'entrée pour le processus de chiffrement de la CBC, CFB et OFB modes comprend, outre le texte en clair, un bloc de données, appelé le vecteur d'initialisation (IV), notée IV. Le IV est utilisé dans une étape initiale dans le cryptage d'un message et dans le déchiffrement du message.
La IV n'a pas besoin d'être un secret; toutefois, pour la CBC et de la BFC modes, le IV pour n'importe quel particulier
l'exécution du processus de chiffrement doit être imprévisible, et, pour le mode OFB, unique IVs doit être utilisé pour chaque exécution de la procédure de chiffrement. La génération de l'IVs est indiqué dans l'Annexe C.

Chose à retenir, vous devez utiliser un hasard IV chaque fois que vous composez un message, ce qui ajoute un " sel " pour le message, par conséquent, ce qui rend le message unique; même avec le 'sel' être à l'air libre, il ne va pas aider à casser le chiffrement si la clé de chiffrement AES est inconnu. Si vous n'utilisez pas une étude randomisée IV, par exemple, vous utilisez le même de 16 octets de chaque message, vos messages, si vous vous répétez, aura la même apparence passe à travers le fil et vous pourriez être assujetti à la fréquence et/ou le rejeu.

Un test pour les résultats de l'aléatoire IVs vs statique:
```
def test_crypto ():
    print("Same IVs same key:")
    key = generate_aes_key()
    iv = b"1234567890123456"
    msg = b"This is some super secret message.  Please don't tell anyone about it or I'll have to shoot you."
    code = encrypt(key, iv, msg)
    print(code.encode('hex'))
    decoded = decrypt(key, iv, code)
    print(decoded)

    code = encrypt(key, iv, msg)
    print(code.encode('hex'))
    decoded = decrypt(key, iv, code)
    print(decoded)

    print("Different IVs same key:")
    iv = generate_aes_key()
    code = encrypt(key, iv, msg)
    print(code.encode('hex'))
    decoded = decrypt(key, iv, code)
    print(decoded)

    iv = generate_aes_key()
    code = encrypt(key, iv, msg)
    print(code.encode('hex'))
    decoded = decrypt(key, iv, code)
    print(decoded)
```
Espérons que cette aide!

Vous devez vous connecter pour publier un commentaire.