У кого-нибудь есть код CRC128 и CRC256 на C ++ и C #?

Question

Я учусь, пытаюсь понять мысли о CRC.Я не могу найти код CRC128 и CRC256 нигде.Если у кого-то из вас есть код C ++ или C #, поделитесь им со мной.Также предоставьте онлайн-ссылки на веб-сайты.Я новичок и вообще не могу кодировать его самостоятельно, равно как и теорию и математику не могу преобразовать в кодирование.Поэтому я прошу у вас помощи.Это будет так мило с вашей стороны, кто предоставит мне правильные и простые коды.Если кто-нибудь предоставит мне эти коды, просьба также предоставить функции генератора таблиц CRC.Спасибо.

Answer 1

Вот класс Java, который я недавно написал для игры с CRC. Помните, что изменение порядка битов реализовано только для побитового вычисления.

/**
 * A CRC algorithm for computing check values.
 */
public class Crc
{
public static final Crc CRC_16_CCITT =
    new Crc(16, 0x1021, 0xffff, 0xffff, true);
public static final Crc CRC_32 =
    new Crc(32, 0x04c11db7, 0xffffffffL, 0xffffffffL, true);


private final int _width;
private final long _polynomial;
private final long _mask;
private final long _highBitMask;
private final long _preset;
private final long _postComplementMask;
private final boolean _msbFirstBitOrder;
private final int _shift;

private final long[] _crcs;



/**
 * Constructs a CRC specification.
 *
 * @param width
 * @param polynomial
 * @param msbFirstBitOrder
 */
public Crc(
    int width,
    long polynomial)
{
    this(width, polynomial, 0, 0, true);
}


/**
 * Constructs a CRC specification.
 *
 * @param width
 * @param polynomial
 * @param msbFirstBitOrder
 */
public Crc(
    int width,
    long polynomial,
    long preset,
    long postComplementMask,
    boolean msbFirstBitOrder)
{
    super();
    _width = width;
    _polynomial = polynomial;
    _mask = (1L << width) - 1;
    _highBitMask = (1L << (width - 1));
    _preset = preset;
    _postComplementMask = postComplementMask;
    _msbFirstBitOrder = msbFirstBitOrder;
    _shift = _width - 8;

    _crcs = new long[256];
    for (int i = 0; i < 256; i++)
    {
        _crcs[i] = crcForByte(i);
    }
}


/**
 * Gets the width.
 *
 * @return  The width.
 */
public int getWidth()
{
    return _width;
}


/**
 * Gets the polynomial.
 *
 * @return  The polynomial.
 */
public long getPolynomial()
{
    return _polynomial;
}


/**
 * Gets the mask.
 *
 * @return  The mask.
 */
public long getMask()
{
    return _mask;
}


/**
 * Gets the preset.
 *
 * @return  The preset.
 */
public long getPreset()
{
    return _preset;
}


/**
 * Gets the post-complement mask.
 *
 * @return  The post-complement mask.
 */
public long getPostComplementMask()
{
    return _postComplementMask;
}


/**
 * @return  True if this CRC uses MSB first bit order.
 */
public boolean isMsbFirstBitOrder()
{
    return _msbFirstBitOrder;
}


public long computeBitwise(byte[] message)
{
    long result = _preset;

    for (int i = 0; i < message.length; i++)
    {
        for (int j = 0; j < 8; j++)
        {
            final int bitIndex = _msbFirstBitOrder ? 7 - j : j;
            final boolean messageBit = (message[i] & (1 << bitIndex)) != 0;
            final boolean crcBit = (result & _highBitMask) != 0;

            result <<= 1;
            if (messageBit ^ crcBit)
            {
                result ^= _polynomial;
            }
            result &= _mask;
        }
    }

    return result ^ _postComplementMask;
}


public long compute(byte[] message)
{
    long result = _preset;

    for (int i = 0; i < message.length; i++)
    {
        final int b = (int) (message[i] ^ (result >>> _shift)) & 0xff;

        result = ((result << 8) ^ _crcs[b]) & _mask;
    }
    return result ^ _postComplementMask;
}


private long crcForByte(int b)
{
    long result1 = (b & 0xff) << _shift;
    for (int j = 0; j < 8; j++)
    {
        final boolean crcBit = (result1 & (1L << (_width - 1))) != 0;

        result1 <<= 1;
        if (crcBit)
        {
            result1 ^= _polynomial;
        }
        result1 &= _mask;
    }
    return result1;
}


public String crcTable()
{
    final int digits = (_width + 3) / 4;
    final int itemsPerLine = (digits + 4) * 8 < 72 ? 8 : 4;

    final String format = "0x%0" + digits + "x, ";

    final StringBuilder builder = new StringBuilder();
    builder.append("{\n");
    for (int i = 0; i < _crcs.length; i += itemsPerLine)
    {
        builder.append("    ");
        for (int j = i; j < i + itemsPerLine; j++)
        {
            builder.append(String.format(format, _crcs[j]));
        }
        builder.append("\n");
    }
    builder.append("}\n");
    return builder.toString();
}
}

Answer 2

CRC-128 и CRC-256 имеют смысл только в том случае, если верны три следующих пункта:

1. Вы ограничены процессором до того момента, когда криптографический хеш значительно замедлит вас
2. Случайное столкновение не должно происходить статистически, 1 в 2 ^ 64 все еще слишком велико
3. OTOH преднамеренные столкновения не являются проблемой

Типичный случай, когда 2 и 3 могут быть истинными вместе, - это если случайное столкновение приведет к потере данных, которая затрагивает только отправителя данных, а не платформу.

Answer 3

Несмотря на то, что были определены CRC-128 и CRC-256, я не знаю никого, кто бы на самом деле их использовал.1003 * криптографическая хеш-функция , которая успешно прошла CRC для многих приложений.Действительно, это был бы редкий случай, когда CRC-128 или CRC-256 был бы лучшим выбором даже для сломанного MD5, а тем более для семейства SHA-2.

Answer 4

Я согласен с вами, за исключением того, что частота случайных столкновений выше, чем 1 в 2 ^ 32 или 1 в 2 ^ 64 для 32-битных и 64-битных CRC соответственно.

Я написал приложение, которое отслеживало вещи по их значениям CRC для отслеживания предметов. Нам нужно было отслеживать потенциально миллионы предметов, и мы начали с CRC32, который в реальной практике имеет частоту столкновений около 1 на 2 ^ 16, что было неприятным сюрпризом. Затем мы перекодировали для использования CRC64, который имел реальную частоту столкновений около 1 на 2 ^ 23. Мы проверили это после неприятного сюрприза 32-битного, с которым мы начали, и приняли небольшую частоту ошибок 64-битного.

Я не могу объяснить статистику ожидаемой частоты столкновений, но имеет смысл, что вы столкнетесь намного раньше, чем ширина битов. Точно так же, как хеш-таблица ... некоторые хэш-контейнеры пусты, а другие содержат более одной записи ....

Даже для 256-битной CRC первые 2 CRC могут быть одинаковыми ... это было бы почти невероятно, но возможно.