rocket-js 0.0.1 → 0.0.2

data/src/vendor/web-socket-js/flash-src/com/hurlant/crypto/symmetric/ECBMode.as

@@ -0,0 +1,86 @@
+/**
+ * ECBMode
+ * 
+ * An ActionScript 3 implementation of the ECB confidentiality mode
+ * Copyright (c) 2007 Henri Torgemane
+ * 
+ * See LICENSE.txt for full license information.
+ */
+package com.hurlant.crypto.symmetric
+{
+	import flash.utils.ByteArray;
+	import com.hurlant.util.Memory;
+	import com.hurlant.util.Hex;
+	
+	/**
+	 * ECB mode.
+	 * This uses a padding and a symmetric key.
+	 * If no padding is given, PKCS#5 is used.
+	 */
+	public class ECBMode implements IMode, ICipher
+	{
+		private var key:ISymmetricKey;
+		private var padding:IPad;
+		
+		public function ECBMode(key:ISymmetricKey, padding:IPad = null) {
+			this.key = key;
+			if (padding == null) {
+				padding = new PKCS5(key.getBlockSize());
+			} else {
+				padding.setBlockSize(key.getBlockSize());
+			}
+			this.padding = padding;
+		}
+		
+		public function getBlockSize():uint {
+			return key.getBlockSize();
+		}
+		
+		public function encrypt(src:ByteArray):void {
+			padding.pad(src);
+			src.position = 0;
+			var blockSize:uint = key.getBlockSize();
+			var tmp:ByteArray = new ByteArray;
+			var dst:ByteArray = new ByteArray;
+			for (var i:uint=0;i<src.length;i+=blockSize) {
+				tmp.length=0;
+				src.readBytes(tmp, 0, blockSize);
+				key.encrypt(tmp);
+				dst.writeBytes(tmp);
+			}
+			src.length=0;
+			src.writeBytes(dst);
+		}
+		public function decrypt(src:ByteArray):void {
+			src.position = 0;
+			var blockSize:uint = key.getBlockSize();
+			
+			// sanity check.
+			if (src.length%blockSize!=0) {
+				throw new Error("ECB mode cipher length must be a multiple of blocksize "+blockSize);
+			}
+			
+			var tmp:ByteArray = new ByteArray;
+			var dst:ByteArray = new ByteArray;
+			for (var i:uint=0;i<src.length;i+=blockSize) {
+				tmp.length=0;
+				src.readBytes(tmp, 0, blockSize);
+				
+				key.decrypt(tmp);
+				dst.writeBytes(tmp);
+			}
+			padding.unpad(dst);
+			src.length=0;
+			src.writeBytes(dst);
+		}
+		public function dispose():void {
+			key.dispose();
+			key = null;
+			padding = null;
+			Memory.gc();
+		}
+		public function toString():String {
+			return key.toString()+"-ecb";
+		}
+	}
+}

data/src/vendor/web-socket-js/flash-src/com/hurlant/crypto/symmetric/ICipher.as

@@ -0,0 +1,21 @@
+/**
+ * ICipher
+ * 
+ * A generic interface to use symmetric ciphers
+ * Copyright (c) 2007 Henri Torgemane
+ * 
+ * See LICENSE.txt for full license information.
+ */
+package com.hurlant.crypto.symmetric
+{
+	import flash.utils.ByteArray;
+	
+	public interface ICipher
+	{
+		function getBlockSize():uint;
+		function encrypt(src:ByteArray):void;
+		function decrypt(src:ByteArray):void;
+		function dispose():void;
+		function toString():String;
+	}
+}

data/src/vendor/web-socket-js/flash-src/com/hurlant/crypto/symmetric/IMode.as

@@ -0,0 +1,15 @@
+/**
+ * IMode
+ * 
+ * An interface for confidentiality modes to implement
+ * This could become deprecated at some point.
+ * Copyright (c) 2007 Henri Torgemane
+ * 
+ * See LICENSE.txt for full license information.
+ */
+package com.hurlant.crypto.symmetric 
+{
+	public interface IMode extends ICipher
+	{
+	}
+}

data/src/vendor/web-socket-js/flash-src/com/hurlant/crypto/symmetric/IPad.as

@@ -0,0 +1,32 @@
+/**
+ * IPad
+ * 
+ * An interface for padding mechanisms to implement.
+ * Copyright (c) 2007 Henri Torgemane
+ * 
+ * See LICENSE.txt for full license information.
+ */
+package com.hurlant.crypto.symmetric
+{
+	import flash.utils.ByteArray;
+	
+	/**
+	 * Tiny interface that represents a padding mechanism.
+	 */
+	public interface IPad
+	{
+		/**
+		 * Add padding to the array
+		 */
+		function pad(a:ByteArray):void;
+		/**
+		 * Remove padding from the array.
+		 * @throws Error if the padding is invalid.
+		 */
+		function unpad(a:ByteArray):void;
+		/**
+		 * Set the blockSize to work on
+		 */
+		function setBlockSize(bs:uint):void;
+	}
+}

