ForHosting KIT · Utilidades de desarrollo

Suma de verificación Fletcher-32

Obtenga una suma de verificación rápida que nota el orden: 123456789 da el valor Fletcher-32 df09d509, y cambiar caracteres de sitio suele alterarlo. Sirve para detectar daños accidentales o un pegado incompleto, no como hash de seguridad. Gratis en su navegador.

Gratis
Funciona en su navegador
Sin registro
Sus datos no salen de su equipo

Ejecutar — gratis Cómo funciona y API

Úselo desde WebAPIEmailTelegramApp pronto

Ejemplo resuelto

Si escribe

Texto: 123456789

Obtiene

Fletcher32: df09d509
Fletcher32 como entero: 3 741 963 529
Bytes: 9
Palabras: 5

Fletcher-32 es una suma de verificación rápida y sensible a la posición que reduce un mensaje a un residual de treinta y dos bits recorriendo palabras de dieciséis bits con dos sumas modulares. A diferencia de un XOR simple o una paridad aditiva, la segunda suma acumula la primera, de modo que el orden de las palabras importa y muchos errores de transposición cambian el resumen. Esta herramienta de suma de verificación Fletcher-32 acepta texto plano, lo serializa como UTF-8, empaqueta los bytes en palabras little-endian de dieciséis bits y devuelve una cadena hex de ocho dígitos en minúsculas, el entero sin signo equivalente, los conteos de bytes y palabras, y un indicador empty cuando la cadena de origen tiene longitud cero.

Qué significa Fletcher-32 y cómo se forman las palabras de dieciséis bits

Fletcher-32 mantiene dos totales acumulados, llamados por convención sum1 y sum2, ambos reducidos módulo sesenta y cinco mil quinientos treinta y cinco—es decir, dos elevado a dieciséis menos uno. Por cada palabra de dieciséis bits del mensaje, sum1 se incrementa con la palabra y se reduce, y sum2 se incrementa con el nuevo sum1 y se reduce igual.

La suma de verificación final coloca sum2 en los dieciséis bits altos y sum1 en los dieciséis bajos, obteniendo un valor de treinta y dos bits que suele mostrarse como ocho dígitos hexadecimales. Esta capacidad codifica la cadena de entrada como UTF-8 para que caracteres multibyte como letras acentuadas o emoji aporten sus bytes reales en el cable, y luego empaqueta esos bytes en little-endian: el primer byte de cada par es la mitad baja de la palabra y el segundo la mitad alta.

Si la longitud UTF-8 es impar, la última palabra se rellena con cero en la mitad alta para que todo byte participe sin inventar datos extra más allá de un solo relleno cero. La entrada vacía procesa cero palabras y produce ocho dígitos hex cero con empty en true, coherente con la identidad natural de las sumas. Fletcher-32 está pensado para comprobaciones rápidas de integridad frente a corrupción accidental y pegados truncados; no es un hash criptográfico y no debe usarse donde se exija resistencia deliberada a colisiones.

Si una herramienta de terceros discrepa sobre los mismos bytes UTF-8, casi siempre usa empaquetado big-endian, otro módulo, Fletcher-16 en lugar de Fletcher-32, o Adler-32 con un sum1 inicial distinto.

Qué puede hacer con ella

Etiquetas rápidas de integridad para texto corto

Calcule el Fletcher-32 de fragmentos de configuración, muestras de protocolo o bases de nombres cuando necesite un residual hex compacto sensible al orden de las palabras.

Demostraciones en aula y soporte

Muestre a estudiantes y operadores cómo reordenar o editar unos caracteres cambia el hex Fletcher-32 sin instalar utilidades locales ni bibliotecas criptográficas.

Preguntas frecuentes

¿Cómo se forman las palabras de dieciséis bits a partir de mi texto?

La cadena se codifica en UTF-8 y cada par de bytes forma una palabra little-endian (primer byte bajo). Un byte final impar se rellena con cero en la mitad alta. Ambas sumas se reducen módulo 65535.

¿Es Fletcher-32 un hash criptográfico?

No. Fletcher-32 detecta con rapidez corrupción accidental y muchos reordenamientos; no está diseñado para resistir colisión o falsificación deliberadas. Use herramientas de la familia SHA cuando necesite un resumen criptográfico.

¿Cómo se calcula la suma de verificación Fletcher-32?

Se llevan dos sumas acumuladas, ambas reducidas módulo 65535. Cada palabra de dieciséis bits se suma a la primera, y luego la primera se suma a la segunda. El resultado coloca la segunda suma en los dieciséis bits altos y la primera en los bajos.

¿Por qué otra herramienta da un resultado Fletcher-32 distinto?

Con los mismos bytes, lo habitual es que siga otra receta: agrupar las palabras en orden big-endian en vez de little-endian, usar otro módulo, calcular Fletcher-16 en lugar de Fletcher-32 o usar Adler-32, que empieza su primera suma con otro valor.

¿Cuál es la suma Fletcher-32 de un texto vacío?

Es 00000000, y el resultado se marca como vacío. El texto vacío se admite a propósito, para que los datos opcionales reciban siempre el mismo valor estable en lugar de un error.

Herramientas relacionadas

