Calculateur de somme de contrôle CRC-16

Apercu de l'outil : Calculateur de somme de contrôle CRC-16

CRC-16 (Contrôle de redondance cyclique 16 bits) est un algorithme de détection d'erreur largement utilisé, principalement utilisé pour la vérification d'intégrité dans la transmission et le stockage de données. Cet outil prend en charge plusieurs variantes d'algorithmes CRC-16 adaptées à différents scénarios d'application.

Qu'est-ce que Calculateur de somme de contrôle CRC-16 ?

Calculateur de somme de contrôle CRC-16 encode/décode le contenu ou génère des checksums pour vérification.

Comment l'utiliser

1. Collez le contenu ou saisissez le texte.
2. Choisissez le mode d'encodage ou de hachage.
3. Copiez le résultat généré.

Cas d'usage courants

• Signatures et vérification d'intégrité
• Transfert sûr entre systèmes
• Validation rapide en debug

❓ FAQ

Q1 : Pourquoi le résultat est incorrect ?
R : Vérifiez le format d'entrée et les options, puis essayez l'exemple s'il existe.

Q2 : Et si l'entrée est très grande ?
R : Découpez les données en plus petits blocs pour plus de stabilité.

Q3 : Comment sauvegarder la sortie ?
R : Utilisez les boutons de copie ou de téléchargement si l'outil les propose.

🔧 Algorithmes pris en charge

CRC-16 Standard

• Polynôme: 0x8005 (x^16 + x^15 + x^2 + 1)
• Valeur initiale: 0x0000
• Application: Vérification générale des données

CRC-16 CCITT

• Polynôme: 0x1021 (x^16 + x^12 + x^5 + 1)
• Valeur initiale: 0xFFFF
• Application: Protocoles de communication, X.25, HDLC

CRC-16 Modbus

• Polynôme: 0x8005
• Valeur initiale: 0xFFFF
• Application: Protocole de communication Modbus

CRC-16 XMODEM

• Polynôme: 0x1021
• Valeur initiale: 0x0000
• Application: Protocole de transfert de fichiers XMODEM

💡 Cas d'utilisation

1. Vérification de l'intégrité des données

// Vérification de l'intégrité de la transmission de données
class DataIntegrityChecker {
  constructor() {
    this.checksums = new Map();
  }

  // Calculer et stocker la somme de contrôle CRC-16 pour les données
  storeChecksum(dataId, data) {
    const crc16 = this.calculateCRC16(data, 'crc16');
    this.checksums.set(dataId, crc16);
    return crc16;
  }

  // Vérifier l'intégrité des données
  verifyIntegrity(dataId, currentData) {
    const originalCRC = this.checksums.get(dataId);
    if (!originalCRC) {
      return { valid: false, reason: 'Somme de contrôle originale non trouvée' };
    }

    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 ? 'Données intactes' : 'Les données ont été modifiées'
    };
  }

  calculateCRC16(data, algorithm) {
    // Utiliser une bibliothèque CRC professionnelle dans l'implémentation réelle
    return this.crcCalculate(data, algorithm);
  }
}

// Exemple d'utilisation
const checker = new DataIntegrityChecker();

// Stocker la somme de contrôle pour les données originales
const originalData = "Données commerciales importantes";
const checksum = checker.storeChecksum('data001', originalData);
console.log('Somme de contrôle stockée:', checksum);

// Vérifier l'intégrité des données
const currentData = "Données commerciales importantes"; // Non modifiées
const verification = checker.verifyIntegrity('data001', currentData);
console.log('Résultat de vérification d\'intégrité:', verification);

2. Implémentation de protocole de communication

// Vérification CRC du protocole de communication Modbus
class ModbusProtocol {
  constructor() {
    this.crcTable = this.generateCRCTable(0x8005);
  }

  // Générer une table de recherche 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;
  }

  // Calculer 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;
  }

  // Créer une trame de message Modbus
  createFrame(deviceId, functionCode, data) {
    const frame = [deviceId, functionCode, ...data];
    const crc = this.calculateModbusCRC(new Uint8Array(frame));
    
    // Ajouter CRC en format little-endian à la fin de la trame
    frame.push(crc & 0xFF);
    frame.push((crc >>> 8) & 0xFF);
    
    return new Uint8Array(frame);
  }

  // Vérifier la trame de message Modbus
  verifyFrame(frame) {
    if (frame.length < 4) {
      return { valid: false, reason: 'Longueur de trame insuffisante' };
    }

    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 ? 'Vérification CRC réussie' : 'Vérification CRC échouée'
    };
  }
}

// Exemple d'utilisation
const modbus = new ModbusProtocol();

// Créer une trame de demande de lecture des registres de maintien
const frame = modbus.createFrame(0x01, 0x03, [0x00, 0x00, 0x00, 0x02]);
console.log('Trame Modbus:', Array.from(frame).map(b => '0x' + b.toString(16).toUpperCase()));

// Vérifier la trame reçue
const verification = modbus.verifyFrame(frame);
console.log('Résultat de vérification de trame:', verification);

🔍 Caractéristiques de l'algorithme

Avantages

• Calcul rapide: Plus rapide que les algorithmes MD5, SHA
• Compatible matériel: Facile à implémenter en matériel
• Standardisé: Plusieurs algorithmes standard disponibles
• Temps réel: Adapté à la vérification de données en temps réel

Limitations

• Sécurité: Non adapté à la sécurité cryptographique
• Collisions: Différentes données peuvent avoir la même somme de contrôle
• Longueur: La somme de contrôle 16 bits est relativement courte

⚠️ Recommandations d'utilisation

1. Sélection d'algorithme: Choisir la variante CRC-16 appropriée selon le protocole spécifique
2. Optimisation des performances: Utiliser des tables de recherche pour améliorer l'efficacité de calcul
3. Gestion d'erreurs: Implémenter une détection et gestion d'erreurs complètes
4. Vérification de test: Utiliser des vecteurs de test standard pour vérifier la justesse de l'implémentation

📚 Références techniques

• ITU-T V.41: Standard CCITT CRC-16
• Spécification Modbus: Implémentation Modbus CRC-16
• RFC 1662: Utilisation CRC-16 dans PPP
• ISO 3309: Standard CRC dans HDLC