MD5 加密

MD5 算法源码（Java版）：

public class MD5 {
	/*
	 * Convert a 32-bit number to a hex string with ls-byte first
	 */
	String hex_chr = "0123456789abcdef";

	private String rhex(int num) {
		String str = "";
		for (int j = 0; j <= 3; j++)
			str = str + hex_chr.charAt((num >> (j * 8 + 4)) & 0x0F)
					+ hex_chr.charAt((num >> (j * 8)) & 0x0F);
		return str;
	}

	/*
	 * Convert a string to a sequence of 16-word blocks, stored as an array.
	 * Append padding bits and the length, as described in the MD5 standard.
	 */
	private int[] str2blks_MD5(String str) {
		int nblk = ((str.length() + 8) >> 6) + 1;
		int[] blks = new int[nblk * 16];
		int i = 0;
		for (i = 0; i < nblk * 16; i++) {
			blks[i] = 0;
		}
		for (i = 0; i < str.length(); i++) {
			blks[i >> 2] |= str.charAt(i) << ((i % 4) * 8);
		}
		blks[i >> 2] |= 0x80 << ((i % 4) * 8);
		blks[nblk * 16 - 2] = str.length() * 8;

		return blks;
	}

	/*
	 * Add integers, wrapping at 2^32 　　
	 */
	private int add(int x, int y) {
		return ((x & 0x7FFFFFFF) + (y & 0x7FFFFFFF)) ^ (x & 0x80000000)
				^ (y & 0x80000000);
	}

	/*
	 * Bitwise rotate a 32-bit number to the left 　　
	 */
	private int rol(int num, int cnt) {
		return (num << cnt) | (num >>> (32 - cnt));
	}

	/*
	 * These functions implement the basic operation for each round of the
	 * algorithm. 　　
	 */
	private int cmn(int q, int a, int b, int x, int s, int t) {
		return add(rol(add(add(a, q), add(x, t)), s), b);
	}

	private int ff(int a, int b, int c, int d, int x, int s, int t) {
		return cmn((b & c) | ((~b) & d), a, b, x, s, t);
	}

	private int gg(int a, int b, int c, int d, int x, int s, int t) {
		return cmn((b & d) | (c & (~d)), a, b, x, s, t);
	}

	private int hh(int a, int b, int c, int d, int x, int s, int t) {
		return cmn(b ^ c ^ d, a, b, x, s, t);
	}

