hongze_yb_xcx/utils/crypto.js

const key = 'zDeESsxsXuionhqSLZYHWcDJ';

class CryptoJS {
	// 3DES加密，CBC/PKCS5Padding
	static Des3Encrypt (input) {
		let genKey = genkey(key, 0, 24);
		return base64encode(des(genKey.key, input, 1, 1, key.substr(0, 8), 1));
	}

	// 3DES解密，CBC/PKCS5Padding
	static Des3Decrypt (input) {
		let genKey = genkey(key, 0, 24);
		return des(genKey.key, base64decode(input), 0, 1, key.substr(0, 8), 1);
	}

	// md5
	static Md5Encrypt (input) {
		return md5(String(input));
	}
}

function des (key, message, encrypt, mode, iv, padding) {
	if (encrypt) // 如果是加密的话，首先转换编码
	{ message = unescape(encodeURIComponent(message)); }
	// declaring this locally speeds things up a bit
	let spfunction1 = new Array(0x1010400, 0, 0x10000, 0x1010404, 0x1010004, 0x10404, 0x4, 0x10000, 0x400, 0x1010400, 0x1010404, 0x400, 0x1000404, 0x1010004, 0x1000000, 0x4, 0x404, 0x1000400, 0x1000400, 0x10400, 0x10400, 0x1010000, 0x1010000, 0x1000404, 0x10004, 0x1000004, 0x1000004, 0x10004, 0, 0x404, 0x10404, 0x1000000, 0x10000, 0x1010404, 0x4, 0x1010000, 0x1010400, 0x1000000, 0x1000000, 0x400, 0x1010004, 0x10000, 0x10400, 0x1000004, 0x400, 0x4, 0x1000404, 0x10404, 0x1010404, 0x10004, 0x1010000, 0x1000404, 0x1000004, 0x404, 0x10404, 0x1010400, 0x404, 0x1000400, 0x1000400, 0, 0x10004, 0x10400, 0, 0x1010004);
	let spfunction2 = new Array(-0x7fef7fe0, -0x7fff8000, 0x8000, 0x108020, 0x100000, 0x20, -0x7fefffe0, -0x7fff7fe0, -0x7fffffe0, -0x7fef7fe0, -0x7fef8000, -0x80000000, -0x7fff8000, 0x100000, 0x20, -0x7fefffe0, 0x108000, 0x100020, -0x7fff7fe0, 0, -0x80000000, 0x8000, 0x108020, -0x7ff00000, 0x100020, -0x7fffffe0, 0, 0x108000, 0x8020, -0x7fef8000, -0x7ff00000, 0x8020, 0, 0x108020, -0x7fefffe0, 0x100000, -0x7fff7fe0, -0x7ff00000, -0x7fef8000, 0x8000, -0x7ff00000, -0x7fff8000, 0x20, -0x7fef7fe0, 0x108020, 0x20, 0x8000, -0x80000000, 0x8020, -0x7fef8000, 0x100000, -0x7fffffe0, 0x100020, -0x7fff7fe0, -0x7fffffe0, 0x100020, 0x108000, 0, -0x7fff8000, 0x8020, -0x80000000, -0x7fefffe0, -0x7fef7fe0, 0x108000);
	let spfunction3 = new Array(0x208, 0x8020200, 0, 0x8020008, 0x8000200, 0, 0x20208, 0x8000200, 0x20008, 0x8000008, 0x8000008, 0x20000, 0x8020208, 0x20008, 0x8020000, 0x208, 0x8000000, 0x8, 0x8020200, 0x200, 0x20200, 0x8020000, 0x8020008, 0x20208, 0x8000208, 0x20200, 0x20000, 0x8000208, 0x8, 0x8020208, 0x200, 0x8000000, 0x8020200, 0x8000000, 0x20008, 0x208, 0x20000, 0x8020200, 0x8000200, 0, 0x200, 0x20008, 0x8020208, 0x8000200, 0x8000008, 0x200, 0, 0x8020008, 0x8000208, 0x20000, 0x8000000, 0x8020208, 0x8, 0x20208, 0x20200, 0x8000008, 0x8020000, 0x8000208, 0x208, 0x8020000, 0x20208, 0x8, 0x8020008, 0x20200);
	let spfunction4 = new Array(0x802001, 0x2081, 0x2081, 0x80, 0x802080, 0x800081, 0x800001, 0x2001, 0, 0x802000, 0x802000, 0x802081, 0x81, 0, 0x800080, 0x800001, 0x1, 0x2000, 0x800000, 0x802001, 0x80, 0x800000, 0x2001, 0x2080, 0x800081, 0x1, 0x2080, 0x800080, 0x2000, 0x802080, 0x802081, 0x81, 0x800080, 0x800001, 0x802000, 0x802081, 0x81, 0, 0, 0x802000, 0x2080, 0x800080, 0x800081, 0x1, 0x802001, 0x2081, 0x2081, 0x80, 0x802081, 0x81, 0x1, 0x2000, 0x800001, 0x2001, 0x802080, 0x800081, 0x2001, 0x2080, 0x800000, 0x802001, 0x80, 0x800000, 0x2000, 0x802080);
	let spfunction5 = new Array(0x100, 0x2080100, 0x2080000, 0x42000100, 0x80000, 0x100, 0x40000000, 0x2080000, 0x40080100, 0x80000, 0x2000100, 0x40080100, 0x42000100, 0x42080000, 0x80100, 0x40000000, 0x2000000, 0x40080000, 0x40080000, 0, 0x40000100, 0x42080100, 0x42080100, 0x2000100, 0x42080000, 0x40000100, 0, 0x42000000, 0x2080100, 0x2000000, 0x42000000, 0x80100, 0x80000, 0x42000100, 0x100, 0x2000000, 0x40000000, 0x2080000, 0x42000100, 0x40080100, 0x2000100, 0x40000000, 0x42080000, 0x2080100, 0x40080100, 0x100, 0x2000000, 0x42080000, 0x42080100, 0x80100, 0x42000000, 0x42080100, 0x2080000, 0, 0x40080000, 0x42000000, 0x80100, 0x2000100, 0x40000100, 0x80000, 0, 0x40080000, 0x2080100, 0x40000100);
	let spfunction6 = new Array(0x20000010, 0x20400000, 0x4000, 0x20404010, 0x20400000, 0x10, 0x20404010, 0x400000, 0x20004000, 0x404010, 0x400000, 0x20000010, 0x400010, 0x20004000, 0x20000000, 0x4010, 0, 0x400010, 0x20004010, 0x4000, 0x404000, 0x20004010, 0x10, 0x20400010, 0x20400010, 0, 0x404010, 0x20404000, 0x4010, 0x404000, 0x20404000, 0x20000000, 0x20004000, 0x10, 0x20400010, 0x404000, 0x20404010, 0x400000, 0x4010, 0x20000010, 0x400000, 0x20004000, 0x20000000, 0x4010, 0x20000010, 0x20404010, 0x404000, 0x20400000, 0x404010, 0x20404000, 0, 0x20400010, 0x10, 0x4000, 0x20400000, 0x404010, 0x4000, 0x400010, 0x20004010, 0, 0x20404000, 0x20000000, 0x400010, 0x20004010);
	let spfunction7 = new Array(0x200000, 0x4200002, 0x4000802, 0, 0x800, 0x4000802, 0x200802, 0x4200800, 0x4200802, 0x200000, 0, 0x4000002, 0x2, 0x4000000, 0x4200002, 0x802, 0x4000800, 0x200802, 0x200002, 0x4000800, 0x4000002, 0x4200000, 0x4200800, 0x200002, 0x4200000, 0x800, 0x802, 0x4200802, 0x200800, 0x2, 0x4000000, 0x200800, 0x4000000, 0x200800, 0x200000, 0x4000802, 0x4000802, 0x4200002, 0x4200002, 0x2, 0x200002, 0x4000000, 0x4000800, 0x200000, 0x4200800, 0x802, 0x200802, 0x4200800, 0x802, 0x4000002, 0x4200802, 0x4200000, 0x200800, 0, 0x2, 0x4200802, 0, 0x200802, 0x4200000, 0x800, 0x4000002, 0x4000800, 0x800, 0x200002);
	let spfunction8 = new Array(0x10001040, 0x1000, 0x40000, 0x10041040, 0x10000000, 0x10001040, 0x40, 0x10000000, 0x40040, 0x10040000, 0x10041040, 0x41000, 0x10041000, 0x41040, 0x1000, 0x40, 0x10040000, 0x10000040, 0x10001000, 0x1040, 0x41000, 0x40040, 0x10040040, 0x10041000, 0x1040, 0, 0, 0x10040040, 0x10000040, 0x10001000, 0x41040, 0x40000, 0x41040, 0x40000, 0x10041000, 0x1000, 0x40, 0x10040040, 0x1000, 0x41040, 0x10001000, 0x40, 0x10000040, 0x10040000, 0x10040040, 0x10000000, 0x40000, 0x10001040, 0, 0x10041040, 0x40040, 0x10000040, 0x10040000, 0x10001000, 0x10001040, 0, 0x10041040, 0x41000, 0x41000, 0x1040, 0x1040, 0x40040, 0x10000000, 0x10041000);

	// create the 16 or 48 subkeys we will need
	let keys = des_createKeys(key);

	let m = 0, i, j, temp, temp2, right1, right2, left, right, looping;
	let cbcleft, cbcleft2, cbcright, cbcright2;
	let endloop, loopinc;
	var len = message.length;
	let chunk = 0;
	// set up the loops for single and triple des
	let iterations = keys.length === 32 ? 3 : 9; // single or triple des
	if (iterations === 3) { looping = encrypt ? new Array(0, 32, 2) : new Array(30, -2, -2); } else { looping = encrypt ? new Array(0, 32, 2, 62, 30, -2, 64, 96, 2) : new Array(94, 62, -2, 32, 64, 2, 30, -2, -2); }

	// pad the message depending on the padding parameter
	if (padding === 2) message += '        '; // pad the message with spaces
	else if (padding === 1) {
		if (encrypt) {
			temp = 8 - (len % 8);
			message += String.fromCharCode(temp, temp, temp, temp, temp, temp, temp, temp);
			if (temp === 8) len += 8;
		}
	} // PKCS7 padding
	else if (!padding) message += '\0\0\0\0\0\0\0\0'; // pad the message out with null bytes

	// store the result here
	let result = '';
	let tempresult = '';

	if (mode === 1) { // CBC mode
		cbcleft = (iv.charCodeAt(m++) << 24) | (iv.charCodeAt(m++) << 16) | (iv.charCodeAt(m++) << 8) | iv.charCodeAt(m++);
		cbcright = (iv.charCodeAt(m++) << 24) | (iv.charCodeAt(m++) << 16) | (iv.charCodeAt(m++) << 8) | iv.charCodeAt(m++);
		m = 0;
	}

	// loop through each 64 bit chunk of the message
	while (m < len) {
		left = (message.charCodeAt(m++) << 24) | (message.charCodeAt(m++) << 16) | (message.charCodeAt(m++) << 8) | message.charCodeAt(m++);
		right = (message.charCodeAt(m++) << 24) | (message.charCodeAt(m++) << 16) | (message.charCodeAt(m++) << 8) | message.charCodeAt(m++);

		// for Cipher Block Chaining mode, xor the message with the previous result
		if (mode === 1) {
			if (encrypt) {
				left ^= cbcleft;
				right ^= cbcright;
			} else {
				cbcleft2 = cbcleft;
				cbcright2 = cbcright;
				cbcleft = left;
				cbcright = right;
			}
		}

		// first each 64 but chunk of the message must be permuted according to IP
		temp = ((left >>> 4) ^ right) & 0x0f0f0f0f;
		right ^= temp;
		left ^= (temp << 4);
		temp = ((left >>> 16) ^ right) & 0x0000ffff;
		right ^= temp;
		left ^= (temp << 16);
		temp = ((right >>> 2) ^ left) & 0x33333333;
		left ^= temp;
		right ^= (temp << 2);
		temp = ((right >>> 8) ^ left) & 0x00ff00ff;
		left ^= temp;
		right ^= (temp << 8);
		temp = ((left >>> 1) ^ right) & 0x55555555;
		right ^= temp;
		left ^= (temp << 1);

		left = ((left << 1) | (left >>> 31));
		right = ((right << 1) | (right >>> 31));

		// do this either 1 or 3 times for each chunk of the message
		for (j = 0; j < iterations; j += 3) {
			endloop = looping[j + 1];
			loopinc = looping[j + 2];
			// now go through and perform the encryption or decryption
			for (i = looping[j]; i !== endloop; i += loopinc) { // for efficiency
				right1 = right ^ keys[i];
				right2 = ((right >>> 4) | (right << 28)) ^ keys[i + 1];
				// the result is attained by passing these bytes through the S selection functions
				temp = left;
				left = right;
				right = temp ^ (spfunction2[(right1 >>> 24) & 0x3f] | spfunction4[(right1 >>> 16) & 0x3f] |
					spfunction6[(right1 >>> 8) & 0x3f] | spfunction8[right1 & 0x3f] |
					spfunction1[(right2 >>> 24) & 0x3f] | spfunction3[(right2 >>> 16) & 0x3f] |
					spfunction5[(right2 >>> 8) & 0x3f] | spfunction7[right2 & 0x3f]);
			}
			temp = left;
			left = right;
			right = temp; // unreverse left and right
		} // for either 1 or 3 iterations

		// move then each one bit to the right
		left = ((left >>> 1) | (left << 31));
		right = ((right >>> 1) | (right << 31));

		// now perform IP-1, which is IP in the opposite direction
		temp = ((left >>> 1) ^ right) & 0x55555555;
		right ^= temp;
		left ^= (temp << 1);
		temp = ((right >>> 8) ^ left) & 0x00ff00ff;
		left ^= temp;
		right ^= (temp << 8);
		temp = ((right >>> 2) ^ left) & 0x33333333;
		left ^= temp;
		right ^= (temp << 2);
		temp = ((left >>> 16) ^ right) & 0x0000ffff;
		right ^= temp;
		left ^= (temp << 16);
		temp = ((left >>> 4) ^ right) & 0x0f0f0f0f;
		right ^= temp;
		left ^= (temp << 4);

		// for Cipher Block Chaining mode, xor the message with the previous result
		if (mode === 1) {
			if (encrypt) {
				cbcleft = left;
				cbcright = right;
			} else {
				left ^= cbcleft2;
				right ^= cbcright2;
			}
		}
		tempresult += String.fromCharCode((left >>> 24), ((left >>> 16) & 0xff), ((left >>> 8) & 0xff), (left & 0xff), (right >>> 24), ((right >>> 16) & 0xff), ((right >>> 8) & 0xff), (right & 0xff));

		chunk += 8;
		if (chunk === 512) {
			result += tempresult;
			tempresult = '';
			chunk = 0;
		}
	} // for every 8 characters, or 64 bits in the message

	// return the result as an array
	result += tempresult;
	result = result.replace(/\0*$/g, '');

	if (!encrypt) { // 如果是解密的话，解密结束后对PKCS7 padding进行解码，并转换成utf-8编码
		if (padding === 1) { // PKCS7 padding解码
			var len = result.length, paddingChars = 0;
			len && (paddingChars = result.charCodeAt(len - 1));
			(paddingChars <= 8) && (result = result.substring(0, len - paddingChars));
		}
		// 转换成UTF-8编码
		result = decodeURIComponent(escape(result));
	}

	return result;
} // end of des

