...
← Curs Blockchain și criptomonede: toate lecțiile
Lecția 10 · Blocuri

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ă.

Bloc 0hash_anterior0000…000dateGenezahashd209…3b3Bloc 1hash_anteriord209…3b3dateAna→Bogdan: 100hash4618…231✕Bloc 2hash_anteriorc20c…4acdateBogdan→Cristina: 4hash364c…f2fBloc 3hash_anterior364c…f2fdateCristina→Dan: 2hash41f2…797Ana → Bogdan: 10 devine 100 → hash-ul blocului 1 devine 4618…231, dar blocul 2 încă indică spre c20c…4ac
După modificarea sumei din blocul 1, hash-ul lui se schimbă, iar legătura spre blocul 2 (care păstrează hash-ul vechi) se rupe.

Două verificări pentru fiecare bloc

1
Hash-ul propriu: bloc["hash"] trebuie să fie egal cu hash_bloc(bloc) recalculat acum. Prinde orice modificare a datelor.
2
Legătura: pentru orice bloc în afară de geneză, bloc["hash_anterior"] trebuie să fie egal cu hash-ul blocului dinainte. Prinde blocurile înlocuite sau rearanjate.
3
Primul bloc care pică una dintre verificări este primul bloc invalid; tot ce urmează după el nu mai poate fi crezut.

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
Mutarea problemei

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
Ca să ascundă modificarea din blocul 1, atacatorul trebuie să recalculeze:Bloc 0neatinsBloc 1modificatBloc 2recalculatBloc 3recalculatBloc 4recalculatBloc 5…recalculatFără minare, recalcularea durează milisecunde: lanțul nostru nu e încă sigur.Cu Proof of Work, fiecare bloc costă muncă reală, iar rețeaua adaugă între timp blocuri noi.
Pentru a ascunde modificarea din blocul 1, toate blocurile următoare trebuie recalculate; fără Proof of Work, asta e foarte ușor.

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 atacatorulCe se întâmplă
modifică datele unui blochash-ul salvat nu se mai potrivește: bloc invalid
modifică datele și recalculează hash-ullegătura cu blocul următor se rupe
rescrie tot lanțul de la modificareultimul hash diferă de cel al rețelei; în rețele cu minare costă enorm
modifică doar copia luiceilalț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ă

₿Confirmările

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.

ΞThe DAO (2016)

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.

Audit

Un auditor care are ultimul hash al unui jurnal poate dovedi oricând că jurnalul nu a fost modificat de atunci.

Trasabilitate

Un registru al loturilor de medicamente legat prin hash face vizibilă orice modificare ulterioară a datelor.

Exercițiul tău

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.
for i, bloc in enumerate(lant): și două if-uri care fac return i; după buclă return None.

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))
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 10 · De ce nu poți modifica trecutul
Progres 0% 0 din 17
Lecția curentă 10 / 15 Blocuri