എംഡി5

ഗൂഢശാസ്ത്രത്തിൽ (Cryptography) വ്യാപകമായി ഉപയോഗിക്കപ്പെട്ടിരുന്നതും 128-ബിറ്റ് ഹാഷ് വില (hash value) ലഭിക്കുന്നതുമായ ഒരു ഗൂഢശാസ്ത്ര ഹാഷ് ഫങ്ഷനാണ് **MD5** (**Message-Digest algorithm 5**). ഒരു ഇന്റെർനെറ്റ് മാനദണ്ഡമായതിനാൽ തന്നെ (RFC 1321) വ്യത്യസ്ത മേഖലകളിലെ കമ്പ്യൂട്ടർ സുരക്ഷാ ആവശ്യങ്ങൾക്ക് പ്രമാണങ്ങളുടെ സാധുത പരിശോധിക്കുവാൻ ഇത് ഉപയോഗിക്കപ്പെട്ടിരിന്നു. പക്ഷേ പൂർണ്ണമായും വ്യത്യസ്ത ഹാഷ് ഫലങ്ങൾ നൽകാൻ കഴിവുള്ളതല്ല MD5 എന്ന് വെളിപ്പെടുത്തലുകളുണ്ടായിട്ടുണ്ട്; അതിനാൽ തന്നെ എസ്.എസ്.എൽ സാക്ഷ്യപത്രങ്ങൾ (SSL certificates) ഡിജിറ്റൽ ഒപ്പുകൾ (digital signatures) എന്നിവയ്ക്ക് ഇത് യോജിച്ചതല്ല, മുപ്പത്തിരണ്ട് അക്കങ്ങളടങ്ങിയ ഹെക്സാഡെസിമൽ (Hexadecimal) സംഖ്യയായാണ് ഒരു MD5 ഹാഷ് വില സാധാരണയായി സൂചിപ്പിക്കാറുള്ളത്.

## ചരിത്രം
1991ൽ റോൺ റിവെസ്റ്റ് (Ron Rivest) MD4 ന് പകരമായി രൂപകൽപ്പന ചെയ്തതാണ് MD5. 1996 ൽ ഇതിന്റെ രൂപകൽപ്പനയിൽ ഒരു പിഴവ് കണ്ടെത്തുകയുണ്ടായി, പക്ഷേ അതത്ര സാരമുള്ളതായിരുന്നില്ലെങ്കിലും, SHA-1 പോലെയുള്ള മറ്റ് അൽഗോരിതങ്ങളെ ആശ്രയിക്കുവാൻ ക്രിപ്റ്റോഗ്രാഫർമാർ ശുപാർശ ചെയ്യാൻ തുടങ്ങിയിരുന്നു. 2004 ൽ കൂടുതൽ ഗൗരവമുള്ള പിഴവുകൾ കണ്ടെത്തുകയും ചെയ്തു. ഇത് ഈ അൽഗോരിതത്തിന്റെ ശേഷമുള്ള ഉപയോഗത്തിനെതിരെയുള്ള ശക്തമായ ചോദ്യങ്ങൾ ഉയർന്നുവരാൻ കാരണമാവുകയും ചെയ്തു. 2007 ൽ അജേൺ ലെൻസ്ട്രയുടെ (Arjen Lenstra) നേതൃത്വത്തിലുള്ള ഒരു കൂട്ടം ഗവേഷകർ ഒരേ MD5 വില (MD5 checksum) ലഭിക്കുന്ന ഒരു ജോഡി പ്രമാണങ്ങൾ നിർമ്മിക്കുന്നതെങ്ങനെയെന്ന് കാണിച്ചുതന്നു. 2008 ഡിസംബറിൽ മറ്റൊരു കൂട്ടം ഗവേഷകർ ഈ വിദ്യയുപയോഗിച്ച് എസ്.എസ്.എൽ. സാക്ഷ്യപത്രത്തിന്റെ (SSL certificate) സാധുത വ്യജമായി സൃഷ്ടിക്കുന്നതെങ്ങനെയെന്നും വെളിവാക്കി ഈ അൽഗോരിതം ആക്രമണങ്ങൾക്ക് വിധേയമാകുമെന്ന് കാണിച്ചുതരികയും ചെയ്തു. "ഗൂഢശാസ്ത്രപരമായി വിള്ളലുകളുള്ള ഇത് ഇനിയുള്ള ഉപയോഗങ്ങൾക്ക് യോജിച്ചതല്ല" എന്നാണ് അമേരിക്കൻ ഐക്യനാടുകളിലെ ആഭ്യന്തര സുരക്ഷാവകുപ്പിൽപ്പെട്ട യു.എസ്-സി.ഇ.ആർ.ടി. ഇതിനെപ്പറ്റി പറഞ്ഞിരിക്കുന്നത്, 2010 ഓടുകൂടി ഭൂരിഭാഗം യു.എസ്. സർക്കാർ വകുപ്പുകളും SHA-2 കുടുംബത്തിൽപ്പെട്ട് ഹാഷ് ഫങ്ങ്ഷനുകൾ ഉപയോഗിക്കുന്നതിലേക്ക് മാറാനിരിക്കുകയുമാണ്.

