rocket-js 0.0.1 → 0.0.2

data/src/vendor/web-socket-js/flash-src/com/hurlant/crypto/tls/TLSError.as

@@ -0,0 +1,39 @@
+/**
+ * TLSError
+ * 
+ * A error that can be thrown when something wrong happens in the TLS protocol.
+ * This is handled in TLSEngine by generating a TLS ALERT as appropriate.
+ * Copyright (c) 2007 Henri Torgemane
+ * 
+ * See LICENSE.txt for full license information.
+ */
+package com.hurlant.crypto.tls {
+	public class TLSError extends Error {
+		public static const close_notify:uint = 0;
+		public static const unexpected_message:uint = 10;
+        public static const bad_record_mac:uint = 20;
+        public static const decryption_failed:uint = 21;
+        public static const record_overflow:uint = 22;
+        public static const decompression_failure:uint = 30;
+        public static const handshake_failure:uint = 40;
+        public static const bad_certificate:uint = 42;
+        public static const unsupported_certificate:uint = 43;
+        public static const certificate_revoked:uint = 44;
+        public static const certificate_expired:uint = 45;
+        public static const certificate_unknown:uint = 46;
+        public static const illegal_parameter:uint = 47;
+        public static const unknown_ca:uint = 48;
+        public static const access_denied:uint = 49;
+        public static const decode_error:uint = 50;
+        public static const decrypt_error:uint = 51;
+        public static const protocol_version:uint = 70;
+        public static const insufficient_security:uint = 71;
+        public static const internal_error:uint = 80;
+        public static const user_canceled:uint = 90;
+        public static const no_renegotiation:uint = 100;
+        
+        public function TLSError(message:String, id:int) {
+        	super(message,id);
+        }
+	}
+}

data/src/vendor/web-socket-js/flash-src/com/hurlant/crypto/tls/TLSEvent.as

@@ -0,0 +1,27 @@
+/**
+ * TLSEvent
+ * 
+ * This is used by TLSEngine to let the application layer know
+ * when we're ready for sending, or have received application data
+ * Copyright (c) 2007 Henri Torgemane
+ * 
+ * See LICENSE.txt for full license information.
+ */
+package com.hurlant.crypto.tls {
+	import flash.events.Event;
+	import flash.utils.ByteArray;
+	
+	public class TLSEvent extends Event {
+		
+		static public const DATA:String = "data";
+		static public const READY:String = "ready";
+		static public const PROMPT_ACCEPT_CERT:String = "promptAcceptCert";
+		
+		public var data:ByteArray;
+		
+		public function TLSEvent(type:String, data:ByteArray = null) {
+			this.data = data;
+			super(type, false, false);
+		}
+	}
+}

data/src/vendor/web-socket-js/flash-src/com/hurlant/crypto/tls/TLSSecurityParameters.as

