ForHosting KIT · Ferramentas para dev

Checksum Fletcher-32

Receba um checksum rápido que percebe a ordem: 123456789 dá o valor Fletcher-32 df09d509, e trocar caracteres de lugar costuma alterá-lo. Serve para pegar corrupção acidental ou um texto colado pela metade, não como hash de segurança. Grátis no seu navegador.

Grátis
Funciona no seu navegador
Sem cadastro
Seus dados não saem do seu aparelho

Executar grátis Ver a API

Use pelo WebAPIE-mailTelegramApp em breve

Exemplo resolvido

Se você digitar

Texto: 123456789

Você obtém

Fletcher32: df09d509
Fletcher32 como inteiro: 3.741.963.529
Bytes: 9
Palavras: 5

Fletcher-32 é uma checksum rápida e sensível à posição que reduz uma mensagem a um residual de trinta e dois bits percorrendo palavras de dezesseis bits com duas somas modulares. Diferente de um XOR simples ou de uma paridade aditiva, a segunda soma acumula a primeira, de modo que a ordem das palavras importa e muitos erros de transposição alteram o resumo. Esta ferramenta de checksum Fletcher-32 aceita texto simples, serializa como UTF-8, empacota os bytes em palavras little-endian de dezesseis bits e devolve uma string hex de oito dígitos em minúsculas, o inteiro sem sinal equivalente, as contagens de bytes e palavras, e um indicador empty quando a string de origem tem comprimento zero.

O que Fletcher-32 significa e como se formam as palavras de dezesseis bits

Fletcher-32 mantém dois totais acumulados, convencionalmente chamados sum1 e sum2, ambos reduzidos módulo sessenta e cinco mil quinhentos e trinta e cinco—isto é, dois elevado a dezesseis menos um. Para cada palavra de dezesseis bits da mensagem, sum1 aumenta com a palavra e é reduzido, e sum2 aumenta com o novo sum1 e é reduzido da mesma forma. A checksum final coloca sum2 nos dezesseis bits altos e sum1 nos dezesseis baixos, produzindo um valor de trinta e dois bits geralmente mostrado como oito dígitos hexadecimais.

Esta capacidade codifica a string de entrada como UTF-8 para que caracteres multibyte como letras acentuadas ou emoji contribuam com seus bytes reais no fio, e então empacota esses bytes em little-endian: o primeiro byte de cada par vira a metade baixa da palavra e o segundo a metade alta. Se o comprimento UTF-8 for ímpar, a última palavra é preenchida com zero na metade alta para que todo byte participe sem inventar dados extras além de um único pad zero.

Entrada vazia processa zero palavras e produz oito dígitos hex zero com empty true, coerente com a identidade natural das somas. Fletcher-32 serve a checagens rápidas de integridade contra corrupção acidental e colagens truncadas; não é um hash criptográfico e não deve ser usado onde se exija resistência deliberada a colisões. Se uma ferramenta de terceiros discordar nos mesmos bytes UTF-8, quase sempre usa empacotamento big-endian, outro módulo, Fletcher-16 em vez de Fletcher-32, ou Adler-32 com sum1 inicial diferente.

Casos de uso

Etiquetas rápidas de integridade para texto curto

Calcule o Fletcher-32 de trechos de configuração, amostras de protocolo ou bases de nomes quando precisar de um residual hex compacto sensível à ordem das palavras.

Demonstrações em sala de aula e suporte

Mostre a estudantes e operadores como reordenar ou editar alguns caracteres muda o hex Fletcher-32 sem instalar utilitários locais ou bibliotecas criptográficas.

Perguntas frequentes

Como as palavras de dezesseis bits são formadas a partir do meu texto?

A string é codificada em UTF-8 e cada par de bytes vira uma palavra little-endian (primeiro byte baixo). Um byte final ímpar é preenchido com zero na metade alta. Ambas as somas reduzem módulo 65535.

Fletcher-32 é um hash criptográfico?

Não. Fletcher-32 detecta rapidamente corrupção acidental e muitas reordenações; não foi projetado para resistir a colisão ou falsificação deliberadas. Use ferramentas da família SHA quando precisar de um digest criptográfico.

Como o checksum Fletcher-32 é calculado?

São mantidas duas somas acumuladas, ambas reduzidas módulo 65535. Cada palavra de dezesseis bits é somada à primeira, e depois a primeira é somada à segunda. O resultado coloca a segunda soma nos dezesseis bits altos e a primeira nos baixos.

Por que outra ferramenta dá um resultado Fletcher-32 diferente?

Com os mesmos bytes, o motivo costuma ser outra receita: montar as palavras em big-endian em vez de little-endian, usar outro módulo, calcular Fletcher-16 em vez de Fletcher-32 ou usar Adler-32, que começa a primeira soma com outro valor.

Qual é o checksum Fletcher-32 de um texto vazio?

É 00000000, e o resultado vem marcado como vazio. O texto vazio é aceito de propósito, para que dados opcionais recebam sempre o mesmo valor estável em vez de um erro.

Ferramentas relacionadas

Para desenvolvedores — acesso via API

