initial import of webcam actionscriptz

1 files changed, 256 insertions, 0 deletions

diff --git a/webcam/com/adobe/crypto/MD5.as b/webcam/com/adobe/crypto/MD5.as
new file mode 100644
index 0000000..d1bba3f
--- /dev/null
+++ b/webcam/com/adobe/crypto/MD5.as
@@ -0,0 +1,256 @@
+/*

+Adobe Systems Incorporated(r) Source Code License Agreement

+Copyright(c) 2005 Adobe Systems Incorporated. All rights reserved.

+	

+Please read this Source Code License Agreement carefully before using

+the source code.

+	

+Adobe Systems Incorporated grants to you a perpetual, worldwide, non-exclusive,

+no-charge, royalty-free, irrevocable copyright license, to reproduce,

+prepare derivative works of, publicly display, publicly perform, and

+distribute this source code and such derivative works in source or

+object code form without any attribution requirements.

+	

+The name "Adobe Systems Incorporated" must not be used to endorse or promote products

+derived from the source code without prior written permission.

+	

+You agree to indemnify, hold harmless and defend Adobe Systems Incorporated from and

+against any loss, damage, claims or lawsuits, including attorney's

+fees that arise or result from your use or distribution of the source

+code.

+	

+THIS SOURCE CODE IS PROVIDED "AS IS" AND "WITH ALL FAULTS", WITHOUT

+ANY TECHNICAL SUPPORT OR ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING,

+BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS

+FOR A PARTICULAR PURPOSE ARE DISCLAIMED. ALSO, THERE IS NO WARRANTY OF

+NON-INFRINGEMENT, TITLE OR QUIET ENJOYMENT. IN NO EVENT SHALL MACROMEDIA

+OR ITS SUPPLIERS 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 SOURCE CODE, EVEN IF

+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+*/

+

