Codage XOR - Corrigé¶

m et k sont définis pour réaliser les tests.

In [1]:

m = 'message testé'
k = 'CLE'

m = 'message testé' k = 'CLE'

1) import de la méthode xor du module operator¶

In [2]:

from operator import xor

from operator import xor

2) Chiffrement du message m avec la clé k¶

Si la clé est plus courte que le message : la clé augmentée sera le début de la clé.
Sinon les caractères de la clé sont répétés jusqu'à ce que la clé augmentée soit de même longueur que le message.

In [3]:

def c_xor(m, k):
    
# SI k plus court que m
    if len(k) > len(m):
# k_aug est le début de k
        k_aug = [ord(i) for i in k[:len(m)]] # On stocke directement le code décimal du caractère
# SINON
    else:
        k_aug = []
        i = 0
# Tant que k_aug plus court que m
        while len(m) > len(k_aug):
            k_aug.append(ord(k[i]))  # On ajoute le code décimal des caractères de k
            i += 1
            if i == len(k): i = 0    # Si on a utilisé tous les caractères de k, on recommence au 1er.
    
    return [chr(xor(ord(m[i]),k_aug[i])) for i in range(len(m))]

def c_xor(m, k): # SI k plus court que m if len(k) > len(m): # k_aug est le début de k k_aug = [ord(i) for i in k[:len(m)]] # On stocke directement le code décimal du caractère # SINON else: k_aug = [] i = 0 # Tant que k_aug plus court que m while len(m) > len(k_aug): k_aug.append(ord(k[i])) # On ajoute le code décimal des caractères de k i += 1 if i == len(k): i = 0 # Si on a utilisé tous les caractères de k, on recommence au 1er. return [chr(xor(ord(m[i]),k_aug[i])) for i in range(len(m))]

return ''.join([chr(xor(ord(m[i]),k_aug[i])) for i in range(len(m))]) renvoie une chaîne de caractère mais les cararctères non imprimables n'apparaissent pas.

La solution est de renvoyer une liste contenant les caractères. Dans ce cas, les caractères non imprimables sont remplacés par un code permettant de les représenter : return [chr(xor(ord(m[i]),k_aug[i])) for i in range(len(m))]

3) Déchiffrement du message m avec la clé k¶

Le principe est le même que le chiffrement. La fonction OU Exclusif permet de retrouver la valeur de départ : 0 XOR 1 = 1 --> 0 = 1 XOR 1.

Les fonctions c_xor(m, k) et d_xor(m, k) complètes :¶

In [4]:

def d_xor(m, k):
    if len(k) > len(m):
        k_aug = [i for i in k[:len(m)]]
    else:
        k_aug = []
        i = 0
        while len(m) > len(k_aug):
            k_aug.append(ord(k[i]))
            i += 1
            if i == len(k): i = 0
    
    return ''.join([chr(xor(ord(m[i]),k_aug[i])) for i in range(len(m))])

def d_xor(m, k): if len(k) > len(m): k_aug = [i for i in k[:len(m)]] else: k_aug = [] i = 0 while len(m) > len(k_aug): k_aug.append(ord(k[i])) i += 1 if i == len(k): i = 0 return ''.join([chr(xor(ord(m[i]),k_aug[i])) for i in range(len(m))])

La fonction d_xor() renvoie une chaîne de caractères. S'agissant du message décodé, il n'y a normalement pas de problèmes de caractères non-imprimables.

In [5]:

from operator import xor

def c_xor(m, k):
    if len(k) > len(m):
        k_aug = [ord(i) for i in k[:len(m)]]
    else:
        k_aug = []
        i = 0
        while len(m) > len(k_aug):
            k_aug.append(ord(k[i]))
            i += 1
            if i == len(k): i = 0
    
    #return ''.join([chr(xor(ord(m[i]),k_aug[i])) for i in range(len(m))])
    return [chr(xor(ord(m[i]),k_aug[i])) for i in range(len(m))]

def d_xor(m, k):
    if len(k) > len(m):
        k_aug = [i for i in k[:len(m)]]
    else:
        k_aug = []
        i = 0
        while len(m) > len(k_aug):
            k_aug.append(ord(k[i]))
            i += 1
            if i == len(k): i = 0
    
    return ''.join([chr(xor(ord(m[i]),k_aug[i])) for i in range(len(m))])

from operator import xor def c_xor(m, k): if len(k) > len(m): k_aug = [ord(i) for i in k[:len(m)]] else: k_aug = [] i = 0 while len(m) > len(k_aug): k_aug.append(ord(k[i])) i += 1 if i == len(k): i = 0 #return ''.join([chr(xor(ord(m[i]),k_aug[i])) for i in range(len(m))]) return [chr(xor(ord(m[i]),k_aug[i])) for i in range(len(m))] def d_xor(m, k): if len(k) > len(m): k_aug = [i for i in k[:len(m)]] else: k_aug = [] i = 0 while len(m) > len(k_aug): k_aug.append(ord(k[i])) i += 1 if i == len(k): i = 0 return ''.join([chr(xor(ord(m[i]),k_aug[i])) for i in range(len(m))])

In [6]:

print(c_xor("Vive la NSI !", "CLE"))
print(d_xor(c_xor("Vive la NSI !", "CLE"), "CLE"))

print(c_xor("Vive la NSI !", "CLE")) print(d_xor(c_xor("Vive la NSI !", "CLE"), "CLE"))

['\x15', '%', '3', '&', 'l', ')', '"', 'l', '\x0b', '\x10', '\x05', 'e', 'b']
Vive la NSI !