Skip to content

Kalkulator Checksum CRC

Tempel data hex atau teks dan dapatkan 63 varian CRC-8, CRC-16, dan CRC-32 sekaligus. Punya checksum yang tidak bisa dicocokkan? Masukkan nilainya dan alat ini menyebut nama variannya — MODBUS, CCITT-FALSE, XMODEM, KERMIT.

Tanpa Pelacakan Berjalan di Browser Gratis
Semuanya dihitung secara lokal di browser Anda — data yang Anda tempel tidak pernah meninggalkan perangkat ini.
Coba ini

Semua 63 varian

Setiap baris dihitung ulang saat Anda mengetik.
Varian Hasil Poly Init RefIn/RefOut XorOut
CRC-8
CRC-8/AUTOSAR 0x2F 0xFF false / false 0xFF
CRC-8/BLUETOOTH 0xA7 0x00 true / true 0x00
CRC-8/CDMA2000 0x9B 0xFF false / false 0x00
CRC-8/DARC 0x39 0x00 true / true 0x00
CRC-8/DVB-S2 0xD5 0x00 false / false 0x00
CRC-8/GSM-A 0x1D 0x00 false / false 0x00
CRC-8/GSM-B 0x49 0x00 false / false 0xFF
CRC-8/HITAG 0x1D 0xFF false / false 0x00
CRC-8/I-432-1 CRC-8/ITU 0x07 0x00 false / false 0x55
CRC-8/I-CODE 0x1D 0xFD false / false 0x00
CRC-8/LTE 0x9B 0x00 false / false 0x00
CRC-8/MAXIM-DOW CRC-8/MAXIM · DOW-CRC 0x31 0x00 true / true 0x00
CRC-8/MIFARE-MAD 0x1D 0xC7 false / false 0x00
CRC-8/NRSC-5 0x31 0xFF false / false 0x00
CRC-8/OPENSAFETY 0x2F 0x00 false / false 0x00
CRC-8/ROHC 0x07 0xFF true / true 0x00
CRC-8/SAE-J1850 CRC-8/J1850 0x1D 0xFF false / false 0xFF
CRC-8/SMBUS CRC-8 0x07 0x00 false / false 0x00
CRC-8/TECH-3250 CRC-8/AES · CRC-8/EBU 0x1D 0xFF true / true 0x00
CRC-8/WCDMA 0x9B 0x00 true / true 0x00
CRC-16
CRC-16/ARC CRC-16 · CRC-16/IBM · CRC-16/LHA 0x8005 0x0000 true / true 0x0000
CRC-16/CDMA2000 0xC867 0xFFFF false / false 0x0000
CRC-16/CMS 0x8005 0xFFFF false / false 0x0000
CRC-16/DDS-110 0x8005 0x800D false / false 0x0000
CRC-16/DECT-R R-CRC-16 0x0589 0x0000 false / false 0x0001
CRC-16/DECT-X X-CRC-16 0x0589 0x0000 false / false 0x0000
CRC-16/DNP 0x3D65 0x0000 true / true 0xFFFF
CRC-16/EN-13757 0x3D65 0x0000 false / false 0xFFFF
CRC-16/GENIBUS CRC-16/DARC · CRC-16/EPC · CRC-16/EPC-C1G2 · CRC-16/I-CODE 0x1021 0xFFFF false / false 0xFFFF
CRC-16/GSM 0x1021 0x0000 false / false 0xFFFF
CRC-16/IBM-3740 CRC-16/CCITT-FALSE · CRC-16/AUTOSAR 0x1021 0xFFFF false / false 0x0000
CRC-16/IBM-SDLC CRC-16/X-25 · CRC-16/X25 · CRC-16/ISO-HDLC · CRC-B · X-25 0x1021 0xFFFF true / true 0xFFFF
CRC-16/ISO-IEC-14443-3-A CRC-A 0x1021 0xC6C6 true / true 0x0000
CRC-16/KERMIT CRC-16/CCITT · CRC-16/CCITT-TRUE · CRC-16/V-41-LSB · CRC-CCITT 0x1021 0x0000 true / true 0x0000
CRC-16/LJ1200 0x6F63 0x0000 false / false 0x0000
CRC-16/M17 0x5935 0xFFFF false / false 0x0000
CRC-16/MAXIM-DOW CRC-16/MAXIM 0x8005 0x0000 true / true 0xFFFF
CRC-16/MCRF4XX 0x1021 0xFFFF true / true 0x0000
CRC-16/MODBUS 0x8005 0xFFFF true / true 0x0000
CRC-16/NRSC-5 0x080B 0xFFFF true / true 0x0000
CRC-16/OPENSAFETY-A 0x5935 0x0000 false / false 0x0000
CRC-16/OPENSAFETY-B 0x755B 0x0000 false / false 0x0000
CRC-16/PROFIBUS CRC-16/IEC-61158-2 0x1DCF 0xFFFF false / false 0xFFFF
CRC-16/RIELLO 0x1021 0xB2AA true / true 0x0000
CRC-16/SPI-FUJITSU CRC-16/AUG-CCITT 0x1021 0x1D0F false / false 0x0000
CRC-16/T10-DIF 0x8BB7 0x0000 false / false 0x0000
CRC-16/TELEDISK 0xA097 0x0000 false / false 0x0000
CRC-16/TMS37157 0x1021 0x89EC true / true 0x0000
CRC-16/UMTS CRC-16/BUYPASS · CRC-16/VERIFONE 0x8005 0x0000 false / false 0x0000
CRC-16/USB 0x8005 0xFFFF true / true 0xFFFF
CRC-16/XMODEM CRC-16/ACORN · CRC-16/LTE · CRC-16/V-41-MSB · ZMODEM 0x1021 0x0000 false / false 0x0000
CRC-32
CRC-32/AIXM CRC-32Q 0x814141AB 0x00000000 false / false 0x00000000
CRC-32/AUTOSAR 0xF4ACFB13 0xFFFFFFFF true / true 0xFFFFFFFF
CRC-32/BASE91-D CRC-32D 0xA833982B 0xFFFFFFFF true / true 0xFFFFFFFF
CRC-32/BZIP2 CRC-32/AAL5 · CRC-32/DECT-B · B-CRC-32 0x04C11DB7 0xFFFFFFFF false / false 0xFFFFFFFF
CRC-32/CD-ROM-EDC 0x8001801B 0x00000000 true / true 0x00000000
CRC-32/CKSUM CRC-32/POSIX 0x04C11DB7 0x00000000 false / false 0xFFFFFFFF
CRC-32/ISCSI CRC-32C · CRC-32/BASE91-C · CRC-32/CASTAGNOLI · CRC-32/INTERLAKEN 0x1EDC6F41 0xFFFFFFFF true / true 0xFFFFFFFF
CRC-32/ISO-HDLC CRC-32 · CRC-32/ADCCP · CRC-32/V-42 · CRC-32/XZ · PKZIP 0x04C11DB7 0xFFFFFFFF true / true 0xFFFFFFFF
CRC-32/JAMCRC 0x04C11DB7 0xFFFFFFFF true / true 0x00000000
CRC-32/MEF 0x741B8CD7 0xFFFFFFFF true / true 0x00000000
CRC-32/MPEG-2 0x04C11DB7 0xFFFFFFFF false / false 0x00000000
CRC-32/XFER 0x000000AF 0x00000000 false / false 0x00000000
Parameter kustom

