Encodeur RFC 1751 S/KEY
La clé de 64 bits EB33 F77E E73D 4053 devient TIDE ITCH SLOW REIN RULE MOT : six mots anglais courts, plus faciles à dicter ou à recopier que l'hexadécimal, avec des bits de parité qui repèrent un mot mal saisi au décodage. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- Texte
- EB33 F77E E73D 4053
- Mode de calcul
- Encode
- Résultat
- TIDE ITCH SLOW REIN RULE MOT
- Hex
- EB33F77EE73D4053
- Mots
- TIDE ITCH SLOW REIN RULE MOT
- Octets de la clé
- 8
La RFC 1751 définit une convention fixe pour transformer des clés cryptographiques binaires en courtes chaînes de mots anglais, afin que l'on puisse lire, mémoriser et saisir un matériel de 64 et 128 bits sans la fatigue de l'hexadécimal. Le même dictionnaire alimente les mots de passe à usage unique classiques de S/KEY : chaque bloc de huit octets devient six mots tirés d'une liste de 2048 jetons d'une à quatre lettres, avec deux bits réservés à la parité pour détecter les erreurs de transcription au décodage. Cette capacité encode une clé hexadécimale sous cette forme verbale et décode les mots en hex majuscule, en vérifiant les bits de parité sur chaque groupe de six mots.
Comment la RFC 1751 empaquette 64 bits en six mots anglais
Le dictionnaire de la RFC 1751 contient exactement deux mille quarante-huit mots anglais d'une à quatre lettres, de sorte que chaque mot indexe onze bits. Six mots fournissent soixante-six bits : soixante-quatre bits de matériel de clé plus un champ de parité de deux bits.
L'encodage parcourt chaque moitié de huit octets de votre clé comme un flux de bits, additionne des tranches consécutives de deux bits sur les soixante-quatre bits de données pour former un nibble de parité, ajoute les deux bits bas de parité, puis découpe le résultat de soixante-six bits en six indices de onze bits. Ces indices sélectionnent des mots de la liste fixe en majuscules, joints par des espaces.
Une clé pure de soixante-quatre bits devient donc exactement six mots ; une de cent vingt-huit bits est formée de deux moitiés indépendantes et devient douze mots. Le décodage inverse la carte : chaque mot doit figurer dans le dictionnaire, six mots reconstruisent neuf octets d'empaquetage, les huit premiers forment la moitié candidate de la clé, et les deux bits de parité stockés sont comparés à une somme de parité fraîche.
Un écart signifie un mot mal saisi ou un bit inversé et est rejeté avec un message clair d'échec de parité, non avec une clé silencieusement fausse. Le dictionnaire ne change jamais entre implémentations ; cette stabilité explique pourquoi les OTP S/KEY, les impressions de clé de l'ère SNMP et les outils modernes de récupération peuvent interopérer lorsqu'ils revendiquent tous la RFC 1751.
Cette page n'implémente que cette liste classique de mots — pas les mnémoniques BIP-39, ni le diceware EFF, ni des générateurs arbitraires de phrases — afin que l'intention de recherche reste ancrée à l'encodage de clés lisibles avec parité.
Où les clés en mots de style S/KEY restent utiles
Les opérateurs qui impriment encore ou dictent un matériel de soixante-quatre bits profitent bien davantage de six mots courts que de seize chiffres hex, surtout au téléphone ou à la radio. Les systèmes S/KEY et OTP qui émettent déjà des phrases RFC 1751 ont besoin d'un décodeur strict qui rejette les échecs de parité au lieu d'accepter une clé voisine qui authentifierait le mauvais principal.
Les laboratoires de formation à la sécurité enseignent l'hygiène de transcription en montrant comment un seul mot erroné inverse le bit de parité et interrompt le décodage. Les notes de réponse à incident stockent parfois le matériel de récupération hors ligne sous forme de groupes de mots lisibles, afin qu'un intervenant sans éditeur hex puisse encore ressaisir une clé plus tard.
Les auteurs de documentation qui se positionnent sur RFC 1751 ou les mots S/KEY veulent une page dédiée avec un outil en direct plutôt qu'une page générique Base32 ou BIP-39, car le dictionnaire, la règle de parité et les longueurs de clé diffèrent. Une validation en échec ne consomme pas le solde.
Limitez les requêtes aux tailles de clé documentées, figez l'hex majuscule et les chaînes de mots dans les tests, et vous obtenez des transformations reproductibles pour les flux de récupération, les outils OTP et les workers en périphérie sans monter une boîte à outils cryptographiques complète de votre côté.
Cas d’usage
Saisie de phrases OTP S/KEY
Décodez des phrases de mot de passe à usage unique S/KEY de six mots vers la valeur 64 bits sous-jacente avec vérification de parité avant d'accepter le matériel de connexion.
Impressions de clé lisibles
Encodez des clés hex de 64 ou 128 bits en six ou douze mots anglais pour un transfert oral, des sauvegardes papier ou des runbooks adaptés à la radio.
Questions fréquentes
Comment convertir une clé hex en mots RFC 1751 ?
Envoyez mode encode (ou omettez mode) avec text égal à 16 chiffres hex pour une clé 64 bits ou 32 chiffres pour 128 bits. Espaces et deux-points sont ignorés. Le champ result contient six ou douze mots du dictionnaire en majuscules.
Comment décoder des mots anglais en hex ?
Envoyez mode decode avec text égal à six ou douze mots RFC 1751 séparés par des espaces.
Que se passe-t-il si le contrôle de parité échoue ?
Un écart de parité signifie qu'au moins un mot a été mal saisi ou corrompu ; la capacité ne renvoie jamais une clé devinée.
Est-ce la même chose que les mots mnémoniques BIP-39 ?
Non. La RFC 1751 utilise une autre liste de 2048 mots, empaquete des moitiés de 64 bits avec un champ de parité de 2 bits et cible des clés de style S/KEY, pas des phrases de graine de portefeuilles HD.
Quels formats de clé puis-je coller ?
Collez 16 chiffres hexadécimaux pour une clé de 64 bits ou 32 pour une clé de 128 bits. Les espaces, deux-points, tirets et le préfixe 0x sont ignorés : EB33 F77E E73D 4053 fonctionne tel quel. Une clé de 128 bits donne douze mots.
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/rfc1751 \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"EB33 F77E E73D 4053"}'const res = await fetch("https://api.kit.forhosting.com/enc/rfc1751", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "EB33 F77E E73D 4053"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/enc/rfc1751",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "EB33 F77E E73D 4053"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/rfc1751", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"EB33 F77E E73D 4053"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"EB33 F77E E73D 4053"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/rfc1751", 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": "EB33 F77E E73D 4053"
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.rfc1751",
"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
Mots invalides, nombres de mots incorrects, longueurs hex illégales et échecs de parité lèvent invalid_input au lieu d'inventer une clé.
Contrat d'entrée, modes et comportement d'erreur
Lorsque mode est omis, encode est la valeur par défaut. Le mode encode traite text comme une clé hexadécimale : le préfixe optionnel 0x, les espaces, les deux-points et les tirets sont retirés ; le nombre de chiffres nettoyés doit être seize pour une clé de soixante-quatre bits ou trente-deux pour cent vingt-huit bits ; toute autre longueur échoue immédiatement. Le mode decode traite text comme des mots anglais séparés par des espaces, les met en majuscules, applique les substitutions historiques S/Key qui mappent le chiffre un vers L, zéro vers O et cinq vers S, et exige un multiple positif de six mots. Les échecs de validation ne consomment pas le solde prépayé. Envoyez en POST un corps JSON avec un champ chaîne obligatoire nommé text et un mode optionnel valant encode ou decode. Les charges utiles de succès incluent toujours mode, le text d'origine, un champ result principal (mots à l'encodage, hex majuscule au décodage), plus les champs écho hex et words, key_bytes, key_bits, word_count, l'étiquette standard RFC 1751 et parity_ok true lorsque la transformation est terminée. Text manquant, objets non chaîne, valeurs de mode non prises en charge, longueurs hex impaires, caractères non hex, mots hors dictionnaire, jetons mal formés de plus de quatre lettres, nombres de mots qui ne sont pas des multiples de six et contrôles de parité en échec lèvent tous invalid_input avec un message en anglais nommant le problème. Le formulaire gratuit du navigateur convient à une seule clé que vous allez saisir ; les scripts doivent figer les mêmes champs JSON pour les goldens de régression. Les appels API réussis utilisent le prix de base publié de $0.002 par élément.
Où les clés en mots de style S/KEY restent utiles
Comme l'implémentation est un parse pur de niveau A, chaque appel réussi coûte le prix de base publié $0.002 sans jetons de modèle ni réseau sortant.
Cas d'intégration
Fixtures golden multilingues
Générez des vecteurs d'encodage et de décodage alignés sur les implémentations de référence de la RFC 1751 afin que le CI multilingue partage une seule vérité de base.
Questions techniques
Combien coûte le convertisseur de mots RFC 1751 ?
L'outil navigateur est gratuit. Les requêtes API utilisent le solde prépayé KIT à $0.002 par appel réussi ; une entrée invalide n'est pas facturée.