data/src/vendor/web-socket-js/flash-src/com/hurlant/crypto/symmetric/IStreamCipher.as

@@ -0,0 +1,21 @@
+/**
+ * IStreamCipher
+ * 
+ * A "marker" interface for stream ciphers.
+ * Copyright (c) 2007 Henri Torgemane
+ * 
+ * See LICENSE.txt for full license information.
+ */
+package com.hurlant.crypto.symmetric {
+	
+	/**
+	 * A marker to indicate how this cipher works.
+	 * A stream cipher:
+	 * - does not use initialization vector
+	 * - keeps some internal state between calls to encrypt() and decrypt()
+	 * 
+	 */
+	public interface IStreamCipher extends ICipher {
+		
+	}
+}

data/src/vendor/web-socket-js/flash-src/com/hurlant/crypto/symmetric/ISymmetricKey.as

@@ -0,0 +1,35 @@
+/**
+ * ISymmetricKey
+ * 
+ * An interface for symmetric encryption keys to implement.
+ * Copyright (c) 2007 Henri Torgemane
+ * 
+ * See LICENSE.txt for full license information.
+ */
+package com.hurlant.crypto.symmetric
+{
+	import flash.utils.ByteArray;
+	
+	public interface ISymmetricKey
+	{
+		/**
+		 * Returns the block size used by this particular encryption algorithm
+		 */
+		function getBlockSize():uint;
+		/**
+		 * Encrypt one block of data in "block", starting at "index", of length "getBlockSize()"
+		 */
+		function encrypt(block:ByteArray, index:uint=0):void;
+		/**
+		 * Decrypt one block of data in "block", starting at "index", of length "getBlockSize()"
+		 */
+		function decrypt(block:ByteArray, index:uint=0):void;
+		/**
+		 * Attempts to destroy sensitive information from memory, such as encryption keys.
+		 * Note: This is not guaranteed to work given the Flash sandbox model.
+		 */
+		function dispose():void;
+		
+		function toString():String;
+	}
+}

data/src/vendor/web-socket-js/flash-src/com/hurlant/crypto/symmetric/IVMode.as

@@ -0,0 +1,110 @@
+/**
+ * IVMode
+ * 
+ * An abstract class for confidentialy modes that rely on an initialization vector.
+ * Copyright (c) 2007 Henri Torgemane
+ * 
+ * See LICENSE.txt for full license information.
+ */
+package com.hurlant.crypto.symmetric
+{
+	import com.hurlant.crypto.prng.Random;
+	import com.hurlant.crypto.tests.TestCase;
+	import com.hurlant.util.Memory;
+	
+	import flash.utils.ByteArray;
+	
+	/**
+	 * An "abtract" class to avoid redundant code in subclasses
+	 */
+	public class IVMode
+	{
+		protected var key:ISymmetricKey;
+		protected var padding:IPad;
+		// random generator used to generate IVs
+		protected var prng:Random;
+		// optional static IV. used for testing only.
+		protected var iv:ByteArray;
+		// generated IV is stored here.
+		protected var lastIV:ByteArray;
+		protected var blockSize:uint;
+		
+		
+		public function IVMode(key:ISymmetricKey, padding:IPad = null) {
+			this.key = key;
+			blockSize = key.getBlockSize();
+			if (padding == null) {
+				padding = new PKCS5(blockSize);
+			} else {
+				padding.setBlockSize(blockSize);
+			}
+			this.padding = padding;
+			
+			prng = new Random;
+			iv = null;
+			lastIV = new ByteArray;
+		}
+		
+		public function getBlockSize():uint {
+			return key.getBlockSize();
+		}
+		public function dispose():void {
+			var i:uint;
+			if (iv != null) {
+				for (i=0;i<iv.length;i++) {
+					iv[i] = prng.nextByte();
+				}
+				iv.length=0;
+				iv = null;
+			}
+			if (lastIV != null) {
+				for (i=0;i<iv.length;i++) {
+					lastIV[i] = prng.nextByte();
+				}
+				lastIV.length=0;
+				lastIV=null;
+			}
+			key.dispose();
+			key = null;
+			padding = null;
+			prng.dispose();
+			prng = null;
+			Memory.gc();
+		}
+		/**
+		 * Optional function to force the IV value.
+		 * Normally, an IV gets generated randomly at every encrypt() call.
+		 * Also, use this to set the IV before calling decrypt()
+		 * (if not set before decrypt(), the IV is read from the beginning of the stream.)
+		 */
+		public function set IV(value:ByteArray):void {
+			iv = value;
+			lastIV.length=0;
+			lastIV.writeBytes(iv);
+		}
+		public function get IV():ByteArray {
+			return lastIV;
+		}
+		
+		protected function getIV4e():ByteArray {
+			var vec:ByteArray = new ByteArray;
+			if (iv) {
+				vec.writeBytes(iv);
+			} else {
+				prng.nextBytes(vec, blockSize);
+			}
+			lastIV.length=0;
+			lastIV.writeBytes(vec);
+			return vec;
+		}
+		protected function getIV4d():ByteArray {
+			var vec:ByteArray = new ByteArray;
+			if (iv) {
+				vec.writeBytes(iv);
+			} else {
+				throw new Error("an IV must be set before calling decrypt()");
+			}
+			return vec;
+		}
+	}
+}

