/*================================================================================*/
/*                                                                                */
/*             BW2Technologies.Web.JScript.Framework (Alpha V1.0.0.0)             */
/*                                                                                */
/*                               Web-Crypting Hash                                */
/*                                                                                */
/*              Copyright © 2006-2010 by BW2Technologies (HP. Lassnig)            */
/*                           mail to : hansi@lassnig.ch                           */
/*                                                                                */
/*================================================================================*/

var _nChrSize = 8;          /* bits per input character. 8 - ASCII; 16 - Unicode */
var _nHexCase = 0;          /* hex output format. 0 - lowercase; 1 - uppercase */ 
var _strB64pad  = '';       /* base-64 pad character. '=' for strict RFC compliance */

/*--------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------*/


/*================================================================================*/
/* <Function> Frame-Set </Function>
/*================================================================================*/
function __getMD5(strData, strKey) {
         if (strKey ==null) {
            return __binl2b64(__coreMD5(__str2binl(strData), strData.length * _nChrSize));
         } else {
            return __binl2b64(__core_hpc_md5(strData, strKey));
         }
}

/*================================================================================*/
/* <Function> Calculate the MD5 of an array of little-endian words, and a bit length </Function>
/*================================================================================*/
function __coreMD5(x, len) {
         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);
}

/*================================================================================*/
/* <Function> These functions implement the four basic operations the algorithm uses </Function>
/*================================================================================*/
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);
}

/*================================================================================*/
/* <Function> Calculate the HPC-MD5, of a key and some data </Function>
/*================================================================================*/
function __core_hpc_md5(strData, strKey) {
         var strD = __binl2b64(__coreMD5(__str2binl(strData), strData.length * _nChrSize));

         strD += __binl2b64(__coreMD5(__str2binl(strKey), strKey.length * _nChrSize));
         return __coreMD5(__str2binl(strD), strD.length * _nChrSize);
}

/*================================================================================*/
/* <Function> Calculate the HMAC-MD5, of a key and some data </Function>
/*================================================================================*/
function __core_hmac_md5(data, key) {
         var bkey = __str2binl(key);
         if(bkey.length > 16) bkey = __coreMD5(bkey, key.length * _nChrSize);
         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 = __coreMD5(ipad.concat(__str2binl(data)), 512 + data.length * _nChrSize);
         return __coreMD5(opad.concat(hash), 512 + 128);
}

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

         return (msw << 16) | (lsw & 0xFFFF);
}

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

/*================================================================================*/
/* <Function> Convert a string to an array of little-endian words If _nChrSize is ASCII, characters >255 have their hi-byte silently ignored </Function>
/*================================================================================*/
function __str2binl(str) {
         var bin = Array();
         var mask = (1 << _nChrSize) - 1;

         for(var i = 0; i < str.length * _nChrSize; i += _nChrSize) bin[i>>5] |= (str.charCodeAt(i / _nChrSize) & mask) << (i%32);
         return bin;
}

/*================================================================================*/
/* <Function> Convert an array of little-endian words to a string </Function>
/*================================================================================*/
function __binl2str(bin) {
         var str = '';
         var mask = (1 << _nChrSize) - 1;

         for(var i = 0; i < bin.length * 32; i += _nChrSize)
            str += String.fromCharCode((bin[i>>5] >>> (i % 32)) & mask);
         return str;
}

/*================================================================================*/
/* <Function> Convert an array of little-endian words to a hex string </Function>
/*================================================================================*/
function __binl2hex(binarray) {
         var hex_tab = _nHexCase ? '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;
}

/*================================================================================*/
/* <Function> Convert an array of little-endian words to a base-64 string </Function>
/*================================================================================*/
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 += _strB64pad;
               else str += tab.charAt((triplet >> 6*(3-j)) & 0x3F);
            }
         }
         return str;
}

/*--------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------*/