有谁给一个JAVA调用MD5的例子呀？？？

Question

package net.wastl.webmail.misc;/*
 * $Header: /cvsroot/jwebmail/webmail/src/net/wastl/webmail/misc/MD5.java,v 1.1 2000/09/13 12:47:50 wastl Exp $
 *
 * MD5 in Java JDK Beta-2
 * written Santeri Paavolainen, Helsinki Finland 1996
 * (c) Santeri Paavolainen, Helsinki Finland 1996
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 * 
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the Free
 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 * 
 * See http://www.cs.hut.fi/~santtu/java/ for more information on this
 * class.
 * 
 * This is rather straight re-implementation of the reference implementation
 * given in RFC1321 by RSA.
 *
 * Passes MD5 test suite as defined in RFC1321.
 *
 *
 * This Java class has been derived from the RSA Data Security, Inc. MD5 
 * Message-Digest Algorithm and its reference implementation. 
 *
 *
 * $Log: MD5.java,v $
 * Revision 1.1  2000/09/13 12:47:50  wastl
 * *** empty log message ***
 *
 * Revision 1.5  1996/12/12 10:47:02  santtu
 * Changed GPL to LGPL
 *
 * Revision 1.4  1996/12/12 10:30:02  santtu
 * Some typos, State -> MD5State etc.
 *
 * Revision 1.3  1996/04/15 07:28:09  santtu
 * Added GPL statemets, and RSA derivate stametemetsnnts.
 *
 * Revision 1.2  1996/03/04 08:05:48  santtu
 * Added offsets to Update method
 *
 * Revision 1.1  1996/01/07 20:51:59  santtu
 * Initial revision
 *
 */

Answer 1

/**
 * Contains internal state of the MD5 class
 */class MD5State {
  /**
   * 128-byte state 
   */
  int state[];  /**
   * 64-bit character count (could be true Java long?)
   */
  int count[];  /**
   * 64-byte buffer (512 bits) for storing to-be-hashed characters
   */
  byte buffer[];  public MD5State() {
    buffer = new byte[64];
    count = new int[2];
    state = new int[4];
    
    state[0] = 0x67452301;
    state[1] = 0xefcdab89;
    state[2] = 0x98badcfe;
    state[3] = 0x10325476;    count[0] = count[1] = 0;
  }  /** Create this State as a copy of another state */
  public MD5State (MD5State from) {
    this();    int i;    for (i = 0; i < buffer.length; i++)
      this.buffer[i] = from.buffer[i];
    
    for (i = 0; i < state.length; i++)
      this.state[i] = from.state[i];    for (i = 0; i < count.length; i++)
      this.count[i] = from.count[i];
  }
}

Answer 2