// des_createKeys
// this takes as input a 64 bit key (even though only 56 bits are used)
// as an array of 2 integers, and returns 16 48 bit keys
function des_createKeys (key) {
	// declaring this locally speeds things up a bit
	let pc2bytes0 = new Array(0, 0x4, 0x20000000, 0x20000004, 0x10000, 0x10004, 0x20010000, 0x20010004, 0x200, 0x204, 0x20000200, 0x20000204, 0x10200, 0x10204, 0x20010200, 0x20010204);
	let pc2bytes1 = new Array(0, 0x1, 0x100000, 0x100001, 0x4000000, 0x4000001, 0x4100000, 0x4100001, 0x100, 0x101, 0x100100, 0x100101, 0x4000100, 0x4000101, 0x4100100, 0x4100101);
	let pc2bytes2 = new Array(0, 0x8, 0x800, 0x808, 0x1000000, 0x1000008, 0x1000800, 0x1000808, 0, 0x8, 0x800, 0x808, 0x1000000, 0x1000008, 0x1000800, 0x1000808);
	let pc2bytes3 = new Array(0, 0x200000, 0x8000000, 0x8200000, 0x2000, 0x202000, 0x8002000, 0x8202000, 0x20000, 0x220000, 0x8020000, 0x8220000, 0x22000, 0x222000, 0x8022000, 0x8222000);
	let pc2bytes4 = new Array(0, 0x40000, 0x10, 0x40010, 0, 0x40000, 0x10, 0x40010, 0x1000, 0x41000, 0x1010, 0x41010, 0x1000, 0x41000, 0x1010, 0x41010);
	let pc2bytes5 = new Array(0, 0x400, 0x20, 0x420, 0, 0x400, 0x20, 0x420, 0x2000000, 0x2000400, 0x2000020, 0x2000420, 0x2000000, 0x2000400, 0x2000020, 0x2000420);
	let pc2bytes6 = new Array(0, 0x10000000, 0x80000, 0x10080000, 0x2, 0x10000002, 0x80002, 0x10080002, 0, 0x10000000, 0x80000, 0x10080000, 0x2, 0x10000002, 0x80002, 0x10080002);
	let pc2bytes7 = new Array(0, 0x10000, 0x800, 0x10800, 0x20000000, 0x20010000, 0x20000800, 0x20010800, 0x20000, 0x30000, 0x20800, 0x30800, 0x20020000, 0x20030000, 0x20020800, 0x20030800);
	let pc2bytes8 = new Array(0, 0x40000, 0, 0x40000, 0x2, 0x40002, 0x2, 0x40002, 0x2000000, 0x2040000, 0x2000000, 0x2040000, 0x2000002, 0x2040002, 0x2000002, 0x2040002);
	let pc2bytes9 = new Array(0, 0x10000000, 0x8, 0x10000008, 0, 0x10000000, 0x8, 0x10000008, 0x400, 0x10000400, 0x408, 0x10000408, 0x400, 0x10000400, 0x408, 0x10000408);
	let pc2bytes10 = new Array(0, 0x20, 0, 0x20, 0x100000, 0x100020, 0x100000, 0x100020, 0x2000, 0x2020, 0x2000, 0x2020, 0x102000, 0x102020, 0x102000, 0x102020);
	let pc2bytes11 = new Array(0, 0x1000000, 0x200, 0x1000200, 0x200000, 0x1200000, 0x200200, 0x1200200, 0x4000000, 0x5000000, 0x4000200, 0x5000200, 0x4200000, 0x5200000, 0x4200200, 0x5200200);
	let pc2bytes12 = new Array(0, 0x1000, 0x8000000, 0x8001000, 0x80000, 0x81000, 0x8080000, 0x8081000, 0x10, 0x1010, 0x8000010, 0x8001010, 0x80010, 0x81010, 0x8080010, 0x8081010);
	let pc2bytes13 = new Array(0, 0x4, 0x100, 0x104, 0, 0x4, 0x100, 0x104, 0x1, 0x5, 0x101, 0x105, 0x1, 0x5, 0x101, 0x105);

	// how many iterations (1 for des, 3 for triple des)
	let iterations = key.length > 8 ? 3 : 1; // changed by Paul 16/6/2007 to use Triple DES for 9+ byte keys
	// stores the return keys
	let keys = new Array(32 * iterations);
	// now define the left shifts which need to be done
	let shifts = new Array(0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0);
	// other variables
	let lefttemp, righttemp, m = 0, n = 0, temp;

	for (let j = 0; j < iterations; j++) { // either 1 or 3 iterations
		let left = (key.charCodeAt(m++) << 24) | (key.charCodeAt(m++) << 16) | (key.charCodeAt(m++) << 8) | key.charCodeAt(m++);
		let right = (key.charCodeAt(m++) << 24) | (key.charCodeAt(m++) << 16) | (key.charCodeAt(m++) << 8) | key.charCodeAt(m++);

		temp = ((left >>> 4) ^ right) & 0x0f0f0f0f;
		right ^= temp;
		left ^= (temp << 4);
		temp = ((right >>> -16) ^ left) & 0x0000ffff;
		left ^= temp;
		right ^= (temp << -16);
		temp = ((left >>> 2) ^ right) & 0x33333333;
		right ^= temp;
		left ^= (temp << 2);
		temp = ((right >>> -16) ^ left) & 0x0000ffff;
		left ^= temp;
		right ^= (temp << -16);
		temp = ((left >>> 1) ^ right) & 0x55555555;
		right ^= temp;
		left ^= (temp << 1);
		temp = ((right >>> 8) ^ left) & 0x00ff00ff;
		left ^= temp;
		right ^= (temp << 8);
		temp = ((left >>> 1) ^ right) & 0x55555555;
		right ^= temp;
		left ^= (temp << 1);

		// the right side needs to be shifted and to get the last four bits of the left side
		temp = (left << 8) | ((right >>> 20) & 0x000000f0);
		// left needs to be put upside down
		left = (right << 24) | ((right << 8) & 0xff0000) | ((right >>> 8) & 0xff00) | ((right >>> 24) & 0xf0);
		right = temp;

		// now go through and perform these shifts on the left and right keys
		for (let i = 0; i < shifts.length; i++) {
			// shift the keys either one or two bits to the left
			if (shifts[i]) {
				left = (left << 2) | (left >>> 26);
				right = (right << 2) | (right >>> 26);
			} else {
				left = (left << 1) | (left >>> 27);
				right = (right << 1) | (right >>> 27);
			}
			left &= -0xf;
			right &= -0xf;

			// now apply PC-2, in such a way that E is easier when encrypting or decrypting
			// this conversion will look like PC-2 except only the last 6 bits of each byte are used
			// rather than 48 consecutive bits and the order of lines will be according to
			// how the S selection functions will be applied: S2, S4, S6, S8, S1, S3, S5, S7
			lefttemp = pc2bytes0[left >>> 28] | pc2bytes1[(left >>> 24) & 0xf] |
				pc2bytes2[(left >>> 20) & 0xf] | pc2bytes3[(left >>> 16) & 0xf] |
				pc2bytes4[(left >>> 12) & 0xf] | pc2bytes5[(left >>> 8) & 0xf] |
				pc2bytes6[(left >>> 4) & 0xf];
			righttemp = pc2bytes7[right >>> 28] | pc2bytes8[(right >>> 24) & 0xf] |
				pc2bytes9[(right >>> 20) & 0xf] | pc2bytes10[(right >>> 16) & 0xf] |
				pc2bytes11[(right >>> 12) & 0xf] | pc2bytes12[(right >>> 8) & 0xf] |
				pc2bytes13[(right >>> 4) & 0xf];
			temp = ((righttemp >>> 16) ^ lefttemp) & 0x0000ffff;
			keys[n++] = lefttemp ^ temp;
			keys[n++] = righttemp ^ (temp << 16);
		}
	} // for each iterations
	// return the keys we've created
	return keys;
} // end of des_createKeys
function genkey (key, start, end) {
	// 8 byte / 64 bit Key (DES) or 192 bit Key
	return { key: pad(key.slice(start, end)), vector: 1 };
}
function pad (key) {
	for (let i = key.length; i < 24; i++) {
		key += '0';
	}
	return key;
}