Pakai ini kalau dokumentasi perangkat Anda menyebut polinomial yang tidak ada di tabel di atas.

Hasil
Seluruh 63 set parameter varian diuji terhadap nilai check katalog yang diterbitkan di dalam test suite, dan CRC-32/ISO-HDLC diperiksa silang terhadap zlib.crc32 bawaan Node sebagai oracle independen. — Tim Go Tools · Sep 6, 2026

Dibangun dan diverifikasi oleh tim engineering Go Tools.

Jawaban singkat

CRC-32 dari "123456789"

0xCBF43926 0xCBF43926 untuk CRC-32/ISO-HDLC, varian yang dipakai ZIP, PNG, Ethernet, dan gzip.

CRC-16/MODBUS dari "123456789"

0x4B37 0x4B37, dengan poly 0x8005, init 0xFFFF, input dan output direfleksikan, tanpa XOR akhir.

CRC-16/CCITT-FALSE dari "123456789"

0x29B1 0x29B1. Nama formalnya di katalog adalah CRC-16/IBM-3740: poly 0x1021, init 0xFFFF, tanpa refleksi.

Ada berapa varian CRC?

63 Kalkulator ini mencakup 63 varian terkatalog: 20 berlebar 8, 31 berlebar 16, dan 12 berlebar 32.

Apa itu CRC?

