Lanțul: fiecare bloc indică spre cel dinainte
Un bloc singur este doar o pagină. Ce face din blocuri un lanț este câmpul hash_anterior: fiecare bloc păstrează amprenta blocului de dinaintea lui. În această lecție creezi blocul geneză și legi blocurile unul de altul în Python.
Legătura: hash_anterior
Imaginează-ți un caiet în care, pe fiecare pagină nouă, copiezi sigiliul paginii anterioare. Dacă cineva rupe sau modifică o pagină, sigiliul copiat pe pagina următoare nu se mai potrivește. Exact asta face hash_anterior.
Fiecare bloc indică înapoi, spre blocul vechi. Un bloc nu știe nimic despre blocurile care vor veni după el, pentru că hash-ul lor nu există încă atunci când el este creat.
Blocul geneză
Primul bloc nu are niciun bloc înaintea lui. Prin convenție, câmpul lui hash_anterior conține 64 de zerouri ("0" * 64). El se numește blocul geneză (genesis block) și este scris direct în codul programului: toate nodurile pornesc de la același geneză.
Pentru blocurile noastre folosim funcția hash_bloc din lecția trecută, cu o mică schimbare: blocul păstrează acum și propriul hash în câmpul hash, dar hash-ul se calculează din toate celelalte câmpuri (dictionary comprehension-ul sare peste cheia hash). Funcția creeaza_bloc construiește blocul și îi adaugă amprenta:
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
geneza = creeaza_bloc(0, "Geneza", "0" * 64)
print(geneza["index"], geneza["hash_anterior"][:12])
print(geneza["hash"])0 000000000000 d2091b27f7b9191c744ead8737800c9b4b68dd0ee434a5670aeeda30d6b053b3
Legăm blocurile
Fiecare bloc nou primește ca hash_anterior hash-ul blocului creat înainte:
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
geneza = creeaza_bloc(0, "Geneza", "0" * 64)
b1 = creeaza_bloc(1, "Ana -> Bogdan: 10", geneza["hash"])
b2 = creeaza_bloc(2, "Bogdan -> Cristina: 4", b1["hash"])
for bloc in [geneza, b1, b2]:
print(bloc["index"], bloc["hash_anterior"][:12], "->", bloc["hash"][:12])0 000000000000 -> d2091b27f7b9 1 d2091b27f7b9 -> c20cf0a09328 2 c20cf0a09328 -> 364ce6fff828
Observă că primele 12 caractere ale lui hash_anterior din blocul 1 sunt chiar începutul hash-ului geneză, iar ale blocului 2 sunt începutul hash-ului blocului 1.
Lanțul ca listă
Lanțul întreg este o listă de blocuri. Ultimul bloc este lant[-1], iar indexul blocului nou este chiar len(lant):
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"]:
ultimul = lant[-1]
lant.append(creeaza_bloc(len(lant), date, ultimul["hash"]))
print("Blocuri:", len(lant))
print(lant[2]["hash_anterior"] == lant[1]["hash"])Blocuri: 3 True
De ce contează ordinea câmpurilor din hash
Pentru a verifica dacă două copii ale lanțului sunt identice, nodurile nu compară blocurile unul câte unul: compară hash-ul ultimului bloc.
Greșeli frecvente
- **Folosești același hash_anterior pentru toate blocurile. Fiecare bloc trebuie să primească hash-ul blocului imediat anterior**, deci lant[-1]["hash"] în momentul creării.
- Calculezi hash-ul înainte să completezi toate câmpurile. Orice câmp adăugat după calcul nu este protejat de hash.
- **Includ câmpul hash în calcul.** Ar trebui să știi rezultatul înainte să-l calculezi; de aceea hash_bloc sare peste el.
- **Geneza cu hash_anterior = "0".** Merge, dar convenția este 64 de zerouri, ca toate hash-urile să aibă aceeași lungime.
Lanțuri în lumea reală
Lanțul Bitcoin are acum peste 900 000 de blocuri, fiecare legat de cel dinainte, până la geneza din 2009.
Fiecare commit conține hash-ul commit-ului părinte: istoricul unui proiect este tot un lanț de hash-uri.
Jurnalele publice ale certificatelor HTTPS folosesc tot structuri de hash-uri ca să nu poată fi modificate pe ascuns.
Au propus legarea documentelor prin hash pentru datare sigură; ideea apare citată în whitepaper-ul Bitcoin.
Folosind funcțiile hash_bloc și creeaza_bloc date, construiește un lanț de 3 blocuri cu datele Bloc geneză, Cristina -> Dan: 3 și Dan -> Ana: 1 (geneza are hash_anterior format din 64 de zerouri). Apoi afișează pentru fiecare bloc o linie de forma 0 | anterior: 000000000000 | hash: 1a2b3c4d5e6f, cu primele 12 caractere din hash_anterior și din hash.
- Creează geneza cu creeaza_bloc(0, "Bloc geneză", "0" * 64) și pune-o într-o listă lant.
- Adaugă celelalte două blocuri, fiecare cu hash_anterior egal cu hash-ul ultimului bloc din lanț.
- Parcurge lanțul și afișează indexul, primele 12 caractere din hash_anterior și din hash.
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
lant = [creeaza_bloc(0, "Bloc geneză", "0" * 64)]
for date in ["Cristina -> Dan: 3", "Dan -> Ana: 1"]:
lant.append(creeaza_bloc(len(lant), date, lant[-1]["hash"]))
for b in lant:
print(f"{b['index']} | anterior: {b['hash_anterior'][:12]} | hash: {b['hash'][:12]}") 