rocket-js 0.0.1 → 0.0.2

data/src/vendor/web-socket-js/flash-src/com/hurlant/crypto/tests/HMACTest.as

@@ -0,0 +1,184 @@
+/**
+ * HMACTest
+ * 
+ * A test class for HMAC
+ * Copyright (c) 2007 Henri Torgemane
+ * 
+ * See LICENSE.txt for full license information.
+ */
+package com.hurlant.crypto.tests
+{
+	import com.hurlant.crypto.hash.HMAC;
+	import com.hurlant.crypto.hash.MD5;
+	import com.hurlant.crypto.hash.SHA1;
+	import com.hurlant.crypto.hash.SHA224;
+	import com.hurlant.crypto.hash.SHA256;
+	import com.hurlant.util.Hex;
+	
+	import flash.utils.ByteArray;
+	
+	public class HMACTest extends TestCase
+	{
+		public function HMACTest(h:ITestHarness)
+		{
+			super(h, "HMAC Test");
+			runTest(testHMAC_MD5,"HMAC MD5 Test Vectors");
+			runTest(testHMAC_SHA_1,"HMAC SHA-1 Test Vectors");
+			runTest(testHMAC_SHA_2,"HMAC SHA-224/SHA-256 Test Vectors");
+			runTest(testHMAC96_MD5,"HMAC-96 MD5 Test Vectors");
+			runTest(testHMAC96_SHA_1,"HMAC-96 SHA-1 Test Vectors");
+			runTest(testHMAC128_SHA_2,"HMAC-128 SHA-224/SHA-256 Test Vectors");
+			h.endTestCase();
+		}
+		/**
+		 * Test vectors taking from RFC2202
+		 * http://tools.ietf.org/html/rfc2202
+		 * Yes, it's from an RFC, jefe! Now waddayawant?
+		 */
+		public function testHMAC_SHA_1():void {
+			var keys:Array = [
+			"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b",
+			Hex.fromString("Jefe"),
+			"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+			"0102030405060708090a0b0c0d0e0f10111213141516171819",
+			"0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c",
+			"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+			"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"];
+			var pts:Array = [
+			Hex.fromString("Hi There"),
+			Hex.fromString("what do ya want for nothing?"),
+			"dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd",
+			"cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd",
+			Hex.fromString("Test With Truncation"),
+			Hex.fromString("Test Using Larger Than Block-Size Key - Hash Key First"),
+			Hex.fromString("Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data")];
+			var cts:Array = [
+			"b617318655057264e28bc0b6fb378c8ef146be00",
+			"effcdf6ae5eb2fa2d27416d5f184df9c259a7c79",
+			"125d7342b9ac11cd91a39af48aa17b4f63f175d3", 
+			"4c9007f4026250c6bc8414f9bf50c86c2d7235da", 
+			"4c1a03424b55e07fe7f27be1d58bb9324a9a5a04",
+			"aa4ae5e15272d00e95705637ce8a3b55ed402112",
+			"e8e99d0f45237d786d6bbaa7965c7808bbff1a91"];
+			
+			var hmac:HMAC = new HMAC(new SHA1());
+			for (var i:uint=0;i<keys.length;i++) {
+				var key:ByteArray = Hex.toArray(keys[i]);
+				var pt:ByteArray = Hex.toArray(pts[i]);
+				var digest:ByteArray = hmac.compute(key, pt);
+				assert("HMAC-SHA-1 test "+i, Hex.fromArray(digest) == cts[i]);
+			}
+		}
+		public function testHMAC96_SHA_1():void {
+			var hmac:HMAC = new HMAC(new SHA1, 96);
+			var key:ByteArray = Hex.toArray("0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c");
+			var pt:ByteArray = Hex.toArray(Hex.fromString("Test With Truncation"));
+			var ct:String = "4c1a03424b55e07fe7f27be1";
+			var digest:ByteArray = hmac.compute(key, pt);
+			assert("HMAC96-SHA-1 test", Hex.fromArray(digest) == ct);
+		}
+		
+		public function testHMAC_MD5():void {
+			var keys:Array = [
+			Hex.fromString("Jefe"),
+			"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b",
+			"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+			"0102030405060708090a0b0c0d0e0f10111213141516171819",
+			"0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c",
+			"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+			"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"];
+			var pts:Array = [
+			Hex.fromString("what do ya want for nothing?"),
+			Hex.fromString("Hi There"),
+			"dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd",
+			"cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd",
+			Hex.fromString("Test With Truncation"),
+			Hex.fromString("Test Using Larger Than Block-Size Key - Hash Key First"),
+			Hex.fromString("Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data")];
+			var cts:Array = [
+			"750c783e6ab0b503eaa86e310a5db738",
+			"9294727a3638bb1c13f48ef8158bfc9d",
+			"56be34521d144c88dbb8c733f0e8b3f6", 
+			"697eaf0aca3a3aea3a75164746ffaa79",
+			"56461ef2342edc00f9bab995690efd4c",
+			"6b1ab7fe4bd7bf8f0b62e6ce61b9d0cd",
+			"6f630fad67cda0ee1fb1f562db3aa53e"];
+
+			var hmac:HMAC = new HMAC(new MD5());
+			for (var i:uint=0;i<keys.length;i++) {
+				var key:ByteArray = Hex.toArray(keys[i]);
+				var pt:ByteArray = Hex.toArray(pts[i]);
+				var digest:ByteArray = hmac.compute(key, pt);
+				assert("HMAC-MD5 test "+i, Hex.fromArray(digest) == cts[i]);
+			}
+		}
+		public function testHMAC96_MD5():void {
+			var hmac:HMAC = new HMAC(new MD5, 96);
+			var key:ByteArray = Hex.toArray("0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c");
+			var pt:ByteArray = Hex.toArray(Hex.fromString("Test With Truncation"));
+			var ct:String = "56461ef2342edc00f9bab995";
+			var digest:ByteArray = hmac.compute(key, pt);
+			assert("HMAC96-MD5 test", Hex.fromArray(digest) == ct);
+		}
+		
+		/**
+		 * Test vectors for HMAC-SHA-2 taken from RFC4231
+		 * http://www.ietf.org/rfc/rfc4231.txt
+		 * Still the same lame strings, but hidden in hex. why not.
+		 */
+		public function testHMAC_SHA_2():void {
+			var keys:Array = [
+			"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b",
+			"4a656665",
+			"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+			"0102030405060708090a0b0c0d0e0f10111213141516171819",
+			"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+			"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"];
+			var pts:Array = [
+			"4869205468657265",
+			"7768617420646f2079612077616e7420666f72206e6f7468696e673f",
+			"dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd",
+			"cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd",
+			"54657374205573696e67204c6172676572205468616e20426c6f636b2d53697a65204b6579202d2048617368204b6579204669727374",
+			"5468697320697320612074657374207573696e672061206c6172676572207468616e20626c6f636b2d73697a65206b657920616e642061206c6172676572207468616e20626c6f636b2d73697a6520646174612e20546865206b6579206e6565647320746f20626520686173686564206265666f7265206265696e6720757365642062792074686520484d414320616c676f726974686d2e"];
+			var cts224:Array = [
+			"896fb1128abbdf196832107cd49df33f47b4b1169912ba4f53684b22",
+			"a30e01098bc6dbbf45690f3a7e9e6d0f8bbea2a39e6148008fd05e44",
+			"7fb3cb3588c6c1f6ffa9694d7d6ad2649365b0c1f65d69d1ec8333ea",
+			"6c11506874013cac6a2abc1bb382627cec6a90d86efc012de7afec5a",
+			"95e9a0db962095adaebe9b2d6f0dbce2d499f112f2d2b7273fa6870e",
+			"3a854166ac5d9f023f54d517d0b39dbd946770db9c2b95c9f6f565d1"];
+			var cts256:Array = [
+			"b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7",
+			"5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843",
+			"773ea91e36800e46854db8ebd09181a72959098b3ef8c122d9635514ced565fe",
+			"82558a389a443c0ea4cc819899f2083a85f0faa3e578f8077a2e3ff46729665b",
+			"60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f0ee37f54",
+			"9b09ffa71b942fcb27635fbcd5b0e944bfdc63644f0713938a7f51535c3a35e2"];
+			// 384 and 512 will be added. someday. if I ever figure how to do 64bit computations half efficiently in as3
+
+			var hmac224:HMAC = new HMAC(new SHA224);
+			var hmac256:HMAC = new HMAC(new SHA256);
+			for (var i:uint=0;i<keys.length;i++) {
+				var key:ByteArray = Hex.toArray(keys[i]);
+				var pt:ByteArray = Hex.toArray(pts[i]);
+				var digest224:ByteArray = hmac224.compute(key, pt);
+				assert("HMAC-SHA-224 test "+i, Hex.fromArray(digest224) == cts224[i]);
+				var digest256:ByteArray = hmac256.compute(key, pt);
+				assert("HMAC-SHA-256 test "+i, Hex.fromArray(digest256) == cts256[i]);
+			}
+		}
+		public function testHMAC128_SHA_2():void {
+			var hmac224:HMAC = new HMAC(new SHA224,128);
+			var hmac256:HMAC = new HMAC(new SHA256,128);
+			var key:ByteArray = Hex.toArray("0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c");
+			var pt:ByteArray = Hex.toArray("546573742057697468205472756e636174696f6e");
+			var ct224:String = "0e2aea68a90c8d37c988bcdb9fca6fa8";
+			var ct256:String = "a3b6167473100ee06e0c796c2955552b";
+			var digest224:ByteArray = hmac224.compute(key, pt);
+			assert("HMAC128-SHA-224 test", Hex.fromArray(digest224) == ct224);
+			var digest256:ByteArray = hmac256.compute(key, pt);
+			assert("HMAC128-SHA-256 test", Hex.fromArray(digest256) == ct256);
+		}
+	}
+}

data/src/vendor/web-socket-js/flash-src/com/hurlant/crypto/tests/ITestHarness.as

@@ -0,0 +1,20 @@
+/**
+ * ITestHarness
+ * 
+ * An interface to specify what's available for test cases to use.
+ * Copyright (c) 2007 Henri Torgemane
+ * 
+ * See LICENSE.txt for full license information.
+ */
+package com.hurlant.crypto.tests
+{
+	public interface ITestHarness
+	{
+		function beginTestCase(name:String):void;
+		function endTestCase():void;
+		
+		function beginTest(name:String):void;
+		function passTest():void;
+		function failTest(msg:String):void;
+	}
+}

data/src/vendor/web-socket-js/flash-src/com/hurlant/crypto/tests/MD2Test.as

@@ -0,0 +1,56 @@
+/**
+ * MD2Test
+ * 
+ * A test class for MD2
+ * Copyright (c) 2007 Henri Torgemane
+ * 
+ * See LICENSE.txt for full license information.
+ */
+package com.hurlant.crypto.tests
+{
+	import com.hurlant.crypto.hash.MD2;
+	import com.hurlant.util.Hex;
+	
+	import flash.utils.ByteArray;
+	
+	public class MD2Test extends TestCase
+	{
+		public function MD2Test(h:ITestHarness)
+		{
+			super(h, "MD2 Test");
+			runTest(testMd2, "MD2 Test Vectors");
+			h.endTestCase();
+		}
+		
+		/**
+		 * Test Vectors grabbed from
+		 * http://www.faqs.org/rfcs/rfc1319.html
+		 */
+		public function testMd2():void {
+			var srcs:Array = [
+			"",
+			Hex.fromString("a"),
+			Hex.fromString("abc"),
+			Hex.fromString("message digest"),
+			Hex.fromString("abcdefghijklmnopqrstuvwxyz"),
+			Hex.fromString("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"),
+			Hex.fromString("12345678901234567890123456789012345678901234567890123456789012345678901234567890")
+			];
+			var hashes:Array = [
+			"8350e5a3e24c153df2275c9f80692773",
+			"32ec01ec4a6dac72c0ab96fb34c0b5d1",
+			"da853b0d3f88d99b30283a69e6ded6bb",
+			"ab4f496bfb2a530b219ff33031fe06b0",
+			"4e8ddff3650292ab5a4108c3aa47940b",
+			"da33def2a42df13975352846c30338cd",
+			"d5976f79d83d3a0dc9806c3c66f3efd8"
+			];
+			var md2:MD2 = new MD2;
+			for (var i:uint=0;i<srcs.length;i++) {
+				var src:ByteArray = Hex.toArray(srcs[i]);
+				var digest:ByteArray = md2.hash(src);
+				assert("MD2 Test "+i, Hex.fromArray(digest) == hashes[i]);
+			}
+		}
+	}
+}

data/src/vendor/web-socket-js/flash-src/com/hurlant/crypto/tests/MD5Test.as

@@ -0,0 +1,58 @@
+/**
+ * MD5Test
+ * 
+ * A test class for MD5
+ * Copyright (c) 2007 Henri Torgemane
+ * 
+ * See LICENSE.txt for full license information.
+ */
+package com.hurlant.crypto.tests
+{
+	import com.hurlant.crypto.hash.MD5;
+	import com.hurlant.util.Hex;
+	
+	import flash.utils.ByteArray;
+	
+	public class MD5Test extends TestCase
+	{
+		public function MD5Test(h:ITestHarness)
+		{
+			super(h, "MD5 Test");
+			runTest(testMd5,"MD5 Test Vectors");
+			h.endTestCase();
+		}
+		
+		/**
+		 * Test Vectors grabbed from
+		 * http://www.faqs.org/rfcs/rfc1321.html
+		 */
+		public function testMd5():void {
+			var srcs:Array = [
+			"",
+			Hex.fromString("a"),
+			Hex.fromString("abc"),
+			Hex.fromString("message digest"),
+			Hex.fromString("abcdefghijklmnopqrstuvwxyz"),
+			Hex.fromString("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"),
+			Hex.fromString("12345678901234567890123456789012345678901234567890123456789012345678901234567890")
+			];
+			var hashes:Array = [
+			"d41d8cd98f00b204e9800998ecf8427e",
+			"0cc175b9c0f1b6a831c399e269772661",
+			"900150983cd24fb0d6963f7d28e17f72",
+			"f96b697d7cb7938d525a2f31aaf161d0",
+			"c3fcd3d76192e4007dfb496cca67e13b",
+			"d174ab98d277d9f5a5611c2c9f419d9f",
+			"57edf4a22be3c955ac49da2e2107b67a"
+			];
+			var md5:MD5 = new MD5;
+			for (var i:uint=0;i<srcs.length;i++) {
+				var src:ByteArray = Hex.toArray(srcs[i]);
+				var digest:ByteArray = md5.hash(src);
+				assert("MD5 Test "+i, Hex.fromArray(digest) == hashes[i]);
+			}
+			
+		}
+		
+	}
+}

data/src/vendor/web-socket-js/flash-src/com/hurlant/crypto/tests/OFBModeTest.as

@@ -0,0 +1,101 @@
+/**
+ * OFBModeTest
+ * 
+ * A test class for OFBMode
+ * Copyright (c) 2007 Henri Torgemane
+ * 
+ * See LICENSE.txt for full license information.
+ */
+package com.hurlant.crypto.tests
+{
+	import flash.utils.ByteArray;
+	import com.hurlant.util.Hex;
+	import com.hurlant.crypto.symmetric.OFBMode;
+	import com.hurlant.crypto.symmetric.AESKey;
+	import com.hurlant.crypto.symmetric.NullPad;
+	
+	public class OFBModeTest extends TestCase
+	{
+		public function OFBModeTest(h:ITestHarness)
+		{
+			super(h, "OFBMode Test");
+			runTest(testOFB_AES128,"OFB AES-128 Test Vectors");
+			runTest(testOFB_AES192,"OFB AES-192 Test Vectors");
+			runTest(testOFB_AES256,"OFB AES-256 Test Vectors");
+			h.endTestCase();
+		}
+		
+		/**
+		 * Nist Vectors: http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
+		 * Section F.4.1 and below.
+		 */
+		public function testOFB_AES128():void {
+			var key:ByteArray = Hex.toArray("2b7e151628aed2a6abf7158809cf4f3c");
+			var pt:ByteArray = Hex.toArray(
+				"6bc1bee22e409f96e93d7e117393172a" +
+				"ae2d8a571e03ac9c9eb76fac45af8e51" + 
+				"30c81c46a35ce411e5fbc1191a0a52ef" + 
+				"f69f2445df4f9b17ad2b417be66c3710");
+			var ct:ByteArray = Hex.toArray(
+				"3b3fd92eb72dad20333449f8e83cfb4a" +
+				"7789508d16918f03f53c52dac54ed825" + 
+				"9740051e9c5fecf64344f7a82260edcc" + 
+				"304c6528f659c77866a510d9c1d6ae5e");
+			var ofb:OFBMode = new OFBMode(new AESKey(key), new NullPad);
+			ofb.IV = Hex.toArray("000102030405060708090a0b0c0d0e0f");
+			var src:ByteArray = new ByteArray;
+			src.writeBytes(pt);
+			ofb.encrypt(src);
+			assert("OFB_AES128 test 1", Hex.fromArray(src)==Hex.fromArray(ct));
+			ofb.decrypt(src);
+			assert("OFB_AES128 test 2", Hex.fromArray(src)==Hex.fromArray(pt));
+		}
+		
+		public function testOFB_AES192():void {
+			var key:ByteArray = Hex.toArray("8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b");
+			var pt:ByteArray = Hex.toArray(
+				"6bc1bee22e409f96e93d7e117393172a" + 
+				"ae2d8a571e03ac9c9eb76fac45af8e51" + 
+				"30c81c46a35ce411e5fbc1191a0a52ef" + 
+				"f69f2445df4f9b17ad2b417be66c3710");
+			var ct:ByteArray = Hex.toArray(
+				"cdc80d6fddf18cab34c25909c99a4174" + 
+				"fcc28b8d4c63837c09e81700c1100401" + 
+				"8d9a9aeac0f6596f559c6d4daf59a5f2" + 
+				"6d9f200857ca6c3e9cac524bd9acc92a");
+			var ofb:OFBMode = new OFBMode(new AESKey(key), new NullPad);
+			ofb.IV = Hex.toArray("000102030405060708090a0b0c0d0e0f");
+			var src:ByteArray = new ByteArray;
+			src.writeBytes(pt);
+			ofb.encrypt(src);
+			assert("OFB_AES192 test 1", Hex.fromArray(src)==Hex.fromArray(ct));
+			ofb.decrypt(src);
+			assert("OFB_AES192 test 2", Hex.fromArray(src)==Hex.fromArray(pt));
+		}
+		
+		public function testOFB_AES256():void {
+			var key:ByteArray = Hex.toArray(
+				"603deb1015ca71be2b73aef0857d7781" + 
+				"1f352c073b6108d72d9810a30914dff4");
+			var pt:ByteArray = Hex.toArray(
+				"6bc1bee22e409f96e93d7e117393172a" + 
+				"ae2d8a571e03ac9c9eb76fac45af8e51" + 
+				"30c81c46a35ce411e5fbc1191a0a52ef" + 
+				"f69f2445df4f9b17ad2b417be66c3710");
+			var ct:ByteArray = Hex.toArray(
+				"dc7e84bfda79164b7ecd8486985d3860" + 
+				"4febdc6740d20b3ac88f6ad82a4fb08d" + 
+				"71ab47a086e86eedf39d1c5bba97c408" + 
+				"0126141d67f37be8538f5a8be740e484");
+			var ofb:OFBMode = new OFBMode(new AESKey(key), new NullPad);
+			ofb.IV = Hex.toArray("000102030405060708090a0b0c0d0e0f");
+			var src:ByteArray = new ByteArray;
+			src.writeBytes(pt);
+			ofb.encrypt(src);
+			assert("OFB_AES256 test 1", Hex.fromArray(src)==Hex.fromArray(ct));
+			ofb.decrypt(src);
+			assert("OFB_AES256 test 2", Hex.fromArray(src)==Hex.fromArray(pt));
+		}
+		
+	}
+}

data/src/vendor/web-socket-js/flash-src/com/hurlant/crypto/tests/RSAKeyTest.as

@@ -0,0 +1,92 @@
+/**
+ * RSAKeyTest
+ * 
+ * A test class for RSAKey
+ * Copyright (c) 2007 Henri Torgemane
+ * 
+ * See LICENSE.txt for full license information.
+ */
+package com.hurlant.crypto.tests
+{
+	import com.hurlant.crypto.rsa.RSAKey;
+	import flash.utils.ByteArray;
+	import com.hurlant.util.Hex;
+	import com.hurlant.util.der.PEM;
+	
+	public class RSAKeyTest extends TestCase
+	{
+		public function RSAKeyTest(h:ITestHarness)
+		{
+			super(h, "RSA Testing");
+			
+			runTest(testSmoke,"RSA smoke test");
+			runTest(testGenerate, "RSA Key Generation test");
+			runTest(testPEM, "RSA Private Key PEM parsing");
+			runTest(testPEM2, "RSA Public Key PEM parsing");
+			h.endTestCase();
+		}
+		
+		public function testSmoke():void {
+			var N:String ="C4E3F7212602E1E396C0B6623CF11D26204ACE3E7D26685E037AD2507DCE82FC" + 
+					"28F2D5F8A67FC3AFAB89A6D818D1F4C28CFA548418BD9F8E7426789A67E73E41";
+			var E:String = "10001";
+			var D:String = "7cd1745aec69096129b1f42da52ac9eae0afebbe0bc2ec89253598dcf454960e" + 
+					"3e5e4ec9f8c87202b986601dd167253ee3fb3fa047e14f1dfd5ccd37e931b29d";
+			var P:String = "f0e4dd1eac5622bd3932860fc749bbc48662edabdf3d2826059acc0251ac0d3b";
+			var Q:String = "d13cb38fbcd06ee9bca330b4000b3dae5dae12b27e5173e4d888c325cda61ab3";
+			var DMP1:String = "b3d5571197fc31b0eb6b4153b425e24c033b054d22b9c8282254fe69d8c8c593";
+			var DMQ1:String = "968ffe89e50d7b72585a79b65cfdb9c1da0963cceb56c3759e57334de5a0ac3f";
+			var IQMP:String = "d9bc4f420e93adad9f007d0e5744c2fe051c9ed9d3c9b65f439a18e13d6e3908";
+			// create a key.
+			var rsa:RSAKey = RSAKey.parsePrivateKey(N,E,D, P,Q,DMP1,DMQ1,IQMP);
+			var txt:String = "hello";
+			var src:ByteArray = Hex.toArray(Hex.fromString(txt));
+			var dst:ByteArray = new ByteArray;
+			var dst2:ByteArray = new ByteArray;
+			rsa.encrypt(src, dst, src.length);
+			rsa.decrypt(dst, dst2, dst.length);
+			var txt2:String = Hex.toString(Hex.fromArray(dst2));
+			assert("rsa encrypt+decrypt", txt==txt2);
+		}
+		
+		public function testGenerate():void {
+			var rsa:RSAKey = RSAKey.generate(256, "10001");
+			// same lame smoke test here.
+			var txt:String = "hello";
+			var src:ByteArray = Hex.toArray(Hex.fromString(txt));
+			var dst:ByteArray = new ByteArray;
+			var dst2:ByteArray = new ByteArray;
+			rsa.encrypt(src, dst, src.length);
+			rsa.decrypt(dst, dst2, dst.length);
+			var txt2:String = Hex.toString(Hex.fromArray(dst2));
+			assert("rsa encrypt+decrypt", txt==txt2);
+		}
+		
+		public function testPEM():void {
+			var pem:String = "-----BEGIN RSA PRIVATE KEY-----\n" + 
+					"MGQCAQACEQDJG3bkuB9Ie7jOldQTVdzPAgMBAAECEQCOGqcPhP8t8mX8cb4cQEaR\n" + 
+					"AgkA5WTYuAGmH0cCCQDgbrto0i7qOQIINYr5btGrtccCCQCYy4qX4JDEMQIJAJll\n" + 
+					"OnLVtCWk\n" + 
+					"-----END RSA PRIVATE KEY-----";
+			var rsa:RSAKey = PEM.readRSAPrivateKey(pem);
+			//trace(rsa.dump());
+
+			// obligatory use
+			var txt:String = "hello";
+			var src:ByteArray = Hex.toArray(Hex.fromString(txt));
+			var dst:ByteArray = new ByteArray;
+			var dst2:ByteArray = new ByteArray;
+			rsa.encrypt(src, dst, src.length);
+			rsa.decrypt(dst, dst2, dst.length);
+			var txt2:String = Hex.toString(Hex.fromArray(dst2));
+			assert("rsa encrypt+decrypt", txt==txt2);
+		}
+		public function testPEM2():void {
+			var pem:String = "-----BEGIN PUBLIC KEY-----\n" + 
+					"MCwwDQYJKoZIhvcNAQEBBQADGwAwGAIRAMkbduS4H0h7uM6V1BNV3M8CAwEAAQ==\n" + 
+					"-----END PUBLIC KEY-----";
+			var rsa:RSAKey = PEM.readRSAPublicKey(pem);
+			//trace(rsa.dump());
+		}
+	}
+}