Bonsoir à tous,

Je suis actuellement en train de recréer l'algorithme Blowfish de Bruce Schneier sur Python 3.5. J'ai fini le chiffrement assez bien je suppose (je vérifie le résultat que je devrais obtenir sur le site Web qui permettent un cryptage en ligne).

Mais maintenant je suis bloqué sur le déchiffrement du texte. J'ai vu beaucoup de différents sites Web et images, mais ils ont tous utilisé la même documentation. J'ai également jeté un coup d'oeil au code fourni par Bruce Schneier sur son propre site, mais je ne comprends toujours pas où est mon erreur.

Le processus de déchiffrement est normalement le même que le chiffrement à la seule différence que le bloc P est utilisé de la dernière valeur de la table à la première.

Voici mon code:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
import sys, string, math
from slist import get_sList, get_pList
 
 
def blowfish(plaintext, key):  
    S, P, K     = generate(key)
    cipher      = ''
    decipher    = ''
    bloc        = []
    switch      = 0
 
    plaintext64 = bourrage64(plaintext)
 
    for case in plaintext64:
        bloc    = decoupage32(case)
        Xl,Xr   = chiffrement(int(bloc[0],2), int(bloc[1],2), P, S)
        cipher += str(hex(Xl)[2:])
        cipher += str(hex(Xr)[2:])
 
    cipher = ''.join(chr(int(cipher[i:i+2], 16)) for i in range(0, 
 
    len(str(cipher)), 2))
    print('Blowfish encrypted: ' + cipher)
    cipher64 = bourrage64(cipher)
 
    for case in cipher64:
        bloc    = decoupage32(case)
        Xl,Xr   = dechiffrement(int(bloc[0],2), int(bloc[1],2), P, S)
        listel  = decoupage8(Xl)
        lister  = decoupage8(Xr)
        for morceau in listel:
            decipher += str(morceau)
 
        for morceau in lister:
            decipher += str(morceau)
 
    decipher = ''.join(chr(int(decipher[i:i+2], 16)) for i in range(0,len(str(decipher)), 2))
    print('Blowfish decrypted: ' + decipher)
 
def generate(key):
    Sliste  = get_sList()
    Pliste  = get_pList()
    Kliste  = []
    taille  = 0
    compt   = 0
    _Kliste = ''.join(bin(char)[2:].zfill(8) for char in key.encode('UTF-8'))
    _Kliste = to_list(_Kliste, 8)
 
    for x in range(14):
        Kliste.append('')
        for y in range(4):
            Kliste[x]+=_Kliste[taille]
            taille += 1
            if taille == len(_Kliste):
                taille = 0
        Kliste[x] = int(Kliste[x],2)
 
    for x in range(18):
        if compt == 14:
            compt = 0
        Pliste[x] = str(bin(Pliste[x] ^ Kliste[compt])[2:].zfill(8))
        Pliste[x] = int(Pliste[x],2)
        compt += 1
 
    datal = 0
    datar = 0
 
    for i in range(0,18,2):
        datal, datar = chiffrement(datal, datar, Pliste, Sliste)
        Pliste[i] = datal
        Pliste[i + 1] = datar
 
    for i in range(4):
        for j in range(0,256,2):
            datal, datar = chiffrement(datal, datar, Pliste, Sliste)
            Sliste[i][j] = datal
            Sliste[i][j + 1] = datar
 
    return Sliste, Pliste, Kliste
 
def chiffrement(datal, datar, P, S):    
    for i in range(16):
        datal = datal ^ P[i]
        datar = F(datal, S) ^ datar
        temp = datal
        datal = datar
        datar = temp
 
    temp = datal
    datal = datar
    datar = temp
 
    datar = datar ^ P[16]
    datal = datal ^ P[16 + 1]
 
    return datal, datar
 
def dechiffrement(datal, datar, P, S):
    for i in range(17,1,-1):
        datal = datal ^ P[i]
        datar = F(datal, S) ^ datar
        temp = datal
        datal = datar
        datar = temp
 
    temp = datal
    datal = datar
    datar = temp
 
    datar = datar ^ P[1]
    datal = datal ^ P[0]
 
    return datal, datar
 
def F(plaintext, S):
    listePT = decoupage8(plaintext)
 
    y = (S[0][int(listePT[0],2)] + S[1][int(listePT[1],2)])%(2**32)
    y = y ^ S[2][int(listePT[2],2)]
    y = (y + S[3][int(listePT[3],2)])%(2**32)
 
    return y
 
def decoupage8(plaintext):
    listePT     = []
    compt       = 0
    plaintext = str(bin(plaintext)[2:].zfill(32))
    if len(plaintext) >= 34:
        sys.exit(1)
 
    listePT     += to_list(plaintext, 8)
 
    return listePT
 
def bourrage64(plaintext):
    xTemp       = ''
    compt       = 0
    x64liste    = []
    bourrage    = []
    reste       = 0
    x64         = len(plaintext)/8
    plaintext   = ''.join(bin(char)[2:].zfill(8) for char in plaintext.encode('UTF-8'))
    listePT     = to_list(plaintext, 8)
 
    if x64%1 != 0:
        for x in range(8 - len(listePT)%8):
            bourrage.append('00000000')
        listePT += bourrage
 
        for x in range(int(x64)+ 1):
            for n in range(8):
                xTemp += listePT[compt]
                compt += 1
            x64liste.append(xTemp)
            xTemp = ''
    else:
        for x in range(int(x64)):
            for n in range(8):
                xTemp += listePT[compt]
                compt += 1
            x64liste.append(xTemp)
            xTemp = ''
    return x64liste
 
def decoupage32(plaintext):
    switch      = 0
    listePT     = []
    _listePT    = []
 
    listePT     += to_list(plaintext, 32)
 
    return listePT
 
if __name__ == '__main__': 
    plaintext   = 'Lesoleilestjaune0'
    key         = 'azertyui'
 
    if len(key) > 56 or len(key) < 4:
        input('Erreur: taille de cle incorrect!')
        sys.exit(1)
 
    blowfish(plaintext, key)
Le problème est sur le second "pour" de la def blowfish.

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
for case in cipher64:
    bloc    = decoupage32(case)
    Xl,Xr   = dechiffrement(int(bloc[0],2), int(bloc[1],2), P, S)
    listel  = decoupage8(Xl)
    lister  = decoupage8(Xr)
    for morceau in listel:
        decipher += str(morceau)
 
    for morceau in lister:
        decipher += str(morceau)
Voici également le fichier qui contient toutes les valeurs de PI qui sont utilisées pour effectuer l'algorithme correctement.

Code : Sélectionner tout - Visualiser dans une fenêtre à part
 
Je tiens préciser que je ne demande pas nécessairement une réponse sous forme de code mais juste une explication de pourquoi mon code ne fonctionne pas me conviendrai amplement.
Aurais-je loupé une étape dans l'algorithme de déchiffrement? Une erreur de sens dans l'utilisation des différentes tables?

Merci d'avance!