Codificatore mnemonic BIP-39
Sedici byte di entropia a zero diventano «abandon» undici volte seguito da «about»: BIP-39 trasforma da 128 a 256 bit in 12-24 parole inglesi con un checksum SHA-256, e restituisce l'entropia solo se quel checksum corrisponde. Gratis nel suo browser.
- Gratis
- Funziona nel suo browser
- Senza registrazione
- I suoi dati restano sul dispositivo
Esegui gratis nel browser
Esempio risolto
- Testo
- 00000000000000000000000000000000
- Modalità di calcolo
- Encode
- Input
- 00000000000000000000000000000000
- Entropia in esadecimale
- 00000000000000000000000000000000
- Numero di parole
- 12
- Bit di entropia
- 128
BIP-39 è lo standard di settore che trasforma l'entropia binaria di un portafoglio in un mnemonic leggibile da dodici a ventiquattro parole inglesi e recupera la stessa entropia solo quando i bit di checksum SHA-256 incorporati coincidono ancora. La validazione fallita non viene addebitata; le chiamate riuscite costano il prezzo base pubblicato per elemento.
Come BIP-39 mappa l'entropia in parole e viceversa
BIP-39 parte da entropia grezza di centoventotto, centosessanta, centonovantadue, duecentoventiquattro o duecentocinquantasei bit. La specifica prende i primi ENT divisi per trentadue bit del digest SHA-256 di tali byte di entropia e li aggiunge come checksum, producendo una stringa di bit la cui lunghezza è sempre multiplo di undici. Ogni gruppo di undici bit è un indice in un elenco fisso di duemilaquarantotto parole inglesi ordinate alfabeticamente da abandon a zoo.
Dodici parole corrispondono a centoventotto bit di entropia più quattro bit di checksum; quindici, diciotto, ventuno e ventiquattro parole scalano allo stesso modo fino a duecentocinquantasei bit più otto bit di checksum. La codifica è quindi interamente determinata dai byte di entropia e dall'elenco: non c'è sale, non c'è scelta di lingua in questa capacità oltre all'inglese e non c'è passo di derivazione di chiave privata.
La decodifica inverte la mappa: spezza la frase sugli spazi, cerca ogni parola, ricostruisce la stringa di bit, separa la finestra finale di checksum e verifica che quei bit coincidano con i bit iniziali dello SHA-256 dell'entropia recuperata. Se una parola è sconosciuta, il conteggio non è una delle cinque lunghezze legali o i bit di checksum non coincidono, l'operazione fallisce.
Quel disegno a fallimento chiuso spiega perché i portafogli preferiscono i mnemonic all'hex grezzo per i backup umani: una sola parola sbagliata fa quasi sempre fallire il checksum invece di sbloccare un altro portafoglio. Questa landing serve chi cerca un codificatore di mnemonic BIP-39, un convertitore da entropia a frase seed o un verificatore di checksum del mnemonic; non esegue derivazione seed PBKDF2, non genera entropia casuale e non supporta elenchi di parole non inglesi.
Vettori pratici, consigli di test e differenza dalla derivazione del seed
Preferisca decode quando una persona ha incollato una frase e deve recuperare l'entropia solo se il checksum è intatto. L'entropia classica di sedici byte tutta zero si codifica in undici parole abandon seguite da about; quella di sedici byte con tutti i bit a uno si codifica in undici zoo seguite da wrong. Esegua l'andata e ritorno in CI: codifichi, affermi il mnemonic, decodifichi, affermi l'hex originale.
Usi uno strumento BIP-32 o PBKDF2 separato se le serve il seed di sessantaquattro byte dal mnemonic più eventuale passphrase: quel passo è volutamente fuori ambito così la landing SEO resta incentrata su codifica e decodifica con verifica del checksum. Le attività fallite non consumano saldo prepagato, il che mantiene economici gli script esplorativi quando si fuzzano frasi errate. Nell'insegnamento, mostri agli studenti che due mnemonic che differiscono di una parola quasi mai condividono un checksum valido, proprietà che rende i backup manoscritti più sicuri dei dump hex grezzi.
Abbini questa capacità a utilità Base58Check o hex quando la pipeline formatta anche indirizzi o chiavi private dopo che il seed è stato derivato altrove.
Casi d'uso
Insegnare le frasi seed con checksum
Mostri i vettori classici tutto zero e tutto uno, poi cambi una parola affinché gli allievi vedano perché BIP-39 fallisce in modo chiuso invece di aprire un altro portafoglio.
Domande frequenti
Come si converte l'entropia hex in un mnemonic BIP-39?
Invii mode encode (predefinito) con text su 32, 40, 48, 56 o 64 cifre hex (16–32 byte).
Come si decodifica un mnemonic di nuovo in entropia?
Invii mode decode con text su una frase BIP-39 inglese di 12, 15, 18, 21 o 24 parole.
Cosa succede se il checksum è errato?
Frasi errate o digitate male non vengono mai addebitate e non restituiscono mai entropia falsa.
Quali elenchi di parole e lunghezze sono supportati?
Solo l'elenco ufficiale BIP-39 inglese di 2048 parole. L'entropia deve essere di 128, 160, 192, 224 o 256 bit (conteggi 12, 15, 18, 21 o 24 parole).
Questo strumento genera entropia casuale o il seed di un portafoglio?
No. Converte soltanto in parole l'entropia che lei fornisce, e viceversa, verificando il checksum. Non genera entropia casuale, non ricava il seed del portafoglio dalla frase e da una passphrase facoltativa e funziona solo con l'elenco di parole inglese.
Strumenti correlati
Per sviluppatori — accesso via API
Tutto quello che vedi in questa pagina è disponibile anche via API. Questa sezione è per i team che vogliono integrarlo nei propri sistemi; chi non ne ha bisogno può semplicemente usare lo strumento qui sopra.
Endpoint
Autenticazione con Bearer token: un POST mette in coda l'attività e il risultato arriva via webhook o link firmato.
Chiamala dal tuo stack
curl -X POST https://api.kit.forhosting.com/enc/bip39 \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"00000000000000000000000000000000"}'const res = await fetch("https://api.kit.forhosting.com/enc/bip39", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "00000000000000000000000000000000"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/enc/bip39",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "00000000000000000000000000000000"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/bip39", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"00000000000000000000000000000000"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"00000000000000000000000000000000"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/bip39", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Esempio di richiesta
{
"text": "00000000000000000000000000000000"
}Esempio di risposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.bip39",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L'API è asincrona: ricevi subito un task_id e puoi fare polling fino a 1 richiesta al secondo.
Prezzi
Prezzo pubblicato, senza token né crediti. Se l'attività fallisce, non paghi.
Errori
| HTTP | Codice | Significato |
|---|---|---|
401 | unauthorized | Chiave API mancante o non valida: controlla l'header Authorization. |
402 | insufficient_balance | Credito esaurito: ricarica per continuare a eseguire attività. |
404 | unknown_type | Tipo di attività sconosciuto: controlla il campo type della richiesta. |
429 | rate_limited | Troppe richieste in poco tempo: rallenta e riprova tra qualche secondo. |
Note tecniche
Questo codificatore di mnemonic BIP-39 accetta l'entropia in esadecimale (sedici, venti, ventiquattro, ventotto o trentadue byte) e restituisce la frase dell'elenco ufficiale inglese; in modalità decode mappa ogni parola a un indice a undici bit, separa entropia e checksum, ricalcola lo SHA-256 dell'entropia e restituisce invalid_input quando i bit di checksum non coincidono. Il percorso gratuito del browser e l'API prepagata condividono lo stesso modulo parse puro, così vettori dorati come l'entropia tutta zero che produce undici parole abandon seguite da about confrontano byte per byte tra ambienti.
Contratto di ingresso, campi di risposta e comportamento degli errori
In modalità encode, text deve essere entropia esadecimale: dopo aver rimosso spazi, due punti, underscore e trattini, la stringa deve avere lunghezza pari e decodificarsi in esattamente sedici, venti, ventiquattro, ventotto o trentadue byte. Invii un corpo JSON con il campo stringa obbligatorio text (alias: input, value, data, entropy e mnemonic) e un mode opzionale encode o decode (predefinito encode). Lunghezza dispari, caratteri non hex o altro conteggio di byte restituiscono invalid_input indicando il problema. In caso di successo la risposta ripete l'hex minuscolo normalizzato come input e entropy_hex, imposta result e mnemonic sulla stessa frase inglese separata da spazi e riporta word_count, entropy_bits, checksum_bits, wordlist english, standard BIP-39 e un breve messaggio in inglese. In modalità decode, text è un mnemonic: le parole sono rese minuscole e spezzate su spazi, virgole o punti e virgola; ciascuna deve comparire nell'elenco ufficiale inglese; il conteggio deve essere dodici, quindici, diciotto, ventuno o ventiquattro. In caso di successo result e entropy_hex contengono l'hex recuperato in minuscolo, mnemonic è la frase normalizzata, checksum_valid è true e sono inclusi gli stessi campi di dimensione. Uno scarto di checksum restituisce invalid_input con un messaggio che nomina il fallimento del checksum BIP-39 così client e test dorati possono abbinare una sottostringa. text assente, mode sconosciuto, mnemonic vuoto, conteggio errato e parole sconosciute restituiscono pure invalid_input e non vengono mai addebitati.
Vettori pratici, consigli di test e differenza dalla derivazione del seed
Cambi di proposito l'ultima parola di una frase valida di dodici parole in abandon e affermi invalid_input con una stringa di corrispondenza per scarto di checksum. Mantenga fonti di entropia offline e di alta qualità per portafogli reali; questa API non campiona mai la casualità e non memorizza i Suoi byte.
Casi di integrazione
Fixture di portafoglio e controlli CI
Codifichi entropia hex nota in frasi BIP-39 per test dorati, poi decodifichi e affermi checksum_valid affinché le librerie di portafoglio non si discostino silenziosamente dal BIP.
Verifica sicura di mnemonic incollati
Decodifichi le frasi seed fornite dall'utente e rifiuti parole errate o checksum rotti con invalid_input prima di qualsiasi passo di derivazione del seed.
Domande tecniche
Quanto costa il codificatore di mnemonic BIP-39?
Lo strumento nel browser è gratuito. Le richieste API usano il saldo prepagato KIT a $0.002 per chiamata riuscita; l'input non valido non viene addebitato.