In need of CRC64 or better algorithm

Hi,

Isn't this a base64 encoding instead of a CRC computation? I need a standard crc64 code, preferably with a #define for the polynomial so that I can generate a CRC64 to crosscheck with database records.

The database includes a CRC32 field, and my job is to change that to a better CRC. This is why I need this CRC to be standard.

Thanks.

#include <stdio.h>
typedef unsigned int hint_t; /* we want a 32 bit unsigned integer here */
typedef struct hash_t {
 hint_t h1; hint_t h2;
} hash_t;
#define TESTHSIZE (4 * 1024 * 1024)
#define TESTHMASK (TESTHSIZE - 1)
void inithash(void);
hash_t testhash(const char *p);
int UniqueOpt;
int HashLimit = 64;
int VerboseOpt = 0;
 int QuietOpt = 0;
void *rmalloc(int bytes);
int main(int ac, char **av){
    char buf[256];
    inithash();
    while ( fgets(buf, sizeof(buf), stdin) != NULL ) {
        hash_t hv;
        hv = testhash(buf);
        printf("%08x.%08x %s", hv.h1, hv.h2, buf);
    }
    return(0);
}
/* * Poly: 0x00600340.00F0D50A * */
#define HINIT1 0xFAC432B1UL
#define HINIT2 0x0CD5E44AUL
#define POLY1 0x00600340UL
#define POLY2 0x00F0D50BUL
hash_t CrcXor[256];
hash_t Poly;
void inithash(void) {
    int i;
    Poly.h1 = POLY1;
    Poly.h2 = POLY2;
    for (i = 0; i < 256; ++i) {
        int j;
        int v = i;
        hash_t hv = { 0, 0 };
        for (j = 0; j < 8; ++j, (v <<= 1)) {
            hv.h1 <<= 1;
            if (hv.h2 & 0x80000000UL) hv.h1 |= 1;
            hv.h2 = (hv.h2 << 1);
            if (v & 0x80) {
                hv.h1 ^= Poly.h1;
                hv.h2 ^= Poly.h2;
            }
        }
        CrcXor[i] = hv;
    }
}

/*
 * testhash() - do the CRC. We extract the top 8 bits to
 * use as a table lookup to obtain the polynomial XOR 8 bits at
 * a time rather then 1 bit at a time.
 */
hash_t testhash(const char *p) {
    hash_t hv = { HINIT1, HINIT2 };
    int s = HashLimit - 40;
    hint_t m = (hint_t)-1 >> (64 - HashLimit);
    hv.h1 &= m;
    while (*p) {
        int i = (hv.h1 >> s) & 255;
        hv.h1= ((hv.h1 << 8) & m) ^ (int)(hv.h2 >> 24) ^ CrcXor[i].h1;
        hv.h2 = (hv.h2 << 8) ^ *p ^ CrcXor[i].h2;
        ++p;
     }
    /* printf("%08lx.%08lx\n", (long)hv.h1, (long)hv.h2); */
    return(hv);
}

The above is the trimmed down code from Math Dillon's "crc tester".

The above code simply takes Dillon's source, and removes the support for CRC with less than 64 bits. IE: This is why "VerboseOpt" is defined but not used. The functions were trimmed down.

Sorry...

What do you need that's not in Math Dillon's "crc tester"?

I was told that the Dillon's function was an "hash" function, and I had to find a standard CRC.

I don't know enough about hasing and CRC to know what this means. This is why I'm looking for another one.

--Eric

Wow, this is exactly what I needed! Better late than never, thanks!

Can I bother you with another question? What is the difference between a block cypher and a hash algorithm?

I have no clue as to what cypher means, and what hash do.

Thanks.

A block cipher: A cipher algorithm that encrypts data in discrete units (called blocks), rather than as a continuous stream of bits.
Hash: A fixed-size result obtained by applying a mathematical function (the hashing algorithm) to an arbitrary amount of data.

A block cipher can be decrypted with the right key/password.
A hash is a one-way function.

There are many cryptography tutorials on the web.
See http://www.hack.gr/users/dij/crypto/overview/    
and http://www.securitypointer.com/encryption.htm