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 = [];
private var arrLen:int;
private var a:int = 1732584193;
private var b:int = -271733879;
private var c:int = -1732584194;
private var d:int = 271733878;
private var aa:int;
private var bb:int;
private var cc:int;
private var dd:int;
private var arrIndexLen:int = 0;
private var arrProcessIndex:int = 0;
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);
}
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
{
arr.length = 0;
arrLen = 0;
a = 1732584193;
b = -271733879;
c = -1732584194;
d = 271733878;
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;
if ( arrProcessIndex - cleanIndex > memoryBlockSize )
{
var newarr:Array= new Array();
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 )
{
arr[ int(arrIndexLen >> 5) ] |= ( input[ k / 8 ] & mask ) << ( arrIndexLen % 32 );
arrIndexLen += 8;
}
}
private function hashRemainingChunks(bUpdate:Boolean=true):void
{
var len:int = arr.length;
if ( bUpdate )
{
len -= 16;
}
if ( arrProcessIndex >= len || len - arrProcessIndex < 15 )
{
return;
}
for ( var i:int = arrProcessIndex; i < len ; i += 16, arrProcessIndex += 16)
{
aa = a;
bb = b;
cc = c;
dd = d;
a = ff( a, b, c, d, arr[int(i+ 0)], 7, -680876936 ); d = ff( d, a, b, c, arr[int(i+ 1)], 12, -389564586 ); c = ff( c, d, a, b, arr[int(i+ 2)], 17, 606105819 ); b = ff( b, c, d, a, arr[int(i+ 3)], 22, -1044525330 ); a = ff( a, b, c, d, arr[int(i+ 4)], 7, -176418897 ); d = ff( d, a, b, c, arr[int(i+ 5)], 12, 1200080426 ); c = ff( c, d, a, b, arr[int(i+ 6)], 17, -1473231341 ); b = ff( b, c, d, a, arr[int(i+ 7)], 22, -45705983 ); a = ff( a, b, c, d, arr[int(i+ 8)], 7, 1770035416 ); d = ff( d, a, b, c, arr[int(i+ 9)], 12, -1958414417 ); c = ff( c, d, a, b, arr[int(i+10)], 17, -42063 ); b = ff( b, c, d, a, arr[int(i+11)], 22, -1990404162 ); a = ff( a, b, c, d, arr[int(i+12)], 7, 1804603682 ); d = ff( d, a, b, c, arr[int(i+13)], 12, -40341101 ); c = ff( c, d, a, b, arr[int(i+14)], 17, -1502002290 ); b = ff( b, c, d, a, arr[int(i+15)], 22, 1236535329 );
a = gg( a, b, c, d, arr[int(i+ 1)], 5, -165796510 ); d = gg( d, a, b, c, arr[int(i+ 6)], 9, -1069501632 ); c = gg( c, d, a, b, arr[int(i+11)], 14, 643717713 ); b = gg( b, c, d, a, arr[int(i+ 0)], 20, -373897302 ); a = gg( a, b, c, d, arr[int(i+ 5)], 5, -701558691 ); d = gg( d, a, b, c, arr[int(i+10)], 9, 38016083 ); c = gg( c, d, a, b, arr[int(i+15)], 14, -660478335 ); b = gg( b, c, d, a, arr[int(i+ 4)], 20, -405537848 ); a = gg( a, b, c, d, arr[int(i+ 9)], 5, 568446438 ); d = gg( d, a, b, c, arr[int(i+14)], 9, -1019803690 ); c = gg( c, d, a, b, arr[int(i+ 3)], 14, -187363961 ); b = gg( b, c, d, a, arr[int(i+ 8)], 20, 1163531501 ); a = gg( a, b, c, d, arr[int(i+13)], 5, -1444681467 ); d = gg( d, a, b, c, arr[int(i+ 2)], 9, -51403784 ); c = gg( c, d, a, b, arr[int(i+ 7)], 14, 1735328473 ); b = gg( b, c, d, a, arr[int(i+12)], 20, -1926607734 );
a = hh( a, b, c, d, arr[int(i+ 5)], 4, -378558 ); d = hh( d, a, b, c, arr[int(i+ 8)], 11, -2022574463 ); c = hh( c, d, a, b, arr[int(i+11)], 16, 1839030562 ); b = hh( b, c, d, a, arr[int(i+14)], 23, -35309556 ); a = hh( a, b, c, d, arr[int(i+ 1)], 4, -1530992060 ); d = hh( d, a, b, c, arr[int(i+ 4)], 11, 1272893353 ); c = hh( c, d, a, b, arr[int(i+ 7)], 16, -155497632 ); b = hh( b, c, d, a, arr[int(i+10)], 23, -1094730640 ); a = hh( a, b, c, d, arr[int(i+13)], 4, 681279174 ); d = hh( d, a, b, c, arr[int(i+ 0)], 11, -358537222 ); c = hh( c, d, a, b, arr[int(i+ 3)], 16, -722521979 ); b = hh( b, c, d, a, arr[int(i+ 6)], 23, 76029189 ); a = hh( a, b, c, d, arr[int(i+ 9)], 4, -640364487 ); d = hh( d, a, b, c, arr[int(i+12)], 11, -421815835 ); c = hh( c, d, a, b, arr[int(i+15)], 16, 530742520 ); b = hh( b, c, d, a, arr[int(i+ 2)], 23, -995338651 );
a = ii( a, b, c, d, arr[int(i+ 0)], 6, -198630844 ); d = ii( d, a, b, c, arr[int(i+ 7)], 10, 1126891415 ); c = ii( c, d, a, b, arr[int(i+14)], 15, -1416354905 ); b = ii( b, c, d, a, arr[int(i+ 5)], 21, -57434055 ); a = ii( a, b, c, d, arr[int(i+12)], 6, 1700485571 ); d = ii( d, a, b, c, arr[int(i+ 3)], 10, -1894986606 ); c = ii( c, d, a, b, arr[int(i+10)], 15, -1051523 ); b = ii( b, c, d, a, arr[int(i+ 1)], 21, -2054922799 ); a = ii( a, b, c, d, arr[int(i+ 8)], 6, 1873313359 ); d = ii( d, a, b, c, arr[int(i+15)], 10, -30611744 ); c = ii( c, d, a, b, arr[int(i+ 6)], 15, -1560198380 ); b = ii( b, c, d, a, arr[int(i+13)], 21, 1309151649 ); a = ii( a, b, c, d, arr[int(i+ 4)], 6, -145523070 ); d = ii( d, a, b, c, arr[int(i+11)], 10, -1120210379 ); c = ii( c, d, a, b, arr[int(i+ 2)], 15, 718787259 ); b = ii( b, c, d, a, arr[int(i+ 9)], 21, -343485551 );
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;
}
/**
* 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 );
}
}
}