MD5

java 版MD5:

1.

/************************************************
 MD5 算法的Java Bean
 *************************************************/
package com.cabletech.commons.md5;

import java.lang.reflect.*;

public class MD5{
    /* 下面这些S11-S44实际上是一个4*4的矩阵，在原始的C实现中是用#define 实现的，
         这里把它们实现成为static final是表示了只读，切能在同一个进程空间内的多个
         Instance间共享*/
    static final int S11 = 7;
    static final int S12 = 12;
    static final int S13 = 17;
    static final int S14 = 22;

    static final int S21 = 5;
    static final int S22 = 9;
    static final int S23 = 14;
    static final int S24 = 20;

    static final int S31 = 4;
    static final int S32 = 11;
    static final int S33 = 16;
    static final int S34 = 23;

    static final int S41 = 6;
    static final int S42 = 10;
    static final int S43 = 15;
    static final int S44 = 21;

    static final byte[] PADDING = { -128, 0, 0, 0, 0, 0, 0, 0, 0,
                                  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
    /* 下面的三个成员是MD5计算过程中用到的3个核心数据，在原始的C实现中
       被定义到MD5_CTX结构中

     */
    private long[] state = new long[4]; // state (ABCD)
    private long[] count = new long[2]; // number of bits, modulo 2^64 (lsb first)
    private byte[] buffer = new byte[64]; // input buffer

    /* digestHexStr是MD5的唯一一个公共成员，是最新一次计算结果的
         　 16进制ASCII表示.
     */
    public String digestHexStr;

    /* digest,是最新一次计算结果的2进制内部表示，表示128bit的MD5值.
     */
    private byte[] digest = new byte[16];

    /*
      getMD5ofStr是类MD5最主要的公共方法，入口参数是你想要进行MD5变换的字符串
      返回的是变换完的结果，这个结果是从公共成员digestHexStr取得的．
     */
    private String getMD5ofStr( String inbuf ){
        md5Init();
        md5Update( inbuf.getBytes(), inbuf.length() );
        md5Final();
        digestHexStr = "";
        for( int i = 0; i < 16; i++ ){
            digestHexStr += byteHEX( digest[i] );
        }
        return digestHexStr;

    }


    // 这是MD5这个类的标准构造函数，JavaBean要求有一个public的并且没有参数的构造函数
    private MD5(){
        md5Init();

        return;
    }


    /* md5Init是一个初始化函数，初始化核心变量，装入标准的幻数 */
    private void md5Init(){
        count[0] = 0L;
        count[1] = 0L;
        ///* Load magic initialization constants.

        state[0] = 0x67452301L;
        state[1] = 0xefcdab89L;
        state[2] = 0x98badcfeL;
        state[3] = 0x10325476L;

        return;
    }


    /* F, G, H ,I 是4个基本的MD5函数，在原始的MD5的C实现中，由于它们是
             简单的位运算，可能出于效率的考虑把它们实现成了宏，在java中，我们把它们
          　　实现成了private方法，名字保持了原来C中的。 */

    private long F( long x, long y, long z ){
        return( x & y ) | ( ( ~x ) & z );

    }


    private long G( long x, long y, long z ){
        return( x & z ) | ( y & ( ~z ) );

    }


    private long H( long x, long y, long z ){
        return x ^ y ^ z;
    }


    private long I( long x, long y, long z ){
        return y ^ ( x | ( ~z ) );
    }


    /*
       FF,GG,HH和II将调用F,G,H,I进行近一步变换
       FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
       Rotation is separate from addition to prevent recomputation.
     */

    private long FF( long a, long b, long c, long d, long x, long s,
        long ac ){
        a += F( b, c, d ) + x + ac;
        a = ( ( int )a << s ) | ( ( int )a >>> ( 32 - s ) );
        a += b;
        return a;
    }


    private long GG( long a, long b, long c, long d, long x, long s,
        long ac ){
        a += G( b, c, d ) + x + ac;
        a = ( ( int )a << s ) | ( ( int )a >>> ( 32 - s ) );
        a += b;
        return a;
    }


    private long HH( long a, long b, long c, long d, long x, long s,
        long ac ){
        a += H( b, c, d ) + x + ac;
        a = ( ( int )a << s ) | ( ( int )a >>> ( 32 - s ) );
        a += b;
        return a;
    }


    private long II( long a, long b, long c, long d, long x, long s,
        long ac ){
        a += I( b, c, d ) + x + ac;
        a = ( ( int )a << s ) | ( ( int )a >>> ( 32 - s ) );
        a += b;
        return a;
    }


    /*
     md5Update是MD5的主计算过程，inbuf是要变换的字节串，inputlen是长度，这个
     函数由getMD5ofStr调用，调用之前需要调用md5init，因此把它设计成private的
     */
    private void md5Update( byte[] inbuf, int inputLen ){

        int i, index, partLen;
        byte[] block = new byte[64];
        index = ( int ) ( count[0] >>> 3 ) & 0x3F;
        // /* Update number of bits */
        if( ( count[0] += ( inputLen << 3 ) ) < ( inputLen << 3 ) ){
            count[1]++;
        }
        count[1] += ( inputLen >>> 29 );

        partLen = 64 - index;

        // Transform as many times as possible.
        if( inputLen >= partLen ){
            md5Memcpy( buffer, inbuf, index, 0, partLen );
            md5Transform( buffer );

            for( i = partLen; i + 63 < inputLen; i += 64 ){

                md5Memcpy( block, inbuf, 0, i, 64 );
                md5Transform( block );
            }
            index = 0;

        }
        else{

            i = 0;
        }

        ///* Buffer remaining input */
        md5Memcpy( buffer, inbuf, index, i, inputLen - i );

    }


    /*
      md5Final整理和填写输出结果
     */
    private void md5Final(){
        byte[] bits = new byte[8];
        int index, padLen;

        ///* Save number of bits */
        Encode( bits, count, 8 );

        ///* Pad out to 56 mod 64.
         index = ( int ) ( count[0] >>> 3 ) & 0x3f;
        padLen = ( index < 56 ) ? ( 56 - index ) : ( 120 - index );
        md5Update( PADDING, padLen );

        ///* Append length (before padding) */
        md5Update( bits, 8 );

        ///* Store state in digest */
        Encode( digest, state, 16 );

    }


    /* md5Memcpy是一个内部使用的byte数组的块拷贝函数，从input的inpos开始把len长度的
     　　　　　 字节拷贝到output的outpos位置开始
     */

    private void md5Memcpy( byte[] output, byte[] input,
        int outpos, int inpos, int len ){
        int i;

        for( i = 0; i < len; i++ ){
            output[outpos + i] = input[inpos + i];
        }
    }


    /*
       md5Transform是MD5核心变换程序，有md5Update调用，block是分块的原始字节
     */
    private void md5Transform( byte block[] ){
        long a = state[0], b = state[1], c = state[2], d = state[3];
        long[] x = new long[16];

        Decode( x, block, 64 );

        /* Round 1 */
        a = FF( a, b, c, d, x[0], S11, 0xd76aa478L ); /* 1 */
        d = FF( d, a, b, c, x[1], S12, 0xe8c7b756L ); /* 2 */
        c = FF( c, d, a, b, x[2], S13, 0x242070dbL ); /* 3 */
        b = FF( b, c, d, a, x[3], S14, 0xc1bdceeeL ); /* 4 */
        a = FF( a, b, c, d, x[4], S11, 0xf57c0fafL ); /* 5 */
        d = FF( d, a, b, c, x[5], S12, 0x4787c62aL ); /* 6 */
        c = FF( c, d, a, b, x[6], S13, 0xa8304613L ); /* 7 */
        b = FF( b, c, d, a, x[7], S14, 0xfd469501L ); /* 8 */
        a = FF( a, b, c, d, x[8], S11, 0x698098d8L ); /* 9 */
        d = FF( d, a, b, c, x[9], S12, 0x8b44f7afL ); /* 10 */
        c = FF( c, d, a, b, x[10], S13, 0xffff5bb1L ); /* 11 */
        b = FF( b, c, d, a, x[11], S14, 0x895cd7beL ); /* 12 */
        a = FF( a, b, c, d, x[12], S11, 0x6b901122L ); /* 13 */
        d = FF( d, a, b, c, x[13], S12, 0xfd987193L ); /* 14 */
        c = FF( c, d, a, b, x[14], S13, 0xa679438eL ); /* 15 */
        b = FF( b, c, d, a, x[15], S14, 0x49b40821L ); /* 16 */

        /* Round 2 */
        a = GG( a, b, c, d, x[1], S21, 0xf61e2562L ); /* 17 */
        d = GG( d, a, b, c, x[6], S22, 0xc040b340L ); /* 18 */
        c = GG( c, d, a, b, x[11], S23, 0x265e5a51L ); /* 19 */
        b = GG( b, c, d, a, x[0], S24, 0xe9b6c7aaL ); /* 20 */
        a = GG( a, b, c, d, x[5], S21, 0xd62f105dL ); /* 21 */
        d = GG( d, a, b, c, x[10], S22, 0x2441453L ); /* 22 */
        c = GG( c, d, a, b, x[15], S23, 0xd8a1e681L ); /* 23 */
        b = GG( b, c, d, a, x[4], S24, 0xe7d3fbc8L ); /* 24 */
        a = GG( a, b, c, d, x[9], S21, 0x21e1cde6L ); /* 25 */
        d = GG( d, a, b, c, x[14], S22, 0xc33707d6L ); /* 26 */
        c = GG( c, d, a, b, x[3], S23, 0xf4d50d87L ); /* 27 */
        b = GG( b, c, d, a, x[8], S24, 0x455a14edL ); /* 28 */
        a = GG( a, b, c, d, x[13], S21, 0xa9e3e905L ); /* 29 */
        d = GG( d, a, b, c, x[2], S22, 0xfcefa3f8L ); /* 30 */
        c = GG( c, d, a, b, x[7], S23, 0x676f02d9L ); /* 31 */
        b = GG( b, c, d, a, x[12], S24, 0x8d2a4c8aL ); /* 32 */

        /* Round 3 */
        a = HH( a, b, c, d, x[5], S31, 0xfffa3942L ); /* 33 */
        d = HH( d, a, b, c, x[8], S32, 0x8771f681L ); /* 34 */
        c = HH( c, d, a, b, x[11], S33, 0x6d9d6122L ); /* 35 */
        b = HH( b, c, d, a, x[14], S34, 0xfde5380cL ); /* 36 */
        a = HH( a, b, c, d, x[1], S31, 0xa4beea44L ); /* 37 */
        d = HH( d, a, b, c, x[4], S32, 0x4bdecfa9L ); /* 38 */
        c = HH( c, d, a, b, x[7], S33, 0xf6bb4b60L ); /* 39 */
        b = HH( b, c, d, a, x[10], S34, 0xbebfbc70L ); /* 40 */
        a = HH( a, b, c, d, x[13], S31, 0x289b7ec6L ); /* 41 */
        d = HH( d, a, b, c, x[0], S32, 0xeaa127faL ); /* 42 */
        c = HH( c, d, a, b, x[3], S33, 0xd4ef3085L ); /* 43 */
        b = HH( b, c, d, a, x[6], S34, 0x4881d05L ); /* 44 */
        a = HH( a, b, c, d, x[9], S31, 0xd9d4d039L ); /* 45 */
        d = HH( d, a, b, c, x[12], S32, 0xe6db99e5L ); /* 46 */
        c = HH( c, d, a, b, x[15], S33, 0x1fa27cf8L ); /* 47 */
        b = HH( b, c, d, a, x[2], S34, 0xc4ac5665L ); /* 48 */

        /* Round 4 */
        a = II( a, b, c, d, x[0], S41, 0xf4292244L ); /* 49 */
        d = II( d, a, b, c, x[7], S42, 0x432aff97L ); /* 50 */
        c = II( c, d, a, b, x[14], S43, 0xab9423a7L ); /* 51 */
        b = II( b, c, d, a, x[5], S44, 0xfc93a039L ); /* 52 */
        a = II( a, b, c, d, x[12], S41, 0x655b59c3L ); /* 53 */
        d = II( d, a, b, c, x[3], S42, 0x8f0ccc92L ); /* 54 */
        c = II( c, d, a, b, x[10], S43, 0xffeff47dL ); /* 55 */
        b = II( b, c, d, a, x[1], S44, 0x85845dd1L ); /* 56 */
        a = II( a, b, c, d, x[8], S41, 0x6fa87e4fL ); /* 57 */
        d = II( d, a, b, c, x[15], S42, 0xfe2ce6e0L ); /* 58 */
        c = II( c, d, a, b, x[6], S43, 0xa3014314L ); /* 59 */
        b = II( b, c, d, a, x[13], S44, 0x4e0811a1L ); /* 60 */
        a = II( a, b, c, d, x[4], S41, 0xf7537e82L ); /* 61 */
        d = II( d, a, b, c, x[11], S42, 0xbd3af235L ); /* 62 */
        c = II( c, d, a, b, x[2], S43, 0x2ad7d2bbL ); /* 63 */
        b = II( b, c, d, a, x[9], S44, 0xeb86d391L ); /* 64 */

        state[0] += a;
        state[1] += b;
        state[2] += c;
        state[3] += d;

    }


    /*Encode把long数组按顺序拆成byte数组，因为java的long类型是64bit的，
      只拆低32bit，以适应原始C实现的用途
     */
    private void Encode( byte[] output, long[] input, int len ){
        int i, j;

        for( i = 0, j = 0; j < len; i++, j += 4 ){
            output[j] = ( byte ) ( input[i] & 0xffL );
            output[j + 1] = ( byte ) ( ( input[i] >>> 8 ) & 0xffL );
            output[j + 2] = ( byte ) ( ( input[i] >>> 16 ) & 0xffL );
            output[j + 3] = ( byte ) ( ( input[i] >>> 24 ) & 0xffL );
        }
    }


    /*Decode把byte数组按顺序合成成long数组，因为java的long类型是64bit的，
      只合成低32bit，高32bit清零，以适应原始C实现的用途
     */
    private void Decode( long[] output, byte[] input, int len ){
        int i, j;

        for( i = 0, j = 0; j < len; i++, j += 4 ){
            output[i] = b2iu( input[j] ) |
                        ( b2iu( input[j + 1] ) << 8 ) |
                        ( b2iu( input[j + 2] ) << 16 ) |
                        ( b2iu( input[j + 3] ) << 24 );
        }

        return;
    }


    /*
      b2iu是我写的一个把byte按照不考虑正负号的原则的＂升位＂程序，因为java没有unsigned运算
     */
    public static long b2iu( byte b ){
        return b < 0 ? b & 0x7F + 128 : b;
    }


    /*byteHEX()，用来把一个byte类型的数转换成十六进制的ASCII表示，
         　因为java中的byte的toString无法实现这一点，我们又没有C语言中的
      sprintf(outbuf,"%02X",ib)
     */
    public static String byteHEX( byte ib ){
        char[] Digit = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
                       'A', 'B', 'C', 'D', 'E', 'F'};
        char[] ob = new char[2];
        ob[0] = Digit[ ( ib >>> 4 ) & 0X0F];
        ob[1] = Digit[ib & 0X0F];
        String s = new String( ob );
        return s;
    }

