ForHosting KIT · Outils pour développeurs

Somme de contrôle Fletcher-32

Obtenez une somme de contrôle rapide qui tient compte de l'ordre : 123456789 donne la valeur Fletcher-32 df09d509, et intervertir des caractères la modifie le plus souvent. Elle repère une corruption accidentelle ou un collage tronqué, sans servir de hachage de sécurité. Gratuit dans votre navigateur.

Gratuit
Fonctionne dans votre navigateur
Sans inscription
Vos données restent sur votre appareil

Lancer gratuitement Voir l’API

Utilisez-le depuis WebAPIE-mailTelegramApp bientôt

Exemple résolu

Si vous saisissez

Texte: 123456789

Vous obtenez

Fletcher32: df09d509
Fletcher32 en entier: 3 741 963 529
Octets: 9
Mots: 5

Fletcher-32 est une somme de contrôle rapide et sensible à la position qui réduit un message à un résidu de trente-deux bits en parcourant des mots de seize bits avec deux sommes modulaires. Contrairement à un simple XOR ou à une parité additive, la seconde somme accumule la première, de sorte que l'ordre des mots compte et que de nombreuses erreurs de transposition modifient le digest. Cet outil de somme de contrôle Fletcher-32 accepte du texte brut, le sérialise en UTF-8, empaquette les octets en mots little-endian de seize bits et renvoie une chaîne hex de huit chiffres en minuscules, l'entier non signé équivalent, les comptages d'octets et de mots, ainsi qu'un indicateur empty lorsque la chaîne source a une longueur nulle.

Ce que signifie Fletcher-32 et comment se forment les mots de seize bits

Fletcher-32 maintient deux totaux cumulés, appelés par convention sum1 et sum2, tous deux réduits modulo soixante-cinq mille cinq cent trente-cinq—c'est-à-dire deux à la puissance seize moins un. Pour chaque mot de seize bits du message, sum1 est augmenté du mot puis réduit, et sum2 est augmenté du nouveau sum1 puis réduit de la même façon. La somme de contrôle finale place sum2 dans les seize bits de poids fort et sum1 dans les seize bits de poids faible, produisant une valeur de trente-deux bits généralement affichée en huit chiffres hexadécimaux.

Cette capacité encode la chaîne d'entrée en UTF-8 afin que les caractères multi-octets tels que lettres accentuées ou emoji contribuent avec leurs octets réels sur le fil, puis empaquette ces octets en little-endian : le premier octet de chaque paire devient la moitié basse du mot et le second la moitié haute. Si la longueur UTF-8 est impaire, le dernier mot est complété par zéro dans la moitié haute pour que chaque octet participe sans inventer de données au-delà d'un simple pad zéro.

Une entrée vide traite zéro mot et produit huit chiffres hex nuls avec empty à true, cohérent avec l'identité naturelle des sommes. Fletcher-32 sert aux contrôles d'intégrité rapides contre la corruption accidentelle et les collages tronqués ; ce n'est pas un hachage cryptographique et il ne doit pas être utilisé lorsque la résistance délibérée aux collisions est requise. Si un outil tiers diverge sur les mêmes octets UTF-8, il utilise presque toujours un empaquetage big-endian, un autre module, Fletcher-16 au lieu de Fletcher-32, ou Adler-32 avec un sum1 initial différent.

Cas d’usage

Étiquettes d'intégrité rapides pour texte court

Calculez le Fletcher-32 de fragments de configuration, d'échantillons de protocole ou de bases de noms lorsque vous avez besoin d'un résidu hex compact sensible à l'ordre des mots.

Démonstrations en classe et support

Montrez aux étudiants et opérateurs comment réordonner ou modifier quelques caractères change le hex Fletcher-32 sans installer d'utilitaires locaux ni de bibliothèques cryptographiques.

Questions fréquentes

Comment les mots de seize bits sont-ils formés à partir de mon texte ?

La chaîne est encodée en UTF-8, puis chaque paire d'octets devient un mot little-endian (premier octet bas). Un octet final impair est complété par zéro dans la moitié haute. Les deux sommes se réduisent modulo 65535.

Fletcher-32 est-il un hachage cryptographique ?

Non. Fletcher-32 détecte rapidement la corruption accidentelle et de nombreux réordonnancements ; il n'est pas conçu pour résister à une collision ou une contrefaçon délibérées. Utilisez des outils de la famille SHA lorsque vous avez besoin d'un digest cryptographique.

Comment se calcule la somme de contrôle Fletcher-32 ?

Deux sommes cumulées sont tenues, toutes deux réduites modulo 65535. Chaque mot de seize bits s'ajoute à la première, puis la première s'ajoute à la seconde. Le résultat place la seconde somme dans les seize bits hauts et la première dans les bits bas.

Pourquoi un autre outil donne-t-il un résultat Fletcher-32 différent ?

