About

CRC-64 is a cyclic redundancy check that produces a 64-bit digest from arbitrary input data. It detects burst errors up to 64 bits in length and is used in storage formats (xz, HDFS), database systems (Redis), and tape archive standards (ECMA-182). Unlike cryptographic hashes, CRC-64 is designed for speed and error detection, not collision resistance. A single flipped bit in multi-terabyte backup archives can silently corrupt data; CRC-64 catches that corruption where shorter CRC-16 or CRC-32 checksums statistically miss it. This tool computes CRC-64 using a table-driven algorithm over a generator polynomial G(x) of degree 64 in GF(2). Results are approximate to the chosen polynomial standard. Different polynomials yield different checksums for identical input.

Five polynomial variants are supported: ECMA-182, ISO 3309, XZ (as used in LZMA/7z), Jones (used in several database engines), and WE. Each has different initial values and post-processing (final XOR). Note: this tool processes data as a byte stream. For text, UTF-8 encoding is applied before computation. File checksums match command-line tools only when the same polynomial and parameters are used.

Formulas

The CRC-64 algorithm treats input data as a polynomial in GF(2) and computes the remainder after division by a generator polynomial G(x) of degree 64. The table-driven method precomputes 256 remainder values for all possible single-byte inputs.

CRC = M(x) ⋅ x⁶⁴ mod G(x)

For each byte b_i of input, the running CRC register R is updated:

idx = (R >> 56) &xor; b_i

R = (R << 8) &xor; T[idx]

For reflected variants, input bits and the final register are bit-reversed. The lookup uses the low byte instead:

idx = (R ∧ 0xFF) &xor; b_i

R = (R >> 8) &xor; T[idx]

Where T is the precomputed 256-entry lookup table, R is the 64-bit CRC register initialized to Init, and the final result is R &xor; FinalXOR. All arithmetic is performed in GF(2) using BigInt to handle 64-bit unsigned values natively.

Reference Data

Variant	Polynomial (Hex)	Init Value	Final XOR	Reflect In	Reflect Out	Usage
CRC-64-ECMA-182	0x42F0E1EBA9EA3693	0x0000000000000000	0x0000000000000000	No	No	ECMA-182 standard, DLT tapes
CRC-64-ISO	0x000000000000001B	0xFFFFFFFFFFFFFFFF	0xFFFFFFFFFFFFFFFF	Yes	Yes	ISO 3309, HDLC
CRC-64-XZ	0x42F0E1EBA9EA3693	0xFFFFFFFFFFFFFFFF	0xFFFFFFFFFFFFFFFF	Yes	Yes	xz utils, 7-Zip, LZMA SDK
CRC-64-Jones	0xAD93D23594C935A9	0xFFFFFFFFFFFFFFFF	0x0000000000000000	Yes	Yes	Redis, various DB engines
CRC-64-WE	0x42F0E1EBA9EA3693	0xFFFFFFFFFFFFFFFF	0xFFFFFFFFFFFFFFFF	No	No	Wolfgang Ehrhardt variant
CRC-32	0x04C11DB7	0xFFFFFFFF	0xFFFFFFFF	Yes	Yes	Ethernet, ZIP, PNG (32-bit only)
CRC-16-CCITT	0x1021	0xFFFF	0x0000	No	No	X.25, Bluetooth, SD cards
Reference: CRC width vs. error detection capability
CRC Width	Max Burst Detection		Hamming Distance		Typical Data Sizes
16 bits	16-bit bursts		HD = 4 up to ~32 KB		Packets, frames
32 bits	32-bit bursts		HD = 6 up to ~12 KB		Files, archives
64 bits	64-bit bursts		HD = 6 up to ~4 GB		Large archives, databases
Known test vectors: ASCII string "123456789"
CRC-64-ECMA-182	0x6C40DF5F0B497347
CRC-64-XZ	0x995DC9BBDF1939FA
CRC-64-ISO	0xB90956C775A41001
CRC-64-Jones	0xE9C6D914C4B8D9CA
CRC-64-WE	0x62EC59E3F1A4F00A

Frequently Asked Questions

Each variant uses a different generator polynomial, initial register value, final XOR mask, and reflection settings. For example, CRC-64-ECMA-182 uses polynomial 0x42F0E1EBA9EA3693 with zero initialization and no reflection, while CRC-64-XZ uses the same polynomial but initializes to 0xFFFFFFFFFFFFFFFF with input/output reflection. These parameter differences produce entirely different remainder values even for identical data.

No. CRC-64 is a linear function in GF(2). An attacker can compute collisions in O(64) operations by solving a system of linear equations. It provides no preimage resistance. Use SHA-256 or BLAKE3 for cryptographic purposes. CRC-64 is strictly an error-detection code optimized for speed, not security.

CRC-32 guarantees detection of all burst errors up to 32 bits and maintains Hamming distance HD = 6 for messages up to approximately 12 KB. CRC-64 extends burst detection to 64 bits and maintains HD = 6 for messages up to approximately 4 GB. For datasets exceeding a few gigabytes, CRC-64 provides a significantly lower probability of undetected errors: roughly 2⁻⁶⁴ versus 2⁻³².

Reflection reverses the bit order within each byte (Reflect In) or the entire final CRC register (Reflect Out). Hardware UART lines transmit LSB first, so reflected CRC variants match the natural bit ordering of serial data. Non-reflected variants assume MSB-first processing, typical of network protocols. Using the wrong reflection setting produces an incorrect checksum.

Use the test vector string "123456789" (ASCII bytes 0x31 through 0x39). CRC-64-XZ should produce 0x995DC9BBDF1939FA. CRC-64-ECMA-182 should produce 0x6C40DF5F0B497347. If your command-line tool reports a different value, check whether it uses a different polynomial or reflection setting. The reference table in this tool lists known test vectors for all five supported variants.

Yes. CRC operates on raw bytes. The same string "café" encoded in UTF-8 is 5 bytes (0x63 0x61 0x66 0xC3 0xA9) but in ISO-8859-1 is 4 bytes (0x63 0x61 0x66 0xE9). This tool encodes text input as UTF-8 before computing CRC. File mode reads raw bytes without encoding conversion, matching the behavior of standard command-line checksum utilities.