常用JS加密编码算法

最新推荐文章于 2024-03-27 19:56:01 发布

dingyiban9011

最新推荐文章于 2024-03-27 19:56:01 发布

阅读量115

点赞数

原文链接：http://www.cnblogs.com/Liq-Blog/archive/2012/11/27/2790310.html

版权

转：http://bbs.csdn.net/u/20111025/14/7c85279a-fc6e-4672-9aa0-0fd8c1894d0a.html

一：UTF8编码函数

二：Base64编码,解码函数

三：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 1999 - 2002.
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
* Distributed under the BSD License
* See http://pajhome.org.uk/crypt/md5 for more info.
*/

/*
* Configurable variables. You may need to tweak these to be compatible with
* 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. "=" 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
* They take string arguments and return either hex or base-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(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, data)); }

/*
* 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
*/
function core_md5(x, len)
{
   /* append padding */
  x[len >> 5 ] |= 0x80 << ((len) % 32 );
  x[(((len + 64 ) >>> 9 ) << 4 ) + 14 ] = len;

   var a =    1732584193 ;
   var b = - 271733879 ;
   var c = - 1732584194 ;
   var d =    271733878 ;

   for ( var i = 0 ; i < x.length; i += 16 )
  {
     var olda = a;
     var oldb = b;
     var oldc = c;
     var oldd = d;

    a = md5_ff(a, b, c, d, x[i + 0 ], 7 , - 680876936 );
    d = md5_ff(d, a, b, c, x[i + 1 ], 12 , - 389564586 );
    c = md5_ff(c, d, a, b, x[i + 2 ], 17 ,   606105819 );
    b = md5_ff(b, c, d, a, x[i + 3 ], 22 , - 1044525330 );
    a = md5_ff(a, b, c, d, x[i + 4 ], 7 , - 176418897 );
    d = md5_ff(d, a, b, c, x[i + 5 ], 12 ,   1200080426 );
    c = md5_ff(c, d, a, b, x[i + 6 ], 17 , - 1473231341 );
    b = md5_ff(b, c, d, a, x[i + 7 ], 22 , - 45705983 );
    a = md5_ff(a, b, c, d, x[i + 8 ], 7 ,   1770035416 );
    d = md5_ff(d, a, b, c, x[i + 9 ], 12 , - 1958414417 );
    c = md5_ff(c, d, a, b, x[i + 10 ], 17 , - 42063 );
    b = md5_ff(b, c, d, a, x[i + 11 ], 22 , - 1990404162 );
    a = md5_ff(a, b, c, d, x[i + 12 ], 7 ,   1804603682 );
    d = md5_ff(d, a, b, c, x[i + 13 ], 12 , - 40341101 );
    c = md5_ff(c, d, a, b, x[i + 14 ], 17 , - 1502002290 );
    b = md5_ff(b, c, d, a, x[i + 15 ], 22 ,   1236535329 );

    a = md5_gg(a, b, c, d, x[i + 1 ], 5 , - 165796510 );
    d = md5_gg(d, a, b, c, x[i + 6 ], 9 , - 1069501632 );
    c = md5_gg(c, d, a, b, x[i + 11 ], 14 ,   643717713 );
    b = md5_gg(b, c, d, a, x[i + 0 ], 20 , - 373897302 );
    a = md5_gg(a, b, c, d, x[i + 5 ], 5 , - 701558691 );
    d = md5_gg(d, a, b, c, x[i + 10 ], 9 ,   38016083 );
    c = md5_gg(c, d, a, b, x[i + 15 ], 14 , - 660478335 );
    b = md5_gg(b, c, d, a, x[i + 4 ], 20 , - 405537848 );
    a = md5_gg(a, b, c, d, x[i + 9 ], 5 ,   568446438 );
    d = md5_gg(d, a, b, c, x[i + 14 ], 9 , - 1019803690 );
    c = md5_gg(c, d, a, b, x[i + 3 ], 14 , - 187363961 );
    b = md5_gg(b, c, d, a, x[i + 8 ], 20 ,   1163531501 );
    a = md5_gg(a, b, c, d, x[i + 13 ], 5 , - 1444681467 );
    d = md5_gg(d, a, b, c, x[i + 2 ], 9 , - 51403784 );
    c = md5_gg(c, d, a, b, x[i + 7 ], 14 ,   1735328473 );
    b = md5_gg(b, c, d, a, x[i + 12 ], 20 , - 1926607734 );

    a = md5_hh(a, b, c, d, x[i + 5 ], 4 , - 378558 );
    d = md5_hh(d, a, b, c, x[i + 8 ], 11 , - 2022574463 );
    c = md5_hh(c, d, a, b, x[i + 11 ], 16 ,   1839030562 );
    b = md5_hh(b, c, d, a, x[i + 14 ], 23 , - 35309556 );
    a = md5_hh(a, b, c, d, x[i + 1 ], 4 , - 1530992060 );
    d = md5_hh(d, a, b, c, x[i + 4 ], 11 ,   1272893353 );
    c = md5_hh(c, d, a, b, x[i + 7 ], 16 , - 155497632 );
    b = md5_hh(b, c, d, a, x[i + 10 ], 23 , - 1094730640 );
    a = md5_hh(a, b, c, d, x[i + 13 ], 4 ,   681279174 );
    d = md5_hh(d, a, b, c, x[i + 0 ], 11 , - 358537222 );
    c = md5_hh(c, d, a, b, x[i + 3 ], 16 , - 722521979 );
    b = md5_hh(b, c, d, a, x[i + 6 ], 23 ,   76029189 );
    a = md5_hh(a, b, c, d, x[i + 9 ], 4 , - 640364487 );
    d = md5_hh(d, a, b, c, x[i + 12 ], 11 , - 421815835 );
    c = md5_hh(c, d, a, b, x[i + 15 ], 16 ,   530742520 );
    b = md5_hh(b, c, d, a, x[i + 2 ], 23 , - 995338651 );

    a = md5_ii(a, b, c, d, x[i + 0 ], 6 , - 198630844 );
    d = md5_ii(d, a, b, c, x[i + 7 ], 10 ,   1126891415 );
    c = md5_ii(c, d, a, b, x[i + 14 ], 15 , - 1416354905 );
    b = md5_ii(b, c, d, a, x[i + 5 ], 21 , - 57434055 );
    a = md5_ii(a, b, c, d, x[i + 12 ], 6 ,   1700485571 );
    d = md5_ii(d, a, b, c, x[i + 3 ], 10 , - 1894986606 );
    c = md5_ii(c, d, a, b, x[i + 10 ], 15 , - 1051523 );
    b = md5_ii(b, c, d, a, x[i + 1 ], 21 , - 2054922799 );
    a = md5_ii(a, b, c, d, x[i + 8 ], 6 ,   1873313359 );
    d = md5_ii(d, a, b, c, x[i + 15 ], 10 , - 30611744 );
    c = md5_ii(c, d, a, b, x[i + 6 ], 15 , - 1560198380 );
    b = md5_ii(b, c, d, a, x[i + 13 ], 21 ,   1309151649 );
    a = md5_ii(a, b, c, d, x[i + 4 ], 6 , - 145523070 );
    d = md5_ii(d, a, b, c, x[i + 11 ], 10 , - 1120210379 );
    c = md5_ii(c, d, a, b, x[i + 2 ], 15 ,   718787259 );
    b = md5_ii(b, c, d, a, x[i + 9 ], 21 , - 343485551 );

    a = safe_add(a, olda);
    b = safe_add(b, oldb);
    c = safe_add(c, oldc);
    d = safe_add(d, oldd);
  }
   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)
{
   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 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 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 ++ )
  {
    ipad[i] = bkey[i] ^ 0x36363636 ;
    opad[i] = bkey[i] ^ 0x5C5C5C5C ;
  }

   var hash = core_md5(ipad.concat(str2binl(data)), 512 + data.length * chrsz);
   return core_md5(opad.concat(hash), 512 + 128 );
}

