Comment réussir à convertir en "SHA-256" les caractères "\x00\x01\tfw`\x06\x9" ?

**cheboy** · 04/01/2018, 15h13

Bonjour à tous.

Je sais que c'est long et j'espère vraiment que vous ne serez pas décu de bien lire pour mieux comprendre mon souci que j'expose. Car j'ai préféré bien détailler voilà pourquoi c'est long. Alors, je vous prie d'avance de ne pas être déçu sans avoir fini de tout lire.

Au fait, j'utilise la librairie "Base58" pour convertir en base58 le "string" de mon adresse décodé qui donne un résultat correcte. Mais quand j'essaie de convertir le même "string" en "SHA-256"
pour finalement en déduire la même adresse qui devrait être égale au résultat de l'encodage en Base58, je reçois une autre adresse erronée qui n'a rien à voir avec mon adresse normale (string encodé en Base58).

Par exemple, je commence par:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
>>> import base58
>>> import hashlib
>>> unencoded_string = "\x00\x01\tfw`\x06\x95=UgC\x9e^9\xf8j\r';\xee\xd6\x19g\xf6" 
>>> encoded_string= base58.b58encode(unencoded_string)
>>> encoded_string= base58.b58encode(unencoded_string)
>>> encoded_string
'16UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM'
>>>

Comme on le vois, le résultat est bien correcte car correspond à mon adresse encodé en Base58.

Mais quand j'essaie de convertir la même variable "unencoded_string" qui a donné ce résultat encodé (Base58 ci-dessus) en SHA-256, puis calculer le tout en utilisant la
Librairie ECDSA (qui permet de calculer les clés à partir d'un string et leur adresse en Base58) pour obtenir après une adresse encodé en base58, j'obtiens un résultat d'adresse
totalement différent du résultat(16UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM) obtenu en utilisant la librairie Base58.

Par exemple, lorsque je fais:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
>>> unencoded_string
"\x00\x01\tfw`\x06\x95=UgC\x9e^9\xf8j\r';\xee\xd6\x19g\xf6"
>>> encoded_string= base58.b58encode(unencoded_string)
>>> encoded_string
'16UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM'
>>> hashlib.sha256(unencoded_string).hexdigest()
'115ce22e648364451ddc19cac1a3086d8db8f9058f6160d26b1185721347670a'

Après, j'utilise un script du genre pour ma convertion en important la Librairie ECDSA :

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
import ecdsa
import ecdsa.der
import ecdsa.util
import hashlib
import os
import re
import struct
 
b58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
 
def base58encode(n):
    result = ''
    while n > 0:
        result = b58[n%58] + result
        n /= 58
    return result
 
def base256decode(s):
    result = 0
    for c in s:
        result = result * 256 + ord(c)
    return result
 
def countLeadingChars(s, ch):
    count = 0
    for c in s:
        if c == ch:
            count += 1
        else:
            break
    return count
 
def base58CheckEncode(version, payload):
    s = chr(version) + payload
    checksum = hashlib.sha256(hashlib.sha256(s).digest()).digest()[0:4]
    result = s + checksum
    leadingZeros = countLeadingChars(result, '\0')
    return '1' * leadingZeros + base58encode(base256decode(result))
 
def privateKeyToWif(key_hex):    
    return base58CheckEncode(0x80, key_hex.decode('hex'))
 
def privateKeyToPublicKey(s):
    sk = ecdsa.SigningKey.from_string(s.decode('hex'), curve=ecdsa.SECP256k1)
    vk = sk.verifying_key
    return ('\04' + sk.verifying_key.to_string()).encode('hex')
 
def pubKeyToAddr(s):
    ripemd160 = hashlib.new('ripemd160')
    ripemd160.update(hashlib.sha256(s.decode('hex')).digest())
    return base58CheckEncode(0, ripemd160.digest())
 
def keyToAddr(s):
    return pubKeyToAddr(privateKeyToPublicKey(s))
 
private_key = "115ce22e648364451ddc19cac1a3086d8db8f9058f6160d26b1185721347670a" # Le Hash en SHA-256 de mon String.
 
print "Address         : %s " % keyToAddr(private_key) # Donne comme résultat: 1DSGp6nVixaYBt1Qtz2Gzb8DhEz2i85ZPG qui est différent de 16UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM.

On voit bien que le résultat obtenu avec la Librairie "ECDSA" après avoir converti le même "string" qui a permis d'obtenir le résultat correcte en base58, est
faux et totalement différent. Ce qui me permet de conclure que le module "Base58" reconnait bien les Octets, car son résultat lorsqu'on encode un "string" du genre
"\x00\x01\tf" est correcte contrairement au module "HASHLIB" qui ne reconnait pas du tout les caractères de ce genre ou reconnait autrement ce qui provoque un faux résultat.

Je suppose donc (si je ne me trompe pas) que l'erreur vient du fait que le module "HASHLIB" ne reconnait pas exactement et correctement tous les caractères du string (\x00\x01\tf)
contrairement au module "Base58" qui semble bien reconnaître en clair ce genre de caractères, c'est pourquoi il (HASHLIB) fournit un mauvais un résultat
du Hash SHA-256 ce qui donne un faux résultat qui ne correspond pas à la Base58 originelle de mon adresse lorsqu'on utilise ce hash SHA-256 du string (\x00\x01\tf) fourni pour
le module "ECDSA".

Alors, comment trouver ou réussir la convertion de mon "string" en SHA-256 quelque soit sa forme (même s'il est du genre "\x00\x01\tf"), exactement comme reconnait
le module "Base58" ce type de caractères de sorte à trouver le vrai Hash pour que lorsque je essayer d'en déduire avec le Module "ECDSA", le résultat ne soit pas différent ???

Ça donne vraiment à réfléchir depuis hier.
Aidez-moi.
Merci d'avance.

**lg_53** · 06/01/2018, 18h27

Salut

J'ai pas tout compris, mais je vais tenter de donner mon (mes) point(s) de vue.

1)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
>>> import base58
>>> import hashlib
>>> unencoded_string = "\x00\x01\tfw`\x06\x95=UgC\x9e^9\xf8j\r';\xee\xd6\x19g\xf6" 
>>> encoded_string= base58.b58encode(unencoded_string)
>>> encoded_string= base58.b58encode(unencoded_string)
>>> encoded_string
'16UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM'
>>>

Comme on le vois, le résultat est bien correcte car correspond à mon adresse encodé en Base58.

Bah non je ne vois pas... En quoi ca montre que c'est bien ce que tu attends ? ...
Pourquoi faire 2 fois l'encodage d'ailleurs ?

2) Ensuite

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
>>> unencoded_string
"\x00\x01\tfw`\x06\x95=UgC\x9e^9\xf8j\r';\xee\xd6\x19g\xf6"
>>> encoded_string= base58.b58encode(unencoded_string)
>>> encoded_string
'16UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM'
>>> hashlib.sha256(unencoded_string).hexdigest()
'115ce22e648364451ddc19cac1a3086d8db8f9058f6160d26b1185721347670a'

