rocket-js 0.0.1 → 0.0.2

data/src/vendor/web-socket-js/flash-src/com/hurlant/crypto/cert/X509Certificate.as

@@ -0,0 +1,218 @@
+/**
+ * X509Certificate
+ * 
+ * A representation for a X509 Certificate, with
+ * methods to parse, verify and sign it.
+ * Copyright (c) 2007 Henri Torgemane
+ * 
+ * See LICENSE.txt for full license information.
+ */
+package com.hurlant.crypto.cert {
+	import com.hurlant.crypto.hash.IHash;
+	import com.hurlant.crypto.hash.MD2;
+	import com.hurlant.crypto.hash.MD5;
+	import com.hurlant.crypto.hash.SHA1;
+	import com.hurlant.crypto.rsa.RSAKey;
+	import com.hurlant.util.ArrayUtil;
+	import com.hurlant.util.Base64;
+	import com.hurlant.util.der.ByteString;
+	import com.hurlant.util.der.DER;
+	import com.hurlant.util.der.OID;
+	import com.hurlant.util.der.ObjectIdentifier;
+	import com.hurlant.util.der.PEM;
+	import com.hurlant.util.der.PrintableString;
+	import com.hurlant.util.der.Sequence;
+	import com.hurlant.util.der.Type;
+	
+	import flash.utils.ByteArray;
+	
+	public class X509Certificate {
+		private var _loaded:Boolean;
+		private var _param:*;
+		private var _obj:Object;
+		public function X509Certificate(p:*) {
+			_loaded = false;
+			_param = p;
+			// lazy initialization, to avoid unnecessary parsing of every builtin CA at start-up.
+		}
+		private function load():void {
+			if (_loaded) return;
+			var p:* = _param;
+			var b:ByteArray;
+			if (p is String) {
+				b = PEM.readCertIntoArray(p as String);
+			} else if (p is ByteArray) {
+				b = p;
+			}
+			if (b!=null) {
+				_obj = DER.parse(b, Type.TLS_CERT);
+				_loaded = true;
+			} else {
+				throw new Error("Invalid x509 Certificate parameter: "+p);
+			}
+		}
+		public function isSigned(store:X509CertificateCollection, CAs:X509CertificateCollection, time:Date=null):Boolean {
+			load();
+			// check timestamps first. cheapest.
+			if (time==null) {
+				time = new Date;
+			}
+			var notBefore:Date = getNotBefore();
+			var notAfter:Date = getNotAfter();
+			if (time.getTime()<notBefore.getTime()) return false; // cert isn't born yet.
+			if (time.getTime()>notAfter.getTime()) return false;  // cert died of old age.
+			// check signature.
+			var subject:String = getIssuerPrincipal();
+			// try from CA first, since they're treated better.
+			var parent:X509Certificate = CAs.getCertificate(subject);
+			var parentIsAuthoritative:Boolean = false;
+			if (parent == null) {
+				parent = store.getCertificate(subject);
+				if (parent == null) {
+					return false; // issuer not found
+				}
+			} else {
+				parentIsAuthoritative = true;
+			}
+			if (parent == this) { // pathological case. avoid infinite loop
+				return false; // isSigned() returns false if we're self-signed.
+			}
+			if (!(parentIsAuthoritative&&parent.isSelfSigned(time)) &&
+				!parent.isSigned(store, CAs, time)) {
+				return false;
+			}
+			var key:RSAKey = parent.getPublicKey();
+			return verifyCertificate(key);
+		}
+		public function isSelfSigned(time:Date):Boolean {
+			load();
+			
+			var key:RSAKey = getPublicKey();
+			return verifyCertificate(key);
+		}
+		private function verifyCertificate(key:RSAKey):Boolean {
+			var algo:String = getAlgorithmIdentifier();
+			var hash:IHash;
+			var oid:String;
+			switch (algo) {
+				case OID.SHA1_WITH_RSA_ENCRYPTION:
+					hash = new SHA1;
+					oid = OID.SHA1_ALGORITHM;
+					break;
+				case OID.MD2_WITH_RSA_ENCRYPTION:
+					hash = new MD2;
+					oid = OID.MD2_ALGORITHM;
+					break;
+				case OID.MD5_WITH_RSA_ENCRYPTION:
+					hash = new MD5;
+					oid = OID.MD5_ALGORITHM;
+					break;
+				default:
+					return false;
+			}
+			var data:ByteArray = _obj.signedCertificate_bin;
+			var buf:ByteArray = new ByteArray;
+			key.verify(_obj.encrypted, buf, _obj.encrypted.length);
+			buf.position=0;
+			data = hash.hash(data);
+			var obj:Object = DER.parse(buf, Type.RSA_SIGNATURE);
+			if (obj.algorithm.algorithmId.toString() != oid) {
+				return false; // wrong algorithm
+			}
+			if (!ArrayUtil.equals(obj.hash, data)) {
+				return false; // hashes don't match
+			}
+			return true;
+		}
+		
+		/**
+		 * This isn't used anywhere so far.
+		 * It would become useful if we started to offer facilities
+		 * to generate and sign X509 certificates.
+		 * 
+		 * @param key
+		 * @param algo
+		 * @return 
+		 * 
+		 */
+		private function signCertificate(key:RSAKey, algo:String):ByteArray {
+			var hash:IHash;
+			var oid:String;
+			switch (algo) {
+				case OID.SHA1_WITH_RSA_ENCRYPTION:
+					hash = new SHA1;
+					oid = OID.SHA1_ALGORITHM;
+					break;
+				case OID.MD2_WITH_RSA_ENCRYPTION:
+					hash = new MD2;
+					oid = OID.MD2_ALGORITHM;
+					break;
+				case OID.MD5_WITH_RSA_ENCRYPTION:
+					hash = new MD5;
+					oid = OID.MD5_ALGORITHM;
+					break;
+				default:
+					return null
+			}
+			var data:ByteArray = _obj.signedCertificate_bin;
+			data = hash.hash(data);
+			var seq1:Sequence = new Sequence;
+			seq1[0] = new Sequence;
+			seq1[0][0] = new ObjectIdentifier(0,0, oid);
+			seq1[0][1] = null;
+			seq1[1] = new ByteString;
+			seq1[1].writeBytes(data);
+			data = seq1.toDER();
+			var buf:ByteArray = new ByteArray;
+			key.sign(data, buf, data.length);
+			return buf;
+		}
+		
+		public function getPublicKey():RSAKey {
+			load();
+			var pk:ByteArray = _obj.signedCertificate.subjectPublicKeyInfo.subjectPublicKey as ByteArray;
+			pk.position = 0;
+			var rsaKey:Object = DER.parse(pk, [{name:"N"},{name:"E"}]);
+			return new RSAKey(rsaKey.N, rsaKey.E.valueOf());
+		}
+		
+		/**
+		 * Returns a subject principal, as an opaque base64 string.
+		 * This is only used as a hash key for known certificates.
+		 * 
+		 * Note that this assumes X509 DER-encoded certificates are uniquely encoded,
+		 * as we look for exact matches between Issuer and Subject fields.
+		 * 
+		 */
+		public function getSubjectPrincipal():String {
+			load();
+			return Base64.encodeByteArray(_obj.signedCertificate.subject_bin);
+		}
+		/**
+		 * Returns an issuer principal, as an opaque base64 string.
+		 * This is only used to quickly find matching parent certificates.
+		 * 
+		 * Note that this assumes X509 DER-encoded certificates are uniquely encoded,
+		 * as we look for exact matches between Issuer and Subject fields.
+		 * 
+		 */
+		public function getIssuerPrincipal():String {
+			load();
+			return Base64.encodeByteArray(_obj.signedCertificate.issuer_bin);
+		}
+		public function getAlgorithmIdentifier():String {
+			return _obj.algorithmIdentifier.algorithmId.toString();
+		}
+		public function getNotBefore():Date {
+			return _obj.signedCertificate.validity.notBefore.date;
+		}
+		public function getNotAfter():Date {
+			return _obj.signedCertificate.validity.notAfter.date;
+		}
+		
+		public function getCommonName():String {
+			var subject:Sequence = _obj.signedCertificate.subject;
+			return (subject.findAttributeValue(OID.COMMON_NAME) as PrintableString).getString();
+		}
+	}
+}

