JAVASCRIPT 常用JS加密编码算法

1、转：一：UTF8编码函数function URLEncode(Str)  if(Str=null|Str="")    return ""  var newStr=""  function toCase(sStr)    return sStr.toString(16).toUpperCase();    &

2、#160; for(var i=0,icode,len=Str.length;i<len;i+)    icode=Str.charCodeAt(i);    if( icode<0x10)      newStr+="%0"+icode.toString(16).toUpperCase();    else if(icode<0x80) 

3、     if(icode=0x20)        newStr+="+"      else if(icode>=0x30&&icode<=0x39)|(icode>=0x41&&icode<=0x5A)|(icode>=0x61&&icode<=0x7A)   

4、;     newStr+=Str.charAt(i);      else        newStr+="%"+toCase(icode);          else if(icode<0x800)      

5、;newStr+="%"+toCase(0xC0+(icode>>6);      newStr+="%"+toCase(0x80+icode%0x40);          else      newStr+="%"+toCase(0xE0+(icode>>12);  &#

6、160;   newStr+="%"+toCase(0x80+(icode>>6)%0x40);      newStr+="%"+toCase(0x80+icode%0x40);            return newStr;  二：Base64编码,解码函数var base64Encode

7、Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" var base64DecodeChars = new Array(     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 

8、;-1, -1, -1,     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,     -1, -1, -1, -1, -1, -1, -1, -1, -1, 

9、;-1, -1, 62, -1, -1, -1, 63,     52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1,     -1, 0, 1, 2, 3, 4,&

10、#160;5, 6, 7, 8, 9, 10, 11, 12, 13, 14,     15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,     -1, 26, 

11、27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,     41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1); funct

12、ion base64encode(str)      var out, i, len;     var c1, c2, c3;     len = str.length;     i = 0;     out = ""  

13、;   while(i < len)      c1 = str.charCodeAt(i+) & 0xff;     if(i = len)              out += base64EncodeChar

14、s.charAt(c1 >> 2);         out += base64EncodeChars.charAt(c1 & 0x3) << 4);         out += "="      

15、0;  break;          c2 = str.charCodeAt(i+);     if(i = len)              out += base64EncodeChars.charAt(c1 &

16、gt;> 2);         out += base64EncodeChars.charAt(c1 & 0x3)<< 4) | (c2 & 0xF0) >> 4);         out += base64EncodeChars

17、.charAt(c2 & 0xF) << 2);         out += "="         break;          c3 = str.charCodeAt(i+); &#

18、160;   out += base64EncodeChars.charAt(c1 >> 2);     out += base64EncodeChars.charAt(c1 & 0x3)<< 4) | (c2 & 0xF0) >> 4);     out 

19、+= base64EncodeChars.charAt(c2 & 0xF) << 2) | (c3 & 0xC0) >>6);     out += base64EncodeChars.charAt(c3 & 0x3F);          return

20、0;out;  function base64decode(str)      var c1, c2, c3, c4;     var i, len, out;     len = str.length;     i = 0;     out =&#

21、160;""     while(i < len)      /* c1 */     do          c1 = base64DecodeCharsstr.charCodeAt(i+) & 0xff;  &#

22、160;   while(i < len && c1 = -1);     if(c1 = -1)         break;     /* c2 */     do   &#

23、160;      c2 = base64DecodeCharsstr.charCodeAt(i+) & 0xff;      while(i < len && c2 = -1);     if(c2 = -1)     

24、0;   break;     out += String.fromCharCode(c1 << 2) | (c2 & 0x30) >> 4);     /* c3 */     do       

25、   c3 = str.charCodeAt(i+) & 0xff;         if(c3 = 61)         return out;         c3 = base64DecodeC

26、harsc3;      while(i < len && c3 = -1);     if(c3 = -1)         break;     out += String.fromCharCode(c2 &

27、; 0XF) << 4) | (c3 & 0x3C) >> 2);     /* c4 */     do          c4 = str.charCodeAt(i+) & 0xff;  

28、;       if(c4 = 61)         return out;         c4 = base64DecodeCharsc4;      while(i < len &&

29、; c4 = -1);     if(c4 = -1)         break;     out += String.fromCharCode(c3 & 0x03) << 6) | c4);     

