Encodeur mnémonique BIP-39
Seize octets d'entropie à zéro deviennent « abandon » onze fois suivi de « about » : BIP-39 transforme de 128 à 256 bits en 12 à 24 mots anglais avec une somme de contrôle SHA-256, et ne rend l'entropie que si cette somme concorde. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- Texte
- 00000000000000000000000000000000
- Mode de calcul
- Encode
- Entrée
- 00000000000000000000000000000000
- Entropie en hex
- 00000000000000000000000000000000
- Nombre de mots
- 12
- Bits d'entropie
- 128
BIP-39 est le standard de l'industrie qui transforme l'entropie binaire d'un portefeuille en un mnémonique lisible de douze à vingt-quatre mots anglais, puis retrouve la même entropie uniquement lorsque les bits de somme de contrôle SHA-256 embarqués coïncident encore. Une validation échouée n'est pas facturée ; les appels réussis coûtent le prix de base publié par élément.
Comment BIP-39 mappe l'entropie vers les mots et inversement
BIP-39 part d'une entropie brute de cent vingt-huit, cent soixante, cent quatre-vingt-douze, deux cent vingt-quatre ou deux cent cinquante-six bits. La spécification prend les premiers ENT divisés par trente-deux bits du condensé SHA-256 de ces octets d'entropie et les ajoute comme somme de contrôle, produisant une chaîne de bits dont la longueur est toujours un multiple de onze. Chaque groupe de onze bits est un index dans une liste fixe de deux mille quarante-huit mots anglais ordonnés alphabétiquement de abandon à zoo.
Douze mots correspondent à cent vingt-huit bits d'entropie plus quatre bits de somme ; quinze, dix-huit, vingt-et-un et vingt-quatre mots progressent de la même façon jusqu'à deux cent cinquante-six bits plus huit bits de somme. L'encodage est donc entièrement déterminé par les octets d'entropie et la liste : il n'y a ni sel, ni choix de langue dans cette capacité au-delà de l'anglais, ni étape de dérivation de clé privée.
Le décodage inverse la carte : découpe la phrase sur les espaces, recherche chaque mot, reconstruit la chaîne de bits, sépare la fenêtre finale de somme et vérifie que ces bits égalent les bits de tête du SHA-256 de l'entropie récupérée. Si un mot est inconnu, si le nombre de mots n'est pas l'une des cinq longueurs légales ou si les bits de somme divergent, l'opération échoue.
Cette conception d'échec fermé explique pourquoi les portefeuilles préfèrent les mnémoniques à l'hex brut pour les sauvegardes humaines : un seul mot erroné fait presque toujours échouer la somme au lieu d'ouvrir un autre portefeuille. Cette page cible ceux qui cherchent un encodeur de mnémoniques BIP-39, un convertisseur d'entropie en phrase de récupération ou un vérificateur de somme de mnémonique ; elle n'exécute pas la dérivation de graine PBKDF2, ne génère pas d'entropie aléatoire et ne prend pas en charge les listes de mots non anglaises.
Vecteurs pratiques, conseils de test et différence avec la dérivation de graine
Préférez decode lorsqu'une personne a collé une phrase et que vous devez récupérer l'entropie seulement si la somme est intacte. L'entropie classique de seize octets tout à zéro s'encode en onze mots abandon suivis de about ; celle de seize octets avec tous les bits à un s'encode en onze zoo suivis de wrong. Faites l'aller-retour en CI : encodez, affirmez le mnémonique, décodez, affirmez l'hex d'origine.
Utilisez un outil BIP-32 ou PBKDF2 séparé si vous avez besoin de la graine de soixante-quatre octets à partir du mnémonique plus une phrase secrète optionnelle — cette étape est volontairement hors périmètre pour que la landing SEO reste centrée sur l'encodage et le décodage avec vérification de somme. Les tâches échouées ne consomment pas le solde prépayé, ce qui rend les scripts exploratoires peu coûteux lors du fuzz de mauvaises phrases.
En enseignement, montrez aux étudiants que deux mnémoniques différant d'un mot ne partagent presque jamais une somme valide, propriété qui rend les sauvegardes manuscrites plus sûres que les dumps hex bruts. Associez cette capacité à des utilitaires Base58Check ou hex lorsque votre chaîne formate aussi des adresses ou des clés privées après dérivation de la graine ailleurs.
Cas d’usage
Enseigner les phrases de récupération avec somme de contrôle
Montrez les vecteurs classiques tout zéro et tout un, puis changez un mot pour que les apprenants voient pourquoi BIP-39 échoue de façon fermée au lieu d'ouvrir un autre portefeuille.
Questions fréquentes
Comment convertir l'entropie hex en mnémonique BIP-39 ?
Envoyez mode encode (par défaut) avec text en 32, 40, 48, 56 ou 64 chiffres hex (16–32 octets).
Comment décoder un mnémonique vers l'entropie ?
Envoyez mode decode avec text en une phrase BIP-39 anglaise de 12, 15, 18, 21 ou 24 mots.
Que se passe-t-il si la somme de contrôle est incorrecte ?
Les phrases erronées ou mal saisies ne sont jamais facturées et ne renvoient jamais de fausse entropie.
Quelles listes de mots et longueurs sont prises en charge ?
Uniquement la liste anglaise officielle BIP-39 de 2048 mots. L'entropie doit être de 128, 160, 192, 224 ou 256 bits (comptages 12, 15, 18, 21 ou 24 mots).
Cet outil génère-t-il une entropie aléatoire ou la graine d'un portefeuille ?
Non. Il convertit seulement en mots l'entropie que vous fournissez, et inversement, en vérifiant la somme de contrôle. Il ne génère pas d'entropie aléatoire, ne dérive pas la graine du portefeuille à partir de la phrase et d'une phrase secrète facultative, et n'utilise que la liste de mots anglaise.
Outils associés
Pour les développeurs — accès API
Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.
Endpoint
Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.
Appeler depuis votre 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)Exemple de requête
{
"text": "00000000000000000000000000000000"
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.bip39",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.
Tarifs
Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.
Erreurs
| HTTP | Code | Signification |
|---|---|---|
401 | unauthorized | Clé API absente ou invalide : vérifiez l’en-tête Authorization. |
402 | insufficient_balance | Solde insuffisant : rechargez votre compte pour lancer cette tâche. |
404 | unknown_type | Type de tâche inconnu : vérifiez le champ type de votre requête. |
429 | rate_limited | Trop de requêtes : ralentissez la cadence, puis réessayez. |
Notes techniques
Cet encodeur de mnémoniques BIP-39 accepte l'entropie en hexadécimal (seize, vingt, vingt-quatre, vingt-huit ou trente-deux octets) et renvoie la phrase de la liste anglaise officielle ; en mode décodage, il mappe chaque mot sur un index de onze bits, sépare entropie et somme, recalcule le SHA-256 de l'entropie et renvoie invalid_input lorsque les bits de somme divergent. Le chemin gratuit du navigateur et l'API prépayée partagent le même module parse pur, de sorte que des vecteurs dorés comme l'entropie tout à zéro produisant onze mots abandon suivis de about comparent octet par octet entre environnements.
Contrat d'entrée, champs de réponse et comportement d'erreur
En mode encode, text doit être de l'entropie hexadécimale : après suppression des espaces, deux-points, tirets bas et tirets, la chaîne doit avoir une longueur paire et se décoder en exactement seize, vingt, vingt-quatre, vingt-huit ou trente-deux octets. En mode decode, text est un mnémonique : les mots sont mis en minuscules et découpés sur espaces, virgules ou points-virgules ; chacun doit figurer dans la liste anglaise officielle ; le nombre doit être douze, quinze, dix-huit, vingt-et-un ou vingt-quatre. Envoyez un corps JSON avec un champ chaîne obligatoire text (alias : input, value, data, entropy et mnemonic) et un mode optionnel encode ou decode (par défaut encode). Longueur impaire, caractères non hex ou autre nombre d'octets renvoient invalid_input en nommant le problème. En cas de succès, la réponse répète l'hex minuscule normalisé comme input et entropy_hex, fixe result et mnemonic à la même phrase anglaise séparée par des espaces, et indique word_count, entropy_bits, checksum_bits, wordlist english, standard BIP-39 et un court message en anglais. En cas de succès, result et entropy_hex contiennent l'hex récupéré en minuscules, mnemonic est la phrase normalisée, checksum_valid vaut true et les mêmes champs de taille sont inclus. Un décalage de somme renvoie invalid_input avec un message nommant l'échec de somme BIP-39 afin que clients et tests dorés puissent faire correspondre une sous-chaîne. text manquant, mode inconnu, mnémonique vide, mauvais nombre de mots et mots inconnus renvoient aussi invalid_input et ne sont jamais facturés.
Vecteurs pratiques, conseils de test et différence avec la dérivation de graine
Changez délibérément le dernier mot d'une phrase valide de douze mots en abandon et affirmez invalid_input avec une chaîne de correspondance de décalage de somme. Gardez des sources d'entropie hors ligne et de haute qualité pour de vrais portefeuilles ; cette API n'échantillonne jamais le hasard et ne stocke jamais vos octets.
Cas d'intégration
Fixtures de portefeuille et contrôles CI
Encodez une entropie hex connue en phrases BIP-39 pour des tests dorés, puis décodez et affirmez checksum_valid afin que les bibliothèques de portefeuille ne divergent pas silencieusement du BIP.
Vérification de mnémoniques collés en toute sécurité
Décodez les phrases de récupération fournies par l'utilisateur et rejetez les mots mal saisis ou les sommes cassées avec invalid_input avant toute dérivation de graine.
Questions techniques
Quel est le coût de l'encodeur de mnémoniques BIP-39 ?
L'outil navigateur est gratuit. Les requêtes API utilisent le solde prépayé KIT à $0.002 par appel réussi ; l'entrée invalide n'est pas facturée.