Lanț invalid după modificarea unui bloc
Când schimbi datele unui bloc, hash-ul lui se schimbă, iar blocul următor indică acum spre un hash care nu mai există. Lanțul redevine valid doar dacă recalculezi hash-ul blocului modificat și al tuturor blocurilor de după el.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Fiecare bloc păstrează hash-ul blocului anterior. Dacă modifici datele blocului 2, hash-ul lui se schimbă, dar blocul 3 are încă vechiul hash în câmpul hash_anterior, deci verificarea legăturii pică la blocul 3. Exact asta face un blockchain greu de falsificat: o modificare se vede imediat, în blocul de după.
Când îți construiești propriul registru și chiar trebuie să corectezi un bloc (de exemplu în teste), nu ajunge să recalculezi hash-ul blocului modificat. Trebuie să mergi mai departe pe lanț: pentru fiecare bloc următor actualizezi hash_anterior, apoi îi recalculezi hash-ul, și tot așa până la capăt. Într-un blockchain real, cu Proof of Work, ar trebui să și minezi din nou fiecare bloc, mai repede decât restul rețelei, ceea ce practic nu se poate.
De ce apare: cauzele frecvente
1Recalculezi doar hash-ul blocului modificat
lant[2]["date"] = "Ana -> Bogdan 50"
lant[2]["hash"] = hash_bloc(lant[2])lant[2]["date"] = "Ana -> Bogdan 50"
for i in range(2, len(lant)):
lant[i]["hash_anterior"] = lant[i - 1]["hash"]
lant[i]["hash"] = hash_bloc(lant[i])Blocurile de după trebuie să primească noul hash anterior și apoi propriul hash recalculat.
2Validatorul verifică doar legăturile, nu și hash-urile
def valid(lant):
return all(lant[i]["hash_anterior"] == lant[i - 1]["hash"] for i in range(1, len(lant)))def valid(lant):
for i in range(1, len(lant)):
if lant[i]["hash_anterior"] != lant[i - 1]["hash"] or lant[i]["hash"] != hash_bloc(lant[i]):
return False
return TrueDacă nu recalculezi hash-ul fiecărui bloc, o modificare a datelor fără recalculare trece neobservată.
Repară eroarea, direct în pagină
În registrul de mai jos, blocul 2 a fost corectat (suma greșită 5 devine 50), dar codul recalculează doar hash-ul blocului 2, așa că validarea afișează Lanț valid: False și Primul bloc invalid: 3. Repară funcția corecteaza ca lanțul să redevină valid și să afișeze Lanț valid: True și Primul bloc invalid: niciunul.
import hashlib, json
def hash_bloc(b):
date = {k: b[k] for k in ("index", "date", "hash_anterior")}
text = json.dumps(date, sort_keys=True, separators=(",", ":"))
return hashlib.sha256(text.encode()).hexdigest()
lant = []
prev = "0" * 64
for i, d in enumerate(["geneza", "Cris -> Ana 3", "Ana -> Bogdan 5", "Bogdan -> Cris 1", "Ana -> Cris 2"]):
b = {"index": i, "date": d, "hash_anterior": prev}
b["hash"] = hash_bloc(b)
lant.append(b)
prev = b["hash"]
def primul_invalid(lant):
for i, b in enumerate(lant):
if b["hash"] != hash_bloc(b):
return i
if i > 0 and b["hash_anterior"] != lant[i - 1]["hash"]:
return i
return None
def corecteaza(lant, i, date_noi):
lant[i]["date"] = date_noi
lant[i]["hash"] = hash_bloc(lant[i])
corecteaza(lant, 2, "Ana -> Bogdan 50")
rez = primul_invalid(lant)
print("Lanț valid:", rez is None)
print("Primul bloc invalid:", "niciunul" if rez is None else rez)Lanț valid: True Primul bloc invalid: niciunul
Indiciu
După blocul modificat, fiecare bloc trebuie să primească noul hash anterior și apoi propriul hash recalculat.
Reparația
import hashlib, json
def hash_bloc(b):
date = {k: b[k] for k in ("index", "date", "hash_anterior")}
text = json.dumps(date, sort_keys=True, separators=(",", ":"))
return hashlib.sha256(text.encode()).hexdigest()
lant = []
prev = "0" * 64
for i, d in enumerate(["geneza", "Cris -> Ana 3", "Ana -> Bogdan 5", "Bogdan -> Cris 1", "Ana -> Cris 2"]):
b = {"index": i, "date": d, "hash_anterior": prev}
b["hash"] = hash_bloc(b)
lant.append(b)
prev = b["hash"]
def primul_invalid(lant):
for i, b in enumerate(lant):
if b["hash"] != hash_bloc(b):
return i
if i > 0 and b["hash_anterior"] != lant[i - 1]["hash"]:
return i
return None
def corecteaza(lant, i, date_noi):
lant[i]["date"] = date_noi
lant[i]["hash"] = hash_bloc(lant[i])
for j in range(i + 1, len(lant)):
lant[j]["hash_anterior"] = lant[j - 1]["hash"]
lant[j]["hash"] = hash_bloc(lant[j])
corecteaza(lant, 2, "Ana -> Bogdan 50")
rez = primul_invalid(lant)
print("Lanț valid:", rez is None)
print("Primul bloc invalid:", "niciunul" if rez is None else rez)De ce merge
Modificarea blocului 2 îi schimbă hash-ul, iar blocul 3 indica încă spre vechiul hash, de aceea validarea se oprea la 3. Bucla din corecteaza merge de la blocul următor până la capăt: copiază în hash_anterior noul hash al blocului precedent și recalculează hash-ul blocului curent. Într-un blockchain cu Proof of Work, fiecare dintre aceste blocuri ar trebui și minat din nou.
Cum o eviți pe viitor
Scrie validarea cu două verificări pentru fiecare bloc: hash-ul salvat e egal cu hash-ul recalculat din date, iar hash_anterior e egal cu hash-ul blocului precedent. Rulează validarea după orice modificare. Nu modifica blocurile direct: dacă ai nevoie de date noi, adaugă un bloc nou la capătul lanțului, așa cum face un blockchain real.
Întrebări frecvente
De ce pică blocul 3, nu blocul 2, pe care l-am modificat?
Dacă ai recalculat hash-ul blocului 2, el e consistent cu datele lui. Blocul 3 însă indică spre vechiul hash al blocului 2, deci legătura dintre ele e ruptă.
Atunci cineva poate recalcula tot lanțul?
În registrul tău de exemplu, da. Într-un blockchain cu Proof of Work, recalcularea înseamnă să minezi din nou toate blocurile de după, mai repede decât minează restul rețelei. Asta e protecția.
Erori înrudite
Blocul nu trece verificarea: câmpul hash e inclus în propriul hash Calculezi hash-ul blocului din tot dicționarul, inclusiv câmpul hash. La creare câmpul nu exista (sau era gol), la verificare are deja valoarea, deci hash-ul recalculat iese mereu altul. Exclude câmpul hash din datele hash-uite. KeyError: 'hash_anterior' Ai citit dintr-un bloc (dicționar) o cheie care nu există: de obicei blocul a fost creat cu alt nume de câmp (prev_hash) sau blocul geneză nu are acest câmp. Folosește aceleași nume de câmpuri peste tot, ideal definite într-un singur loc. Hash diferit pentru aceleași date: ordinea cheilor în json.dumps Două dicționare cu aceleași date, dar cu cheile adăugate în altă ordine, dau texte JSON diferite, deci hash-uri diferite. Serializează determinist: json.dumps(date, sort_keys=True, separators=(",", ":")). Învață Blockchain de la zero, cu exerciții la fiecare lecție
Curs Blockchain și criptomonede: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.