@@ -0,0 +1,197 @@
+/**
+ * TLSSecurityParameters
+ * 
+ * This class encapsulates all the security parameters that get negotiated
+ * during the TLS handshake. It also holds all the key derivation methods.
+ * Copyright (c) 2007 Henri Torgemane
+ * 
+ * Patched by Bobby Parker (sh0rtwave@gmail.com)
+ * 
+ * See LICENSE.txt for full license information.
+ */
+package com.hurlant.crypto.tls {
+	import com.hurlant.crypto.hash.MD5;
+	import com.hurlant.crypto.hash.SHA1;
+	import com.hurlant.crypto.prng.TLSPRF;
+	import com.hurlant.util.Hex;
+	
+	import flash.utils.ByteArray;
+	import com.hurlant.crypto.rsa.RSAKey;
+	
+	public class TLSSecurityParameters implements ISecurityParameters {
+		
+		// COMPRESSION
+		public static const COMPRESSION_NULL:uint = 0;
+		
+		// This is probably not smart. Revise this to use all settings from TLSConfig, since this shouldn't really know about
+		// user settings, those are best handled from the engine at a session level.
+		public static var IGNORE_CN_MISMATCH:Boolean = true;
+		public static var ENABLE_USER_CLIENT_CERTIFICATE:Boolean = false;
+		public static var USER_CERTIFICATE:String;
+		
+		
+		private var cert:ByteArray; // Local Cert
+		private var key:RSAKey; // local key
+		private var entity:uint; // SERVER | CLIENT
+		private var bulkCipher:uint; // BULK_CIPHER_*
+		private var cipherType:uint; // STREAM_CIPHER | BLOCK_CIPHER
+		private var keySize:uint;
+		private var keyMaterialLength:uint;
+		private var IVSize:uint;
+		private var macAlgorithm:uint; // MAC_*
+		private var hashSize:uint;
+		private var compression:uint; // COMPRESSION_NULL
+		private var masterSecret:ByteArray; // 48 bytes
+		private var clientRandom:ByteArray; // 32 bytes
+		private var serverRandom:ByteArray; // 32 bytes
+		private var ignoreCNMismatch:Boolean = true;
+		private var trustAllCerts:Boolean = false;
+		private var trustSelfSigned:Boolean = false;
+		public static const PROTOCOL_VERSION:uint = 0x0301; 
+		private var tlsDebug:Boolean = false;
+
+		
+		// not strictly speaking part of this, but yeah.
+		public var keyExchange:uint;
+		public function TLSSecurityParameters(entity:uint, localCert:ByteArray = null, localKey:RSAKey = null) {
+			this.entity = entity;
+			reset();
+			key = localKey;
+			cert = localCert;
+		}
+		
+		public function get version() : uint {
+			return PROTOCOL_VERSION;
+		}
+		
+		public function reset():void {
+			bulkCipher = BulkCiphers.NULL;
+			cipherType = BulkCiphers.BLOCK_CIPHER;
+			macAlgorithm = MACs.NULL;
+			compression = COMPRESSION_NULL;
+			masterSecret = null;
+		}
+		
+		public function getBulkCipher():uint {
+			return bulkCipher;
+		}
+		public function getCipherType():uint {
+			return cipherType;
+		}
+		public function getMacAlgorithm():uint {
+			return macAlgorithm;
+		}
+		
+		public function setCipher(cipher:uint):void {
+			bulkCipher = CipherSuites.getBulkCipher(cipher);
+			cipherType = BulkCiphers.getType(bulkCipher);
+			keySize = BulkCiphers.getExpandedKeyBytes(bulkCipher);   // 8
+			keyMaterialLength = BulkCiphers.getKeyBytes(bulkCipher); // 5
+			IVSize = BulkCiphers.getIVSize(bulkCipher);
+			
+			keyExchange = CipherSuites.getKeyExchange(cipher);
+			
+			macAlgorithm = CipherSuites.getMac(cipher);
+			hashSize = MACs.getHashSize(macAlgorithm);
+		}
+		public function setCompression(algo:uint):void {
+			compression = algo;
+		}
+		public function setPreMasterSecret(secret:ByteArray):void {
+			// compute master_secret
+			var seed:ByteArray = new ByteArray;
+			seed.writeBytes(clientRandom, 0, clientRandom.length);
+			seed.writeBytes(serverRandom, 0, serverRandom.length);
+			var prf:TLSPRF = new TLSPRF(secret, "master secret", seed);
+			masterSecret = new ByteArray;
+			prf.nextBytes(masterSecret, 48);
+			if (tlsDebug)
+				trace("Master Secret: " + Hex.fromArray( masterSecret, true ));
+		}
+		public function setClientRandom(secret:ByteArray):void {
+			clientRandom = secret;
+		}
+		public function setServerRandom(secret:ByteArray):void { 
+			serverRandom = secret;
+		}
+		
+		public function get useRSA():Boolean {
+			return KeyExchanges.useRSA(keyExchange);
+		}
+		
+		public function computeVerifyData(side:uint, handshakeMessages:ByteArray):ByteArray {
+			var seed:ByteArray = new ByteArray;
+			var md5:MD5 = new MD5;
+			if (tlsDebug)
+				trace("Handshake value: " + Hex.fromArray(handshakeMessages, true ));
+			seed.writeBytes(md5.hash(handshakeMessages),0,md5.getHashSize());
+			var sha:SHA1 = new SHA1;
+			seed.writeBytes(sha.hash(handshakeMessages),0,sha.getHashSize());
+			if (tlsDebug)
+				trace("Seed in: " + Hex.fromArray(seed, true ));
+			var prf:TLSPRF = new TLSPRF(masterSecret, (side==TLSEngine.CLIENT) ? "client finished" : "server finished", seed);
+			var out:ByteArray = new ByteArray;
+			prf.nextBytes(out, 12);
+			if (tlsDebug)
+				trace("Finished out: " + Hex.fromArray(out, true ));
+			out.position = 0;
+			return out;
+		}
+		
+		// client side certficate check - This is probably incorrect somehow
+		public function computeCertificateVerify( side:uint, handshakeMessages:ByteArray ):ByteArray {
+			var seed:ByteArray = new ByteArray;
+			var md5:MD5 = new MD5;
+			seed.writeBytes(md5.hash(handshakeMessages),0,md5.getHashSize());
+			var sha:SHA1 = new SHA1;
+			seed.writeBytes(sha.hash(handshakeMessages),0,sha.getHashSize());
+			
+			// Now that I have my hashes of existing handshake messages (which I'm not sure about the length of yet) then 
+			// Sign that with my private key
+			seed.position = 0;
+			var out:ByteArray = new ByteArray();
+			key.sign( seed, out, seed.bytesAvailable);
+			out.position = 0;
+			return out;	
+		}
+		
+		public function getConnectionStates():Object {
+			if (masterSecret != null) {
+				var seed:ByteArray = new ByteArray;
+				seed.writeBytes(serverRandom, 0, serverRandom.length);
+				seed.writeBytes(clientRandom, 0, clientRandom.length);
+				var prf:TLSPRF = new TLSPRF(masterSecret, "key expansion", seed);
+				
+				var client_write_MAC:ByteArray = new ByteArray;
+				prf.nextBytes(client_write_MAC, hashSize);
+				var server_write_MAC:ByteArray = new ByteArray;
+				prf.nextBytes(server_write_MAC, hashSize);
+				var client_write_key:ByteArray = new ByteArray;
+				prf.nextBytes(client_write_key, keyMaterialLength);
+				var server_write_key:ByteArray = new ByteArray;
+				prf.nextBytes(server_write_key, keyMaterialLength);
+				var client_write_IV:ByteArray = new ByteArray;
+				prf.nextBytes(client_write_IV, IVSize);
+				var server_write_IV:ByteArray = new ByteArray;
+				prf.nextBytes(server_write_IV, IVSize);
+
+				var client_write:TLSConnectionState = new TLSConnectionState(
+						bulkCipher, cipherType, macAlgorithm,
+						client_write_MAC, client_write_key, client_write_IV);
+				var server_write:TLSConnectionState = new TLSConnectionState(
+						bulkCipher, cipherType, macAlgorithm,
+						server_write_MAC, server_write_key, server_write_IV);
+				
+				if (entity == TLSEngine.CLIENT) {
+					return {read:server_write, write:client_write};
+				} else {
+					return {read:client_write, write:server_write};
+				}
+
+			} else {
+				return {read:new TLSConnectionState, write:new TLSConnectionState};
+			}
+		}
+		
+	}
+}

