SHA-1 હેશ કોડ કેલ્ક્યુલેટર

SHA-1 (સિક્યોર હેશ અલ્ગોરિધમ 1) એ NSA દ્વારા ડિઝાઇન કરાયેલ અને NIST દ્વારા 1995 માં પ્રકાશિત કરાયેલ ક્રિપ્ટોગ્રાફિક હેશ ફંક્શન છે. તે 160 બીટ (20 બાઇટ) હેશ મૂલ્ય ઉત્પન્ન કરે છે, જે સામાન્ય રીતે 40-અક્ષર હેક્સાડેસિમલ સ્ટ્રિંગ તરીકે રજૂ થાય છે. SHA-1 નો ઉપયોગ ડેટા ઇન્ટિગ્રિટી, ડિજિટલ સિગ્નેચર અને સર્ટિફિકેટ્સને સુરક્ષિત કરવા માટે વ્યાપકપણે થતો હતો, પરંતુ હવે તેને અથડામણ હુમલાઓની નબળાઈઓને કારણે અસુરક્ષિત માનવામાં આવે છે. જૂની સિસ્ટમ સાથે સુસંગત હોવા જોઈએ તેવા હેશ કોડની ગણતરી કરવાની જરૂર હોય તેવા કિસ્સામાં તેનો અહીં સમાવેશ કરવામાં આવ્યો છે, પરંતુ નવી સિસ્ટમ ડિઝાઇન કરતી વખતે તેનો ઉપયોગ થવો જોઈએ નહીં.

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

SHA-1 હેશ અલ્ગોરિધમ વિશે

હું ગણિતશાસ્ત્રી નથી, તેથી હું આ હેશ ફંક્શનને એવી રીતે સમજાવવાનો પ્રયાસ કરીશ કે અન્ય બિન-ગણિતશાસ્ત્રીઓ સમજી શકે - જો તમને સમજૂતીનું ચોક્કસ વૈજ્ઞાનિક ગણિત સંસ્કરણ જોઈતું હોય, તો તમે તે ઘણી બધી અન્ય વેબસાઇટ્સ પર શોધી શકો છો ;-)

SHA-1 ને એક ખાસ પેપર શ્રેડર તરીકે વિચારો જે કોઈપણ સંદેશ લે છે - પછી ભલે તે એક શબ્દ હોય, વાક્ય હોય કે આખું પુસ્તક હોય - અને તેને ખૂબ જ ચોક્કસ રીતે કટકા કરે છે. પરંતુ ફક્ત કટકા કરવાને બદલે, તે જાદુઈ રીતે એક અનોખો "કટકા કોડ" બહાર કાઢે છે જે હંમેશા બરાબર 40 હેક્સાડેસિમલ અક્ષરો લાંબો હોય છે.

• ઉદાહરણ તરીકે, તમે "હેલો" લખો છો
• તમને f7ff9e8b7bb2e09b70935a5d785e0cc5d9d0abf0 જેવા 40 હેક્સાડેસિમલ અંકો મળે છે.

તમે તેને ગમે તે ખવડાવો - ટૂંકું કે લાંબુ - આઉટપુટ હંમેશા સમાન લંબાઈનું હોય છે.

"જાદુઈ કટકા કરનાર" ચાર પગલામાં કામ કરે છે:

પગલું 1: કાગળ તૈયાર કરો (ગાદી)

• કાપતા પહેલા, તમારે તમારા કાગળ તૈયાર કરવાની જરૂર છે. કલ્પના કરો કે તમે તમારા સંદેશના અંતમાં ખાલી જગ્યાઓ ઉમેરો છો જેથી તે કાપનારની ટ્રેમાં સંપૂર્ણ રીતે ફિટ થઈ જાય.
• એવું લાગે છે કે જ્યારે તમે કૂકીઝ શેકતા હો, અને તમે ખાતરી કરો કે કણક મોલ્ડમાં સરખી રીતે ભરાય.

પગલું 2: તેને સમાન ટુકડાઓમાં કાપો (વિભાજીત કરો)

• કટકા કરનારને મોટા ટુકડા પસંદ નથી. તેથી, તે તમારા તૈયાર કરેલા સંદેશને નાના, સમાન કદના ટુકડાઓમાં કાપી નાખે છે - જેમ કે મોટી કેકને સંપૂર્ણ ટુકડાઓમાં કાપવી.

પગલું 3: ગુપ્ત રેસીપી (મિશ્રણ અને છૂંદવું)

• હવે આવે છે મજેદાર ભાગ! શ્રેડરની અંદર, તમારા સંદેશનો દરેક ટુકડો મિક્સર અને રોલર્સની શ્રેણીમાંથી પસાર થાય છે:
  • મિશ્રણ: તે તમારા સંદેશને કેટલાક ગુપ્ત ઘટકો (બિલ્ટ-ઇન નિયમો અને સંખ્યાઓ) સાથે જોડે છે.
  • મેશિંગ: તે ભાગોને ખાસ રીતે સ્ક્વિશ કરે છે, પલટાવે છે અને ફરતે ફેરવે છે.
  • વળી જવું: કેટલાક ભાગો વળી ગયા છે અથવા ઉલટા છે, જેમ કે કાગળને ઓરિગામિમાં ફોલ્ડ કરવો.

દરેક પગલું સંદેશને વધુ ગૂંચવણભર્યો બનાવે છે, પરંતુ ખૂબ જ ચોક્કસ રીતે જે મશીન હંમેશા અનુસરે છે.

પગલું 4: અંતિમ કોડ (હેશ)

• બધી મિક્સિંગ અને મેશિંગ પછી, એક સુઘડ, સ્ક્રેમ્બલ્ડ કોડ બહાર આવે છે - જે તમારા સંદેશ માટે એક અનોખી ફિંગરપ્રિન્ટ જેવો છે.
• ભલે તમે બદલો તમારા મૂળ સંદેશમાં ફક્ત એક અક્ષર હોય તો, આઉટપુટ સંપૂર્ણપણે અલગ હશે. તે જ તેને ખાસ બનાવે છે.

SHA-1 નો ઉપયોગ હવે ન થવો જોઈએ તેનું કારણ એ છે કે કેટલાક ખૂબ જ હોશિયાર લોકોએ શોધી કાઢ્યું કે કેવી રીતે શ્રેડરને બે અલગ અલગ સંદેશાઓ માટે સમાન કોડ બનાવવા માટે છેતરવું (આને અથડામણ કહેવામાં આવે છે).

SHA-1 ને બદલે, હવે આપણી પાસે વધુ મજબૂત, સ્માર્ટ "શ્રેડર્સ" છે. લેખન સમયે, મોટાભાગના હેતુઓ માટે મારો ડિફોલ્ટ ગો-ટુ હેશ અલ્ગોરિધમ SHA-256 છે - અને હા, મારી પાસે તેના માટે એક કેલ્ક્યુલેટર પણ છે: SHA-256 હેશ કોડ કેલ્ક્યુલેટર