Sur les mêmes octets, la cause est presque toujours une autre recette : des mots assemblés en big-endian plutôt qu'en little-endian, un autre modulo, Fletcher-16 au lieu de Fletcher-32, ou Adler-32, qui démarre sa première somme à une autre valeur.

Quelle est la somme Fletcher-32 d'un texte vide ?

C'est 00000000, et le résultat est signalé comme vide. Le texte vide est accepté exprès, pour que les données facultatives reçoivent toujours la même valeur stable plutôt qu'une erreur.

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

POSThttps://api.kit.forhosting.com/enc/fletcher32

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/fletcher32 \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"123456789"}'

const res = await fetch("https://api.kit.forhosting.com/enc/fletcher32", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "text": "123456789"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/enc/fletcher32",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "text": "123456789"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/fletcher32", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"text":"123456789"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"text":"123456789"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/fletcher32", 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": "123456789"
}

Exemple de réponse

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "enc.fletcher32",
  "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

par requête$0.002

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

Aucun appel réseau, sel aléatoire ni horloge murale n'entre dans le calcul : chaque chemin réussi est de l'arithmétique pure au prix de base publié $0.002.

Contrat d'entrée, champs de réponse et comportement avec entrée vide

La chaîne vide est autorisée volontairement : de nombreux pipelines résument des champs optionnels et ont besoin d'un résidu zéro stable plutôt qu'un échec dur. Algorithm est toujours l'étiquette Fletcher-32 et modulus est toujours la chaîne décimale six-cinq-cinq-trois-cinq afin que les exemples OpenAPI et les réponses de support citent le profil sans ambiguïté. Il n'y a pas de commutateur de mode pour Fletcher-16, Adler-32 ou CRC-32 : si vous avez besoin de ces digests, utilisez une capacité dédiée pour que chaque page d'atterrissage corresponde à une seule intention de recherche et un slug SEO. Envoyez un corps JSON avec le champ obligatoire text égal à la chaîne dont vous souhaitez calculer la somme de contrôle. Les alias input, value, s, string et content sont acceptés afin que les anciens formulaires et les clients courts se lient encore. Les nombres finis et les grands entiers sont convertis en chaîne avant le calcul ; objets, tableaux, booléens, null, Infinity et NaN lèvent invalid_input et ne sont pas facturés. Lorsque la longueur source est nulle, la réponse met empty à true, fletcher32 à huit zéros, fletcher32_int à zéro, bytes à zéro et words à zéro. Pour une entrée non vide empty est false, bytes égale la longueur UTF-8, words est le plafond de cette longueur divisée par deux, fletcher32 est le résidu hex de huit chiffres en minuscules sans préfixe zéro-x, et fletcher32_int est la même valeur en entier non signé de trente-deux bits, utile dans les langages qui préfèrent les nombres aux chaînes.

Où une API de somme de contrôle Fletcher-32 apporte de la valeur

Les développeurs collent de courts fragments de configuration, des échantillons de protocole et des bases de noms de fichier dans un calculateur Fletcher-32 lorsqu'ils ont besoin d'une étiquette d'intégrité compacte moins chère qu'un hachage cryptographique et plus sensible à l'ordre qu'une simple somme. Les ingénieurs de support recalculent les résidus à partir du texte du ticket pour confirmer qu'un dump collé n'a pas été tronqué ni réordonné en transit. Les laboratoires éducatifs utilisent le même endpoint pour montrer qu'échanger deux mots de seize bits change le digest hex, illustrant la sensibilité à la position sans machinerie cryptographique. Comme l'implémentation est pure parse 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 ; une validation échouée ne consomme pas de solde. Gardez les charges sous le plafond de caractères documenté, traitez le champ hex comme cible de collage canonique, et vous obtenez des valeurs Fletcher-32 reproductibles pour la documentation, les SDK, les workers en périphérie et les démonstrations en classe sans déployer un service de somme de contrôle séparé.

Cas d'intégration

Vecteurs golden de CI et fixtures d'entrée vide

Épinglez une chaîne connue → digest hex fixe et vide → 00000000 pour que l'intégration continue détecte aussitôt une dérive d'endianness, de module ou d'encodage UTF-8.

Questions techniques

Comment calculer la somme de contrôle Fletcher-32 d'un texte ?

Envoyez un JSON avec text égal à votre chaîne. Le champ fletcher32 renvoie huit chiffres hex minuscules du résidu sur des octets UTF-8 empaquetés en mots little-endian de seize bits ; fletcher32_int est la même valeur en entier non signé.

Que se passe-t-il avec une entrée vide ?

Le texte vide est valide. La réponse met empty à true, fletcher32 à 00000000, fletcher32_int à 0, bytes à 0 et words à 0. Un text manquant ou non chaîne lève invalid_input.

Combien coûte l'outil de somme de contrôle Fletcher-32 ?

Le widget du navigateur est gratuit. Les requêtes API utilisent le solde KIT prépayé à $0.002 par appel réussi ; une entrée invalide n'est pas facturée.

Consulter la documentation complète du KIT →

Lancer gratuitement