随笔 - 154  文章 - 60  trackbacks - 0
<2008年2月>
272829303112
3456789
10111213141516
17181920212223
2425262728291
2345678

声明:

该blog是为了收集资料,认识朋友,学习、提高技术,所以本blog的内容除非声明,否则一律为转载!!

感谢那些公开自己技术成果的高人们!!!

支持开源,尊重他人的劳动!!

常用链接

留言簿(3)

随笔分类(148)

随笔档案(143)

收藏夹(2)

其他

学习(技术)

观察思考(非技术)

搜索

  •  

最新评论

阅读排行榜

评论排行榜

             [精华] md5算法的java源代码!
            
                http://www.chinaunix.net 作者:ii  发表于:2003-08-19 02:57:15
           

                  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)) &amp;
                  0x0F) + hex_chr.charAt((num >;>; (j * 8)) &amp; 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&amp;0x7FFFFFFF) + (y&amp;0x7FFFFFFF)) ^
                  (x&amp;0x80000000) ^ (y&amp;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 &amp; c) | ((~b) &amp; 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 &amp; d) | (c &amp; (~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);
                    }

                  }

 


                   ii 回复于:2003-01-28 13:51:46

                  另:  一中国人写的md5 的javabean:

                  /************************************************
                  MD5 算法的Java Bean
                  @author:Topcat Tuppin
                  Last Modified:10,Mar,2001
                  *************************************************/
                  //package beartool;
                  import java.lang.reflect.*;
                  /*************************************************
                  md5 类实现了RSA Data Security, Inc.在提交给IETF
                  的RFC1321中的MD5 message-digest 算法。
                  *************************************************/

                  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取得的.
                  */
                          public String getMD5ofStr(String inbuf) {
                                  md5Init();
                                  md5Update(inbuf.getBytes(), inbuf.length());
                                  md5Final();
                                  digestHexStr = "";
                                  for (int i = 0; i < 16; i++) {
                                          digestHexStr += byteHEX(digest);
                                  }
                                  return digestHexStr;

                          }
                          // 这是MD5这个类的标准构造函数,JavaBean要求有一个public的并且没有参数的构造函数
                          public 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 &amp; y) | ((~x) &amp; z);

                          }
                          private long G(long x, long y, long z) {
                                  return (x &amp; z) | (y &amp; (~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) &amp; 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) &amp; 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 &amp; 0xffL);

                                          output[j + 1] = (byte)((input >;>;>;
                  8) &amp; 0xffL);
                                          output[j + 2] = (byte)((input >;>;>;
                  16) &amp; 0xffL);
                                          output[j + 3] = (byte)((input >;>;>;
                  24) &amp; 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 = 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 &amp; 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) &amp; 0X0F];
                                  ob[1] = Digit[ib &amp; 0X0F];
                                  String s = new String(ob);
                                  return s;
                          }

                          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(""));
                                  
                  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]));
                                  
                           
                          }

                  }

 

                   ii 回复于:2003-02-09 09:40:22

                  再次改人家的程序,来简化处理.

                  //    程序名为MMM.java
                  package md5;
                  import java.security.*; 

                  public class MMM { 

                  public String calcMD5(String str) { 
                  try { 
                  MessageDigest alga=MessageDigest.getInstance("MD5"); 
                  // MessageDigest alga=MessageDigest.getInstance("SHA-1"); 
                  alga.update(str.getBytes()); 
                  byte[] digesta=alga.digest(); 
                  return byte2hex(digesta);
                  }
                  catch (NoSuchAlgorithmException ex) 
                  { System.out.println("大哥,出错了!!"); }
                  return "NULL";
                   
                  }

                  public String byte2hex(byte[] b) {             //二行制转字符串 

                  String hs=""; 
                  String stmp=""; 
                  for (int n=0;n<b.length;n++) { 
                  stmp=(Integer.toHexString(b[n] &amp; 0XFF)); 
                  if (stmp.length()==1) hs=hs+"0"+stmp; 
                  else hs=hs+stmp; 
                  if (n<b.length-1) hs=hs+""; 
                  } 
                  // return hs.toUpperCase(); 
                  return hs;
                  } 

                  }


                  原文链接:http://bbs.chinaunix.net/viewthread.php?tid=8972
                  转载请注明作者名及原文出处

 

posted on 2008-02-13 11:16 lk 阅读(417) 评论(0)  编辑  收藏 所属分类: j2se

只有注册用户登录后才能发表评论。


网站导航: