Calculadora de soma de verificação CRC-16

Visao geral da ferramenta: Calculadora de soma de verificação CRC-16

CRC-16 (Verificação de redundância cíclica de 16 bits) é um algoritmo de detecção de erro amplamente utilizado, principalmente usado para verificação de integridade na transmissão e armazenamento de dados. Esta ferramenta suporta múltiplas variantes de algoritmos CRC-16 adequadas para diferentes cenários de aplicação.

O que é Calculadora de soma de verificação CRC-16?

Calculadora de soma de verificação CRC-16 codifica/decodifica conteúdo ou gera checksums para verificação.

Como usar

1. Cole o conteúdo ou informe o texto.
2. Escolha o modo de codificação ou hash.
3. Copie o resultado gerado.

Casos de uso comuns

• Assinaturas e verificação de integridade
• Transferência segura entre sistemas
• Validação rápida durante debug

❓ Perguntas frequentes

P1: Por que o resultado está incorreto?
R: Verifique o formato de entrada e as opções, e teste o exemplo se houver.

P2: E se a entrada for muito grande?
R: Divida os dados em partes menores para obter resultados mais estáveis.

P3: Como salvo a saída?
R: Use os botões de copiar ou baixar se a ferramenta oferecer.

🔧 Algoritmos suportados

CRC-16 Standard

• Polinômio: 0x8005 (x^16 + x^15 + x^2 + 1)
• Valor inicial: 0x0000
• Aplicação: Verificação geral de dados

CRC-16 CCITT

• Polinômio: 0x1021 (x^16 + x^12 + x^5 + 1)
• Valor inicial: 0xFFFF
• Aplicação: Protocolos de comunicação, X.25, HDLC

CRC-16 Modbus

• Polinômio: 0x8005
• Valor inicial: 0xFFFF
• Aplicação: Protocolo de comunicação Modbus

CRC-16 XMODEM

• Polinômio: 0x1021
• Valor inicial: 0x0000
• Aplicação: Protocolo de transferência de arquivos XMODEM

💡 Casos de uso

1. Verificação de integridade de dados

// Verificação de integridade de transmissão de dados
class DataIntegrityChecker {
  constructor() {
    this.checksums = new Map();
  }

  // Calcular e armazenar soma de verificação CRC-16 para dados
  storeChecksum(dataId, data) {
    const crc16 = this.calculateCRC16(data, 'crc16');
    this.checksums.set(dataId, crc16);
    return crc16;
  }

  // Verificar integridade dos dados
  verifyIntegrity(dataId, currentData) {
    const originalCRC = this.checksums.get(dataId);
    if (!originalCRC) {
      return { valid: false, reason: 'Soma de verificação original não encontrada' };
    }

    const currentCRC = this.calculateCRC16(currentData, 'crc16');
    const isValid = originalCRC === currentCRC;

    return {
      valid: isValid,
      originalCRC: '0x' + originalCRC.toString(16).toUpperCase(),
      currentCRC: '0x' + currentCRC.toString(16).toUpperCase(),
      reason: isValid ? 'Dados intactos' : 'Os dados foram modificados'
    };
  }

  calculateCRC16(data, algorithm) {
    // Usar biblioteca CRC profissional na implementação real
    return this.crcCalculate(data, algorithm);
  }
}

// Exemplo de uso
const checker = new DataIntegrityChecker();

// Armazenar soma de verificação para dados originais
const originalData = "Dados comerciais importantes";
const checksum = checker.storeChecksum('data001', originalData);
console.log('Soma de verificação armazenada:', checksum);

// Verificar integridade dos dados
const currentData = "Dados comerciais importantes"; // Não modificado
const verification = checker.verifyIntegrity('data001', currentData);
console.log('Resultado da verificação de integridade:', verification);

2. Implementação de protocolo de comunicação