data/src/vendor/web-socket-js/flash-src/com/hurlant/crypto/tls/TLSSocket.as

@@ -0,0 +1,370 @@
+/**
+ * TLSSocket
+ * 
+ * This is the "end-user" TLS class.
+ * It works just like a Socket, by encapsulating a Socket and
+ * wrapping the TLS protocol around the data that passes over it.
+ * This class can either create a socket connection, or reuse an
+ * existing connected socket. The later is useful for STARTTLS flows.
+ * 
+ * Copyright (c) 2007 Henri Torgemane
+ * 
+ * See LICENSE.txt for full license information.
+ */
+package com.hurlant.crypto.tls {
+	import flash.events.Event;
+	import flash.events.EventDispatcher;
+	import flash.events.IOErrorEvent;
+	import flash.events.ProgressEvent;
+	import flash.events.SecurityErrorEvent;
+	import flash.net.ObjectEncoding;
+	import flash.net.Socket;
+	import flash.utils.ByteArray;
+	import flash.utils.Endian;
+	import flash.utils.IDataInput;
+	import flash.utils.IDataOutput;
+	import flash.utils.clearTimeout;
+	import flash.utils.setTimeout;
+	import com.hurlant.crypto.cert.X509Certificate;
+	
+	
+	[Event(name="close", type="flash.events.Event")]
+	[Event(name="connect", type="flash.events.Event")]
+	[Event(name="ioError", type="flash.events.IOErrorEvent")]
+	[Event(name="securityError", type="flash.events.SecurityErrorEvent")]
+	[Event(name="socketData", type="flash.events.ProgressEvent")]
+	[Event(name="acceptPeerCertificatePrompt", type="flash.events.Event")]
+	
+	/**
+	 * It feels like a socket, but it wraps the stream
+	 * over TLS 1.0
+	 * 
+	 * That's all.
+	 * 
+	 */
+	public class TLSSocket extends Socket implements IDataInput, IDataOutput {
+		
+		private var _endian:String;
+		private var _objectEncoding:uint;
+		
+		private var _iStream:ByteArray;
+		private var _oStream:ByteArray;
+		private var _iStream_cursor:uint;
+		
+		private var _socket:Socket;
+		private var _config:TLSConfig;
+		private var _engine:TLSEngine;
+		public static const ACCEPT_PEER_CERT_PROMPT:String = "acceptPeerCertificatePrompt"
+		
+		public function TLSSocket(host:String = null, port:int = 0, config:TLSConfig = null) {
+			_config = config;
+			if (host!=null && port!=0) {
+				connect(host, port);
+			}
+		}
+		
+		override public function get bytesAvailable():uint {
+			return _iStream.bytesAvailable;
+		}
+		override public function get connected():Boolean {
+			return _socket.connected;
+		}
+		override public function get endian():String {
+			return _endian;
+		}
+		override public function set endian(value:String):void {
+			_endian = value;
+			_iStream.endian = value;
+			_oStream.endian = value;
+		}
+		override public function get objectEncoding():uint {
+			return _objectEncoding;
+		}
+		override public function set objectEncoding(value:uint):void {
+			_objectEncoding = value;
+			_iStream.objectEncoding = value;
+			_oStream.objectEncoding = value;
+		}
+		
+		
+		private function onTLSData(event:TLSEvent):void {
+			if (_iStream.position == _iStream.length) {
+				_iStream.position = 0;
+				_iStream.length = 0;
+				_iStream_cursor = 0;
+			}
+			var cursor:uint = _iStream.position;
+			_iStream.position = _iStream_cursor;
+			_iStream.writeBytes(event.data);
+			_iStream_cursor = _iStream.position;
+			_iStream.position = cursor;
+			dispatchEvent(new ProgressEvent(ProgressEvent.SOCKET_DATA, false, false, event.data.length));
+		}
+		
+		private function onTLSReady(event:TLSEvent):void {
+			_ready = true;
+			scheduleWrite();
+		}
+		
+		private function onTLSClose(event:Event):void {
+			dispatchEvent(event);
+			// trace("Received TLS close");
+			close();
+		}
+		
+		private var _ready:Boolean;
+		private var _writeScheduler:uint;
+		private function scheduleWrite():void {
+			if (_writeScheduler!=0) return;
+			_writeScheduler = setTimeout(commitWrite, 0);
+		}
+		private function commitWrite():void {
+			clearTimeout(_writeScheduler);
+			_writeScheduler = 0;
+			if (_ready) {
+				_engine.sendApplicationData(_oStream);
+				_oStream.length = 0;
+			}
+		}
+		
+		
+		override public function close():void {
+			_ready = false;
+			_engine.close();
+			if (_socket.connected) {
+				_socket.flush();
+				_socket.close();
+			}
+		}
+		public function setTLSConfig( config:TLSConfig) : void {
+			_config = config;
+		}		
+
+		override public function connect(host:String, port:int):void {
+			init(new Socket, _config, host);
+			_socket.connect(host, port);
+			_engine.start();
+		}
+		
+		public function releaseSocket() : void {
+			_socket.removeEventListener(Event.CONNECT, dispatchEvent);
+			_socket.removeEventListener(IOErrorEvent.IO_ERROR, dispatchEvent);
+			_socket.removeEventListener(SecurityErrorEvent.SECURITY_ERROR, dispatchEvent);
+			_socket.removeEventListener(Event.CLOSE, dispatchEvent);
+			_socket.removeEventListener(ProgressEvent.SOCKET_DATA, _engine.dataAvailable);
+			_socket = null; 
+		}
+		
+		public function reinitialize(host:String, config:TLSConfig) : void {
+			// Reinitialize the connection using new values
+			// but re-use the existing socket
+			// Doubt this is useful in any valid context other than my specific case (VMWare)
+			var ba:ByteArray = new ByteArray;
+			
+			if (_socket.bytesAvailable > 0) {
+				_socket.readBytes(ba, 0, _socket.bytesAvailable);	
+			}
+			// Do nothing with it.
+			_iStream = new ByteArray;
+			_oStream = new ByteArray;
+			_iStream_cursor = 0;
+			objectEncoding = ObjectEncoding.DEFAULT;
+			endian = Endian.BIG_ENDIAN;
+			/* 
+			_socket.addEventListener(Event.CONNECT, dispatchEvent);
+			_socket.addEventListener(IOErrorEvent.IO_ERROR, dispatchEvent);
+			_socket.addEventListener(SecurityErrorEvent.SECURITY_ERROR, dispatchEvent);
+			_socket.addEventListener(Event.CLOSE, dispatchEvent);
+			*/
+			
+			if (config == null) {
+				config = new TLSConfig(TLSEngine.CLIENT);
+			}
+			
+			_engine = new TLSEngine(config, _socket, _socket, host);
+			_engine.addEventListener(TLSEvent.DATA, onTLSData);
+			_engine.addEventListener(TLSEvent.READY, onTLSReady);
+			_engine.addEventListener(Event.CLOSE, onTLSClose);
+			_engine.addEventListener(ProgressEvent.SOCKET_DATA, function(e:*):void { _socket.flush(); });
+			_socket.addEventListener(ProgressEvent.SOCKET_DATA, _engine.dataAvailable);
+			_engine.addEventListener( TLSEvent.PROMPT_ACCEPT_CERT, onAcceptCert );
+
+			_ready = false;
+			_engine.start();
+		}
+		
+		public function startTLS(socket:Socket, host:String, config:TLSConfig = null):void {
+			if (!socket.connected) {
+				throw new Error("Cannot STARTTLS on a socket that isn't connected.");
+			}
+			init(socket, config, host);
+			_engine.start();
+		}
+		
+		private function init(socket:Socket, config:TLSConfig, host:String):void {
+			_iStream = new ByteArray;
+			_oStream = new ByteArray;
+			_iStream_cursor = 0;
+			objectEncoding = ObjectEncoding.DEFAULT;
+			endian = Endian.BIG_ENDIAN;
+			_socket = socket;
+			_socket.addEventListener(Event.CONNECT, dispatchEvent);
+			_socket.addEventListener(IOErrorEvent.IO_ERROR, dispatchEvent);
+			_socket.addEventListener(SecurityErrorEvent.SECURITY_ERROR, dispatchEvent);
+			_socket.addEventListener(Event.CLOSE, dispatchEvent);
+			
+			if (config == null) {
+				config = new TLSConfig(TLSEngine.CLIENT);
+			}
+			_engine = new TLSEngine(config, _socket, _socket, host);
+			_engine.addEventListener(TLSEvent.DATA, onTLSData);
+			_engine.addEventListener( TLSEvent.PROMPT_ACCEPT_CERT, onAcceptCert );
+			_engine.addEventListener(TLSEvent.READY, onTLSReady);
+			_engine.addEventListener(Event.CLOSE, onTLSClose);
+			_engine.addEventListener(ProgressEvent.SOCKET_DATA, function(e:*):void { if(connected) _socket.flush(); });
+			_socket.addEventListener(ProgressEvent.SOCKET_DATA, _engine.dataAvailable);
+
+			_ready = false;
+		}
+		
+		override public function flush():void {
+			commitWrite();
+			_socket.flush();
+		}
+		
+		override public function readBoolean():Boolean {
+			return _iStream.readBoolean();
+		}
+		
+		override public function readByte():int {
+			return _iStream.readByte();
+		}
+		
+		override public function readBytes(bytes:ByteArray, offset:uint = 0, length:uint = 0):void {
+			return _iStream.readBytes(bytes, offset, length);
+		}
+		
+		override public function readDouble():Number {
+			return _iStream.readDouble();
+		}
+		
+		override public function readFloat():Number {
+			return _iStream.readFloat();
+		}
+		
+		override public function readInt():int {
+			return _iStream.readInt();
+		}
+		
+		override public function readMultiByte(length:uint, charSet:String):String {
+			return _iStream.readMultiByte(length, charSet);
+		}
+		
+		override public function readObject():* {
+			return _iStream.readObject();
+		}
+		
+		override public function readShort():int {
+			return _iStream.readShort();
+		}
+		
+		override public function readUnsignedByte():uint {
+			return _iStream.readUnsignedByte();
+		}
+		
+		override public function readUnsignedInt():uint {
+			return _iStream.readUnsignedInt();
+		}
+		
+		override public function readUnsignedShort():uint {
+			return _iStream.readUnsignedShort();
+		}
+		
+		override public function readUTF():String {
+			return _iStream.readUTF();
+		}
+		
+		override public function readUTFBytes(length:uint):String {
+			return _iStream.readUTFBytes(length);
+		}
+		
+		override public function writeBoolean(value:Boolean):void {
+			_oStream.writeBoolean(value);
+			scheduleWrite();
+		}
+		
+		override public function writeByte(value:int):void {
+			_oStream.writeByte(value);
+			scheduleWrite();
+		}
+		
+		override public function writeBytes(bytes:ByteArray, offset:uint = 0, length:uint = 0):void {
+			_oStream.writeBytes(bytes, offset, length);
+			scheduleWrite();
+		}
+		
+		override public function writeDouble(value:Number):void {
+			_oStream.writeDouble(value);
+			scheduleWrite();
+		}
+		
+		override public function writeFloat(value:Number):void {
+			_oStream.writeFloat(value);
+			scheduleWrite();
+		}
+		
+		override public function writeInt(value:int):void {
+			_oStream.writeInt(value);
+			scheduleWrite();
+		}
+		
+		override public function writeMultiByte(value:String, charSet:String):void {
+			_oStream.writeMultiByte(value, charSet);
+			scheduleWrite();
+		}
+		
+		override public function writeObject(object:*):void {
+			_oStream.writeObject(object);
+			scheduleWrite();
+		}
+		
+		override public function writeShort(value:int):void {
+			_oStream.writeShort(value);
+			scheduleWrite();
+		}
+		
+		override public function writeUnsignedInt(value:uint):void {
+			_oStream.writeUnsignedInt(value);
+			scheduleWrite();
+		}
+		
+		override public function writeUTF(value:String):void {
+			_oStream.writeUTF(value);
+			scheduleWrite();
+		}
+		
+		override public function writeUTFBytes(value:String):void {
+			_oStream.writeUTFBytes(value);
+			scheduleWrite();
+		}
+		
+		public function getPeerCertificate() : X509Certificate {
+			return _engine.peerCertificate;
+		}
+		
+		public function onAcceptCert( event:TLSEvent ) : void {
+			dispatchEvent( new TLSSocketEvent( _engine.peerCertificate ) );
+		}
+		
+		// These are just a passthroughs to the engine. Encapsulation, et al
+		public function acceptPeerCertificate( event:Event ) : void {
+			_engine.acceptPeerCertificate();
+		}
+	
+		public function rejectPeerCertificate( event:Event ) : void {
+			_engine.rejectPeerCertificate();
+		}
+		
+	}
+}
+