MD5-encrypted JavaScript implementation

Guidance:
<SCRIPT>
/* MD5 message-Digest algorithm-Javascript
Modification history:
1.0 16-feb-2001-Phil fresystemic (<a href = "mailto: sales@frez.co.uk"> sales@frez.co.uk </a>)-initial version (Vb/ASP code)
1.0 21-feb-2001-Enrico mosanghini (<a href = "mailto: erik504@yahoo.com"> erik504@yahoo.com </a>)-JavaScript porting
*/
Function MD5 (smessage ){
Function rotateleft (lvalue, ishiftbits) {return (lvalue <ishiftbits) | (lvalue >>>( 32-ishiftbits ));}
Function addunsigned (LX, ly ){
VaR lx4, ly4, lx8, ly8, lresult;
Lx8 = (Lux & 0x80000000 );
Ly8 = (ly & 0x80000000 );
Lx4 = (LX & 0x40000000 );
Ly4 = (ly & 0x40000000 );
Lresult = (LX & 0x3fffffff) + (ly & 0x3fffffff );
If (lx4 & ly4) Return (lresult ^ 0x80000000 ^ lx8 ^ ly8 );
If (lx4 | ly4 ){
If (lresult & 0x40000000) Return (lresult ^ 0xc0000000 ^ lx8 ^ ly8 );
Else return (lresult ^ 0x40000000 ^ lx8 ^ ly8 );
} Else return (lresult ^ lx8 ^ ly8 );
}
Function f (x, y, z) {return (X & Y) | ((~ X) & Z );}
Function g (x, y, z) {return (X & z) | (Y &(~ Z ));}
Function h (x, y, z) {return (x ^ y ^ Z );}
Function I (x, y, z) {return (y ^ (X | (~ Z )));}
Function ff (a, B, c, d, X, S, AC ){
A = addunsigned (A, addunsigned (f (B, c, d), x), AC ));
Return addunsigned (rotateleft (A, S), B );
}
Function Gg (a, B, c, d, X, S, AC ){
A = addunsigned (A, addunsigned (G (B, c, d), x), AC ));
Return addunsigned (rotateleft (A, S), B );
}
Function HH (a, B, c, d, X, S, AC ){
A = addunsigned (A, addunsigned (H (B, c, d), x), AC ));
Return addunsigned (rotateleft (A, S), B );
}
Function II (a, B, c, d, X, S, AC ){
A = addunsigned (A, addunsigned (I (B, c, d), x), AC ));
Return addunsigned (rotateleft (A, S), B );
}
Function converttowordarray (smessage ){
VaR lwordcount;
VaR lmessagelength = smessage. length;
VaR lnumberofwords_temp1 = lmessagelength + 8;
VaR lnumberofwords_temp2 = (lnumberofwords_temp1-(lnumberofwords_temp1% 64)/64;
VaR lnumberofwords = (lnumberofwords_temp2 + 1) * 16;
VaR lwordarray = array (lNumberOfWords-1 );
VaR lbyteposition = 0;
VaR lbytecount = 0;
While (lbytecount <lmessagelength ){
Lwordcount = (lbytecount-(lbytecount % 4)/4;
Lbyteposition = (lbytecount % 4) * 8;
Lwordarray [lwordcount] = (lwordarray [lwordcount] | (smessage. charcodeat (lbytecount) <lbyteposition ));
Lbytecount ++;
}
Lwordcount = (lbytecount-(lbytecount % 4)/4;
Lbyteposition = (lbytecount % 4) * 8;
Lwordarray [lwordcount] = lwordarray [lwordcount] | (0x80 <lbyteposition );
Lwordarray [lNumberOfWords-2] = lmessagelength <3;
Lwordarray [lNumberOfWords-1] = lmessagelength >>> 29;
Return lwordarray;
}
Function wordtohex (lvalue ){
VaR wordtohexvalue = "", wordtohexvalue_temp = "", lbyte, lcount;
For (lcount = 0; lcount <= 3; lcount ++ ){
Lbyte = (lvalue >>> (lcount * 8) & 255;
Wordtohexvalue_temp = "0" + lbyte. tostring (16 );
Wordtohexvalue = wordtohexvalue + wordtohexvalue_temp.substr (WordToHexValue_temp.length-2, 2 );
}
Return wordtohexvalue;
}
VaR x = array ();
VaR K, AA, BB, CC, DD, a, B, c, d
VaR S11 = 7, S12 = 12, S13 = 17, S14 = 22;
VaR S21 = 5, s22 = 9, S23 = 14, S24 = 20;
VaR s31 = 4, s32 = 11, s33 = 16, s34 = 23;
VaR s41 = 6, S42 = 10, s43 = 15, s44 = 21;
// Steps 1 and 2. append padding bits and length and convert to words
X = converttowordarray (smessage );
// Step 3. initialise
A = 0x67452301; B = 0xefcdab89; C = 0x98badcfe; D = 0x10325476;
// Step 4. process the message in 16-word Blocks
For (k = 0; k <X. length; k + = 16 ){
AA = A; BB = B; CC = C; dd = D;
A = ff (a, B, c, d, X [K + 0], S11, 0xd76aa478 );
D = ff (D, a, B, c, X [k + 1], S12, 0xe8c7b756 );
C = ff (c, d, A, B, X [K + 2], S13, 0x242070db );
B = ff (B, c, d, A, X [K + 3], S14, 0xc1bdceee );
A = ff (a, B, c, d, X [K + 4], S11, 0xf57c0faf );
D = ff (D, a, B, c, X [K + 5], S12, 0x4787c62a );
C = ff (c, d, A, B, X [K + 6], S13, 0xa8304613 );
B = ff (B, c, d, A, X [K + 7], S14, 0xfd469501 );
A = ff (a, B, c, d, X [K + 8], S11, 0x698098d8 );
D = ff (D, a, B, c, X [K + 9], S12, 0x8b44f7af );
C = ff (c, d, A, B, X [K + 10], S13, 0xffff5bb1 );
B = ff (B, c, d, A, X [K + 11], S14, 0x895cd7be );
A = ff (a, B, c, d, X [K + 12], S11, 0x6b901122 );
D = ff (D, a, B, c, X [K + 13], S12, 0xfd987193 );
C = ff (c, d, A, B, X [K + 14], S13, 0xa679438e );
B = ff (B, c, d, A, X [K + 15], S14, 0x49b40821 );
A = Gg (a, B, c, d, X [k + 1], S21, 0xf61e2562 );
D = Gg (D, a, B, c, X [K + 6], s22, 0xc040b340 );
C = Gg (c, d, A, B, X [K + 11], S23, 0x265e5a51 );
B = Gg (B, c, d, A, X [K + 0], S24, 0xe9b6c7aa );
A = Gg (a, B, c, d, X [K + 5], S21, 0xd62f105d );
D = Gg (D, a, B, c, X [K + 10], s22, 0x2441453 );
C = Gg (c, d, A, B, X [K + 15], S23, 0xd8a1e681 );
B = Gg (B, c, d, A, X [K + 4], S24, 0xe7d3fbc8 );
A = Gg (a, B, c, d, X [K + 9], S21, 0x21e1cde6 );
D = Gg (D, a, B, c, X [K + 14], s22, 0xc33707d6 );
C = Gg (c, d, A, B, X [K + 3], S23, 0xf4d50d87 );
B = Gg (B, c, d, A, X [K + 8], S24, 0x455a14ed );
A = Gg (a, B, c, d, X [K + 13], S21, 0xa9e3e905 );
D = Gg (D, a, B, c, X [K + 2], s22, 0xfcefa3f8 );
C = Gg (c, d, A, B, X [K + 7], S23, 0x676f02d9 );
B = Gg (B, c, d, A, X [K + 12], S24, 0x8d2a4c8a );
A = HH (a, B, c, d, X [K + 5], s31, 0xfffa3942 );
D = HH (D, a, B, c, X [K + 8], s32, 0x8771f681 );
C = HH (c, d, A, B, X [K + 11], s33, 0x6d9d6122 );
B = HH (B, c, d, A, X [K + 14], s34, 0xfde5380c );
A = HH (a, B, c, d, X [k + 1], s31, 0xa4beea44 );
D = HH (D, a, B, c, X [K + 4], s32, 0x4bdecfa9 );
C = HH (c, d, A, B, X [K + 7], s33, 0xf6bb4b60 );
B = HH (B, c, d, A, X [K + 10], s34, 0xbebfbc70 );
A = HH (a, B, c, d, X [K + 13], s31, 0x289b7ec6 );
D = HH (D, a, B, c, X [K + 0], s32, 0xeaa127fa );
C = HH (c, d, A, B, X [K + 3], s33, 0xd4ef3085 );
B = HH (B, c, d, A, X [K + 6], s34, 0x4881d05 );
A = HH (a, B, c, d, X [K + 9], s31, 0xd9d4d039 );
D = HH (D, a, B, c, X [K + 12], s32, 0xe6db99e5 );
C = HH (c, d, A, B, X [K + 15], s33, 0x1fa27cf8 );
B = HH (B, c, d, A, X [K + 2], s34, 0xc4ac5665 );
A = II (a, B, c, d, X [K + 0], s41, 0xf4292244 );
D = II (D, a, B, c, X [K + 7], S42, 0x432aff97 );
C = II (c, d, A, B, X [K + 14], s43, 0xab9423a7 );
B = II (B, c, d, A, X [K + 5], s44, 0xfc93a039 );
A = II (a, B, c, d, X [K + 12], s41, 0x655b59c3 );
D = II (D, a, B, c, X [K + 3], S42, 0x8f0ccc92 );
C = II (c, d, A, B, X [K + 10], s43, 0xffeff47d );
B = II (B, c, d, A, X [k + 1], s44, 0x85845dd1 );
A = II (a, B, c, d, X [K + 8], s41, 0x6fa87e4f );
D = II (D, a, B, c, X [K + 15], S42, 0xfe2ce6e0 );
C = II (c, d, A, B, X [K + 6], s43, 0xa3014314 );
B = II (B, c, d, A, X [K + 13], s44, 0x4e0811a1 );
A = II (a, B, c, d, X [K + 4], s41, 0xf7537e82 );
D = II (D, a, B, c, X [K + 11], S42, 0xbd3af235 );
C = II (c, d, A, B, X [K + 2], s43, 0x2ad7d2bb );
B = II (B, c, d, A, X [K + 9], s44, 0xeb86d391 );
A = addunsigned (A, AA); B = addunsigned (B, BB); C = addunsigned (C, CC); D = addunsigned (D, DD );
}
// Step 5. output the 128 bit digest
VaR temp = wordtohex (A) + wordtohex (B) + wordtohex (c) + wordtohex (d );
Return temp. tolowercase ();
}
</SCRIPT>
<Input type = text id = myinput> <input type = text ondblclick = 'this. value = MD5 (myinput. value) '> <p> compared with the MD5 encryption implemented by Delphi, english numbers are encrypted with the same results, and Chinese characters are different, which may be related to the processing of Chinese characters. </P> <p> the function copyright statement is at the top.
</P>