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
| Proprietate | Ce înseamnă | De ce contează în blockchain |
|---|---|---|
| Determinist | aceleași date dau mereu același hash | toate nodurile calculează același hash pentru același bloc |
| Rapid | calculul durează microsecunde | un nod verifică mii de blocuri repede |
| Efect de avalanșă | o schimbare minimă schimbă cam jumătate din biți | orice modificare, oricât de mică, se vede |
| Ireversibil (one-way) | din hash nu poți afla datele | hash-ul nu dezvăluie nimic și nu poate fi „fabricat” pentru un rezultat dorit |
| Rezistent la coliziuni | nimeni nu poate găsi două intrări cu același hash | nu poți înlocui un bloc cu altul care are aceeași amprentă |
„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.
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 %
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ă
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.
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.
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.
Google și CWI au creat două PDF-uri diferite cu același SHA-1: de aceea SHA-1 nu mai e folosit pentru securitate.
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).
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)}%") 