## ഉപയോഗങ്ങൾ
സോഫ്റ്റ്‌വെയർ ലോകത്ത് കൈമാറ്റം ചെയ്യപ്പെടുന്ന ഫയലുകൾ മാറ്റം കൂടാതെയാണ് ലഭിച്ചിരിക്കുന്നത് എന്നുറപ്പാക്കുന്നതിന് MD5 ഡയജെസ്റ്റുകൾ വ്യാപകമായി ഉപയോഗിക്കപ്പെട്ടിരിക്കുന്നു. ഉദാഹരണത്തിന് ഫയൽ സെർവറുകളിൽ നിന്ന് ഉപയോക്താക്കൾ ഡൗൺലോഡ് ചെയ്യുന്ന ഫയലുകൾ അവർക്ക് മാറ്റം കൂടാതെയാണ് ലഭിച്ചിരിക്കുന്നതെന്നുറപ്പാക്കുന്നതിന് ഫയലുകളുടെ മുൻകൂട്ടി തയ്യാറാക്കിയ MD5 ഹാഷ് വിലകൾ നൽകാറുണ്ട്. യുണിക്സ് അടിസ്ഥാനമാക്കിയുള്ള ഓപ്പറേറ്റിങ്ങ് സിസ്റ്റങ്ങളിൽ MD5 വില കണക്കാക്കുവാൻ സഹായിക്കുന്ന ഉപകരണങ്ങൾ ഉൾപ്പെടുത്തിയിരിക്കും, അതേ സമയം വിൻഡോസ് ഉപയോക്താക്കൾ ഇതിനു വേണ്ടി മറ്റ് പ്രോഗ്രാമുകളെ ആശ്രയിക്കുന്നു.

ഒരു പ്രമാണം തയ്യാറാക്കിയ വ്യക്തിക്ക് ആ പ്രമാണത്തിന്റെ MD5 ഹാഷ് വില ലഭിക്കുന്ന മറ്റൊരു പ്രമാണം തയ്യാറാക്കാൻ സാധ്യമാണ്. അതിനാൽ തന്നെ ഈ വിദ്യ ഉപദ്രവകരമായ മാറ്റം വരുത്തലുകളിൽ നിന്ന് സം‌രക്ഷിക്കുവാൻ മാത്രം പ്രാപ്തമല്ല. മാത്രമല്ല ചില അവസരങ്ങളിൽ ലഭിച്ച ഹാഷ് വിലയെ വിശ്വസിക്കാവതുമല്ല; ഇത്തരം അവസരങ്ങളിൽ MD5 പ്രമാണങ്ങളിലെ പിഴ-പരിശോധനകൾക്ക് മാത്രമായേ ഉപയോഗപ്പെടുത്താനാവുകയുള്ളൂ: ഇത് ഡൗൺലോഡ് ചെയ്ത പ്രമാണം ദുഷിപ്പിക്കപ്പെട്ടതാണോ അല്ലയോ എന്ന് മനസ്സിലാക്കിത്തരുന്നു, വലിയ പ്രമാണങ്ങളാണ് ഡൗൺലോഡ് ചെയ്യുന്നതെങ്കിൽ അതിൽ നെറ്റ്വർക്കിലെ പിഴവുകൾ വഴി പ്രമാണത്തിൽ മാറ്റങ്ങൾ വരുവാൻ സാധ്യത കൂടുതലുമാണ്.

രഹസ്യവാക്കുകൾ സൂക്ഷിക്കുവാൻ MD5 വ്യാപകമായി ഉപയോഗിക്കപ്പെട്ടിരുന്നു. ആക്രമണ സാധ്യതകളെ മറികടക്കുവാൻ രഹസ്യവാക്കുകളെ ഹാഷ് ചെയ്യുന്നതിനുമുൻപായി അധികമായി അന്യ ഡേറ്റായെ ചേർക്കാവുന്നതാണ്. ചില ഉപയോഗങ്ങളിൽ ഒന്നിൽ കൂടുതൽ തവണ ഹാഷ് നടത്താറുണ്ട്.

