royale-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ha...@apache.org
Subject [royale-asjs] branch develop updated: Replaced MD5 implementation
Date Thu, 21 Jun 2018 08:59:00 GMT
This is an automated email from the ASF dual-hosted git repository.

harbs pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/royale-asjs.git


The following commit(s) were added to refs/heads/develop by this push:
     new a979eb6  Replaced MD5 implementation
a979eb6 is described below

commit a979eb602623b9053ccf433a927f2999b1b9ac55
Author: Harbs <harbs@in-tools.com>
AuthorDate: Thu Jun 21 11:58:53 2018 +0300

    Replaced MD5 implementation
    
    The old one did not work.
---
 LICENSE                                            |  26 ++
 .../src/main/royale/org/apache/royale/utils/MD5.as | 458 ++++++++++++---------
 2 files changed, 284 insertions(+), 200 deletions(-)

diff --git a/LICENSE b/LICENSE
index 0b5974b..b8e676d 100644
--- a/LICENSE
+++ b/LICENSE
@@ -286,3 +286,29 @@ Google Closure Library which are available under Apache License 2.0.
 The createjs.js file in createjs/src/main/javascript is
 a non-copyrightable subset of EaselJS and TweenJS from 
 https://github.com/CreateJS 
+
+The file frameworks/projects/Core/src/main/royale/org/apache/royale/utils/MD5.as
+is derived from https://github.com/blueimp/JavaScript-MD5 which is available under an
+MIT License.
+
+MIT License
+
+Copyright © 2011 Sebastian Tschan, https://blueimp.net
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
\ No newline at end of file
diff --git a/frameworks/projects/Core/src/main/royale/org/apache/royale/utils/MD5.as b/frameworks/projects/Core/src/main/royale/org/apache/royale/utils/MD5.as
index daef624..5da93c7 100644
--- a/frameworks/projects/Core/src/main/royale/org/apache/royale/utils/MD5.as
+++ b/frameworks/projects/Core/src/main/royale/org/apache/royale/utils/MD5.as
@@ -19,239 +19,297 @@
 package org.apache.royale.utils
 {
 
-    /**
-	 * The MD5 Message-Digest Algorithm
-	 *
-	 * Implementation based on algorithm description at
-	 * http://www.faqs.org/rfcs/rfc1321.html
-	 */
+	/*
+	* Adapted from JavaScript MD5
+	* https://github.com/blueimp/JavaScript-MD5
+	*
+	* Copyright 2011, Sebastian Tschan
+	* https://blueimp.net
+	*
+	* Licensed under the MIT license:
+	* https://opensource.org/licenses/MIT
+	*
+	* Based on
+	* A JavaScript implementation of the RSA Data Security, Inc. MD5 Message
+	* Digest Algorithm, as defined in RFC 1321.
+	* Version 2.2 Copyright (C) Paul Johnston 1999 - 2009
+	* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+	* Distributed under the BSD License
+	* See http://pajhome.org.uk/crypt/md5 for more info.
+	*/
 	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 8.5
-		 *  @productversion Royale 0.8
-		 */
+		/*
+		* Add integers, wrapping at 2^32. This uses 16-bit operations internally
+		* to work around bugs in some JS interpreters.
+		*/
+		private static function safeAdd (x:int, y:int):int
+		{
+			var lsw:int = (x & 0xffff) + (y & 0xffff);
+			var msw:int = (x >> 16) + (y >> 16) + (lsw >> 16);
+			return (msw << 16) | (lsw & 0xffff);
+		}
 
-		public static function hash(s:String) :String{
-			//Convert to BinaryData and send through hashBinary function
-			// so as to only have complex code in one location
-			var len:int = s.length;
-			var bd:BinaryData = new BinaryData();
-			for(var i:int = 0; i<len; i++){
-				bd.writeByte(s.charCodeAt(i));
-			}
-			return hashBinary(bd);
+		/*
+		* Bitwise rotate a 32-bit number to the left.
+		*/
+		private static function bitRotateLeft (num:int, cnt:int):int
+		{
+			return (num << cnt) | (num >>> (32 - cnt))
+		}
+
+		/*
+		* These functions implement the four basic operations the algorithm uses.
+		*/
+		private static function md5cmn (q:int, a:int, b:int, x:int, s:int, t:int):int
+		{
+			return safeAdd(bitRotateLeft(safeAdd(safeAdd(a, q), safeAdd(x, t)), s), b)
+		}
+		
+		private static function md5ff (a:int, b:int, c:int, d:int, x:int, s:int, t:int):int {
+			return md5cmn((b & c) | (~b & d), a, b, x, s, t)
+		}
+		
+		private static function md5gg (a:int, b:int, c:int, d:int, x:int, s:int, t:int):int
+		{
+			return md5cmn((b & d) | (c & ~d), a, b, x, s, t)
+		}
+		private static function md5hh (a:int, b:int, c:int, d:int, x:int, s:int, t:int):int
+		{
+			return md5cmn(b ^ c ^ d, a, b, x, s, t)
 		}
-		/**
-		 * Performs the MD5 hash algorithm on a BinaryData.
-		 *
-		 * @param s The string to hash
-		 * @return A string containing the hash value of s
-		 * @langversion ActionScript 3.0
-		 * @playerversion Flash 8.5
-		 *  @productversion Royale 0.8
-		 */
-		public static function hashBinary( s:BinaryData ):String {
-			// initialize the md buffers
+		private static function md5ii (a:int, b:int, c:int, d:int, x:int, s:int, t:int):int
+		{
+			return md5cmn(c ^ (b | ~d), a, b, x, s, t)
+		}
+
+		/*
+		* Calculate the MD5 of an array of little-endian words, and a bit length.
+		*/
+		private static function binlMD5 (x:Array, len:int):Array
+		{
+			/* append padding */
+			x[len >> 5] |= 0x80 << (len % 32)
+			x[((len + 64) >>> 9 << 4) + 14] = len
+
+			var i:int;
+			var olda:int;
+			var oldb:int;
+			var oldc:int;
+			var oldd:int;
 			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;
+			for (i = 0; i < x.length; i += 16) {
+			olda = a;
+			oldb = b;
+			oldc = c;
+			oldd = d;
 
-			// 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;
+			a = md5ff(a, b, c, d, x[i], 7, -680876936);
+			d = md5ff(d, a, b, c, x[i + 1], 12, -389564586);
+			c = md5ff(c, d, a, b, x[i + 2], 17, 606105819);
+			b = md5ff(b, c, d, a, x[i + 3], 22, -1044525330);
+			a = md5ff(a, b, c, d, x[i + 4], 7, -176418897);
+			d = md5ff(d, a, b, c, x[i + 5], 12, 1200080426);
+			c = md5ff(c, d, a, b, x[i + 6], 17, -1473231341);
+			b = md5ff(b, c, d, a, x[i + 7], 22, -45705983);
+			a = md5ff(a, b, c, d, x[i + 8], 7, 1770035416);
+			d = md5ff(d, a, b, c, x[i + 9], 12, -1958414417);
+			c = md5ff(c, d, a, b, x[i + 10], 17, -42063);
+			b = md5ff(b, c, d, a, x[i + 11], 22, -1990404162);
+			a = md5ff(a, b, c, d, x[i + 12], 7, 1804603682);
+			d = md5ff(d, a, b, c, x[i + 13], 12, -40341101);
+			c = md5ff(c, d, a, b, x[i + 14], 17, -1502002290);
+			b = md5ff(b, c, d, a, x[i + 15], 22, 1236535329);
 
-			// 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;
+			a = md5gg(a, b, c, d, x[i + 1], 5, -165796510);
+			d = md5gg(d, a, b, c, x[i + 6], 9, -1069501632);
+			c = md5gg(c, d, a, b, x[i + 11], 14, 643717713);
+			b = md5gg(b, c, d, a, x[i], 20, -373897302);
+			a = md5gg(a, b, c, d, x[i + 5], 5, -701558691);
+			d = md5gg(d, a, b, c, x[i + 10], 9, 38016083);
+			c = md5gg(c, d, a, b, x[i + 15], 14, -660478335);
+			b = md5gg(b, c, d, a, x[i + 4], 20, -405537848);
+			a = md5gg(a, b, c, d, x[i + 9], 5, 568446438);
+			d = md5gg(d, a, b, c, x[i + 14], 9, -1019803690);
+			c = md5gg(c, d, a, b, x[i + 3], 14, -187363961);
+			b = md5gg(b, c, d, a, x[i + 8], 20, 1163531501);
+			a = md5gg(a, b, c, d, x[i + 13], 5, -1444681467);
+			d = md5gg(d, a, b, c, x[i + 2], 9, -51403784);
+			c = md5gg(c, d, a, b, x[i + 7], 14, 1735328473);
+			b = md5gg(b, c, d, a, x[i + 12], 20, -1926607734);
 
-				// 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
+			a = md5hh(a, b, c, d, x[i + 5], 4, -378558);
+			d = md5hh(d, a, b, c, x[i + 8], 11, -2022574463);
+			c = md5hh(c, d, a, b, x[i + 11], 16, 1839030562);
+			b = md5hh(b, c, d, a, x[i + 14], 23, -35309556);
+			a = md5hh(a, b, c, d, x[i + 1], 4, -1530992060);
+			d = md5hh(d, a, b, c, x[i + 4], 11, 1272893353);
+			c = md5hh(c, d, a, b, x[i + 7], 16, -155497632);
+			b = md5hh(b, c, d, a, x[i + 10], 23, -1094730640);
+			a = md5hh(a, b, c, d, x[i + 13], 4, 681279174);
+			d = md5hh(d, a, b, c, x[i], 11, -358537222);
+			c = md5hh(c, d, a, b, x[i + 3], 16, -722521979);
+			b = md5hh(b, c, d, a, x[i + 6], 23, 76029189);
+			a = md5hh(a, b, c, d, x[i + 9], 4, -640364487);
+			d = md5hh(d, a, b, c, x[i + 12], 11, -421815835);
+			c = md5hh(c, d, a, b, x[i + 15], 16, 530742520);
+			b = md5hh(b, c, d, a, x[i + 2], 23, -995338651);
 
-				// 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
+			a = md5ii(a, b, c, d, x[i], 6, -198630844);
+			d = md5ii(d, a, b, c, x[i + 7], 10, 1126891415);
+			c = md5ii(c, d, a, b, x[i + 14], 15, -1416354905);
+			b = md5ii(b, c, d, a, x[i + 5], 21, -57434055);
+			a = md5ii(a, b, c, d, x[i + 12], 6, 1700485571);
+			d = md5ii(d, a, b, c, x[i + 3], 10, -1894986606);
+			c = md5ii(c, d, a, b, x[i + 10], 15, -1051523);
+			b = md5ii(b, c, d, a, x[i + 1], 21, -2054922799);
+			a = md5ii(a, b, c, d, x[i + 8], 6, 1873313359);
+			d = md5ii(d, a, b, c, x[i + 15], 10, -30611744);
+			c = md5ii(c, d, a, b, x[i + 6], 15, -1560198380);
+			b = md5ii(b, c, d, a, x[i + 13], 21, 1309151649);
+			a = md5ii(a, b, c, d, x[i + 4], 6, -145523070);
+			d = md5ii(d, a, b, c, x[i + 11], 10, -1120210379);
+			c = md5ii(c, d, a, b, x[i + 2], 15, 718787259);
+			b = md5ii(b, c, d, a, x[i + 9], 21, -343485551);
 
-				// 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;
+			a = safeAdd(a, olda);
+			b = safeAdd(b, oldb);
+			c = safeAdd(c, oldc);
+			d = safeAdd(d, oldd);
 			}
-
-			// Finish up by concatening the buffers with their hex output
-			return IntUtil.toHex( a ) + IntUtil.toHex( b ) + IntUtil.toHex( c ) + IntUtil.toHex( d
);
+			return [a, b, c, d];
 		}
 
-		/**
-		 * Auxiliary function f as defined in RFC
-		 */
-		private static function f( x:int, y:int, z:int ):int {
-			return ( x & y ) | ( (~x) & z );
+		/*
+		* Convert an array of little-endian words to a string
+		*/
+		private static function binl2rstr (input:Array):String
+		{
+			var i:int;
+			var output:String = ''
+			var length32:int = input.length * 32
+			for (i = 0; i < length32; i += 8)
+			{
+				output += String.fromCharCode((input[i >> 5] >>> (i % 32)) & 0xff);
+			}
+			return output;
 		}
 
-		/**
-		 * Auxiliary function g as defined in RFC
-		 */
-		private static function g( x:int, y:int, z:int ):int {
-			return ( x & z ) | ( y & (~z) );
+		/*
+		* Convert a raw string to an array of little-endian words
+		* Characters >255 have their high-byte silently ignored.
+		*/
+		private static function rstr2binl (input:String):Array {
+			var i:int;
+			var output:Array = [];
+			output[(input.length >> 2) - 1] = undefined;
+			for (i = 0; i < output.length; i += 1)
+			{
+				output[i] = 0;
+			}
+			var length8:int = input.length * 8;
+			for (i = 0; i < length8; i += 8)
+			{
+				output[i >> 5] |= (input.charCodeAt(i / 8) & 0xff) << (i % 32);
+			}
+			return output;
 		}
 
-		/**
-		 * Auxiliary function h as defined in RFC
-		 */
-		private static function h( x:int, y:int, z:int ):int {
-			return x ^ y ^ z;
+		/*
+		* Calculate the MD5 of a raw string
+		*/
+		private static function rstrMD5 (s:String):String
+		{
+			return binl2rstr(binlMD5(rstr2binl(s), s.length * 8));
 		}
 
-		/**
-		 * Auxiliary function i as defined in RFC
-		 */
-		private static function i( x:int, y:int, z:int ):int {
-			return y ^ ( x | (~z) );
+		/*
+		* Calculate the HMAC-MD5, of a key and some data (raw strings)
+		*/
+		private static function rstrHMACMD5 (key:String, data):String
+		{
+			var i:int;
+			var bkey:Array = rstr2binl(key);
+			var ipad:Array = [];
+			var opad:Array = [];
+			var hash:Array;
+			ipad[15] = opad[15] = undefined;
+			if (bkey.length > 16) {
+				bkey = binlMD5(bkey, key.length * 8);
+			}
+			for (i = 0; i < 16; i += 1)
+			{
+				ipad[i] = bkey[i] ^ 0x36363636;
+				opad[i] = bkey[i] ^ 0x5c5c5c5c;
+			}
+			hash = binlMD5(ipad.concat(rstr2binl(data)), 512 + data.length * 8);
+			return binl2rstr(binlMD5(opad.concat(hash), 512 + 128));
 		}
 
-		/**
-		 * 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;
+		/*
+		* Convert a raw string to a hex string
+		*/
+		private static function rstr2hex (input:String):String
+		{
+			var hexTab:String = '0123456789abcdef';
+			var output:String = '';
+			var x:int;
+			var i:int;
+			for (i = 0; i < input.length; i += 1) {
+				x = input.charCodeAt(i);
+				output += hexTab.charAt((x >>> 4) & 0x0f) + hexTab.charAt(x & 0x0f);
+			}
+			return output;
 		}
 
-		/**
-		 * 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 );
+		/*
+		* Encode a string as utf-8
+		*/
+		private static function str2rstrUTF8 (input:String):String
+		{
+			return unescape(encodeURIComponent(input));
 		}
 
-		/**
-		 * 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 );
+		/*
+		* Take string arguments and return either raw or hex encoded strings
+		*/
+		private static function rawMD5 (s:String):String
+		{
+			return rstrMD5(str2rstrUTF8(s));
 		}
-
-		/**
-		 * 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 );
+		private static function hexMD5 (s:String):String
+		{
+			return rstr2hex(rawMD5(s));
 		}
-
-		/**
-		 * 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 );
+		private static function rawHMACMD5 (k:String, d:String):String
+		{
+			return rstrHMACMD5(str2rstrUTF8(k), str2rstrUTF8(d));
+		}
+		private static function hexHMACMD5 (k:String, d:String):String
+		{
+			return rstr2hex(rawHMACMD5(k, d));
 		}
+		public static function hash(value:String):String
+		{
+			return hexMD5(value);
+		}
+		//   private static function md5 (string, key, raw) {
+		//     if (!key) {
+		//       if (!raw) {
+		//         return hexMD5(string)
+		//       }
+		//       return rawMD5(string)
+		//     }
+		//     if (!raw) {
+		//       return hexHMACMD5(key, string)
+		//     }
+		//     return rawHMACMD5(key, string)
+		//   }
 
-		/**
-		 * 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:BinaryData ):Array {
-			var blocks: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[ i / 8 ] & mask ) << ( i % 32 );
-			}
 
-			// append padding and length
-			blocks[ len >> 5 ] |= 0x80 << ( len % 32 );
-			blocks[ ( ( ( len + 64 ) >>> 9 ) << 4 ) + 14 ] = len;
-			return blocks;
-		}
 	}
 }


Mime
View raw message