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.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Nu primești o excepție, ci un bloc care pică validarea chiar dacă nimeni nu l-a modificat. Explicația: când creezi blocul, calculezi hash-ul din dicționar înainte să adaugi cheia hash. La verificare, recalculezi hash-ul din același dicționar, dar acum el conține și cheia hash, deci textul JSON e altul și hash-ul la fel.
Nu poți repara problema „punând hash-ul înainte”: un hash nu se poate conține pe sine, pentru că orice valoare ai pune în câmp schimbă rezultatul. Regula corectă: hash-ul se calculează doar din câmpurile de conținut (index, date, timestamp, nonce, hash anterior), niciodată din câmpul care păstrează rezultatul. Cel mai sigur e să alegi explicit câmpurile, nu să elimini cheia hash după.
De ce apare: cauzele frecvente
1Hash din tot dicționarul
def hash_bloc(b):
return sha(json.dumps(b, sort_keys=True))
b = {"index": 1, "date": "x"}
b["hash"] = hash_bloc(b)
print(b["hash"] == hash_bloc(b)) # Falsedef hash_bloc(b):
date = {k: v for k, v in b.items() if k != "hash"}
return sha(json.dumps(date, sort_keys=True))
b = {"index": 1, "date": "x"}
b["hash"] = hash_bloc(b)
print(b["hash"] == hash_bloc(b)) # TrueFuncția ignoră câmpul hash, deci dă același rezultat înainte și după ce îl adaugi.
2Clasă care hash-uiește toate atributele
def calculeaza_hash(self):
return sha(json.dumps(vars(self), sort_keys=True))def calculeaza_hash(self):
campuri = {"index": self.index, "date": self.date, "hash_anterior": self.hash_anterior}
return sha(json.dumps(campuri, sort_keys=True))vars(self) include și self.hash, setat după primul calcul. Câmpurile alese explicit nu îl includ.
Repară eroarea, direct în pagină
Codul de mai jos creează trei blocuri și apoi le verifică, dar fiecare bloc nemodificat apare ca invalid (bloc N: invalid). Repară funcția hash_bloc ca să ignore câmpul hash și afișează pentru toate cele trei blocuri valid.
import hashlib, json
def hash_bloc(b):
text = json.dumps(b, sort_keys=True, separators=(",", ":"))
return hashlib.sha256(text.encode()).hexdigest()
lant = []
prev = "0" * 64
for i, d in enumerate(["geneza", "Ana -> Bogdan 5", "Bogdan -> Cris 2"]):
b = {"index": i, "date": d, "hash_anterior": prev}
b["hash"] = hash_bloc(b)
lant.append(b)
prev = b["hash"]
for b in lant:
print(f"bloc {b['index']}:", "valid" if b["hash"] == hash_bloc(b) else "invalid")bloc 0: valid bloc 1: valid bloc 2: valid
Indiciu
Construiește dicționarul de hash-uit fără cheia hash.
Reparația
import hashlib, json
def hash_bloc(b):
date = {k: v for k, v in b.items() if k != "hash"}
text = json.dumps(date, sort_keys=True, separators=(",", ":"))
return hashlib.sha256(text.encode()).hexdigest()
lant = []
prev = "0" * 64
for i, d in enumerate(["geneza", "Ana -> Bogdan 5", "Bogdan -> Cris 2"]):
b = {"index": i, "date": d, "hash_anterior": prev}
b["hash"] = hash_bloc(b)
lant.append(b)
prev = b["hash"]
for b in lant:
print(f"bloc {b['index']}:", "valid" if b["hash"] == hash_bloc(b) else "invalid")De ce merge
La creare, hash_bloc primea blocul fără cheia hash, iar la verificare cu ea, deci textul JSON era diferit și hash-ul la fel. Acum funcția construiește un dicționar nou fără câmpul hash, așa că dă același rezultat înainte și după salvarea hash-ului. Un hash nu se poate include pe sine: se calculează doar din conținutul blocului.
Cum o eviți pe viitor
În funcția de hash, alege explicit câmpurile care intră în calcul, de exemplu {k: b[k] for k in ("index", "date", "hash_anterior", "nonce")}. Testează imediat după creare: assert b["hash"] == hash_bloc(b). Dacă testul pică pentru un bloc nou, nemodificat, funcția de hash ia în calcul ceva ce nu ar trebui, de obicei chiar câmpul hash.
Întrebări frecvente
De ce primul bloc pare corect și doar verificarea pică?
Pentru că la creare cheia hash nu exista încă, deci hash-ul s-a calculat fără ea. Problema se vede abia la a doua calculare, când cheia există.
Bitcoin păstrează hash-ul în bloc?
Nu. Antetul unui bloc Bitcoin conține hash-ul blocului anterior, dar nu propriul hash. Fiecare nod îl calculează din antet. În exemplele noastre îl păstrăm doar ca să fie ușor de afișat.
Erori înrudite
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. TypeError: Object of type Bloc is not JSON serializable Ai dat lui json.dumps un obiect al clasei tale (Bloc, Tranzactie), pe care JSON nu știe să-l scrie. Transformă-l întâi în dicționar, de exemplu cu o metodă ca_dict() sau cu vars(bloc). 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.
