Checksum CRC-64
Os nove caracteres 123456789 dão em CRC-64/ECMA-182 o valor 6C40DF5F0B497347, a verificação de referência deste perfil, então uma biblioteca que devolve outra coisa não é ECMA-182. Cole qualquer texto para obter o resíduo de 64 bits. Grátis no seu navegador.
- Grátis
- Funciona no seu navegador
- Sem cadastro
- Seus dados não saem do seu aparelho
Executar grátis
Exemplo resolvido
- Texto
- 123456789
- CRC em hex
- 6C40DF5F0B497347
- Crc hi
- 6C40DF5F
- Crc lo
- 0B497347
- Contagem de bytes
- 9
CRC-64 com o polinômio ECMA é uma verificação de redundância cíclica de sessenta e quatro bits usada quando você precisa de um residual mais forte que CRC-32 sem recorrer a um hash criptográfico. Sistemas de armazenamento, ferramentas de arquivamento e projetistas de protocolo confiam em CRC-64/ECMA-182 para detectar corrupção acidental em buffers, segmentos de arquivo e mensagens emolduradas. Esta capacidade recebe uma string de texto não vazia, codifica-a como UTF-8, executa o algoritmo padrão ECMA-182 com polinômio 0x42F0E1EBA9EA3693 e valor inicial zero, e devolve o residual como dezesseis dígitos hexadecimais em maiúsculas.
O que é CRC-64 ECMA e quando usá-lo
Uma verificação de redundância cíclica dobra cada byte de entrada por um polinômio gerador fixo de modo que um único bit invertido quase sempre altera o residual. CRC-64/ECMA-182 é o perfil de sessenta e quatro bits definido em torno do polinômio da European Computer Manufacturers Association 0x42F0E1EBA9EA3693: o registrador começa em zero, cada byte é combinado com XOR nos oito bits altos da palavra de sessenta e quatro bits, e por byte seguem oito passos de deslocamento e XOR condicional sem reflexão de entrada nem máscara final de exclusive-or.
O vetor de verificação clássico são os nove dígitos ASCII de um a nove, que devem produzir o residual 0x6C40DF5F0B497347; se a sua biblioteca discordar desse valor, não é ECMA-182 mesmo que anuncie CRC-64. Em comparação com CRC-16 Modbus ou CRC-32, o residual mais largo reduz o risco de colisão em cargas grandes e arquivos multi-segmento, e permanece bem mais barato que SHA-256 quando você só precisa de integridade contra ruído acidental, não de resistência a colisões adversárias.
Não o use como hash de senha nem como substituto de um MAC com chave: verificações de redundância cíclica são funções lineares públicas e não oferecem segredo nem autenticação contra um atacante motivado.
Perguntas frequentes
Como calcular um checksum CRC-64 ECMA?
Envie uma string de texto não vazia no campo text.
Qual polinômio e valor inicial esta ferramenta usa?
CRC-64/ECMA-182: polinômio 0x42F0E1EBA9EA3693, registrador inicial 0x0000000000000000, sem reflexão nem XOR final. O vetor de verificação 123456789 produz 6C40DF5F0B497347.
O que acontece se eu enviar entrada vazia?
Forneça ao menos um caractere de texto para hashear.
CRC-64 é o mesmo que um hash criptográfico?
Não. CRC-64 detecta corrupção acidental; não é resistente a colisões contra um atacante e não deve substituir SHA-256, HMAC nem hash de senhas.
Quando o CRC-64 é melhor escolha que o CRC-32?
Quando os dados são grandes ou divididos em muitos segmentos de arquivo. O resíduo de 64 bits reduz o risco de uma coincidência acidental e continua bem mais leve que o SHA-256 quando você só precisa se proteger de ruído.
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
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/crc64 \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"123456789"}'const res = await fetch("https://api.kit.forhosting.com/enc/crc64", {
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/crc64",
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/crc64", 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/crc64", 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.crc64",
"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
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
A entrada vazia é rejeitada com invalid_input para que ninguém confunda uma carga de comprimento zero com um hash bem-sucedido.
O que é CRC-64 ECMA e quando usá-lo
Use este endpoint sempre que uma especificação nomeie CRC-64 ECMA, ECMA-182 ou o polinômio da família XZ sem reflexão, quando fixar residuais dourados em integração contínua, ou quando precisar de uma calculadora visível no navegador que coincida byte a byte com as ferramentas de servidor.
Contrato de entrada, entrada vazia e campos de resposta
A string é codificada como UTF-8 e cada byte resultante entra no CRC; não há modo hex separado nesta capacidade — cole o texto literal que deseja hashear. Números e booleanos são aceitos convertendo-os primeiro em string, o que facilita demonstrações simples de calculadora. Validação falha não é cobrada. Envie por POST um corpo JSON com o campo de string obrigatório text. Texto vazio, incluindo uma string de comprimento zero após omitir conteúdo útil, é rejeitado com invalid_input e uma mensagem que reporta entrada vazia para que interfaces de formulário e clientes API destaquem o campo sem adivinhar. Falta de text, null ou um valor que não seja string nem escalar também falham com invalid_input. Em caso de sucesso, o corpo inclui crc_hex como dezesseis dígitos hexadecimais em maiúsculas do residual completo de sessenta e quatro bits, crc_hi e crc_lo como as metades alta e baixa de trinta e dois bits com oito dígitos hex cada, byte_count da carga UTF-8, e strings fixas algorithm, poly e init que documentam CRC-64/ECMA-182 com polinômio 0x42F0E1EBA9EA3693 e init 0x0000000000000000. Aceitam-se aliases data, payload, value e input para o campo de carga, para que clientes SDK e posts de formulário legados continuem funcionando.
Onde uma API CRC-64 ECMA realmente vale a pena
Sites de conteúdo que rankeiam por checksum CRC-64 ou calculadora do polinômio ECMA ganham uma ferramenta ao vivo cujo caminho gratuito coincide exatamente com o de automação, o que gera confiança quando o leitor compara com utilitários offline. Suites de integração contínua fixam pares dourados como um-dois-três-quatro-cinco-seis-sete-oito-nove igual a 6C40DF5F0B497347 para que um erro de polinômio nunca chegue à produção. Mantenha pedidos determinísticos, rejeite cargas vazias na borda e obtenha reprodutibilidade de nível de arquivo sem embutir tabelas CRC em cada microsserviço. Autores de backend incorporam a chamada em pipelines de upload que carimbam cada pedaço com crc_hex antes de gravar no armazenamento de objetos, e recalculam no download para detectar bit rot cedo. 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 e sem rede de saída no caminho de computação. Combine crc_hex com seu log e trilha de auditoria quando precisar de um único token imprimível, ou use crc_hi e crc_lo quando armazenar o residual como dois inteiros de trinta e dois bits sem sinal em linguagens sem tipos nativos de sessenta e quatro bits.
Casos de integração
Selos de integridade por pedaços
Faça o hash de cada segmento de texto enviado com CRC-64 ECMA e armazene crc_hex ao lado do objeto para que leitores recalculem e detectem corrupção sem hash criptográfico completo.
Checagens douradas de biblioteca e firmware
Afirme que o código do dispositivo e as ferramentas de servidor produzem ambos crc_hex 6C40DF5F0B497347 para ASCII 123456789 e coincidem com seus modelos fixos de regressão.
Calculadora SEO e documentação de suporte
Ofereça uma página ao vivo de checksum CRC-64 para engenheiros que buscam o residual do polinômio ECMA, com execução gratuita no navegador alinhada à API pré-paga.
Perguntas técnicas
Quanto custa a ferramenta de checksum CRC-64?
A ferramenta do navegador é gratuita. Pedidos API usam saldo KIT pré-pago a US$ 0,002 por chamada bem-sucedida; entrada inválida não é cobrada.