    /**
     * 将字符串转换为MD5
     * @param str String 待转换的字符串
     * @param type int 默认是32位的。type=16时，MD5长度为16位
     * @return String 返回 MD5 字符串
     */
    public static String encode( String str, int type){
        MD5 md5 = new MD5();
        String strmd5 = null;
        strmd5 = md5.getMD5ofStr( str ).toLowerCase();
        if(type == 16){
            strmd5 = strmd5.substring(8,24);
            return strmd5;
        }else
            return strmd5;
    }

    /**
     * md5解密
     * @param md5 String
     * @return String
     */
    public String decode( String md5 ){
        return null;
    }


//    public static void main( String args[] ){
//        MD5 m = new MD5();
//        if( Array.getLength( args ) == 0 ){ //如果没有参数，执行标准的Test Suite
//            System.out.println( "MD5 Test suite:" );
//            System.out.println( "MD5(\"\"):" + m.getMD5ofStr( "" ).substring(8,24) );
//            System.out.println( "MD5(\"a\"):" + m.getMD5ofStr( "a" ) );
//            System.out.println( "MD5(\"abc\"):" + m.getMD5ofStr( "abc" ) );
//            System.out.println( "MD5(\"message digest\"):" + m.getMD5ofStr( "message digest" ) );
//            System.out.println( "MD5(\"abcdefghijklmnopqrstuvwxyz\"):" +
//                m.getMD5ofStr( "abcdefghijklmnopqrstuvwxyz" ) );
//            System.out.println( "MD5(\"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789\"):" +
//                m.getMD5ofStr( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789" ) );
//        }
//        else{
//            System.out.println( "MD5(" + args[0] + ")=" + m.getMD5ofStr( args[0] ) );
//        }
//
//    }

}
 

