coffeecake 0.0.1

data/node_modules/jasmine-runner/node_modules/socket.io/support/socket.io-client/lib/vendor/web-socket-js/flash-src/com/hurlant/crypto/hash/MD2.as

@@ -0,0 +1,124 @@
+/**
+ * MD2
+ * 
+ * An ActionScript 3 implementation of the RSA Data Security, Inc MD2 Message
+ * Digest Algorithm, as defined in RFC 1319
+ * Copyright (c) 2007 Henri Torgemane
+ * 
+ * See LICENSE.txt for full license information.
+ * 
+ * Excerpt from http://en.wikipedia.org/wiki/MD2:
+ * > 
+ * > Rogier and Chauvaud (1997) described collisions of MD2's compression function,
+ * > although they were unable to extend the attack to the full MD2.
+ * > 
+ * > In 2004, MD2 was shown to be vulnerable to a preimage attack with time 
+ * > complexity equivalent to 2104 applications of the compression function 
+ * > (Muller, 2004). 
+ * > The author concludes, "MD2 can no longer be considered a secure one-way 
+ * > hash function".
+ * 
+ * also, this implementaton is quite slow.
+ */
+
+package com.hurlant.crypto.hash
+{
+	import flash.utils.ByteArray;
+
+	public class MD2 implements IHash
+	{
+		public static const HASH_SIZE:int = 16;
+		public var pad_size:int = 48; // probably will never get used, only here for SSL 3.0 support
+		
+		private static const S:Array = [ // PI Digits
+ 41,  46,  67, 201, 162, 216, 124,   1,  61,  54,  84, 161, 236, 240,   6,  19,
+ 98, 167,   5, 243, 192, 199, 115, 140, 152, 147,  43, 217, 188,  76, 130, 202,
+ 30, 155,  87,  60, 253, 212, 224,  22, 103,  66, 111,  24, 138,  23, 229,  18,
+190,  78, 196, 214, 218, 158, 222,  73, 160, 251, 245, 142, 187,  47, 238, 122,
+169, 104, 121, 145,  21, 178,   7,  63, 148, 194,  16, 137,  11,  34,  95,  33,
+128, 127,  93, 154,  90, 144,  50,  39,  53,  62, 204, 231, 191, 247, 151,   3,
+255,  25,  48, 179,  72, 165, 181, 209, 215,  94, 146,  42, 172,  86, 170, 198,
+ 79, 184,  56, 210, 150, 164, 125, 182, 118, 252, 107, 226, 156, 116,   4, 241,
+ 69, 157, 112,  89, 100, 113, 135,  32, 134,  91, 207, 101, 230,  45, 168,   2,
+ 27,  96,  37, 173, 174, 176, 185, 246,  28,  70,  97, 105,  52,  64, 126,  15,
+ 85,  71, 163,  35, 221,  81, 175,  58, 195,  92, 249, 206, 186, 197, 234,  38,
+ 44,  83,  13, 110, 133,  40, 132,   9, 211, 223, 205, 244,  65, 129,  77,  82,
+106, 220,  55, 200, 108, 193, 171, 250,  36, 225, 123,   8,  12, 189, 177,  74,
+120, 136, 149, 139, 227,  99, 232, 109, 233, 203, 213, 254,  59,   0,  29,  57,
+242, 239, 183,  14, 102,  88, 208, 228, 166, 119, 114, 248, 235, 117,  75,  10,
+ 49,  68,  80, 180, 143, 237,  31,  26, 219, 153, 141,  51, 159,  17, 131,  20 ];
+		
+
+        public function MD2() { }
+
+		public function getInputSize():uint
+		{
+			return 16;
+		}
+		
+		public function getPadSize():int {
+			return pad_size;
+		}
+		
+		public function getHashSize():uint
+		{
+			return HASH_SIZE;
+		}
+		
+		public function hash(src:ByteArray):ByteArray
+		{
+			var savedLength:uint = src.length;
+			
+			// 3.1 Step 1. Padding
+			var i:uint = (16-src.length%16) || 16;
+			do {
+				src[src.length]=i;
+			} while (src.length%16!=0);
+			
+			// 3.2 Step 2. Checksum
+			var len:uint = src.length;
+			var checksum:ByteArray = new ByteArray;
+			var L:uint = 0;
+			for (i = 0;i<len;i+=16) {
+				for (var j:uint=0;j<16;j++) {
+					L = checksum[j] ^= S[src[i+j] ^ L];
+				}
+			}
+			src.position = src.length;
+			src.writeBytes(checksum);
+			len += 16;
+			
+			// 3.3 Step 3. MD Buffer
+			var X:ByteArray = new ByteArray;
+
+			// 3.4 Process Message
+			for (i=0;i<len;i+=16) {
+				
+				/* Copy block i into X */
+				for (j=0;j<16;j++) {
+					X[32+j] = (X[16+j] = src[i+j])^X[j];
+				}
+				var t:uint=0;
+				/* Do 18 rounds */
+				for (j=0;j<18;j++) {
+					/* Round j. */
+					for (var k:uint=0;k<48;k++) {
+						X[k] = t = X[k]^S[t];
+					}
+					t = (t+j)&0xff;
+				}
+			}
+			// 3.5 Step 5. Output
+			X.length = 16;
+			// restore original length;
+			src.length = savedLength;
+			return X;
+		}
+		
+		public function toString():String
+		{
+			return "md2";
+		}
+		
+	}
+}