+package com.adobe.crypto {

+	

+	import com.adobe.utils.IntUtil;

+	

+	/**

+	 * The MD5 Message-Digest Algorithm

+	 *

+	 * Implementation based on algorithm description at 

+	 * http://www.faqs.org/rfcs/rfc1321.html

+	 */

+	public class MD5 {

+		

+		/**

+		 * 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 9.0

+		 * @tiptext

+		 */

+		public static function hash( s:String ):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[i+ 0],  7, -680876936 ); 	// 1

+				d = ff( d, a, b, c, x[i+ 1], 12, -389564586 );	// 2

+				c = ff( c, d, a, b, x[i+ 2], 17, 606105819 ); 	// 3

+				b = ff( b, c, d, a, x[i+ 3], 22, -1044525330 );	// 4

+				a = ff( a, b, c, d, x[i+ 4],  7, -176418897 ); 	// 5

+				d = ff( d, a, b, c, x[i+ 5], 12, 1200080426 ); 	// 6

+				c = ff( c, d, a, b, x[i+ 6], 17, -1473231341 );	// 7

+				b = ff( b, c, d, a, x[i+ 7], 22, -45705983 ); 	// 8

+				a = ff( a, b, c, d, x[i+ 8],  7, 1770035416 ); 	// 9

+				d = ff( d, a, b, c, x[i+ 9], 12, -1958414417 );	// 10

+				c = ff( c, d, a, b, x[i+10], 17, -42063 ); 		// 11

+				b = ff( b, c, d, a, x[i+11], 22, -1990404162 );	// 12

+				a = ff( a, b, c, d, x[i+12],  7, 1804603682 ); 	// 13

+				d = ff( d, a, b, c, x[i+13], 12, -40341101 ); 	// 14

+				c = ff( c, d, a, b, x[i+14], 17, -1502002290 );	// 15

+				b = ff( b, c, d, a, x[i+15], 22, 1236535329 ); 	// 16

+				

+				// Round 2

+				a = gg( a, b, c, d, x[i+ 1],  5, -165796510 ); 	// 17

+				d = gg( d, a, b, c, x[i+ 6],  9, -1069501632 );	// 18

+				c = gg( c, d, a, b, x[i+11], 14, 643717713 ); 	// 19

+				b = gg( b, c, d, a, x[i+ 0], 20, -373897302 ); 	// 20

+				a = gg( a, b, c, d, x[i+ 5],  5, -701558691 ); 	// 21

+				d = gg( d, a, b, c, x[i+10],  9, 38016083 ); 	// 22

+				c = gg( c, d, a, b, x[i+15], 14, -660478335 ); 	// 23

+				b = gg( b, c, d, a, x[i+ 4], 20, -405537848 ); 	// 24

+				a = gg( a, b, c, d, x[i+ 9],  5, 568446438 ); 	// 25

+				d = gg( d, a, b, c, x[i+14],  9, -1019803690 );	// 26

+				c = gg( c, d, a, b, x[i+ 3], 14, -187363961 ); 	// 27

+				b = gg( b, c, d, a, x[i+ 8], 20, 1163531501 ); 	// 28

+				a = gg( a, b, c, d, x[i+13],  5, -1444681467 );	// 29

+				d = gg( d, a, b, c, x[i+ 2],  9, -51403784 ); 	// 30

+				c = gg( c, d, a, b, x[i+ 7], 14, 1735328473 ); 	// 31

+				b = gg( b, c, d, a, x[i+12], 20, -1926607734 );	// 32

+				

+				// Round 3

+				a = hh( a, b, c, d, x[i+ 5],  4, -378558 ); 	// 33

+				d = hh( d, a, b, c, x[i+ 8], 11, -2022574463 );	// 34

+				c = hh( c, d, a, b, x[i+11], 16, 1839030562 ); 	// 35

+				b = hh( b, c, d, a, x[i+14], 23, -35309556 ); 	// 36

+				a = hh( a, b, c, d, x[i+ 1],  4, -1530992060 );	// 37

+				d = hh( d, a, b, c, x[i+ 4], 11, 1272893353 ); 	// 38

+				c = hh( c, d, a, b, x[i+ 7], 16, -155497632 ); 	// 39

+				b = hh( b, c, d, a, x[i+10], 23, -1094730640 );	// 40

+				a = hh( a, b, c, d, x[i+13],  4, 681279174 ); 	// 41

+				d = hh( d, a, b, c, x[i+ 0], 11, -358537222 ); 	// 42

+				c = hh( c, d, a, b, x[i+ 3], 16, -722521979 ); 	// 43

+				b = hh( b, c, d, a, x[i+ 6], 23, 76029189 ); 	// 44

+				a = hh( a, b, c, d, x[i+ 9],  4, -640364487 ); 	// 45

+				d = hh( d, a, b, c, x[i+12], 11, -421815835 ); 	// 46

+				c = hh( c, d, a, b, x[i+15], 16, 530742520 ); 	// 47

+				b = hh( b, c, d, a, x[i+ 2], 23, -995338651 ); 	// 48

+				

+				// Round 4

+				a = ii( a, b, c, d, x[i+ 0],  6, -198630844 ); 	// 49

+				d = ii( d, a, b, c, x[i+ 7], 10, 1126891415 ); 	// 50

+				c = ii( c, d, a, b, x[i+14], 15, -1416354905 );	// 51

+				b = ii( b, c, d, a, x[i+ 5], 21, -57434055 ); 	// 52

+				a = ii( a, b, c, d, x[i+12],  6, 1700485571 ); 	// 53

+				d = ii( d, a, b, c, x[i+ 3], 10, -1894986606 );	// 54

+				c = ii( c, d, a, b, x[i+10], 15, -1051523 ); 	// 55

+				b = ii( b, c, d, a, x[i+ 1], 21, -2054922799 );	// 56

+				a = ii( a, b, c, d, x[i+ 8],  6, 1873313359 ); 	// 57

+				d = ii( d, a, b, c, x[i+15], 10, -30611744 ); 	// 58

+				c = ii( c, d, a, b, x[i+ 6], 15, -1560198380 );	// 59

+				b = ii( b, c, d, a, x[i+13], 21, 1309151649 ); 	// 60

+				a = ii( a, b, c, d, x[i+ 4],  6, -145523070 ); 	// 61

+				d = ii( d, a, b, c, x[i+11], 10, -1120210379 );	// 62

+				c = ii( c, d, a, b, x[i+ 2], 15, 718787259 ); 	// 63

+				b = ii( b, c, d, a, x[i+ 9], 21, -343485551 ); 	// 64

+

+				a += aa;

+				b += bb;

+				c += cc;

+				d += dd;

+			}

+

+			// 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: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 ) << ( i % 32 );

+			}

+			

+			// append padding and length

+			blocks[ len >> 5 ] |= 0x80 << ( len % 32 );

+			blocks[ ( ( ( len + 64 ) >>> 9 ) << 4 ) + 14 ] = len;

+			return blocks;

+		}

+		

+	}

+}
\ No newline at end of file