Shopping Cart
0

#10 | 💪🏻 Brute-Force di una chiave privata

Tempo di lettura: 4 minuti

👉🏻 Clicca qui per guardare la versione video su YouTube 👈🏻

Cosa significa davvero “bruteforzare” una seed BIP39? Quante combinazioni serve testare? È davvero impossibile? Oggi entriamo nella parte più tecnica e affascinante: proveremo a sbloccare un wallet conoscendo solo 10 parole su 12, per capire i veri limiti di questa operazione.

Episodio 10 di 10 della serie sulla crittografia Bitcoin. Recupera qui gli altri episodi della serie 👉🏻 Caccia al tesoro

🔓 Quando puoi forzare una seed?

Partiamo da una situazione comune in questa challenge:

stridulo barbaro paonazzo tralcio surgelato erario usanza maretta editoria sillaba ? ?

Conosciamo 10 parole su 12… o 13?!

Non puoi testare miliardi di combinazioni a caso, devi ragionare come un investigatore:

  • Indizi: Alcune parole possono essere dedotte (iniziali, tema o ordine).
  • Checksum: Non tutte le combinazioni sono valide: ogni seed BIP39 ha un checksum (4 bit di controllo).
  • Target preciso: Se conosci l’indirizzo Bitcoin con il bottino, puoi testare solo le combinazioni che generano quell’indirizzo.

Ecco la vera sfida: ottimizzare la ricerca, filtrare le parole e lavorare in parallelo con più macchine.

⚙️ Come verificare una seed?

1️⃣ Mnemonic Slots

Mnemonic Slots è un sito interessante per fare test con le combinazioni di parole di una seed BIP39. Non serve per attacchi reali, ma è un buon modo per capire come funzionano le mnemonic e quanto sia improbabile indovinare una combinazione valida per caso.

Puoi provare a generare combinazioni casuali e vedere come queste vengono trasformate in indirizzi. È una sorta di slot machine crittografica: divertente per chi vuole visualizzare il meccanismo senza toccare codice.

2️⃣ Private Key Finder

PrivateKeyFinder è un sito che mostra pagine di chiavi private Bitcoin generate casualmente con i relativi indirizzi. Se per pura fortuna ne trovassi una con saldo, potresti spenderla. A differenza del tool di prima qui hai decine e decine di chiavi sulla stessa schermata.

È uno strumento utile per capire quanto lo spazio delle chiavi sia immenso e perché è matematicamente quasi impossibile trovare un portafoglio attivo per caso. Serve più come esercizio mentale che come reale metodo di scoperta.

Clicca sull’immagine e registrati con il codice “COSTANZA”

3️⃣ btcRecover

BtcRecover è uno strumento che avvia un piccolo programmino sul tuo computer ed inizia a scansionare la blockchain in cerca di una seedphrase con saldo.

È molto utile perchè si può configurare per cercare più precisamente dove vogliamo. Questo restringe di molto il campo di ricerca. Nel nostro ho preparato una piccola guida che ti mostra come eseguirlo e come utilizzarlo al meglio.

Ecco cosa ti permette di fare questo programmino:

  • Inserire le parole mancanti come “?” per farle cercare
  • Impostare una serie di passphrase di ricerca
  • Impostare il tipo di indirizzo target
  • Definire lo spazio di ricerca negli indirizzi

Il programma in automatico proverà SOLO le seedphrase valide (ovvero quelle che danno un checksum corretto) e di queste guarderà se le chiavi pubbliche hanno del saldo (allora hai vinto qui BTC!) oppure no.

1- Copia ed incolla questo blocco

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
brew install python
python3 -m venv btc-env
source btc-env/bin/activate
pip install --upgrade pip
pip install mnemonic bip-utils requests
mkdir -p wordlists
curl -o wordlists/bip39_italian.txt https://raw.githubusercontent.com/bitcoin/bips/master/bip-0039/italian.txt
nano bruteforce.py

2- Copia ed incolla questo blocco, dopo clicca in sequenza: CTRL + X , Y , INVIO

import requests
import time
from itertools import product
from mnemonic import Mnemonic
from bip_utils import (
    Bip39SeedGenerator,
    Bip44, Bip44Coins,
    Bip84, Bip84Coins,
    Bip86, Bip86Coins,
    Bip44Changes
)

mnemo = Mnemonic("italian")
with open("wordlists/bip39_italian.txt", "r", encoding="utf-8") as f:
    wordlist = [w.strip() for w in f.readlines()]

# Input seed
partial_seed = input("Inserisci la seed parziale (usa '?' per ogni parola mancante): ").strip()
words = partial_seed.split()
missing_indexes = [i for i, w in enumerate(words) if w == "?"]

if len(missing_indexes) == 0:
    print("Errore: devi indicare almeno una parola mancante con '?'")
    exit(1)