let BASE64_MAPPING = [
	'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
	'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
	'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
	'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
	'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
	'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
	'w', 'x', 'y', 'z', '0', '1', '2', '3',
	'4', '5', '6', '7', '8', '9', '+', '/'
];

/**
 *ascii convert to binary
 */
let _toBinary = function (ascii) {
	let binary = new Array();
	while (ascii > 0) {
		let b = ascii % 2;
		ascii = Math.floor(ascii / 2);
		binary.push(b);
	}
	/*
	 var len = binary.length;
	 if(6-len > 0){
	 for(var i = 6-len ; i > 0 ; --i){
	 binary.push(0);
	 }
	 } */
	binary.reverse();
	return binary;
};

/**
 *binary convert to decimal
 */
let _toDecimal = function (binary) {
	let dec = 0;
	let p = 0;
	for (let i = binary.length - 1; i >= 0; --i) {
		let b = binary[i];
		if (b === 1) {
			dec += Math.pow(2, p);
		}
		++p;
	}
	return dec;
};

/**
 *unicode convert to utf-8
 */
let _toUTF8Binary = function (c, binaryArray) {
	let mustLen = (8 - (c + 1)) + ((c - 1) * 6);
	let fatLen = binaryArray.length;
	let diff = mustLen - fatLen;
	while (--diff >= 0) {
		binaryArray.unshift(0);
	}
	let binary = [];
	let _c = c;
	while (--_c >= 0) {
		binary.push(1);
	}
	binary.push(0);
	let i = 0, len = 8 - (c + 1);
	for (; i < len; ++i) {
		binary.push(binaryArray[i]);
	}

	for (let j = 0; j < c - 1; ++j) {
		binary.push(1);
		binary.push(0);
		let sum = 6;
		while (--sum >= 0) {
			binary.push(binaryArray[i++]);
		}
	}
	return binary;
};