30、60;    return out;  function utf16to8(str)      var out, i, len, c;     out = ""     len = str.length;     for(i = 

31、0; i < len; i+)      c = str.charCodeAt(i);     if (c >= 0x0001) && (c <= 0x007F)          out += str.charAt(i);  

32、;    else if (c > 0x07FF)          out += String.fromCharCode(0xE0 | (c >> 12) & 0x0F);         out += Stri

33、ng.fromCharCode(0x80 | (c >> 6) & 0x3F);         out += String.fromCharCode(0x80 | (c >> 0) & 0x3F);      else    &

34、#160;     out += String.fromCharCode(0xC0 | (c >> 6) & 0x1F);         out += String.fromCharCode(0x80 | (c >> 0) & 0x3F); 

35、60;             return out;  function utf8to16(str)      var out, i, len, c;     var char2, char3;     out = ""

36、;     len = str.length;     i = 0;     while(i < len)      c = str.charCodeAt(i+);     switch(c >> 4)  

37、60;         case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:         / 0xxxxxxx      

38、   out += str.charAt(i-1);         break;       case 12: case 13:         / 110x xxxx 10xx xxxx      

39、;   char2 = str.charCodeAt(i+);         out += String.fromCharCode(c & 0x1F) << 6) | (char2 & 0x3F);         break; 

40、      case 14:         / 1110 xxxx 10xx xxxx 10xx xxxx         char2 = str.charCodeAt(i+);         char3 =

41、0;str.charCodeAt(i+);         out += String.fromCharCode(c & 0x0F) << 12) |                      

42、60; (char2 & 0x3F) << 6) |                        (char3 & 0x3F) << 0);      

