CRC-32C હેશ કોડ કેલ્ક્યુલેટર

સાયક્લિક રીડન્ડન્સી ચેક (CRC) એ એક ભૂલ-શોધનાર કોડ છે જેનો ઉપયોગ સામાન્ય રીતે કાચા ડેટામાં આકસ્મિક ફેરફારો શોધવા માટે થાય છે. તકનીકી રીતે ક્રિપ્ટોગ્રાફિક હેશ ફંક્શન ન હોવા છતાં, ચલ-લંબાઈ ઇનપુટમાંથી ફિક્સ્ડ-સાઇઝ આઉટપુટ (32 બિટ્સ) ઉત્પન્ન કરવાની ક્ષમતાને કારણે CRC-32 ને ઘણીવાર હેશ તરીકે ઓળખવામાં આવે છે. આ પૃષ્ઠ પર પ્રસ્તુત સંસ્કરણ CRC-32C વેરિઅન્ટ છે, જે એક નવું, "સ્માર્ટર" (વધુ સારી ભૂલ શોધ) સંસ્કરણ છે જે ઘણીવાર આધુનિક CPUs (SSE 4.2 દ્વારા) પર હાર્ડવેર એક્સિલરેટેડ હોય છે.

સંપૂર્ણ ખુલાસો: મેં આ પૃષ્ઠ પર ઉપયોગમાં લેવાતા હેશ ફંક્શનના ચોક્કસ અમલીકરણ વિશે લખ્યું નથી. તે PHP પ્રોગ્રામિંગ ભાષામાં સમાવિષ્ટ એક માનક ફંક્શન છે. મેં ફક્ત સુવિધા માટે અહીં જાહેરમાં ઉપલબ્ધ કરાવવા માટે વેબ ઇન્ટરફેસ બનાવ્યું છે.

CRC-32C હેશ અલ્ગોરિધમ વિશે

હું ગણિતશાસ્ત્રી નથી, પણ હું આ હેશ ફંક્શનને એક સરળ સામ્યતા સાથે સમજાવવાનો પ્રયાસ કરીશ. ઘણા ક્રિપ્ટોગ્રાફિક હેશ ફંક્શનથી વિપરીત, તે ખાસ જટિલ અલ્ગોરિધમ નથી, તેથી તે કદાચ ઠીક રહેશે ;-)

કલ્પના કરો કે તમે ટપાલમાં એક પત્ર મોકલી રહ્યા છો, પરંતુ તમને ચિંતા છે કે તે પ્રાપ્તકર્તા સુધી પહોંચે તે પહેલાં જ તે બગડી જશે. પત્રની સામગ્રીના આધારે, તમે CRC-32 ચેકસમની ગણતરી કરો છો અને તેને પરબિડીયું પર લખો છો. જ્યારે પ્રાપ્તકર્તાને પત્ર મળે છે, ત્યારે તે ચેકસમની ગણતરી પણ કરી શકે છે અને જોઈ શકે છે કે તે તમે જે લખ્યું છે તે સાથે મેળ ખાય છે કે નહીં. જો તે થાય છે, તો પત્રને નુકસાન થયું નથી અથવા રસ્તામાં બદલાયું નથી.

CRC-32 આ જે રીતે કરે છે તે ચાર પગલાની પ્રક્રિયા છે:

પગલું 1: થોડી વધારાની જગ્યા ઉમેરો (ગાદી)

• CRC સંદેશના અંતે થોડી વધારાની જગ્યા ઉમેરે છે (જેમ કે બોક્સમાં મગફળી પેક કરવી).
• આનાથી ભૂલો વધુ સરળતાથી જોવા મળે છે.

પગલું 2: જાદુઈ શાસક (બહુપદી)

• CRC-32 ડેટા માપવા માટે એક ખાસ "જાદુઈ શાસક" નો ઉપયોગ કરે છે.
  • આ શાસકને બમ્પ્સ અને ખાંચોના પેટર્ન તરીકે વિચારો (આ બહુપદી છે, પરંતુ તે શબ્દ વિશે ચિંતા કરશો નહીં).
  • CRC-32 માટે સૌથી સામાન્ય "રૂલર" એક નિશ્ચિત પેટર્ન છે.

પગલું 3: રૂલરને સ્લાઇડ કરવું (વિભાજન પ્રક્રિયા)

• હવે CRC સંદેશ પર રૂલર સ્લાઇડ કરે છે.
  • દરેક જગ્યાએ, તે તપાસે છે કે બમ્પ અને ખાંચો એક બીજા સાથે જોડાયેલા છે કે નહીં.
  • જો તેઓ લાઇનમાં ન આવે, તો CRC એક નોંધ બનાવે છે (આ સરળ XOR નો ઉપયોગ કરીને કરવામાં આવે છે, જેમ કે સ્વીચો ચાલુ કે બંધ કરવા).
  • તે અંત સુધી પહોંચે ત્યાં સુધી સ્વીચો સ્લાઇડિંગ અને ફ્લિપ કરવાનું ચાલુ રાખે છે.

પગલું 4: અંતિમ પરિણામ (ચેકસમ)

• આખા સંદેશ પર રૂલર સ્લાઇડ કર્યા પછી, તમારી પાસે એક નાની સંખ્યા (32 બિટ્સ લાંબી) બાકી રહે છે જે મૂળ ડેટાનું પ્રતિનિધિત્વ કરે છે.
  • આ નંબર સંદેશ માટે એક અનોખી ફિંગરપ્રિન્ટ જેવો છે.
  • આ CRC-32 ચેકસમ છે.

પેજ પર રજૂ કરાયેલું વર્ઝન CRC-32C વેરિઅન્ટ છે, જે પસંદગીનું વેરિઅન્ટ હોવું જોઈએ, ખાસ કરીને જો તમે એવા CPUનો ઉપયોગ કરી રહ્યા છો જેમાં તેનું હાર્ડવેર એક્સિલરેટેડ વર્ઝન (SSE 4.2 અને પછીનું) હોય અને તમારે અન્ય વેરિઅન્ટ્સ સાથે સુસંગતતાની જરૂર ન હોય.

મારી પાસે અન્ય પ્રકારો માટે પણ કેલ્ક્યુલેટર છે:

• CRC-32 હેશ કોડ કેલ્ક્યુલેટર
• CRC-32B હેશ કોડ કેલ્ક્યુલેટર