let BASE64 = {
	/**
	 *BASE64 Encode
	 */
	encoder: function (str) {
		let base64_Index = [];
		let binaryArray = [];
		for (var i = 0, len = str.length; i < len; ++i) {
			let unicode = str.charCodeAt(i);
			let _tmpBinary = _toBinary(unicode);
			if (unicode < 0x80) {
				let _tmpdiff = 8 - _tmpBinary.length;
				while (--_tmpdiff >= 0) {
					_tmpBinary.unshift(0);
				}
				binaryArray = binaryArray.concat(_tmpBinary);
			} else if (unicode >= 0x80 && unicode <= 0x7FF) {
				binaryArray = binaryArray.concat(_toUTF8Binary(2, _tmpBinary));
			} else if (unicode >= 0x800 && unicode <= 0xFFFF) { // UTF-8 3byte
				binaryArray = binaryArray.concat(_toUTF8Binary(3, _tmpBinary));
			} else if (unicode >= 0x10000 && unicode <= 0x1FFFFF) { // UTF-8 4byte
				binaryArray = binaryArray.concat(_toUTF8Binary(4, _tmpBinary));
			} else if (unicode >= 0x200000 && unicode <= 0x3FFFFFF) { // UTF-8 5byte
				binaryArray = binaryArray.concat(_toUTF8Binary(5, _tmpBinary));
			} else if (unicode >= 4000000 && unicode <= 0x7FFFFFFF) { // UTF-8 6byte
				binaryArray = binaryArray.concat(_toUTF8Binary(6, _tmpBinary));
			}
		}

		let extra_Zero_Count = 0;
		for (var i = 0, len = binaryArray.length; i < len; i += 6) {
			let diff = (i + 6) - len;
			if (diff === 2) {
				extra_Zero_Count = 2;
			} else if (diff === 4) {
				extra_Zero_Count = 4;
			}
			// if(extra_Zero_Count > 0){
			//  len += extra_Zero_Count+1;
			// }
			let _tmpExtra_Zero_Count = extra_Zero_Count;
			while (--_tmpExtra_Zero_Count >= 0) {
				binaryArray.push(0);
			}
			base64_Index.push(_toDecimal(binaryArray.slice(i, i + 6)));
		}

		let base64 = '';
		for (var i = 0, len = base64_Index.length; i < len; ++i) {
			base64 += BASE64_MAPPING[base64_Index[i]];
		}

		for (var i = 0, len = extra_Zero_Count / 2; i < len; ++i) {
			base64 += '=';
		}
		return base64;
	},
	/**
	 *BASE64  Decode for UTF-8
	 */
	decoder: function (_base64Str) {
		let _len = _base64Str.length;
		let extra_Zero_Count = 0;
		/**
		 *计算在进行BASE64编码的时候，补了几个0
		 */
		if (_base64Str.charAt(_len - 1) === '=') {
			// alert(_base64Str.charAt(_len-1));
			// alert(_base64Str.charAt(_len-2));
			if (_base64Str.charAt(_len - 2) === '=') { // 两个等号说明补了4个0
				extra_Zero_Count = 4;
				_base64Str = _base64Str.substring(0, _len - 2);
			} else { // 一个等号说明补了2个0
				extra_Zero_Count = 2;
				_base64Str = _base64Str.substring(0, _len - 1);
			}
		}

		let binaryArray = [];
		for (var i = 0, len = _base64Str.length; i < len; ++i) {
			let c = _base64Str.charAt(i);
			for (let j = 0, size = BASE64_MAPPING.length; j < size; ++j) {
				if (c === BASE64_MAPPING[j]) {
					let _tmp = _toBinary(j);
					/* 不足6位的补0 */
					let _tmpLen = _tmp.length;
					if (6 - _tmpLen > 0) {
						for (let k = 6 - _tmpLen; k > 0; --k) {
							_tmp.unshift(0);
						}
					}
					binaryArray = binaryArray.concat(_tmp);
					break;
				}
			}
		}

		if (extra_Zero_Count > 0) {
			binaryArray = binaryArray.slice(0, binaryArray.length - extra_Zero_Count);
		}

		let unicode = [];
		let unicodeBinary = [];
		for (var i = 0, len = binaryArray.length; i < len;) {
			if (binaryArray[i] === 0) {
				unicode = unicode.concat(_toDecimal(binaryArray.slice(i, i + 8)));
				i += 8;
			} else {
				let sum = 0;
				while (i < len) {
					if (binaryArray[i] === 1) {
						++sum;
					} else {
						break;
					}
					++i;
				}
				unicodeBinary = unicodeBinary.concat(binaryArray.slice(i + 1, i + 8 - sum));
				i += 8 - sum;
				while (sum > 1) {
					unicodeBinary = unicodeBinary.concat(binaryArray.slice(i + 2, i + 8));
					i += 8;
					--sum;
				}
				unicode = unicode.concat(_toDecimal(unicodeBinary));
				unicodeBinary = [];
			}
		}
		// ---------直接转换为结果
		let strResult = '';
		for (var i = 0, len = unicode.length; i < len; ++i) {
			strResult += String.fromCharCode(unicode[i]);
		}
		return strResult;
	}
};

