Rovereto, sabato 21 novembre 2026 · Anno XIII, n. 325 Blocco 976951
it
Bitcoin Valley
SommarioChiudi

Cronache dalla valle dove si paga in bitcoin.

Impara · Per chi programma

Busta chiusa

Sei esercizi del corso per sviluppatori del 2018, rifatti per oggi. Le soluzioni sono già in pagina, chiuse in un hash: si aprono solo con la risposta giusta.

Nell'autunno del 2018, mentre al Mani al Cielo si pagava con Lightning, la squadra di sviluppo di inbitcoin scriveva le lezioni del corso per sviluppatori bcademy: quaderni Jupyter, uno per argomento, con il codice da completare.1 Ne restano ventuno, dalla terza alla sesta settimana. Abbiamo preso le domande che valgono ancora e le abbiamo rifatte per il 2026, con i numeri veri di quelle lezioni dove si poteva.

Serve Python 3.9 o più recente, e basta: niente da installare, tutto con la libreria standard. Ogni esercizio chiede un'ora, più o meno.

Come funziona la busta

Sotto ogni esercizio c'è una busta: una riga di 64 caratteri, l'hash SHA-256 di busta-chiusa/ seguito dal numero dell'esercizio, una barra e la risposta. Scrivi la tua risposta e il telefono calcola l'hash: se viene uguale alla busta, hai trovato la risposta, e nessuno te l'ha detta. Nemmeno questa pagina la conosce.

L'idea non è nostra: una lezione del 2018 dava già le soluzioni così, come hash da confrontare. È un impegno crittografico (commitment), e attraversa tutto il corso: gli alberi di Merkle, le fatture di Lightning, i sigilli di RGB. Il sesto esercizio insegna ad aprire le buste senza risolvere niente, e lì si capisce quando reggono.

Per controllare dal terminale, con la risposta scritta in minuscolo e senza spazi:

printf 'busta-chiusa/3/%s' "$RISPOSTA" | sha256sum

1. L'hash fatto a mano

Il programma del corso cominciava così: «crea la tua funzione di hash». Come esempio dava questa, che moltiplica un numero primo per ogni lettera, elevato a una potenza che dipende dalla lettera e dalla posizione:

def basic_hash(in_str):
    m = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101]
    v = 1
    base = ord('a')
    MAX = 2 ** 64
    for i, c in enumerate(in_str):
        idx = ord(c) - base + 1
        assert 0 <= idx <= 25
        v *= m[idx] ** (idx + i)
    return v % MAX

Prova basic_hash('moneta') e basic_hash('monete'): una lettera di differenza, numeri lontanissimi, come deve essere. Poi prova basic_hash('pizza').

La domanda: con parole di sole lettere minuscole, dalla a alla y, quanti risultati diversi può dare, al massimo, basic_hash? Scrivi il numero intero. Un aiuto: guarda l'ultimo bit dei risultati.

Per aprire la busta serve JavaScript.

Dopo la busta: cosa insegna