43、60;  break;               return out;  function doit()      var f = document.f     f.output.value = base64encode(utf16to

44、8(f.source.value)     f.decode.value = utf8to16(base64decode(f.output.value) 三：MD5/* * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message * Digest Algorithm, as defined in RFC 1321. * Version 2.1 Copyright (C) Paul Johnston 1

45、999 - 2002. * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet * Distributed under the BSD License * See .uk/crypt/md5 for more info. */* * Configurable variables. You may need to tweak these to be compatible with * the server-side, but the

46、 defaults work in most cases. */var hexcase = 0;  /* hex output format. 0 - lowercase; 1 - uppercase        */var b64pad  = "" /* base-64 pad character. "=" for strict RFC com

47、pliance   */var chrsz   = 8;  /* bits per input character. 8 - ASCII; 16 - Unicode      */* * These are the functions you'll usually want to call * They take string arguments and return either hex or b

48、ase-64 encoded strings */function hex_md5(s) return binl2hex(core_md5(str2binl(s), s.length * chrsz);function b64_md5(s) return binl2b64(core_md5(str2binl(s), s.length * chrsz);function str_md5(s) return binl2str(core_md5(str2binl

49、(s), s.length * chrsz);function hex_hmac_md5(key, data)  return binl2hex(core_hmac_md5(key, data); function b64_hmac_md5(key, data)  return binl2b64(core_hmac_md5(key, data); function str_hmac_md5(key, data)  return binl2str(core_hmac_md5(key, d

50、ata); /* * Perform a simple self-test to see if the VM is working */function md5_vm_test()  return hex_md5("abc") = "900150983cd24fb0d6963f7d28e17f72"/* * Calculate the MD5 of an array of little-endian words, and a bit length */fu

51、nction core_md5(x, len)  /* append padding */  xlen >> 5 |= 0x80 << (len) % 32);  x(len + 64) >>> 9) << 4) + 14 = len;  var 

52、;a =  1732584193;  var b = -271733879;  var c = -1732584194;  var d =  271733878;  for(var i = 0; i < x.length; i += 16)      v

53、ar olda = a;    var oldb = b;    var oldc = c;    var oldd = d;    a = md5_ff(a, b, c, d, xi+ 0, 7 , -680876936);   

54、; d = md5_ff(d, a, b, c, xi+ 1, 12, -389564586);    c = md5_ff(c, d, a, b, xi+ 2, 17,  606105819);    b = md5_ff(b, c, d, a, xi+ 3, 22, -1044525330);    a&

55、#160;= md5_ff(a, b, c, d, xi+ 4, 7 , -176418897);    d = md5_ff(d, a, b, c, xi+ 5, 12,  1200080426);    c = md5_ff(c, d, a, b, xi+ 6, 17, -1473231341);    b

56、0;= md5_ff(b, c, d, a, xi+ 7, 22, -45705983);    a = md5_ff(a, b, c, d, xi+ 8, 7 ,  1770035416);    d = md5_ff(d, a, b, c, xi+ 9, 12, -1958414417);    c =&

57、#160;md5_ff(c, d, a, b, xi+10, 17, -42063);    b = md5_ff(b, c, d, a, xi+11, 22, -1990404162);    a = md5_ff(a, b, c, d, xi+12, 7 ,  1804603682);    d = md5_ff(d, a, b, c

58、, xi+13, 12, -40341101);    c = md5_ff(c, d, a, b, xi+14, 17, -1502002290);    b = md5_ff(b, c, d, a, xi+15, 22,  1236535329);    a = md5_gg(a, b, c, d, xi+ 1, 5

59、0;, -165796510);    d = md5_gg(d, a, b, c, xi+ 6, 9 , -1069501632);    c = md5_gg(c, d, a, b, xi+11, 14,  643717713);    b = md5_gg(b, c, d, a, xi+ 0, 20, 

60、-373897302);    a = md5_gg(a, b, c, d, xi+ 5, 5 , -701558691);    d = md5_gg(d, a, b, c, xi+10, 9 ,  38016083);    c = md5_gg(c, d, a, b, xi+15, 14, -660478335)

61、;    b = md5_gg(b, c, d, a, xi+ 4, 20, -405537848);    a = md5_gg(a, b, c, d, xi+ 9, 5 ,  568446438);    d = md5_gg(d, a, b, c, xi+14, 9 , -1019803690);

62、60;   c = md5_gg(c, d, a, b, xi+ 3, 14, -187363961);    b = md5_gg(b, c, d, a, xi+ 8, 20,  1163531501);    a = md5_gg(a, b, c, d, xi+13, 5 , -1444681467);  

63、;  d = md5_gg(d, a, b, c, xi+ 2, 9 , -51403784);    c = md5_gg(c, d, a, b, xi+ 7, 14,  1735328473);    b = md5_gg(b, c, d, a, xi+12, 20, -1926607734);   &#

64、160;a = md5_hh(a, b, c, d, xi+ 5, 4 , -378558);    d = md5_hh(d, a, b, c, xi+ 8, 11, -2022574463);    c = md5_hh(c, d, a, b, xi+11, 16,  1839030562);    b 

65、= md5_hh(b, c, d, a, xi+14, 23, -35309556);    a = md5_hh(a, b, c, d, xi+ 1, 4 , -1530992060);    d = md5_hh(d, a, b, c, xi+ 4, 11,  1272893353);    c = md

66、5_hh(c, d, a, b, xi+ 7, 16, -155497632);    b = md5_hh(b, c, d, a, xi+10, 23, -1094730640);    a = md5_hh(a, b, c, d, xi+13, 4 ,  681279174);    d = md5_hh(d, a, b,

67、c, xi+ 0, 11, -358537222);    c = md5_hh(c, d, a, b, xi+ 3, 16, -722521979);    b = md5_hh(b, c, d, a, xi+ 6, 23,  76029189);    a = md5_hh(a, b, c, d, xi+ 

68、;9, 4 , -640364487);    d = md5_hh(d, a, b, c, xi+12, 11, -421815835);    c = md5_hh(c, d, a, b, xi+15, 16,  530742520);    b = md5_hh(b, c, d, a, xi+ 2, 23,

69、60;-995338651);    a = md5_ii(a, b, c, d, xi+ 0, 6 , -198630844);    d = md5_ii(d, a, b, c, xi+ 7, 10,  1126891415);    c = md5_ii(c, d, a, b, xi+14, 15, -14163

70、54905);    b = md5_ii(b, c, d, a, xi+ 5, 21, -57434055);    a = md5_ii(a, b, c, d, xi+12, 6 ,  1700485571);    d = md5_ii(d, a, b, c, xi+ 3, 10, -1894986606);&#

71、160;   c = md5_ii(c, d, a, b, xi+10, 15, -1051523);    b = md5_ii(b, c, d, a, xi+ 1, 21, -2054922799);    a = md5_ii(a, b, c, d, xi+ 8, 6 ,  1873313359);  

72、  d = md5_ii(d, a, b, c, xi+15, 10, -30611744);    c = md5_ii(c, d, a, b, xi+ 6, 15, -1560198380);    b = md5_ii(b, c, d, a, xi+13, 21,  1309151649);    a 

73、= md5_ii(a, b, c, d, xi+ 4, 6 , -145523070);    d = md5_ii(d, a, b, c, xi+11, 10, -1120210379);    c = md5_ii(c, d, a, b, xi+ 2, 15,  718787259);    b = md

74、5_ii(b, c, d, a, xi+ 9, 21, -343485551);    a = safe_add(a, olda);    b = safe_add(b, oldb);    c = safe_add(c, oldc);    d = safe_add(d, oldd);   

75、60;return Array(a, b, c, d);/* * These functions implement the four basic operations the algorithm uses. */function md5_cmn(q, a, b, x, s, t)  return safe_add(bit_rol(safe_add(safe_add(a, q), safe_add(x, t), s),b);function md5_ff(a, b, c, d, x, s, t) 

76、0;return md5_cmn(b & c) | (b) & d), a, b, x, s, t);function md5_gg(a, b, c, d, x, s, t)  return md5_cmn(b & d) | (c & (d), a, b, x, s, t);function md5_hh(a, b, c, d, x, s, t)  return&#

77、160;md5_cmn(b  c  d, a, b, x, s, t);function md5_ii(a, b, c, d, x, s, t)  return md5_cmn(c  (b | (d), a, b, x, s, t);/* * Calculate the HMAC-MD5, of a key and some data */function core_hmac_md5(key, data)  var 

78、bkey = str2binl(key);  if(bkey.length > 16) bkey = core_md5(bkey, key.length * chrsz);  var ipad = Array(16), opad = Array(16);  for(var i = 0; i < 16; i+)   &

79、#160;  ipadi = bkeyi  0x36363636;    opadi = bkeyi  0x5C5C5C5C;    var hash = core_md5(ipad.concat(str2binl(data), 512 + data.length * chrsz);  return core

80、_md5(opad.concat(hash), 512 + 128);/* * Add integers, wrapping at 232. This uses 16-bit operations internally * to work around bugs in some JS interpreters. */function safe_add(x, y)  var lsw = (x & 0xFFFF) + (y 

81、;& 0xFFFF);  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);  return (msw << 16) | (lsw & 0xFFFF);/* * Bitwise rotate a 32-bit number to th

82、e left. */function bit_rol(num, cnt)  return (num << cnt) | (num >>> (32 - cnt);/* * Convert a string to an array of little-endian words * If chrsz is ASCII, characters >255 have their hi-byte silently ignor

83、ed. */function str2binl(str)  var bin = Array();  var mask = (1 << chrsz) - 1;  for(var i = 0; i < str.length * chrsz; i += chrsz)    bi

84、ni>>5 |= (str.charCodeAt(i / chrsz) & mask) << (i%32);  return bin;/* * Convert an array of little-endian words to a string */function binl2str(bin)  var str = ""  var&#

85、160;mask = (1 << chrsz) - 1;  for(var i = 0; i < bin.length * 32; i += chrsz)    str += String.fromCharCode(bini>>5 >>> (i % 32) &&#

86、160;mask);  return str;/* * Convert an array of little-endian words to a hex string. */function binl2hex(binarray)  var hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef"  var str&#

87、160;= ""  for(var i = 0; i < binarray.length * 4; i+)      str += hex_tab.charAt(binarrayi>>2 >> (i%4)*8+4) & 0xF) +      

88、0;    hex_tab.charAt(binarrayi>>2 >> (i%4)*8  ) & 0xF);    return str;/* * Convert an array of little-endian words to a base-64 string */function binl2b64(binarray)  var tab 

89、= "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"  var str = ""  for(var i = 0; i < binarray.length * 4; i += 3)      var triplet =&#

90、160;(binarrayi   >> 2 >> 8 * ( i   %4) & 0xFF) << 16)                | (binarrayi+1 >> 2 >>

91、 8 * (i+1)%4) & 0xFF) << 8 )                |  (binarrayi+2 >> 2 >> 8 * (i+2)%4) & 0xFF);  