2。

public class MD5
{
/*
  * A Java implementation of the RSA Data Security, Inc. MD5 Message
  * Digest Algorithm, as defined in RFC 1321.
  * Based on the JavaScript implementation of Paul Johnston
  *     Copyright (C) Paul Johnston 1999 - 2000.
  *     See http://pajhome.org.uk/site/legal.html for details.
  * Java Version by Thomas Weber (Orange Interactive GmbH)
  */

/*
  * 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 = 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);
}

}

javascript 版源码：

<html>
<head>
<meta name="GENERATOR" content="Microsoft FrontPage 5.0">
<meta name="ProgId" content="FrontPage.Editor.Document">
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
<title>MD5</title>
</head>

<body>
<form>
<input type="button" id="t1" name="t1" value="test" onclick="md5_vm_test()">
<input type="text" id="txt" name="txt" value="a" size="20">
</form>
<SCRIPT LANGUAGE="JavaScript">
/*
 * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message
 * Digest Algorithm, as defined in RFC 1321.
 * Version 2.1 Copyright (C) Paul Johnston 1999 - 2002.
 * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
 * Distributed under the BSD License
 * See http://pajhome.org.uk/crypt/md5 for more info.
 */

/*
 * Configurable variables. You may need to tweak these to be compatible with
 * the server-side, but the defaults work in most cases.
 */
var hexcase = 0;  /* hex output format. 0 - lowercase; 1 - uppercase        */
var b64pad  = ""; /* base-64 pad character. "=" for strict RFC compliance   */
var chrsz   = 8;  /* bits per input character. 8 - ASCII; 16 - Unicode      */

/*
 * These are the functions you'll usually want to call
 * They take string arguments and return either hex or base-64 encoded strings
 */
function hex_md5(s){ return binl2hex(core_md5(str2binl(s), s.length * chrsz));}
function b64_md5(s){ return binl2b64(core_md5(str2binl(s), s.length * chrsz));}
function str_md5(s){ return binl2str(core_md5(str2binl(s), s.length * chrsz));}
function hex_hmac_md5(key, data) { return binl2hex(core_hmac_md5(key, data)); }
function b64_hmac_md5(key, data) { return binl2b64(core_hmac_md5(key, data)); }
function str_hmac_md5(key, data) { return binl2str(core_hmac_md5(key, data)); }

/*
 * Perform a simple self-test to see if the VM is working
 */
function md5_vm_test()
{
    var tt = md5("1");
    alert(tt);
}
function md5(s){
    return hex_md5(s);
}

/*
 * Calculate the MD5 of an array of little-endian words, and a bit length
 */
function core_md5(x, len)
{
  /* append padding */
  x[len >> 5] |= 0x80 << ((len) % 32);
  x[(((len + 64) >>> 9) << 4) + 14] = len;

  var a =  1732584193;
  var b = -271733879;
  var c = -1732584194;
  var d =  271733878;

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

    a = md5_ff(a, b, c, d, x[i+ 0], 7 , -680876936);
    d = md5_ff(d, a, b, c, x[i+ 1], 12, -389564586);
    c = md5_ff(c, d, a, b, x[i+ 2], 17,  606105819);
    b = md5_ff(b, c, d, a, x[i+ 3], 22, -1044525330);
    a = md5_ff(a, b, c, d, x[i+ 4], 7 , -176418897);
    d = md5_ff(d, a, b, c, x[i+ 5], 12,  1200080426);
    c = md5_ff(c, d, a, b, x[i+ 6], 17, -1473231341);
    b = md5_ff(b, c, d, a, x[i+ 7], 22, -45705983);
    a = md5_ff(a, b, c, d, x[i+ 8], 7 ,  1770035416);
    d = md5_ff(d, a, b, c, x[i+ 9], 12, -1958414417);
    c = md5_ff(c, d, a, b, x[i+10], 17, -42063);
    b = md5_ff(b, c, d, a, x[i+11], 22, -1990404162);
    a = md5_ff(a, b, c, d, x[i+12], 7 ,  1804603682);
    d = md5_ff(d, a, b, c, x[i+13], 12, -40341101);
    c = md5_ff(c, d, a, b, x[i+14], 17, -1502002290);
    b = md5_ff(b, c, d, a, x[i+15], 22,  1236535329);

    a = md5_gg(a, b, c, d, x[i+ 1], 5 , -165796510);
    d = md5_gg(d, a, b, c, x[i+ 6], 9 , -1069501632);
    c = md5_gg(c, d, a, b, x[i+11], 14,  643717713);
    b = md5_gg(b, c, d, a, x[i+ 0], 20, -373897302);
    a = md5_gg(a, b, c, d, x[i+ 5], 5 , -701558691);
    d = md5_gg(d, a, b, c, x[i+10], 9 ,  38016083);
    c = md5_gg(c, d, a, b, x[i+15], 14, -660478335);
    b = md5_gg(b, c, d, a, x[i+ 4], 20, -405537848);
    a = md5_gg(a, b, c, d, x[i+ 9], 5 ,  568446438);
    d = md5_gg(d, a, b, c, x[i+14], 9 , -1019803690);
    c = md5_gg(c, d, a, b, x[i+ 3], 14, -187363961);
    b = md5_gg(b, c, d, a, x[i+ 8], 20,  1163531501);
    a = md5_gg(a, b, c, d, x[i+13], 5 , -1444681467);
    d = md5_gg(d, a, b, c, x[i+ 2], 9 , -51403784);
    c = md5_gg(c, d, a, b, x[i+ 7], 14,  1735328473);
    b = md5_gg(b, c, d, a, x[i+12], 20, -1926607734);

    a = md5_hh(a, b, c, d, x[i+ 5], 4 , -378558);
    d = md5_hh(d, a, b, c, x[i+ 8], 11, -2022574463);
    c = md5_hh(c, d, a, b, x[i+11], 16,  1839030562);
    b = md5_hh(b, c, d, a, x[i+14], 23, -35309556);
    a = md5_hh(a, b, c, d, x[i+ 1], 4 , -1530992060);
    d = md5_hh(d, a, b, c, x[i+ 4], 11,  1272893353);
    c = md5_hh(c, d, a, b, x[i+ 7], 16, -155497632);
    b = md5_hh(b, c, d, a, x[i+10], 23, -1094730640);
    a = md5_hh(a, b, c, d, x[i+13], 4 ,  681279174);
    d = md5_hh(d, a, b, c, x[i+ 0], 11, -358537222);
    c = md5_hh(c, d, a, b, x[i+ 3], 16, -722521979);
    b = md5_hh(b, c, d, a, x[i+ 6], 23,  76029189);
    a = md5_hh(a, b, c, d, x[i+ 9], 4 , -640364487);
    d = md5_hh(d, a, b, c, x[i+12], 11, -421815835);
    c = md5_hh(c, d, a, b, x[i+15], 16,  530742520);
    b = md5_hh(b, c, d, a, x[i+ 2], 23, -995338651);

    a = md5_ii(a, b, c, d, x[i+ 0], 6 , -198630844);
    d = md5_ii(d, a, b, c, x[i+ 7], 10,  1126891415);
    c = md5_ii(c, d, a, b, x[i+14], 15, -1416354905);
    b = md5_ii(b, c, d, a, x[i+ 5], 21, -57434055);
    a = md5_ii(a, b, c, d, x[i+12], 6 ,  1700485571);
    d = md5_ii(d, a, b, c, x[i+ 3], 10, -1894986606);
    c = md5_ii(c, d, a, b, x[i+10], 15, -1051523);
    b = md5_ii(b, c, d, a, x[i+ 1], 21, -2054922799);
    a = md5_ii(a, b, c, d, x[i+ 8], 6 ,  1873313359);
    d = md5_ii(d, a, b, c, x[i+15], 10, -30611744);
    c = md5_ii(c, d, a, b, x[i+ 6], 15, -1560198380);
    b = md5_ii(b, c, d, a, x[i+13], 21,  1309151649);
    a = md5_ii(a, b, c, d, x[i+ 4], 6 , -145523070);
    d = md5_ii(d, a, b, c, x[i+11], 10, -1120210379);
    c = md5_ii(c, d, a, b, x[i+ 2], 15,  718787259);
    b = md5_ii(b, c, d, a, x[i+ 9], 21, -343485551);

    a = safe_add(a, olda);
    b = safe_add(b, oldb);
    c = safe_add(c, oldc);
    d = safe_add(d, oldd);
  }
  return Array(a, b, c, d);

}