data/src/vendor/web-socket-js/flash-src/com/hurlant/crypto/cert/X509CertificateCollection.as

@@ -0,0 +1,57 @@
+/**
+ * X509CertificateCollection
+ * 
+ * A class to store and index X509 Certificates by Subject.
+ * Copyright (c) 2007 Henri Torgemane
+ * 
+ * See LICENSE.txt for full license information.
+ */
+package com.hurlant.crypto.cert {
+	
+	public class X509CertificateCollection {
+		
+		private var _map:Object;
+		
+		public function X509CertificateCollection() {
+			_map = {};
+		}
+		
+		/**
+		 * Mostly meant for built-in CA loading.
+		 * This entry-point allows to index CAs without parsing them.
+		 * 
+		 * @param name		A friendly name. not currently used
+		 * @param subject	base64 DER encoded Subject principal for the Cert
+		 * @param pem		PEM encoded certificate data
+		 * 
+		 */
+		public function addPEMCertificate(name:String, subject:String, pem:String):void {
+			_map[subject] = new X509Certificate(pem);
+		}
+		
+		/**
+		 * Adds a X509 certificate to the collection.
+		 * This call will force the certificate to be parsed.
+		 * 
+		 * @param cert		A X509 certificate
+		 * 
+		 */
+		public function addCertificate(cert:X509Certificate):void {
+			var subject:String = cert.getSubjectPrincipal();
+			_map[subject] = cert;
+		}
+		
+		/**
+		 * Returns a X509 Certificate present in the collection, given
+		 * a base64 DER encoded X500 Subject principal
+		 * 
+		 * @param subject	A Base64 DER-encoded Subject principal
+		 * @return 			A matching certificate, or null.
+		 * 
+		 */
+		public function getCertificate(subject:String):X509Certificate {
+			return _map[subject];
+		}
+		
+	}
+}

