CRC-32 / ISO-HDLCPKZip · PNG · Ethernet
The most common CRC-32 implementation, also called CRC-32b. It uses di reflected form of polynomial 0x04C11DB7, namely 0xEDB88320. Both input bytes and output na bit-reflected (LSB first), with initial value and final XOR both set to 0xFFFFFFFF.
Widely used by ZIP, gzip, PNG images, Ethernet frames (IEEE 802.3), PKCS#7, and many legacy systems. Dis na di de facto "default CRC-32" variant.
| Polynomial | 0x04C11DB7(normal) /0xEDB88320(reflected) |
| Initial Value | 0xFFFFFFFF |
| Input Reflection | Yes (RefIn = true) |
| Output Reflection | Yes (RefOut = true) |
| Final XOR | 0xFFFFFFFF |
| Check Value | 0xCBF43926(for "123456789") |
CRC-32C / CastagnoliiSCSI · NVMe · SCTP
Proposed by G. Castagnoli and colleagues in 1993, dis variant uses polynomial 0x1EDC6F41 (reflected form 0x82F63B78). At di same Hamming distance, it offers stronger burst-error detection than di ISO-HDLC polynomial.
Hardware acceleration na available through Intel SSE4.2 and ARM CRC32 instructions. It na widely used in modern storage and transport protocols such as iSCSI, NVMe, Btrfs, and SCTP.
| Polynomial | 0x1EDC6F41(normal) /0x82F63B78(reflected) |
| Initial Value | 0xFFFFFFFF |
| Input Reflection | Yes (RefIn = true) |
| Output Reflection | Yes (RefOut = true) |
| Final XOR | 0xFFFFFFFF |
| Check Value | 0xE3069283(for "123456789") |
CRC-32 / MPEG-2MPEG-2 · DVB · ATSC
Uses di same 0x04C11DB7 polynomial as ISO-HDLC, but neither input nor output nabit-reflected(MSB first, big-endian). Di initial value na 0xFFFFFFFF and di final XOR na disabled (XorOut = 0x00000000).
Mainly used for PSI/SI tables in MPEG-2 transport streams (PAT, PMT, NIT, and related tables), plus integrity checks in DVB and ATSC broadcast systems.
| Polynomial | 0x04C11DB7 |
| Initial Value | 0xFFFFFFFF |
| Input Reflection | No (RefIn = false) |
| Output Reflection | No (RefOut = false) |
| Final XOR | 0x00000000(disabled) |
| Check Value | 0x0376E6E7(for "123456789") |
CRC-32 / BZIP2BZip2 · AAL5 · DECT
Its parameters na almost identical to MPEG-2 (polynomial 0x04C11DB7, no reflection, initial value 0xFFFFFFFF). Di only difference na afinal XOR with 0xFFFFFFFF, which flips every bit. It na also known as CRC-32/AAL5 or CRC-32/DECT-B.
Used by di BZip2 compressed file format and di trailer checksum field of di ATM AAL5 protocol.
| Polynomial | 0x04C11DB7 |
| Initial Value | 0xFFFFFFFF |
| Input Reflection | No (RefIn = false) |
| Output Reflection | No (RefOut = false) |
| Final XOR | 0xFFFFFFFF |
| Check Value | 0xFC891918(for "123456789") |
UTF-8 TextDefault · General
Treats di input as aUTF-8string, converts it to bytes, and then calculates CRC32. Dis na di most common mode for plain text, source code, JSON, and similar content.
Note: di same text encoded with a different character set such as GBK or UTF-16 produces a different byte stream and therefore a different CRC32 value. Dis tool always uses UTF-8.
| Best For | Plain text, source code, JSON, XML |
| Example | "Hello" →48 65 6C 6C 6F(5 bytes) |
| CJK Characters | Most CJK characters use 3 bytes in UTF-8 |
HexadecimalBinary Data · Protocol Frames
Treats di input as rawhexadecimal byte literals. Spaces and line breaks na ignored. Every two hex characters become one byte (00–FF).
Useful when you need CRC checks for exact binary data such as network frames, firmware image fragments, or memory dumps. You fit paste Wireshark or hex dump output directly.
| Format | Only0-9anda-f / A-Fna allowed |
| Character Count | Must be even (2 characters per byte) |
| Example | 48656C6C6F= "Hello" (5 bytes) |
| Whitespace | Ignored automatically.48 65 6Cna di same as48656C |
Base64Encoded Binary · Certificates · Images
Treats di input as aBase64-encoded string, decodes it into raw bytes, and then calculates CRC32. Useful for PEM certificates, JWT payloads, Data URIs, and other Base64 content.
E support di standard Base64 alphabet (A-Z a-z 0-9 + /). Di padding character=na optional. URL-safe Base64 (-_) na not supported.
| Alphabet | A-Z a-z 0-9 + / = |
| Example | SGVsbG8=→ "Hello" (5 bytes) |
| URL-safe | Not supported. Replace-→+and_→/first |
| ⚠ 1 Character | Invalid — 6 bits na not enough to form 1 byte (8 bits required) |
| 2 Characters | Decodes to1 byte(minimum valid input) |
| 3 Characters | Decodes to2 bytes |
| 4 Characters | Decodes to3 bytes(the pattern repeats every 4 characters) |
HexadecimalMost Common · Default
E show di value as an 8-digit uppercase hexadecimal number prefixed with0x. Each character represents 4 bits, for a total of 32 bits. Dis na di standard format used in most tools, source code, and documentation.
Compared with decimal output, hexadecimal makes byte boundaries easier to inspect and matches memory dumps and protocol fields more naturally.
| Example | 0xCBF43926 |
| Length | 8 hexadecimal characters = 32 bits |
| Base | Base 16 (0-9, A-F) |
| Best For | Code, documentation, Wireshark, hex editors |
DecimalUnsigned 32-bit Integer
E show di checksum as anunsigned 32-bit decimal integerin di range 0–4,294,967,295 (2³²−1). Some languages and tools compare CRC values in decimal form, and database fields often store dis representation.
Note: CRC32 results suppose be treated as unsigned integers. In signed int types such as Java or C#, values above 0x7FFFFFFF may appear negative and suppose be converted to uint or a wider unsigned representation.
| Example | 3421780262 |
| Range | 0–4,294,967,295 |
| Note | For Java int, convert with& 0xFFFFFFFFL |
| Best For | Databases, Python struct values, numeric comparison |
BinaryBit-Level Analysis
E show di checksum as a 32-bit binary string prefixed with0b. Each character na 0 or 1, aligned with di most significant bit on di left, and padded with leading zeroes when necessary.
Mainly useful for understanding di internal CRC algorithm, studying polynomial division, teaching, and embedded scenarios dat need bit-level checksum processing.
| Example | 0b11001011…00100110 |
| Length | Fixed at 32 bits with left zero padding |
| Highest Bit | Bit 31 (MSB) appears on di far left |
| Best For | Algorithm analysis, teaching, embedded debugging |
OctalUnix · File Systems
E show di checksum as an 11-digit octal number prefixed with0o. At most 11 octal characters na needed for 32 bits because 3×11 = 33 > 32. Each octal digit represents 3 bits.
Octal output na uncommon in modern CRC workflows, but it still appears in some Unix tools, embedded firmware toolchains, and older communication protocol specifications.
| Example | 0o31572031046 |
| Length | Up to 11 octal digits |
| Per Digit | Represents 3 bits (0-7) |
| Best For | Unix tools, older protocol specifications |