/*
 * These functions implement the four basic operations the algorithm uses.
 */
function md5_cmn(q, a, b, x, s, t)
{
  return safe_add(bit_rol(safe_add(safe_add(a, q), safe_add(x, t)), s),b);
}
function md5_ff(a, b, c, d, x, s, t)
{
  return md5_cmn((b & c) | ((~b) & d), a, b, x, s, t);
}
function md5_gg(a, b, c, d, x, s, t)
{
  return md5_cmn((b & d) | (c & (~d)), a, b, x, s, t);
}
function md5_hh(a, b, c, d, x, s, t)
{
  return md5_cmn(b ^ c ^ d, a, b, x, s, t);
}
function md5_ii(a, b, c, d, x, s, t)
{
  return md5_cmn(c ^ (b | (~d)), a, b, x, s, t);
}

/*
 * Calculate the HMAC-MD5, of a key and some data
 */
function core_hmac_md5(key, data)
{
  var bkey = str2binl(key);
  if(bkey.length > 16) bkey = core_md5(bkey, key.length * chrsz);

  var ipad = Array(16), opad = Array(16);
  for(var i = 0; i < 16; i++)
  {
    ipad[i] = bkey[i] ^ 0x36363636;
    opad[i] = bkey[i] ^ 0x5C5C5C5C;
  }

  var hash = core_md5(ipad.concat(str2binl(data)), 512 + data.length * chrsz);
  return core_md5(opad.concat(hash), 512 + 128);
}