data/node_modules/jasmine-runner/node_modules/socket.io/support/socket.io-client/lib/vendor/web-socket-js/flash-src/com/hurlant/crypto/hash/MD5.as

@@ -0,0 +1,204 @@
+/**
+ * MD5
+ * 
+ * An ActionScript 3 implementation of the RSA Data Security, Inc. MD5 Message
+ * Digest Algorithm, as defined in RFC 1321.
+ * Copyright (c) 2007 Henri Torgemane
+ * 
+ * Derived from
+ * 		A JavaScript implementation of the same.
+ *		Version 2.1 Copyright (C) Paul Johnston 1999 - 2002.
+ * 		Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+ * 
+ * Note:
+ * This algorithm should not be your first choice for new developements, but is
+ * included to allow interoperability with existing codes and protocols.
+ * 
+ * See LICENSE.txt for full license information.
+ */
+package com.hurlant.crypto.hash
+{
+	import flash.utils.ByteArray;
+	import flash.utils.Endian;
+
+ 	public class MD5 implements IHash
+	{
+		public static const HASH_SIZE:int = 16;
+		public var pad_size:int = 48;
+
+        public function MD5() { }
+		
+		public function getInputSize():uint
+		{
+			return 64;
+		}
+		
+		public function getHashSize():uint
+		{
+			return HASH_SIZE;
+		}
+		
+		public function getPadSize():int 
+		{
+			return pad_size;
+		}
+		
+		public function hash(src:ByteArray):ByteArray
+		{
+			var len:uint = src.length *8;
+			var savedEndian:String = src.endian;
+			// pad to nearest int.
+			while (src.length%4!=0) {
+				src[src.length]=0;
+			}
+			// convert ByteArray to an array of uint
+			src.position=0;
+			var a:Array = [];
+			src.endian=Endian.LITTLE_ENDIAN
+			for (var i:uint=0;i<src.length;i+=4) {
+				a.push(src.readUnsignedInt());
+			}
+			var h:Array = core_md5(a, len);
+			var out:ByteArray = new ByteArray;
+			out.endian=Endian.LITTLE_ENDIAN;
+			for (i=0;i<4;i++) {
+				out.writeUnsignedInt(h[i]);
+			}
+			// restore length!
+			src.length = len/8;
+			src.endian = savedEndian;
+			
+			return out;
+		}
+		
+		private function core_md5(x:Array, len:uint):Array {
+		  /* append padding */
+		  x[len >> 5] |= 0x80 << ((len) % 32);
+		  x[(((len + 64) >>> 9) << 4) + 14] = len;
+
+		  var a:uint = 0x67452301; // 1732584193;
+		  var b:uint = 0xEFCDAB89; //-271733879;
+		  var c:uint = 0x98BADCFE; //-1732584194;
+		  var d:uint = 0x10325476; // 271733878;
+
+		  for(var i:uint = 0; i < x.length; i += 16)
+		  {
+		  	x[i]||=0;    x[i+1]||=0;  x[i+2]||=0;  x[i+3]||=0;
+		  	x[i+4]||=0;  x[i+5]||=0;  x[i+6]||=0;  x[i+7]||=0;
+		  	x[i+8]||=0;  x[i+9]||=0;  x[i+10]||=0; x[i+11]||=0;
+		  	x[i+12]||=0; x[i+13]||=0; x[i+14]||=0; x[i+15]||=0;
+
+		    var olda:uint = a;
+		    var oldb:uint = b;
+		    var oldc:uint = c;
+		    var oldd:uint = d;
+		    
+		    a = ff(a, b, c, d, x[i+ 0], 7 , 0xD76AA478);
+		    d = ff(d, a, b, c, x[i+ 1], 12, 0xE8C7B756);
+		    c = ff(c, d, a, b, x[i+ 2], 17, 0x242070DB);
+		    b = ff(b, c, d, a, x[i+ 3], 22, 0xC1BDCEEE);
+		    a = ff(a, b, c, d, x[i+ 4], 7 , 0xF57C0FAF);
+		    d = ff(d, a, b, c, x[i+ 5], 12, 0x4787C62A);
+		    c = ff(c, d, a, b, x[i+ 6], 17, 0xA8304613);
+		    b = ff(b, c, d, a, x[i+ 7], 22, 0xFD469501);
+		    a = ff(a, b, c, d, x[i+ 8], 7 , 0x698098D8);
+		    d = ff(d, a, b, c, x[i+ 9], 12, 0x8B44F7AF);
+		    c = ff(c, d, a, b, x[i+10], 17, 0xFFFF5BB1);
+		    b = ff(b, c, d, a, x[i+11], 22, 0x895CD7BE);
+		    a = ff(a, b, c, d, x[i+12], 7 , 0x6B901122);
+		    d = ff(d, a, b, c, x[i+13], 12, 0xFD987193);
+		    c = ff(c, d, a, b, x[i+14], 17, 0xA679438E);
+		    b = ff(b, c, d, a, x[i+15], 22, 0x49B40821);
+
+		    a = gg(a, b, c, d, x[i+ 1], 5 , 0xf61e2562);
+		    d = gg(d, a, b, c, x[i+ 6], 9 , 0xc040b340);
+		    c = gg(c, d, a, b, x[i+11], 14, 0x265e5a51);
+		    b = gg(b, c, d, a, x[i+ 0], 20, 0xe9b6c7aa);
+		    a = gg(a, b, c, d, x[i+ 5], 5 , 0xd62f105d);
+		    d = gg(d, a, b, c, x[i+10], 9 ,  0x2441453);
+		    c = gg(c, d, a, b, x[i+15], 14, 0xd8a1e681);
+		    b = gg(b, c, d, a, x[i+ 4], 20, 0xe7d3fbc8);
+		    a = gg(a, b, c, d, x[i+ 9], 5 , 0x21e1cde6);
+		    d = gg(d, a, b, c, x[i+14], 9 , 0xc33707d6);
+		    c = gg(c, d, a, b, x[i+ 3], 14, 0xf4d50d87);
+		    b = gg(b, c, d, a, x[i+ 8], 20, 0x455a14ed);
+		    a = gg(a, b, c, d, x[i+13], 5 , 0xa9e3e905);
+		    d = gg(d, a, b, c, x[i+ 2], 9 , 0xfcefa3f8);
+		    c = gg(c, d, a, b, x[i+ 7], 14, 0x676f02d9);
+		    b = gg(b, c, d, a, x[i+12], 20, 0x8d2a4c8a);
+
+		    a = hh(a, b, c, d, x[i+ 5], 4 , 0xfffa3942);
+		    d = hh(d, a, b, c, x[i+ 8], 11, 0x8771f681);
+		    c = hh(c, d, a, b, x[i+11], 16, 0x6d9d6122);
+		    b = hh(b, c, d, a, x[i+14], 23, 0xfde5380c);
+		    a = hh(a, b, c, d, x[i+ 1], 4 , 0xa4beea44);
+		    d = hh(d, a, b, c, x[i+ 4], 11, 0x4bdecfa9);
+		    c = hh(c, d, a, b, x[i+ 7], 16, 0xf6bb4b60);
+		    b = hh(b, c, d, a, x[i+10], 23, 0xbebfbc70);
+		    a = hh(a, b, c, d, x[i+13], 4 , 0x289b7ec6);
+		    d = hh(d, a, b, c, x[i+ 0], 11, 0xeaa127fa);
+		    c = hh(c, d, a, b, x[i+ 3], 16, 0xd4ef3085);
+		    b = hh(b, c, d, a, x[i+ 6], 23,  0x4881d05);
+		    a = hh(a, b, c, d, x[i+ 9], 4 , 0xd9d4d039);
+		    d = hh(d, a, b, c, x[i+12], 11, 0xe6db99e5);
+		    c = hh(c, d, a, b, x[i+15], 16, 0x1fa27cf8);
+		    b = hh(b, c, d, a, x[i+ 2], 23, 0xc4ac5665);
+		
+		    a = ii(a, b, c, d, x[i+ 0], 6 , 0xf4292244);
+		    d = ii(d, a, b, c, x[i+ 7], 10, 0x432aff97);
+		    c = ii(c, d, a, b, x[i+14], 15, 0xab9423a7);
+		    b = ii(b, c, d, a, x[i+ 5], 21, 0xfc93a039);
+		    a = ii(a, b, c, d, x[i+12], 6 , 0x655b59c3);
+		    d = ii(d, a, b, c, x[i+ 3], 10, 0x8f0ccc92);
+		    c = ii(c, d, a, b, x[i+10], 15, 0xffeff47d);
+		    b = ii(b, c, d, a, x[i+ 1], 21, 0x85845dd1);
+		    a = ii(a, b, c, d, x[i+ 8], 6 , 0x6fa87e4f);
+		    d = ii(d, a, b, c, x[i+15], 10, 0xfe2ce6e0);
+		    c = ii(c, d, a, b, x[i+ 6], 15, 0xa3014314);
+		    b = ii(b, c, d, a, x[i+13], 21, 0x4e0811a1);
+		    a = ii(a, b, c, d, x[i+ 4], 6 , 0xf7537e82);
+		    d = ii(d, a, b, c, x[i+11], 10, 0xbd3af235);
+		    c = ii(c, d, a, b, x[i+ 2], 15, 0x2ad7d2bb);
+		    b = ii(b, c, d, a, x[i+ 9], 21, 0xeb86d391);
+		
+			a += olda;
+			b += oldb;
+			c += oldc;
+			d += oldd;
+			
+		  }
+		  return [ a, b, c, d ];
+		}
+
+		/*
+		 * Bitwise rotate a 32-bit number to the left.
+		 */
+		private function rol(num:uint, cnt:uint):uint
+		{
+		  return (num << cnt) | (num >>> (32 - cnt));
+		}
+
+		/*
+		 * These functions implement the four basic operations the algorithm uses.
+		 */
+		private function cmn(q:uint, a:uint, b:uint, x:uint, s:uint, t:uint):uint {
+		  return rol(a + q + x + t, s) + b;
+		}
+		private function ff(a:uint, b:uint, c:uint, d:uint, x:uint, s:uint, t:uint):uint {
+		  return cmn((b & c) | ((~b) & d), a, b, x, s, t);
+		}
+		private function gg(a:uint, b:uint, c:uint, d:uint, x:uint, s:uint, t:uint):uint {
+		  return cmn((b & d) | (c & (~d)), a, b, x, s, t);
+		}
+		private function hh(a:uint, b:uint, c:uint, d:uint, x:uint, s:uint, t:uint):uint {
+		  return cmn(b ^ c ^ d, a, b, x, s, t);
+		}
+		private function ii(a:uint, b:uint, c:uint, d:uint, x:uint, s:uint, t:uint):uint {
+		  return cmn(c ^ (b | (~d)), a, b, x, s, t);
+		}
+
+		public function toString():String {
+			return "md5";
+		}
+	}
+}