Cyclic redundancy check memperlakukan satu blok data sebagai koefisien dari sebuah polinomial biner yang sangat panjang, membaginya dengan polinomial generator tetap memakai aritmetika modulo-2, lalu menyimpan sisanya. Sisa pembagian itulah checksum-nya. Konstruksi ini populer karena pembagiannya bisa direduksi menjadi operasi geser dan XOR, yang biayanya nyaris nol di hardware, dan karena aljabarnya memberi jaminan yang keras alih-alih harapan statistik: polinomial 16-bit yang dipilih dengan baik mendeteksi setiap error satu bit, setiap error dua bit dalam panjang blok yang wajar, setiap jumlah pembalikan bit yang ganjil, dan setiap burst sepanjang 16 bit berurutan atau kurang.

Yang membuat CRC membingungkan dalam praktik adalah kenyataan bahwa polinomial hanyalah satu dari enam parameter. Dua implementasi bisa sepakat soal polinomial dan tetap berbeda di setiap hasilnya, karena keduanya berbeda pada nilai awal register, pada apakah byte input dan register output dibalik urutan bit-nya, dan pada konstanta yang di-XOR-kan ke nilai akhir. Sebuah varian CRC adalah keseluruhan set parameter itu, bukan polinomialnya saja — itulah sebabnya nama seperti "CRC-16" praktis tidak mengidentifikasi apa pun kalau berdiri sendiri, dan itulah alasan halaman ini menampilkan polinomial, nilai awal, kedua flag refleksi, dan XOR akhir di sebelah setiap hasil, dengan lebar bit sebagai judul kelompoknya.

Satu hal yang tidak bisa ditampilkan tabel: polinomial 16-bit hanya mendeteksi setiap jumlah pembalikan bit yang ganjil kalau x+1 membagi habis polinomial itu. Itu berlaku untuk dua yang paling mungkin Anda temui, 0x1021 dan 0x8005, tapi tidak untuk semuanya — CRC-16/T10-DIF dan CRC-16/PROFIBUS termasuk pengecualiannya.

// CRC-16/MODBUS: poly=0x8005, init=0xFFFF, refin/refout=true, xorout=0x0000
// Written in the reflected form, so the polynomial appears bit-reversed as 0xA001.
function crc16Modbus(bytes) {
  let crc = 0xffff;
  for (const byte of bytes) {
    crc ^= byte;
    for (let i = 0; i < 8; i++) {
      crc = crc & 1 ? (crc >>> 1) ^ 0xa001 : crc >>> 1;
    }
  }
  return crc;
}

crc16Modbus([0x01, 0x03, 0x00, 0x00, 0x00, 0x0a]); // 0xCDC5
// On the wire Modbus RTU sends the low byte first: ... 0x0A 0xC5 0xCD

Apa yang dilakukan kalkulator ini

63 varian sekaligus

CRC-8, CRC-16, dan CRC-32 dihitung ulang bersamaan saat Anda mengetik. Tidak ada dropdown yang harus ditebak dulu sebelum Anda bisa melihat apa pun.

Pencarian balik

Ketik checksum yang Anda terima dan varian yang menghasilkannya akan disorot, sehingga mengidentifikasi algoritma yang tidak dikenal cukup satu langkah, bukan dua puluh.

Nama formal dan nama di manual

Setiap baris menampilkan nama katalog RevEng plus alias yang dipakai di lapangan — CCITT-FALSE, CRC-16/IBM, CRC-32C, X-25, dan seterusnya.

Tabel parameter lengkap

Polinomial, nilai awal, kedua flag refleksi, dan XOR akhir berjajar di samping setiap hasil, jadi Anda bisa memverifikasi kecocokan terhadap spesifikasi.

Parameter kustom

Lebar, polinomial, init, refleksi, dan XOR akhir semuanya bisa diubah untuk polinomial yang tidak pernah masuk katalog mana pun.

Berjalan sepenuhnya offline

Perhitungan terjadi di browser Anda. Frame produksi dan image firmware tidak pernah meninggalkan mesin Anda.

Contoh terhitung

Nilai check standar dari katalog

123456789
CRC-32/ISO-HDLC = 0xCBF43926, CRC-16/MODBUS = 0x4B37, CRC-8/SMBUS = 0xF4

Setiap varian CRC di katalog RevEng menerbitkan hasilnya untuk string ASCII 123456789. Itu yang membuat input ini jadi self-test baku: kalau sebuah library tidak sepakat dengan tabel di sini, library itulah yang salah.

Satu frame permintaan Modbus RTU