data/src/vendor/web-socket-js/flash-src/com/hurlant/crypto/hash/HMAC.as

@@ -0,0 +1,82 @@
+/**
+ * HMAC
+ * 
+ * An ActionScript 3 implementation of HMAC, Keyed-Hashing for Message
+ * Authentication, as defined by RFC-2104
+ * Copyright (c) 2007 Henri Torgemane
+ * 
+ * See LICENSE.txt for full license information.
+ */
+package com.hurlant.crypto.hash
+{
+	import flash.utils.ByteArray;
+	import com.hurlant.util.Hex;
+	
+	public class HMAC implements IHMAC
+	{
+		private var hash:IHash;
+		private var bits:uint;
+		
+		/**
+		 * Create a HMAC object, using a Hash function, and 
+		 * optionally a number of bits to return. 
+		 * The HMAC will be truncated to that size if needed.
+		 */
+		public function HMAC(hash:IHash, bits:uint=0) {
+			this.hash = hash;
+			this.bits = bits;
+		}
+		
+
+		public function getHashSize():uint {
+			if (bits!=0) {
+				return bits/8;
+			} else {
+				return hash.getHashSize();
+			}
+		}
+		
+		/**
+		 * Compute a HMAC using a key and some data.
+		 * It doesn't modify either, and returns a new ByteArray with the HMAC value.
+		 */
+		public function compute(key:ByteArray, data:ByteArray):ByteArray {
+			var hashKey:ByteArray;
+			if (key.length>hash.getInputSize()) {
+				hashKey = hash.hash(key);
+			} else {
+				hashKey = new ByteArray;
+				hashKey.writeBytes(key);
+			}
+			while (hashKey.length<hash.getInputSize()) {
+				hashKey[hashKey.length]=0;
+			}
+			var innerKey:ByteArray = new ByteArray;
+			var outerKey:ByteArray = new ByteArray;
+			for (var i:uint=0;i<hashKey.length;i++) {
+				innerKey[i] = hashKey[i] ^ 0x36;
+				outerKey[i] = hashKey[i] ^ 0x5c;
+			}
+			// inner + data
+			innerKey.position = hashKey.length;
+			innerKey.writeBytes(data);
+			var innerHash:ByteArray = hash.hash(innerKey);
+			// outer + innerHash
+			outerKey.position = hashKey.length;
+			outerKey.writeBytes(innerHash);
+			var outerHash:ByteArray = hash.hash(outerKey);
+			if (bits>0 && bits<8*outerHash.length) {
+				outerHash.length = bits/8;
+			}
+			return outerHash;
+		}
+		public function dispose():void {
+			hash = null;
+			bits = 0;
+		}
+		public function toString():String {
+			return "hmac-"+(bits>0?bits+"-":"")+hash.toString();
+		}
+		
+	}
+}

data/src/vendor/web-socket-js/flash-src/com/hurlant/crypto/hash/IHMAC.as

@@ -0,0 +1,27 @@
+/**
+ * HMAC
+ * 
+ * An ActionScript 3 interface for HMAC & MAC 
+ * implementations.
+ * 
+ * Loosely copyrighted by Bobby Parker
+ * 
+ * See LICENSE.txt for full license information.
+ */
+package com.hurlant.crypto.hash
+{
+	import flash.utils.ByteArray;
+	
+	public interface IHMAC 
+	{
+		function getHashSize():uint;
+		/**
+		 * Compute a HMAC using a key and some data.
+		 * It doesn't modify either, and returns a new ByteArray with the HMAC value.
+		 */
+		function compute(key:ByteArray, data:ByteArray):ByteArray;
+		function dispose():void;
+		function toString():String;
+		
+	}
+}

data/src/vendor/web-socket-js/flash-src/com/hurlant/crypto/hash/IHash.as

@@ -0,0 +1,21 @@
+/**
+ * IHash
+ * 
+ * An interface for each hash function to implement
+ * Copyright (c) 2007 Henri Torgemane
+ * 
+ * See LICENSE.txt for full license information.
+ */
+package com.hurlant.crypto.hash
+{
+	import flash.utils.ByteArray;
+
+	public interface IHash
+	{
+		function getInputSize():uint;
+		function getHashSize():uint;
+		function hash(src:ByteArray):ByteArray;
+		function toString():String;
+		function getPadSize():int;
+	}
+}

data/src/vendor/web-socket-js/flash-src/com/hurlant/crypto/hash/MAC.as

@@ -0,0 +1,137 @@
+/**
+ * MAC
+ * 
+ * An ActionScript 3 implementation of MAC, Message Authentication Code
+ * for use with SSL 3.0.
+ * Loosely copyrighted by Bobby Parker.
+ * As3crypto copyrighted by Henri Torgemane.
+ * 
+ * See LICENSE.txt for full license information.
+ */
+package com.hurlant.crypto.hash
+{
+	import flash.utils.ByteArray;
+	import com.hurlant.util.Hex;
+	
+	public class MAC implements IHMAC
+	{
+		private var hash:IHash;
+		private var bits:uint;
+		private var pad_1:ByteArray;
+		private var pad_2:ByteArray;
+		private var innerHash:ByteArray;
+		private var outerHash:ByteArray;
+		private var outerKey:ByteArray;
+		private var innerKey:ByteArray;
+		/**
+		 * Create a MAC object (for SSL 3.0 ) and 
+		 * optionally a number of bits to return. 
+		 * The MAC will be truncated to that size if needed.
+		 */
+		public function MAC(hash:IHash, bits:uint=0) {
+			this.hash = hash;
+			this.bits = bits;
+			innerHash = new ByteArray();
+			outerHash = new ByteArray();
+			innerKey = new ByteArray();
+			outerKey = new ByteArray();
+
+
+			if (hash != null) { 
+				var pad_size:int = hash.getPadSize();
+				pad_1 = new ByteArray();
+				pad_2 = new ByteArray();
+			
+				for (var x:int = 0; x < pad_size; x++) {
+					pad_1.writeByte(0x36);
+					pad_2.writeByte(0x5c);
+				}
+			}
+		}
+		
+		public function setPadSize(pad_size:int) : void {	}
+		
+		public function getHashSize():uint {
+			if (bits!=0) {
+				return bits/8;
+			} else {
+				return hash.getHashSize();
+			}
+		}
+		
+		
+		/**
+		 * Compute a MAC using a key and some data.
+		 * 
+		 */ 
+		public function compute(key:ByteArray, data:ByteArray):ByteArray {
+			// take that incoming key and do hash(key + pad_2 + hash(key + pad_1 + sequence + length + record)
+			// note that data =  (sequence + type + length + record)
+
+		 	if (pad_1 == null) {
+		 		var pad_size:int = hash.getPadSize();
+				pad_1 = new ByteArray();
+				pad_2 = new ByteArray();
+			
+				for (var x:int = 0; x < pad_size; x++) {
+					pad_1.writeByte(0x36);
+					pad_2.writeByte(0x5c);
+				}
+		 	}
+		 	
+		 	// Do some preliminary checking on stuff
+		 	/* 
+		 	if (key.length > hash.getInputSize()) {
+		 		hashKey = hash.hash(key); 
+		 	} else {
+		 		hashKey = new ByteArray;
+		 		hashKey.writeBytes(key); 
+		 	}
+		 	
+		 	while (hashKey.length < hash.getInputSize() ) {
+		 		hashKey[hashKey.length] = 0;
+		 	} */
+		 	// Henri's conventions work just fine here..
+		 	
+		 	innerKey.length = 0;
+			outerKey.length = 0;
+		 	// trace("MAC Key: " + Hex.fromArray(key));
+			// trace("Key Length: " + key.length);
+			// trace("Pad_1 : " + Hex.fromArray(pad_1));
+		 	// inner hash calc
+		 	innerKey.writeBytes(key);
+	 		innerKey.writeBytes(pad_1);
+		 	innerKey.writeBytes(data);
+		 	// trace("MAC Inner Key: " + Hex.fromArray(innerKey));
+			
+		 	innerHash = hash.hash(innerKey);
+		 	// trace("MAC Inner Hash: " + Hex.fromArray(innerHash));
+			
+			// outer hash calc		 	
+		 	outerKey.writeBytes(key);
+		 	outerKey.writeBytes(pad_2);
+		 	outerKey.writeBytes(innerHash);
+			
+		 	// trace("MAC Outer Key: " + Hex.fromArray(outerKey));
+		 	outerHash = hash.hash(outerKey);
+		 	
+		 	
+		 	if (bits > 0 && bits < 8*outerHash.length) {
+		 		outerHash.length = bits/8;
+		 	}
+		 	
+		 	// trace("MAC for record: " + Hex.fromArray(outerHash));		 	
+		 	return outerHash;
+
+		}
+		
+		public function dispose():void {
+			hash = null;
+			bits = 0;
+		}
+		public function toString():String {
+			return "mac-"+(bits>0?bits+"-":"")+hash.toString();
+		}
+		
+	}
+}