...
← Curs Blockchain și criptomonede: toate lecțiile
Lecția 6 · Hash

Proprietățile unui hash bun

Nu orice funcție care produce un rezultat scurt este bună pentru blockchain. SHA-256 are cinci proprietăți care o fac potrivită: este deterministă, rapidă, are efect de avalanșă, nu se poate inversa și nu are coliziuni cunoscute. În această lecție le iei pe rând și măsori efectul de avalanșă în Python.

Cinci proprietăți

1Deterministaceeași intrare →același hash2Rapidsute de mii dehash-uri pe secundă3Avalanșăo literă schimbată →alt hash4Ireversibildin hash nuafli intrarea5Fără coliziuninu găsești 2 intrăricu același hash
Cele cinci proprietăți ale unei funcții hash criptografice precum SHA-256.
ProprietateCe înseamnăDe ce contează în blockchain
Deterministaceleași date dau mereu același hashtoate nodurile calculează același hash pentru același bloc
Rapidcalculul durează microsecundeun nod verifică mii de blocuri repede
Efect de avalanșăo schimbare minimă schimbă cam jumătate din bițiorice modificare, oricât de mică, se vede
Ireversibil (one-way)din hash nu poți afla datelehash-ul nu dezvăluie nimic și nu poate fi „fabricat” pentru un rezultat dorit
Rezistent la coliziuninimeni nu poate găsi două intrări cu același hashnu poți înlocui un bloc cu altul care are aceeași amprentă
Atenție

„Rapid” pare în contradicție cu siguranța, dar nu este: calculul înainte e rapid, pe când inversarea sau găsirea unei coliziuni ar dura mai mult decât vârsta universului. Vei vedea în lecțiile 17 și 18 de ce.

Determinist, dar sensibil la orice detaliu

Același text dă de fiecare dată același hash. Dar un singur spațiu în plus la final înseamnă alte date și deci un hash complet diferit:

import hashlib

def sha(text):
    return hashlib.sha256(text.encode()).hexdigest()

print(sha("Plata 100 lei")[:32])
print(sha("Plata 100 lei")[:32])
print(sha("Plata 100 lei ")[:32])
d0dc8a43daf86a58ae44ca33056b197b
d0dc8a43daf86a58ae44ca33056b197b
8249709836961006b4bc9c27101e4131

De aceea, în blockchain, datele se transformă în text într-un mod strict definit înainte de hash (vei vedea în lecția 8 cum facem asta pentru un bloc).

Efectul de avalanșă

Schimbă o singură cifră dintr-o plată: „Plata 100 lei” devine „Plata 101 lei”. Hash-urile nu seamănă deloc. Dacă ar semăna, cineva ar putea ghici cum să modifice datele ca să obțină un hash dorit.

intrare 1Plata 100 leiintrare 2Plata 101 leiun singur caracter diferit → SHA-256 →hash 1d0dc8a43daf86a58ae44ca33056b197b51347bd7b14c5e320309f1d3597cb1dehash 27e6898e099ef891e70c8d6495071411fa301e72c2a580294fb53cf79e55c9e6f63 din 64 de poziții diferă (98%)
Hash-urile lui „Plata 100 lei” și „Plata 101 lei”: caracterele colorate diferă, cele gri coincid în aceeași poziție.

Cum numeri pozițiile diferite? Compari caracterele de pe aceeași poziție. Cu un indice i:

h1 = "a3f9c0"
h2 = "a3e9c1"

for i in range(len(h1)):
    semn = "=" if h1[i] == h2[i] else "X"
    print(i, h1[i], h2[i], semn)
0 a a =
1 3 3 =
2 f e X
3 9 9 =
4 c c =
5 0 1 X

Mai elegant, zip(h1, h2) îți dă perechile de caractere direct. Numeri diferențele și calculezi procentul:

h1 = "a3f9c0"
h2 = "a3e9c1"

diferite = 0
for x, y in zip(h1, h2):
    if x != y:
        diferite += 1

print("Poziții diferite:", diferite)
print("Procent:", round(diferite / len(h1) * 100), "%")
Poziții diferite: 2
Procent: 33 %
Cât ar trebui să iasă?