## സ്യൂഡോകോഡ്
MD5 ഹാഷ് അൽഗോരിതത്തിന്റെ സ്യൂഡോകോഡ് താഴെ ചേർത്തിരിക്കുന്നു.

 //*Note: All variables are unsigned 32 bits and wrap modulo 2^32 when calculating*
 **var** *int*[64] r, k
 
 //*r specifies the per-round shift amounts*
 r[ 0..15] := {7, 12, 17, 22,  7, 12, 17, 22,  7, 12, 17, 22,  7, 12, 17, 22} 
 r[16..31] := {5,  9, 14, 20,  5,  9, 14, 20,  5,  9, 14, 20,  5,  9, 14, 20}
 r[32..47] := {4, 11, 16, 23,  4, 11, 16, 23,  4, 11, 16, 23,  4, 11, 16, 23}
 r[48..63] := {6, 10, 15, 21,  6, 10, 15, 21,  6, 10, 15, 21,  6, 10, 15, 21}
 
 //*Use binary integer part of the sines of integers (Radians) as constants:*
 **for** i **from** 0 **to** 63
     k[i] := floor(abs(sin(i + 1)) &times; (2 **pow** 32))
 
 //*Initialize variables:*
 **var** *int* h0 := 0x67452301
 **var** *int* h1 := 0xEFCDAB89
 **var** *int* h2 := 0x98BADCFE
 **var** *int* h3 := 0x10325476
 
 //*Pre-processing:*
 **append** "1" bit **to** message
 **append** "0" bits **until** message length in bits ≡ 448 (mod 512)
 **append** bit /* bit, not byte */ length of unpadded message **as** *64-bit little-endian integer* **to** message
 
 //*Process the message in successive 512-bit chunks:*
 **for each** *512-bit* chunk **of** message
     break chunk into sixteen 32-bit little-endian words w[i], 0 ≤ i ≤ 15
 
     //*Initialize hash value for this chunk:*
     **var** *int* a := h0
     **var** *int* b := h1
     **var** *int* c := h2
     **var** *int* d := h3
 
     //*Main loop:*
     **for** i **from** 0 **to** 63
         **if** 0 ≤ i ≤ 15 **then**
             f := (b **and** c) **or** ((**not** b) **and** d)
             g := i
         **else if** 16 ≤ i ≤ 31
             f := (d **and** b) **or** ((**not** d) **and** c)
             g := (5&times;i + 1) **mod** 16
         **else if** 32 ≤ i ≤ 47
             f := b **xor** c **xor** d
             g := (3&times;i + 5) **mod** 16
         **else if** 48 ≤ i ≤ 63
             f := c **xor** (b **or** (**not** d))
             g := (7&times;i) **mod** 16
  
         temp := d
         d := c
         c := b
         b := b + **leftrotate**((a + f + k[i] + w[g]) , r[i])
         a := temp
 
     //*Add this chunk's hash to result so far:*
     h0 := h0 + a
     h1 := h1 + b 
     h2 := h2 + c
     h3 := h3 + d
 
 **var** *int* digest := h0 **append** h1 **append** h2 **append** h3 //*(expressed as little-endian)*

   //*leftrotate function definition*
   **leftrotate** (x, c) 
       return (x > (32-c)); 

*Note: Instead of the formulation from the original RFC 1321 shown, the following may be used for improved efficiency (useful if assembly language is being used - otherwise, the compiler will generally optimize the above code.  Since each computation is dependent on another in these formulations, this is often slower than the above method where the nand/and can be parallelised):*
 (0  ≤ i ≤ 15): f := d **xor** (b **and** (c **xor** d))
 (16 ≤ i ≤ 31): f := c **xor** (d **and** (b **xor** c))

## MD5 ഹാഷുകൾ
മുപ്പത്തിരണ്ട് അക്കങ്ങളുള്ള ഹെക്സാഡെസിമൽ സംഖ്യയായിട്ടാണ് 128-ബിറ്റ് MD5 ഹാഷ് വിലയെ സാധാരണയായി കാണിക്കാറുള്ളത്. താഴെ തന്നിരിക്കുന്ന ഉദാഹരണത്തിൽ 60 ബൈറ്റുകളുള്ള ഒരു യൂണീകോഡ് ഇൻപുട്ടും അതിന്റെ MD5 ഹാഷും നൽകിയിരിക്കുന്നു:

 MD5("ആർക്കും തിരുത്താവുന്ന സ്വതന്ത്ര വിജ്ഞാനകോശമാണ് വിക്കിപീഡിയ") 
   = 39f48629ea5b07304820467c63dfd088

അവലാൻഷെ പ്രഭാവം (avalanche effect) നിമിത്തമായി, നൽകിയിരിക്കുന്ന ഇൻപുട്ടിൽ വരുന്ന ചെറിയ മാറ്റം പോലും പൂർണ്ണമായും വ്യത്യസ്തമായ ഹാഷ് വില ലഭിക്കുന്നതിന് കാരണമാകുന്നു. ഉദാഹരണത്തിന് മുകളിലെ ഉദാഹരണത്തിലെ സന്ദേശത്തിന്റെ അവസാനം ഒരു പൂർണ്ണ വിരാമം ചേർത്താൽ ലഭിക്കുന്നത്:

 MD5("ആർക്കും തിരുത്താവുന്ന സ്വതന്ത്ര വിജ്ഞാനകോശമാണ് വിക്കിപീഡിയ.") 
   = 1f93c3fdc908981e588fc13823ebd0fc

പൂജ്യം നീളമുള്ള സന്ദേശത്തിന്റെ ഹാഷ്:

  MD5("") 
   = d41d8cd98f00b204e9800998ecf8427e

## അവലംബം

 

വർഗ്ഗം:ഗൂഢശാസ്ത്രം