Générateur de codes de secours 2FA avec graine
Ce générateur de codes de secours pour l’authentification à deux facteurs crée le nombre exact de codes de récupération uniques et à usage unique au format habituel de quatre chiffres, un tiret, puis quatre chiffres.
Lancer gratuitement
Indiquez un nombre et une graine secrète : les mêmes entrées produiront toujours la même liste ordonnée. Cette reproductibilité convient au provisionnement contrôlé, aux jeux de données de test, aux procédures de récupération documentées et aux systèmes devant reconstituer des codes sans conserver la liste générée. Le calcul reste entièrement local : il n’utilise ni réseau, ni horloge, ni source aléatoire, ni données de compte, ni état caché. Protégez la graine et chaque code obtenu comme des données d’authentification sensibles.
Choisissez le nombre et protégez la graine
Commencez par déterminer combien de codes de récupération le compte ou l’application doit émettre. Le nombre doit être un entier compris entre un et mille ; une demande inférieure à un est refusée au lieu de produire discrètement une liste vide. Fournissez ensuite une graine non vide. La graine constitue l’unique source de reproductibilité : une graine et un nombre identiques génèrent les mêmes codes dans le même ordre. Utilisez un secret long et à forte entropie, créé et conservé selon la procédure de gestion des secrets approuvée par votre organisation. Le nom d’une personne, une adresse électronique, un libellé de projet ou une courte phrase facile à retenir ne convient pas comme graine de production, car un tiers pourrait le deviner et reconstituer les codes. Ne réutilisez jamais une graine pour plusieurs utilisateurs, environnements ou services. La séparation de domaines intégrée à l’algorithme évite les recouvrements accidentels avec d’autres dérivations, mais elle ne compense pas une graine faible ou divulguée. Pour des données reproductibles dans les tests automatisés, identifiez et isolez clairement les graines de test afin que leurs résultats ne soient jamais acceptés par un système d’authentification de production. La graine est limitée à 4,096 caractères afin que l’exécution reste bornée et prévisible.
Comprenez la génération déterministe
Chaque position de sortie est dérivée séparément avec SHA-256 à partir d’un libellé versionné, de la longueur exacte de la graine, du texte de la graine, de la position comptée depuis zéro et d’un compteur de nouvelles tentatives. La longueur rend le découpage de l’entrée sans ambiguïté, tandis que le libellé versionné sépare cet usage des autres calculs fondés sur une graine. Le générateur lit des valeurs non signées dans le condensat et applique un échantillonnage par rejet avant de les ramener à huit chiffres décimaux. Cette étape supprime le léger biais de distribution qu’introduirait une conversion directe par modulo. Chaque nombre accepté est présenté en deux groupes de quatre chiffres séparés par un tiret, sans supprimer les zéros initiaux. Un ensemble mémorise les valeurs déjà émises ; en cas de collision, le compteur progresse de façon déterministe jusqu’à l’obtention d’un nouveau code. Le résultat contient donc le nombre demandé de codes uniques, et une nouvelle exécution reproduit aussi bien les décisions liées aux collisions que la liste finale. Aucun service réseau, aucune horloge système, aucun générateur aléatoire de l’environnement, aucun cache persistant ni état de module modifiable ne peut influencer la réponse. La modification d’un seul caractère de la graine transforme normalement toute la liste.
Déployez, conservez et invalidez les codes en sécurité
La génération ne constitue qu’une partie d’une procédure de codes de secours. Votre service d’authentification doit conserver un vérificateur approuvé pour chaque code, marquer le code comme consommé après sa première utilisation réussie, limiter la fréquence des tentatives et proposer une action explicite de révocation ou de régénération. N’inscrivez jamais la graine ni les codes en clair dans les outils d’analyse, les traces, les tickets d’assistance, les sorties de compilation ou les conversations partagées. Transmettez les codes à l’utilisateur authentifié dans une session protégée et conseillez un stockage hors ligne dans un gestionnaire de mots de passe ou un autre emplacement sûr. Le déterminisme facilite la reprise après sinistre et le provisionnement contrôlé, mais toute personne obtenant la graine peut également reconstituer tous les codes. Adoptez une nouvelle graine indépendante dès qu’une divulgation est suspectée, lorsque l’utilisateur demande une régénération ou lorsque la politique exige d’invalider l’ancienne liste. Ne demandez pas simplement un nombre différent avec l’ancienne graine : les positions communes aux deux demandes resteront identiques. Le regroupement des chiffres facilite la transcription, mais chaque code ne dispose que de cent millions de valeurs possibles ; les protections en ligne demeurent donc indispensables. L’API coûte $0.002 par demande et le navigateur exécute le même calcul pur.
Cas d’usage
Provisionner des codes de récupération
Créez une liste contrôlée de codes de récupération groupés pendant l’inscription tout en conservant une dérivation reproductible grâce à une graine protégée par utilisateur.
Stabiliser les tests d’authentification
Générez des données fixes de codes de secours pour les tests d’intégration sans enregistrer dans le dépôt une liste tenue à jour manuellement.
Reconstituer une liste autorisée
Récupérez la même liste ordonnée pendant une procédure d’incident documentée lorsque la graine protégée reste disponible, mais pas la copie affichée.
Questions fréquentes
Quel format les codes utilisent-ils ?
Chaque code contient huit chiffres décimaux répartis en deux groupes de quatre, par exemple 0123-4567. Les zéros initiaux sont conservés.
Les mêmes entrées renvoient-elles toujours les mêmes codes ?
Oui. L’algorithme ne dépend ni du hasard, ni de l’horloge, ni du réseau, ni d’un état conservé ; le même nombre et la graine exacte reproduisent donc la même liste ordonnée.
Une réponse peut-elle contenir des codes en double ?
Non. Les collisions sont détectées et réessayées de façon déterministe jusqu’à ce que la liste demandée ne contienne que des codes uniques.
Puis-je employer une graine facile à retenir ?
Pas en production. Utilisez un secret long et à forte entropie, créé et stocké selon une procédure approuvée, car quiconque obtient ou devine la graine peut reconstituer les codes.
Que se passe-t-il si le nombre est nul ou négatif ?
La demande échoue avec une erreur d’entrée non valide indiquant que le nombre doit être au moins égal à un.
Combien coûte une demande à l’API ?
Chaque demande à l’API coûte $0.002. La version pour navigateur exécute localement le même algorithme pur.
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/security/two-factor-backup-codes-generate \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"count":8,"seed":"correct-horse-battery-staple-2026"}'const res = await fetch("https://api.kit.forhosting.com/security/two-factor-backup-codes-generate", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"count": 8,
"seed": "correct-horse-battery-staple-2026"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/security/two-factor-backup-codes-generate",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"count": 8,
"seed": "correct-horse-battery-staple-2026"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/security/two-factor-backup-codes-generate", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"count":8,"seed":"correct-horse-battery-staple-2026"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"count":8,"seed":"correct-horse-battery-staple-2026"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/security/two-factor-backup-codes-generate", 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
{
"count": 8,
"seed": "correct-horse-battery-staple-2026"
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "security.two_factor_backup_codes_generate",
"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. |