01 03 00 00 00 0A
CRC-16/MODBUS = 0xCDC5

Membaca holding register dari slave 1. Modbus RTU menaruh byte rendah CRC lebih dulu, jadi di jalur transmisi frame ini menjadi 01 03 00 00 00 0A C5 CD — pembalikan urutan yang menjelaskan sebagian besar kasus checksum yang tidak mau cocok.

Byte yang sama, empat jawaban CRC-16

DEADBEEF
MODBUS = 0xC19B, CCITT-FALSE = 0x4097, XMODEM = 0xC457, KERMIT = 0x1915

Dibaca dalam mode Hex, jadi empat byte, bukan delapan karakter string-nya. Empat varian CRC-16 paling terkenal sama sekali tidak sepakat soal keempat byte itu. Tidak ada yang rusak: bedanya ada di nilai awal, refleksi, dan XOR akhir, bukan di benar atau salah.

Pencarian balik dari respons perangkat

123456789 dengan nilai ekspektasi 0x29B1
CRC-16/IBM-3740 (manual perangkat Anda mungkin menyebutnya CRC-16/CCITT-FALSE)

Inilah kasus yang jadi alasan kalkulator ini dibuat. Anda punya datanya dan punya checksum yang dihitung orang lain, tapi tidak tahu nama variannya — jadi Anda cari set parameter yang bisa mereproduksi nilai itu.

Cara memakai kalkulator CRC

  1. 1

    Pilih teks atau hex

    Frame protokol hampir selalu hex. Pakai mode teks hanya kalau Anda menghitung checksum sebuah string harfiah, misalnya nilai self-test 123456789.

  2. 2

    Tempel data Anda

    Di mode hex pemisah diabaikan, jadi 01 03 00 00 00 0A, 0x01 0x03, dan 010300 00000A sama-sama diterima.

  3. 3

    Baca varian yang Anda perlukan

    Tabelnya dikelompokkan menurut lebar. Nama formal diambil dari katalog RevEng, dengan alias yang kemungkinan dipakai manual perangkat Anda tercetak di bawahnya.

  4. 4

    Atau kerjakan dari arah sebaliknya

    Kalau Anda sudah punya checksum dan ingin tahu variannya, ketik nilai itu di kotak nilai ekspektasi lalu baca baris yang disorot.

Kenapa checksum Anda tidak cocok

Menghitung checksum teks "01 03", bukan byte-nya

Kalau dibiarkan di mode teks, kalkulator menghitung karakter ASCII dari hex dump Anda, bukan byte yang diwakilinya. Ganti ke mode Hex — jumlah byte di bawah pemilih mode memberi tahu pembacaan mana yang sedang berlaku.

✗ Salah
Text mode, input "01 03" -> 5 bytes: 30 31 20 30 33
✓ Benar
Hex mode, input "01 03" -> 2 bytes: 01 03

Membandingkan dengan checksum yang tertukar urutan byte-nya

Modbus RTU mengirim byte rendah CRC lebih dulu. Frame yang berakhir dengan C5 CD membawa checksum 0xCDC5, bukan 0xC5CD.

✗ Salah
expected 0xC5CD  (bytes read in transmission order)
✓ Benar
expected 0xCDC5  (bytes reassembled low-byte-first)

Ikut menghitung field checksum ke dalam perhitungannya sendiri

CRC mencakup byte-byte sebelum dirinya. Memasukkan kembali seluruh frame beserta trailer-nya menghasilkan residu, bukan checksum.

✗ Salah
01 03 00 00 00 0A C5 CD    <- trailer included
✓ Benar
01 03 00 00 00 0A          <- payload only

Mengira "CRC-16" sudah menentukan sebuah algoritma

Ada 31 varian terkatalog yang lebarnya 16 bit. Tanpa lima parameter lainnya, nama itu tidak mempersempit apa pun.

✗ Salah
spec says: "trailer is a CRC-16"
✓ Benar
spec says: "CRC-16/MODBUS, poly 0x8005, init 0xFFFF, refin/refout true"

Kapan Anda membutuhkannya