# Input passphrase
use_passphrase = input("Vuoi provare una passphrase? (sì/no): ").strip().lower()
if use_passphrase in ["sì", "si"]:
    passphrases_input = input("Inserisci una o più passphrase separate da virgola: ").strip()
    passphrases = [p.strip() for p in passphrases_input.split(",")]
else:
    passphrases = [""]

# Selezione tipo di indirizzo
print("\nSeleziona il tipo di indirizzo da scansionare:")
print("1 = Legacy (1...)")
print("2 = SegWit (bc1q...)")
print("3 = Taproot (bc1p...)")
address_type_input = input("Scelta: ").strip()

if address_type_input == "1":
    address_types = [(Bip44Coins.BITCOIN, "Legacy (P2PKH)", Bip44)]
elif address_type_input == "2":
    address_types = [(Bip84Coins.BITCOIN, "Native SegWit (bc1q)", Bip84)]
elif address_type_input == "3":
    address_types = [(Bip86Coins.BITCOIN, "Taproot (bc1p)", Bip86)]
else:
    print("Errore: selezione tipo indirizzo non valida.")
    exit(1)

# Numero di indirizzi
try:
    num_addresses = int(input("Quanti indirizzi vuoi scansionare (es: 20)? ").strip())
except ValueError:
    print("Errore: inserire un numero valido.")
    exit(1)

total_combinations = len(wordlist) ** len(missing_indexes)
print(f"Proverò {total_combinations:,} combinazioni possibili (x {len(passphrases)} passphrase). Inizio...")

def get_balance(address):
    url = f"https://blockstream.info/api/address/{address}"
    try:
        r = requests.get(url)
        r.raise_for_status()
        data = r.json()
        funded = data.get("chain_stats", {}).get("funded_txo_sum", 0)
        spent = data.get("chain_stats", {}).get("spent_txo_sum", 0)
        return funded - spent
    except Exception as e:
        print(f"Errore API su {address}: {e}")
        return 0

found = False

for combo in product(wordlist, repeat=len(missing_indexes)):
    if found:
        break

    candidate_words = words.copy()
    for idx, replacement in zip(missing_indexes, combo):
        candidate_words[idx] = replacement

    candidate_seed = " ".join(candidate_words)
    if not mnemo.check(candidate_seed):
        continue

    for passphrase in passphrases:
        print(f"\nSeed valida trovata: {candidate_seed} - Passphrase: '{passphrase}' - controllo saldo...")

        seed_bytes = Bip39SeedGenerator(candidate_seed).Generate(passphrase)

        for coin_type, label, bip_class in address_types:
            print(f"  ➤ Verifica standard: {label}")
            bip = bip_class.FromSeed(seed_bytes, coin_type)

            for i in range(num_addresses):
                try:
                    addr = bip.Purpose().Coin().Account(0).Change(Bip44Changes.CHAIN_EXT).AddressIndex(i).PublicKey().ToAddress()
                    print(f"    → {addr}")
                    balance = get_balance(addr)
                    if balance > 0:
                        print("\n💰 SALDO TROVATO!")
                        print(f"Seed: {candidate_seed}")
                        print(f"Passphrase: {passphrase}")
                        print(f"Indirizzo: {addr}")
                        print(f"Saldo: {balance} satoshi")
                        found = True
                        break
                    time.sleep(0.1)
                except Exception as e:
                    print(f"Errore generazione indirizzo: {e}")
                    continue
            if found:
                break
        if found:
            break

if not found:
    print("\nNessun saldo trovato.")

3- Copia ed incolla questo e premi INVIO

python3 bruteforce.py

4- Segui le istruzioni che ti darà il terminale

Se hai un sistema operativo windows, può facilmente chiudere a ChatGPT di darti i comandi corretti. In ogni caso ti consiglio la visione del video se hai problemi.

🎯 La sfida è aperta

Come scoprirai tu stesso, bruteforzare una seed BIP39 non è un gioco da ragazzi:

  • Lo spazio di ricerca è enorme.
  • Servono strumenti, conoscenze e tanta pazienza.
  • Con poche parole mancanti e un buon setup… è comunque difficile. Ma non impossibile 👀

Questa challenge dimostra quanto sia cruciale custodire ogni singola parola della tua seed, bene, al sicuro, nell’ordine corretto.

Perdere un pezzo può significare rischiare di non ritrovare mai più i propri fondi.

🙏🏻 Fine della serie

È stato un viaggio entusiasmante e ricchissimo di informazioni che non si sentono tutti i giorni.

Spero che questa caccia al tesoro ti sia piaciuta e che tu abbia imparato nuove cose!

Se vuoi supportare altre iniziative del genere continua a seguirmi e soprattutto condividi questi contenuti con il tuo gruppo di amici.

Grazie mille in anticipo, alla prossima 🔥

Episodio 10 di 10 della serie sulla crittografia Bitcoin. Recupera qui gli altri episodi della serie 👉🏻 Caccia al tesoro

🤬 La parola di oggi è: 10. sillaba

Flash News

Articoli correlati