	private int ii(int a, int b, int c, int d, int x, int s, int t) {
		return cmn(c ^ (b | (~d)), a, b, x, s, t);
	}

	
	/*
	 * Take a string and return the hex representation of its MD5. 　　
	 */
	public String calcMD5(String str) {
		int[] x = str2blks_MD5(str);
		int a = 0x67452301;
		int b = 0xEFCDAB89;
		int c = 0x98BADCFE;
		int d = 0x10325476;

		for (int i = 0; i < x.length; i += 16) {
			int olda = a;
			int oldb = b;
			int oldc = c;
			int oldd = d;

			a = ff(a, b, c, d, x[i + 0], 7, 0xD76AA478);
			d = ff(d, a, b, c, x[i + 1], 12, 0xE8C7B756);
			c = ff(c, d, a, b, x[i + 2], 17, 0x242070DB);
			b = ff(b, c, d, a, x[i + 3], 22, 0xC1BDCEEE);
			a = ff(a, b, c, d, x[i + 4], 7, 0xF57C0FAF);
			d = ff(d, a, b, c, x[i + 5], 12, 0x4787C62A);
			c = ff(c, d, a, b, x[i + 6], 17, 0xA8304613);
			b = ff(b, c, d, a, x[i + 7], 22, 0xFD469501);
			a = ff(a, b, c, d, x[i + 8], 7, 0x698098D8);
			d = ff(d, a, b, c, x[i + 9], 12, 0x8B44F7AF);
			c = ff(c, d, a, b, x[i + 10], 17, 0xFFFF5BB1);
			b = ff(b, c, d, a, x[i + 11], 22, 0x895CD7BE);
			a = ff(a, b, c, d, x[i + 12], 7, 0x6B901122);
			d = ff(d, a, b, c, x[i + 13], 12, 0xFD987193);
			c = ff(c, d, a, b, x[i + 14], 17, 0xA679438E);
			b = ff(b, c, d, a, x[i + 15], 22, 0x49B40821);

			a = gg(a, b, c, d, x[i + 1], 5, 0xF61E2562);
			d = gg(d, a, b, c, x[i + 6], 9, 0xC040B340);
			c = gg(c, d, a, b, x[i + 11], 14, 0x265E5A51);
			b = gg(b, c, d, a, x[i + 0], 20, 0xE9B6C7AA);
			a = gg(a, b, c, d, x[i + 5], 5, 0xD62F105D);
			d = gg(d, a, b, c, x[i + 10], 9, 0x02441453);
			c = gg(c, d, a, b, x[i + 15], 14, 0xD8A1E681);
			b = gg(b, c, d, a, x[i + 4], 20, 0xE7D3FBC8);
			a = gg(a, b, c, d, x[i + 9], 5, 0x21E1CDE6);
			d = gg(d, a, b, c, x[i + 14], 9, 0xC33707D6);
			c = gg(c, d, a, b, x[i + 3], 14, 0xF4D50D87);
			b = gg(b, c, d, a, x[i + 8], 20, 0x455A14ED);
			a = gg(a, b, c, d, x[i + 13], 5, 0xA9E3E905);
			d = gg(d, a, b, c, x[i + 2], 9, 0xFCEFA3F8);
			c = gg(c, d, a, b, x[i + 7], 14, 0x676F02D9);
			b = gg(b, c, d, a, x[i + 12], 20, 0x8D2A4C8A);

			a = hh(a, b, c, d, x[i + 5], 4, 0xFFFA3942);
			d = hh(d, a, b, c, x[i + 8], 11, 0x8771F681);
			c = hh(c, d, a, b, x[i + 11], 16, 0x6D9D6122);
			b = hh(b, c, d, a, x[i + 14], 23, 0xFDE5380C);
			a = hh(a, b, c, d, x[i + 1], 4, 0xA4BEEA44);
			d = hh(d, a, b, c, x[i + 4], 11, 0x4BDECFA9);
			c = hh(c, d, a, b, x[i + 7], 16, 0xF6BB4B60);
			b = hh(b, c, d, a, x[i + 10], 23, 0xBEBFBC70);
			a = hh(a, b, c, d, x[i + 13], 4, 0x289B7EC6);
			d = hh(d, a, b, c, x[i + 0], 11, 0xEAA127FA);
			c = hh(c, d, a, b, x[i + 3], 16, 0xD4EF3085);
			b = hh(b, c, d, a, x[i + 6], 23, 0x04881D05);
			a = hh(a, b, c, d, x[i + 9], 4, 0xD9D4D039);
			d = hh(d, a, b, c, x[i + 12], 11, 0xE6DB99E5);
			c = hh(c, d, a, b, x[i + 15], 16, 0x1FA27CF8);
			b = hh(b, c, d, a, x[i + 2], 23, 0xC4AC5665);

			a = ii(a, b, c, d, x[i + 0], 6, 0xF4292244);
			d = ii(d, a, b, c, x[i + 7], 10, 0x432AFF97);
			c = ii(c, d, a, b, x[i + 14], 15, 0xAB9423A7);
			b = ii(b, c, d, a, x[i + 5], 21, 0xFC93A039);
			a = ii(a, b, c, d, x[i + 12], 6, 0x655B59C3);
			d = ii(d, a, b, c, x[i + 3], 10, 0x8F0CCC92);
			c = ii(c, d, a, b, x[i + 10], 15, 0xFFEFF47D);
			b = ii(b, c, d, a, x[i + 1], 21, 0x85845DD1);
			a = ii(a, b, c, d, x[i + 8], 6, 0x6FA87E4F);
			d = ii(d, a, b, c, x[i + 15], 10, 0xFE2CE6E0);
			c = ii(c, d, a, b, x[i + 6], 15, 0xA3014314);
			b = ii(b, c, d, a, x[i + 13], 21, 0x4E0811A1);
			a = ii(a, b, c, d, x[i + 4], 6, 0xF7537E82);
			d = ii(d, a, b, c, x[i + 11], 10, 0xBD3AF235);
			c = ii(c, d, a, b, x[i + 2], 15, 0x2AD7D2BB);
			b = ii(b, c, d, a, x[i + 9], 21, 0xEB86D391);

			a = add(a, olda);
			b = add(b, oldb);
			c = add(c, oldc);
			d = add(d, oldd);
		}
		return rhex(a) + rhex(b) + rhex(c) + rhex(d);
	}
}

测试类：

public class MD5_Test {

	public static void main(String[] args) {
		MD5 m = new MD5();
		
		System.out.println(m.calcMD5("123456"));
	}
}

MD5 算法源码（Flex版）：

package com.my.commons {
	import flash.utils.Endian;
	
	/**
	 * Contains reusable methods for operations pertaining
	 * to int values.
	 */
	public class IntUtil {
		
		/**
		 * Rotates x left n bits
		 *
		 * @langversion ActionScript 3.0
		 * @playerversion Flash 9.0
		 * @tiptext
		 */
		public static function rol(x : int, n : int) : int {
			return (x << n) | (x >>> (32 - n));
		}
		
		
		/**
		 * Rotates x right n bits
		 *
		 * @langversion ActionScript 3.0
		 * @playerversion Flash 9.0
		 * @tiptext
		 */
		public static function ror(x : int, n : int) : uint {
			var nn : int = 32 - n;
			return (x << nn) | (x >>> (32 - nn));
		}
		
		/** String for quick lookup of a hex character based on index */
		private static var hexChars : String = "0123456789abcdef";
		
		
		/**
		 * Outputs the hex value of a int, allowing the developer to specify
		 * the endinaness in the process.  Hex output is lowercase.
		 *
		 * @param n The int value to output as hex
		 * @param bigEndian Flag to output the int as big or little endian
		 * @return A string of length 8 corresponding to the
		 *		hex representation of n ( minus the leading "0x" )
		 * @langversion ActionScript 3.0
		 * @playerversion Flash 9.0
		 * @tiptext
		 */
		public static function toHex(n : int, bigEndian : Boolean = false) : String {
			var s : String = "";
			
			if (bigEndian) {
				for (var i : int = 0; i < 4; i++) {
					s += hexChars.charAt((n >> ((3 - i) * 8 + 4)) & 0xF) + hexChars.charAt((n >> ((3 - i) * 8)) & 0xF);
				}
			} else {
				for (var x : int = 0; x < 4; x++) {
					s += hexChars.charAt((n >> (x * 8 + 4)) & 0xF) + hexChars.charAt((n >> (x * 8)) & 0xF);
				}
			}
			
			return s;
		}
	}
	
}

package com.my.commons {
	
	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;
		}
		
	}
}

测试类：

public function init():void{
	Alert.show(MD5.hash("123456"));
}