Un errore di uno nell'indice fa entrare l'apice inverso (`, l'unico che porta il 2) e lascia fuori la z. Senza il 2, ogni parola è un prodotto di primi dispari, e il risultato è sempre dispari: metà dei valori possibili non esce mai. Una funzione di hash vera accetta qualunque sequenza di byte e usa tutti i suoi bit allo stesso modo. Per questo Bitcoin usa SHA-256, e non una funzione inventata in casa.

2. La prova in quattro numeri

Nell'intestazione di un blocco non ci sono le transazioni: c'è un solo hash, la radice di un albero di Merkle costruito sopra di loro. La lezione del 2018 lo faceva costruire a mano, con transazioni finte di due byte e un hash da quattro caratteri, perché tutto stesse su un foglio:

from hashlib import md5   # MD5 non è sicuro: qui serve solo a fare numeri corti

def merge(a, b):
    return md5(a + b).digest()[:2]

txids = [bytes.fromhex(x) for x in
         'b930 9162 5a4e 9808 f157 7dc1 754e 1ddb e758 e747 59a1 ce11 0b4d 7181 d68b 3790'.split()]

Scrivi make_tree(txids), che restituisce i livelli dell'albero, dalle foglie alla radice. Se la radice viene b63d, è lo stesso albero del 2018. Poi scrivi make_proof(index, tree) e check_proof(txid, root, proof): la prova che 1ddb sta nel blocco sono quattro numeri, non sedici. Il testimone fa vedere quali, da toccare col dito.

La lezione poi chiedeva: e se le transazioni sono dispari? Bitcoin accoppia l'ultima con sé stessa. Prova con un blocco di sette:

third_block = [bytes.fromhex(x) for x in '1ff1 df9f 491a 952d 4691 0efa 7245'.split()]

La domanda: qual è la radice di third_block, con la regola di Bitcoin? Scrivi i quattro caratteri esadecimali.

Per aprire la busta serve JavaScript.

Dopo la busta: il doppione

Il quaderno del 2018 chiudeva con una domanda maliziosa: sai trovare un'altra lista di transazioni con la stessa radice? Basta ripetere l'ultima, 7245, e la radice non cambia. È un difetto vero dell'albero di Bitcoin, il CVE-2012-2459, e il codice di Bitcoin Core lo spiega in un commento che comincia con «WARNING!» e si rivolge proprio a chi sta imparando. La difesa: un blocco con due transazioni uguali in fondo a un livello viene scartato come «bad-txns-duplicate», ma la sua intestazione non viene segnata come non valida, perché la stessa intestazione appartiene anche al blocco buono.6

3. Dodici parole, l'ultima a scelta

Le parole di recupero di un wallet seguono il BIP-39: 128 bit casuali, più 4 bit di controllo presi dallo SHA-256 di quei 128, fanno 132 bit, cioè dodici gruppi da 11. Ogni gruppo è il numero di una parola in un elenco di 2.048.2 La lezione del 2018 lo faceva costruire passo per passo.

Scarica l'elenco inglese ufficiale, english.txt dal repository dei BIP, e controlla che sia quello giusto: il suo SHA-256 è 2f5eed53a4727b4bf8880d8f3f199efc90e58503646d9ff8eff3a2ed3b24dbda. Scrivi valid_mnemonic(words), che controlla i bit di controllo.

Per provare il tuo codice usa solo le frasi di prova pubbliche del BIP-39, come undici volte abandon e poi about. Le parole di un wallet vero non vanno mai in un programma né in un sito: si scrivono su carta e basta.

Un controllo a metà strada: con hashlib.pbkdf2_hmac("sha512", ...), 2.048 giri e la passphrase di prova TREZOR, il seme di quella frase comincia con c55257c360c07c72.

La domanda: le prime undici parole sono abandon. Quante parole dell'elenco, messe al dodicesimo posto, danno una frase valida?

Per aprire la busta serve JavaScript.

Dopo la busta: perché proprio quelle

L'ultima parola porta 7 bit casuali e i 4 di controllo. I 7 bit si possono scegliere liberamente, i 4 no: li decide lo SHA-256 di tutto il resto. Una dodicesima parola presa a caso è giusta una volta su sedici: per questo, quindici volte su sedici, il wallet si accorge di una parola ricopiata male.

4. Perché due derivazioni

Il quaderno sul BIP-32 del 2018, quello dei wallet che da un seme solo generano un albero di chiavi, faceva una domanda e la lasciava lì: «perché ci sono due algoritmi per creare le chiavi figlie?». Le chiavi normali si derivano anche dalla sola chiave pubblica estesa, l'xpub: un registro delle entrate può generare tutti gli indirizzi senza poter spendere. Le chiavi hardened no. Questo esercizio risponde con un attacco.

Un collega ha condiviso l'xpub del suo conto di prova, per farsi un registro delle entrate. Poi, per un test, ha incollato in una chat la chiave privata dell'indirizzo numero 5, derivato in modo normale. Sono chiavi della rete di prova, nate da un seme scritto in questa pagina: chiunque le può ricostruire, e non ci sono soldi sopra.

tpub = "tpubD9KA96Wig8KzCRAX9ESPbuaNUd9tkUahrq1j9vR86hUEZkovCnvpg6yZoyeJg7kVjVDaYkJob9BXPg7C9S8D5SsTx6sx3AT9hLrgLtrJp3H"
child_5 = 0x9dbb596bfa26edc00c6e4b90f73227cf1279ce54a8efabe400f9c69106d3aff1
N = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141   # l'ordine di secp256k1

Ti servono due cose dalla specifica del BIP-32: il formato di una chiave estesa (78 byte in base58 con controllo: il codice di catena sta nei byte da 13 a 44, la chiave pubblica compressa da 45 a 77) e la formula della derivazione normale. La chiave figlia è la somma, modulo N, della chiave madre e di un numero, IL, che si calcola con HMAC-SHA512 usando il codice di catena come chiave, e la chiave pubblica madre più l'indice come messaggio. Tutto quello che serve per calcolare IL sta nell'xpub.

Non serve fare conti sulla curva ellittica. Il base58 lo scrivi in sei righe: è una conversione di base, con un alfabeto senza 0, O, I e l.

La domanda: qual è la chiave privata madre? Scrivila in esadecimale, 64 caratteri.

Per aprire la busta serve JavaScript.

Dopo la busta: la risposta del 2018

Con l'xpub e una sola chiave privata figlia normale si risale alla chiave madre, e da lì a tutte le chiavi del conto. Il BIP-32 lo scrive nella sezione sulla sicurezza: una chiave pubblica estesa va trattata con più cura di una chiave pubblica qualunque.3 Per questo i wallet derivano con hardened i livelli alti del percorso (m/84'/0'/0'), dove l'apice vuol dire indice da 231 in su e HMAC calcolato con la chiave privata, e lasciano normali solo gli ultimi, quelli degli indirizzi. Chi riceve un xpub vede anche tutti gli incassi di quel conto.

5. Il tempo relativo

Il BIP-68 dà un senso nuovo al campo nSequence di ogni input: un'attesa minima dalla conferma dell'output che si spende, in blocchi o in multipli di 512 secondi. Il BIP-112 aggiunge l'istruzione OP_CHECKSEQUENCEVERIFY, che mette quell'attesa dentro lo script.4 Le regole: se il bit 31 è acceso, il campo non vale come attesa; se è acceso il bit 22, l'attesa è a tempo; il valore sta nei 16 bit bassi.

Il quaderno del 2018 dava sette numeri da decifrare:

nsequences = [6, 506353076, 2147483647, 4194310, 4259839, 2147483648, 2822828760]

def decode_nsequence(n_seq):
    """Restituisce ('blocks', n), ('time', secondi) o ('disabled', 0)."""

Scrivi la funzione, e prima di fidarti guarda i numeri in esadecimale: qualcuno ha dei bit accesi dove non te li aspetti.

La domanda: quanti blocchi deve aspettare l'input con nSequence 506353076?

Per aprire la busta serve JavaScript.

Dopo la busta: i bit di riserva

506353076 è 0x1e2e55b4: ha accesi diversi bit che il BIP-68 non usa, e vanno ignorati. Sono lasciati liberi apposta: il quaderno chiedeva se un soft fork potrebbe allungare l'attesa a dieci anni, e il BIP-68 risponde che quei bit servono proprio ad aumentare la durata massima o la precisione, in futuro. Oggi l'attesa relativa lavora in ogni canale Lightning: chi chiude un canale da solo aspetta to_self_delay blocchi prima di spendere la sua parte, e in quel tempo l'altro può punire una chiusura fatta con uno stato vecchio.5

Al 52° Bitcoin Milano Meetup, il 13 giugno 2018, il canale si spiegava proprio così: Alice tiene in mano una transazione che vale solo dal 31 dicembre, così sa di riavere i suoi soldi anche se Bob sparisce, e Bob sa che deve chiudere prima.8

Una nota sulle buste del 2018. Il quaderno dava le soluzioni di questo esercizio come sette hash RIPEMD-160, con la funzione per calcolarli. Rifacendo i conti oggi, con la soluzione del docente, nessuna si apre: chi le ha chiuse ha usato una ricetta un po' diversa da quella scritta, e noi non l'abbiamo trovata. Una busta vale quanto la ricetta pubblicata con lei: per questo qui la ricetta è scritta in cima alla pagina.

6. Apri la busta

Questa busta contiene quattro caratteri esadecimali, da 0000 a ffff, e nessun esercizio da risolvere.

La domanda: quali sono? Hai la ricetta, hai Python, e ci sono solo 65.536 possibilità.

Per aprire la busta serve JavaScript.

Con lo stesso ciclo si aprono le buste 2 e 5 senza fare l'esercizio, e la 3 e la 1 con qualche tentativo ragionato. Regge solo la 4, che nasconde un numero di 256 bit. Un hash nasconde soltanto quello che è difficile da indovinare: se le risposte possibili sono poche, la busta è di vetro.

Lightning usa la stessa busta, nella versione che regge. Ogni fattura contiene un payment_hash, lo SHA-256 di 32 byte casuali che conosce solo chi incassa: il preimage. Chi incassa riscuote solo rivelando il preimage, e chi paga se lo ritrova in mano come ricevuta.7 Nessuno può aprire la busta prima, perché 2256 tentativi non li fa nessuno. Allo stesso meetup di Milano il contratto si raccontava come una scatola nera da cui i bitcoin escono quando qualcuno mostra il preimage di un hash; tre settimane dopo, a Venezia, Amadori lo spiegava con Alice che deve pagare Eric: Eric crea il segreto e ad Alice dà solo l'hash.9

La fattura di Eric2.000 sat · H = SHA-256(R)H è la busta chiusa: R lo sa solo EricAndata«paga se mostri R»RitornoR apre le buste2.003 satentro 160 blocchiRBob mostra Re incassa 2.003 sat2.002 satentro 120 blocchiRCarol mostra Re incassa 2.002 sat2.001 satentro 80 blocchiRDiana mostra Re incassa 2.001 sat2.000 satentro 40 blocchiREric mostra Re incassa 2.000 satAlicepaga 2.003 satBobtiene 1 satCaroltiene 1 satDianatiene 1 satEricconosce R
Ridisegnato dalla storia che si raccontava ai meetup del 2018, con i prezzi di oggi. Andando verso Eric la scadenza si accorcia di 40 blocchi a passaggio, poco meno di sette ore: chi sta in mezzo ha sempre il tempo di incassare da chi lo precede, dopo aver visto R.

Nel 2019 inbitcoin ha raccontato dove porta l'idea, nel suo contributo a un progetto di ricerca con l'Università della Calabria: i sigilli monouso, «una versione digitale della fascetta numerata per pacchi», e RGB, nato nel 2015-2016 dalle sessioni di ricerca di Blockchainlab a Milano, a cui inbitcoin partecipava.10 Lì la busta sta dentro una transazione bitcoin qualunque, nascosta in una chiave pubblica: non si legge, si dimostra dopo, a chi serve.

Cosa è cambiato dal 2018

Il resto del corso parlava di strumenti che nel frattempo sono cambiati. Se riprendi i quaderni, tieni presente:

  • BIP-70, il protocollo di pagamento che il corso faceva usare con un server di prova, è stato tolto da Bitcoin Core nella versione 0.20, nel 2020.11 Oggi la richiesta di pagamento on-chain è il vecchio BIP-21, bitcoin:indirizzo?amount=…, e per Lightning la fattura del BOLT 11.
  • Le API di blockchain.info degli esercizi del programma non servono: il tuo nodo risponde alle stesse domande, e un explorer open source come mempool.space si installa in casa.
  • Taproot (BIP-340, 341 e 342) è attivo dal blocco 709.632, novembre 2021: firme Schnorr, che si provano nella firma.12
  • Le specifiche di Lightning non stanno più in lightning-rfc: il repository si chiama lightning/bolts.
  • Lighter, il caso di studio della sesta settimana, è fermo dal 2020. La sua storia sta nella cronaca.

Una cosa del 2018 invece vale com'era: l'esercizio sulle unità di Lightning chiedeva di convertire bitcoin, satoshi e millisatoshi troncando, mai arrotondando. Aggiungiamo un dettaglio per chi scrive un wallet nel browser: 21 milioni di bitcoin in millisatoshi sono 2,1 × 10¹⁸, oltre il limite degli interi esatti di JavaScript (Number.MAX_SAFE_INTEGER, circa 9 × 10¹⁵). Per i millisatoshi servono BigInt o stringhe.

In classe: testa o croce in busta

Quindici minuti, per una classe di informatica o per chiunque abbia un telefono. Serve una moneta vera, e questo sigillo:

Per il sigillo serve JavaScript.

  1. Fai fare un pronostico. Ognuno sceglie testa o croce, la scrive nel sigillo e copia alla lavagna, accanto al suo nome, i primi otto caratteri (quelli in rosso).
  2. Lancia la moneta. Chi ha indovinato rivela la sua scelta; la classe la riscrive nel sigillo e controlla che vengano gli stessi otto caratteri. Nessuno può cambiare idea dopo il lancio.
  3. Fai notare il buco. Prima del lancio bastava scrivere «testa» e «croce» nel sigillo per conoscere il pronostico di tutti: le risposte possibili erano due.
  4. Ripeti con una parola segreta. Ognuno aggiunge parole che conosce solo chi le scrive: «testa gatto blu 17». Ora la lavagna non dice niente fino alla rivelazione.

Quell'aggiunta segreta è il preimage di Lightning, e i 32 byte casuali di una fattura fanno lo stesso lavoro. Per un'ora intera con gli studenti c'è In classe; per le soluzioni di riferimento in Python, scrivici.

Il testimone Tutte le lezioni


  1. Corso bcademy, quaderni Jupyter delle settimane 3-6 (versione per gli studenti e per il docente) e programma del corso, settembre-novembre 2018; archivio di inbitcoin. Le domande e il codice del 2018 citati qui vengono da lì: la funzione basic_hash (programma), i sedici txid e il blocco di sette (lezione 5b), la domanda sul BIP-32 (lezione 4c), i sette nSequence (lezione 5h), le unità di Lightning (lezione 6c). ↩

  2. BIP-39, letto il 20 novembre 2026. La frase di prova e il seme con la passphrase TREZOR sono il primo dei vettori di prova ufficiali, nel repository di riferimento python-mnemonic. ↩

  3. BIP-32, sezione «Security», letto il 20 novembre 2026. La chiave estesa di questo esercizio nasce dal seme SHA-256 di «bcademy, Rovereto, novembre 2018», percorso m/0', e la chiave trapelata è m/0'/5. ↩

  4. BIP-68 e BIP-112, letti il 20 novembre 2026. I bit liberi sono nella sezione «Deployment» del BIP-68. ↩

  5. BOLT 3, l'uscita to_local, letto il 20 novembre 2026. ↩

  6. Bitcoin Core, src/consensus/merkle.cpp, il commento in testa al file, e bad-txns-duplicate in src/validation.cpp, letti il 20 novembre 2026. ↩

  7. BOLT 11, il campo p: «Preimage of this provides proof of payment». Letto il 20 novembre 2026. ↩

  8. 52° Bitcoin Milano Meetup, «Layer 2: Lightning Network», 13 giugno 2018, min. 8; il contratto con l'hash al min. 11. ↩

  9. Amadori al Bitcoin Venezia Meetup, «Lightning Network è arrivato», 2 luglio 2018, min. 26. ↩

  10. Marco Amadori e Martino Salvetti, The path to Blockchain Enabled Smart Contracts, contributo di inbitcoin al progetto di ricerca IOT&B con Blockchainlab e Università della Calabria, 3 dicembre 2019, aggiornato al 24 febbraio 2020, licenza CC BY-SA 4.0; archivio di inbitcoin. La citazione è a p. 6; la «piccola parentesi storica» sulla nascita di RGB alle pp. 5-6. ↩

  11. Note di rilascio di Bitcoin Core 0.20.0: «BIP70 support has been fully removed». ↩

  12. Note di rilascio di Bitcoin Core 0.21.1: Taproot attivo dal blocco 709632. ↩