/*
 * Add integers, wrapping at 2^32. This uses 16-bit operations internally
 * to work around bugs in some JS interpreters.
 */
function safe_add(x, y)
{
  var lsw = (x & 0xFFFF) + (y & 0xFFFF);
  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
  return (msw << 16) | (lsw & 0xFFFF);
}

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

/*
 * Convert a string to an array of little-endian words
 * If chrsz is ASCII, characters >255 have their hi-byte silently ignored.
 */
function str2binl(str)
{
  var bin = Array();
  var mask = (1 << chrsz) - 1;
  for(var i = 0; i < str.length * chrsz; i += chrsz)
    bin[i>>5] |= (str.charCodeAt(i / chrsz) & mask) << (i%32);
  return bin;
}

/*
 * Convert an array of little-endian words to a string
 */
function binl2str(bin)
{
  var str = "";
  var mask = (1 << chrsz) - 1;
  for(var i = 0; i < bin.length * 32; i += chrsz)
    str += String.fromCharCode((bin[i>>5] >>> (i % 32)) & mask);
  return str;
}

/*
 * Convert an array of little-endian words to a hex string.
 */
function binl2hex(binarray)
{
  var hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";
  var str = "";
  for(var i = 0; i < binarray.length * 4; i++)
  {
    str += hex_tab.charAt((binarray[i>>2] >> ((i%4)*8+4)) & 0xF) +
           hex_tab.charAt((binarray[i>>2] >> ((i%4)*8  )) & 0xF);
  }
  return str;
}

