CRC चेकसम कैलकुलेटर

गणना दर्ज करें

इनपुट टेक्स्ट (ASCII)

CRC वैरिएंट CRC-8 (पॉलिनोमियल 0x07) CRC-16/CCITT-FALSE (पॉलिनोमियल 0x1021, init 0xFFFF) CRC-32 (IEEE 802.3, रिफ़्लेक्टेड)

परिणाम

CRC चेकसम (हेक्स)

0x29B1

16-bit checksum

डेसिमल मान	10,673
चौड़ाई	16 bits
प्रोसेस की गई बाइट्स	9

CRC चेकसम क्या होता है?

Cyclic Redundancy Check (CRC) एक ऐसा एरर-डिटेक्टिंग कोड है जिसका इस्तेमाल नेटवर्किंग, स्टोरेज और फ़ाइल फ़ॉर्मैट (Ethernet, ZIP, PNG, Modbus, USB वगैरह) में बड़े पैमाने पर होता है। यह आपके डेटा को एक लंबी बाइनरी संख्या मान लेता है और उसे एक निश्चित जनरेटर पॉलिनोमियल से कैरी-रहित बाइनरी अंकगणित (GF(2), जहाँ जोड़ और घटाव दोनों ही XOR होते हैं) के ज़रिए भाग देता है। इस भाग का शेषफल ही CRC है। अगर मैसेज का एक भी बिट बदल जाए, तो शेषफल लगभग हमेशा बदल जाता है — यही वजह है कि CRC ट्रांसमिशन और स्टोरेज की गलतियों को पकड़ने में बेहद कारगर है।

CRC डेटा में एक छोटा जाँच मान जोड़ता है ताकि त्रुटियों का पता लगाया जा सके।

इस कैलकुलेटर का इस्तेमाल कैसे करें

इनपुट बॉक्स में कोई भी ASCII टेक्स्ट टाइप करें, अपनी ज़रूरत का CRC वैरिएंट चुनें और नतीजा देखें। यह टूल चेकसम को हेक्साडेसिमल और डेसिमल दोनों रूप में दिखाता है, साथ ही बिट चौड़ाई और प्रोसेस की गई बाइट्स की संख्या भी बताता है। तीन आम वैरिएंट समर्थित हैं:

CRC-8 — पॉलिनोमियल \(\mathtt{0x07}\), शुरुआती मान \(\mathtt{0x00}\)।
CRC-16/CCITT-FALSE — पॉलिनोमियल \(\mathtt{0x1021}\), शुरुआती मान \(\mathtt{0xFFFF}\), कोई रिफ़्लेक्शन नहीं।
CRC-32 (IEEE 802.3) — रिफ़्लेक्टेड पॉलिनोमियल \(\mathtt{0xEDB88320}\), शुरुआती मान \(\mathtt{0xFFFFFFFF}\), अंतिम XOR \(\mathtt{0xFFFFFFFF}\)। यही वैरिएंट ZIP, gzip और Ethernet में इस्तेमाल होता है।

$$\text{CRC} = \mathrm{XorOut} \oplus \bigoplus_{b \in \text{Message bytes}} \mathrm{Update}_{\text{poly}}(\text{crc}, b)$$