92、60; for(var j = 0; j < 4; j+)          if(i * 8 + j * 6 > binarray.length * 32) str += b64pad;      else str +=

93、60;tab.charAt(triplet >> 6*(3-j) & 0x3F);        return str;MD4算法/* * A JavaScript implementation of the RSA Data Security, Inc. MD4 Message * Digest Algorithm, as defined in RFC 1320. * Version 2.1 Copyright (

94、C) Jerrad Pierce, Paul Johnston 1999 - 2002. * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet * Distributed under the BSD License * See .uk/crypt/md5 for more info. */* * Configurable variables. You may need to tweak these to be compatible wit

95、h * the server-side, but the defaults work in most cases. */var hexcase = 0;  /* hex output format. 0 - lowercase; 1 - uppercase        */var b64pad  = "" /* base-64 pad character.

96、 "=" for strict RFC compliance   */var chrsz   = 8;  /* bits per input character. 8 - ASCII; 16 - Unicode      */* * These are the functions you'll usually want to call */function hex_md

97、4(s) return binl2hex(core_md4(str2binl(s), s.length * chrsz);function b64_md4(s) return binl2b64(core_md4(str2binl(s), s.length * chrsz);function str_md4(s) return binl2str(core_md4(str2binl(s), s.length * chrsz);function hex

98、_hmac_md4(key, data)  return binl2hex(core_hmac_md4(key, data); function b64_hmac_md4(key, data)  return binl2b64(core_hmac_md4(key, data); function str_hmac_md4(key, data)  return binl2str(core_hmac_md4(key, data); /*  * Perform a simple self-test t

99、o see if the VM is working  */function md4_vm_test()  return hex_md4("abc") = "a448017aaf21d8525fc10ae87aa6729d"/* * Calculate the MD4 of an array of little-endian words, and a bit length */function core_md4(x, len) 

100、0;/* append padding */  xlen >> 5 |= 0x80 << (len % 32);  x(len + 64) >>> 9) << 4) + 14 = len;    var a =  173258

101、4193;  var b = -271733879;  var c = -1732584194;  var d =  271733878;  for(var i = 0; i < x.length; i += 16)      var olda = a;

102、    var oldb = b;    var oldc = c;    var oldd = d;    a = md4_ff(a, b, c, d, xi+ 0, 3 );    d = md4_ff(d, a, b, c, xi+&

103、#160;1, 7 );    c = md4_ff(c, d, a, b, xi+ 2, 11);    b = md4_ff(b, c, d, a, xi+ 3, 19);    a = md4_ff(a, b, c, d, xi+ 4, 3 );    d = m

104、d4_ff(d, a, b, c, xi+ 5, 7 );    c = md4_ff(c, d, a, b, xi+ 6, 11);    b = md4_ff(b, c, d, a, xi+ 7, 19);    a = md4_ff(a, b, c, d, xi+ 8, 3 );   

105、; d = md4_ff(d, a, b, c, xi+ 9, 7 );    c = md4_ff(c, d, a, b, xi+10, 11);    b = md4_ff(b, c, d, a, xi+11, 19);    a = md4_ff(a, b, c, d, xi+12, 3 ); 

106、0;  d = md4_ff(d, a, b, c, xi+13, 7 );    c = md4_ff(c, d, a, b, xi+14, 11);    b = md4_ff(b, c, d, a, xi+15, 19);    a = md4_gg(a, b, c, d, xi+ 0, 3 );

107、60;   d = md4_gg(d, a, b, c, xi+ 4, 5 );    c = md4_gg(c, d, a, b, xi+ 8, 9 );    b = md4_gg(b, c, d, a, xi+12, 13);    a = md4_gg(a, b, c, d, xi+

108、0;1, 3 );    d = md4_gg(d, a, b, c, xi+ 5, 5 );    c = md4_gg(c, d, a, b, xi+ 9, 9 );    b = md4_gg(b, c, d, a, xi+13, 13);    a = md4_

109、gg(a, b, c, d, xi+ 2, 3 );    d = md4_gg(d, a, b, c, xi+ 6, 5 );    c = md4_gg(c, d, a, b, xi+10, 9 );    b = md4_gg(b, c, d, a, xi+14, 13);    a

110、 = md4_gg(a, b, c, d, xi+ 3, 3 );    d = md4_gg(d, a, b, c, xi+ 7, 5 );    c = md4_gg(c, d, a, b, xi+11, 9 );    b = md4_gg(b, c, d, a, xi+15, 13);    a = md4_hh(a, b, c, d, xi+ 0, 3 );    d = md4_