/*
 * Convert an array of little-endian words to a base-64 string
 */
function binl2b64(binarray)
{
  var tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  var str = "";
  for(var i = 0; i < binarray.length * 4; i += 3)
  {
    var triplet = (((binarray[i   >> 2] >> 8 * ( i   %4)) & 0xFF) << 16)
                | (((binarray[i+1 >> 2] >> 8 * ((i+1)%4)) & 0xFF) << 8 )
                |  ((binarray[i+2 >> 2] >> 8 * ((i+2)%4)) & 0xFF);
    for(var j = 0; j < 4; j++)
    {
      if(i * 8 + j * 6 > binarray.length * 32) str += b64pad;
      else str += tab.charAt((triplet >> 6*(3-j)) & 0x3F);
    }
  }
  return str;
}

</script>
</body>

</html>

C#版

代码如下:

using System;
using System.Collections.Generic;
using System.Text;

namespace MYMD5
{
public class MD5
{
const int BITS_TO_A_BYTE = 8;
const int BYTES_TO_A_WORD = 4;
const int BITS_TO_A_WORD = 32;
private static long[] m_lOnBits = new long[30 + 1];
private static long[] m_l2Power = new long[30 + 1];

private static long LShift(long lValue, long iShiftBits)
{
long LShift = 0;
if (iShiftBits == 0)
{
LShift = lValue;
return LShift;
}
else
{
if (iShiftBits == 31)
{
if (Convert.ToBoolean(lValue & 1))
{
LShift = 0x80000000;
}
else
{
LShift = 0;
}
return LShift;
}
else
{
if (iShiftBits < 0 || iShiftBits > 31)
{
// Err.Raise 6;
}
}
}

if (Convert.ToBoolean((lValue & m_l2Power[31 - iShiftBits])))
{
LShift = ((lValue & m_lOnBits[31 - (iShiftBits + 1)]) * m_l2Power[iShiftBits]) | 0x80000000;
}
else
{
LShift = ((lValue & m_lOnBits[31 - iShiftBits]) * m_l2Power[iShiftBits]);
}

return LShift;
}

private static long RShift(long lValue, long iShiftBits)
{
long RShift = 0;
if (iShiftBits == 0)
{
RShift = lValue;
return RShift;
}
else
{
if (iShiftBits == 31)
{
if (Convert.ToBoolean(lValue & 0x80000000))
{
RShift = 1;
}
else
{
RShift = 0;
}
return RShift;
}
else
{
if (iShiftBits < 0 || iShiftBits > 31)
{
// Err.Raise 6;
}
}
}

RShift = (lValue & 0x7FFFFFFE) / m_l2Power[iShiftBits];

if (Convert.ToBoolean((lValue & 0x80000000)))
{
RShift = (RShift | (0x40000000 / m_l2Power[iShiftBits - 1]));
}

return RShift;
}

private static long RotateLeft(long lValue, long iShiftBits)
{
long RotateLeft = 0;
RotateLeft = LShift(lValue, iShiftBits) | RShift(lValue, (32 - iShiftBits));
return RotateLeft;
}

private static long AddUnsigned(long lX, long lY)
{
long AddUnsigned = 0;
long lX4 = 0;
long lY4 = 0;
long lX8 = 0;
long lY8 = 0;
long lResult = 0;

lX8 = lX & 0x80000000;
lY8 = lY & 0x80000000;
lX4 = lX & 0x40000000;
lY4 = lY & 0x40000000;

lResult = (lX & 0x3FFFFFFF) + (lY & 0x3FFFFFFF);
if (Convert.ToBoolean(lX4 & lY4))
{
lResult = lResult ^ 0x80000000 ^ lX8 ^ lY8;
}
else if (Convert.ToBoolean(lX4 | lY4))
{
if (Convert.ToBoolean(lResult & 0x40000000))
{
lResult = lResult ^ 0xC0000000 ^ lX8 ^ lY8;
}
else
{
lResult = lResult ^ 0x40000000 ^ lX8 ^ lY8;
}
}
else
{
lResult = lResult ^ lX8 ^ lY8;
}
AddUnsigned = lResult;
return AddUnsigned;
}

private static long md5_F(long x, long y, long z)
{
long md5_F = 0;
md5_F = (x & y) | ((~x) & z);
return md5_F;
}

private static long md5_G(long x, long y, long z)
{
long md5_G = 0;
md5_G = (x & z) | (y & (~z));
return md5_G;
}

private static long md5_H(long x, long y, long z)
{
long md5_H = 0;
md5_H = (x ^ y ^ z);
return md5_H;
}

private static long md5_I(long x, long y, long z)
{
long md5_I = 0;
md5_I = (y ^ (x | (~z)));
return md5_I;
}

private static void md5_FF(ref long a, long b, long c, long d, long x, long s, long ac)
{
a = AddUnsigned(a, AddUnsigned(AddUnsigned(md5_F(b, c, d), x), ac));
a = RotateLeft(a, s);
a = AddUnsigned(a, b);
}

private static void md5_GG(ref long a, long b, long c, long d, long x, long s, long ac)
{
a = AddUnsigned(a, AddUnsigned(AddUnsigned(md5_G(b, c, d), x), ac));
a = RotateLeft(a, s);
a = AddUnsigned(a, b);
}

private static void md5_HH(ref long a, long b, long c, long d, long x, long s, long ac)
{
a = AddUnsigned(a, AddUnsigned(AddUnsigned(md5_H(b, c, d), x), ac));
a = RotateLeft(a, s);
a = AddUnsigned(a, b);
}

private static void md5_II(ref long a, long b, long c, long d, long x, long s, long ac)
{
a = AddUnsigned(a, AddUnsigned(AddUnsigned(md5_I(b, c, d), x), ac));
a = RotateLeft(a, s);
a = AddUnsigned(a, b);
}

private static long[] ConvertToWordArray(string sMessage)
{
long[] ConvertToWordArray = null;
int lMessageLength = 0;
int lNumberOfWords = 0;
long[] lWordArray = null;
int lBytePosition = 0;
int lByteCount = 0;
int lWordCount = 0;

const int MODULUS_BITS = 512;
const int CONGRUENT_BITS = 448;

lMessageLength = sMessage.Length;
lNumberOfWords = (((lMessageLength + ((MODULUS_BITS - CONGRUENT_BITS) / BITS_TO_A_BYTE)) / (MODULUS_BITS / BITS_TO_A_BYTE)) + 1) * (MODULUS_BITS / BITS_TO_A_WORD);
lWordArray = new long[lNumberOfWords];

lBytePosition = 0;
lByteCount = 0;

while (lByteCount < lMessageLength)
{
lWordCount = lByteCount / BYTES_TO_A_WORD;
lBytePosition = (lByteCount % BYTES_TO_A_WORD) * BITS_TO_A_BYTE;
lWordArray[lWordCount] = lWordArray[lWordCount] | LShift(Convert.ToByte(sMessage.Substring(lByteCount, 1).ToCharArray()[0]), lBytePosition);
lByteCount = lByteCount + 1;
}

lWordCount = lByteCount / BYTES_TO_A_WORD;
lBytePosition = (lByteCount % BYTES_TO_A_WORD) * BITS_TO_A_BYTE;
lWordArray[lWordCount] = lWordArray[lWordCount] | LShift(0x80, lBytePosition);
lWordArray[lNumberOfWords - 2] = LShift(lMessageLength, 3);
lWordArray[lNumberOfWords - 1] = RShift(lMessageLength, 29);
ConvertToWordArray = lWordArray;

return ConvertToWordArray;
}

private static string WordToHex(long lValue)
{
string WordToHex = "";
long lByte = 0;
int lCount = 0;
for (lCount = 0; lCount <= 3; lCount++)
{
lByte = RShift(lValue, lCount * BITS_TO_A_BYTE) & m_lOnBits[BITS_TO_A_BYTE - 1];
WordToHex = WordToHex + (("0" + ToHex(lByte)).Substring(("0" + ToHex(lByte)).Length - 2));
}
return WordToHex;
}

private static string ToHex(long dec)
{
string strhex = "";
while (dec > 0)
{
strhex = tohex(dec % 16) + strhex;
dec = dec / 16;
}
return strhex;
}

private static string tohex(long hex)
{
string strhex = "";
switch (hex)
{
case 10: strhex = "a"; break;
case 11: strhex = "b"; break;
case 12: strhex = "c"; break;
case 13: strhex = "d"; break;
case 14: strhex = "e"; break;
case 15: strhex = "f"; break;
default: strhex = hex.ToString(); break;
}
return strhex;
}


public static string Encrypt(string sMessage, int stype)
{
string MD5 = "";

for (int i = 0; i <= 30; i++)
{
m_lOnBits[i] = Convert.ToInt64(Math.Pow(2, i + 1) - 1);
m_l2Power[i] = Convert.ToInt64(Math.Pow(2, i));
}

long[] x = null;
int k = 0;
long AA = 0;
long BB = 0;
long CC = 0;
long DD = 0;
long a = 0;
long b = 0;
long c = 0;
long d = 0;

const int S11 = 7;
const int S12 = 12;
const int S13 = 17;
const int S14 = 22;
const int S21 = 5;
const int S22 = 9;
const int S23 = 14;
const int S24 = 20;
const int S31 = 4;
const int S32 = 11;
const int S33 = 16;
const int S34 = 23;
const int S41 = 6;
const int S42 = 10;
const int S43 = 15;
const int S44 = 21;

x = ConvertToWordArray(sMessage);

a = 0x67452301;
b = 0xEFCDAB89;
c = 0x98BADCFE;
d = 0x10325476;

for (k = 0; k < x.Length; k += 16)
{
AA = a;
BB = b;
CC = c;
DD = d;

md5_FF(ref a, b, c, d, x[k + 0], S11, 0xD76AA478);
md5_FF(ref d, a, b, c, x[k + 1], S12, 0xE8C7B756);
md5_FF(ref c, d, a, b, x[k + 2], S13, 0x242070DB);
md5_FF(ref b, c, d, a, x[k + 3], S14, 0xC1BDCEEE);
md5_FF(ref a, b, c, d, x[k + 4], S11, 0xF57C0FAF);
md5_FF(ref d, a, b, c, x[k + 5], S12, 0x4787C62A);
md5_FF(ref c, d, a, b, x[k + 6], S13, 0xA8304613);
md5_FF(ref b, c, d, a, x[k + 7], S14, 0xFD469501);
md5_FF(ref a, b, c, d, x[k + 8], S11, 0x698098D8);
md5_FF(ref d, a, b, c, x[k + 9], S12, 0x8B44F7AF);
md5_FF(ref c, d, a, b, x[k + 10], S13, 0xFFFF5BB1);
md5_FF(ref b, c, d, a, x[k + 11], S14, 0x895CD7BE);
md5_FF(ref a, b, c, d, x[k + 12], S11, 0x6B901122);
md5_FF(ref d, a, b, c, x[k + 13], S12, 0xFD987193);
md5_FF(ref c, d, a, b, x[k + 14], S13, 0xA679438E);
md5_FF(ref b, c, d, a, x[k + 15], S14, 0x49B40821);
md5_GG(ref a, b, c, d, x[k + 1], S21, 0xF61E2562);
md5_GG(ref d, a, b, c, x[k + 6], S22, 0xC040B340);
md5_GG(ref c, d, a, b, x[k + 11], S23, 0x265E5A51);
md5_GG(ref b, c, d, a, x[k + 0], S24, 0xE9B6C7AA);
md5_GG(ref a, b, c, d, x[k + 5], S21, 0xD62F105D);
md5_GG(ref d, a, b, c, x[k + 10], S22, 0x2441453);
md5_GG(ref c, d, a, b, x[k + 15], S23, 0xD8A1E681);
md5_GG(ref b, c, d, a, x[k + 4], S24, 0xE7D3FBC8);
md5_GG(ref a, b, c, d, x[k + 9], S21, 0x21E1CDE6);
md5_GG(ref d, a, b, c, x[k + 14], S22, 0xC33707D6);
md5_GG(ref c, d, a, b, x[k + 3], S23, 0xF4D50D87);
md5_GG(ref b, c, d, a, x[k + 8], S24, 0x455A14ED);
md5_GG(ref a, b, c, d, x[k + 13], S21, 0xA9E3E905);
md5_GG(ref d, a, b, c, x[k + 2], S22, 0xFCEFA3F8);
md5_GG(ref c, d, a, b, x[k + 7], S23, 0x676F02D9);
md5_GG(ref b, c, d, a, x[k + 12], S24, 0x8D2A4C8A);
md5_HH(ref a, b, c, d, x[k + 5], S31, 0xFFFA3942);
md5_HH(ref d, a, b, c, x[k + 8], S32, 0x8771F681);
md5_HH(ref c, d, a, b, x[k + 11], S33, 0x6D9D6122);
md5_HH(ref b, c, d, a, x[k + 14], S34, 0xFDE5380C);
md5_HH(ref a, b, c, d, x[k + 1], S31, 0xA4BEEA44);
md5_HH(ref d, a, b, c, x[k + 4], S32, 0x4BDECFA9);
md5_HH(ref c, d, a, b, x[k + 7], S33, 0xF6BB4B60);
md5_HH(ref b, c, d, a, x[k + 10], S34, 0xBEBFBC70);
md5_HH(ref a, b, c, d, x[k + 13], S31, 0x289B7EC6);
md5_HH(ref d, a, b, c, x[k + 0], S32, 0xEAA127FA);
md5_HH(ref c, d, a, b, x[k + 3], S33, 0xD4EF3085);
md5_HH(ref b, c, d, a, x[k + 6], S34, 0x4881D05);
md5_HH(ref a, b, c, d, x[k + 9], S31, 0xD9D4D039);
md5_HH(ref d, a, b, c, x[k + 12], S32, 0xE6DB99E5);
md5_HH(ref c, d, a, b, x[k + 15], S33, 0x1FA27CF8);
md5_HH(ref b, c, d, a, x[k + 2], S34, 0xC4AC5665);
md5_II(ref a, b, c, d, x[k + 0], S41, 0xF4292244);
md5_II(ref d, a, b, c, x[k + 7], S42, 0x432AFF97);
md5_II(ref c, d, a, b, x[k + 14], S43, 0xAB9423A7);
md5_II(ref b, c, d, a, x[k + 5], S44, 0xFC93A039);
md5_II(ref a, b, c, d, x[k + 12], S41, 0x655B59C3);
md5_II(ref d, a, b, c, x[k + 3], S42, 0x8F0CCC92);
md5_II(ref c, d, a, b, x[k + 10], S43, 0xFFEFF47D);
md5_II(ref b, c, d, a, x[k + 1], S44, 0x85845DD1);
md5_II(ref a, b, c, d, x[k + 8], S41, 0x6FA87E4F);
md5_II(ref d, a, b, c, x[k + 15], S42, 0xFE2CE6E0);
md5_II(ref c, d, a, b, x[k + 6], S43, 0xA3014314);
md5_II(ref b, c, d, a, x[k + 13], S44, 0x4E0811A1);
md5_II(ref a, b, c, d, x[k + 4], S41, 0xF7537E82);
md5_II(ref d, a, b, c, x[k + 11], S42, 0xBD3AF235);
md5_II(ref c, d, a, b, x[k + 2], S43, 0x2AD7D2BB);
md5_II(ref b, c, d, a, x[k + 9], S44, 0xEB86D391);

a = AddUnsigned(a, AA);
b = AddUnsigned(b, BB);
c = AddUnsigned(c, CC);
d = AddUnsigned(d, DD);
}

if (stype == 32)
{
MD5 = ((((WordToHex(a)) + (WordToHex(b))) + (WordToHex(c))) + (WordToHex(d))).ToLower();
}
else
{
MD5 = ((WordToHex(b)) + (WordToHex(c))).ToLower();
}
return MD5;
}
}
}

调用时，使用MD5.Encrypt(需要加密的string,加密类型16或者32)