Pentru două hash-uri fără legătură, fiecare poziție are 16 valori posibile, deci șansa să coincidă întâmplător este 1/16. În medie, aproximativ 60 din 64 de poziții diferă (cam 94%). Exact asta vezi la SHA-256 când schimbi o singură literă.

Avalanșa la orice modificare

Punct în plus, literă mică în loc de mare, o cifră adăugată: de fiecare dată hash-ul este de nerecunoscut. sum(1 for ...) numără elementele care respectă condiția, pe un singur rând:

import hashlib

baza = hashlib.sha256("Plata 100 lei".encode()).hexdigest()
for text in ["Plata 100 lei.", "plata 100 lei", "Plata 1000 lei"]:
    h = hashlib.sha256(text.encode()).hexdigest()
    diferite = sum(1 for x, y in zip(baza, h) if x != y)
    print(f"{text!r}: {diferite} din 64")
'Plata 100 lei.': 57 din 64
'plata 100 lei': 63 din 64
'Plata 1000 lei': 60 din 64

Greșeli frecvente

  • „Hash-uri apropiate = date apropiate.” Nu există nicio „apropiere”: un hash nu spune nimic despre cât de diferite sunt datele.
  • Compari doar începutul hash-ului și concluzionezi că datele sunt egale. Pentru egalitate compari hash-ul întreg.
  • Numeri diferențele pe hash-uri de lungimi diferite. zip se oprește la cel mai scurt șir; asigură-te că ambele au 64 de caractere.
  • MD5 și SHA-1 sunt „la fel de bune”. Nu: pentru amândouă s-au găsit coliziuni (SHA-1 în 2017, proiectul SHAttered). Blockchain-urile folosesc SHA-256, Keccak-256 sau BLAKE2.

Proprietățile în practică

Imutabilitatea

Avalanșa face ca orice modificare a unui bloc vechi să-i schimbe complet hash-ul, deci legătura cu blocul următor se rupe.

Minarea

Pentru că hash-ul nu se poate prezice, minerii nu au altă cale decât să încerce miliarde de variante. Asta e Proof of Work.

Angajamente

Poți publica hash-ul unei predicții azi și textul ei peste un an: oricine verifică, dar nimeni nu află predicția mai devreme.

SHAttered (2017)

Google și CWI au creat două PDF-uri diferite cu același SHA-1: de aceea SHA-1 nu mai e folosit pentru securitate.

Exercițiul tău

Scrie funcția diferente(h1, h2) care întoarce numărul de poziții pe care cele două hash-uri au caractere diferite. Calculează hash-urile SHA-256 pentru Plata 100 lei și Plata 101 lei, apoi afișează primele 16 caractere din fiecare hash, numărul de poziții diferite și procentul rotunjit la întreg.

  • Calculează h1 și h2 cu hashlib.sha256(...).hexdigest().
  • Scrie diferente(h1, h2) folosind zip (sau un indice) și un contor.
  • Afișează hash 1: și hash 2: urmate de primele 16 caractere ale fiecărui hash.
  • Afișează Poziții diferite: N din 64 și Procent: P%, cu P = round(N / 64 * 100).
for x, y in zip(h1, h2): if x != y: n += 1. Pentru procent: f"Procent: {round(n / len(h1) * 100)}%".

Soluția exercițiului

import hashlib


def diferente(h1, h2):
    n = 0
    for x, y in zip(h1, h2):
        if x != y:
            n += 1
    return n


h1 = hashlib.sha256("Plata 100 lei".encode()).hexdigest()
h2 = hashlib.sha256("Plata 101 lei".encode()).hexdigest()

print("hash 1:", h1[:16])
print("hash 2:", h2[:16])
n = diferente(h1, h2)
print(f"Poziții diferite: {n} din {len(h1)}")
print(f"Procent: {round(n / len(h1) * 100)}%")
Excelent! Continuă cu lecția următoare →
main.pyPython
ConsolăSe încarcă...
Mediul de lucru se încarcă. Poți citi lecția între timp.
Rulează codul cu butonul de sus sau cu Ctrl + Enter / Cmd + Enter.
Parcursul tău Primii pași în blockchain Lecția 6 · Proprietățile unui hash bun
Progres 0% 0 din 17
Lecția curentă 6 / 15 Hash