data/src/vendor/web-socket-js/flash-src/com/hurlant/crypto/symmetric/NullPad.as

@@ -0,0 +1,34 @@
+/**
+ * NullPad
+ * 
+ * A padding class that doesn't pad.
+ * Copyright (c) 2007 Henri Torgemane
+ * 
+ * See LICENSE.txt for full license information.
+ */
+package com.hurlant.crypto.symmetric
+{
+	import flash.utils.ByteArray;
+
+	/**
+	 * A pad that does nothing.
+	 * Useful when you don't want padding in your Mode.
+	 */
+	public class NullPad implements IPad
+	{
+		public function unpad(a:ByteArray):void
+		{
+			return;
+		}
+		
+		public function pad(a:ByteArray):void
+		{
+			return;
+		}
+
+		public function setBlockSize(bs:uint):void {
+			return;
+		}
+		
+	}
+}

data/src/vendor/web-socket-js/flash-src/com/hurlant/crypto/symmetric/OFBMode.as

@@ -0,0 +1,52 @@
+/**
+ * OFBMode
+ * 
+ * An ActionScript 3 implementation of the OFB confidentiality mode
+ * Copyright (c) 2007 Henri Torgemane
+ * 
+ * See LICENSE.txt for full license information.
+ */
+package com.hurlant.crypto.symmetric
+{
+	import flash.utils.ByteArray;
+
+	public class OFBMode extends IVMode implements IMode
+	{
+		public function OFBMode(key:ISymmetricKey, padding:IPad=null)
+		{
+			super(key, null);
+		}
+		
+		public function encrypt(src:ByteArray):void
+		{
+			var vector:ByteArray = getIV4e();
+			core(src, vector);
+		}
+		
+		public function decrypt(src:ByteArray):void
+		{
+			var vector:ByteArray = getIV4d();
+			core(src, vector);
+		}
+		
+		private function core(src:ByteArray, iv:ByteArray):void { 
+			var l:uint = src.length;
+			var tmp:ByteArray = new ByteArray;
+			for (var i:uint=0;i<src.length;i+=blockSize) {
+				key.encrypt(iv);
+				tmp.position=0;
+				tmp.writeBytes(iv);
+				var chunk:uint = (i+blockSize<l)?blockSize:l-i;
+				for (var j:uint=0;j<chunk;j++) {
+					src[i+j] ^= iv[j];
+				}
+				iv.position=0;
+				iv.writeBytes(tmp);
+			}
+		}
+		public function toString():String {
+			return key.toString()+"-ofb";
+		}
+		
+	}
+}

data/src/vendor/web-socket-js/flash-src/com/hurlant/crypto/symmetric/PKCS5.as

@@ -0,0 +1,44 @@
+/**
+ * PKCS5
+ * 
+ * A padding implementation of PKCS5.
+ * Copyright (c) 2007 Henri Torgemane
+ * 
+ * See LICENSE.txt for full license information.
+ */
+package com.hurlant.crypto.symmetric
+{
+	import flash.utils.ByteArray;
+	
+	public class PKCS5 implements IPad
+	{
+		private var blockSize:uint;
+		
+		public function PKCS5(blockSize:uint=0) {
+			this.blockSize = blockSize;
+		}
+		
+		public function pad(a:ByteArray):void {
+			var c:uint = blockSize-a.length%blockSize;
+			for (var i:uint=0;i<c;i++){
+				a[a.length] = c;
+			}
+		}
+		public function unpad(a:ByteArray):void {
+			var c:uint = a.length%blockSize;
+			if (c!=0) throw new Error("PKCS#5::unpad: ByteArray.length isn't a multiple of the blockSize");
+			c = a[a.length-1];
+			for (var i:uint=c;i>0;i--) {
+				var v:uint = a[a.length-1];
+				a.length--;
+				if (c!=v) throw new Error("PKCS#5:unpad: Invalid padding value. expected ["+c+"], found ["+v+"]");
+			}
+			// that is all.
+		}
+
+		public function setBlockSize(bs:uint):void {
+			blockSize = bs;
+		}
+
+	}
+}