git init1.1.103

8 files changed, 2094 insertions, 0 deletions

diff --git a/http/3rdParty/yaMD5/test/lib/ireal-md5.js b/http/3rdParty/yaMD5/test/lib/ireal-md5.js
new file mode 100644
index 0000000..ad69af4
--- /dev/null
+++ b/http/3rdParty/yaMD5/test/lib/ireal-md5.js
@@ -0,0 +1,346 @@
+// https://github.com/iReal/FastMD5
+;md5 = /* window.md5 || */ (function(window) {
+	var $0 = [], // res
+		$1 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // tail
+		$2 = [], // md5blks
+		$3 = [128, 32768, 8388608, -2147483648], // c4
+		$4 = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"], // c16
+		$5 = [0, 8, 16, 24]; // cS
+
+	function encode(s, sLen) {
+		var utf = "", start = end = 0;
+
+		for(var i = 0;i < sLen;i++) {
+			var c1 = s.charCodeAt(i),
+				enc = null;
+
+			if(c1 < 128) {
+				end++;
+			}else if(c1 > 127 && c1 < 2048) {
+				enc = String.fromCharCode((c1 >> 6) | 192, (c1 & 63) | 128);
+			}else{
+				enc = String.fromCharCode((c1 >> 12) | 224, ((c1 >> 6) & 63) | 128, (c1 & 63) | 128);
+			}
+			if(enc != null) {
+				if(end > start) {
+					utf += s.slice(start, end);
+				}
+				utf += enc;
+				start = end = i + 1;
+			}
+		}
+
+		if(end > start) {
+			utf += s.slice(start, sLen);
+		}
+
+		return utf;
+	}
+
+	function md51(s, sLen) {
+		var state,
+			N = sLen,
+			i;
+
+		s += "";
+
+		if(sLen > 63) {
+			md5blk(s.substring(0, 64));
+			state = md5cycle($2[0], $2[1], $2[2], $2[3], $2[4], $2[5], $2[6], $2[7], $2[8], $2[9], $2[10], $2[11], $2[12], $2[13], $2[14], $2[15])
+
+			for(i = 128;i <= sLen;i += 64) {
+				md5blk(s.substring(i - 64, i));
+				state = md5cycleAdd(state[0], state[1], state[2], state[3], $2[0], $2[1], $2[2], $2[3], $2[4], $2[5], $2[6], $2[7], $2[8], $2[9], $2[10], $2[11], $2[12], $2[13], $2[14], $2[15]);
+			}
+
+			s = s.substring(i - 64);
+			N = s.length;
+		}
+
+		for(i = ~~(N / 4);i < 16;i++) {
+			$1[i] = 0;
+		}
+
+		for(i = 0;i < N;i++) {
+			var I = i % 4;
+			if(I == 0) {
+				$1[i >> 2] = s.charCodeAt(i) << $5[I];
+				continue;
+			}
+
+			$1[i >> 2] |= s.charCodeAt(i) << $5[I];
+		}
+		$1[i >> 2] |= $3[i % 4];
+
+		if(i > 55) {
+			state = md5cycleAdd(1732584193, 4023233417, 2562383102, 271733878, $1[0], $1[1], $1[2], $1[3], $1[4], $1[5], $1[6], $1[7], $1[8], $1[9], $1[10], $1[11], $1[12], $1[13], $1[14], $1[15]);
+
+			return md5cycleAdd(state[0], state[1], state[2], state[3], 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, sLen * 8, 0);
+		}
+
+		return !state ? md5cycle($1[0], $1[1], $1[2], $1[3], $1[4], $1[5], $1[6], $1[7], $1[8], $1[9], $1[10], $1[11], $1[12], $1[13], sLen * 8, $1[15]) : md5cycleAdd(state[0], state[1], state[2], state[3], $1[0], $1[1], $1[2], $1[3], $1[4], $1[5], $1[6], $1[7], $1[8], $1[9], $1[10], $1[11], $1[12], $1[13], sLen * 8, $1[15]);
+	}
+
+	function md5blk(s) {
+		var i = 16;
+		while(i--) {
+			var I = i << 2;
+			$2[i] = s.charCodeAt(I) + (s.charCodeAt(I + 1) << 8) + (s.charCodeAt(I + 2) << 16) + (s.charCodeAt(I + 3) << 24);
+		}
+	}
+
+	function md5_main(s, enc, arr) {
+		var sLen = s.length;
+		if(enc) {
+			s = encode(s, sLen);
+			sLen = s.length;
+		}
+		s = md51(s, sLen);
+
+		var tmp = s[0];$0[1] = $4[tmp & 15];
+		tmp >>= 4;$0[0] = $4[tmp & 15];
+		tmp >>= 4;$0[3] = $4[tmp & 15];
+		tmp >>= 4;$0[2] = $4[tmp & 15];
+		tmp >>= 4;$0[5] = $4[tmp & 15];
+		tmp >>= 4;$0[4] = $4[tmp & 15];
+		tmp >>= 4;$0[7] = $4[tmp & 15];
+		tmp >>= 4;$0[6] = $4[tmp & 15];
+
+		tmp = s[1];$0[9] = $4[tmp & 15];
+		tmp >>= 4;$0[8] = $4[tmp & 15];
+		tmp >>= 4;$0[11] = $4[tmp & 15];
+		tmp >>= 4;$0[10] = $4[tmp & 15];
+		tmp >>= 4;$0[13] = $4[tmp & 15];
+		tmp >>= 4;$0[12] = $4[tmp & 15];
+		tmp >>= 4;$0[15] = $4[tmp & 15];
+		tmp >>= 4;$0[14] = $4[tmp & 15];
+
+		tmp = s[2];$0[17] = $4[tmp & 15];
+		tmp >>= 4;$0[16] = $4[tmp & 15];
+		tmp >>= 4;$0[19] = $4[tmp & 15];
+		tmp >>= 4;$0[18] = $4[tmp & 15];
+		tmp >>= 4;$0[21] = $4[tmp & 15];
+		tmp >>= 4;$0[20] = $4[tmp & 15];
+		tmp >>= 4;$0[23] = $4[tmp & 15];
+		tmp >>= 4;$0[22] = $4[tmp & 15];
+
+		tmp = s[3];$0[25] = $4[tmp & 15];
+		tmp >>= 4;$0[24] = $4[tmp & 15];
+		tmp >>= 4;$0[27] = $4[tmp & 15];
+		tmp >>= 4;$0[26] = $4[tmp & 15];
+		tmp >>= 4;$0[29] = $4[tmp & 15];
+		tmp >>= 4;$0[28] = $4[tmp & 15];
+		tmp >>= 4;$0[31] = $4[tmp & 15];
+		tmp >>= 4;$0[30] = $4[tmp & 15];
+
+		return arr ? $0 : $0[0] + $0[1] + $0[2] + $0[3] + $0[4] + $0[5] + $0[6] + $0[7] + $0[8] + $0[9] + $0[10] + $0[11] + $0[12] + $0[13] + $0[14] + $0[15] + $0[16] + $0[17] + $0[18] + $0[19] + $0[20] + $0[21] + $0[22] + $0[23] + $0[24] + $0[25] + $0[26] + $0[27] + $0[28] + $0[29] + $0[30] + $0[31];
+	}
+
+	var md5_asmjs = (function(std, env, buf) {
+		"use asm";
+
+		var TA = new std.Int32Array(buf);
+
+		function R(q, a, b, x, s1, s2, t) {
+			q = q|0;
+			a = a|0;
+			b = b|0;
+			x = x|0;
+			s1 = s1|0;
+			s2 = s2|0;
+			t = t|0;
+
+			a = a + q + x + t;
+			return ((a << s1 | a >>> s2) + b) << 0;
+		}
+
+		function md5cycle(k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15) {
+			k0 = k0|0;
+			k1 = k1|0;
+			k2 = k2|0;
+			k3 = k3|0;
+			k4 = k4|0;
+			k5 = k5|0;
+			k6 = k6|0;
+			k7 = k7|0;
+			k8 = k8|0;
+			k9 = k9|0;
+			k10 = k10|0;
+			k11 = k11|0;
+			k12 = k12|0;
+			k13 = k13|0;
+			k14 = k14|0;
+			k15 = k15|0;
+
+			md5_rounds(1732584193, -271733879, -1732584194, 271733878, k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, 1);
+
+			TA[0] = (TA[0] + 1732584193) << 0;
+			TA[1] = (TA[1] - 271733879) << 0;
+			TA[2] = (TA[2] - 1732584194) << 0;
+			TA[3] = (TA[3] + 271733878) << 0;
+
+			return TA;
+		}
+
+		function md5cycleAdd(x0, x1, x2, x3, k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15) {
+			x0 = x0|0;
+			x1 = x1|0;
+			x2 = x2|0;
+			x3 = x3|0;
+			k0 = k0|0;
+			k1 = k1|0;
+			k2 = k2|0;
+			k3 = k3|0;
+			k4 = k4|0;
+			k5 = k5|0;
+			k6 = k6|0;
+			k7 = k7|0;
+			k8 = k8|0;
+			k9 = k9|0;
+			k10 = k10|0;
+			k11 = k11|0;
+			k12 = k12|0;
+			k13 = k13|0;
+			k14 = k14|0;
+			k15 = k15|0;
+
+			md5_rounds(x0, x1, x2, x3, k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, 0);
+
+			TA[0] = (TA[0] + x0) << 0;
+			TA[1] = (TA[1] + x1) << 0;
+			TA[2] = (TA[2] + x2) << 0;
+			TA[3] = (TA[3] + x3) << 0;
+
+			return TA;
+		}
+
+		function md5_rounds(a, b, c, d, k0, k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, simple) {
+			a = a|0;
+			b = b|0;
+			c = c|0;
+			d = d|0;
+			k0 = k0|0;
+			k1 = k1|0;
+			k2 = k2|0;
+			k3 = k3|0;
+			k4 = k4|0;
+			k5 = k5|0;
+			k6 = k6|0;
+			k7 = k7|0;
+			k8 = k8|0;
+			k9 = k9|0;
+			k10 = k10|0;
+			k11 = k11|0;
+			k12 = k12|0;
+			k13 = k13|0;
+			k14 = k14|0;
+			k15 = k15|0;
+			simple = simple|0;
+			var bc = bc|0;
+			var da = da|0;
+
+			if(simple == 1|0) {
+				a = k0 - 680876937;
+				a = ((a << 7 | a >>> 25) - 271733879) << 0;
+				d = k1 - 117830708 + ((2004318071 & a) ^ -1732584194);
+				d = ((d << 12 | d >>> 20) + a) << 0;
+				c = k2 - 1126478375 + (((a ^ -271733879) & d) ^ -271733879);
+				c = ((c << 17 | c >>> 15) + d) << 0;
+				b = k3 - 1316259209 + (((d ^ a) & c) ^ a);
+				b = ((b << 22 | b >>> 10) + c) << 0;
+			}else{
+				a = R(((c ^ d) & b) ^ d, a, b, k0, 7, 25, -680876936);
+				d = R(((b ^ c) & a) ^ c, d, a, k1, 12, 20, -389564586);
+				c = R(((a ^ b) & d) ^ b, c, d, k2, 17, 15, 606105819);
+				b = R(((d ^ a) & c) ^ a, b, c, k3, 22, 10, -1044525330);
+			}
+
+			a = R(((c ^ d) & b) ^ d, a, b, k4, 7, 25, -176418897);
+			d = R(((b ^ c) & a) ^ c, d, a, k5, 12, 20, 1200080426);
+			c = R(((a ^ b) & d) ^ b, c, d, k6, 17, 15, -1473231341);
+			b = R(((d ^ a) & c) ^ a, b, c, k7, 22, 10, -45705983);
+			a = R(((c ^ d) & b) ^ d, a, b, k8, 7, 25, 1770035416);
+			d = R(((b ^ c) & a) ^ c, d, a, k9, 12, 20, -1958414417);
+			c = R(((a ^ b) & d) ^ b, c, d, k10, 17, 15, -42063);
+			b = R(((d ^ a) & c) ^ a, b, c, k11, 22, 10, -1990404162);
+			a = R(((c ^ d) & b) ^ d, a, b, k12, 7, 25, 1804603682);
+			d = R(((b ^ c) & a) ^ c, d, a, k13, 12, 20, -40341101);
+			c = R(((a ^ b) & d) ^ b, c, d, k14, 17, 15, -1502002290);
+			b = R(((d ^ a) & c) ^ a, b, c, k15, 22, 10, 1236535329);
+
+			a = R(((b ^ c) & d) ^ c, a, b, k1, 5, 27, -165796510);
+			d = R(((a ^ b) & c) ^ b, d, a, k6, 9, 23, -1069501632);
+			c = R(((d ^ a) & b) ^ a, c, d, k11, 14, 18, 643717713);
+			b = R(((c ^ d) & a) ^ d, b, c, k0, 20, 12, -373897302);
+			a = R(((b ^ c) & d) ^ c, a, b, k5, 5, 27, -701558691);
+			d = R(((a ^ b) & c) ^ b, d, a, k10, 9, 23, 38016083);
+			c = R(((d ^ a) & b) ^ a, c, d, k15, 14, 18, -660478335);
+			b = R(((c ^ d) & a) ^ d, b, c, k4, 20, 12, -405537848);
+			a = R(((b ^ c) & d) ^ c, a, b, k9, 5, 27, 568446438);
+			d = R(((a ^ b) & c) ^ b, d, a, k14, 9, 23, -1019803690);
+			c = R(((d ^ a) & b) ^ a, c, d, k3, 14, 18, -187363961);
+			b = R(((c ^ d) & a) ^ d, b, c, k8, 20, 12, 1163531501);
+			a = R(((b ^ c) & d) ^ c, a, b, k13, 5, 27, -1444681467);
+			d = R(((a ^ b) & c) ^ b, d, a, k2, 9, 23, -51403784);
+			c = R(((d ^ a) & b) ^ a, c, d, k7, 14, 18, 1735328473);
+			b = R(((c ^ d) & a) ^ d, b, c, k12, 20, 12, -1926607734);
+
+			bc = b ^ c;
+			a = R(bc ^ d, a, b, k5, 4, 28, -378558);
+			d = R(bc ^ a, d, a, k8, 11, 21, -2022574463);
+			da = d ^ a;
+			c = R(da ^ b, c, d, k11, 16, 16, 1839030562);
+			b = R(da ^ c, b, c, k14, 23, 9, -35309556);
+			bc = b ^ c;
+			a = R(bc ^ d, a, b, k1, 4, 28, -1530992060);
+			d = R(bc ^ a, d, a, k4, 11, 21, 1272893353);
+			da = d ^ a;
+			c = R(da ^ b, c, d, k7, 16, 16, -155497632);
+			b = R(da ^ c, b, c, k10, 23, 9, -1094730640);
+			bc = b ^ c;
+			a = R(bc ^ d, a, b, k13, 4, 28, 681279174);
+			d = R(bc ^ a, d, a, k0, 11, 21, -358537222);
+			da = d ^ a;
+			c = R(da ^ b, c, d, k3, 16, 16, -722521979);
+			b = R(da ^ c, b, c, k6, 23, 9, 76029189);
+			bc = b ^ c;
+			a = R(bc ^ d, a, b, k9, 4, 28, -640364487);
+			d = R(bc ^ a, d, a, k12, 11, 21, -421815835);
+			da = d ^ a;
+			c = R(da ^ b, c, d, k15, 16, 16, 530742520);
+			b = R(da ^ c, b, c, k2, 23, 9, -995338651);
+
+			a = R(c ^ (b | ~d), a, b, k0, 6, 26, -198630844);
+			d = R(b ^ (a | ~c), d, a, k7, 10, 22, 1126891415);
+			c = R(a ^ (d | ~b), c, d, k14, 15, 17, -1416354905);
+			b = R(d ^ (c | ~a), b, c, k5, 21, 11, -57434055);
+			a = R(c ^ (b | ~d), a, b, k12, 6, 26, 1700485571);
+			d = R(b ^ (a | ~c), d, a, k3, 10, 22, -1894986606);
+			c = R(a ^ (d | ~b), c, d, k10, 15, 17, -1051523);
+			b = R(d ^ (c | ~a), b, c, k1, 21, 11, -2054922799);
+			a = R(c ^ (b | ~d), a, b, k8, 6, 26, 1873313359);
+			d = R(b ^ (a | ~c), d, a, k15, 10, 22, -30611744);
+			c = R(a ^ (d | ~b), c, d, k6, 15, 17, -1560198380);
+			b = R(d ^ (c | ~a), b, c, k13, 21, 11, 1309151649);
+			a = R(c ^ (b | ~d), a, b, k4, 6, 26, -145523070);
+			d = R(b ^ (a | ~c), d, a, k11, 10, 22, -1120210379);
+			c = R(a ^ (d | ~b), c, d, k2, 15, 17, 718787259);
+			b = R(d ^ (c | ~a), b, c, k9, 21, 11, -343485551);
+
+			TA[0] = a;
+			TA[1] = b;
+			TA[2] = c;
+			TA[3] = d;
+		}
+
+		return {
+			md5cycle: md5cycle,
+			md5cycleAdd: md5cycleAdd
+		};
+	})(window, null, new ArrayBuffer(16));
+
+	var md5cycle = md5_asmjs.md5cycle,
+		md5cycleAdd = md5_asmjs.md5cycleAdd;
+
+	return md5_main;
+})(window);
diff --git a/http/3rdParty/yaMD5/test/lib/izumo-md5.js b/http/3rdParty/yaMD5/test/lib/izumo-md5.js
new file mode 100644
index 0000000..bf400f6
--- /dev/null
+++ b/http/3rdParty/yaMD5/test/lib/izumo-md5.js
@@ -0,0 +1,206 @@
+// http://www.onicos.com/staff/iz/amuse/javascript/expert/md5.txt
+var izumoMD5 = (function(){
+
+/* md5.js - MD5 Message-Digest
+ * Copyright (C) 1999,2002 Masanao Izumo <iz@onicos.co.jp>
+ * Version: 2.0.0
+ * LastModified: May 13 2002
+ *
+ * This program is free software.  You can redistribute it and/or modify
+ * it without any warranty.  This library calculates the MD5 based on RFC1321.
+ * See RFC1321 for more information and algorism.
+ */
+
+/* Interface:
+ * md5_128bits = MD5_hash(data);
+ * md5_hexstr = MD5_hexhash(data);
+ */
+
+/* ChangeLog
+ * 2002/05/13: Version 2.0.0 released
+ * NOTICE: API is changed.
+ * 2002/04/15: Bug fix about MD5 length.
+ */
+
+
+//    md5_T[i] = parseInt(Math.abs(Math.sin(i)) * 4294967296.0);
+var MD5_T = new Array(0x00000000, 0xd76aa478, 0xe8c7b756, 0x242070db,
+		      0xc1bdceee, 0xf57c0faf, 0x4787c62a, 0xa8304613,
+		      0xfd469501, 0x698098d8, 0x8b44f7af, 0xffff5bb1,
+		      0x895cd7be, 0x6b901122, 0xfd987193, 0xa679438e,
+		      0x49b40821, 0xf61e2562, 0xc040b340, 0x265e5a51,
+		      0xe9b6c7aa, 0xd62f105d, 0x02441453, 0xd8a1e681,
+		      0xe7d3fbc8, 0x21e1cde6, 0xc33707d6, 0xf4d50d87,
+		      0x455a14ed, 0xa9e3e905, 0xfcefa3f8, 0x676f02d9,
+		      0x8d2a4c8a, 0xfffa3942, 0x8771f681, 0x6d9d6122,
+		      0xfde5380c, 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60,
+		      0xbebfbc70, 0x289b7ec6, 0xeaa127fa, 0xd4ef3085,
+		      0x04881d05, 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8,
+		      0xc4ac5665, 0xf4292244, 0x432aff97, 0xab9423a7,
+		      0xfc93a039, 0x655b59c3, 0x8f0ccc92, 0xffeff47d,
+		      0x85845dd1, 0x6fa87e4f, 0xfe2ce6e0, 0xa3014314,
+		      0x4e0811a1, 0xf7537e82, 0xbd3af235, 0x2ad7d2bb,
+		      0xeb86d391);
+
+var MD5_round1 = new Array(new Array( 0, 7, 1), new Array( 1,12, 2),
+			   new Array( 2,17, 3), new Array( 3,22, 4),
+			   new Array( 4, 7, 5), new Array( 5,12, 6),
+			   new Array( 6,17, 7), new Array( 7,22, 8),
+			   new Array( 8, 7, 9), new Array( 9,12,10),
+			   new Array(10,17,11), new Array(11,22,12),
+			   new Array(12, 7,13), new Array(13,12,14),
+			   new Array(14,17,15), new Array(15,22,16));
+
+var MD5_round2 = new Array(new Array( 1, 5,17), new Array( 6, 9,18),
+			   new Array(11,14,19), new Array( 0,20,20),
+			   new Array( 5, 5,21), new Array(10, 9,22),
+			   new Array(15,14,23), new Array( 4,20,24),
+			   new Array( 9, 5,25), new Array(14, 9,26),
+			   new Array( 3,14,27), new Array( 8,20,28),
+			   new Array(13, 5,29), new Array( 2, 9,30),
+			   new Array( 7,14,31), new Array(12,20,32));
+
+var MD5_round3 = new Array(new Array( 5, 4,33), new Array( 8,11,34),
+			   new Array(11,16,35), new Array(14,23,36),
+			   new Array( 1, 4,37), new Array( 4,11,38),
+			   new Array( 7,16,39), new Array(10,23,40),
+			   new Array(13, 4,41), new Array( 0,11,42),
+			   new Array( 3,16,43), new Array( 6,23,44),
+			   new Array( 9, 4,45), new Array(12,11,46),
+			   new Array(15,16,47), new Array( 2,23,48));
+
+var MD5_round4 = new Array(new Array( 0, 6,49), new Array( 7,10,50),
+			   new Array(14,15,51), new Array( 5,21,52),
+			   new Array(12, 6,53), new Array( 3,10,54),
+			   new Array(10,15,55), new Array( 1,21,56),
+			   new Array( 8, 6,57), new Array(15,10,58),
+			   new Array( 6,15,59), new Array(13,21,60),
+			   new Array( 4, 6,61), new Array(11,10,62),
+			   new Array( 2,15,63), new Array( 9,21,64));
+
+function MD5_F(x, y, z) { return (x & y) | (~x & z); }
+function MD5_G(x, y, z) { return (x & z) | (y & ~z); }
+function MD5_H(x, y, z) { return x ^ y ^ z;          }
+function MD5_I(x, y, z) { return y ^ (x | ~z);       }
+
+var MD5_round = new Array(new Array(MD5_F, MD5_round1),
+			  new Array(MD5_G, MD5_round2),
+			  new Array(MD5_H, MD5_round3),
+			  new Array(MD5_I, MD5_round4));
+
+function MD5_pack(n32) {
+  return String.fromCharCode(n32 & 0xff) +
+	 String.fromCharCode((n32 >>> 8) & 0xff) +
+	 String.fromCharCode((n32 >>> 16) & 0xff) +
+	 String.fromCharCode((n32 >>> 24) & 0xff);
+}
+
+function MD5_unpack(s4) {
+  return  s4.charCodeAt(0)        |
+	 (s4.charCodeAt(1) <<  8) |
+	 (s4.charCodeAt(2) << 16) |
+	 (s4.charCodeAt(3) << 24);
+}
+
+function MD5_number(n) {
+  while (n < 0)
+    n += 4294967296;
+  while (n > 4294967295)
+    n -= 4294967296;
+  return n;
+}
+
+function MD5_apply_round(x, s, f, abcd, r) {
+  var a, b, c, d;
+  var kk, ss, ii;
+  var t, u;
+
+  a = abcd[0];
+  b = abcd[1];
+  c = abcd[2];
+  d = abcd[3];
+  kk = r[0];
+  ss = r[1];
+  ii = r[2];
+
+  u = f(s[b], s[c], s[d]);
+  t = s[a] + u + x[kk] + MD5_T[ii];
+  t = MD5_number(t);
+  t = ((t<<ss) | (t>>>(32-ss)));
+  t += s[b];
+  s[a] = MD5_number(t);
+}
+
+function MD5_hash(data) {
+  var abcd, x, state, s;
+  var len, index, padLen, f, r;
+  var i, j, k;
+  var tmp;
+
+  state = new Array(0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476);
+  len = data.length;
+  index = len & 0x3f;
+  padLen = (index < 56) ? (56 - index) : (120 - index);
+  if(padLen > 0) {
+    data += "\x80";
+    for(i = 0; i < padLen - 1; i++)
+      data += "\x00";
+  }
+  data += MD5_pack(len * 8);
+  data += MD5_pack(0);
+  len  += padLen + 8;
+  abcd = new Array(0, 1, 2, 3);
+  x    = new Array(16);
+  s    = new Array(4);
+
+  for(k = 0; k < len; k += 64) {
+    for(i = 0, j = k; i < 16; i++, j += 4) {
+      x[i] = data.charCodeAt(j) |
+	    (data.charCodeAt(j + 1) <<  8) |
+	    (data.charCodeAt(j + 2) << 16) |
+	    (data.charCodeAt(j + 3) << 24);
+    }
+    for(i = 0; i < 4; i++)
+      s[i] = state[i];
+    for(i = 0; i < 4; i++) {
+      f = MD5_round[i][0];
+      r = MD5_round[i][1];
+      for(j = 0; j < 16; j++) {
+	MD5_apply_round(x, s, f, abcd, r[j]);
+	tmp = abcd[0];
+	abcd[0] = abcd[3];
+	abcd[3] = abcd[2];
+	abcd[2] = abcd[1];
+	abcd[1] = tmp;
+      }
+    }
+
+    for(i = 0; i < 4; i++) {
+      state[i] += s[i];
+      state[i] = MD5_number(state[i]);
+    }
+  }
+
+  return MD5_pack(state[0]) +
+	 MD5_pack(state[1]) +
+	 MD5_pack(state[2]) +
+	 MD5_pack(state[3]);
+}
+
+function MD5_hexhash(data) {
+    var i, out, c;
+    var bit128;
+
+    bit128 = MD5_hash(data);
+    out = "";
+    for(i = 0; i < 16; i++) {
+	c = bit128.charCodeAt(i);
+	out += "0123456789abcdef".charAt((c>>4) & 0xf);
+	out += "0123456789abcdef".charAt(c & 0xf);
+    }
+    return out;
+}
+
+return MD5_hexhash;
+
+})();
diff --git a/http/3rdParty/yaMD5/test/lib/jbt-md5.js b/http/3rdParty/yaMD5/test/lib/jbt-md5.js
new file mode 100644
index 0000000..4738877
--- /dev/null
+++ b/http/3rdParty/yaMD5/test/lib/jbt-md5.js
@@ -0,0 +1,74 @@
+// https://github.com/jbt/js-crypto
+md5 = function(sixteen){
+
+  var k = [],i=0;
+
+  for(;i<64;){
+    k[i] = 0|(Math.abs(Math.sin(++i)) * 4294967296);
+  }
+
+  function add(x, y){
+    return (((x>>1)+(y>>1))<<1)+(x&1)+(y&1) ;
+    //var msw = (x >> sixteen) + (y >> sixteen) + ((y=(x & ffff) + (y & ffff)) >> sixteen);
+    //return (msw << sixteen) | (y & ffff);
+  }
+
+  var calcMD5 = function(str){
+    var b,c,d,j,
+        x = [],
+        str2 = unescape(encodeURI(str)),
+        a = str2.length,
+        h = [b=1732584193,c=-271733879,~b,~c],
+        i=0;
+
+    for(;i<=a;) x[i >> 2] |= (str2.charCodeAt(i)||128) << 8*(i++ % 4);
+    x[str=(a+8 >> 6)*sixteen+14] = a * 8;
+    i = 0;
+
+    for(; i < str; i += sixteen){
+      a = h,j=0;
+      for(;j<64;){
+        a = [
+          d = a[3],
+          add(
+            b = a[1] ,
+            (d = add(
+              add(
+                a[0],
+                [
+                  b&(c=a[2]) | ~b&d,
+                  d&b | ~d&c,
+                  b^c^d,
+                  c^(b|~d)
+                ][a=j>>4]
+              ),
+              add(
+                k[j],
+                x[[
+                  j,
+                  5*j+1,
+                  3*j+5,
+                  7*j
+                ][a]%sixteen+i]
+              )
+            )) << (a =[
+              7, 12, 17, 22,
+              5,  9, 14, 20,
+              4, 11, sixteen, 23,
+              6, 10, 15, 21
+            ][4*a+j++%4]) | d >>> 32-a
+          ),
+          b,
+          c
+        ];
+      }
+      for(j=4;j;) h[--j] = add(h[j], a[j]);
+    }
+
+    str = '';
+    for(;j<32;) str += ((h[j>>3] >> ((1^j++&7)*4)) & 15).toString(sixteen);
+
+    return str;
+  };
+  return calcMD5;
+}(16);
diff --git a/http/3rdParty/yaMD5/test/lib/jkm-md5.js b/http/3rdParty/yaMD5/test/lib/jkm-md5.js
new file mode 100644
index 0000000..69ed9fe
--- /dev/null
+++ b/http/3rdParty/yaMD5/test/lib/jkm-md5.js
@@ -0,0 +1,191 @@
+// http://www.myersdaily.org/joseph/javascript/md5-text.html
+var jkmMD5 = (function(){
+
+function md5cycle(x, k) {
+var a = x[0], b = x[1], c = x[2], d = x[3];
+
+a = ff(a, b, c, d, k[0], 7, -680876936);
+d = ff(d, a, b, c, k[1], 12, -389564586);
+c = ff(c, d, a, b, k[2], 17,  606105819);
+b = ff(b, c, d, a, k[3], 22, -1044525330);
+a = ff(a, b, c, d, k[4], 7, -176418897);
+d = ff(d, a, b, c, k[5], 12,  1200080426);
+c = ff(c, d, a, b, k[6], 17, -1473231341);
+b = ff(b, c, d, a, k[7], 22, -45705983);
+a = ff(a, b, c, d, k[8], 7,  1770035416);
+d = ff(d, a, b, c, k[9], 12, -1958414417);
+c = ff(c, d, a, b, k[10], 17, -42063);
+b = ff(b, c, d, a, k[11], 22, -1990404162);
+a = ff(a, b, c, d, k[12], 7,  1804603682);
+d = ff(d, a, b, c, k[13], 12, -40341101);
+c = ff(c, d, a, b, k[14], 17, -1502002290);
+b = ff(b, c, d, a, k[15], 22,  1236535329);
+
+a = gg(a, b, c, d, k[1], 5, -165796510);
+d = gg(d, a, b, c, k[6], 9, -1069501632);
+c = gg(c, d, a, b, k[11], 14,  643717713);
+b = gg(b, c, d, a, k[0], 20, -373897302);
+a = gg(a, b, c, d, k[5], 5, -701558691);
+d = gg(d, a, b, c, k[10], 9,  38016083);
+c = gg(c, d, a, b, k[15], 14, -660478335);
+b = gg(b, c, d, a, k[4], 20, -405537848);
+a = gg(a, b, c, d, k[9], 5,  568446438);
+d = gg(d, a, b, c, k[14], 9, -1019803690);
+c = gg(c, d, a, b, k[3], 14, -187363961);
+b = gg(b, c, d, a, k[8], 20,  1163531501);
+a = gg(a, b, c, d, k[13], 5, -1444681467);
+d = gg(d, a, b, c, k[2], 9, -51403784);
+c = gg(c, d, a, b, k[7], 14,  1735328473);
+b = gg(b, c, d, a, k[12], 20, -1926607734);
+
+a = hh(a, b, c, d, k[5], 4, -378558);
+d = hh(d, a, b, c, k[8], 11, -2022574463);
+c = hh(c, d, a, b, k[11], 16,  1839030562);
+b = hh(b, c, d, a, k[14], 23, -35309556);
+a = hh(a, b, c, d, k[1], 4, -1530992060);
+d = hh(d, a, b, c, k[4], 11,  1272893353);
+c = hh(c, d, a, b, k[7], 16, -155497632);
+b = hh(b, c, d, a, k[10], 23, -1094730640);
+a = hh(a, b, c, d, k[13], 4,  681279174);
+d = hh(d, a, b, c, k[0], 11, -358537222);
+c = hh(c, d, a, b, k[3], 16, -722521979);
+b = hh(b, c, d, a, k[6], 23,  76029189);
+a = hh(a, b, c, d, k[9], 4, -640364487);
+d = hh(d, a, b, c, k[12], 11, -421815835);
+c = hh(c, d, a, b, k[15], 16,  530742520);
+b = hh(b, c, d, a, k[2], 23, -995338651);
+
+a = ii(a, b, c, d, k[0], 6, -198630844);
+d = ii(d, a, b, c, k[7], 10,  1126891415);
+c = ii(c, d, a, b, k[14], 15, -1416354905);
+b = ii(b, c, d, a, k[5], 21, -57434055);
+a = ii(a, b, c, d, k[12], 6,  1700485571);
+d = ii(d, a, b, c, k[3], 10, -1894986606);
+c = ii(c, d, a, b, k[10], 15, -1051523);
+b = ii(b, c, d, a, k[1], 21, -2054922799);
+a = ii(a, b, c, d, k[8], 6,  1873313359);
+d = ii(d, a, b, c, k[15], 10, -30611744);
+c = ii(c, d, a, b, k[6], 15, -1560198380);
+b = ii(b, c, d, a, k[13], 21,  1309151649);
+a = ii(a, b, c, d, k[4], 6, -145523070);
+d = ii(d, a, b, c, k[11], 10, -1120210379);
+c = ii(c, d, a, b, k[2], 15,  718787259);
+b = ii(b, c, d, a, k[9], 21, -343485551);
+
+x[0] = add32(a, x[0]);
+x[1] = add32(b, x[1]);
+x[2] = add32(c, x[2]);
+x[3] = add32(d, x[3]);
+
+}
+
+function cmn(q, a, b, x, s, t) {
+a = add32(add32(a, q), add32(x, t));
+return add32((a << s) | (a >>> (32 - s)), b);
+}
+
+function ff(a, b, c, d, x, s, t) {
+return cmn((b & c) | ((~b) & d), a, b, x, s, t);
+}
+
+function gg(a, b, c, d, x, s, t) {
+return cmn((b & d) | (c & (~d)), a, b, x, s, t);
+}
+
+function hh(a, b, c, d, x, s, t) {
+return cmn(b ^ c ^ d, a, b, x, s, t);
+}
+
+function ii(a, b, c, d, x, s, t) {
+return cmn(c ^ (b | (~d)), a, b, x, s, t);
+}
+
+function md51(s) {
+txt = '';
+var n = s.length,
+state = [1732584193, -271733879, -1732584194, 271733878], i;
+for (i=64; i<=s.length; i+=64) {
+md5cycle(state, md5blk(s.substring(i-64, i)));
+}
+s = s.substring(i-64);
+var tail = [0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0];
+for (i=0; i<s.length; i++)
+tail[i>>2] |= s.charCodeAt(i) << ((i%4) << 3);
+tail[i>>2] |= 0x80 << ((i%4) << 3);
+if (i > 55) {
+md5cycle(state, tail);
+for (i=0; i<16; i++) tail[i] = 0;
+}
+tail[14] = n*8;
+md5cycle(state, tail);
+return state;
+}
+
+/* there needs to be support for Unicode here,
+ * unless we pretend that we can redefine the MD-5
+ * algorithm for multi-byte characters (perhaps
+ * by adding every four 16-bit characters and
+ * shortening the sum to 32 bits). Otherwise
+ * I suggest performing MD-5 as if every character
+ * was two bytes--e.g., 0040 0025 = @%--but then
+ * how will an ordinary MD-5 sum be matched?
+ * There is no way to standardize text to something
+ * like UTF-8 before transformation; speed cost is
+ * utterly prohibitive. The JavaScript standard
+ * itself needs to look at this: it should start
+ * providing access to strings as preformed UTF-8
+ * 8-bit unsigned value arrays.
+ */
+function md5blk(s) { /* I figured global was faster.   */
+var md5blks = [], i; /* Andy King said do it this way. */
+for (i=0; i<64; i+=4) {
+md5blks[i>>2] = s.charCodeAt(i)
++ (s.charCodeAt(i+1) << 8)
++ (s.charCodeAt(i+2) << 16)
++ (s.charCodeAt(i+3) << 24);
+}
+return md5blks;
+}
+
+var hex_chr = '0123456789abcdef'.split('');
+
+function rhex(n)
+{
+var s='', j=0;
+for(; j<4; j++)
+s += hex_chr[(n >> (j * 8 + 4)) & 0x0F]
++ hex_chr[(n >> (j * 8)) & 0x0F];
+return s;
+}
+
+function hex(x) {
+for (var i=0; i<x.length; i++)
+x[i] = rhex(x[i]);
+return x.join('');
+}
+
+function md5(s) {
+return hex(md51(s));
+}
+
+/* this function is much faster,
+so if possible we use it. Some IEs
+are the only ones I know of that
+need the idiotic second function,
+generated by an if clause.  */
+
+function add32(a, b) {
+return (a + b) & 0xFFFFFFFF;
+}
+
+if (md5('hello') != '5d41402abc4b2a76b9719d911017c592') {
+function add32(x, y) {
+var lsw = (x & 0xFFFF) + (y & 0xFFFF),
+msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+return (msw << 16) | (lsw & 0xFFFF);
+}
+}
+
+return md5;
+
+})();
diff --git a/http/3rdParty/yaMD5/test/lib/paj-md5.js b/http/3rdParty/yaMD5/test/lib/paj-md5.js
new file mode 100644
index 0000000..1c4ce4b
--- /dev/null
+++ b/http/3rdParty/yaMD5/test/lib/paj-md5.js
@@ -0,0 +1,360 @@
+// http://pajhome.org.uk/crypt/md5/md5.html
+var pajMD5 = (function(){
+  /*
+   * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message
+   * Digest Algorithm, as defined in RFC 1321.
+   * Version 2.2 Copyright (C) Paul Johnston 1999 - 2009
+   * 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   */
+  
+  /*
+   * 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 rstr2hex(rstr_md5(str2rstr_utf8(s)));
+  }
+  
+  function b64_md5(s) {
+   return rstr2b64(rstr_md5(str2rstr_utf8(s)));
+  }
+  
+  function any_md5(s, e) {
+   return rstr2any(rstr_md5(str2rstr_utf8(s)), e);
+  }
+  
+  function hex_hmac_md5(k, d) {
+   return rstr2hex(rstr_hmac_md5(str2rstr_utf8(k), str2rstr_utf8(d)));
+  }
+  
+  function b64_hmac_md5(k, d) {
+   return rstr2b64(rstr_hmac_md5(str2rstr_utf8(k), str2rstr_utf8(d)));
+  }
+  
+  function any_hmac_md5(k, d, e) {
+   return rstr2any(rstr_hmac_md5(str2rstr_utf8(k), str2rstr_utf8(d)), e);
+  }
+  
+  /*
+   * Perform a simple self-test to see if the VM is working
+   */
+  
+  function md5_vm_test() {
+   return hex_md5("abc").toLowerCase() == "900150983cd24fb0d6963f7d28e17f72";
+  }
+  
+  /*
+   * Calculate the MD5 of a raw string
+   */
+  
+  function rstr_md5(s) {
+   return binl2rstr(binl_md5(rstr2binl(s), s.length * 8));
+  }
+  
+  /*
+   * Calculate the HMAC-MD5, of a key and some data (raw strings)
+   */
+  
+  function rstr_hmac_md5(key, data) {
+   var bkey = rstr2binl(key);
+   if (bkey.length > 16) bkey = binl_md5(bkey, key.length * 8);
+  
+   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 = binl_md5(ipad.concat(rstr2binl(data)), 512 + data.length * 8);
+   return binl2rstr(binl_md5(opad.concat(hash), 512 + 128));
+  }
+  
+  /*
+   * Convert a raw string to a hex string
+   */
+  
+  function rstr2hex(input) {
+   try {
+    hexcase
+   } catch (e) {
+    hexcase = 0;
+   }
+   var hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";
+   var output = "";
+   var x;
+   for (var i = 0; i < input.length; i++) {
+    x = input.charCodeAt(i);
+    output += hex_tab.charAt((x >>> 4) & 0x0F) + hex_tab.charAt(x & 0x0F);
+   }
+   return output;
+  }
+  
+  /*
+   * Convert a raw string to a base-64 string
+   */
+  
+  function rstr2b64(input) {
+   try {
+    b64pad
+   } catch (e) {
+    b64pad = '';
+   }
+   var tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+   var output = "";
+   var len = input.length;
+   for (var i = 0; i < len; i += 3) {
+    var triplet = (input.charCodeAt(i) << 16) | (i + 1 < len ? input.charCodeAt(i + 1) << 8 : 0) | (i + 2 < len ? input.charCodeAt(i + 2) : 0);
+    for (var j = 0; j < 4; j++) {
+     if (i * 8 + j * 6 > input.length * 8) output += b64pad;
+     else output += tab.charAt((triplet >>> 6 * (3 - j)) & 0x3F);
+    }
+   }
+   return output;
+  }
+  
+  /*
+   * Convert a raw string to an arbitrary string encoding
+   */
+  
+  function rstr2any(input, encoding) {
+   var divisor = encoding.length;
+   var i, j, q, x, quotient;
+  
+   /* Convert to an array of 16-bit big-endian values, forming the dividend */
+   var dividend = Array(Math.ceil(input.length / 2));
+   for (i = 0; i < dividend.length; i++) {
+    dividend[i] = (input.charCodeAt(i * 2) << 8) | input.charCodeAt(i * 2 + 1);
+   }
+  
+  /*
+     * Repeatedly perform a long division. The binary array forms the dividend,
+     * the length of the encoding is the divisor. Once computed, the quotient
+     * forms the dividend for the next step. All remainders are stored for later
+     * use.
+     */
+   var full_length = Math.ceil(input.length * 8 / (Math.log(encoding.length) / Math.log(2)));
+   var remainders = Array(full_length);
+   for (j = 0; j < full_length; j++) {
+    quotient = Array();
+    x = 0;
+    for (i = 0; i < dividend.length; i++) {
+     x = (x << 16) + dividend[i];
+     q = Math.floor(x / divisor);
+     x -= q * divisor;
+     if (quotient.length > 0 || q > 0) quotient[quotient.length] = q;
+    }
+    remainders[j] = x;
+    dividend = quotient;
+   }
+  
+   /* Convert the remainders to the output string */
+   var output = "";
+   for (i = remainders.length - 1; i >= 0; i--)
+   output += encoding.charAt(remainders[i]);
+  
+   return output;
+  }
+  
+  /*
+   * Encode a string as utf-8.
+   * For efficiency, this assumes the input is valid utf-16.
+   */
+  
+  function str2rstr_utf8(input) {
+   return unescape(encodeURI(input));
+  }
+  
+  /*
+   * Encode a string as utf-16
+   */
+  
+  function str2rstr_utf16le(input) {
+   var output = "";
+   for (var i = 0; i < input.length; i++)
+   output += String.fromCharCode(input.charCodeAt(i) & 0xFF, (input.charCodeAt(i) >>> 8) & 0xFF);
+   return output;
+  }
+  
+  function str2rstr_utf16be(input) {
+   var output = "";
+   for (var i = 0; i < input.length; i++)
+   output += String.fromCharCode((input.charCodeAt(i) >>> 8) & 0xFF, input.charCodeAt(i) & 0xFF);
+   return output;
+  }
+  
+  /*
+   * Convert a raw string to an array of little-endian words
+   * Characters >255 have their high-byte silently ignored.
+   */
+  
+  function rstr2binl(input) {
+   var output = Array(input.length >> 2);
+   for (var i = 0; i < output.length; i++)
+   output[i] = 0;
+   for (var i = 0; i < input.length * 8; i += 8)
+   output[i >> 5] |= (input.charCodeAt(i / 8) & 0xFF) << (i % 32);
+   return output;
+  }
+  
+  /*
+   * Convert an array of little-endian words to a string
+   */
+  
+  function binl2rstr(input) {
+   var output = "";
+   for (var i = 0; i < input.length * 32; i += 8)
+   output += String.fromCharCode((input[i >> 5] >>> (i % 32)) & 0xFF);
+   return output;
+  }
+  
+  /*
+   * Calculate the MD5 of an array of little-endian words, and a bit length.
+   */
+  
+  function binl_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);
+  }
+  
+  /*
+   * 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));
+  }
+
+  return hex_md5;
+})();
diff --git a/http/3rdParty/yaMD5/test/lib/satazor-md5.js b/http/3rdParty/yaMD5/test/lib/satazor-md5.js
new file mode 100644
index 0000000..db606b3
--- /dev/null
+++ b/http/3rdParty/yaMD5/test/lib/satazor-md5.js
@@ -0,0 +1,600 @@
+// https://raw.githubusercontent.com/satazor/SparkMD5/master/spark-md5.js
+/*jshint bitwise:false*/
+/*global unescape*/
+
+(function (factory) {
+    if (typeof exports === 'object') {
+        // Node/CommonJS
+        module.exports = factory();
+    } else if (typeof define === 'function' && define.amd) {
+        // AMD
+        define(factory);
+    } else {
+        // Browser globals (with support for web workers)
+        var glob;
+        try {
+            glob = window;
+        } catch (e) {
+            glob = self;
+        }
+
+        glob.SparkMD5 = factory();
+    }
+}(function (undefined) {
+
+    'use strict';
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    /*
+     * Fastest md5 implementation around (JKM md5)
+     * Credits: Joseph Myers
+     *
+     * @see http://www.myersdaily.org/joseph/javascript/md5-text.html
+     * @see http://jsperf.com/md5-shootout/7
+     */
+
+    /* this function is much faster,
+      so if possible we use it. Some IEs
+      are the only ones I know of that
+      need the idiotic second function,
+      generated by an if clause.  */
+    var add32 = function (a, b) {
+        return (a + b) & 0xFFFFFFFF;
+    },
+
+    cmn = function (q, a, b, x, s, t) {
+        a = add32(add32(a, q), add32(x, t));
+        return add32((a << s) | (a >>> (32 - s)), b);
+    },
+
+    ff = function (a, b, c, d, x, s, t) {
+        return cmn((b & c) | ((~b) & d), a, b, x, s, t);
+    },
+
+    gg = function (a, b, c, d, x, s, t) {
+        return cmn((b & d) | (c & (~d)), a, b, x, s, t);
+    },
+
+    hh = function (a, b, c, d, x, s, t) {
+        return cmn(b ^ c ^ d, a, b, x, s, t);
+    },
+
+    ii = function (a, b, c, d, x, s, t) {
+        return cmn(c ^ (b | (~d)), a, b, x, s, t);
+    },
+
+    md5cycle = function (x, k) {
+        var a = x[0],
+            b = x[1],
+            c = x[2],
+            d = x[3];
+
+        a = ff(a, b, c, d, k[0], 7, -680876936);
+        d = ff(d, a, b, c, k[1], 12, -389564586);
+        c = ff(c, d, a, b, k[2], 17, 606105819);
+        b = ff(b, c, d, a, k[3], 22, -1044525330);
+        a = ff(a, b, c, d, k[4], 7, -176418897);
+        d = ff(d, a, b, c, k[5], 12, 1200080426);
+        c = ff(c, d, a, b, k[6], 17, -1473231341);
+        b = ff(b, c, d, a, k[7], 22, -45705983);
+        a = ff(a, b, c, d, k[8], 7, 1770035416);
+        d = ff(d, a, b, c, k[9], 12, -1958414417);
+        c = ff(c, d, a, b, k[10], 17, -42063);
+        b = ff(b, c, d, a, k[11], 22, -1990404162);
+        a = ff(a, b, c, d, k[12], 7, 1804603682);
+        d = ff(d, a, b, c, k[13], 12, -40341101);
+        c = ff(c, d, a, b, k[14], 17, -1502002290);
+        b = ff(b, c, d, a, k[15], 22, 1236535329);
+
+        a = gg(a, b, c, d, k[1], 5, -165796510);
+        d = gg(d, a, b, c, k[6], 9, -1069501632);
+        c = gg(c, d, a, b, k[11], 14, 643717713);
+        b = gg(b, c, d, a, k[0], 20, -373897302);
+        a = gg(a, b, c, d, k[5], 5, -701558691);
+        d = gg(d, a, b, c, k[10], 9, 38016083);
+        c = gg(c, d, a, b, k[15], 14, -660478335);
+        b = gg(b, c, d, a, k[4], 20, -405537848);
+        a = gg(a, b, c, d, k[9], 5, 568446438);
+        d = gg(d, a, b, c, k[14], 9, -1019803690);
+        c = gg(c, d, a, b, k[3], 14, -187363961);
+        b = gg(b, c, d, a, k[8], 20, 1163531501);
+        a = gg(a, b, c, d, k[13], 5, -1444681467);
+        d = gg(d, a, b, c, k[2], 9, -51403784);
+        c = gg(c, d, a, b, k[7], 14, 1735328473);
+        b = gg(b, c, d, a, k[12], 20, -1926607734);
+
+        a = hh(a, b, c, d, k[5], 4, -378558);
+        d = hh(d, a, b, c, k[8], 11, -2022574463);
+        c = hh(c, d, a, b, k[11], 16, 1839030562);
+        b = hh(b, c, d, a, k[14], 23, -35309556);
+        a = hh(a, b, c, d, k[1], 4, -1530992060);
+        d = hh(d, a, b, c, k[4], 11, 1272893353);
+        c = hh(c, d, a, b, k[7], 16, -155497632);
+        b = hh(b, c, d, a, k[10], 23, -1094730640);
+        a = hh(a, b, c, d, k[13], 4, 681279174);
+        d = hh(d, a, b, c, k[0], 11, -358537222);
+        c = hh(c, d, a, b, k[3], 16, -722521979);
+        b = hh(b, c, d, a, k[6], 23, 76029189);
+        a = hh(a, b, c, d, k[9], 4, -640364487);
+        d = hh(d, a, b, c, k[12], 11, -421815835);
+        c = hh(c, d, a, b, k[15], 16, 530742520);
+        b = hh(b, c, d, a, k[2], 23, -995338651);
+
+        a = ii(a, b, c, d, k[0], 6, -198630844);
+        d = ii(d, a, b, c, k[7], 10, 1126891415);
+        c = ii(c, d, a, b, k[14], 15, -1416354905);
+        b = ii(b, c, d, a, k[5], 21, -57434055);
+        a = ii(a, b, c, d, k[12], 6, 1700485571);
+        d = ii(d, a, b, c, k[3], 10, -1894986606);
+        c = ii(c, d, a, b, k[10], 15, -1051523);
+        b = ii(b, c, d, a, k[1], 21, -2054922799);
+        a = ii(a, b, c, d, k[8], 6, 1873313359);
+        d = ii(d, a, b, c, k[15], 10, -30611744);
+        c = ii(c, d, a, b, k[6], 15, -1560198380);
+        b = ii(b, c, d, a, k[13], 21, 1309151649);
+        a = ii(a, b, c, d, k[4], 6, -145523070);
+        d = ii(d, a, b, c, k[11], 10, -1120210379);
+        c = ii(c, d, a, b, k[2], 15, 718787259);
+        b = ii(b, c, d, a, k[9], 21, -343485551);
+
+        x[0] = add32(a, x[0]);
+        x[1] = add32(b, x[1]);
+        x[2] = add32(c, x[2]);
+        x[3] = add32(d, x[3]);
+    },
+
+    /* there needs to be support for Unicode here,
+       * unless we pretend that we can redefine the MD-5
+       * algorithm for multi-byte characters (perhaps
+       * by adding every four 16-bit characters and
+       * shortening the sum to 32 bits). Otherwise
+       * I suggest performing MD-5 as if every character
+       * was two bytes--e.g., 0040 0025 = @%--but then
+       * how will an ordinary MD-5 sum be matched?
+       * There is no way to standardize text to something
+       * like UTF-8 before transformation; speed cost is
+       * utterly prohibitive. The JavaScript standard
+       * itself needs to look at this: it should start
+       * providing access to strings as preformed UTF-8
+       * 8-bit unsigned value arrays.
+       */
+    md5blk = function (s) {
+        var md5blks = [],
+            i; /* Andy King said do it this way. */
+
+        for (i = 0; i < 64; i += 4) {
+            md5blks[i >> 2] = s.charCodeAt(i) + (s.charCodeAt(i + 1) << 8) + (s.charCodeAt(i + 2) << 16) + (s.charCodeAt(i + 3) << 24);
+        }
+        return md5blks;
+    },
+
+    md5blk_array = function (a) {
+        var md5blks = [],
+            i; /* Andy King said do it this way. */
+
+        for (i = 0; i < 64; i += 4) {
+            md5blks[i >> 2] = a[i] + (a[i + 1] << 8) + (a[i + 2] << 16) + (a[i + 3] << 24);
+        }
+        return md5blks;
+    },
+
+    md51 = function (s) {
+        var n = s.length,
+            state = [1732584193, -271733879, -1732584194, 271733878],
+            i,
+            length,
+            tail,
+            tmp,
+            lo,
+            hi;
+
+        for (i = 64; i <= n; i += 64) {
+            md5cycle(state, md5blk(s.substring(i - 64, i)));
+        }
+        s = s.substring(i - 64);
+        length = s.length;
+        tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+        for (i = 0; i < length; i += 1) {
+            tail[i >> 2] |= s.charCodeAt(i) << ((i % 4) << 3);
+        }
+        tail[i >> 2] |= 0x80 << ((i % 4) << 3);
+        if (i > 55) {
+            md5cycle(state, tail);
+            for (i = 0; i < 16; i += 1) {
+                tail[i] = 0;
+            }
+        }
+
+        // Beware that the final length might not fit in 32 bits so we take care of that
+        tmp = n * 8;
+        tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+        lo = parseInt(tmp[2], 16);
+        hi = parseInt(tmp[1], 16) || 0;
+
+        tail[14] = lo;
+        tail[15] = hi;
+
+        md5cycle(state, tail);
+        return state;
+    },
+
+    md51_array = function (a) {
+        var n = a.length,
+            state = [1732584193, -271733879, -1732584194, 271733878],
+            i,
+            length,
+            tail,
+            tmp,
+            lo,
+            hi;
+
+        for (i = 64; i <= n; i += 64) {
+            md5cycle(state, md5blk_array(a.subarray(i - 64, i)));
+        }
+
+        // Not sure if it is a bug, however IE10 will always produce a sub array of length 1
+        // containing the last element of the parent array if the sub array specified starts
+        // beyond the length of the parent array - weird.
+        // https://connect.microsoft.com/IE/feedback/details/771452/typed-array-subarray-issue
+        a = (i - 64) < n ? a.subarray(i - 64) : new Uint8Array(0);
+
+        length = a.length;
+        tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+        for (i = 0; i < length; i += 1) {
+            tail[i >> 2] |= a[i] << ((i % 4) << 3);
+        }
+
+        tail[i >> 2] |= 0x80 << ((i % 4) << 3);
+        if (i > 55) {
+            md5cycle(state, tail);
+            for (i = 0; i < 16; i += 1) {
+                tail[i] = 0;
+            }
+        }
+
+        // Beware that the final length might not fit in 32 bits so we take care of that
+        tmp = n * 8;
+        tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+        lo = parseInt(tmp[2], 16);
+        hi = parseInt(tmp[1], 16) || 0;
+
+        tail[14] = lo;
+        tail[15] = hi;
+
+        md5cycle(state, tail);
+
+        return state;
+    },
+
+    hex_chr = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'],
+
+    rhex = function (n) {
+        var s = '',
+            j;
+        for (j = 0; j < 4; j += 1) {
+            s += hex_chr[(n >> (j * 8 + 4)) & 0x0F] + hex_chr[(n >> (j * 8)) & 0x0F];
+        }
+        return s;
+    },
+
+    hex = function (x) {
+        var i;
+        for (i = 0; i < x.length; i += 1) {
+            x[i] = rhex(x[i]);
+        }
+        return x.join('');
+    },
+
+    md5 = function (s) {
+        return hex(md51(s));
+    },
+
+
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    /**
+     * SparkMD5 OOP implementation.
+     *
+     * Use this class to perform an incremental md5, otherwise use the
+     * static methods instead.
+     */
+    SparkMD5 = function () {
+        // call reset to init the instance
+        this.reset();
+    };
+
+
+    // In some cases the fast add32 function cannot be used..
+    if (md5('hello') !== '5d41402abc4b2a76b9719d911017c592') {
+        add32 = function (x, y) {
+            var lsw = (x & 0xFFFF) + (y & 0xFFFF),
+                msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+            return (msw << 16) | (lsw & 0xFFFF);
+        };
+    }
+
+
+    /**
+     * Appends a string.
+     * A conversion will be applied if an utf8 string is detected.
+     *
+     * @param {String} str The string to be appended
+     *
+     * @return {SparkMD5} The instance itself
+     */
+    SparkMD5.prototype.append = function (str) {
+        // converts the string to utf8 bytes if necessary
+        if (/[\u0080-\uFFFF]/.test(str)) {
+            str = unescape(encodeURIComponent(str));
+        }
+
+        // then append as binary
+        this.appendBinary(str);
+
+        return this;
+    };
+
+    /**
+     * Appends a binary string.
+     *
+     * @param {String} contents The binary string to be appended
+     *
+     * @return {SparkMD5} The instance itself
+     */
+    SparkMD5.prototype.appendBinary = function (contents) {
+        this._buff += contents;
+        this._length += contents.length;
+
+        var length = this._buff.length,
+            i;
+
+        for (i = 64; i <= length; i += 64) {
+            md5cycle(this._state, md5blk(this._buff.substring(i - 64, i)));
+        }
+
+        this._buff = this._buff.substr(i - 64);
+
+        return this;
+    };
+
+    /**
+     * Finishes the incremental computation, reseting the internal state and
+     * returning the result.
+     * Use the raw parameter to obtain the raw result instead of the hex one.
+     *
+     * @param {Boolean} raw True to get the raw result, false to get the hex result
+     *
+     * @return {String|Array} The result
+     */
+    SparkMD5.prototype.end = function (raw) {
+        var buff = this._buff,
+            length = buff.length,
+            i,
+            tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            ret;
+
+        for (i = 0; i < length; i += 1) {
+            tail[i >> 2] |= buff.charCodeAt(i) << ((i % 4) << 3);
+        }
+
+        this._finish(tail, length);
+        ret = !!raw ? this._state : hex(this._state);
+
+        this.reset();
+
+        return ret;
+    };
+
+    /**
+     * Finish the final calculation based on the tail.
+     *
+     * @param {Array}  tail   The tail (will be modified)
+     * @param {Number} length The length of the remaining buffer
+     */
+    SparkMD5.prototype._finish = function (tail, length) {
+        var i = length,
+            tmp,
+            lo,
+            hi;
+
+        tail[i >> 2] |= 0x80 << ((i % 4) << 3);
+        if (i > 55) {
+            md5cycle(this._state, tail);
+            for (i = 0; i < 16; i += 1) {
+                tail[i] = 0;
+            }
+        }
+
+        // Do the final computation based on the tail and length
+        // Beware that the final length may not fit in 32 bits so we take care of that
+        tmp = this._length * 8;
+        tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+        lo = parseInt(tmp[2], 16);
+        hi = parseInt(tmp[1], 16) || 0;
+
+        tail[14] = lo;
+        tail[15] = hi;
+        md5cycle(this._state, tail);
+    };
+
+    /**
+     * Resets the internal state of the computation.
+     *
+     * @return {SparkMD5} The instance itself
+     */
+    SparkMD5.prototype.reset = function () {
+        this._buff = "";
+        this._length = 0;
+        this._state = [1732584193, -271733879, -1732584194, 271733878];
+
+        return this;
+    };
+
+    /**
+     * Releases memory used by the incremental buffer and other aditional
+     * resources. If you plan to use the instance again, use reset instead.
+     */
+    SparkMD5.prototype.destroy = function () {
+        delete this._state;
+        delete this._buff;
+        delete this._length;
+    };
+
+
+    /**
+     * Performs the md5 hash on a string.
+     * A conversion will be applied if utf8 string is detected.
+     *
+     * @param {String}  str The string
+     * @param {Boolean} raw True to get the raw result, false to get the hex result
+     *
+     * @return {String|Array} The result
+     */
+    SparkMD5.hash = function (str, raw) {
+        // converts the string to utf8 bytes if necessary
+        if (/[\u0080-\uFFFF]/.test(str)) {
+            str = unescape(encodeURIComponent(str));
+        }
+
+        var hash = md51(str);
+
+        return !!raw ? hash : hex(hash);
+    };
+
+    /**
+     * Performs the md5 hash on a binary string.
+     *
+     * @param {String}  content The binary string
+     * @param {Boolean} raw     True to get the raw result, false to get the hex result
+     *
+     * @return {String|Array} The result
+     */
+    SparkMD5.hashBinary = function (content, raw) {
+        var hash = md51(content);
+
+        return !!raw ? hash : hex(hash);
+    };
+
+    /**
+     * SparkMD5 OOP implementation for array buffers.
+     *
+     * Use this class to perform an incremental md5 ONLY for array buffers.
+     */
+    SparkMD5.ArrayBuffer = function () {
+        // call reset to init the instance
+        this.reset();
+    };
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    /**
+     * Appends an array buffer.
+     *
+     * @param {ArrayBuffer} arr The array to be appended
+     *
+     * @return {SparkMD5.ArrayBuffer} The instance itself
+     */
+    SparkMD5.ArrayBuffer.prototype.append = function (arr) {
+        // TODO: we could avoid the concatenation here but the algorithm would be more complex
+        //       if you find yourself needing extra performance, please make a PR.
+        var buff = this._concatArrayBuffer(this._buff, arr),
+            length = buff.length,
+            i;
+
+        this._length += arr.byteLength;
+
+        for (i = 64; i <= length; i += 64) {
+            md5cycle(this._state, md5blk_array(buff.subarray(i - 64, i)));
+        }
+
+        // Avoids IE10 weirdness (documented above)
+        this._buff = (i - 64) < length ? buff.subarray(i - 64) : new Uint8Array(0);
+
+        return this;
+    };
+
+    /**
+     * Finishes the incremental computation, reseting the internal state and
+     * returning the result.
+     * Use the raw parameter to obtain the raw result instead of the hex one.
+     *
+     * @param {Boolean} raw True to get the raw result, false to get the hex result
+     *
+     * @return {String|Array} The result
+     */
+    SparkMD5.ArrayBuffer.prototype.end = function (raw) {
+        var buff = this._buff,
+            length = buff.length,
+            tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            i,
+            ret;
+
+        for (i = 0; i < length; i += 1) {
+            tail[i >> 2] |= buff[i] << ((i % 4) << 3);
+        }
+
+        this._finish(tail, length);
+        ret = !!raw ? this._state : hex(this._state);
+
+        this.reset();
+
+        return ret;
+    };
+
+    SparkMD5.ArrayBuffer.prototype._finish = SparkMD5.prototype._finish;
+
+    /**
+     * Resets the internal state of the computation.
+     *
+     * @return {SparkMD5.ArrayBuffer} The instance itself
+     */
+    SparkMD5.ArrayBuffer.prototype.reset = function () {
+        this._buff = new Uint8Array(0);
+        this._length = 0;
+        this._state = [1732584193, -271733879, -1732584194, 271733878];
+
+        return this;
+    };
+
+    /**
+     * Releases memory used by the incremental buffer and other aditional
+     * resources. If you plan to use the instance again, use reset instead.
+     */
+    SparkMD5.ArrayBuffer.prototype.destroy = SparkMD5.prototype.destroy;
+
+    /**
+     * Concats two array buffers, returning a new one.
+     *
+     * @param  {ArrayBuffer} first  The first array buffer
+     * @param  {ArrayBuffer} second The second array buffer
+     *
+     * @return {ArrayBuffer} The new array buffer
+     */
+    SparkMD5.ArrayBuffer.prototype._concatArrayBuffer = function (first, second) {
+        var firstLength = first.length,
+            result = new Uint8Array(firstLength + second.byteLength);
+
+        result.set(first);
+        result.set(new Uint8Array(second), firstLength);
+
+        return result;
+    };
+
+    /**
+     * Performs the md5 hash on an array buffer.
+     *
+     * @param {ArrayBuffer} arr The array buffer
+     * @param {Boolean}     raw True to get the raw result, false to get the hex result
+     *
+     * @return {String|Array} The result
+     */
+    SparkMD5.ArrayBuffer.hash = function (arr, raw) {
+        var hash = md51_array(new Uint8Array(arr));
+
+        return !!raw ? hash : hex(hash);
+    };
+
+    return SparkMD5;
+}));
diff --git a/http/3rdParty/yaMD5/test/lib/valums-md5.js b/http/3rdParty/yaMD5/test/lib/valums-md5.js
new file mode 100644
index 0000000..865d626
--- /dev/null
+++ b/http/3rdParty/yaMD5/test/lib/valums-md5.js
@@ -0,0 +1,218 @@
+/**
+* Namespace for hashing and other cryptographic functions
+* Copyright (c) Andrew Valums
+* Licensed under the MIT license, http://valums.com/mit-license/
+*/
+
+var V = V || {};
+V.Security = V.Security || {};
+
+(function() {
+    // for faster access
+    var S = V.Security;
+
+    /**
+    * The highest integer value a number can go to without losing precision.
+    */
+    S.maxExactInt = Math.pow(2, 53);
+
+    /**
+    * Converts string from internal UTF-16 to UTF-8
+    * and saves it using array of numbers (bytes), 0-255 per cell
+    * @param {String} str
+    * @return {Array}
+    */
+    S.toUtf8ByteArr = function(str) {
+        var arr = [],
+        code;
+
+        for (var i = 0; i < str.length; i++) {
+            code = str.charCodeAt(i);
+
+            /*
+            Note that charCodeAt will always return a value that is less than 65,536.
+            This is because the higher code points are represented by a pair of (lower valued)
+            "surrogate" pseudo-characters which are used to comprise the real character.
+            Because of this, in order to examine or reproduce the full character for
+            individual characters of value 65,536 and above, for such characters,
+            it is necessary to retrieve not only charCodeAt(0), but also charCodeAt(1). 
+             */
+            if (0xD800 <= code && code <= 0xDBFF) {
+                // UTF-16 high surrogate 
+                var hi = code,
+                low = str.charCodeAt(i + 1);
+
+                code = ((hi - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000;
+
+                i++;
+            }
+
+            if (code <= 127) {
+                arr[arr.length] = code;
+            } else if (code <= 2047) {
+                arr[arr.length] = (code >>> 6) + 0xC0;
+                arr[arr.length] = code & 0x3F | 0x80;
+            } else if (code <= 65535) {
+                arr[arr.length] = (code >>> 12) + 0xE0;
+                arr[arr.length] = (code >>> 6 & 0x3F) | 0x80;
+                arr[arr.length] = (code & 0x3F) | 0x80;
+            } else if (code <= 1114111) {
+                arr[arr.length] = (code >>> 18) + 0xF0;
+                arr[arr.length] = (code >>> 12 & 0x3F) | 0x80;
+                arr[arr.length] = (code >>> 6 & 0x3F) | 0x80;
+                arr[arr.length] = (code & 0x3F) | 0x80;
+            } else {
+                throw 'Unicode standart supports code points up-to U+10FFFF';
+            }
+        }
+
+        return arr;
+    };
+
+    /**
+    * Outputs 32 integer bits of a number in hex format.
+    * Preserves leading zeros.
+    * @param {Number} num
+    */
+    S.toHex32 = function(num) {
+        // if negative
+        if (num & 0x80000000) {
+            // convert to positive number
+            num = num & (~0x80000000);
+            num += Math.pow(2, 31);
+        }
+
+        var str = num.toString(16);
+
+        while (str.length < 8) {
+            str = '0' + str;
+        }
+
+        return str;
+    };
+
+    /**
+    * Changes the order of 4 bytes in integer representation of number.
+    * From 1234 to 4321. 
+    * @param {Number} num Only 32 int bits are used.
+    */
+    S.reverseBytes = function(num) {
+        var res = 0;
+        res += ((num >>> 24) & 0xff);
+        res += ((num >>> 16) & 0xff) << 8;
+        res += ((num >>> 8) & 0xff) << 16;
+        res += (num & 0xff) << 24;
+        return res;
+    };
+
+    S.leftRotate = function(x, c) {
+        return (x << c) | (x >>> (32 - c));
+    };
+
+    /**
+    * RSA Data Security, Inc. MD5 Message-Digest Algorithm
+    * http://tools.ietf.org/html/rfc1321
+    * http://en.wikipedia.org/wiki/MD5
+    * @param {String} message
+    */
+    S.md5 = function(message) {
+        // r specifies the per-round shift amounts
+        var r = [7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21];
+
+        // Use binary integer part of the sines of integers (Radians) as constants:
+        var k = [];
+        for (var i = 0; i <= 63; i++) {
+            k[i] = (Math.abs(Math.sin(i + 1)) * Math.pow(2, 32)) << 0;
+        }
+
+        var h0 = 0x67452301,
+            h1 = 0xEFCDAB89,
+            h2 = 0x98BADCFE,
+            h3 = 0x10325476,
+            bytes, unpadded;
+
+        //Pre-processing:   
+        bytes = S.toUtf8ByteArr(message);
+        message = null;
+        unpadded = bytes.length;
+
+        //append "1" bit to message
+        //append "0" bits until message length in bits ≡ 448 (mod 512)    
+        bytes.push(0x80);
+        var zeroBytes = Math.abs(448 - (bytes.length * 8) % 512) / 8;
+
+        while (zeroBytes--) {
+            bytes.push(0);
+        }
+
+        //append bit length of unpadded message as 64-bit little-endian integer to message          
+        bytes.push(unpadded * 8 & 0xff, unpadded * 8 >> 8 & 0xff, unpadded * 8 >> 16 & 0xff, unpadded * 8 >> 24 & 0xff);
+
+        var i = 4;
+        while (i--) {
+            bytes.push(0);
+        }
+
+        var leftRotate = S.leftRotate;
+
+        //Process the message in successive 512-bit chunks:
+        var i = 0,
+        w = [];
+        while (i < bytes.length) {
+
+            //break chunk into sixteen 32-bit words w[i], 0 ≤ i ≤ 15
+            for (var j = 0; j <= 15; j++) {
+                w[j] = (bytes[i + 4 * j] << 0) + (bytes[i + 4 * j + 1] << 8) + (bytes[i + 4 * j + 2] << 16) + (bytes[i + 4 * j + 3] << 24);
+            }
+
+            //Initialize hash value for this chunk:
+            var a = h0,
+                b = h1,
+                c = h2,
+                d = h3,
+                f, g;
+
+            //Main loop:
+            for (var j = 0; j <= 63; j++) {
+
+                if (j <= 15) {
+                    f = (b & c) | ((~b) & d);
+                    g = j;
+                } else if (j <= 31) {
+                    f = (d & b) | ((~d) & c);
+                    g = (5 * j + 1) % 16;
+                } else if (j <= 47) {
+                    f = b ^ c ^ d;
+                    g = (3 * j + 5) % 16;
+                } else {
+                    f = c ^ (b | (~d));
+                    g = (7 * j) % 16;
+                }
+
+                var temp = d;
+
+                d = c;
+                c = b;
+                b = b + leftRotate((a + f + k[j] + w[g]), r[j]);
+                a = temp;
+            }
+
+            //Add this chunk's hash to result so far:
+            h0 = (h0 + a) << 0;
+            h1 = (h1 + b) << 0;
+            h2 = (h2 + c) << 0;
+            h3 = (h3 + d) << 0;
+
+            i += 512 / 8;
+        }
+
+        // fix when starting with 0                 
+        var res = out(h0) + out(h1) + out(h2) + out(h3);
+
+        function out(h) {
+            return S.toHex32(S.reverseBytes(h));
+        }
+
+        return res;
+    };
+})();
diff --git a/http/3rdParty/yaMD5/test/test.html b/http/3rdParty/yaMD5/test/test.html
new file mode 100644
index 0000000..ce2659f
--- /dev/null
+++ b/http/3rdParty/yaMD5/test/test.html
@@ -0,0 +1,99 @@
+<!DOCTYPE html>
+<html>
+<head>
+<style>
+body  {
+    font: 13px mono;
+    }
+.good {
+    color: green;
+    }
+.bad {
+    color: red;
+    }
+</style>
+</head>
+<body>
+<script>
+var test = function(md5Name, md5Func) {
+    // Add tests here
+    // A test is a pair of strings: hash then data
+    var tests = [
+
+        // from Appendix 5 of http://www.ietf.org/rfc/rfc1321.txt
+        'd41d8cd98f00b204e9800998ecf8427e', '',
+        '0cc175b9c0f1b6a831c399e269772661', 'a',
+        '900150983cd24fb0d6963f7d28e17f72', 'abc',
+        'f96b697d7cb7938d525a2f31aaf161d0', 'message digest',
+        'c3fcd3d76192e4007dfb496cca67e13b', 'abcdefghijklmnopqrstuvwxyz',
+        'd174ab98d277d9f5a5611c2c9f419d9f', 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789',
+        '57edf4a22be3c955ac49da2e2107b67a', '12345678901234567890123456789012345678901234567890123456789012345678901234567890',
+
+        // Unicode strings taken from http://en.wikipedia.org/wiki/List_of_pangrams
+        // Then I ran them through md5sum
+        'b69cf1b7b6888f1f8928e2e2b74da8bc', 'Voix ambiguë d\'un cœur qui au zéphyr préfère les jattes de kiwis',
+        'd1ea7e7792c50a0386b1064ab220da0c', 'Жълтата дюля беше щастлива, че пухът, който цъфна, замръзна като гьон',
+        'b6071a4fc17e44a7d0246e5b4c939a70', 'Hyvän lorun sangen pieneksi hyödyksi jäi suomen kirjaimet',
+        '47ee7efa5573066d43ab5f9ae1830cf8', 'Ταχίστη αλώπηξ βαφής ψημένη γη, δρασκελίζει υπέρ νωθρού κυνός',
+        '7e626d44cd9610f2fef198156730e7d9', '色は匂へど 散りぬるを 我が世誰ぞ 常ならむ 有為の奥山 今日越えて 浅き夢見じ 酔ひもせず',
+        'ae5f9c6b87f4e50e68eb20c10e21733a', 'นายสังฆภัณฑ์ เฮงพิทักษ์ฝั่ง ผู้เฒ่าซึ่งมีอาชีพเป็นฅนขายฃวด ถูกตำรวจปฏิบัติการจับฟ้องศาล ฐานลักนาฬิกาคุณหญิงฉัตรชฎา ฌานสมาธิ'
+    ];
+    var templateSuccess = '<span class="good">Success: "{{hash}}" === md5("{{data}}")</span><br>';
+    var templateFailure = '<span class="bad">Failure: "{{hash}}" !== md5("{{data}}")</span><br>';
+
+    document.write('<h1>'+ md5Name + '</h1>');
+
+    var hash, data, template, output;
+    for ( var i = 0; i < tests.length; i += 2 ) {
+        hash = tests[i+0];
+        data = tests[i+1];
+        if ( md5Func(data) === hash ) {
+            template = templateSuccess;
+        } else {
+            template = templateFailure;
+        }
+        document.write(template.replace('{{data}}', data).replace('{{hash}}', hash));
+    }
+};
+
+var module = module || {};
+</script>
+
+<script src="../yamd5.js"></script>
+<script>test('github.com/gorhill/yamd5.js', YaMD5.hashStr);</script>
+<p>Project home: <a href="https://github.com/gorhill/yamd5.js">https://github.com/gorhill/yamd5.js</a></p>
+
+<script src="./lib/satazor-md5.js"></script>
+<script>test('github.com/satazor/SparkMD5', SparkMD5.hash);</script>
+<p>Project home: <a href="https://github.com/satazor/SparkMD5">https://github.com/satazor/SparkMD5</a></p>
+
+<script src="./lib/paj-md5.js"></script>
+<script>test('Paul Johnston', pajMD5);</script>
+<p>Project home: <a href="http://pajhome.org.uk/crypt/md5/md5.html">http://pajhome.org.uk/crypt/md5/md5.html</a></p>
+
+<script src="./lib/jbt-md5.js"></script>
+<script>test('github.com/jbt/js-crypto', md5);</script>
+<p>Project home: <a href="https://github.com/jbt/js-crypto">https://github.com/jbt/js-crypto</a></p>
+
+<script src="./lib/izumo-md5.js"></script>
+<script>test('Masanao Izumo', izumoMD5);</script>
+<p>Project home: <a href="http://www.onicos.com/staff/iz/amuse/javascript/expert/md5.txt">http://www.onicos.com/staff/iz/amuse/javascript/expert/md5.txt</a></p>
+
+<script src="./lib/jkm-md5.js"></script>
+<script>test('Joseph Myers', jkmMD5);</script>
+<p>Project home: <a href="http://www.myersdaily.org/joseph/javascript/md5-text.html">http://www.myersdaily.org/joseph/javascript/md5-text.html</a></p>
+
+<script src="https://rawgit.com/trentmillar/md5-o-matic/master/lib/md5omatic.js"></script>
+<script>test('github.com/trentmillar/md5-o-matic', module.exports);</script>
+<p>Project home: <a href="https://github.com/trentmillar/md5-o-matic">https://github.com/trentmillar/md5-o-matic</a></p>
+
+<script src="./lib/ireal-md5.js"></script>
+<script>test('github.com/iReal/FastMD5', function(s) { return md5(s, true); });</script>
+<p>Project home: <a href="https://github.com/iReal/FastMD5">https://github.com/iReal/FastMD5</a></p>
+
+<script src="./lib/valums-md5.js"></script>
+<script>test('valums', V.Security.md5);</script>
+<p>Code taken from: <a href="http://jsperf.com/md5-shootout/48">http://jsperf.com/md5-shootout/48</a></p>
+
+</body>
+</html>