Les blowfish diffèrent dans les deux langages

Bonjour,

je dois écrire un script qui a besoin d'accéder à une information qui est verrouillée par un token. Ayant accès à la base de données, j'ai tout ce qu'il me faut pour construire le token.

Ce token est construit par une application java et j'ai besoin d'y accéder en python (version 3 please). Voilà comment c'est codé en java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

public String getToken(String salt, String p1, String p2, String p3, String p4){
        String result = null;
        String labelSource = p1 + "//" +p2 + "//" + p3 + "//" + p4;
        SecretKey key = new SecretKeySpec(salt.getBytes(), "BLOWFISH");

        try
        {
            mailCipher.init(Cipher.ENCRYPT_MODE, key);
            byte[] encrypted = mailCipher.doFinal(labelSource.getBytes());
            result = new String(Hex.encode(encrypted));

        }
        catch(Exception e){
              //log
        }
}

Lorsqu'en entrée de la fonction blowfish j'ai 18//1//2//1444925625767 et en clef x9af8Sly java me renvoie : 1d64dbf38cb07f6bd28ffaabd3cd1dbc0426394e7e7f6258f106cf60d9e0db31 qui fait 64 caractères.

EN python j'ai ceci :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

from Crypto.Cipher import Blowfish
import binascii
from Crypto import Random
from struct import pack
if __name__ == '__main__':
    key = 'x9af8Sly'
    bs = Blowfish.block_size
    iv = "12345678"
    s = '18//1//2//1444925625767'
    plen = bs - divmod(len(s),bs)[1]
    padding = [plen]*plen
    padding = pack('b'*plen, *padding)
    c = Blowfish.new(key, Blowfish.MODE_ECB, "12345678")
    c = c.encrypt(s + padding)
    #c = PandoraEncrypt(s)    
    a = binascii.hexlify(c).decode("ascii")
    print(a, len(a))

Et avec le résultat est celui-ci :

u'c377c454b0259052ee543fdc2f0c50435ff67692d14a83a1' 48

Savez-vous comment changer la donne?

Salut !

Est-ce que tu es sûr que c'est bien le mode ECB qui est utilisé par défaut par Python ?

Sinon, y'a toujours les conneries de string qui sont en UTF-8 d'une part et en ansi de l'autre. Surtout connaissant python 3 –"

en jouant avec les encodages et en laissant le mode par défaut :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

if __name__ == '__main__':
    key = 'x9af8Sly'
    bs = Blowfish.block_size
    iv = "12345678"
    s = '18//1//2//1444925625767'
    plen = bs - divmod(len(s),bs)[1]
    padding = [plen]*plen
    padding = pack('b'*plen, *padding)
    c = Blowfish.new(key)
    c = c.encrypt(s.encode("ascii") + padding)
    a = binascii.hexlify(c).decode("ascii")
    print(a, len(a))

c377c454b0259052ee543fdc2f0c50435ff67692d14a83a1 48

Donc je suis toujours bloqué.

je vais te donner une réponse avec des idées completement idiotes (je serai ta "peluche de spacefox" :p) pour une bonne partie des question il faudrait ouvrir la lib en question, et aller gratter dedans, mais je te laisse le soin de le faire

peut-être une question d'endian?

vu que la clé est pas de taille fixée par blowfish (de 32 à 448 bits)… est-ce qu'il y a pas un changement de taille de clé dans l'un des mécanismes (bit stuffing, ou autoconcaténation, bref…)

à tout hasard, tu exécute ton code sur une machine 64 bits ou pas? si c'est pas le cas, es-tu bien sûr que dans les libs la taille des registres a été traitée de la même manière.

es-tu bien sûr que le chiffrement est fait sur le même nombre d'itérations dans les deux libs?

là comme ça je vois pas de questions encore plus bêtes, et comme j'y connais pas grand chose en python et en chiffrement en général (pis en java j'suis pas une lumière non plus) j'oserais pas aller trouver une réponse intéressante du point de vue des langages.