/*
* Add integers, wrapping at 2^32. This uses 16-bit operations internally
* to work around bugs in some JS interpreters.
*/
function safe_add(x, y)
{
   var lsw = (x & 0xFFFF ) + (y & 0xFFFF );
   var msw = (x >> 16 ) + (y >> 16 ) + (lsw >> 16 );
   return (msw << 16 ) | (lsw & 0xFFFF );
}

/*
* Bitwise rotate a 32-bit number to the 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 ignored.
*/
function str2binl(str)
{
   var bin = Array();
   var mask = ( 1 << chrsz) - 1 ;
   for ( var i = 0 ; i < str.length * chrsz; i += chrsz)
    bin[i >> 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 mask = ( 1 << chrsz) - 1 ;
   for ( var i = 0 ; i < bin.length * 32 ; i += chrsz)
    str += String.fromCharCode((bin[i >> 5 ] >>> (i % 32 )) & 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 = "" ;
   for ( var i = 0 ; i < binarray.length * 4 ; i ++ )
  {
    str += hex_tab.charAt((binarray[i >> 2 ] >> ((i % 4 ) * 8 + 4 )) & 0xF ) +
           hex_tab.charAt((binarray[i >> 2 ] >> ((i % 4 ) * 8   )) & 0xF );
  }
   return str;
}

/*
* Convert an array of little-endian words to a base-64 string
*/
function binl2b64(binarray)
{
   var tab = " ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/ " ;
   var str = "" ;
   for ( var i = 0 ; i < binarray.length * 4 ; i += 3 )
  {
     var triplet = (((binarray[i    >> 2 ] >> 8 * ( i    % 4 )) & 0xFF ) << 16 )
                 | (((binarray[i + 1 >> 2 ] >> 8 * ((i + 1 ) % 4 )) & 0xFF ) << 8 )
                 |   ((binarray[i + 2 >> 2 ] >> 8 * ((i + 2 ) % 4 )) & 0xFF );
     for ( var j = 0 ; j < 4 ; j ++ )
    {
       if (i * 8 + j * 6 > binarray.length * 32 ) str += b64pad;
       else str += 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 (C) Jerrad Pierce, Paul Johnston 1999 - 2002.
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
* Distributed under the BSD License
* See http://pajhome.org.uk/crypt/md5 for more info.
*/

/*
* Configurable variables. You may need to tweak these to be compatible with
* 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. "=" 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_md4(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_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 to 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)
{
   /* append padding */
  x[len >> 5 ] |= 0x80 << (len % 32 );
  x[(((len + 64 ) >>> 9 ) << 4 ) + 14 ] = len;

   var a =    1732584193 ;
   var b = - 271733879 ;
   var c = - 1732584194 ;
   var d =    271733878 ;

   for ( var i = 0 ; i < x.length; i += 16 )
  {
     var olda = a;
     var oldb = b;
     var oldc = c;
     var oldd = d;

    a = md4_ff(a, b, c, d, x[i + 0 ], 3 );
    d = md4_ff(d, a, b, c, x[i + 1 ], 7 );
    c = md4_ff(c, d, a, b, x[i + 2 ], 11 );
    b = md4_ff(b, c, d, a, x[i + 3 ], 19 );
    a = md4_ff(a, b, c, d, x[i + 4 ], 3 );
    d = md4_ff(d, a, b, c, x[i + 5 ], 7 );
    c = md4_ff(c, d, a, b, x[i + 6 ], 11 );
    b = md4_ff(b, c, d, a, x[i + 7 ], 19 );
    a = md4_ff(a, b, c, d, x[i + 8 ], 3 );
    d = md4_ff(d, a, b, c, x[i + 9 ], 7 );
    c = md4_ff(c, d, a, b, x[i + 10 ], 11 );
    b = md4_ff(b, c, d, a, x[i + 11 ], 19 );
    a = md4_ff(a, b, c, d, x[i + 12 ], 3 );
    d = md4_ff(d, a, b, c, x[i + 13 ], 7 );
    c = md4_ff(c, d, a, b, x[i + 14 ], 11 );
    b = md4_ff(b, c, d, a, x[i + 15 ], 19 );

    a = md4_gg(a, b, c, d, x[i + 0 ], 3 );
    d = md4_gg(d, a, b, c, x[i + 4 ], 5 );
    c = md4_gg(c, d, a, b, x[i + 8 ], 9 );
    b = md4_gg(b, c, d, a, x[i + 12 ], 13 );
    a = md4_gg(a, b, c, d, x[i + 1 ], 3 );
    d = md4_gg(d, a, b, c, x[i + 5 ], 5 );
    c = md4_gg(c, d, a, b, x[i + 9 ], 9 );
    b = md4_gg(b, c, d, a, x[i + 13 ], 13 );
    a = md4_gg(a, b, c, d, x[i + 2 ], 3 );
    d = md4_gg(d, a, b, c, x[i + 6 ], 5 );
    c = md4_gg(c, d, a, b, x[i + 10 ], 9 );
    b = md4_gg(b, c, d, a, x[i + 14 ], 13 );
    a = md4_gg(a, b, c, d, x[i + 3 ], 3 );
    d = md4_gg(d, a, b, c, x[i + 7 ], 5 );
    c = md4_gg(c, d, a, b, x[i + 11 ], 9 );
    b = md4_gg(b, c, d, a, x[i + 15 ], 13 );

    a = md4_hh(a, b, c, d, x[i + 0 ], 3 );
    d = md4_hh(d, a, b, c, x[i + 8 ], 9 );
    c = md4_hh(c, d, a, b, x[i + 4 ], 11 );
    b = md4_hh(b, c, d, a, x[i + 12 ], 15 );
    a = md4_hh(a, b, c, d, x[i + 2 ], 3 );
    d = md4_hh(d, a, b, c, x[i + 10 ], 9 );
    c = md4_hh(c, d, a, b, x[i + 6 ], 11 );
    b = md4_hh(b, c, d, a, x[i + 14 ], 15 );
    a = md4_hh(a, b, c, d, x[i + 1 ], 3 );
    d = md4_hh(d, a, b, c, x[i + 9 ], 9 );
    c = md4_hh(c, d, a, b, x[i + 5 ], 11 );
    b = md4_hh(b, c, d, a, x[i + 13 ], 15 );
    a = md4_hh(a, b, c, d, x[i + 3 ], 3 );
    d = md4_hh(d, a, b, c, x[i + 11 ], 9 );
    c = md4_hh(c, d, a, b, x[i + 7 ], 11 );
    b = md4_hh(b, c, d, a, x[i + 15 ], 15 );

    a = safe_add(a, olda);
    b = safe_add(b, oldb);
    c = safe_add(c, oldc);
    d = safe_add(d, oldd);

  }
   return Array(a, b, c, d);

}

/*
* These functions implement the basic operation for each round of the
* algorithm.
*/
function md4_cmn(q, a, b, x, s, t)
{
   return safe_add(rol(safe_add(safe_add(a, q), safe_add(x, t)), s), b);
}
function md4_ff(a, b, c, d, x, s)
{
   return md4_cmn((b & c) | (( ~ b) & d), a, 0 , x, s, 0 );
}
function md4_gg(a, b, c, d, x, s)
{
   return md4_cmn((b & c) | (b & d) | (c & d), a, 0 , x, s, 1518500249 );
}
function md4_hh(a, b, c, d, x, s)
{
   return md4_cmn(b ^ c ^ d, a, 0 , x, s, 1859775393 );
}

/*
* Calculate the HMAC-MD4, of a key and some data
*/
function core_hmac_md4(key, data)
{
   var bkey = str2binl(key);
   if (bkey.length > 16 ) bkey = core_md4(bkey, key.length * chrsz);

   var ipad = Array( 16 ), opad = Array( 16 );
   for ( var i = 0 ; i < 16 ; i ++ )
  {
    ipad[i] = bkey[i] ^ 0x36363636 ;
    opad[i] = bkey[i] ^ 0x5C5C5C5C ;
  }

   var hash = core_md4(ipad.concat(str2binl(data)), 512 + data.length * chrsz);
   return core_md4(opad.concat(hash), 512 + 128 );
}

/*
* Add integers, wrapping at 2^32. This uses 16-bit operations internally
* to work around bugs in some JS interpreters.
*/
function safe_add(x, y)
{
   var lsw = (x & 0xFFFF ) + (y & 0xFFFF );
   var msw = (x >> 16 ) + (y >> 16 ) + (lsw >> 16 );
   return (msw << 16 ) | (lsw & 0xFFFF );
}

/*
* Bitwise rotate a 32-bit number to the left.
*/
function 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 ignored.
*/
function str2binl(str)
{
   var bin = Array();
   var mask = ( 1 << chrsz) - 1 ;
   for ( var i = 0 ; i < str.length * chrsz; i += chrsz)
    bin[i >> 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 mask = ( 1 << chrsz) - 1 ;
   for ( var i = 0 ; i < bin.length * 32 ; i += chrsz)
    str += String.fromCharCode((bin[i >> 5 ] >>> (i % 32 )) & 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 = "" ;
   for ( var i = 0 ; i < binarray.length * 4 ; i ++ )
  {
    str += hex_tab.charAt((binarray[i >> 2 ] >> ((i % 4 ) * 8 + 4 )) & 0xF ) +
           hex_tab.charAt((binarray[i >> 2 ] >> ((i % 4 ) * 8   )) & 0xF );
  }
   return str;
}

/*
* Convert an array of little-endian words to a base-64 string
*/
function binl2b64(binarray)
{
   var tab = " ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/ " ;
   var str = "" ;
   for ( var i = 0 ; i < binarray.length * 4 ; i += 3 )
  {
     var triplet = (((binarray[i    >> 2 ] >> 8 * ( i    % 4 )) & 0xFF ) << 16 )
                 | (((binarray[i + 1 >> 2 ] >> 8 * ((i + 1 ) % 4 )) & 0xFF ) << 8 )
                 |   ((binarray[i + 2 >> 2 ] >> 8 * ((i + 2 ) % 4 )) & 0xFF );
     for ( var j = 0 ; j < 4 ; j ++ )
    {
       if (i * 8 + j * 6 > binarray.length * 32 ) str += b64pad;
       else str += tab.charAt((triplet >> 6 * ( 3 - j)) & 0x3F );
    }
  }
   return str;
}

SHA1算法

/*
* A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined
* in FIPS PUB 180-1
* Version 2.1a Copyright Paul Johnston 2000 - 2002.
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
* Distributed under the BSD License
* See http://pajhome.org.uk/crypt/md5 for details.
*/

/*
* Configurable variables. You may need to tweak these to be compatible with
* 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. "=" 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
* They take string arguments and return either hex or base-64 encoded strings
*/
function hex_sha1(s){ return binb2hex(core_sha1(str2binb(s),s.length * chrsz));}
function b64_sha1(s){ return binb2b64(core_sha1(str2binb(s),s.length * chrsz));}
function str_sha1(s){ return binb2str(core_sha1(str2binb(s),s.length * chrsz));}
function hex_hmac_sha1(key, data){ return binb2hex(core_hmac_sha1(key, data));}
function b64_hmac_sha1(key, data){ return binb2b64(core_hmac_sha1(key, data));}
function str_hmac_sha1(key, data){ return binb2str(core_hmac_sha1(key, data));}

/*
* Perform a simple self-test to see if the VM is working
*/
function sha1_vm_test()
{
   return hex_sha1( " abc " ) == " a9993e364706816aba3e25717850c26c9cd0d89d " ;
}

/*
* Calculate the SHA-1 of an array of big-endian words, and a bit length
*/
function core_sha1(x, len)
{
   /* append padding */
  x[len >> 5 ] |= 0x80 << ( 24 - len % 32 );
  x[((len + 64 >> 9 ) << 4 ) + 15 ] = len;

   var w = Array( 80 );
   var a =    1732584193 ;
   var b = - 271733879 ;
   var c = - 1732584194 ;
   var d =    271733878 ;
   var e = - 1009589776 ;

   for ( var i = 0 ; i < x.length; i += 16 )
  {
     var olda = a;
     var oldb = b;
     var oldc = c;
     var oldd = d;
     var olde = e;

     for ( var j = 0 ; j < 80 ; j ++ )
    {
       if (j < 16 ) w[j] = x[i + j];
       else w[j] = rol(w[j - 3 ] ^ w[j - 8 ] ^ w[j - 14 ] ^ w[j - 16 ], 1 );
       var t = safe_add(safe_add(rol(a, 5 ), sha1_ft(j, b, c, d)),
                       safe_add(safe_add(e, w[j]), sha1_kt(j)));
      e = d;
      d = c;
      c = rol(b, 30 );
      b = a;
      a = t;
    }

    a = safe_add(a, olda);
    b = safe_add(b, oldb);
    c = safe_add(c, oldc);
    d = safe_add(d, oldd);
    e = safe_add(e, olde);
  }
   return Array(a, b, c, d, e);

}

/*
* Perform the appropriate triplet combination function for the current
* iteration
*/
function sha1_ft(t, b, c, d)
{
   if (t < 20 ) return (b & c) | (( ~ b) & d);
   if (t < 40 ) return b ^ c ^ d;
   if (t < 60 ) return (b & c) | (b & d) | (c & d);
   return b ^ c ^ d;
}

/*
* Determine the appropriate additive constant for the current iteration
*/
function sha1_kt(t)
{
   return (t < 20 ) ?    1518500249 : (t < 40 ) ?    1859775393 :
         (t < 60 ) ? - 1894007588 : - 899497514 ;
}

/*
* Calculate the HMAC-SHA1 of a key and some data
*/
function core_hmac_sha1(key, data)
{
   var bkey = str2binb(key);
   if (bkey.length > 16 ) bkey = core_sha1(bkey, key.length * chrsz);

   var ipad = Array( 16 ), opad = Array( 16 );
   for ( var i = 0 ; i < 16 ; i ++ )
  {
    ipad[i] = bkey[i] ^ 0x36363636 ;
    opad[i] = bkey[i] ^ 0x5C5C5C5C ;
  }

   var hash = core_sha1(ipad.concat(str2binb(data)), 512 + data.length * chrsz);
   return core_sha1(opad.concat(hash), 512 + 160 );
}

/*
* Add integers, wrapping at 2^32. This uses 16-bit operations internally
* to work around bugs in some JS interpreters.
*/
function safe_add(x, y)
{
   var lsw = (x & 0xFFFF ) + (y & 0xFFFF );
   var msw = (x >> 16 ) + (y >> 16 ) + (lsw >> 16 );
   return (msw << 16 ) | (lsw & 0xFFFF );
}

/*
* Bitwise rotate a 32-bit number to the left.
*/
function rol(num, cnt)
{
   return (num << cnt) | (num >>> ( 32 - cnt));
}

/*
* Convert an 8-bit or 16-bit string to an array of big-endian words
* In 8-bit function, characters >255 have their hi-byte silently ignored.
*/
function str2binb(str)
{
   var bin = Array();
   var mask = ( 1 << chrsz) - 1 ;
   for ( var i = 0 ; i < str.length * chrsz; i += chrsz)
    bin[i >> 5 ] |= (str.charCodeAt(i / chrsz) & mask) << ( 32 - chrsz - i % 32 );
   return bin;
}

/*
* Convert an array of big-endian words to a string
*/
function binb2str(bin)
{
   var str = "" ;
   var mask = ( 1 << chrsz) - 1 ;
   for ( var i = 0 ; i < bin.length * 32 ; i += chrsz)
    str += String.fromCharCode((bin[i >> 5 ] >>> ( 32 - chrsz - i % 32 )) & mask);
   return str;
}

/*
* Convert an array of big-endian words to a hex string.
*/
function binb2hex(binarray)
{
   var hex_tab = hexcase ? " 0123456789ABCDEF " : " 0123456789abcdef " ;
   var str = "" ;
   for ( var i = 0 ; i < binarray.length * 4 ; i ++ )
  {
    str += hex_tab.charAt((binarray[i >> 2 ] >> (( 3 - i % 4 ) * 8 + 4 )) & 0xF ) +
           hex_tab.charAt((binarray[i >> 2 ] >> (( 3 - i % 4 ) * 8   )) & 0xF );
  }
   return str;
}

/*
* Convert an array of big-endian words to a base-64 string
*/
function binb2b64(binarray)
{
   var tab = " ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/ " ;
   var str = "" ;
   for ( var i = 0 ; i < binarray.length * 4 ; i += 3 )
  {
     var triplet = (((binarray[i    >> 2 ] >> 8 * ( 3 -   i    % 4 )) & 0xFF ) << 16 )
                 | (((binarray[i + 1 >> 2 ] >> 8 * ( 3 - (i + 1 ) % 4 )) & 0xFF ) << 8 )
                 |   ((binarray[i + 2 >> 2 ] >> 8 * ( 3 - (i + 2 ) % 4 )) & 0xFF );
     for ( var j = 0 ; j < 4 ; j ++ )
    {
       if (i * 8 + j * 6 > binarray.length * 32 ) str += b64pad;
       else str += tab.charAt((triplet >> 6 * ( 3 - j)) & 0x3F );
    }
  }
   return str;
}

转载于:https://www.cnblogs.com/Liq-Blog/archive/2012/11/27/2790310.html