Oui ca donne pas la même chose. En même temps tu compares des choses non comparable. Tu compares qqch en base 16 à qqch en base 58. Il faut comparer ce qui est comparable.

3) Il y a plusieurs librairies là dans ce que tu utilises. Si je résume il y a hashlib, base58, et ecdsa. Ces librairies font peut etre des choses qui te paraissent similaires mais il n'y a absolument aucune raison pour qu'elles soit compatibles. Si tu encode avec une librairie, tu dois décoder avec la même librairie. Si tu décodes avec une autre librairie, tu n'as à priori aucune garanti du résultat fourni !

4) Si j'essaie de reproduire un peu ton code, déjà chez moi, ce que tu fournis, ça ne fonctionne pas ...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
>>import base58
>>unencoded_string = "\x00\x01\tfw`\x06\x95=UgC\x9e^9\xf8j\r';\xee\xd6\x19g\xf6" 
>>base58.b58encode(unencoded_string)
Traceback (most recent call last):
  File "python", line 1, in <module>
TypeError: a bytes-like object is required, not 'str'

Ceci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

base58.b58encode(unencoded_string.encode())

fonctionne (encode convertissant le string en byte), mais est-ce que tu veux ?...

En espérant t'avoir fait progresser,
Lg53

**cheboy** · 06/01/2018, 21h36

Ok merci à vous pour l'explication.

**sunriseparadyse** · 12/01/2018, 21h04

SHA(a)=b

SHA(b) NE DONNE PAS a mais encore un autre résultat

**lg_53** · 15/01/2018, 10h40

Les librairies dont nous parlons possèdent des fonctions d'encodage ET de décodage. Ce ne sont bien évidemment pas les mêmes.

Prend une fonction f défini par :

f(x)=x+1

donc si tu fais b=f(a), alors b vaut a+1.
Et si ensuite tu écris f(b), ca fait b+1, donc (a+1)+1, autrement dit a+2. Ainsi

f(b) = f(f(a)) = a+2

Et donc évidemment tu ne retombes pas sur a. Et c'est normal ! Appliqué deux fois une même fonction n'a jamais garantie que tu retombes sur l'argument de départ. Il faut appliquer sa fonction inverse pour ca, que l'on note souvent f^-1.

Ici sha, c'est la fonction f. Et son inverse c'est une autre fonction de la même librairie, qui elle permet de décoder.