CRC Calculator

Result

Width

32

Poly

0x04C11DB7

Init

0xFFFFFFFF

RefIn

true

RefOut

true

XorOut

0xFFFFFFFF

Check value: this model returns 0xCBF43926 for the string “123456789”, against a published 0xCBF43926 — match.

Model catalogue

Every model below is verified against its published check value in this site's test suite. Where two rows share a polynomial, the difference is the seed, the reflection or the final XOR - which is exactly why two libraries can both claim “CRC-16” and disagree.

How a CRC works

A CRC treats the message as the coefficients of a polynomial over GF(2) - the field with two elements, where addition and subtraction are both XOR. Divide that polynomial by a fixed generator and the remainder is the CRC. In hardware it is a shift register with XOR taps at the positions of the generator's set bits, which is why it costs almost nothing to compute inline with a serial stream.

The generator is what determines the error-detection strength. A well-chosen degree-32 polynomial catches every single-bit error, every double-bit error over practical frame lengths, every odd number of bit errors, and every burst of 32 bits or fewer. That last property is the point: real-world corruption on a wire or a flash cell tends to arrive in bursts, not as scattered independent flips.

The other five parameters are bookkeeping, but they are not optional. A non-zero seed means a run of leading zero bytes changes the result, so a truncated frame does not silently pass. Reflection matches the LSB-first order that serial hardware shifts bits in. The final XOR means an all-zero message does not produce an all-zero CRC. Get any one of them wrong and your value disagrees with everyone else's.

CRC is not a hash

A CRC is linear: CRC(a XOR b) is a simple function of CRC(a) and CRC(b). That makes it trivial to modify a message and patch its CRC back to the original value, so a CRC proves nothing about intent. It detects accidents, not adversaries. If the threat model includes someone deliberately editing the data, you want SHA-256 or an HMAC, not a checksum - reach for the hash generator instead.

The flip side is that a CRC is far cheaper. CRC-32C runs as a single x86 instruction, so filesystems and network stacks can checksum every block and every frame without a measurable cost.

Code Examples

import zlib

data = b"123456789"

print(hex(zlib.crc32(data)))  # 0xcbf43926 - CRC-32/ISO-HDLC

# Generic bit-by-bit model
def crc(data, width, poly, init, refin, refout, xorout):
    mask = (1 << width) - 1
    top = 1 << (width - 1)
    reg = init & mask
    for byte in data:
        if refin:
            byte = int(f"{byte:08b}"[::-1], 2)
        reg ^= byte << (width - 8)
        for _ in range(8):
            reg = ((reg << 1) ^ poly) & mask if reg & top else (reg << 1) & mask
    if refout:
        reg = int(f"{reg:0{width}b}"[::-1], 2)
    return (reg ^ xorout) & mask

print(hex(crc(data, 16, 0x8005, 0xFFFF, True, True, 0x0000)))  # 0x4b37 MODBUS

Frequently Asked Questions

Related Tools