$$\text{where (CRC-16/CCITT-FALSE)}\quad \left\{ \begin{aligned} \text{poly} &= \mathtt{0x1021} \\ \mathrm{init} &= \mathtt{0xFFFF} \\ \mathrm{XorOut} &= \mathtt{0x0000} \\ \text{width} &= 16 \text{ bits (MSB-first, no reflection)} \end{aligned} \right.$$

$$\text{CRC}_{8} = \bigoplus_{b \in \text{Message bytes}} \mathrm{Update}(\text{crc}, b)$$

$$\text{where}\quad \left\{ \begin{aligned} \mathrm{init} &= \mathtt{0x00} \\ \text{poly} &= \mathtt{0x07} \\ \text{step} &: \text{crc} \leftarrow \big(\text{crc} \ll 1\big) \oplus (\text{MSB}?\,\text{poly}:0) \\ \text{width} &= 8 \text{ bits, MSB-first} \end{aligned} \right.$$

$$\text{CRC}_{16} = \bigoplus_{b \in \text{Message bytes}} \mathrm{Update}(\text{crc}, b)$$

$$\text{where}\quad \left\{ \begin{aligned} \mathrm{init} &= \mathtt{0xFFFF} \\ \text{poly} &= \mathtt{0x1021} \\ \text{step} &: \text{crc} \leftarrow \big(\text{crc} \ll 1\big) \oplus (\text{MSB}?\,\text{poly}:0) \\ \text{width} &= 16 \text{ bits, MSB-first} \end{aligned} \right.$$

$$\text{CRC}_{32} = \mathtt{0xFFFFFFFF} \oplus \bigoplus_{b \in \text{Message bytes}} \mathrm{Update}(\text{crc}, b)$$

$$\text{where}\quad \left\{ \begin{aligned} \mathrm{init} &= \mathtt{0xFFFFFFFF} \\ \text{poly} &= \mathtt{0xEDB88320}\ (\text{reflected}) \\ \text{step} &: \text{crc} \leftarrow \big(\text{crc} \gg 1\big) \oplus (\text{LSB}?\,\text{poly}:0) \\ \text{width} &= 32 \text{ bits, LSB-first} \end{aligned} \right.$$

फ़ॉर्मूला समझें

सैद्धांतिक रूप से, मैसेज \(M(x)\) को \(x^n\) से गुणा किया जाता है (जहाँ \(n\) जनरेटर की डिग्री है) और फिर \(G(x)\) से भाग दिया जाता है। व्यावहारिक रूप में हम एक रजिस्टर का इस्तेमाल करते हैं जिसे एक-एक बिट करके शिफ़्ट करते हैं और जब भी अग्रणी (leading) बिट 1 हो, तो उसमें पॉलिनोमियल XOR कर देते हैं। रिफ़्लेक्टेड वैरिएंट (जैसे CRC-32) बिट्स को least-significant-first प्रोसेस करते हैं और बाएँ की बजाय दाएँ शिफ़्ट करते हैं।

CRC, संदेश को जनरेटर \(G(x)\) से बाइनरी बहुपद विभाजन (XOR) करने का शेषफल है।

हल किया हुआ उदाहरण

क्लासिक चेक स्ट्रिंग 123456789 के लिए: CRC-16/CCITT-FALSE का नतीजा होता है 0x29B1 (डेसिमल 10673), और CRC-32/IEEE का नतीजा होता है 0xCBF43926 (डेसिमल 3421780262)। ये CRC रेफ़रेंस कैटलॉग में प्रकाशित मानक "check" मान हैं, इसलिए आप इनके ज़रिए किसी भी इम्प्लीमेंटेशन की जाँच कर सकते हैं।

अक्सर पूछे जाने वाले सवाल

मेरा नतीजा किसी दूसरे टूल से अलग क्यों आ रहा है? CRC वैरिएंट पॉलिनोमियल, शुरुआती मान, बिट रिफ़्लेक्शन और अंतिम XOR में अलग-अलग होते हैं। पक्का कर लें कि आप बिल्कुल वही वैरिएंट आपस में तुलना कर रहे हैं।

क्या CRC एक सुरक्षित हैश है? नहीं। CRC अनजाने में हुई गलतियाँ पकड़ता है, लेकिन इसे जानबूझकर बदलना (forge करना) बहुत आसान है। सुरक्षा के लिए SHA-256 या इस जैसे हैश का इस्तेमाल करें।

कौन-सी एन्कोडिंग इस्तेमाल होती है? CRC की गणना से पहले हर अक्षर को उसके 8-बिट ASCII/Latin-1 बाइट मान के रूप में लिया जाता है।