Calculadora de soma de verificação CRC

Respostas rápidas

O que é um CRC?

// CRC-16/MODBUS: poly=0x8005, init=0xFFFF, refin/refout=true, xorout=0x0000
// Written in the reflected form, so the polynomial appears bit-reversed as 0xA001.
function crc16Modbus(bytes) {
  let crc = 0xffff;
  for (const byte of bytes) {
    crc ^= byte;
    for (let i = 0; i < 8; i++) {
      crc = crc & 1 ? (crc >>> 1) ^ 0xa001 : crc >>> 1;
    }
  }
  return crc;
}

crc16Modbus([0x01, 0x03, 0x00, 0x00, 0x00, 0x0a]); // 0xCDC5
// On the wire Modbus RTU sends the low byte first: ... 0x0A 0xC5 0xCD

O que esta calculadora faz

Exemplos resolvidos

123456789

CRC-32/ISO-HDLC = 0xCBF43926, CRC-16/MODBUS = 0x4B37, CRC-8/SMBUS = 0xF4

01 03 00 00 00 0A

CRC-16/MODBUS = 0xCDC5

DEADBEEF

MODBUS = 0xC19B, CCITT-FALSE = 0x4097, XMODEM = 0xC457, KERMIT = 0x1915

123456789 com valor esperado 0x29B1

CRC-16/IBM-3740 (seu manual pode chamá-la de CRC-16/CCITT-FALSE)

Como usar a calculadora de CRC

1. 1

   Escolha texto ou hex

   Quadros de protocolo são quase sempre hex. Use texto apenas quando estiver calculando o checksum de uma string literal, como o valor de autoteste 123456789.

2. 2

   Cole seus dados

   No modo hex os separadores são ignorados, então 01 03 00 00 00 0A, 0x01 0x03 e 010300 00000A são todos aceitos.

3. 3

   Localize a variante que você precisa

   A tabela é agrupada por largura. Os nomes formais vêm do catálogo RevEng, com os apelidos que o manual do seu equipamento provavelmente usa impressos logo abaixo.

4. 4

   Ou faça o caminho inverso

   Se você já tem um checksum e quer saber a variante dele, digite-o no campo de valor esperado e leia a linha destacada.

Por que seu checksum não bate

Text mode, input "01 03" -> 5 bytes: 30 31 20 30 33

Hex mode, input "01 03" -> 2 bytes: 01 03

expected 0xC5CD  (bytes read in transmission order)

expected 0xCDC5  (bytes reassembled low-byte-first)

01 03 00 00 00 0A C5 CD    <- trailer included

01 03 00 00 00 0A          <- payload only

spec says: "trailer is a CRC-16"

spec says: "CRC-16/MODBUS, poly 0x8005, init 0xFFFF, refin/refout true"

Quando você precisa disto

Depurar um enlace Modbus

Um CLP rejeita seus quadros e você precisa saber se o CRC está errado ou apenas com os bytes trocados. Calcule o CRC-16/MODBUS e compare as duas ordens.

Identificar um protocolo sem documentação

Você capturou tráfego com um sufixo de dois bytes que parece um checksum. Passe o payload e o sufixo para a busca reversa e veja qual variante o reivindica.

Portar firmware entre toolchains

A biblioteca do fornecedor e a sua implementação discordam. Comparar as duas com o valor de verificação do catálogo mostra qual delas saiu do rumo.

Escrever ou revisar uma especificação

Escrever apenas "CRC-16" em um documento de protocolo é garantia de bugs de interoperabilidade. A tabela de parâmetros te dá os seis valores que de fato fixam o algoritmo.

Conferir dados armazenados

Sistemas de arquivos, formatos de compactação e imagens de flash carregam campos CRC-32. Recalcular um deles diz se o bloco sobreviveu intacto.

Como o CRC funciona

Representação do polinômio

A tabela imprime os polinômios na forma normal (MSB primeiro): 0x8005 significa x^16 + x^15 + x^2 + 1. Implementações refletidas costumam mostrar o mesmo polinômio como 0xA001, e a notação de Koopman o desloca de outra maneira ainda. Três notações para um único polinômio são uma fonte comum de portes que não funcionam.

O valor inicial

Começar o registrador em 0xFFFF em vez de 0x0000 deixa o checksum sensível a bytes zero no início. Com init zero, prefixar uma mensagem com zeros não muda o CRC — que é exatamente a corrupção que um protocolo com quadros precisa pegar.

Reflexão

refin inverte os bits dentro de cada byte de entrada, refout inverte o registrador final. O hardware desloca os bits do MSB para o LSB, enquanto o software orientado a bytes acha mais barato ir do LSB para o MSB, e as formas refletidas dos parâmetros reconciliam as duas.

XOR final

O xorout é aplicado por último, e não é simplesmente um init na outra ponta. Bytes zero acrescentados à mensagem são detectados nos dois casos. O que um xorout diferente de zero muda é o resíduo que um receptor obtém quando roda o CRC sobre a mensagem e o checksum juntos: com xorout zero esse resíduo é ele próprio zero, de modo que zeros acrescentados depois do campo de CRC continuam passando. Ele também faz a mensagem toda de zeros produzir um checksum diferente de zero.

O valor de verificação

Toda variante catalogada publica seu resultado para a string ASCII 123456789. Os 63 valores exibidos nesta página quando essa entrada é carregada são exatamente essas constantes publicadas, e é assim que o motor desta página é testado.

Como chegar a um resultado que bate

Nomeie os parâmetros, não o algoritmo

Escreva "poly 0x1021, init 0xFFFF, refin false, refout false, xorout 0x0000" nas especificações. "CRC-16/CCITT" já significou pelo menos três coisas diferentes.

Confira a ordem dos bytes separadamente

Quando um checksum está a uma troca de bytes de bater, o algoritmo está certo e o enquadramento está errado. Trate os dois como bugs distintos.

Valide primeiro contra o valor de verificação

Antes de depurar seus dados, confirme que sua implementação devolve o valor do catálogo para 123456789. Isso separa um algoritmo quebrado de uma entrada quebrada em segundos.

Seja explícito sobre o que é coberto

A maior parte das divergências vem de incluir ou excluir marcadores de início, endereços ou campos de comprimento. Decida exatamente quais bytes o CRC abrange e deixe isso escrito.

Não use CRC onde é preciso um MAC

O CRC é linear e trivialmente falsificável. Se um adversário puder modificar os dados, use HMAC no lugar.

Perguntas frequentes