Menelusuri masalah jalur Modbus
Sebuah PLC menolak frame Anda dan Anda perlu tahu apakah CRC-nya salah atau sekadar tertukar urutan byte-nya. Hitung CRC-16/MODBUS lalu bandingkan kedua urutannya.
Mengidentifikasi protokol tanpa dokumentasi
Anda menangkap trafik dengan trailer dua byte yang tampak seperti checksum. Berikan payload dan trailer itu ke pencarian balik, lalu lihat varian mana yang mengakuinya.
Memindahkan firmware antar toolchain
Library dari vendor dan implementasi Anda sendiri tidak sepakat. Membandingkan keduanya terhadap nilai check katalog menunjukkan mana yang melenceng.
Menulis atau mereview spesifikasi
Menyebut "CRC-16" di dokumen protokol sama saja memesan bug interoperabilitas. Tabel parameter memberi Anda enam nilai yang benar-benar mengunci algoritmanya.
Memverifikasi data tersimpan
Filesystem, format arsip, dan image flash membawa field CRC-32. Menghitung ulang salah satunya memberi tahu Anda apakah sebuah blok masih utuh.

Cara kerja CRC

Representasi polinomial
Tabel ini mencetak polinomial dalam bentuk normal (MSB dulu): 0x8005 berarti x^16 + x^15 + x^2 + 1. Implementasi yang direfleksikan sering menuliskan polinomial yang sama sebagai 0xA001, dan notasi Koopman menggesernya dengan cara lain lagi. Tiga notasi untuk satu polinomial adalah sumber kegagalan porting yang umum.
Nilai awal
Memulai register dari 0xFFFF alih-alih 0x0000 membuat checksum peka terhadap byte nol di awal data. Dengan init nol, menambahkan nol di depan pesan tidak mengubah CRC sama sekali — dan justru kerusakan seperti itulah yang harus ditangkap protokol berbasis frame.
Refleksi
refin membalik bit di dalam setiap byte input, refout membalik register akhir. Hardware menggeser bit dengan MSB dulu sementara software berbasis byte merasa LSB dulu lebih murah, dan bentuk parameter yang direfleksikan mendamaikan keduanya.
XOR akhir
xorout diterapkan paling akhir, dan ia bukan sekadar init yang dipindah ke ujung yang lain. Byte nol yang ditambahkan di belakang pesan tetap terdeteksi pada kedua kasus. Yang diubah oleh xorout bukan-nol adalah residu yang didapat penerima ketika ia menjalankan CRC atas pesan dan checksum sekaligus: dengan xorout nol residu itu sendiri bernilai nol, sehingga nol yang ditambahkan setelah field CRC tetap lolos. Ia juga membuat pesan berisi nol semua menghasilkan checksum bukan-nol.
Nilai check
Setiap varian yang terkatalog menerbitkan hasilnya untuk string ASCII 123456789. Ke-63 nilai yang ditampilkan halaman ini ketika input tersebut dimuat persis sama dengan konstanta yang diterbitkan itu, dan begitulah engine di halaman ini diuji.

Supaya hasilnya cocok

Sebut parameternya, bukan nama algoritmanya
Tulis "poly 0x1021, init 0xFFFF, refin false, refout false, xorout 0x0000" di spesifikasi. "CRC-16/CCITT" sudah pernah berarti setidaknya tiga hal yang berbeda.
Periksa urutan byte secara terpisah
Kalau sebuah checksum hanya kurang satu kali tukar byte untuk cocok, algoritmanya sudah benar dan yang salah adalah framing-nya. Perlakukan keduanya sebagai dua bug yang berbeda.
Validasi dengan nilai check lebih dulu
Sebelum menelusuri data Anda, pastikan implementasi Anda mengembalikan nilai katalog untuk 123456789. Dalam hitungan detik itu memisahkan algoritma yang rusak dari input yang salah.
Tegaskan byte mana saja yang dicakup
Sebagian besar ketidakcocokan berasal dari marker awal, alamat, atau field panjang yang ikut dihitung atau justru terlewat. Tentukan persis byte mana yang dicakup CRC, lalu tuliskan.
Jangan pakai CRC di tempat yang butuh MAC
CRC bersifat linier dan sepele untuk dipalsukan. Kalau ada kemungkinan penyerang mengubah datanya, pakai HMAC saja.

Pertanyaan yang sering diajukan