data/node_modules/jasmine-runner/node_modules/socket.io/support/socket.io-client/lib/vendor/web-socket-js/flash-src/com/hurlant/crypto/hash/SHA1.as

@@ -0,0 +1,106 @@
+/**
+ * SHA1
+ * 
+ * An ActionScript 3 implementation of Secure Hash Algorithm, SHA-1, as defined
+ * in FIPS PUB 180-1
+ * Copyright (c) 2007 Henri Torgemane
+ * 
+ * Derived from:
+ * 		A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined
+ * 		in FIPS PUB 180-1
+ * 		Version 2.1a Copyright Paul Johnston 2000 - 2002.
+ * 		Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+ * 
+ * See LICENSE.txt for full license information.
+ */
+package com.hurlant.crypto.hash
+{
+	
+
+	public class SHA1 extends SHABase implements IHash
+	{
+		public static const HASH_SIZE:int = 20;
+		
+		public override function getHashSize():uint {
+			return HASH_SIZE;
+		}
+		
+		protected override function core(x:Array, len:uint):Array
+		{
+		  /* append padding */
+		  x[len >> 5] |= 0x80 << (24 - len % 32);
+		  x[((len + 64 >> 9) << 4) + 15] = len;
+		
+		  var w:Array = [];
+		  var a:uint =  0x67452301; //1732584193;
+		  var b:uint = 0xEFCDAB89; //-271733879;
+		  var c:uint = 0x98BADCFE; //-1732584194;
+		  var d:uint = 0x10325476; //271733878;
+		  var e:uint = 0xC3D2E1F0; //-1009589776;
+		
+		  for(var i:uint = 0; i < x.length; i += 16)
+		  {
+		  	
+		    var olda:uint = a;
+		    var oldb:uint = b;
+		    var oldc:uint = c;
+		    var oldd:uint = d;
+		    var olde:uint = e;
+		
+		    for(var j:uint = 0; j < 80; j++)
+		    {
+		      if (j < 16) {
+		      	w[j] = x[i + j] || 0;
+		      } else {
+		      	w[j] = rol(w[j-3] ^ w[j-8] ^ w[j-14] ^ w[j-16], 1);
+		      }
+		      var t:uint = rol(a,5) + ft(j,b,c,d) + e + w[j] + kt(j);
+		      e = d;
+		      d = c;
+		      c = rol(b, 30);
+		      b = a;
+		      a = t;
+		    }
+			a += olda;
+			b += oldb;
+			c += oldc;
+			d += oldd;
+			e += olde;
+		  }
+		  return [ a, b, c, d, e ];
+		
+		}
+		
+		/*
+		 * Bitwise rotate a 32-bit number to the left.
+		 */
+		private function rol(num:uint, cnt:uint):uint
+		{
+		  return (num << cnt) | (num >>> (32 - cnt));
+		}
+		
+		/*
+		 * Perform the appropriate triplet combination function for the current
+		 * iteration
+		 */
+		private function ft(t:uint, b:uint, c:uint, d:uint):uint
+		{
+		  if(t < 20) return (b & c) | ((~b) & d);
+		  if(t < 40) return b ^ c ^ d;
+		  if(t < 60) return (b & c) | (b & d) | (c & d);
+		  return b ^ c ^ d;
+		}
+		
+		/*
+		 * Determine the appropriate additive constant for the current iteration
+		 */
+		private function kt(t:uint):uint
+		{
+		  return (t < 20) ? 0x5A827999 : (t < 40) ?  0x6ED9EBA1 :
+		         (t < 60) ? 0x8F1BBCDC : 0xCA62C1D6;
+		}
+		public override function toString():String {
+			return "sha1";
+		}
+	}
+}

data/node_modules/jasmine-runner/node_modules/socket.io/support/socket.io-client/lib/vendor/web-socket-js/flash-src/com/hurlant/crypto/hash/SHA224.as

@@ -0,0 +1,28 @@
+/**
+ * SHA224
+ * 
+ * An ActionScript 3 implementation of Secure Hash Algorithm, SHA-224, as defined
+ * in FIPS PUB 180-2
+ * Copyright (c) 2007 Henri Torgemane
+ * 
+ * See LICENSE.txt for full license information.
+ */
+package com.hurlant.crypto.hash
+{
+	public class SHA224 extends SHA256
+	{
+		function SHA224() {
+			h = [
+				0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939,
+				0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4
+			];
+		}
+		
+		public override function getHashSize():uint {
+			return 28;
+		}
+		public override function toString():String {
+			return "sha224";
+		}
+	}
+}