Exemplo usando CRC (Cyclic Redundancy Check) em c#

[marcialwushu]

O algoritmo CRC é comumente usado para detecção de erros em transmissões de dados. Aqui está um exemplo simples de como calcular o valor CRC de uma mensagem usando C#:

using System;
using System.IO;
using System.Security.Cryptography;

public class Program
{
    public static void Main()
    {
        string message = "Hello, world!";
        byte[] data = System.Text.Encoding.UTF8.GetBytes(message);
        
        var crc = new CRC32();
        var hash = crc.ComputeHash(data);
        
        Console.WriteLine(BitConverter.ToString(hash));
    }
}

public class CRC32 : HashAlgorithm
{
    private const uint _defaultPolynomial = 0xedb88320u;
    private const uint _defaultSeed = 0xffffffffu;
    private static uint[] _defaultTable;

    private readonly uint _seed;
    private readonly uint[] _table;
    private uint _hash;

    public CRC32()
        : this(_defaultPolynomial, _defaultSeed)
    {
    }

    public CRC32(uint polynomial, uint seed)
    {
        _table = InitializeTable(polynomial);
        _seed = _hash = seed;
    }

    public override void Initialize()
    {
        _hash = _seed;
    }

    protected override void HashCore(byte[] buffer, int start, int length)
    {
        _hash = CalculateHash(_table, _hash, buffer, start, length);
    }

    protected override byte[] HashFinal()
    {
        var hashBuffer = UInt32ToBigEndianBytes(~_hash);
        HashValue = hashBuffer;
        return hashBuffer;
    }

    public override int HashSize => 32;

    public static uint Compute(byte[] buffer)
    {
        var crc = new CRC32();
        var hash = crc.ComputeHash(buffer);
        return BitConverter.ToUInt32(hash, 0);
    }

    private static uint[] InitializeTable(uint polynomial)
    {
        if (polynomial == _defaultPolynomial && _defaultTable != null)
            return _defaultTable;

        var table = new uint[256];
        for (int i = 0; i < 256; i++)
        {
            var entry = (uint)i;
            for (int j = 0; j < 8; j++)
                if ((entry & 1) == 1)
                    entry = (entry >> 1) ^ polynomial;
                else
                    entry >>= 1;
            table[i] = entry;
        }

        if (polynomial == _defaultPolynomial)
            _defaultTable = table;

        return table;
    }

    private static uint CalculateHash(uint[] table, uint seed, byte[] buffer, int start, int size)
    {
        var hash = seed;
        for (int i = start; i < start + size; i++)
            hash = (hash >> 8) ^ table[buffer[i] ^ hash & 0xff];
        return hash;
    }

    private static byte[] UInt32ToBigEndianBytes(uint x)
    {
        return new[]
        {
            (byte)((x >> 24) & 0xff),
            (byte)((x >> 16) & 0xff),
            (byte)((x >> 8) & 0xff),
            (byte)(x & 0xff)
        };
    }
}

Neste exemplo, a classe CRC32 herda da classe HashAlgorithm e implementa a lógica de cálculo do valor CRC. A classe CRC32 também define um construtor que aceita um polinômio e um valor semente para personalizar a função de hash CRC. A classe `