Para desarrolladores — acceso por API

Todo lo de esta página está disponible por programación. Esta sección es para equipos que quieren integrarlo en sus sistemas; el resto puede usar la herramienta de arriba sin más.

Endpoint de API

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

¿Prefiere automatizarlo? Un POST autenticado crea la tarea; el resultado llega por webhook o enlace firmado. La misma capacidad también se ejecuta aquí en la web, por email y desde Telegram — y pronto también desde nuestra app.

Llámela desde su 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)

Ejemplo de solicitud

{
  "text": "123456789"
}

Ejemplo de respuesta

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

La API es asíncrona: la llamada devuelve un task_id al instante y el resultado llega por webhook. El polling está limitado a 1 req/s por tarea.

Precio

Por solicitud$0.002

Precio publicado — sin tokens ni créditos inventados. Una tarea fallida no se cobra.

Errores

HTTP	Código	Significado
`401`	`unauthorized`	API key ausente o inválida.
`402`	`insufficient_balance`	El saldo no cubre el precio de la tarea.
`404`	`unknown_type`	El tipo de tarea no existe.
`429`	`rate_limited`	Demasiadas peticiones. Use el webhook en vez de sondear.

Notas técnicas

Ninguna llamada de red, sal aleatoria ni reloj de pared intervienen en el cálculo: cada ruta exitosa es aritmética pura al precio base publicado $0.002.

Contrato de entrada, campos de respuesta y comportamiento con entrada vacía

La cadena vacía se permite a propósito: muchas canalizaciones resumen campos opcionales y necesitan un residual cero estable en lugar de un fallo duro. Algorithm es siempre la etiqueta Fletcher-32 y modulus es siempre la cadena decimal seis-cinco-cinco-tres-cinco para que ejemplos OpenAPI y respuestas de soporte citen el perfil sin ambigüedad. No hay conmutador de modo para Fletcher-16, Adler-32 o CRC-32: si necesita esos resúmenes, use una capacidad dedicada para que cada página de destino coincida con una sola intención de búsqueda y slug SEO. Envíe un cuerpo JSON con el campo obligatorio text igual a la cadena cuya suma de verificación desea calcular. Se aceptan los alias input, value, s, string y content para que formularios antiguos y clientes breves sigan enlazando. Los números finitos y los enteros grandes se convierten a cadena antes del cálculo; objetos, arrays, booleanos, null, Infinity y NaN provocan invalid_input y no se facturan. Cuando la longitud de origen es cero, la respuesta pone empty en true, fletcher32 en ocho dígitos cero, fletcher32_int en cero, bytes en cero y words en cero. Con entrada no vacía empty es false, bytes iguala la longitud UTF-8, words es el techo de esa longitud dividido entre dos, fletcher32 es el residual hex de ocho dígitos en minúsculas sin prefijo cero-x, y fletcher32_int es el mismo valor como entero de treinta y dos bits sin signo, útil en lenguajes que prefieren números a cadenas.

Dónde una API de suma de verificación Fletcher-32 aporta valor

Los desarrolladores pegan fragmentos cortos de configuración, muestras de protocolo y bases de nombres de archivo en una calculadora Fletcher-32 cuando necesitan una etiqueta de integridad compacta más barata que un hash criptográfico y más sensible al orden que una suma simple. Los ingenieros de soporte recalculan residuales a partir del texto del ticket para confirmar que un volcado pegado no se truncó ni reordenó en tránsito. Los laboratorios educativos usan el mismo endpoint para mostrar que intercambiar dos palabras de dieciséis bits cambia el resumen hex, ilustrando la sensibilidad a la posición sin maquinaria criptográfica. Como la implementación es parse pura de nivel A, cada llamada exitosa cuesta el precio base publicado $0.002 sin tokens de modelo ni red saliente; la validación fallida no consume saldo. Mantenga las cargas bajo el techo de caracteres documentado, trate el campo hex como destino canónico de pegado, y obtendrá valores Fletcher-32 reproducibles para documentación, SDK, workers en el borde y demostraciones de aula sin levantar un servicio de suma de verificación aparte.

Casos de integración

Vectores golden de CI y fixtures de entrada vacía

Fije una cadena conocida → digest hex fijo y vacío → 00000000 para que la integración continua detecte al instante deriva de endianness, módulo o codificación UTF-8.

Preguntas técnicas

¿Cómo calculo la suma de verificación Fletcher-32 de un texto?

Envíe JSON con text igual a su cadena. El campo fletcher32 devuelve ocho dígitos hex en minúsculas del residual sobre bytes UTF-8 empaquetados como palabras little-endian de dieciséis bits; fletcher32_int es el mismo valor como entero sin signo.

¿Qué ocurre con la entrada vacía?

El texto vacío es válido. La respuesta pone empty en true, fletcher32 en 00000000, fletcher32_int en 0, bytes en 0 y words en 0. Un text ausente o no cadena provoca invalid_input.

¿Cuánto cuesta la herramienta de suma de verificación Fletcher-32?

El widget del navegador es gratuito. Las peticiones API usan saldo KIT prepago a $0.002 por llamada exitosa; la entrada inválida no se factura.

Ver la documentación completa del KIT →

Ejecutar — gratis