Tudo nesta página está disponível via API. Esta seção é para equipes que querem integrar a ferramenta aos próprios sistemas; quem não precisa disso pode simplesmente usar a ferramenta acima.

Endpoint

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

Autenticação por token Bearer. Um único POST coloca a tarefa na fila; o resultado chega por webhook ou link assinado.

Chame do seu código

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)

Exemplo de requisição

{
  "text": "123456789"
}

Exemplo de resposta

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "enc.fletcher32",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

A API é assíncrona: cada chamada devolve um task_id na hora. Se preferir polling, consulte o status a até 1 requisição por segundo.

Preço

por chamadaUS$ 0,002

Preço publicado, sem tokens nem créditos escondidos. Tarefa que falha não é cobrada.

Erros

HTTP	Código	O que significa
`401`	`unauthorized`	Token ausente ou inválido. Confira o header Authorization.
`402`	`insufficient_balance`	Saldo insuficiente para esta tarefa. Faça uma recarga e tente de novo.
`404`	`unknown_type`	Esse tipo de tarefa não existe. Confira o campo type no catálogo.
`429`	`rate_limited`	Muitas requisições em pouco tempo. Espere um instante e tente de novo.

Notas técnicas

Nenhuma chamada de rede, sal aleatório ou relógio de parede entra no cálculo: cada caminho bem-sucedido é aritmética pura ao preço base publicado US$ 0,002.

Contrato de entrada, campos de resposta e comportamento com entrada vazia

String vazia é permitida de propósito: muitos pipelines resumem campos opcionais e precisam de um residual zero estável em vez de falha rígida. Algorithm é sempre o rótulo Fletcher-32 e modulus é sempre a string decimal seis-cinco-cinco-três-cinco para que exemplos OpenAPI e respostas de suporte citem o perfil sem ambiguidade. Não há seletor de modo para Fletcher-16, Adler-32 ou CRC-32: se você precisar desses digests, use uma capacidade dedicada para que cada página de destino coincida com uma única intenção de busca e slug SEO. Envie um corpo JSON com o campo obrigatório text igual à string cuja checksum você deseja calcular. Os aliases input, value, s, string e content são aceitos para que formulários antigos e clientes curtos ainda se vinculem. Números finitos e big integers são convertidos em string antes do cálculo; objetos, arrays, booleanos, null, Infinity e NaN geram invalid_input e não são cobrados. Quando o comprimento de origem é zero, a resposta define empty como true, fletcher32 como oito dígitos zero, fletcher32_int como zero, bytes como zero e words como zero. Com entrada não vazia empty é false, bytes iguala o comprimento UTF-8, words é o teto desse comprimento dividido por dois, fletcher32 é o residual hex de oito dígitos em minúsculas sem prefixo zero-x, e fletcher32_int é o mesmo valor como inteiro de trinta e dois bits sem sinal, útil em linguagens que preferem números a strings.

Onde uma API de checksum Fletcher-32 gera valor

Desenvolvedores colam trechos curtos de configuração, amostras de protocolo e bases de nomes de arquivo em uma calculadora Fletcher-32 quando precisam de uma etiqueta de integridade compacta mais barata que um hash criptográfico e mais sensível à ordem que uma soma simples. Engenheiros de suporte recalculam residuais a partir do texto do ticket para confirmar que um dump colado não foi truncado nem reordenado em trânsito. Laboratórios educacionais usam o mesmo endpoint para mostrar que trocar duas palavras de dezesseis bits altera o digest hex, ilustrando sensibilidade à posição sem maquinaria criptográfica. Como a implementação é parse pura de nível A, cada chamada bem-sucedida custa o preço base publicado US$ 0,002 sem tokens de modelo nem rede de saída; validação falha não consome saldo. Mantenha os payloads abaixo do teto de caracteres documentado, trate o campo hex como destino canônico de colagem, e você obtém valores Fletcher-32 reproduzíveis para docs, SDKs, workers de borda e demos de sala de aula sem levantar um serviço de checksum separado.

Casos de integração

Vetores golden de CI e fixtures de entrada vazia

Fixe uma string conhecida → digest hex fixo e vazio → 00000000 para que a integração contínua detecte de imediato deriva de endianness, módulo ou codificação UTF-8.

Perguntas técnicas

Como calculo o checksum Fletcher-32 de um texto?

Envie JSON com text igual à sua string. O campo fletcher32 devolve oito dígitos hex minúsculos do residual sobre bytes UTF-8 empacotados como palavras little-endian de dezesseis bits; fletcher32_int é o mesmo valor como inteiro sem sinal.

O que acontece com entrada vazia?

Texto vazio é válido. A resposta define empty como true, fletcher32 como 00000000, fletcher32_int como 0, bytes como 0 e words como 0. Text ausente ou não string gera invalid_input.

Quanto custa a ferramenta de checksum Fletcher-32?

O widget do navegador é gratuito. Pedidos API usam saldo KIT pré-pago a US$ 0,002 por chamada bem-sucedida; entrada inválida não é cobrada.

Ver a documentação completa do KIT →

Executar grátis