Kenapa CRC dari perangkat saya berbeda dengan hasil kalkulator ini?
Hampir selalu karena Anda sedang membandingkan dua varian yang berbeda. CRC-16 saja punya 31 set parameter yang terkatalog, dan MODBUS, CCITT-FALSE, XMODEM, serta KERMIT menghasilkan empat angka yang tidak berhubungan dari byte yang identik. Masukkan nilai dari perangkat ke kotak nilai ekspektasi: kalau ada varian yang mereproduksinya, baris yang cocok akan disorot dan jawabannya sudah di tangan. Kalau tidak ada satu pun yang cocok, berarti data yang dihitung bukan seperti yang Anda kira — periksa urutan byte, dan periksa apakah marker awal dan akhir frame ikut dihitung.
Modbus memakai CRC-16 yang mana?
CRC-16/MODBUS: polinomial 0x8005, nilai awal 0xFFFF, input dan output sama-sama direfleksikan, tanpa XOR akhir. Yang paling sering membingungkan justru urutan transmisinya, bukan algoritmanya — Modbus RTU mengirim byte rendah CRC lebih dulu, jadi frame dengan CRC 0xCDC5 membawa byte C5 CD di ujungnya. Pembahasan frame lengkapnya ada di panduan varian CRC-16.
Apa bedanya CRC-16/CCITT dan CRC-16/CCITT-FALSE?
Keduanya algoritma yang berbeda dengan nama yang mirip sampai membingungkan, dan justru karena itu katalog RevEng mengganti nama keduanya. Yang orang sebut CCITT-FALSE sebenarnya adalah CRC-16/IBM-3740: nilai awal 0xFFFF, tanpa refleksi. Yang biasanya dimaksud dengan CCITT polos adalah CRC-16/KERMIT: nilai awal 0x0000, input dan output direfleksikan. Kalkulator ini menampilkan nama formalnya sekaligus nama yang kemungkinan besar dipakai manual perangkat Anda.
Bisakah CRC mendeteksi bahwa sebuah file sudah dimanipulasi?
Tidak. CRC adalah kode deteksi error yang dirancang untuk kerusakan tak sengaja di kanal berderau, dan sifatnya linier — siapa pun bisa mengubah pesan lalu menyesuaikannya sehingga CRC-nya tetap cocok. Untuk integritas terhadap penyerang yang sengaja, pakai hash kriptografis seperti SHA-256, atau konstruksi terautentikasi seperti HMAC. CRC sangat baik untuk tugas yang memang jadi alasan ia dibuat, tapi sama sekali tidak memberi jaminan keamanan.
Sebenarnya refin dan refout itu melakukan apa?
refin membalik urutan bit di dalam setiap byte input sebelum byte itu masuk ke register; refout membalik urutan bit dari register akhir. Keduanya ada karena shift register di hardware dan implementasi tabel di software menggeser bit ke arah yang berlawanan, dan bentuk refleksi membuat keduanya sampai ke angka yang sama. Ini bukan hal yang sama dengan urutan byte — refleksi bekerja pada bit di dalam satu byte, sedangkan endianness menentukan urutan byte-nya sendiri.
Saya cuma punya checksum-nya, bukan datanya. Bisakah alat ini bekerja mundur?
Tidak bisa, dan tidak ada alat yang bisa. CRC memampatkan pesan sepanjang apa pun menjadi 8, 16, atau 32 bit, sehingga tak terhitung pesan berbeda berbagi nilai yang sama — ini bukan soal seberapa keras usahanya. Pencarian balik di halaman ini menjawab pertanyaan yang lebih sempit: kalau datanya ada dan ada checksum yang dihitung seseorang dari data itu, set parameter mana yang menghubungkan keduanya. Kalau Anda menangkap respons perangkat tapi bukan payload di baliknya, tangkap dulu payload-nya. Untuk memilih di antara lebar bit alih-alih mengidentifikasi satu varian, lihat panduan varian CRC-16.
Kenapa kalkulator ini menampilkan 63 varian padahal perangkat saya hanya menyebut satu?
Karena pertanyaan yang benar-benar berguna biasanya bukan "hitung sebuah CRC", melainkan "yang mana dari sekian varian ini yang menghasilkan nilai yang sedang saya pegang". Alat yang memaksa Anda memilih varian lebih dulu berasumsi Anda sudah tahu jawabannya. Menampilkan semua varian sekaligus mengubah proses identifikasi menjadi satu kali lihat tabel, dan kolom parameternya memungkinkan Anda memastikan kecocokan terhadap spesifikasi, bukan sekadar percaya pada sebuah nama.
Apakah data saya dikirim ke suatu tempat?
Tidak. Seluruh perhitungan berjalan di browser Anda memakai engine yang sama dengan yang merender tabel di halaman ini — tidak ada unggahan, tidak ada panggilan API, tidak ada logging. Anda bisa memutus koneksi jaringan dan alat ini tetap bekerja, dan itu penting karena input CRC sering kali berupa frame produksi atau image firmware.