Les blowfish diffèrent dans les deux langages

Et pourtant...

L'auteur de ce sujet a trouvé une solution à son problème.
Staff
Auteur du sujet

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))

documentation de Crypto ici

Et avec le résultat est celui-ci :

u'c377c454b0259052ee543fdc2f0c50435ff67692d14a83a1' 48

Savez-vous comment changer la donne?

+0 -0
Staff
Auteur du sujet

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é.

+0 -0

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 :p

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.

Oui. Non. Attends, je regarde mieux et je te dis.

+0 -0
Vous devez être connecté pour pouvoir poster un message.
Connexion

Pas encore inscrit ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte