Skip to content
Browse files

3.2 Beta 1 for AS3 on Flex 4.6

  • Loading branch information...
1 parent 2b5d770 commit a39e3286c68ccd20315df3f252d69e857456ce3b geremy cohen committed Aug 4, 2012
Showing with 11,479 additions and 0 deletions.
  1. 0 flash/{ → AS3_Flex_4.6}/MessageBox.as
  2. +704 −0 flash/AS3_Flex_4.6/PubNub/PubNub.as
  3. +39 −0 flash/AS3_Flex_4.6/PubNub/PubNubEvent.as
  4. +133 −0 flash/AS3_Flex_4.6/PubNub/PubnubCrypto.as
  5. +98 −0 flash/AS3_Flex_4.6/com/adobe/air/logging/FileTarget.as
  6. +127 −0 flash/AS3_Flex_4.6/com/adobe/crypto/HMAC.as
  7. +281 −0 flash/AS3_Flex_4.6/com/adobe/crypto/MD5.as
  8. +402 −0 flash/AS3_Flex_4.6/com/adobe/crypto/MD5Stream.as
  9. +271 −0 flash/AS3_Flex_4.6/com/adobe/crypto/SHA1.as
  10. +257 −0 flash/AS3_Flex_4.6/com/adobe/crypto/SHA224.as
  11. +261 −0 flash/AS3_Flex_4.6/com/adobe/crypto/SHA256.as
  12. +114 −0 flash/AS3_Flex_4.6/com/adobe/crypto/WSSEUsernameToken.as
  13. +63 −0 flash/AS3_Flex_4.6/com/adobe/errors/IllegalStateError.as
  14. +47 −0 flash/AS3_Flex_4.6/com/adobe/fileformats/vcard/Address.as
  15. +39 −0 flash/AS3_Flex_4.6/com/adobe/fileformats/vcard/Email.as
  16. +39 −0 flash/AS3_Flex_4.6/com/adobe/fileformats/vcard/Phone.as
  17. +54 −0 flash/AS3_Flex_4.6/com/adobe/fileformats/vcard/VCard.as
  18. +246 −0 flash/AS3_Flex_4.6/com/adobe/fileformats/vcard/VCardParser.as
  19. +39 −0 flash/AS3_Flex_4.6/com/adobe/images/BitString.as
  20. +648 −0 flash/AS3_Flex_4.6/com/adobe/images/JPGEncoder.as
  21. +141 −0 flash/AS3_Flex_4.6/com/adobe/images/PNGEncoder.as
  22. +55 −0 flash/AS3_Flex_4.6/com/adobe/net/DynamicURLLoader.as
  23. +76 −0 flash/AS3_Flex_4.6/com/adobe/net/IURIResolver.as
  24. +196 −0 flash/AS3_Flex_4.6/com/adobe/net/MimeTypeMap.as
  25. +2,466 −0 flash/AS3_Flex_4.6/com/adobe/net/URI.as
  26. +139 −0 flash/AS3_Flex_4.6/com/adobe/net/URIEncodingBitmap.as
  27. +198 −0 flash/AS3_Flex_4.6/com/adobe/net/proxies/RFC2817Socket.as
  28. +34 −0 flash/AS3_Flex_4.6/com/adobe/protocols/dict/Database.as
  29. +39 −0 flash/AS3_Flex_4.6/com/adobe/protocols/dict/Definition.as
  30. +328 −0 flash/AS3_Flex_4.6/com/adobe/protocols/dict/Dict.as
  31. +28 −0 flash/AS3_Flex_4.6/com/adobe/protocols/dict/DictionaryServer.as
  32. +34 −0 flash/AS3_Flex_4.6/com/adobe/protocols/dict/MatchStrategy.as
  33. +39 −0 flash/AS3_Flex_4.6/com/adobe/protocols/dict/Response.as
  34. +14 −0 flash/AS3_Flex_4.6/com/adobe/protocols/dict/events/ConnectedEvent.as
  35. +26 −0 flash/AS3_Flex_4.6/com/adobe/protocols/dict/events/DatabaseEvent.as
  36. +27 −0 flash/AS3_Flex_4.6/com/adobe/protocols/dict/events/DefinitionEvent.as
  37. +26 −0 flash/AS3_Flex_4.6/com/adobe/protocols/dict/events/DefinitionHeaderEvent.as
  38. +26 −0 flash/AS3_Flex_4.6/com/adobe/protocols/dict/events/DictionaryServerEvent.as
  39. +14 −0 flash/AS3_Flex_4.6/com/adobe/protocols/dict/events/DisconnectedEvent.as
  40. +37 −0 flash/AS3_Flex_4.6/com/adobe/protocols/dict/events/ErrorEvent.as
  41. +26 −0 flash/AS3_Flex_4.6/com/adobe/protocols/dict/events/MatchEvent.as
  42. +26 −0 flash/AS3_Flex_4.6/com/adobe/protocols/dict/events/MatchStrategiesEvent.as
  43. +14 −0 flash/AS3_Flex_4.6/com/adobe/protocols/dict/events/NoMatchEvent.as
  44. +25 −0 flash/AS3_Flex_4.6/com/adobe/protocols/dict/util/CompleteResponseEvent.as
  45. +49 −0 flash/AS3_Flex_4.6/com/adobe/protocols/dict/util/SocketHelper.as
  46. +85 −0 flash/AS3_Flex_4.6/com/adobe/serialization/json/JSON.as
  47. +221 −0 flash/AS3_Flex_4.6/com/adobe/serialization/json/JSONDecoder.as
  48. +299 −0 flash/AS3_Flex_4.6/com/adobe/serialization/json/JSONEncoder.as
  49. +87 −0 flash/AS3_Flex_4.6/com/adobe/serialization/json/JSONParseError.as
  50. +104 −0 flash/AS3_Flex_4.6/com/adobe/serialization/json/JSONToken.as
  51. +67 −0 flash/AS3_Flex_4.6/com/adobe/serialization/json/JSONTokenType.as
  52. +583 −0 flash/AS3_Flex_4.6/com/adobe/serialization/json/JSONTokenizer.as
  53. +187 −0 flash/AS3_Flex_4.6/com/adobe/utils/ArrayUtil.as
  54. +699 −0 flash/AS3_Flex_4.6/com/adobe/utils/DateUtil.as
  55. +87 −0 flash/AS3_Flex_4.6/com/adobe/utils/DictionaryUtil.as
  56. +99 −0 flash/AS3_Flex_4.6/com/adobe/utils/IntUtil.as
  57. +74 −0 flash/AS3_Flex_4.6/com/adobe/utils/NumberFormatter.as
  58. +270 −0 flash/AS3_Flex_4.6/com/adobe/utils/StringUtil.as
  59. +168 −0 flash/AS3_Flex_4.6/com/adobe/utils/XMLUtil.as
  60. +48 −0 flash/AS3_Flex_4.6/com/adobe/webapis/ServiceBase.as
  61. +108 −0 flash/AS3_Flex_4.6/com/adobe/webapis/URLLoaderBase.as
  62. +75 −0 flash/AS3_Flex_4.6/com/adobe/webapis/events/ServiceEvent.as
  63. +273 −0 flash/AS3_Flex_4.6/com/hurlant/crypto/Crypto.as
Sorry, we could not display the entire diff because it was too big.
View
0 flash/MessageBox.as → flash/AS3_Flex_4.6/MessageBox.as
File renamed without changes.
View
704 flash/AS3_Flex_4.6/PubNub/PubNub.as
@@ -0,0 +1,704 @@
+/**
+ * Author: WikiFlashed
+ * Released under: MIT or whatever license allowed by PubNub.
+ * Use of this file at your own risk. WikiFlashed holds no responsibility or liability to what you do with this.
+ */
+package PubNub
+{
+ import flash.utils.ByteArray;
+ import flash.events.Event;
+ import flash.events.EventDispatcher;
+ import flash.events.IOErrorEvent;
+ import flash.events.SecurityErrorEvent;
+ import flash.events.TimerEvent;
+ import flash.net.URLLoader;
+ import flash.net.URLRequest;
+ import flash.utils.Timer;
+ import flash.utils.SetIntervalTimer;
+ import com.adobe.crypto.MD5;
+ import com.adobe.crypto.HMAC;
+ import com.adobe.crypto.SHA256;
+ import com.adobe.webapis.URLLoaderBase;
+ import com.hurlant.util.der.Type;
+
+ import flash.external.ExternalInterface;
+
+
+
+
+ /**
+ * PubNub Static Class
+ *
+ * This should allow creating threads of listeners to each individual channel
+ *
+ * @author Fan
+ */
+ public class PubNub extends EventDispatcher
+ {
+ private static var INSTANCE:PubNub;
+ private static const ALPHA_CHAR_CODES:Array = [48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70];
+
+ public var initialized:Boolean = false;
+ public var origin:String = "http://pubsub.pubnub.com";
+ public var ssl:Boolean = false;
+ public var interval:Number = 10;
+
+ private var publish_key:String = "demo";
+ private var sub_key:String = "demo";
+ private var secret_key:String = "";
+ private var cipher_key:String = "";
+
+ private var subscriptions:Array;
+ private var start_time_token:Number = 0;
+ private var queue:Array;
+ private var session_uuid:String = "";
+
+ private var ori:Number = Math.floor(Math.random() * 9) + 1;
+ private function nextOrigin(origin:String):String
+ {
+ return origin.indexOf('pubsub') > 0
+ && origin.replace(
+ 'pubsub', 'ps' + (++ori < 10 ? ori : ori=1)
+ ) || origin;
+ }
+
+ public function getSessionUUID():String {
+ return this.session_uuid;
+ }
+
+ public function PubNub(enforcer:SingletonEnforcer)
+ {
+
+ }
+
+ public static function getInstance():PubNub
+ {
+ if (!INSTANCE)
+ {
+ INSTANCE = new PubNub(new SingletonEnforcer());
+
+ }
+ return INSTANCE;
+ }
+
+ /**
+ * ??
+ * Hash Array
+ * origin = https:// or http://
+ * @param config
+ */
+ public function init(config:Object):void
+ {
+ if(config.ssl && config.origin)
+ {
+ origin = "https://" + config.origin;
+ }
+ else if (config.origin)
+ {
+ origin = "http://" + config.origin;
+ }
+
+ if(config.publish_key)
+ {
+ publish_key = config.publish_key;
+ }
+
+ if(config.sub_key)
+ {
+ sub_key = config.sub_key;
+ }
+
+ if(config.secret_key)
+ {
+ secret_key = config.secret_key;
+ }
+
+ if(config.cipher_key)
+ {
+ this.cipher_key = config.cipher_key;
+ }
+
+ if (config.push_interval)
+ {
+ interval = config.push_interval;
+ }
+
+ queue = [];
+ subscriptions = [];
+ this.session_uuid = INSTANCE._uid();
+
+
+ function timeHandler( evt:Event ):void
+ {
+
+ var node:Object = queue["init"];
+ var loader:URLLoader = node.loader;
+ if ( evt.type == Event.COMPLETE )
+ {
+ try
+ {
+ var result:Object = JSON.parse(loader.data);
+ start_time_token = result[0];
+ } catch (e:*)
+ {
+ trace("[PubNub] Bad JSON Content");
+ }
+ initialized = true;
+ dispatchEvent(new PubNubEvent(PubNubEvent.INIT));
+ }
+ }
+ var url:String = origin + "/" + "time" + "/" + 0;
+
+ // Loads Time Token
+ _request( { url:url, channel:"system", handler:timeHandler, uid:"init" } );
+ }
+
+ /**
+ * Wrapper for function below
+ * @param args
+ */
+ public static function publish(args:Object):void
+ {
+
+ if (!INSTANCE.initialized)
+ {
+ throw("[PUBNUB] Not initialized yet");
+ }
+ INSTANCE._publish(args);
+ }
+
+ /**
+ * Broadcasts a message
+ * args: { callback:Function, channel:"String", message:"String|Array|Object" }
+ * ????
+ * @param args
+ */
+ public function _publish(args:Object):void
+ {
+ var onResult:Function = args.callback || dispatchEvent;
+
+ if (!args.channel || !args.message)
+ {
+ onResult(new PubNubEvent(PubNubEvent.PUBLISH, { channel:channel, result:[-1,"Channel Not Given and/or Message"], timeout:1000 } ));
+ return;
+ }
+ var channel:String = args.channel;
+ var message:Object = args.message;
+ var signature:String = "0";
+
+ if (secret_key)
+ {
+ // Create the signature for this message
+ var concat:String = publish_key + "/" + sub_key + "/" + secret_key + "/" + channel + "/" + message;
+
+ // Sign message using HmacSHA256
+ signature = HMAC.hash(secret_key, concat,SHA256);
+ }
+ if(this.cipher_key.length > 0)
+ {
+ var pubnubcrypto:PubnubCrypto = new PubnubCrypto();
+ message = pubnubcrypto.encrypt(this.cipher_key,message);
+ }
+
+ message = JSON.stringify(message);
+ var uid:String = _uid();
+
+ function publishHandler( evt:Event ):void
+ {
+ var node:Object = queue[uid];
+ var loader:URLLoader = node.loader;
+ if ( evt.type == Event.COMPLETE )
+ {
+ try
+ {
+ var result:Object = JSON.parse(loader.data);
+ onResult(new PubNubEvent(PubNubEvent.PUBLISH, { channel:channel, result:result, timeout:1 } ));
+ }
+ catch (e:*)
+ {
+ trace("[PubNub] Bad Data Content Ignored");
+ }
+ }
+ else
+ {
+ onResult(new PubNubEvent(PubNubEvent.PUBLISH, { channel:channel, result:[-1,"Connection Issue"], timeout:1000 } ));
+ }
+ node.loader.close();
+ node.loader = null;
+ node.handler = null;
+ }
+ var url:String = origin + "/" + "publish" + "/" + publish_key + "/" + sub_key + "/" + signature + "/" + _encode(channel) + "/" + 0 + "/" +_encode(message as String);
+ _request( { url:url, channel:channel, handler:publishHandler, uid:uid } );
+ }
+
+ /**
+ * Subscription Wrapper
+ * @param args
+ */
+ public static function subscribe(args:Object):void
+ {
+ if (!INSTANCE.initialized)
+ {
+ throw("[PUBNUB] Not initialized yet");
+ }
+ INSTANCE._subscribe(args);
+ }
+
+ /**
+ * Subscribes to a channel
+ * args: { callback:Function, channel:"String" }
+ * @param args
+ */
+ public function _subscribe(args:Object):void
+ {
+ var pubnubcrypto:PubnubCrypto = new PubnubCrypto();
+ var onResult:Function = args.callback || dispatchEvent;
+
+ if (!args.callback)
+ {
+ throw("[PubNub] Missing Callback Function");
+ return;
+ }
+
+ if (!args.channel)
+ {
+ onResult(new PubNubEvent(PubNubEvent.PUBLISH, { channel:channel, result:[-1,"Channel Not Given"], timeout:1000 } ));
+ return;
+ }
+
+ var channel:String = args.channel;
+ var time:Number = 0;
+ if (!subscriptions[channel])
+ {
+ subscriptions[channel] = {}
+ }
+
+ if (subscriptions[channel].connected)
+ {
+ onResult(new PubNubEvent(PubNubEvent.SUBSCRIBE, { channel:channel, result:[-1, "Already Connected"], timeout:1000 } ));
+ return;
+ }
+
+ subscriptions[channel].connected = true;
+
+ var url:String = origin + "/" + "subscribe" + "/" + sub_key + "/" + _encode(channel) + "/" + 0;
+
+ var uid:String = _uid();
+
+ function subHandler( evt:Event ):void
+ {
+ var node:Object = queue[uid];
+ var loader:URLLoader = node.loader;
+
+ if (!subscriptions[channel].connected)
+ {
+ // Stops the connection or any further listening loops
+ loader.close();
+ delete node.loader;
+ delete node.channel;
+ delete node.uid;
+ delete node.timetoken;
+ delete node.request;
+ delete queue[uid];
+ return;
+ }
+ var timer:Timer;
+
+ if ( evt.type == Event.COMPLETE )
+ {
+
+ try
+ {
+ var result:Object = JSON.parse(loader.data);
+ time = result[1];
+ if(result is Array)
+ {
+ if (time == 0)
+ {
+ onResult(new PubNubEvent(PubNubEvent.SUBSCRIBE_CONNECTED, { channel:channel }));
+ }
+ else
+ {
+ var messages:Array = result[0];
+ if(messages)
+ {
+ var pubnubcrypto:PubnubCrypto = new PubnubCrypto();
+ for (var i:int = 0; i < messages.length; i++)
+ {
+ if(cipher_key.length > 0)
+ {
+ onResult(new PubNubEvent(PubNubEvent.SUBSCRIBE, { channel:channel, result:[i+1,pubnubcrypto.decrypt(cipher_key,messages[i])],timeout:1 } ));
+
+ }
+ else
+ {
+ onResult(new PubNubEvent(PubNubEvent.SUBSCRIBE, { channel:channel, result:[i+1,JSON.stringify(messages[i])],timeout:1 } ));
+ }
+ }
+ }
+ }
+ time = result[1];
+ }
+ }
+ catch (e:Error)
+ {
+ trace("[PubNub] Bad Data Content Ignored");
+ }
+
+ node.tries = 0;
+ timer = new Timer(interval, 100);
+ timer.addEventListener(TimerEvent.TIMER_COMPLETE, function():void {
+ _request({ url:url, channel:channel, handler:subHandler, uid:uid, timetoken:time, operation:"subscribe_with_timetoken" });
+ });
+ timer.start();
+ }
+ else
+ {
+ // Possibly Network Issue, then try again after 1 second.
+ onResult(new PubNubEvent(PubNubEvent.SUBSCRIBE, { channel:channel, result:[ -1, "Connection Issue"], timeout:1000 } ));
+ node.tries++;
+
+ if (node.tries == 30)
+ {
+ // After 30 tries, seeming the network is now dead after 30 seconds.
+ // Dispatches error event
+ _unsubscribe({ channel:channel, uid:uid });
+ dispatchEvent(new PubNubEvent(PubNubEvent.ERROR, { channel:channel, message:"Channel Dropped" } ));
+ }
+ else
+ {
+ timer = new Timer(1000, 1);
+ timer.addEventListener(TimerEvent.TIMER_COMPLETE, function():void {
+ _request({ url:url, channel:channel, handler:subHandler, uid:uid, timetoken:time, operation:"subscribe_with_retry" });
+ });
+ timer.start();
+ }
+ }
+ }
+
+ _request( { url:url, channel:channel, handler:subHandler, uid:uid, timetoken:time, operation:"subscribe_get_timetoken" } );
+ }
+
+ public static function history(args:Object):void
+ {
+
+ if (!INSTANCE.initialized)
+ {
+ throw("[PUBNUB] Not initialized yet");
+ }
+ INSTANCE._history(args);
+ }
+ public function _history(args:Object):void
+ {
+ var onResult:Function = args.callback || dispatchEvent;
+
+ if (!args.channel || !args.limit)
+ {
+ onResult(new PubNubEvent(PubNubEvent.HISTORY, { channel:channel, result:[-1,"Channel Not Given and/or Limit"], timeout:1000 } ));
+ return;
+ }
+ var channel:String = args.channel;
+ var limit:String = args.limit;
+ var uid:String = _uid();
+ var url:String = origin + "/" + "history" + "/" + sub_key + "/" + _encode(channel) + "/" + 0 + "/" +_encode(limit);
+ function HistoryHandler( evt:Event ):void
+ {
+ var node:Object = queue[uid];
+ var loader:URLLoader = node.loader;
+ if ( evt.type == Event.COMPLETE )
+ {
+ try
+ {
+ var result:Object = JSON.parse(loader.data);
+ if(result)
+ {
+ var pubnubcrypto:PubnubCrypto = new PubnubCrypto();
+ for (var i:int = 0; i < result.length; i++)
+ {
+ if(cipher_key.length > 0)
+ {
+ onResult(new PubNubEvent(PubNubEvent.HISTORY, { channel:channel, result:[i+1,pubnubcrypto.decrypt(cipher_key,result[i])],timeout:1 } ));
+ }
+ else
+ {
+ onResult(new PubNubEvent(PubNubEvent.HISTORY, { channel:channel, result:[i+1,JSON.stringify(result[i])],timeout:1 } ));
+ }
+ }
+ }
+ }
+ catch (e:*)
+ {
+ trace("[PubNub history] Bad Data Content Ignored");
+ }
+ }
+ else
+ {
+ onResult(new PubNubEvent(PubNubEvent.HISTORY, { channel:channel, result:[-1,"Connection Issue"], timeout:1000 } ));
+ }
+ node.loader.close();
+ node.loader = null;
+ node.handler = null;
+ }
+ _request( { url:url, channel:channel, handler:HistoryHandler, uid:uid, operation:"history" } );
+ }
+ public static function time(args:Object):void
+ {
+ if (!INSTANCE.initialized)
+ {
+ throw("[PUBNUB] Not initialized yet");
+ }
+ INSTANCE._time(args);
+ }
+
+
+ public function here_now(args:Object):void
+ {
+ var uid:String = _uid();
+ var onResult:Function = args.callback || dispatchEvent;
+
+ if (!args.channel) {
+ return;
+ }
+
+ var url:String = origin + "/" + "v2/presence/sub_key/" + this.sub_key + "/channel/" + args.channel;
+ ExternalInterface.call( "console.log", ("here_now url is: " + url) );
+
+ function HereNowHandler( evt:Event ):void
+ {
+
+// var result:Object = JSON.parse(evt.target.data);
+// ExternalInterface.call( "console.log", (result) );
+
+// TODO: Why doesn't this work here?
+// var node:Object = queue[uid];
+// var loader:URLLoader = node.loader;
+// var result:Object = JSON.parse(evt.target);
+// ExternalInterface.call( "console.log", ("event receivied: " + result) );
+
+
+ if ( evt.type == Event.COMPLETE )
+ {
+ try
+ {
+ var result:Object = JSON.parse(evt.target.data);
+ if(result)
+ {
+ onResult(new PubNubEvent(PubNubEvent.HERE_NOW, {result:(result),timeout:1 } ));
+ }
+ }
+ catch (e:*)
+ {
+ trace("[PubNub here_now] Bad Data Content Ignored");
+ }
+ }
+ else
+ {
+ onResult(new PubNubEvent(PubNubEvent.HERE_NOW, {result:["here_now Connection Issue"], timeout:1000 } ));
+ }
+
+// node.loader.close();
+// node.loader = null;
+// node.handler = null;
+ }
+
+ ExternalInterface.call( "console.log", ("here now _request started.") );
+ _request( { url:url, handler:HereNowHandler } );
+ }
+
+ public function _time(args:Object):void
+ {
+ var onResult:Function = args.callback || dispatchEvent;
+ var uid:String = _uid();
+ var url:String = origin + "/" + "time" + "/" + 0 ;
+
+ function TimeHandler( evt:Event ):void
+ {
+ var node:Object = queue[uid];
+ var loader:URLLoader = node.loader;
+ if ( evt.type == Event.COMPLETE )
+ {
+ try
+ {
+ var result:Object = JSON.parse(loader.data);
+ if(result)
+ {
+ onResult(new PubNubEvent(PubNubEvent.TIME, {result:[JSON.stringify(result[0])],timeout:1 } ));
+ }
+ }
+ catch (e:*)
+ {
+ trace("[PubNub time] Bad Data Content Ignored");
+ }
+ }
+ else
+ {
+ onResult(new PubNubEvent(PubNubEvent.TIME, {result:["Connection Issue"], timeout:1000 } ));
+ }
+ node.loader.close();
+ node.loader = null;
+ node.handler = null;
+ }
+ _request( { url:url, handler:TimeHandler, uid:uid } );
+ }
+ /**
+ * UnSubscription Wrapper
+ * @param args
+ */
+ public static function unsubscribe(args:Object):void
+ {
+ if (!INSTANCE.initialized)
+ {
+ throw("[PUBNUB] Not initialized yet");
+ }
+ INSTANCE._unsubscribe(args);
+ }
+
+ /**
+ * UnSubscribes to a channel
+ * args: { callback:Function, channel:"String" }
+ * @param args
+ */
+ public function _unsubscribe(args:Object):void
+ {
+ var onResult:Function = args.callback || dispatchEvent;
+
+ if (!args.channel)
+ {
+ onResult(new PubNubEvent(PubNubEvent.UNSUBSCRIBE, { channel:channel, result:[-1,"Channel Not Given"], timeout:1000 } ));
+ return;
+ }
+ var channel:String = args.channel;
+
+ if (subscriptions[channel] && subscriptions[channel].connected)
+ {
+ subscriptions[channel].connected = false;
+ }
+
+ var event:PubNubEvent = new PubNubEvent(PubNubEvent.UNSUBSCRIBE, { channel:channel, result:[1, "Channel '" + channel + "' Unsubscribed"], timeout:1000 } );
+ onResult(event);
+ }
+
+ /**
+ * Helper Functions
+ * ==============================================
+ */
+
+ /**
+ * Makes a pub nub request
+ * @param args
+ */
+ public function _request(args:Object):void
+ {
+
+ var node:Object = queue[args.uid] || { tries:0 }
+ import flash.net.URLLoader;
+ import flash.net.URLRequestHeader;
+
+ var loader:URLLoader = node.loader;
+ var url:String = args.url;
+ if (args.timetoken != null)
+ {
+ url += "/" + args.timetoken;
+
+ if ( args.operation == "subscribe_with_timetoken") {
+ url += "?uuid=" + this.session_uuid;
+ }
+
+// ExternalInterface.call( "console.log", (url) );
+// ExternalInterface.call( "console.log", (this) );
+// ExternalInterface.call( "console.log", (args) );
+
+
+ }
+ if (!loader)
+ {
+
+ node.loader = loader = new URLLoader();
+ loader.addEventListener( Event.COMPLETE, args.handler );
+ loader.addEventListener( IOErrorEvent.IO_ERROR, args.handler );
+ loader.addEventListener( SecurityErrorEvent.SECURITY_ERROR, args.handler );
+ node.request = new URLRequest(url);
+ }
+ var Request:URLRequest = node.request;
+ Request.url = url;
+
+ loader.load(Request);
+
+ node.uid = args.uid;
+ node.channel = args.channel;
+ queue[args.uid] = node;
+ }
+
+ /**
+ * Encodes a string into some format
+ * Should be the escape function
+ * @param args
+ * @return
+ */
+ public function _encode(args:String):String
+ {
+ return escape(args);
+ }
+
+ /**
+ * Apply function to all elements in a table
+ * @param f
+ * @param array
+ * @return
+ */
+ public function _map(f:Function, array:Array):Array
+ {
+ return [];
+ }
+
+
+ public function _uid():String
+ {
+ var uid:Array = new Array(36);
+ var index:int = 0;
+
+ var i:int;
+ var j:int;
+
+ for (i = 0; i < 8; i++)
+ {
+ uid[index++] = ALPHA_CHAR_CODES[Math.floor(Math.random() * 16)];
+ }
+
+ for (i = 0; i < 3; i++)
+ {
+ uid[index++] = 45; // charCode for "-"
+
+ for (j = 0; j < 4; j++)
+ {
+ uid[index++] = ALPHA_CHAR_CODES[Math.floor(Math.random() * 16)];
+ }
+ }
+
+ uid[index++] = 45; // charCode for "-"
+
+ for (i = 0; i < 8; i++)
+ {
+ uid[index++] = ALPHA_CHAR_CODES[Math.floor(Math.random() * 16)];
+ }
+
+ for (j = 0; j < 4; j++)
+ {
+ uid[index++] = ALPHA_CHAR_CODES[Math.floor(Math.random() * 16)];
+ }
+
+ var time:Number = new Date().getTime();
+ // Note: time is the number of milliseconds since 1970,
+ // which is currently more than one trillion.
+ // We use the low 8 hex digits of this number in the UID.
+ // Just in case the system clock has been reset to
+ // Jan 1-4, 1970 (in which case this number could have only
+ // 1-7 hex digits), we pad on the left with 7 zeros
+ // before taking the low digits.
+
+ return String.fromCharCode.apply(null, uid);
+ }
+ }
+}
+
+internal class SingletonEnforcer{}
View
39 flash/AS3_Flex_4.6/PubNub/PubNubEvent.as
@@ -0,0 +1,39 @@
+package PubNub
+{
+ import flash.events.Event;
+
+ /**
+ * Pub Nub Event
+ * @author Fan Di
+ */
+ public class PubNubEvent extends Event
+ {
+ public static const SUBSCRIBE_CONNECTED:String = "SubscribeConnected";
+ public static const PUBLISH:String = "Publish";
+ public static const SUBSCRIBE:String = "Subscribe";
+ public static const PRESENCE:String = "Presence";
+ public static const HERE_NOW:String = "HereNow";
+ public static const HISTORY:String = "History";
+ public static const TIME:String="Time";
+ public static const UNSUBSCRIBE:String = "Unsubscribe";
+ public static const ERROR:String = "Error";
+ public static const INIT:String = "Init";
+ public var data:Object;
+
+ public function PubNubEvent(type:String, d:Object = null, bubbles:Boolean=false, cancelable:Boolean=false)
+ {
+ data = d;
+ super(type, bubbles, cancelable);
+ }
+
+ public override function clone():Event
+ {
+ return new PubNubEvent(type, data, bubbles, cancelable);
+ }
+
+ public override function toString():String
+ {
+ return formatToString("PubNubEvent", "type", "bubbles", "cancelable", "eventPhase");
+ }
+ }
+}
View
133 flash/AS3_Flex_4.6/PubNub/PubnubCrypto.as
@@ -0,0 +1,133 @@
+package PubNub
+{
+ import com.adobe.crypto.MD5;
+ import com.adobe.utils.IntUtil;
+ import com.hurlant.crypto.Crypto;
+ import com.hurlant.crypto.symmetric.AESKey;
+ import com.hurlant.crypto.symmetric.CBCMode;
+ import com.hurlant.crypto.symmetric.ICipher;
+ import com.hurlant.crypto.symmetric.IMode;
+ import com.hurlant.crypto.symmetric.IPad;
+ import com.hurlant.crypto.symmetric.IVMode;
+ import com.hurlant.crypto.symmetric.NullPad;
+ import com.hurlant.crypto.symmetric.PKCS5;
+ import com.hurlant.util.Base64;
+ import com.hurlant.util.Hex;
+
+ import flash.display.Sprite;
+ import flash.utils.ByteArray;
+
+ public class PubnubCrypto extends Sprite
+ {
+ private var type:String='aes-cbc';
+
+ //Basic encryption for string
+ public function encryptString(cipher_key:String, plainStr:String ):String
+ {
+ cipher_key = md5Key(cipher_key);
+ var key:ByteArray = Hex.toArray(cipher_key);
+ var data:ByteArray = Hex.toArray(Hex.fromString(plainStr));
+ var cbc:CBCMode = new CBCMode(new AESKey(key),new PKCS5());
+ cbc.IV = Hex.toArray(Hex.fromString("0123456789012345"));
+ cbc.encrypt(data);
+ return Base64.encodeByteArray(data);
+ }
+
+ //Basic decryption for string
+ public function decryptString(cipher_key:String, cipherStr:String):String
+ {
+ var data:ByteArray = Base64.decodeToByteArray(cipherStr);
+ cipher_key = md5Key(cipher_key);
+ var key:ByteArray = Hex.toArray(cipher_key);
+ var testkey:ByteArray = new ByteArray;
+ var cbc:CBCMode = new CBCMode(new AESKey(key), new PKCS5());
+ cbc.IV = Hex.toArray(Hex.fromString("0123456789012345"));
+ cbc.decrypt(data);
+ return Hex.toString(Hex.fromArray(data));
+ }
+
+ //Encryption for string/object/array
+ public function encrypt(cipher_key:String, plainObj:* ):*
+ {
+ if(typeof(plainObj) == "object")
+ {
+ if(plainObj.length == undefined) //plainObj is object
+ {
+ var cipherObj:Object = new Object();
+ for(var s:String in plainObj)
+ {
+ if(typeof(plainObj[s]) == "object")
+ {
+ cipherObj[s] = encrypt(cipher_key,plainObj[s]);
+ }
+ else
+ {
+ cipherObj[s] = encryptString(cipher_key,plainObj[s]);
+ }
+ }
+ return cipherObj;
+ }
+ else
+ {
+ //plainObj is array
+ var cipherArray:Array = new Array();
+ for(var i:int =0;i<plainObj.length;i++)
+ {
+ cipherArray[i] = encryptString(cipher_key,plainObj[i])
+ }
+ return cipherArray;
+ }
+ }
+ else if(typeof(plainObj) == "string")
+ {
+ return encryptString(cipher_key,plainObj);
+ }
+ }
+
+ //Decryption for string/object/array
+ public function decrypt(cipher_key:String, cipherObj:* ):*
+ {
+ if(typeof(cipherObj) == "object")
+ {
+ if(cipherObj.length == undefined) //cipherObj is object
+ {
+ var plainObj:Object = new Object();
+ for(var s:String in cipherObj)
+ {
+ if(typeof(cipherObj[s]) == "object")
+ {
+ plainObj[s] = decrypt(cipher_key,cipherObj[s]);
+ plainObj[s] = JSON.parse(plainObj[s].toString());
+ }
+ else
+ {
+ plainObj[s] = decryptString(cipher_key,cipherObj[s]);
+ }
+ }
+ return JSON.stringify(plainObj);
+ }
+ else
+ {
+ //cipherObj is array
+ var plainArray:Array = new Array();
+ for(var i:int =0;i<cipherObj.length;i++)
+ {
+ plainArray[i] = decryptString(cipher_key,cipherObj[i])
+ }
+ return JSON.stringify(plainArray);
+ }
+ }
+ else if(typeof(cipherObj) =="string")
+ {
+ return JSON.stringify(decryptString(cipher_key,cipherObj));
+ }
+ }
+
+ public function md5Key(s:String) :String
+ {
+ var ba:ByteArray = new ByteArray();
+ ba.writeUTFBytes(s);
+ return MD5.hashBinary(ba);
+ }
+ }
+}
View
98 flash/AS3_Flex_4.6/com/adobe/air/logging/FileTarget.as
@@ -0,0 +1,98 @@
+/*
+ Copyright (c) 2008, Adobe Systems Incorporated
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+
+ * Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ * Neither the name of Adobe Systems Incorporated nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+package com.adobe.air.logging
+{
+ import mx.logging.AbstractTarget;
+ import flash.filesystem.File;
+ import flash.filesystem.FileStream;
+ import flash.filesystem.FileMode;
+ import mx.logging.LogEvent;
+ import flash.system.System;
+ import flash.system.Capabilities;
+ import mx.logging.targets.LineFormattedTarget;
+ import mx.core.mx_internal;
+
+ use namespace mx_internal;
+
+ /**
+ * An Adobe AIR only class that provides a log target for the Flex logging
+ * framework, that logs files to a file on the user's system.
+ *
+ * This class will only work when running within Adobe AIR>
+ */
+ public class FileTarget extends LineFormattedTarget
+ {
+ private const DEFAULT_LOG_PATH:String = "app-storage:/application.log";
+
+ private var log:File;
+
+ public function FileTarget(logFile:File = null)
+ {
+ if(logFile != null)
+ {
+ log = logFile;
+ }
+ else
+ {
+ log = new File(DEFAULT_LOG_PATH);
+ }
+ }
+
+ public function get logURI():String
+ {
+ return log.url;
+ }
+
+ mx_internal override function internalLog(message:String):void
+ {
+ write(message);
+ }
+
+ private function write(msg:String):void
+ {
+ var fs:FileStream = new FileStream();
+ fs.open(log, FileMode.APPEND);
+ fs.writeUTFBytes(msg + "\n");
+ fs.close();
+ }
+
+ public function clear():void
+ {
+ var fs:FileStream = new FileStream();
+ fs.open(log, FileMode.WRITE);
+ fs.writeUTFBytes("");
+ fs.close();
+ }
+
+ }
+}
View
127 flash/AS3_Flex_4.6/com/adobe/crypto/HMAC.as
@@ -0,0 +1,127 @@
+/*
+ Copyright (c) 2008, Adobe Systems Incorporated
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+
+ * Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ * Neither the name of Adobe Systems Incorporated nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+package com.adobe.crypto {
+ import flash.utils.ByteArray;
+ import flash.utils.Endian;
+ import flash.utils.describeType;
+ /**
+ * Keyed-Hashing for Message Authentication
+ * Implementation based on algorithm description at
+ * http://www.faqs.org/rfcs/rfc2104.html
+ */
+ public class HMAC
+ {
+ /**
+ * Performs the HMAC hash algorithm using byte arrays.
+ *
+ * @param secret The secret key
+ * @param message The message to hash
+ * @param algorithm Hash object to use
+ * @return A string containing the hash value of message
+ * @langversion ActionScript 3.0
+ * @playerversion Flash 8.5
+ * @tiptext
+ */
+ public static function hash( secret:String, message:String, algorithm:Object = null ):String
+ {
+ var text:ByteArray = new ByteArray();
+ var k_secret:ByteArray = new ByteArray();
+
+ text.writeUTFBytes(message);
+ k_secret.writeUTFBytes(secret);
+
+ return hashBytes(k_secret, text, algorithm);
+ }
+
+ /**
+ * Performs the HMAC hash algorithm using string.
+ *
+ * @param secret The secret key
+ * @param message The message to hash
+ * @param algorithm Hash object to use
+ * @return A string containing the hash value of message
+ * @langversion ActionScript 3.0
+ * @playerversion Flash 8.5
+ * @tiptext
+ */
+ public static function hashBytes( secret:ByteArray, message:ByteArray, algorithm:Object = null ):String
+ {
+ var ipad:ByteArray = new ByteArray();
+ var opad:ByteArray = new ByteArray();
+ var endian:String = Endian.BIG_ENDIAN;
+
+ if(algorithm == null){
+ algorithm = MD5;
+ }
+
+ if ( describeType(algorithm).@name.toString() == "com.adobe.crypto::MD5" ) {
+ endian = Endian.LITTLE_ENDIAN;
+ }
+
+ if ( secret.length > 64 ) {
+ algorithm.hashBytes(secret);
+ secret = new ByteArray();
+ secret.endian = endian;
+
+ while ( algorithm.digest.bytesAvailable != 0 ) {
+ secret.writeInt(algorithm.digest.readInt());
+ }
+ }
+
+ secret.length = 64
+ secret.position = 0;
+ for ( var x:int = 0; x < 64; x++ ) {
+ var byte:int = secret.readByte();
+ ipad.writeByte(0x36 ^ byte);
+ opad.writeByte(0x5c ^ byte);
+ }
+
+ ipad.writeBytes(message);
+ algorithm.hashBytes(ipad);
+ var tmp:ByteArray = new ByteArray();
+ tmp.endian = endian;
+
+ while ( algorithm.digest.bytesAvailable != 0 ) {
+ tmp.writeInt(algorithm.digest.readInt());
+ }
+ tmp.position = 0;
+
+ while ( tmp.bytesAvailable != 0 ) {
+ opad.writeByte(tmp.readUnsignedByte());
+ }
+ return algorithm.hashBytes( opad );
+ }
+
+ }
+
+}
View
281 flash/AS3_Flex_4.6/com/adobe/crypto/MD5.as
@@ -0,0 +1,281 @@
+/*
+ Copyright (c) 2008, Adobe Systems Incorporated
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+
+ * Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ * Neither the name of Adobe Systems Incorporated nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+package com.adobe.crypto {
+
+ import com.adobe.utils.IntUtil;
+ import flash.utils.ByteArray;
+ /**
+ * The MD5 Message-Digest Algorithm
+ *
+ * Implementation based on algorithm description at
+ * http://www.faqs.org/rfcs/rfc1321.html
+ */
+ public class MD5 {
+
+ public static var digest:ByteArray;
+ /**
+ * Performs the MD5 hash algorithm on a string.
+ *
+ * @param s The string to hash
+ * @return A string containing the hash value of s
+ * @langversion ActionScript 3.0
+ * @playerversion Flash 8.5
+ * @tiptext
+ */
+
+ public static function hash(s:String) :String{
+ //Convert to byteArray and send through hashBinary function
+ // so as to only have complex code in one location
+ var ba:ByteArray = new ByteArray();
+ ba.writeUTFBytes(s);
+ return hashBinary(ba);
+ }
+
+ public static function hashBytes(s:ByteArray) :String{
+ return hashBinary(s);
+ }
+
+ /**
+ * Performs the MD5 hash algorithm on a ByteArray.
+ *
+ * @param s The string to hash
+ * @return A string containing the hash value of s
+ * @langversion ActionScript 3.0
+ * @playerversion Flash 8.5
+ * @tiptext
+ */
+ public static function hashBinary( s:ByteArray ):String {
+ // initialize the md buffers
+ var a:int = 1732584193;
+ var b:int = -271733879;
+ var c:int = -1732584194;
+ var d:int = 271733878;
+
+ // variables to store previous values
+ var aa:int;
+ var bb:int;
+ var cc:int;
+ var dd:int;
+
+ // create the blocks from the string and
+ // save the length as a local var to reduce
+ // lookup in the loop below
+ var x:Array = createBlocks( s );
+ var len:int = x.length;
+
+ // loop over all of the blocks
+ for ( var i:int = 0; i < len; i += 16) {
+ // save previous values
+ aa = a;
+ bb = b;
+ cc = c;
+ dd = d;
+
+ // Round 1
+ a = ff( a, b, c, d, x[int(i+ 0)], 7, -680876936 ); // 1
+ d = ff( d, a, b, c, x[int(i+ 1)], 12, -389564586 ); // 2
+ c = ff( c, d, a, b, x[int(i+ 2)], 17, 606105819 ); // 3
+ b = ff( b, c, d, a, x[int(i+ 3)], 22, -1044525330 ); // 4
+ a = ff( a, b, c, d, x[int(i+ 4)], 7, -176418897 ); // 5
+ d = ff( d, a, b, c, x[int(i+ 5)], 12, 1200080426 ); // 6
+ c = ff( c, d, a, b, x[int(i+ 6)], 17, -1473231341 ); // 7
+ b = ff( b, c, d, a, x[int(i+ 7)], 22, -45705983 ); // 8
+ a = ff( a, b, c, d, x[int(i+ 8)], 7, 1770035416 ); // 9
+ d = ff( d, a, b, c, x[int(i+ 9)], 12, -1958414417 ); // 10
+ c = ff( c, d, a, b, x[int(i+10)], 17, -42063 ); // 11
+ b = ff( b, c, d, a, x[int(i+11)], 22, -1990404162 ); // 12
+ a = ff( a, b, c, d, x[int(i+12)], 7, 1804603682 ); // 13
+ d = ff( d, a, b, c, x[int(i+13)], 12, -40341101 ); // 14
+ c = ff( c, d, a, b, x[int(i+14)], 17, -1502002290 ); // 15
+ b = ff( b, c, d, a, x[int(i+15)], 22, 1236535329 ); // 16
+
+ // Round 2
+ a = gg( a, b, c, d, x[int(i+ 1)], 5, -165796510 ); // 17
+ d = gg( d, a, b, c, x[int(i+ 6)], 9, -1069501632 ); // 18
+ c = gg( c, d, a, b, x[int(i+11)], 14, 643717713 ); // 19
+ b = gg( b, c, d, a, x[int(i+ 0)], 20, -373897302 ); // 20
+ a = gg( a, b, c, d, x[int(i+ 5)], 5, -701558691 ); // 21
+ d = gg( d, a, b, c, x[int(i+10)], 9, 38016083 ); // 22
+ c = gg( c, d, a, b, x[int(i+15)], 14, -660478335 ); // 23
+ b = gg( b, c, d, a, x[int(i+ 4)], 20, -405537848 ); // 24
+ a = gg( a, b, c, d, x[int(i+ 9)], 5, 568446438 ); // 25
+ d = gg( d, a, b, c, x[int(i+14)], 9, -1019803690 ); // 26
+ c = gg( c, d, a, b, x[int(i+ 3)], 14, -187363961 ); // 27
+ b = gg( b, c, d, a, x[int(i+ 8)], 20, 1163531501 ); // 28
+ a = gg( a, b, c, d, x[int(i+13)], 5, -1444681467 ); // 29
+ d = gg( d, a, b, c, x[int(i+ 2)], 9, -51403784 ); // 30
+ c = gg( c, d, a, b, x[int(i+ 7)], 14, 1735328473 ); // 31
+ b = gg( b, c, d, a, x[int(i+12)], 20, -1926607734 ); // 32
+
+ // Round 3
+ a = hh( a, b, c, d, x[int(i+ 5)], 4, -378558 ); // 33
+ d = hh( d, a, b, c, x[int(i+ 8)], 11, -2022574463 ); // 34
+ c = hh( c, d, a, b, x[int(i+11)], 16, 1839030562 ); // 35
+ b = hh( b, c, d, a, x[int(i+14)], 23, -35309556 ); // 36
+ a = hh( a, b, c, d, x[int(i+ 1)], 4, -1530992060 ); // 37
+ d = hh( d, a, b, c, x[int(i+ 4)], 11, 1272893353 ); // 38
+ c = hh( c, d, a, b, x[int(i+ 7)], 16, -155497632 ); // 39
+ b = hh( b, c, d, a, x[int(i+10)], 23, -1094730640 ); // 40
+ a = hh( a, b, c, d, x[int(i+13)], 4, 681279174 ); // 41
+ d = hh( d, a, b, c, x[int(i+ 0)], 11, -358537222 ); // 42
+ c = hh( c, d, a, b, x[int(i+ 3)], 16, -722521979 ); // 43
+ b = hh( b, c, d, a, x[int(i+ 6)], 23, 76029189 ); // 44
+ a = hh( a, b, c, d, x[int(i+ 9)], 4, -640364487 ); // 45
+ d = hh( d, a, b, c, x[int(i+12)], 11, -421815835 ); // 46
+ c = hh( c, d, a, b, x[int(i+15)], 16, 530742520 ); // 47
+ b = hh( b, c, d, a, x[int(i+ 2)], 23, -995338651 ); // 48
+
+ // Round 4
+ a = ii( a, b, c, d, x[int(i+ 0)], 6, -198630844 ); // 49
+ d = ii( d, a, b, c, x[int(i+ 7)], 10, 1126891415 ); // 50
+ c = ii( c, d, a, b, x[int(i+14)], 15, -1416354905 ); // 51
+ b = ii( b, c, d, a, x[int(i+ 5)], 21, -57434055 ); // 52
+ a = ii( a, b, c, d, x[int(i+12)], 6, 1700485571 ); // 53
+ d = ii( d, a, b, c, x[int(i+ 3)], 10, -1894986606 ); // 54
+ c = ii( c, d, a, b, x[int(i+10)], 15, -1051523 ); // 55
+ b = ii( b, c, d, a, x[int(i+ 1)], 21, -2054922799 ); // 56
+ a = ii( a, b, c, d, x[int(i+ 8)], 6, 1873313359 ); // 57
+ d = ii( d, a, b, c, x[int(i+15)], 10, -30611744 ); // 58
+ c = ii( c, d, a, b, x[int(i+ 6)], 15, -1560198380 ); // 59
+ b = ii( b, c, d, a, x[int(i+13)], 21, 1309151649 ); // 60
+ a = ii( a, b, c, d, x[int(i+ 4)], 6, -145523070 ); // 61
+ d = ii( d, a, b, c, x[int(i+11)], 10, -1120210379 ); // 62
+ c = ii( c, d, a, b, x[int(i+ 2)], 15, 718787259 ); // 63
+ b = ii( b, c, d, a, x[int(i+ 9)], 21, -343485551 ); // 64
+
+ a += aa;
+ b += bb;
+ c += cc;
+ d += dd;
+ }
+ digest = new ByteArray()
+ digest.writeInt(a);
+ digest.writeInt(b);
+ digest.writeInt(c);
+ digest.writeInt(d);
+ digest.position = 0;
+ // Finish up by concatening the buffers with their hex output
+ return IntUtil.toHex( a ) + IntUtil.toHex( b ) + IntUtil.toHex( c ) + IntUtil.toHex( d );
+ }
+
+ /**
+ * Auxiliary function f as defined in RFC
+ */
+ private static function f( x:int, y:int, z:int ):int {
+ return ( x & y ) | ( (~x) & z );
+ }
+
+ /**
+ * Auxiliary function g as defined in RFC
+ */
+ private static function g( x:int, y:int, z:int ):int {
+ return ( x & z ) | ( y & (~z) );
+ }
+
+ /**
+ * Auxiliary function h as defined in RFC
+ */
+ private static function h( x:int, y:int, z:int ):int {
+ return x ^ y ^ z;
+ }
+
+ /**
+ * Auxiliary function i as defined in RFC
+ */
+ private static function i( x:int, y:int, z:int ):int {
+ return y ^ ( x | (~z) );
+ }
+
+ /**
+ * A generic transformation function. The logic of ff, gg, hh, and
+ * ii are all the same, minus the function used, so pull that logic
+ * out and simplify the method bodies for the transoformation functions.
+ */
+ private static function transform( func:Function, a:int, b:int, c:int, d:int, x:int, s:int, t:int):int {
+ var tmp:int = a + int( func( b, c, d ) ) + x + t;
+ return IntUtil.rol( tmp, s ) + b;
+ }
+
+ /**
+ * ff transformation function
+ */
+ private static function ff ( a:int, b:int, c:int, d:int, x:int, s:int, t:int ):int {
+ return transform( f, a, b, c, d, x, s, t );
+ }
+
+ /**
+ * gg transformation function
+ */
+ private static function gg ( a:int, b:int, c:int, d:int, x:int, s:int, t:int ):int {
+ return transform( g, a, b, c, d, x, s, t );
+ }
+
+ /**
+ * hh transformation function
+ */
+ private static function hh ( a:int, b:int, c:int, d:int, x:int, s:int, t:int ):int {
+ return transform( h, a, b, c, d, x, s, t );
+ }
+
+ /**
+ * ii transformation function
+ */
+ private static function ii ( a:int, b:int, c:int, d:int, x:int, s:int, t:int ):int {
+ return transform( i, a, b, c, d, x, s, t );
+ }
+
+ /**
+ * Converts a string to a sequence of 16-word blocks
+ * that we'll do the processing on. Appends padding
+ * and length in the process.
+ *
+ * @param s The string to split into blocks
+ * @return An array containing the blocks that s was
+ * split into.
+ */
+ private static function createBlocks( s:ByteArray ):Array {
+ var blocks:Array = new Array();
+ var len:int = s.length * 8;
+ var mask:int = 0xFF; // ignore hi byte of characters > 0xFF
+ for( var i:int = 0; i < len; i += 8 ) {
+ blocks[ int(i >> 5) ] |= ( s[ i / 8 ] & mask ) << ( i % 32 );
+ }
+
+ // append padding and length
+ blocks[ int(len >> 5) ] |= 0x80 << ( len % 32 );
+ blocks[ int(( ( ( len + 64 ) >>> 9 ) << 4 ) + 14) ] = len;
+ return blocks;
+ }
+
+ }
+}
View
402 flash/AS3_Flex_4.6/com/adobe/crypto/MD5Stream.as
@@ -0,0 +1,402 @@
+/*
+ Copyright (c) 2008, Adobe Systems Incorporated
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+
+ * Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ * Neither the name of Adobe Systems Incorporated nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+package com.adobe.crypto
+{
+ import com.adobe.utils.IntUtil;
+ import flash.utils.ByteArray;
+
+ /**
+ * Perform MD5 hash of an input stream in chunks. This class is
+ * based on com.adobe.crypto.MD5 and can process data in
+ * chunks. Both block creation and hash computation are done
+ * together for whatever input is available so that the memory
+ * overhead at a time is always fixed. Memory usage is governed by
+ * two parameters: one is the amount of data passed in to update()
+ * and the other is memoryBlockSize. The latter comes into play
+ * only when the memory window exceeds the pre allocated memory
+ * window of flash player. Usage: create an instance, call
+ * update(data) repeatedly for all chunks and finally complete()
+ * which will return the md5 hash.
+ */
+ public class MD5Stream
+ {
+ private static var mask:int = 0xFF;
+
+ private var arr:Array = [];
+
+ /* running count of length */
+ private var arrLen:int;
+
+ // initialize the md buffers
+ private var a:int = 1732584193;
+ private var b:int = -271733879;
+ private var c:int = -1732584194;
+ private var d:int = 271733878;
+
+ // variables to store previous values
+ private var aa:int;
+ private var bb:int;
+ private var cc:int;
+ private var dd:int;
+
+ /* index for data read */
+ private var arrIndexLen:int = 0;
+ /* index for hash computation */
+ private var arrProcessIndex:int = 0;
+ /* index for removing stale arr values */
+ private var cleanIndex:int = 0;
+
+ /**
+ * Change this value from the default (16384) in the range of
+ * MBs to actually affect GC as GC allocates in pools of
+ * memory */
+ public var memoryBlockSize:int = 16384;
+
+
+ public function MD5Stream()
+ {
+
+ }
+
+
+ /**
+ * Pass in chunks of the input data with update(), call
+ * complete() with an optional chunk which will return the
+ * final hash. Equivalent to the way
+ * java.security.MessageDigest works.
+ *
+ * @param input The optional bytearray chunk which is the final part of the input
+ * @return A string containing the hash value
+ * @langversion ActionScript 3.0
+ * @playerversion Flash 8.5
+ * @tiptext
+ */
+ public function complete(input:ByteArray=null):String
+ {
+ if ( arr.length == 0 )
+ {
+ if ( input == null )
+ {
+ throw new Error("null input to complete without prior call to update. At least an empty bytearray must be passed.");
+ }
+ }
+
+ if ( input != null )
+ {
+ readIntoArray(input);
+ }
+
+ //pad, append length
+ padArray(arrLen);
+
+ hashRemainingChunks(false);
+
+ var res:String = IntUtil.toHex( a ) + IntUtil.toHex( b ) +
+ IntUtil.toHex( c ) + IntUtil.toHex( d );
+ resetFields();
+
+ return res;
+ }
+
+ /**
+ * Pass in chunks of the input data with update(), call
+ * complete() with an optional chunk which will return the
+ * final hash. Equivalent to the way
+ * java.security.MessageDigest works.
+ *
+ * @param input The bytearray chunk to perform the hash on
+ * @langversion ActionScript 3.0
+ * @playerversion Flash 8.5
+ * @tiptext
+ */
+ public function update(input:ByteArray):void
+ {
+ readIntoArray(input);
+ hashRemainingChunks();
+ }
+
+ /**
+ * Re-initialize this instance for use to perform hashing on
+ * another input stream. This is called automatically by
+ * complete().
+ *
+ * @langversion ActionScript 3.0
+ * @playerversion Flash 8.5
+ * @tiptext
+ */
+ public function resetFields():void
+ {
+ //truncate array
+ arr.length = 0;
+ arrLen = 0;
+
+ // initialize the md buffers
+ a = 1732584193;
+ b = -271733879;
+ c = -1732584194;
+ d = 271733878;
+
+ // variables to store previous values
+ aa = 0;
+ bb = 0;
+ cc = 0;
+ dd = 0;
+
+ arrIndexLen = 0;
+ arrProcessIndex = 0;
+ cleanIndex = 0;
+ }
+
+ /** read into arr and free up used blocks of arr */
+ private function readIntoArray(input:ByteArray):void
+ {
+ var closestChunkLen:int = input.length * 8;
+ arrLen += closestChunkLen;
+
+ /* clean up memory. if there are entries in the array that
+ * are already processed and the amount is greater than
+ * memoryBlockSize, create a new array, copy the last
+ * block into it and let the old one get picked up by
+ * GC. */
+ if ( arrProcessIndex - cleanIndex > memoryBlockSize )
+ {
+ var newarr:Array= new Array();
+
+ /* AS Arrays in sparse arrays. arr[2002] can exist
+ * without values for arr[0] - arr[2001] */
+ for ( var j:int = arrProcessIndex; j < arr.length; j++ )
+ {
+ newarr[j] = arr[j];
+ }
+
+ cleanIndex = arrProcessIndex;
+ arr = null;
+ arr = newarr;
+ }
+
+ for ( var k:int = 0; k < closestChunkLen; k+=8 )
+ {
+ //discard high bytes (convert to uint)
+ arr[ int(arrIndexLen >> 5) ] |= ( input[ k / 8 ] & mask ) << ( arrIndexLen % 32 );
+ arrIndexLen += 8;
+ }
+
+
+ }
+
+ private function hashRemainingChunks(bUpdate:Boolean=true):void
+ {
+ var len:int = arr.length;
+
+ /* leave a 16 word block untouched if we are called from
+ * update. This is because, padArray() can modify the last
+ * block and this modification has to happen before we
+ * compute the hash. */
+ if ( bUpdate )
+ {
+ len -= 16;
+ }
+
+ /* don't do anything if don't have a 16 word block. */
+ if ( arrProcessIndex >= len || len - arrProcessIndex < 15 )
+ {
+ return;
+ }
+
+
+ for ( var i:int = arrProcessIndex; i < len ; i += 16, arrProcessIndex += 16)
+ {
+ // save previous values
+ aa = a;
+ bb = b;
+ cc = c;
+ dd = d;
+
+ // Round 1
+ a = ff( a, b, c, d, arr[int(i+ 0)], 7, -680876936 ); // 1
+ d = ff( d, a, b, c, arr[int(i+ 1)], 12, -389564586 ); // 2
+ c = ff( c, d, a, b, arr[int(i+ 2)], 17, 606105819 ); // 3
+ b = ff( b, c, d, a, arr[int(i+ 3)], 22, -1044525330 ); // 4
+ a = ff( a, b, c, d, arr[int(i+ 4)], 7, -176418897 ); // 5
+ d = ff( d, a, b, c, arr[int(i+ 5)], 12, 1200080426 ); // 6
+ c = ff( c, d, a, b, arr[int(i+ 6)], 17, -1473231341 ); // 7
+ b = ff( b, c, d, a, arr[int(i+ 7)], 22, -45705983 ); // 8
+ a = ff( a, b, c, d, arr[int(i+ 8)], 7, 1770035416 ); // 9
+ d = ff( d, a, b, c, arr[int(i+ 9)], 12, -1958414417 ); // 10
+ c = ff( c, d, a, b, arr[int(i+10)], 17, -42063 ); // 11
+ b = ff( b, c, d, a, arr[int(i+11)], 22, -1990404162 ); // 12
+ a = ff( a, b, c, d, arr[int(i+12)], 7, 1804603682 ); // 13
+ d = ff( d, a, b, c, arr[int(i+13)], 12, -40341101 ); // 14
+ c = ff( c, d, a, b, arr[int(i+14)], 17, -1502002290 ); // 15
+ b = ff( b, c, d, a, arr[int(i+15)], 22, 1236535329 ); // 16
+
+ // Round 2
+ a = gg( a, b, c, d, arr[int(i+ 1)], 5, -165796510 ); // 17
+ d = gg( d, a, b, c, arr[int(i+ 6)], 9, -1069501632 ); // 18
+ c = gg( c, d, a, b, arr[int(i+11)], 14, 643717713 ); // 19
+ b = gg( b, c, d, a, arr[int(i+ 0)], 20, -373897302 ); // 20
+ a = gg( a, b, c, d, arr[int(i+ 5)], 5, -701558691 ); // 21
+ d = gg( d, a, b, c, arr[int(i+10)], 9, 38016083 ); // 22
+ c = gg( c, d, a, b, arr[int(i+15)], 14, -660478335 ); // 23
+ b = gg( b, c, d, a, arr[int(i+ 4)], 20, -405537848 ); // 24
+ a = gg( a, b, c, d, arr[int(i+ 9)], 5, 568446438 ); // 25
+ d = gg( d, a, b, c, arr[int(i+14)], 9, -1019803690 ); // 26
+ c = gg( c, d, a, b, arr[int(i+ 3)], 14, -187363961 ); // 27
+ b = gg( b, c, d, a, arr[int(i+ 8)], 20, 1163531501 ); // 28
+ a = gg( a, b, c, d, arr[int(i+13)], 5, -1444681467 ); // 29
+ d = gg( d, a, b, c, arr[int(i+ 2)], 9, -51403784 ); // 30
+ c = gg( c, d, a, b, arr[int(i+ 7)], 14, 1735328473 ); // 31
+ b = gg( b, c, d, a, arr[int(i+12)], 20, -1926607734 ); // 32
+
+ // Round 3
+ a = hh( a, b, c, d, arr[int(i+ 5)], 4, -378558 ); // 33
+ d = hh( d, a, b, c, arr[int(i+ 8)], 11, -2022574463 ); // 34
+ c = hh( c, d, a, b, arr[int(i+11)], 16, 1839030562 ); // 35
+ b = hh( b, c, d, a, arr[int(i+14)], 23, -35309556 ); // 36
+ a = hh( a, b, c, d, arr[int(i+ 1)], 4, -1530992060 ); // 37
+ d = hh( d, a, b, c, arr[int(i+ 4)], 11, 1272893353 ); // 38
+ c = hh( c, d, a, b, arr[int(i+ 7)], 16, -155497632 ); // 39
+ b = hh( b, c, d, a, arr[int(i+10)], 23, -1094730640 ); // 40
+ a = hh( a, b, c, d, arr[int(i+13)], 4, 681279174 ); // 41
+ d = hh( d, a, b, c, arr[int(i+ 0)], 11, -358537222 ); // 42
+ c = hh( c, d, a, b, arr[int(i+ 3)], 16, -722521979 ); // 43
+ b = hh( b, c, d, a, arr[int(i+ 6)], 23, 76029189 ); // 44
+ a = hh( a, b, c, d, arr[int(i+ 9)], 4, -640364487 ); // 45
+ d = hh( d, a, b, c, arr[int(i+12)], 11, -421815835 ); // 46
+ c = hh( c, d, a, b, arr[int(i+15)], 16, 530742520 ); // 47
+ b = hh( b, c, d, a, arr[int(i+ 2)], 23, -995338651 ); // 48
+
+ // Round 4
+ a = ii( a, b, c, d, arr[int(i+ 0)], 6, -198630844 ); // 49
+ d = ii( d, a, b, c, arr[int(i+ 7)], 10, 1126891415 ); // 50
+ c = ii( c, d, a, b, arr[int(i+14)], 15, -1416354905 ); // 51
+ b = ii( b, c, d, a, arr[int(i+ 5)], 21, -57434055 ); // 52
+ a = ii( a, b, c, d, arr[int(i+12)], 6, 1700485571 ); // 53
+ d = ii( d, a, b, c, arr[int(i+ 3)], 10, -1894986606 ); // 54
+ c = ii( c, d, a, b, arr[int(i+10)], 15, -1051523 ); // 55
+ b = ii( b, c, d, a, arr[int(i+ 1)], 21, -2054922799 ); // 56
+ a = ii( a, b, c, d, arr[int(i+ 8)], 6, 1873313359 ); // 57
+ d = ii( d, a, b, c, arr[int(i+15)], 10, -30611744 ); // 58
+ c = ii( c, d, a, b, arr[int(i+ 6)], 15, -1560198380 ); // 59
+ b = ii( b, c, d, a, arr[int(i+13)], 21, 1309151649 ); // 60
+ a = ii( a, b, c, d, arr[int(i+ 4)], 6, -145523070 ); // 61
+ d = ii( d, a, b, c, arr[int(i+11)], 10, -1120210379 ); // 62
+ c = ii( c, d, a, b, arr[int(i+ 2)], 15, 718787259 ); // 63
+ b = ii( b, c, d, a, arr[int(i+ 9)], 21, -343485551 ); // 64
+
+ a += aa;
+ b += bb;
+ c += cc;
+ d += dd;
+
+ }
+
+ }
+
+ private function padArray(len:int):void
+ {
+ arr[ int(len >> 5) ] |= 0x80 << ( len % 32 );
+ arr[ int(( ( ( len + 64 ) >>> 9 ) << 4 ) + 14) ] = len;
+ arrLen = arr.length;
+ }
+
+ /* Code below same as com.adobe.crypto.MD5 */
+
+ /**
+ * Auxiliary function f as defined in RFC
+ */
+ private static function f( x:int, y:int, z:int ):int {
+ return ( x & y ) | ( (~x) & z );
+ }
+
+ /**
+ * Auxiliary function g as defined in RFC
+ */
+ private static function g( x:int, y:int, z:int ):int {
+ return ( x & z ) | ( y & (~z) );
+ }
+
+ /**
+ * Auxiliary function h as defined in RFC
+ */
+ private static function h( x:int, y:int, z:int ):int {
+ return x ^ y ^ z;
+ }
+
+ /**
+ * Auxiliary function i as defined in RFC
+ */
+ private static function i( x:int, y:int, z:int ):int {
+ return y ^ ( x | (~z) );
+ }
+
+ /**
+ * A generic transformation function. The logic of ff, gg, hh, and
+ * ii are all the same, minus the function used, so pull that logic
+ * out and simplify the method bodies for the transoformation functions.
+ */
+ private static function transform( func:Function, a:int, b:int, c:int, d:int, x:int, s:int, t:int):int {
+ var tmp:int = a + int( func( b, c, d ) ) + x + t;
+ return IntUtil.rol( tmp, s ) + b;
+ }
+
+ /**
+ * ff transformation function
+ */
+ private static function ff ( a:int, b:int, c:int, d:int, x:int, s:int, t:int ):int {
+ return transform( f, a, b, c, d, x, s, t );
+ }
+
+ /**
+ * gg transformation function
+ */
+ private static function gg ( a:int, b:int, c:int, d:int, x:int, s:int, t:int ):int {
+ return transform( g, a, b, c, d, x, s, t );
+ }
+
+ /**
+ * hh transformation function
+ */
+ private static function hh ( a:int, b:int, c:int, d:int, x:int, s:int, t:int ):int {
+ return transform( h, a, b, c, d, x, s, t );
+ }
+
+ /**
+ * ii transformation function
+ */
+ private static function ii ( a:int, b:int, c:int, d:int, x:int, s:int, t:int ):int {
+ return transform( i, a, b, c, d, x, s, t );
+ }
+
+ }
+}
View
271 flash/AS3_Flex_4.6/com/adobe/crypto/SHA1.as
@@ -0,0 +1,271 @@
+/*
+ Copyright (c) 2008, Adobe Systems Incorporated
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+
+ * Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ * Neither the name of Adobe Systems Incorporated nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+package com.adobe.crypto
+{
+ import com.adobe.utils.IntUtil;
+ import flash.utils.ByteArray;
+ import mx.utils.Base64Encoder;
+
+ /**
+ * US Secure Hash Algorithm 1 (SHA1)
+ *
+ * Implementation based on algorithm description at
+ * http://www.faqs.org/rfcs/rfc3174.html
+ */
+ public class SHA1
+ {
+ public static var digest:ByteArray;
+
+ /**
+ * Performs the SHA1 hash algorithm on a string.
+ *
+ * @param s The string to hash
+ * @return A string containing the hash value of s
+ * @langversion ActionScript 3.0
+ * @playerversion 9.0
+ * @tiptext
+ */
+ public static function hash( s:String ):String
+ {
+ var blocks:Array = createBlocksFromString( s );
+ var byteArray:ByteArray = hashBlocks( blocks );
+
+ return IntUtil.toHex( byteArray.readInt(), true )
+ + IntUtil.toHex( byteArray.readInt(), true )
+ + IntUtil.toHex( byteArray.readInt(), true )
+ + IntUtil.toHex( byteArray.readInt(), true )
+ + IntUtil.toHex( byteArray.readInt(), true );
+ }
+
+ /**
+ * Performs the SHA1 hash algorithm on a ByteArray.
+ *
+ * @param data The ByteArray data to hash
+ * @return A string containing the hash value of data
+ * @langversion ActionScript 3.0
+ * @playerversion 9.0
+ */
+ public static function hashBytes( data:ByteArray ):String
+ {
+ var blocks:Array = SHA1.createBlocksFromByteArray( data );
+ var byteArray:ByteArray = hashBlocks(blocks);
+
+ return IntUtil.toHex( byteArray.readInt(), true )
+ + IntUtil.toHex( byteArray.readInt(), true )
+ + IntUtil.toHex( byteArray.readInt(), true )
+ + IntUtil.toHex( byteArray.readInt(), true )
+ + IntUtil.toHex( byteArray.readInt(), true );
+ }
+
+ /**
+ * Performs the SHA1 hash algorithm on a string, then does
+ * Base64 encoding on the result.
+ *
+ * @param s The string to hash
+ * @return The base64 encoded hash value of s
+ * @langversion ActionScript 3.0
+ * @playerversion 9.0
+ * @tiptext
+ */
+ public static function hashToBase64( s:String ):String
+ {
+ var blocks:Array = SHA1.createBlocksFromString( s );
+ var byteArray:ByteArray = hashBlocks(blocks);
+
+ // ByteArray.toString() returns the contents as a UTF-8 string,
+ // which we can't use because certain byte sequences might trigger
+ // a UTF-8 conversion. Instead, we convert the bytes to characters
+ // one by one.
+ var charsInByteArray:String = "";
+ byteArray.position = 0;
+ for (var j:int = 0; j < byteArray.length; j++)
+ {
+ var byte:uint = byteArray.readUnsignedByte();
+ charsInByteArray += String.fromCharCode(byte);
+ }
+
+ var encoder:Base64Encoder = new Base64Encoder();
+ encoder.encode(charsInByteArray);
+ return encoder.flush();
+ }
+
+ private static function hashBlocks( blocks:Array ):ByteArray
+ {
+ // initialize the h's
+ var h0:int = 0x67452301;
+ var h1:int = 0xefcdab89;
+ var h2:int = 0x98badcfe;
+ var h3:int = 0x10325476;
+ var h4:int = 0xc3d2e1f0;
+
+ var len:int = blocks.length;
+ var w:Array = new Array( 80 );
+
+ // loop over all of the blocks
+ for ( var i:int = 0; i < len; i += 16 ) {
+
+ // 6.1.c
+ var a:int = h0;
+ var b:int = h1;
+ var c:int = h2;
+ var d:int = h3;
+ var e:int = h4;
+
+ // 80 steps to process each block
+ // TODO: unroll for faster execution, or 4 loops of
+ // 20 each to avoid the k and f function calls
+ for ( var t:int = 0; t < 80; t++ ) {
+
+ if ( t < 16 ) {
+ // 6.1.a
+ w[ t ] = blocks[ i + t ];
+ } else {
+ // 6.1.b
+ w[ t ] = IntUtil.rol( w[ t - 3 ] ^ w[ t - 8 ] ^ w[ t - 14 ] ^ w[ t - 16 ], 1 );
+ }
+
+ // 6.1.d
+ var temp:int = IntUtil.rol( a, 5 ) + f( t, b, c, d ) + e + int( w[ t ] ) + k( t );
+
+ e = d;
+ d = c;
+ c = IntUtil.rol( b, 30 );
+ b = a;
+ a = temp;
+ }
+
+ // 6.1.e
+ h0 += a;
+ h1 += b;
+ h2 += c;
+ h3 += d;
+ h4 += e;
+ }
+
+ var byteArray:ByteArray = new ByteArray();
+ byteArray.writeInt(h0);
+ byteArray.writeInt(h1);
+ byteArray.writeInt(h2);
+ byteArray.writeInt(h3);
+ byteArray.writeInt(h4);
+ byteArray.position = 0;
+
+ digest = new ByteArray();
+ digest.writeBytes(byteArray);
+ digest.position = 0;
+ return byteArray;
+ }
+
+ /**
+ * Performs the logical function based on t
+ */
+ private static function f( t:int, b:int, c:int, d:int ):int {
+ if ( t < 20 ) {
+ return ( b & c ) | ( ~b & d );
+ } else if ( t < 40 ) {
+ return b ^ c ^ d;
+ } else if ( t < 60 ) {
+ return ( b & c ) | ( b & d ) | ( c & d );
+ }
+ return b ^ c ^ d;
+ }
+
+ /**
+ * Determines the constant value based on t
+ */
+ private static function k( t:int ):int {
+ if ( t < 20 ) {
+ return 0x5a827999;
+ } else if ( t < 40 ) {
+ return 0x6ed9eba1;
+ } else if ( t < 60 ) {
+ return 0x8f1bbcdc;
+ }
+ return 0xca62c1d6;
+ }
+
+ /**
+ * Converts a ByteArray to a sequence of 16-word blocks
+ * that we'll do the processing on. Appends padding
+ * and length in the process.
+ *
+ * @param data The data to split into blocks
+ * @return An array containing the blocks into which data was split
+ */
+ private static function createBlocksFromByteArray( data:ByteArray ):Array
+ {
+ var oldPosition:int = data.position;
+ data.position = 0;
+
+ var blocks:Array = new Array();
+ var len:int = data.length * 8;
+ var mask:int = 0xFF; // ignore hi byte of characters > 0xFF
+ for( var i:int = 0; i < len; i += 8 )
+ {
+ blocks[ i >> 5 ] |= ( data.readByte() & mask ) << ( 24 - i % 32 );
+ }
+
+ // append padding and length
+ blocks[ len >> 5 ] |= 0x80 << ( 24 - len % 32 );
+ blocks[ ( ( ( len + 64 ) >> 9 ) << 4 ) + 15 ] = len;
+
+ data.position = oldPosition;
+
+ return blocks;
+ }
+
+ /**
+ * Converts a string to a sequence of 16-word blocks
+ * that we'll do the processing on. Appends padding
+ * and length in the process.
+ *
+ * @param s The string to split into blocks
+ * @return An array containing the blocks that s was split into.
+ */
+ private static function createBlocksFromString( s:String ):Array
+ {
+ var blocks:Array = new Array();
+ var len:int = s.length * 8;
+ var mask:int = 0xFF; // ignore hi byte of characters > 0xFF
+ for( var i:int = 0; i < len; i += 8 ) {
+ blocks[ i >> 5 ] |= ( s.charCodeAt( i / 8 ) & mask ) << ( 24 - i % 32 );
+ }
+
+ // append padding and length
+ blocks[ len >> 5 ] |= 0x80 << ( 24 - len % 32 );
+ blocks[ ( ( ( len + 64 ) >> 9 ) << 4 ) + 15 ] = len;
+ return blocks;
+ }
+
+ }
+}
View
257 flash/AS3_Flex_4.6/com/adobe/crypto/SHA224.as
@@ -0,0 +1,257 @@
+/*
+ Copyright (c) 2008, Adobe Systems Incorporated
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+
+ * Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright