```js
(function(global) {
	/*
	此加密算法是一个16次的迭代过程，并且是反馈的，每一个加密单元是8字节，输出也是8字节，密钥是16字节
	我们以prePlain表示前一个明文块，plain表示当前明文块，crypt表示当前明文块加密得到的密文块，preCrypt表示前一个密文块 f表示加密算法，d表示解密算法
	那么从plain得到crypt的过程是: crypt = f(plain ^ preCrypt) ^ prePlain 
	所以，从crypt得到plain的过程自然是 plain = d(crypt ^ prePlain) ^ preCrypt 
	此外，算法有它的填充机制，其会在明文前和明文后分别填充一定的字节数，以保证明文长度是8字节的倍数 填充的字节数与原始明文长度有关，填充的方法是:
		------- 消息填充算法 ----------- 
		a = (明文长度 + 10) mod 8
		if(a 不等于 0) a = 8 - a;
		b = 随机数 & 0xF8 | a;				这个的作用是把a的值保存了下来, a的值小于8
		plain[0] = b;                      	然后把b做为明文的第0个字节，这样第0个字节就保存了a的信息，这个信息在解密时就要用来找到真正明文的起始位置
		plain[1..a+2] = 随机数 & 0xFF;   	这里用随机数填充明文的第1到第a+2个字节
		plain[a+3..a+3+明文长度-1] = 明文; 	从a+3字节开始才是真正的明文
		plain[a+3+明文长度, 最后] = 0;      	在最后，填充0，填充到总长度为8的整数为止。到此为止，结束了，这就是最后得到的要加密的明文内容
		------- 消息填充算法 ------------
	@author 马若劼
	@author notXX
    @author 唐浩宸
	*/
	var	__key = '',
		__pos = 0,
		__plain = [],
		__prePlain = [],
		__cryptPos = 0, // 当前密文块位置
		__preCryptPos = 0, // 上一个密文块位置
		__out = [], // 保存加密/解密的输出
		__cipher = [], // 输出的密文
		/*用于加密时，表示当前是否是第一个8字节块，因为加密算法是反馈的,
		但是最开始的8个字节没有反馈可用，所有需要标明这种情况*/
		__header = true;
	function __rand() {
		return Math.round(Math.random()*0xffffffff);
	}
	/**
	 * 将数据转化为无符号整形
	 */
	function __getUInt(data, offset, len) {
		if (!len || len > 4)
			len = 4;
		var ret = 0;
		for (var i=offset; i<offset+len; i++) {
			ret <<= 8;
			ret |= data[i];
		}
		return (ret & 0xffffffff) >>> 0; // 无符号化
	}
	/**
	 把整形数据填充到数组里，要注意端序
	 */
	function __intToBytes(data, offset, value) {
		data[offset+3] = (value >> 0) & 0xff;
		data[offset+2] = (value >> 8) & 0xff;
		data[offset+1] = (value >> 16) & 0xff;
		data[offset+0] = (value >> 24) & 0xff;
	}
	function __bytesInStr(data) {
		if (!data) return "";
		var outInHex = "";
		for (var i=0; i<data.length; i++) {
			var hex = Number(data[i]).toString(16);
			if (hex.length == 1)
				hex = "0" + hex;
			outInHex += hex;
		}
		return outInHex;
	}
	function __bytesToStr(data) {
		var str = "";
		for (var i=0; i<data.length; i+=2) // 输入的16进制字符串
				str += String.fromCharCode(parseInt(data.substr(i, 2), 16));
		return str;
	}
	function __strToBytes(str, unicode) {
		if (!str) return "";
		if (unicode) str = utf16ToUtf8(str);

		var data = [];
		for (var i=0; i<str.length; i++)
			data[i] = str.charCodeAt(i);
		return __bytesInStr(data);
	}

	//UTF-16转UTF-8
	function utf16ToUtf8(s){
		var i, code, ret = [], len = s.length;
		for(i = 0; i < len; i++){
			code = s.charCodeAt(i);
			if(code > 0x0 && code <= 0x7f){
				//单字节
				//UTF-16 0000 - 007F
				//UTF-8  0xxxxxxx
				ret.push(s.charAt(i));
			}else if(code >= 0x80 && code <= 0x7ff){
				//双字节
				//UTF-16 0080 - 07FF
				//UTF-8  110xxxxx 10xxxxxx
				ret.push(
					//110xxxxx
					String.fromCharCode(0xc0 | ((code >> 6) & 0x1f)),
					//10xxxxxx
					String.fromCharCode(0x80 | (code & 0x3f))
				);
			}else if(code >= 0x800 && code <= 0xffff){
				//三字节
				//UTF-16 0800 - FFFF
				//UTF-8  1110xxxx 10xxxxxx 10xxxxxx
				ret.push(
					//1110xxxx
					String.fromCharCode(0xe0 | ((code >> 12) & 0xf)),
					//10xxxxxx
					String.fromCharCode(0x80 | ((code >> 6) & 0x3f)),
					//10xxxxxx
					String.fromCharCode(0x80 | (code & 0x3f))
				);
			}
		}

		return ret.join('');
	}

	function __encrypt(data) {
		__plain = new Array(8);
		__prePlain = new Array(8);
		__cryptPos = __preCryptPos = 0;
		__header = true;
		__pos = 0;
		var len = data.length;
		var padding = 0;

		__pos = (len + 0x0A) % 8;
		if (__pos != 0)
			__pos = 8 - __pos;
		__out = new Array(len + __pos + 10);
		__plain[0] = ((__rand() & 0xF8) | __pos ) & 0xFF;

		for (var i=1; i<=__pos; i++)
			__plain[i] = __rand() & 0xFF;
		__pos++;

		for (var i=0; i<8; i++)
			__prePlain[i] = 0;

		padding = 1;
		while (padding <= 2) {
			if (__pos < 8) {
				__plain[__pos++] = __rand() & 0xFF;
				padding++;
			}
			if (__pos == 8)
				__encrypt8bytes();
		}

		var i = 0;
		while (len > 0) {
			if (__pos < 8) {
				__plain[__pos++] = data[i++];
				len--;
			}
			if (__pos == 8)
				__encrypt8bytes();
		}

		padding = 1;
		while (padding <= 7) {
			if (__pos < 8) {
				__plain[__pos++] = 0;
				padding++;
			}
			if (__pos == 8)
				__encrypt8bytes();
		}

		return __out;
	}
	function __decrypt(data) {
		var count = 0;
		var m = new Array(8);
		var len = data.length;
		__cipher = data;

		if (len % 8 != 0 || len < 16)
			return null;
		/* 第一个8字节，加密的时候因为prePlain是全0，所以可以直接解密，得到消息的头部，
		关键是可以得到真正明文开始的位置
		*/
		__prePlain = __decipher(data);
		__pos = __prePlain[0] & 0x7;
		count = len - __pos - 10; // 真正的明文长度
		if (count < 0)
			return null;

		// 临时的preCrypt, 与加密时对应，全0的prePlain 对应 全0的preCrypt
		for (var i=0; i<m.length; i++)
			m[i] = 0;
		__out = new Array(count);
		__preCryptPos = 0;
		__cryptPos = 8; // 头部已经解密过，所以是8
		__pos++; // 与解密过程对应，+1

	/*	开始跳过头部，如果在这个过程中满了8字节，则解密下一块
		因为是解密下一块，所以我们有一个语句 m = data，下一块当然有preCrypt了，我们不再用m了
		但是如果不满8，这说明了什么？说明了头8个字节的密文是包含了明文信息的，当然还是要用m把明文弄出来
		所以，很显然，满了8的话，说明了头8个字节的密文除了一个长度信息有用之外，其他都是无用的填充*/
		var padding = 1;
		while (padding <= 2) {
			if (__pos < 8) {
				__pos++;
				padding++;
			}
			if (__pos == 8) {
				m = data;
				if (!__decrypt8Bytes())
					return null;
			}
		}

	/*	这里是解密的重要阶段，这个时候头部的填充都已经跳过了，开始解密
		注意如果上面一个while没有满8，这里第一个if里面用的就是原始的m，否则这个m就是data了*/
		var i=0;
		while (count != 0) {
			if (__pos < 8) {
				__out[i] = (m[__preCryptPos + __pos] ^ __prePlain[__pos]) & 0xff;
				i++;
				count--;
				__pos++;
			}
			if (__pos == 8) {
				m = data;
				__preCryptPos = __cryptPos - 8;
				if (!__decrypt8Bytes())
					return null;
			}
		}

		/*
			明文已经解密完毕了，到这里剩下的只有尾部的填充，应该全是0，如果解密后非0，即出错了，返回null
		*/
		for (padding=1; padding<8; padding++) {
			if (__pos < 8) {
				if ((m[__preCryptPos + __pos] ^ __prePlain[__pos]) != 0)
					return null;
				__pos++;
			}
			if (__pos == 8) {
				m = data;
				__preCryptPos = __cryptPos;
				if (!__decrypt8Bytes())
					return null;
			}
		}

		return __out;
	}
	function __encrypt8bytes() {
		for (var i=0; i<8; i++) {
			if (__header)
				__plain[i] ^= __prePlain[i];
			else
				__plain[i] ^= __out[__preCryptPos + i];
		}
		var crypted = __encipher(__plain);
		for (var i=0; i<8; i++) {
			__out[__cryptPos+i] = crypted[i] ^ __prePlain[i];
			__prePlain[i] = __plain[i];
		}

		__preCryptPos = __cryptPos;
		__cryptPos += 8;
		__pos = 0;
		__header = false;
	}
	function __encipher(data) {
		var loop = 16;
		var y = __getUInt(data, 0, 4);
		var z = __getUInt(data, 4, 4);
		var a = __getUInt(__key, 0, 4);
		var b = __getUInt(__key, 4, 4);
		var c = __getUInt(__key, 8, 4);
		var d = __getUInt(__key, 12, 4);
		var sum = 0;
		var delta = 0x9E3779B9 >>> 0;

		while (loop-- > 0) {
			sum += delta;
			sum = (sum & 0xFFFFFFFF) >>> 0;
			y += ((z << 4) + a) ^ (z + sum) ^ ((z >>> 5) + b);
			y = (y & 0xFFFFFFFF) >>> 0;
			z += ((y << 4) + c) ^ (y + sum) ^ ((y >>> 5) + d);
			z = (z & 0xFFFFFFFF) >>> 0;
		}
		var bytes = new Array(8);
		__intToBytes(bytes, 0, y);
		__intToBytes(bytes, 4, z);
		return bytes;
	}
	function __decipher(data) {
		var loop = 16;
		var y = __getUInt(data, 0, 4);
		var z = __getUInt(data, 4, 4);
		var a = __getUInt(__key, 0, 4);
		var b = __getUInt(__key, 4, 4);
		var c = __getUInt(__key, 8, 4);
		var d = __getUInt(__key, 12, 4);
		var sum = 0xE3779B90 >>> 0;
		var delta = 0x9E3779B9 >>> 0;

		while (loop-- > 0) {
			z -= ((y << 4) + c) ^ (y + sum) ^ ((y >>> 5) + d);
			z = (z & 0xFFFFFFFF) >>> 0;
			y -= ((z << 4) + a) ^ (z + sum) ^ ((z >>> 5) + b);
			y = (y & 0xFFFFFFFF) >>> 0;
			sum -= delta;
			sum = (sum & 0xFFFFFFFF) >>> 0;
		}

		var bytes = new Array(8);
		__intToBytes(bytes, 0, y);
		__intToBytes(bytes, 4, z);
		return bytes;
	}
	function __decrypt8Bytes() {
		var len = __cipher.length;
		for (var i=0; i<8; i++) {
			__prePlain[i] ^= __cipher[__cryptPos + i];
		}

		__prePlain = __decipher(__prePlain);

		__cryptPos += 8;
		__pos = 0;
		return true;
	}
	/**
	 * 把输入字符串转换为javascript array
	 */
	function __dataFromStr(str, isASCII) {
		var data = [];
		if (isASCII) {
			for (var i=0; i<str.length; i++)
				data[i] = str.charCodeAt(i) & 0xff;
		} else {
			var k = 0;
			for (var i=0; i<str.length; i+=2) // 输入的16进制字符串
				data[k++] = parseInt(str.substr(i, 2), 16);
		}
		return data;
	}

	global.TEA = {
		encrypt: function(str, isASCII) {
			var data = __dataFromStr(str, isASCII);
			var encrypted = __encrypt(data);
			return __bytesInStr(encrypted);
		},
		enAsBase64: function(str, isASCII) { // output base64 encoded
			var data = __dataFromStr(str, isASCII);
			var encrypted = __encrypt(data);
			var bytes = "";
			for (var i=0; i<encrypted.length; i++)
				bytes += String.fromCharCode(encrypted[i]);
			return btoa(bytes);
		},
		decrypt: function(str) {
			var data = __dataFromStr(str, false);
			var decrypted = __decrypt(data);
			return __bytesInStr(decrypted);
		},
		initkey: function(key, isASCII) {
			__key = __dataFromStr(key, isASCII);
		},
		bytesToStr: __bytesToStr,
		strToBytes: __strToBytes,
		bytesInStr: __bytesInStr,
		dataFromStr: __dataFromStr
	};

	/**
	 * base64 兼容window.btoa window.atob
	 * if (!window.btoa) window.btoa = base64.encode
	 * if (!window.atob) window.atob = base64.decode
	 */
	var base64 = {};
	base64.PADCHAR = '=';
	base64.ALPHA = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
/*
	base64.getbyte64 = function(s,i) {
		// This is oddly fast, except on Chrome/V8.
		//  Minimal or no improvement in performance by using a
		//   object with properties mapping chars to value (eg. 'A': 0)
		var idx = base64.ALPHA.indexOf(s.charAt(i));
		if (idx == -1) {
			throw "Cannot decode base64";
		}
		return idx;
	}

	base64.decode = function(s) {
		// convert to string
		s = "" + s;
		var getbyte64 = base64.getbyte64;
		var pads, i, b10;
		var imax = s.length
		if (imax == 0) {
			return s;
		}

		if (imax % 4 != 0) {
			throw "Cannot decode base64";
		}

		pads = 0
		if (s.charAt(imax -1) == base64.PADCHAR) {
			pads = 1;
			if (s.charAt(imax -2) == base64.PADCHAR) {
				pads = 2;
			}
			// either way, we want to ignore this last block
			imax -= 4;
		}

		var x = [];
		for (i = 0; i < imax; i += 4) {
			b10 = (getbyte64(s,i) << 18) | (getbyte64(s,i+1) << 12) |
			(getbyte64(s,i+2) << 6) | getbyte64(s,i+3);
			x.push(String.fromCharCode(b10 >> 16, (b10 >> 8) & 0xff, b10 & 0xff));
		}

		switch (pads) {
			case 1:
				b10 = (getbyte64(s,i) << 18) | (getbyte64(s,i+1) << 12) | (getbyte64(s,i+2) << 6)
				x.push(String.fromCharCode(b10 >> 16, (b10 >> 8) & 0xff));
				break;
			case 2:
				b10 = (getbyte64(s,i) << 18) | (getbyte64(s,i+1) << 12);
				x.push(String.fromCharCode(b10 >> 16));
				break;
		}
		return x.join('');
	}
*/

	base64.getbyte = function(s,i) {
		var x = s.charCodeAt(i);
		if (x > 255) {
			throw "INVALID_CHARACTER_ERR: DOM Exception 5";
		}
		return x;
	}

	base64.encode = function(s) {
		if (arguments.length != 1) {
			throw "SyntaxError: Not enough arguments";
		}
		var padchar = base64.PADCHAR;
		var alpha   = base64.ALPHA;
		var getbyte = base64.getbyte;

		var i, b10;
		var x = [];

		// convert to string
		s = "" + s;

		var imax = s.length - s.length % 3;

		if (s.length == 0) {
			return s;
		}
		for (i = 0; i < imax; i += 3) {
			b10 = (getbyte(s,i) << 16) | (getbyte(s,i+1) << 8) | getbyte(s,i+2);
			x.push(alpha.charAt(b10 >> 18));
			x.push(alpha.charAt((b10 >> 12) & 0x3F));
			x.push(alpha.charAt((b10 >> 6) & 0x3f));
			x.push(alpha.charAt(b10 & 0x3f));
		}
		switch (s.length - imax) {
			case 1:
				b10 = getbyte(s,i) << 16;
				x.push(alpha.charAt(b10 >> 18) + alpha.charAt((b10 >> 12) & 0x3F) +
				padchar + padchar);
				break;
			case 2:
				b10 = (getbyte(s,i) << 16) | (getbyte(s,i+1) << 8);
				x.push(alpha.charAt(b10 >> 18) + alpha.charAt((b10 >> 12) & 0x3F) +
				alpha.charAt((b10 >> 6) & 0x3f) + padchar);
				break;
		}
		return x.join('');
	}
	if (!window.btoa) window.btoa = base64.encode;
	//if (!window.atob) window.atob = base64.decode;
})(window);
```