let rotateLeft = function (lValue, iShiftBits) {
	return (lValue << iShiftBits) | (lValue >>> (32 - iShiftBits));
};

let addUnsigned = function (lX, lY) {
	let lX4, lY4, lX8, lY8, lResult;
	lX8 = (lX & 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);
	}
};

let F = function (x, y, z) {
	return (x & y) | ((~x) & z);
};

let G = function (x, y, z) {
	return (x & z) | (y & (~z));
};

let H = function (x, y, z) {
	return (x ^ y ^ z);
};

let I = function (x, y, z) {
	return (y ^ (x | (~z)));
};

let FF = function (a, b, c, d, x, s, ac) {
	a = addUnsigned(a, addUnsigned(addUnsigned(F(b, c, d), x), ac));
	return addUnsigned(rotateLeft(a, s), b);
};

let GG = function (a, b, c, d, x, s, ac) {
	a = addUnsigned(a, addUnsigned(addUnsigned(G(b, c, d), x), ac));
	return addUnsigned(rotateLeft(a, s), b);
};

let HH = function (a, b, c, d, x, s, ac) {
	a = addUnsigned(a, addUnsigned(addUnsigned(H(b, c, d), x), ac));
	return addUnsigned(rotateLeft(a, s), b);
};

let II = function (a, b, c, d, x, s, ac) {
	a = addUnsigned(a, addUnsigned(addUnsigned(I(b, c, d), x), ac));
	return addUnsigned(rotateLeft(a, s), b);
};

