Calculadora de suma de verificación CRC-16

Resumen de la herramienta: Calculadora de suma de verificación CRC-16

CRC-16 (Verificación de redundancia cíclica de 16 bits) es un algoritmo de detección de errores ampliamente utilizado, principalmente usado para verificación de integridad en transmisión y almacenamiento de datos. Esta herramienta admite múltiples variantes de algoritmos CRC-16 adecuadas para diferentes escenarios de aplicación.

¿Qué es Calculadora de suma de verificación CRC-16?

Calculadora de suma de verificación CRC-16 codifica/decodifica contenido o genera checksums para verificación.

Cómo usarlo

1. Pega el contenido o ingresa el texto.
2. Elige el modo de codificación o hash.
3. Copia el resultado generado.

Casos de uso comunes

• Firmas y verificación de integridad
• Transmisión segura entre sistemas
• Validación rápida durante el debug

❓ Preguntas frecuentes

P1: ¿Resultados distintos con el mismo input?
R: Revisa la codificación y caracteres ocultos.

P2: ¿Se puede revertir?
R: La codificación es reversible; el hash no.

P3: ¿Entrada grande?
R: Divide en partes pequeñas para estabilidad.

🔧 Algoritmos admitidos

CRC-16 Standard

• Polinomio: 0x8005 (x^16 + x^15 + x^2 + 1)
• Valor inicial: 0x0000
• Aplicación: Verificación general de datos

CRC-16 CCITT

• Polinomio: 0x1021 (x^16 + x^12 + x^5 + 1)
• Valor inicial: 0xFFFF
• Aplicación: Protocolos de comunicación, X.25, HDLC

CRC-16 Modbus

• Polinomio: 0x8005
• Valor inicial: 0xFFFF
• Aplicación: Protocolo de comunicación Modbus

CRC-16 XMODEM

• Polinomio: 0x1021
• Valor inicial: 0x0000
• Aplicación: Protocolo de transferencia de archivos XMODEM

💡 Casos de uso

1. Verificación de integridad de datos

// Verificación de integridad de transmisión de datos
class DataIntegrityChecker {
  constructor() {
    this.checksums = new Map();
  }

  // Calcular y almacenar suma de verificación CRC-16 para datos
  storeChecksum(dataId, data) {
    const crc16 = this.calculateCRC16(data, 'crc16');
    this.checksums.set(dataId, crc16);
    return crc16;
  }

  // Verificar integridad de datos
  verifyIntegrity(dataId, currentData) {
    const originalCRC = this.checksums.get(dataId);
    if (!originalCRC) {
      return { valid: false, reason: 'Suma de verificación original no 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 ? 'Datos intactos' : 'Los datos han sido modificados'
    };
  }

  calculateCRC16(data, algorithm) {
    // Usar biblioteca CRC profesional en implementación real
    return this.crcCalculate(data, algorithm);
  }
}

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

// Almacenar suma de verificación para datos originales
const originalData = "Datos comerciales importantes";
const checksum = checker.storeChecksum('data001', originalData);
console.log('Suma de verificación almacenada:', checksum);

// Verificar integridad de datos
const currentData = "Datos comerciales importantes"; // Sin modificar
const verification = checker.verifyIntegrity('data001', currentData);
console.log('Resultado de verificación de integridad:', verification);

2. Implementación de protocolo de comunicación

// Verificación CRC del protocolo de comunicación Modbus
class ModbusProtocol {
  constructor() {
    this.crcTable = this.generateCRCTable(0x8005);
  }

  // Generar tabla de búsqueda 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;
  }

  // Crear trama de mensaje Modbus
  createFrame(deviceId, functionCode, data) {
    const frame = [deviceId, functionCode, ...data];
    const crc = this.calculateModbusCRC(new Uint8Array(frame));
    
    // Agregar CRC en formato little-endian al final de la trama
    frame.push(crc & 0xFF);
    frame.push((crc >>> 8) & 0xFF);
    
    return new Uint8Array(frame);
  }

  // Verificar trama de mensaje Modbus
  verifyFrame(frame) {
    if (frame.length < 4) {
      return { valid: false, reason: 'Longitud de trama 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 ? 'Verificación CRC exitosa' : 'Verificación CRC fallida'
    };
  }
}

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

// Crear trama de solicitud de lectura de registros de retención
const frame = modbus.createFrame(0x01, 0x03, [0x00, 0x00, 0x00, 0x02]);
console.log('Trama Modbus:', Array.from(frame).map(b => '0x' + b.toString(16).toUpperCase()));

// Verificar trama recibida
const verification = modbus.verifyFrame(frame);
console.log('Resultado de verificación de trama:', verification);

🔍 Características del algoritmo

Ventajas

• Cálculo rápido: Más rápido que algoritmos MD5, SHA
• Compatible con hardware: Fácil de implementar en hardware
• Estandarizado: Múltiples algoritmos estándar disponibles
• Tiempo real: Adecuado para verificación de datos en tiempo real

Limitaciones

• Seguridad: No adecuado para seguridad criptográfica
• Colisiones: Diferentes datos pueden tener la misma suma de verificación
• Longitud: La suma de verificación de 16 bits es relativamente corta

⚠️ Recomendaciones de uso

1. Selección de algoritmo: Elegir la variante CRC-16 apropiada según el protocolo específico
2. Optimización de rendimiento: Usar tablas de búsqueda para mejorar la eficiencia de cálculo
3. Manejo de errores: Implementar detección y manejo de errores integral
4. Verificación de prueba: Usar vectores de prueba estándar para verificar la corrección de la implementación

📚 Referencias técnicas

• ITU-T V.41: Estándar CCITT CRC-16
• Especificación Modbus: Implementación Modbus CRC-16
• RFC 1662: Uso de CRC-16 en PPP
• ISO 3309: Estándar CRC en HDLC