/**
 * Implementation of RSA's MD5 hash generator
 *
 * @version $Revision: 1.1 $
 * @author Santeri Paavolainen <[email protected]>
 */public class MD5 {
  /**
   * MD5 state
   */
  MD5State state;
 
  /**
   * If Final() has been called, finals is set to the current finals
   * state. Any Update() causes this to be set to null.
   */
  MD5State  finals;  /** 
   * Padding for Final()
   */
  static byte padding[] = {
    (byte) 0x80, 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
  };  /**
   * Initialize MD5 internal state (object can be reused just by
   * calling Init() after every Final()
   */
  public synchronized void Init () {
    state = new MD5State();
    finals = null;
  }  /**
   * Class constructor
   */
  public MD5 () {
    this.Init();
  }  /**
   * Initialize class, and update hash with ob.toString()
   *
   * @param ob Object, ob.toString() is used to update hash
   * after initialization
   */
  public MD5 (Object ob) {
    this();
    Update(ob.toString());
  }  private int rotate_left (int x, int n) {
    return (x << n) | (x >>> (32 - n));
  }  /* I wonder how many loops and hoops you'll have to go through to
     get unsigned add for longs in java */  private int uadd (int a, int b) {
    long aa, bb;
    aa = ((long) a) & 0xffffffffL;
    bb = ((long) b) & 0xffffffffL;
    
    aa += bb;    return (int) (aa & 0xffffffffL);
  }  private int uadd (int a, int b, int c) {
    return uadd(uadd(a, b), c);
  }  private int uadd (int a, int b, int c, int d) {
    return uadd(uadd(a, b, c), d);
  }  private int FF (int a, int b, int c, int d, int x, int s, int ac) {
    a = uadd(a, ((b & c) | (~b & d)), x, ac);
    return uadd(rotate_left(a, s), b);
  }  private int GG (int a, int b, int c, int d, int x, int s, int ac) {
    a = uadd(a, ((b & d) | (c & ~d)), x, ac);
    return uadd(rotate_left(a, s), b);
  }  private int HH (int a, int b, int c, int d, int x, int s, int ac) { 
    a = uadd(a, (b ^ c ^ d), x, ac);
    return uadd(rotate_left(a, s) , b);
  }  private int II (int a, int b, int c, int d, int x, int s, int ac) {  
    a = uadd(a, (c ^ (b | ~d)), x, ac);
    return uadd(rotate_left(a, s), b);
  }  private int[] Decode (byte buffer[], int len, int shift) {
    int out[];
    int  i, j;    out = new int[16];    for (i = j = 0; j < len; i++, j += 4) {
      out[i] = ((int) (buffer[j + shift] & 0xff)) | 
(((int) (buffer[j + 1 + shift] & 0xff)) << 8) |
(((int) (buffer[j + 2 + shift] & 0xff)) << 16) | 
(((int) (buffer[j + 3 + shift] & 0xff)) << 24);/*      System.out.println("out[" + i + "] = \t" +
 ((int) buffer[j + 0 + shift] & 0xff) + "\t|\t" +
 ((int) buffer[j + 1 + shift] & 0xff) + "\t|\t" +
 ((int) buffer[j + 2 + shift] & 0xff) + "\t|\t" +
 ((int) buffer[j + 3 + shift] & 0xff));*/
    }
    
    return out;
  }  private void Transform (MD5State state, byte buffer[], int shift) {
    int
      a = state.state[0],
      b = state.state[1],
      c = state.state[2],
      d = state.state[3],
      x[];    x = Decode(buffer, 64, shift);
       
    /* Round 1 */
    a = FF (a, b, c, d, x[ 0],   7, 0xd76aa478); /* 1 */
    d = FF (d, a, b, c, x[ 1],  12, 0xe8c7b756); /* 2 */
    c = FF (c, d, a, b, x[ 2],  17, 0x242070db); /* 3 */
    b = FF (b, c, d, a, x[ 3],  22, 0xc1bdceee); /* 4 */
    a = FF (a, b, c, d, x[ 4],   7, 0xf57c0faf); /* 5 */
    d = FF (d, a, b, c, x[ 5],  12, 0x4787c62a); /* 6 */
    c = FF (c, d, a, b, x[ 6],  17, 0xa8304613); /* 7 */
    b = FF (b, c, d, a, x[ 7],  22, 0xfd469501); /* 8 */
    a = FF (a, b, c, d, x[ 8],   7, 0x698098d8); /* 9 */
    d = FF (d, a, b, c, x[ 9],  12, 0x8b44f7af); /* 10 */
    c = FF (c, d, a, b, x[10],  17, 0xffff5bb1); /* 11 */
    b = FF (b, c, d, a, x[11],  22, 0x895cd7be); /* 12 */
    a = FF (a, b, c, d, x[12],   7, 0x6b901122); /* 13 */
    d = FF (d, a, b, c, x[13],  12, 0xfd987193); /* 14 */
    c = FF (c, d, a, b, x[14],  17, 0xa679438e); /* 15 */
    b = FF (b, c, d, a, x[15],  22, 0x49b40821); /* 16 */    /* Round 2 */
    a = GG (a, b, c, d, x[ 1],   5, 0xf61e2562); /* 17 */
    d = GG (d, a, b, c, x[ 6],   9, 0xc040b340); /* 18 */
    c = GG (c, d, a, b, x[11],  14, 0x265e5a51); /* 19 */
    b = GG (b, c, d, a, x[ 0],  20, 0xe9b6c7aa); /* 20 */
    a = GG (a, b, c, d, x[ 5],   5, 0xd62f105d); /* 21 */
    d = GG (d, a, b, c, x[10],   9,  0x2441453); /* 22 */
    c = GG (c, d, a, b, x[15],  14, 0xd8a1e681); /* 23 */
    b = GG (b, c, d, a, x[ 4],  20, 0xe7d3fbc8); /* 24 */
    a = GG (a, b, c, d, x[ 9],   5, 0x21e1cde6); /* 25 */
    d = GG (d, a, b, c, x[14],   9, 0xc33707d6); /* 26 */
    c = GG (c, d, a, b, x[ 3],  14, 0xf4d50d87); /* 27 */
    b = GG (b, c, d, a, x[ 8],  20, 0x455a14ed); /* 28 */
    a = GG (a, b, c, d, x[13],   5, 0xa9e3e905); /* 29 */
    d = GG (d, a, b, c, x[ 2],   9, 0xfcefa3f8); /* 30 */
    c = GG (c, d, a, b, x[ 7],  14, 0x676f02d9); /* 31 */
    b = GG (b, c, d, a, x[12],  20, 0x8d2a4c8a); /* 32 */    /* Round 3 */
    a = HH (a, b, c, d, x[ 5],   4, 0xfffa3942); /* 33 */
    d = HH (d, a, b, c, x[ 8],  11, 0x8771f681); /* 34 */
    c = HH (c, d, a, b, x[11],  16, 0x6d9d6122); /* 35 */
    b = HH (b, c, d, a, x[14],  23, 0xfde5380c); /* 36 */
    a = HH (a, b, c, d, x[ 1],   4, 0xa4beea44); /* 37 */
    d = HH (d, a, b, c, x[ 4],  11, 0x4bdecfa9); /* 38 */
    c = HH (c, d, a, b, x[ 7],  16, 0xf6bb4b60); /* 39 */
    b = HH (b, c, d, a, x[10],  23, 0xbebfbc70); /* 40 */
    a = HH (a, b, c, d, x[13],   4, 0x289b7ec6); /* 41 */
    d = HH (d, a, b, c, x[ 0],  11, 0xeaa127fa); /* 42 */
    c = HH (c, d, a, b, x[ 3],  16, 0xd4ef3085); /* 43 */
    b = HH (b, c, d, a, x[ 6],  23,  0x4881d05); /* 44 */
    a = HH (a, b, c, d, x[ 9],   4, 0xd9d4d039); /* 45 */
    d = HH (d, a, b, c, x[12],  11, 0xe6db99e5); /* 46 */
    c = HH (c, d, a, b, x[15],  16, 0x1fa27cf8); /* 47 */
    b = HH (b, c, d, a, x[ 2],  23, 0xc4ac5665); /* 48 */    /* Round 4 */
    a = II (a, b, c, d, x[ 0],   6, 0xf4292244); /* 49 */
    d = II (d, a, b, c, x[ 7],  10, 0x432aff97); /* 50 */
    c = II (c, d, a, b, x[14],  15, 0xab9423a7); /* 51 */
    b = II (b, c, d, a, x[ 5],  21, 0xfc93a039); /* 52 */
    a = II (a, b, c, d, x[12],   6, 0x655b59c3); /* 53 */
    d = II (d, a, b, c, x[ 3],  10, 0x8f0ccc92); /* 54 */
    c = II (c, d, a, b, x[10],  15, 0xffeff47d); /* 55 */
    b = II (b, c, d, a, x[ 1],  21, 0x85845dd1); /* 56 */
    a = II (a, b, c, d, x[ 8],   6, 0x6fa87e4f); /* 57 */
    d = II (d, a, b, c, x[15],  10, 0xfe2ce6e0); /* 58 */
    c = II (c, d, a, b, x[ 6],  15, 0xa3014314); /* 59 */
    b = II (b, c, d, a, x[13],  21, 0x4e0811a1); /* 60 */
    a = II (a, b, c, d, x[ 4],   6, 0xf7537e82); /* 61 */
    d = II (d, a, b, c, x[11],  10, 0xbd3af235); /* 62 */
    c = II (c, d, a, b, x[ 2],  15, 0x2ad7d2bb); /* 63 */
    b = II (b, c, d, a, x[ 9],  21, 0xeb86d391); /* 64 */    state.state[0] += a;
    state.state[1] += b;
    state.state[2] += c;
    state.state[3] += d;
  }

Answer 3

可以去这里看一看，有完整的演示代码，绝对实用：
http://www.aslike.net

Answer 4

使用MessageDigest
(1)
public class test
{
    private static final char[] ENCODE_TABLE = new char[]{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
    
    private static String toHexString(byte[] bytes)
    {
        StringBuffer result = new StringBuffer();
        for(int i=0; i<bytes.length; i++)
        {
            byte c = bytes[i];
            if((c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
                result.append((char) c);
            else
            {
                result.append('%');
                result.append(ENCODE_TABLE[(c >> 4) & 0x0f]);
                result.append(ENCODE_TABLE[c & 0x0f]);
            }
        }
        return result.toString();
    }    public static void main(String args[])
    {
        String info=args[0];
        try
        {
            java.security.MessageDigest alg=java.security.MessageDigest.getInstance("MD5");
            alg.update(info.getBytes());
            byte[] digesta=alg.digest();
            System.out.println(toHextString(digesta.toString()));
        }catch(Exception e)
        {
            System.out.println(e);
        }
    }
}(2)
/*
**进行md5加密的类
*/public class MD5Encoder
{
public static void main(String args[])
{
String info=args[0];
try
{
java.security.MessageDigest alg=java.security.MessageDigest.getInstance("MD5");
alg.update(info.getBytes());
byte[] digesta=alg.digest();
String result="";
for(int i=0;i<digesta.length;i++)
{
int m=digesta[i];
if(m<0)
{
m+=256;//如果是负数就取模
}
if(m<16)
{
result+="0";//如果长度不够就加"0"
}
result=result+Integer.toString(m,16).toUpperCase()+"";
}
System.out.println(result);
}catch(Exception e)
{
System.out.println(e);
}
}
}