इंटरनेट पर सीआरसी चेकसम की गणना के लिए कई विकल्प हैं। लेकिन चेकसम वास्तव में क्या है और इसकी गणना इस तरह क्यों की जाती है? आइए इसका पता लगाते हैं।
अनुदेश
चरण 1
सबसे पहले, आइए थोड़ा सिद्धांत प्राप्त करें। तो सीआरसी वास्तव में क्या है? संक्षेप में, यह चेकसम गणना की किस्मों में से एक है। चेकसम संचार चैनलों पर संचारित करते समय रिसीवर की ओर से प्राप्त जानकारी की अखंडता की जाँच करने की एक विधि है। उदाहरण के लिए, सबसे सरल जाँचों में से एक समता बिट का उपयोग करना है। यह तब होता है जब प्रेषित संदेश के सभी बिट्स का योग किया जाता है, और यदि योग सम हो जाता है, तो संदेश के अंत में 0 जोड़ा जाता है, यदि यह विषम है, तो 1. प्राप्त करते समय, का योग संदेश बिट्स को भी गिना जाता है और प्राप्त समता बिट के साथ तुलना की जाती है। यदि वे भिन्न हैं, तो संचरण के दौरान त्रुटियां हुईं और प्रेषित जानकारी विकृत हो गई।
लेकिन त्रुटियों की उपस्थिति का पता लगाने का यह तरीका बहुत ही जानकारीपूर्ण है और हमेशा काम नहीं करता है, क्योंकि यदि संदेश के कई टुकड़े विकृत हो जाते हैं, तो योग की समता नहीं बदल सकती है। इसलिए, सीआरसी सहित कई और "उन्नत" जांच हैं।
वास्तव में, सीआरसी एक योग नहीं है, बल्कि एक निश्चित मात्रा में जानकारी (सूचना संदेश) को एक स्थिरांक से विभाजित करने का परिणाम है, या यों कहें, एक संदेश को एक स्थिरांक से विभाजित करने का शेष भाग। हालांकि, सीआरसी को ऐतिहासिक रूप से "चेकसम" के रूप में भी जाना जाता है। संदेश का प्रत्येक बिट सीआरसी मूल्य में योगदान देता है। यही है, अगर प्रसारण के दौरान मूल संदेश का कम से कम एक बिट बदल जाता है, तो चेकसम भी बदल जाएगा, और महत्वपूर्ण रूप से। यह इस तरह के चेक का एक बड़ा प्लस है, क्योंकि यह आपको स्पष्ट रूप से यह निर्धारित करने की अनुमति देता है कि ट्रांसमिशन के दौरान मूल संदेश विकृत हो गया था या नहीं।
चरण दो
इससे पहले कि हम सीआरसी की गणना शुरू करें, थोड़ा और सिद्धांत की जरूरत है।
मूल संदेश क्या है स्पष्ट होना चाहिए। यह मनमानी लंबाई के बिट्स का एक सन्निहित क्रम है।
वह नियतांक क्या है जिससे हमें मूल संदेश को विभाजित करना चाहिए? यह संख्या भी किसी भी लम्बाई की होती है, लेकिन आमतौर पर 1 बाइट के गुणकों का उपयोग किया जाता है - 8, 16 और 32 बिट। इसे गिनना आसान है, क्योंकि कंप्यूटर बाइट्स के साथ काम करते हैं, बिट्स के साथ नहीं।
भाजक स्थिरांक को आमतौर पर इस तरह बहुपद (बहुपद) के रूप में लिखा जाता है: x ^ 8 + x ^ 2 + x ^ 1 + x ^ 0। यहां, संख्या "x" की डिग्री का अर्थ है शून्य से शुरू होने वाली संख्या में एक-बिट की स्थिति, और सबसे महत्वपूर्ण बिट बहुपद की डिग्री को इंगित करता है और संख्या की व्याख्या करते समय त्याग दिया जाता है। यानी पहले लिखी गई संख्या बाइनरी में (1) 00000111 या दशमलव में 7 से अधिक कुछ नहीं है। कोष्ठकों में, मैंने संख्या के निहित सबसे महत्वपूर्ण अंक का संकेत दिया।
यहां एक और उदाहरण दिया गया है: x ^ 16 + x ^ 15 + x ^ 2 + x ^ 0 = (1) 1000000000000101 = 0x8005 = 32773।
आमतौर पर कुछ मानक बहुपद विभिन्न प्रकार के सीआरसी के लिए उपयोग किए जाते हैं।
चरण 3
तो आप चेकसम की गणना कैसे करते हैं? एक मूल विधि है - एक संदेश को एक बहुपद "हेड-ऑन" में विभाजित करना - और गणना की संख्या को कम करने के लिए इसके संशोधन और, तदनुसार, सीआरसी गणना को गति देना। हम मूल विधि को देखेंगे।
सामान्य तौर पर, एक बहुपद द्वारा एक संख्या का विभाजन निम्नलिखित एल्गोरिथम के अनुसार किया जाता है:
1) एक सरणी (रजिस्टर) बनाई जाती है, जो शून्य से भरी होती है, जो बहुपद की चौड़ाई की लंबाई के बराबर होती है;
2) मूल संदेश बहुपद के बिट्स की संख्या के बराबर राशि में, कम से कम महत्वपूर्ण बिट्स में शून्य के साथ पूरक है;
3) संदेश का एक सबसे महत्वपूर्ण बिट रजिस्टर के कम से कम महत्वपूर्ण बिट में दर्ज किया जाता है, और एक बिट को रजिस्टर के सबसे महत्वपूर्ण बिट से स्थानांतरित किया जाता है;
4) यदि विस्तारित बिट "1" के बराबर है, तो बिट्स उल्टे (XOR ऑपरेशन, अनन्य OR) उन रजिस्टर बिट्स में होते हैं जो बहुपद में से मेल खाते हैं;
5) अगर संदेश में अभी भी बिट्स हैं, तो चरण 3 पर जाएं);
६) जब संदेश के सभी बिट्स रजिस्टर में प्रवेश करते हैं और इस एल्गोरिथम द्वारा संसाधित किए जाते हैं, तो शेष विभाजन रजिस्टर में रहता है, जो कि सीआरसी चेकसम है।
यह आंकड़ा मूल बिट अनुक्रम के विभाजन को संख्या (1) 00000111, या बहुपद x ^ 8 + x ^ 2 + x ^ 1 + x ^ 0 से दिखाता है।
चरण 4
कुछ अतिरिक्त स्पर्श शेष हैं। जैसा कि आपने देखा होगा, संदेश को किसी भी संख्या से विभाजित किया जा सकता है। इसे कैसे चुनें? कई मानक बहुपद हैं जिनका उपयोग सीआरसी की गणना के लिए किया जाता है। उदाहरण के लिए, CRC32 के लिए यह 0x04C11DB7 हो सकता है, और CRC16 के लिए यह 0x8005 हो सकता है।
इसके अलावा, गणना की शुरुआत में रजिस्टर में, आप शून्य नहीं, बल्कि कुछ अन्य संख्या लिख सकते हैं।
साथ ही, गणना के दौरान, अंतिम सीआरसी चेकसम जारी करने से ठीक पहले, उन्हें किसी अन्य संख्या से विभाजित किया जा सकता है।
और आखिरी बात। रजिस्टर में लिखते समय संदेश के बाइट्स को सबसे महत्वपूर्ण बिट "फॉरवर्ड" के रूप में रखा जा सकता है, और इसके विपरीत, कम से कम महत्वपूर्ण।
चरण 5
उपरोक्त सभी के आधार पर, आइए एक बेसिक. NET फ़ंक्शन लिखें जो सीआरसी चेकसम की गणना मेरे द्वारा ऊपर वर्णित कई मापदंडों को लेकर और सीआरसी मान को 32-बिट अहस्ताक्षरित संख्या के रूप में लौटाता है।
पब्लिक शेयर्ड फंक्शन GetCrc (ByVal बाइट्स as Byte (), ByVal poly as UInteger, वैकल्पिक ByVal चौड़ाई Integer = 32, वैकल्पिक ByVal initReg as UInteger = & HFFFFFFFFUI, वैकल्पिक ByVal finalXor as UInteger = & HFFFFFFFFUI, वैकल्पिक ByVal रिवर्सबाइट्स, वैकल्पिक बूलियन ByVal रिवर्स सीआरसी बूलियन = ट्रू के रूप में)
डिम चौड़ाई इनबाइट्स अस इंटीजर = चौड़ाई / 8
'संदेश की चौड़ाई को शून्य के साथ पूरक करें (बाइट्स में गणना):
रीडिम संरक्षित बाइट्स (बाइट्स। लंबाई - 1 + चौड़ाईइनबाइट्स)
'संदेश से थोड़ी सी कतार बनाएं:
नई कतार के रूप में मंद msgFifo (बूलियन का) (बाइट्स। गणना * 8 - 1)
प्रत्येक बी के लिए बाइट्स में बाइट के रूप में
डिम बा ऐज़ न्यू बिटअरे ({b})
अगर रिवर्सबाइट्स तब
मैं के लिए पूर्णांक के रूप में = 0 से 7
msgFifo. Enqueue (बीए (i))
अगला
अन्य
क्योंकि मैं पूर्णांक के रूप में = 7 से 0 चरण -1
msgFifo. Enqueue (बीए (i))
अगला
अगर अंत
अगला
'रजिस्टर के प्रारंभिक भरण बिट्स से एक कतार बनाएँ:
मंद initBytes बाइट के रूप में () = BitConverter. GetBytes (initReg)
मंद initBytes IEnumerable के रूप में उलट (बाइट का) = (b से initBytes में बाइट के रूप में चौड़ाई लें). Reverse
नई कतार के रूप में मंद initFifo (बूलियन का) (चौड़ाई -1)
प्रत्येक बी के लिए बाइट के रूप में initBytesReversed
डिम बा ऐज़ न्यू बिटअरे ({b})
यदि रिवर्स नहीं हैबाइट्स तो
मैं के लिए पूर्णांक के रूप में = 0 से 7
initFifo. Enqueue (बीए (i))
अगला
अन्य
क्योंकि मैं पूर्णांक के रूप में = 7 से 0 चरण -1
initFifo. Enqueue (बीए (i))
अगला
अगर अंत
अगला
'शिफ्ट और एक्सओआर:
मंद रजिस्टर UInteger = 0 के रूप में 'चौड़ाई-बिट रजिस्टर को शून्य से भरें।
जबकि msgFifo. Count> 0. करें
Dim poppedBit As Integer = CInt (रजिस्टर >> (चौड़ाई - 1)) और 1 'शिफ्ट रजिस्टर से पहले परिभाषित करें।
डिम शिफ्ट किया गया बिट के रूप में बाइट = कनवर्ट करें। टूबाइट (msgFifo. Dequeue)
अगर initFifo. Count> 0 तो
डिम बी बाइट के रूप में = Convert. ToByte (initFifo. Dequeue)
शिफ्ट बिट = शिफ्ट किया गयाबिट एक्सया बीor
अगर अंत
रजिस्टर = रजिस्टर << 1
रजिस्टर = रजिस्टर या शिफ्ट किया गया बिट
अगर poppedBit = 1 फिर
रजिस्टर = एक्सर पॉली रजिस्टर करें
अगर अंत
कुंडली
'अंतिम रूपांतरण:
Dim crc UInteger के रूप में = रजिस्टर 'रजिस्टर में शेष भाग == चेकसम होता है।
अगर रिवर्ससीआरसी तब
सीआरसी = प्रतिबिंबित (सीआरसी, चौड़ाई)
अगर अंत
सीआरसी = सीआरसी Xor finalXor
crc = crc और (& HFFFFFFFFUI >> (32 - चौड़ाई)) 'कम से कम महत्वपूर्ण बिट्स को मास्क करें।
वापसी सीआरसी
अंत समारोह
