How to generate Crc-64 table having all negative integer Constants and checksum?

Question

I have some example code for Crc-64 Table generator. I tried to check the unsigned integer's sign and discovered that it generates mixed table Constants both negative & positive integers. Same for the Crc-64 Checksum, it may be negative or positive. Is it possible to implement a modified Crc-64 Table generator that should produce all negative signed Constants and also the Checksum? Or otherwise all positive signed Constants and Checksum. Kindly help me with some information and example implementation.

Here is the example code for the Crc-64 Table generator:

public class Crc64
{
    public const UInt64 POLYNOMIAL = 0xD800000000000000;
    public UInt64[] CRCTable;

    public Crc64()
    {
            this.CRCTable = new ulong[256];
            for (int i = 0; i <= 255; i++)
            {
                int j;
                UInt64 part = (UInt64)i;
                for (j = 0; j < 8; j++)
                {
                    if ((part & 1) != 0)
                        part = (part >> 1) ^ POLYNOMIAL;
                    else
                        part >>= 1;
                }
                CRCTable[i] = part;
            }
    }
}

UPDATE: Kindly inform, is this implementation correct as per my question:

public static List<UInt64> generateCrcTable(UInt64 POLY)
{
    const ulong TOPBIT_MASK = 0x8000000000000000;
    const ulong LOWBIT_MASK = 0x0000000000000001;

    List<UInt64> list = new List<UInt64>();

    for (int i = 0; i <= 255; i++)
    {
        UInt64 part = (UInt64)(i);            // << 56;

        for (byte bit = 0; bit < 63; bit++)
        {
            if ((part & LOWBIT_MASK) != 0) // 0x8000000000000000) != 0) //1) != 0) // 0x8000000000000000) != 0)
            {
                part >>= 1;
                part ^= POLY;
            }
            else
            {
                part >>= 1;
                //currentValue |= 0x8000000000000000;
            }
        }

        part |= TOPBIT_MASK; // 0x8000000000000000;

        list.Add(part);
    }
    return list;
}

I don't know how to do it. Can you provide an example implementation? — Jain, Sep 11 '19 at 15:56
I think your code is wrong. See Sunshine website : http://www.sunshine2k.de/articles/coding/crc/understanding_crc.html. Youi shouldn't be looping 256 times for a 64 bit CRC. Loop only 63 times and then OR 0x80000000. — jdweng, Sep 11 '19 at 16:14
I have read the article you informed. There is no mention of Crc64 in the article. The code I have, loops for 256 times, because it processes all 256 bytes to create a checksum. I have no idea why you informed that it should loop only 63 times for 64 bits Crc, and then OR 0x80000000. Can you explain it? To let you know, I also need a C# example implementation to understand the information you informed. — Jain, Sep 11 '19 at 16:53
Look at link at section 6 : xtending to CRC-32. There are two for loops. The outside loop is for the number of bytes you are adding a CRC and the inner is the CRC algorithm. You are missing the equivalent of : crc ^= (uint)(b << 24); /* move byte into MSB of 32bit CRC */. — jdweng, Sep 11 '19 at 17:22
I have tried to implement the code as you answered. I have put it above on display. Please read it and see if it is correct. — Jain, Sep 11 '19 at 18:11

jdweng · Answer 1 · 2019-09-11T21:13:27.623

I got code to work. No table. crc2 is always zero. I run CRC twice. Once to create CRC then add CRC to original data. Then run again to validate.

if you only want 63 bits then change the shift from 56 to 55. Then use mask starting with 0x4 instead of 0x8. And then on the return AND with 0x7FFFFFFFFFFFFFFF

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Random rand = new Random();

            List<byte> data = Enumerable.Range(0, 1000).Select(x => (byte)rand.Next(0,256)).ToList();
            ulong crc = Crc64.ComputeCrc64(data);
            List<byte> results = new List<byte>();
            for (int i = 7; i >= 0; i--)
            {
                results.Add((byte)((crc >> (8 * i)) & 0xFF));
            }
            data.AddRange(results);

            ulong crc2 = Crc64.ComputeCrc64(data);
        }
    }
    public class Crc64
    {
        const ulong POLYNOMIAL = 0xD800000000000000;
        public static ulong ComputeCrc64(List<byte> data)
        {
            ulong crc = 0; /* CRC value is 64bit */
            foreach (byte b in data)
            {
                crc ^= (ulong)b << 56; /* move byte into MSB of 63bit CRC */
                for (int i = 0; i < 8; i++)
                {
                    if ((crc & 0x8000000000000000) != 0) /* test for MSB = bit 63 */
                    {
                        crc = (ulong)((crc << 1) ^ POLYNOMIAL);
                    }
                    else
                    {
                        crc <<= 1;
                    }
                }
            }
            return crc;
        }
    }
}

How to generate Crc-64 table having all negative integer Constants and checksum?

1 Answers1