De ce nu poți modifica trecutul
Se spune că un blockchain este imutabil: ce s-a scris nu se mai schimbă. De fapt, oricine își poate modifica propria copie, dar modificarea se vede imediat. În această lecție modifici un bloc vechi, vezi cum se rupe lanțul și scrii funcția care verifică dacă un lanț este valid.
Ce se întâmplă când modifici un bloc
Să zicem că Bogdan vrea să pară că a primit 100, nu 10. Schimbă datele din blocul 1. Dar hash-ul salvat în bloc a fost calculat din datele vechi, deci nu se mai potrivește cu datele noi:
import hashlib, json
def hash_bloc(bloc):
continut = {k: v for k, v in bloc.items() if k != "hash"}
text = json.dumps(continut, sort_keys=True, separators=(",", ":"))
return hashlib.sha256(text.encode()).hexdigest()
def creeaza_bloc(index, date, hash_anterior):
bloc = {"index": index, "timestamp": 1700000000 + index * 600,
"date": date, "hash_anterior": hash_anterior}
bloc["hash"] = hash_bloc(bloc)
return bloc
lant = [creeaza_bloc(0, "Geneza", "0" * 64)]
for date in ["Ana -> Bogdan: 10", "Bogdan -> Cristina: 4"]:
lant.append(creeaza_bloc(len(lant), date, lant[-1]["hash"]))
print("înainte:", lant[1]["hash"][:16])
lant[1]["date"] = "Ana -> Bogdan: 100"
print("salvat: ", lant[1]["hash"][:16])
print("real: ", hash_bloc(lant[1])[:16])înainte: c20cf0a093283c37 salvat: c20cf0a093283c37 real: 4618b4c987be8d2e
Orice nod care recalculează hash-ul blocului 1 vede că nu este egal cu cel salvat. Modificarea a fost prinsă.
Două verificări pentru fiecare bloc
enumerate(lant) îți dă și indexul i, și blocul. Funcția întoarce indexul primului bloc invalid sau None dacă totul e în regulă:
import hashlib, json
def hash_bloc(bloc):
continut = {k: v for k, v in bloc.items() if k != "hash"}
text = json.dumps(continut, sort_keys=True, separators=(",", ":"))
return hashlib.sha256(text.encode()).hexdigest()
def creeaza_bloc(index, date, hash_anterior):
bloc = {"index": index, "timestamp": 1700000000 + index * 600,
"date": date, "hash_anterior": hash_anterior}
bloc["hash"] = hash_bloc(bloc)
return bloc
def primul_invalid(lant):
for i, bloc in enumerate(lant):
if bloc["hash"] != hash_bloc(bloc):
return i
if i > 0 and bloc["hash_anterior"] != lant[i - 1]["hash"]:
return i
return None
lant = [creeaza_bloc(0, "Geneza", "0" * 64)]
for date in ["Ana -> Bogdan: 10", "Bogdan -> Cristina: 4", "Cristina -> Dan: 2"]:
lant.append(creeaza_bloc(len(lant), date, lant[-1]["hash"]))
print("Lanț intact:", primul_invalid(lant))
lant[1]["date"] = "Ana -> Bogdan: 100"
print("După modificare:", primul_invalid(lant))
lant[1]["hash"] = hash_bloc(lant[1])
print("După recalcularea blocului 1:", primul_invalid(lant))Lanț intact: None După modificare: 1 După recalcularea blocului 1: 2
Când atacatorul recalculează hash-ul blocului 1, blocul 1 trece prima verificare, dar acum blocul 2 pică legătura. Problema doar s-a mutat cu un bloc mai încolo.
Ar putea rescrie tot lanțul?
Ca să ascundă complet modificarea, atacatorul trebuie să recalculeze toate blocurile de după cel modificat. În lanțul nostru simplu asta durează o fracțiune de secundă:
import hashlib, json
def hash_bloc(bloc):
continut = {k: v for k, v in bloc.items() if k != "hash"}
text = json.dumps(continut, sort_keys=True, separators=(",", ":"))
return hashlib.sha256(text.encode()).hexdigest()
def creeaza_bloc(index, date, hash_anterior):
bloc = {"index": index, "timestamp": 1700000000 + index * 600,
"date": date, "hash_anterior": hash_anterior}
bloc["hash"] = hash_bloc(bloc)
return bloc
def primul_invalid(lant):
for i, bloc in enumerate(lant):
if bloc["hash"] != hash_bloc(bloc):
return i
if i > 0 and bloc["hash_anterior"] != lant[i - 1]["hash"]:
return i
return None
lant = [creeaza_bloc(0, "Geneza", "0" * 64)]
for date in ["Ana -> Bogdan: 10", "Bogdan -> Cristina: 4", "Cristina -> Dan: 2"]:
lant.append(creeaza_bloc(len(lant), date, lant[-1]["hash"]))
lant[1]["date"] = "Ana -> Bogdan: 100"
for i in range(1, len(lant)):
lant[i]["hash_anterior"] = lant[i - 1]["hash"]
lant[i]["hash"] = hash_bloc(lant[i])
print("După rescrierea tuturor blocurilor:", primul_invalid(lant))
print("Ultimul hash:", lant[-1]["hash"][:16])După rescrierea tuturor blocurilor: None Ultimul hash: 6da289b213e3b3e3
Lanțul rescris este valid, dar ultimul hash este altul. Ceilalți participanți au lanțul original, cu alt ultim hash, deci tot observă diferența. În plus, rețelele reale fac rescrierea foarte scumpă: fiecare bloc cere muncă de calcul (minare), iar rețeaua onestă adaugă blocuri noi mai repede decât poate rescrie atacatorul. Vei vedea asta în modulul despre minare.
Imutabil nu înseamnă „nemodificabil fizic”
| Ce poate face atacatorul | Ce se întâmplă |
|---|---|
| modifică datele unui bloc | hash-ul salvat nu se mai potrivește: bloc invalid |
| modifică datele și recalculează hash-ul | legătura cu blocul următor se rupe |
| rescrie tot lanțul de la modificare | ultimul hash diferă de cel al rețelei; în rețele cu minare costă enorm |
| modifică doar copia lui | ceilalți nu o acceptă: au alt istoric |
Greșeli frecvente
- Verifici doar hash-ul propriu. Un atacator care recalculează hash-ul trece de această verificare; ai nevoie și de verificarea legăturii.
- Verifici legătura și pentru geneză. Geneza nu are bloc anterior: lant[-1] pentru i = 0 ar fi ultimul bloc, deci comparația ar fi greșită. Pornește legătura de la i > 0.
- **Întorci True prea devreme. Funcția poate spune că lanțul e valid abia după ce a verificat toate** blocurile.
- „Imutabil = nimeni nu poate greși.” Dacă o tranzacție greșită a intrat în lanț, rămâne acolo; se corectează cu o tranzacție nouă, nu prin ștergere.
Imutabilitatea în practică
O tranzacție cu 6 blocuri peste ea este considerată practic definitivă: atacatorul ar trebui să rescrie 6 blocuri mai repede decât toată rețeaua.
După un atac pe un smart contract, comunitatea Ethereum a ales un hard fork. Cei care au refuzat au rămas pe lanțul vechi: Ethereum Classic.
Un auditor care are ultimul hash al unui jurnal poate dovedi oricând că jurnalul nu a fost modificat de atunci.
Un registru al loturilor de medicamente legat prin hash face vizibilă orice modificare ulterioară a datelor.
Scrie funcția primul_invalid(lant) care întoarce indexul primului bloc invalid sau None, și funcția este_valid(lant) care întoarce True dacă lanțul nu are niciun bloc invalid. Pe lanțul dat, afișează rezultatul lui este_valid, apoi modifică datele blocului 2 în Bogdan -> Cristina: 40 și afișează din nou este_valid și Primul bloc invalid: 2. La final recalculează doar hash-ul blocului 2 și afișează Primul bloc invalid: 3.
- În primul_invalid, pentru fiecare bloc compară bloc["hash"] cu hash_bloc(bloc).
- Pentru blocurile cu i > 0 compară bloc["hash_anterior"] cu lant[i - 1]["hash"].
- este_valid întoarce primul_invalid(lant) is None.
- Afișează Valid: True, apoi după modificare Valid: False și Primul bloc invalid: 2, apoi după recalcularea hash-ului blocului 2 Primul bloc invalid: 3.
Soluția exercițiului
import hashlib, json
def hash_bloc(bloc):
continut = {k: v for k, v in bloc.items() if k != "hash"}
text = json.dumps(continut, sort_keys=True, separators=(",", ":"))
return hashlib.sha256(text.encode()).hexdigest()
def creeaza_bloc(index, date, hash_anterior):
bloc = {"index": index, "timestamp": 1700000000 + index * 600,
"date": date, "hash_anterior": hash_anterior}
bloc["hash"] = hash_bloc(bloc)
return bloc
def primul_invalid(lant):
for i, bloc in enumerate(lant):
if bloc["hash"] != hash_bloc(bloc):
return i
if i > 0 and bloc["hash_anterior"] != lant[i - 1]["hash"]:
return i
return None
def este_valid(lant):
return primul_invalid(lant) is None
lant = [creeaza_bloc(0, "Geneza", "0" * 64)]
for date in ["Ana -> Bogdan: 10", "Bogdan -> Cristina: 4", "Cristina -> Dan: 2"]:
lant.append(creeaza_bloc(len(lant), date, lant[-1]["hash"]))
print("Valid:", este_valid(lant))
lant[2]["date"] = "Bogdan -> Cristina: 40"
print("Valid:", este_valid(lant))
print("Primul bloc invalid:", primul_invalid(lant))
lant[2]["hash"] = hash_bloc(lant[2])
print("Primul bloc invalid:", primul_invalid(lant)) 