// Verificação CRC do protocolo de comunicação Modbus
class ModbusProtocol {
  constructor() {
    this.crcTable = this.generateCRCTable(0x8005);
  }

  // Gerar tabela de consulta CRC
  generateCRCTable(polynomial) {
    const table = [];
    for (let i = 0; i < 256; i++) {
      let crc = i;
      for (let j = 0; j < 8; j++) {
        if (crc & 1) {
          crc = (crc >>> 1) ^ polynomial;
        } else {
          crc = crc >>> 1;
        }
      }
      table[i] = crc & 0xFFFF;
    }
    return table;
  }

  // Calcular Modbus CRC-16
  calculateModbusCRC(data) {
    let crc = 0xFFFF;
    const bytes = typeof data === 'string' ? 
      new TextEncoder().encode(data) : data;

    for (const byte of bytes) {
      const tableIndex = (crc ^ byte) & 0xFF;
      crc = ((crc >>> 8) ^ this.crcTable[tableIndex]) & 0xFFFF;
    }

    return crc;
  }

  // Criar quadro de mensagem Modbus
  createFrame(deviceId, functionCode, data) {
    const frame = [deviceId, functionCode, ...data];
    const crc = this.calculateModbusCRC(new Uint8Array(frame));
    
    // Adicionar CRC em formato little-endian ao final do quadro
    frame.push(crc & 0xFF);
    frame.push((crc >>> 8) & 0xFF);
    
    return new Uint8Array(frame);
  }

  // Verificar quadro de mensagem Modbus
  verifyFrame(frame) {
    if (frame.length < 4) {
      return { valid: false, reason: 'Comprimento do quadro insuficiente' };
    }

    const dataLength = frame.length - 2;
    const data = frame.slice(0, dataLength);
    const receivedCRC = frame[dataLength] | (frame[dataLength + 1] << 8);
    const calculatedCRC = this.calculateModbusCRC(data);

    return {
      valid: receivedCRC === calculatedCRC,
      receivedCRC: '0x' + receivedCRC.toString(16).toUpperCase(),
      calculatedCRC: '0x' + calculatedCRC.toString(16).toUpperCase(),
      reason: receivedCRC === calculatedCRC ? 'Verificação CRC bem-sucedida' : 'Verificação CRC falhada'
    };
  }
}

// Exemplo de uso
const modbus = new ModbusProtocol();

// Criar quadro de solicitação de leitura de registros de retenção
const frame = modbus.createFrame(0x01, 0x03, [0x00, 0x00, 0x00, 0x02]);
console.log('Quadro Modbus:', Array.from(frame).map(b => '0x' + b.toString(16).toUpperCase()));

// Verificar quadro recebido
const verification = modbus.verifyFrame(frame);
console.log('Resultado da verificação do quadro:', verification);

🔍 Características do algoritmo

Vantagens

• Cálculo rápido: Mais rápido que algoritmos MD5, SHA
• Compatível com hardware: Fácil de implementar em hardware
• Padronizado: Múltiplos algoritmos padrão disponíveis
• Tempo real: Adequado para verificação de dados em tempo real

Limitações

• Segurança: Não adequado para segurança criptográfica
• Colisões: Dados diferentes podem ter a mesma soma de verificação
• Comprimento: Soma de verificação de 16 bits é relativamente curta

⚠️ Recomendações de uso

1. Seleção de algoritmo: Escolher a variante CRC-16 apropriada com base no protocolo específico
2. Otimização de desempenho: Usar tabelas de consulta para melhorar a eficiência de cálculo
3. Tratamento de erros: Implementar detecção e tratamento de erros abrangentes
4. Verificação de teste: Usar vetores de teste padrão para verificar a correção da implementação

📚 Referências técnicas

• ITU-T V.41: Padrão CCITT CRC-16
• Especificação Modbus: Implementação Modbus CRC-16
• RFC 1662: Uso de CRC-16 em PPP
• ISO 3309: Padrão CRC em HDLC