let convertToWordArray = function (string) {
	let lWordCount;
	let lMessageLength = string.length;
	let lNumberOfWordsTempOne = lMessageLength + 8;
	let lNumberOfWordsTempTwo = (lNumberOfWordsTempOne - (lNumberOfWordsTempOne % 64)) / 64;
	let lNumberOfWords = (lNumberOfWordsTempTwo + 1) * 16;
	let lWordArray = Array(lNumberOfWords - 1);
	let lBytePosition = 0;
	let lByteCount = 0;
	while (lByteCount < lMessageLength) {
		lWordCount = (lByteCount - (lByteCount % 4)) / 4;
		lBytePosition = (lByteCount % 4) * 8;
		lWordArray[lWordCount] = (lWordArray[lWordCount] | (string.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;
};

let wordToHex = function (lValue) {
	let WordToHexValue = '', WordToHexValueTemp = '', lByte, lCount;
	for (lCount = 0; lCount <= 3; lCount++) {
		lByte = (lValue >>> (lCount * 8)) & 255;
		WordToHexValueTemp = '0' + lByte.toString(16);
		WordToHexValue = WordToHexValue + WordToHexValueTemp.substr(WordToHexValueTemp.length - 2, 2);
	}
	return WordToHexValue;
};

let uTF8Encode = function (str) {
	str = str.replace(/\x0d\x0a/g, '\x0a');
	let output = '';
	for (let n = 0; n < str.length; n++) {
		let c = str.charCodeAt(n);
		if (c < 128) {
			output += String.fromCharCode(c);
		} else if ((c > 127) && (c < 2048)) {
			output += String.fromCharCode((c >> 6) | 192);
			output += String.fromCharCode((c & 63) | 128);
		} else {
			output += String.fromCharCode((c >> 12) | 224);
			output += String.fromCharCode(((c >> 6) & 63) | 128);
			output += String.fromCharCode((c & 63) | 128);
		}
	}
	return output;
};

var md5 = function (string) {
	let x = Array();
	let k, AA, BB, CC, DD, a, b, c, d;
	let S11 = 7, S12 = 12, S13 = 17, S14 = 22;
	let S21 = 5, S22 = 9, S23 = 14, S24 = 20;
	let S31 = 4, S32 = 11, S33 = 16, S34 = 23;
	let S41 = 6, S42 = 10, S43 = 15, S44 = 21;
	string = uTF8Encode(string);
	x = convertToWordArray(string);
	a = 0x67452301;
	b = 0xEFCDAB89;
	c = 0x98BADCFE;
	d = 0x10325476;
	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);
	}
	let tempValue = wordToHex(a) + wordToHex(b) + wordToHex(c) + wordToHex(d);
	return tempValue.toLowerCase();
};
let base64EncodeChars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
let base64DecodeChars = new Array(-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, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -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, 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, 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);
/**
 * base64编码
 * @param {Object} str
 */
function base64encode (str) {
	let out, i, len;
	let c1, c2, c3;
	len = str.length;
	i = 0;
	out = '';
	while (i < len) {
		c1 = str.charCodeAt(i++) & 0xff;
		if (i === len) {
			out += base64EncodeChars.charAt(c1 >> 2);
			out += base64EncodeChars.charAt((c1 & 0x3) << 4);
			out += '==';
			break;
		}
		c2 = str.charCodeAt(i++);
		if (i === len) {
			out += base64EncodeChars.charAt(c1 >> 2);
			out += base64EncodeChars.charAt(((c1 & 0x3) << 4) | ((c2 & 0xF0) >> 4));
			out += base64EncodeChars.charAt((c2 & 0xF) << 2);
			out += '=';
			break;
		}
		c3 = str.charCodeAt(i++);
		out += base64EncodeChars.charAt(c1 >> 2);
		out += base64EncodeChars.charAt(((c1 & 0x3) << 4) | ((c2 & 0xF0) >> 4));
		out += base64EncodeChars.charAt(((c2 & 0xF) << 2) | ((c3 & 0xC0) >> 6));
		out += base64EncodeChars.charAt(c3 & 0x3F);
	}
	return out;
}
/**
 * base64解码
 * @param {Object} str
 */
function base64decode (str) {
	let c1, c2, c3, c4;
	let i, len, out;
	len = str.length;
	i = 0;
	out = '';
	while (i < len) {
		/* c1 */
		do {
			c1 = base64DecodeChars[str.charCodeAt(i++) & 0xff];
		}
		while (i < len && c1 === -1);
		if (c1 === -1) { break; }
		/* c2 */
		do {
			c2 = base64DecodeChars[str.charCodeAt(i++) & 0xff];
		}
		while (i < len && c2 === -1);
		if (c2 === -1) { break; }
		out += String.fromCharCode((c1 << 2) | ((c2 & 0x30) >> 4));
		/* c3 */
		do {
			c3 = str.charCodeAt(i++) & 0xff;
			if (c3 === 61) { return out; }
			c3 = base64DecodeChars[c3];
		}
		while (i < len && c3 === -1);
		if (c3 === -1) { break; }
		out += String.fromCharCode(((c2 & 0XF) << 4) | ((c3 & 0x3C) >> 2));
		/* c4 */
		do {
			c4 = str.charCodeAt(i++) & 0xff;
			if (c4 === 61) { return out; }
			c4 = base64DecodeChars[c4];
		}
		while (i < len && c4 === -1);
		if (c4 === -1) { break; }
		out += String.fromCharCode(((c3 & 0x03) << 6) | c4);
	}
	return out;
}

export default CryptoJS;