protected string EncodePwd(string NoEnPwd)
{
MD5CryptoServiceProvider MD5CSP = new MD5CryptoServiceProvider();
byte[] MD5Source = System.Text.Encoding.UTF8.GetBytes(NoEnPwd);
byte[] MD5Out = MD5CSP.ComputeHash(MD5Source);
return Convert.ToBase64String(MD5Out);
}这个是用C#实现的加密算法，NoEnPwd 是要加密的内容。现在我需要用java 实现一样的加密效果，怎么实现我遇到的问题是，MD5CSP.ComputeHash(MD5Source); 这段代码在java 中怎么实现，不管用什么方法，只有能够实现就行。我之前是用的Spring 中的MD5加密。 但是无法得到相同的结果，希望高手帮忙解决。本人在线等
{
MD5CryptoServiceProvider MD5CSP = new MD5CryptoServiceProvider();
byte[] MD5Source = System.Text.Encoding.UTF8.GetBytes(NoEnPwd);
byte[] MD5Out = MD5CSP.ComputeHash(MD5Source);
return Convert.ToBase64String(MD5Out);
}这个是用C#实现的加密算法，NoEnPwd 是要加密的内容。现在我需要用java 实现一样的加密效果，怎么实现我遇到的问题是，MD5CSP.ComputeHash(MD5Source); 这段代码在java 中怎么实现，不管用什么方法，只有能够实现就行。我之前是用的Spring 中的MD5加密。 但是无法得到相同的结果，希望高手帮忙解决。本人在线等
static public final String crypt(String password, String salt, String magic)
{
byte finalState[];
long l;
/**
* Two MD5 hashes are used
*/
MessageDigest ctx, ctx1;
try
{
ctx = MessageDigest.getInstance("md5");
ctx1 = MessageDigest.getInstance("md5");
}
catch (NoSuchAlgorithmException ex)
{
return null;
}
/* Refine the Salt first */
/* If it starts with the magic string, then skip that */ if (salt.startsWith(magic))
{
salt = salt.substring(magic.length());
}
/* It stops at the first '$', max 8 chars */ if (salt.indexOf('$') != -1)
{
salt = salt.substring(0, salt.indexOf('$'));
}
if (salt.length() > 8)
{
salt = salt.substring(0, 8);
}
/**
* Transformation set #1:
* The password first, since that is what is most unknown
* Magic string
* Raw salt
*/
ctx.update(password.getBytes());
ctx.update(magic.getBytes());
ctx.update(salt.getBytes());
/* Then just as many characters of the MD5(pw,salt,pw) */ ctx1.update(password.getBytes());
ctx1.update(salt.getBytes());
ctx1.update(password.getBytes());
finalState = ctx1.digest(); // ctx1.Final();
for (int pl = password.length(); pl > 0; pl -= 16)
{
ctx.update(finalState, 0, pl > 16 ? 16 : pl);
}
/** the original code claimed that finalState was being cleared
to keep dangerous bits out of memory,
but doing this is also required in order to get the right output. */
clearbits(finalState);
/* Then something really weird... */ for (int i = password.length(); i != 0; i >>>= 1)
{
if ((i & 1) != 0)
{
ctx.update(finalState, 0, 1);
}
else
{
ctx.update(password.getBytes(), 0, 1);
}
}
finalState = ctx.digest();
/** and now, just to make sure things don't run too fast
* On a 60 Mhz Pentium this takes 34 msec, so you would
* need 30 seconds to build a 1000 entry dictionary...
* (The above timings from the C version)
*/
finalState = cryptSubSlowdown(finalState, password, salt);
if (null == finalState)
{
return null;
}
/* Now make the output string */ StringBuffer result = new StringBuffer();
result.append(magic);
result.append(salt);
result.append("$");
/**
* Build a 22 byte output string from the set: A-Za-z0-9./
*/
l = (bytes2u(finalState[0]) << 16) | (bytes2u(finalState[6]) << 8)
| bytes2u(finalState[12]);
result.append(to64(l, 4));
l = (bytes2u(finalState[1]) << 16) | (bytes2u(finalState[7]) << 8)
| bytes2u(finalState[13]);
result.append(to64(l, 4));
l = (bytes2u(finalState[2]) << 16) | (bytes2u(finalState[8]) << 8)
| bytes2u(finalState[14]);
result.append(to64(l, 4));
l = (bytes2u(finalState[3]) << 16) | (bytes2u(finalState[9]) << 8)
| bytes2u(finalState[15]);
result.append(to64(l, 4));
l = (bytes2u(finalState[4]) << 16) | (bytes2u(finalState[10]) << 8)
| bytes2u(finalState[5]);
result.append(to64(l, 4));
l = bytes2u(finalState[11]);
result.append(to64(l, 2));
/* Don't leave anything around in vm they could use. */
clearbits(finalState);
return result.toString();
}
/**
* convert an encoded unsigned byte value
* into a int with the unsigned value.
*/
static private final int bytes2u(byte inp)
{
return inp & 0xff;
}
static private final void clearbits(byte bits[])
{
for (int i = 0; i < bits.length; i++)
{
bits[i] = 0;
}
}
static private final String to64(long v, int size)
{
StringBuffer result = new StringBuffer();
while (--size >= 0)
{
result.append(itoa64.charAt((int) (v & 0x3f)));
v >>>= 6;
}
return result.toString();
} //加密算法的子流程
static private byte[] cryptSubSlowdown(byte finalState[],
String password, String salt)
{
MessageDigest ctx1 = null;
for (int i = 0; i < 1000; i++)
{
try
{
ctx1 = MessageDigest.getInstance("md5");
}
catch (NoSuchAlgorithmException e0)
{
return null;
}
if ((i & 1) != 0)
{
ctx1.update(password.getBytes());
}
else
{
ctx1.update(finalState, 0, 16);
}
if ((i % 3) != 0)
{
ctx1.update(salt.getBytes());
}
if ((i % 7) != 0)
{
ctx1.update(password.getBytes());
}
if ((i & 1) != 0)
{
ctx1.update(finalState, 0, 16);
}
else
{
ctx1.update(password.getBytes());
}
finalState = ctx1.digest(); // Final();
}
return finalState;
}
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintStream;
import java.io.UnsupportedEncodingException;
public class Md5 {
private static final int BUFFER_SIZE = 1024 ; private static final int S11 = 7 ;
private static final int S12 = 12 ;
private static final int S13 = 17 ;
private static final int S14 = 22 ;
private static final int S21 = 5 ;
private static final int S22 = 9 ;
private static final int S23 = 14 ;
private static final int S24 = 20 ;
private static final int S31 = 4 ;
private static final int S32 = 11 ;
private static final int S33 = 16 ;
private static final int S34 = 23 ;
private static final int S41 = 6 ;
private static final int S42 = 10 ;
private static final int S43 = 15 ;
private static final int S44 = 21 ; private static byte padding[] = {
(byte) 0x80, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0,
(byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0,
(byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0,
(byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0,
(byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0,
(byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0,
(byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0,
(byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0,
(byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0,
(byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0,
(byte) 0, (byte) 0, (byte) 0, (byte) 0
} ; private InputStream in = null ;
private boolean stringp = false ;
private int state[] = null ;
private long count = 0 ;
private byte buffer[] = null ;
private byte digest[] = null ; private static String stringify (byte buf[]) {
StringBuffer sb = new StringBuffer(2*buf.length) ;
for (int i = 0 ; i < buf.length; i++) {
int h = (buf[i] & 0xf0) >> 4 ;
int l = (buf[i] & 0x0f) ;
sb.append (new Character((char)((h>9) ? 'a'+h-10 : '0'+h))) ;
sb.append (new Character((char)((l>9) ? 'a'+l-10 : '0'+l))) ;
}
return sb.toString() ;
} private final int F(int x, int y, int z) {
return ((x & y) | ((~x) & z)) ;
} private final int G(int x, int y, int z) {
return ((x & z) | (y & (~z))) ;
} private final int H(int x, int y, int z) {
return (x ^ y ^ z) ;
} private final int I(int x, int y, int z) {
return (y ^ (x | (~z))) ;
} private final int rotate_left(int x, int n) {
return ((x << n) | (x >>> (32-n))) ;
} private final int FF(int a,int b,int c,int d,int x,int s,int ac) {
a += (F(b, c, d) + x + ac) ;
a = rotate_left(a, s) ;
a += b ;
return a ;
} private final int GG(int a,int b,int c,int d,int x,int s,int ac) {
a += (G(b, c, d) + x + ac) ;
a = rotate_left(a, s) ;
a += b ;
return a ;
} private final int HH(int a,int b,int c,int d,int x,int s,int ac) {
a += (H(b, c, d) + x + ac) ;
a = rotate_left(a, s) ;
a += b ;
return a ;
} private final int II(int a,int b,int c,int d,int x,int s,int ac) {
a += (I(b, c, d) + x + ac) ;
a = rotate_left(a, s) ;
a += b ;
return a;
} private final void decode (int output[], byte input[], int off, int len) {
int i = 0 ;
int j = 0 ;
for ( ; j < len; i++, j += 4) {
output[i] = (((int) (input[off+j]&0xff))
| (((int) (input[off+j+1] & 0xff)) << 8)
| (((int) (input[off+j+2] & 0xff)) << 16)
| (((int) (input[off+j+3] & 0xff)) << 24)) ;
}
} private final void transform (byte block[], int offset) {
int a = state[0] ;
int b = state[1] ;
int c = state[2] ;
int d = state[3] ;
int x[] = new int[16] ; decode (x, block, offset, 64);
/* Round 1 */
a = FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
d = FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
c = FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
b = FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
a = FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
d = FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
c = FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
b = FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
a = FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
d = FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
c = FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
b = FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
a = FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
d = FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
c = FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
b = FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
/* Round 2 */
a = GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
d = GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
c = GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
b = GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
a = GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
d = GG (d, a, b, c, x[10], S22, 0x2441453); /* 22 */
c = GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
b = GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
a = GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
d = GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
c = GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
b = GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
a = GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
d = GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
c = GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
b = GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */ /* Round 3 */
a = HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
d = HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
c = HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
b = HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
a = HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
d = HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
c = HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
b = HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
a = HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
d = HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
c = HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
b = HH (b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */
a = HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
d = HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
c = HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
b = HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */ /* Round 4 */
a = II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
d = II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
c = II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
b = II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
a = II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
d = II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
c = II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
b = II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
a = II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
d = II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
c = II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
b = II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
a = II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
d = II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
c = II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
b = II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */ state[0] += a;
state[1] += b;
state[2] += c;
state[3] += d;
}
int index = ((int) (count >> 3)) & 0x3f ;
count += (len << 3) ;
int partLen = 64 - index ;
int i = 0 ;
if ( len >= partLen ) {
System.arraycopy (input, 0, buffer, index, partLen) ;
transform (buffer, 0) ;
for (i = partLen ; i + 63 < len ; i+= 64)
transform (input, i) ;
index = 0 ;
} else {
i = 0 ;
}
System.arraycopy (input, i, buffer, index, len - i) ;
} private byte[] end () {
byte bits[] = new byte[8] ;
for (int i = 0 ; i < 8 ; i++)
bits[i] = (byte) ((count>>>(i*8)) & 0xff) ;
int index = ((int) (count >> 3)) & 0x3f ;
int padlen = (index < 56) ? (56 - index) : (120 - index) ;
update (padding, padlen) ;
update (bits, 8) ;
return encode(state, 16) ;
} // Encode the content.state array into 16 bytes array
private byte[] encode (int input[], int len) {
byte output[] = new byte[len] ;
int i = 0 ;
int j = 0 ;
for ( ; j < len ; i++, j+= 4) {
output[j] = (byte) ((input[i] ) & 0xff) ;
output[j+1] = (byte) ((input[i] >> 8 ) & 0xff) ;
output[j+2] = (byte) ((input[i] >> 16) & 0xff) ;
output[j+3] = (byte) ((input[i] >> 24) & 0xff) ;
}
return output ;
} /**
* Get the digest for our input stream.
* This method constructs the input stream digest, and return it, as a
* a String, following the MD5 (rfc1321) algorithm,
* @return An instance of String, giving the message digest.
* @exception IOException Thrown if the digestifier was unable to read the
* input stream.
*/ public byte[] getDigest ()
throws IOException
{
byte buffer[] = new byte[BUFFER_SIZE] ;
int got = -1 ; if ( digest != null )
return digest ;
while ((got = in.read(buffer)) > 0 )
update (buffer, got) ;
this.digest = end () ;
return digest ;
} /**
* Get the digest, for this string digestifier.
* This method doesn't throw any IOException, since it knows that the
* underlying stream ws built from a String.
*/ public byte[] processString () {
if ( ! stringp )
throw new RuntimeException (this.getClass().getName()
+ "[processString]"
+ " not a string.") ;
try {
return getDigest() ;
} catch (IOException ex) {
}
throw new RuntimeException (this.getClass().getName()
+ "[processString]"
+ ": implementation error.") ;
} /**
* Get the digest, as a proper string.
*/ public String getStringDigest() {
if ( digest == null )
throw new RuntimeException (this.getClass().getName()
+ "[getStringDigest]"
+ ": called before processing.") ;
return stringify (digest) ;
} /**
* Construct a digestifier for the given string.
* @param input The string to be digestified.
* @param encoding the encoding name used (such as UTF8)
*/ public Md5 (String input, String enc) {
byte bytes [] = null;
try {
bytes = input.getBytes (enc);
} catch(UnsupportedEncodingException e){
throw new RuntimeException("no "+enc+" encoding!!!");
}
this.stringp = true ;
this.in = new ByteArrayInputStream (bytes) ;
this.state = new int[4] ;
this.buffer = new byte[64] ;
this.count = 0 ;
state[0] = 0x67452301;
state[1] = 0xefcdab89;
state[2] = 0x98badcfe;
state[3] = 0x10325476;
} /**
* Construct a digestifier for the given string.
* @param input The string to be digestified.
*/ public Md5 (String input) {
this(input, "UTF8");
} /**
* Construct a digestifier for the given input stream.
* @param in The input stream to be digestified.
*/ public Md5 (InputStream in) {
this.stringp = false ;
this.in = in ;
this.state = new int[4] ;
this.buffer = new byte[64] ;
this.count = 0 ;
state[0] = 0x67452301;
state[1] = 0xefcdab89;
state[2] = 0x98badcfe;
state[3] = 0x10325476;
} public static void main (String args[])
throws IOException
{
if ( args.length != 1) {
System.out.println ("Md5 <file>") ;
System.exit (1) ;
}
Md5 md5 = new Md5 (new FileInputStream(new File(args[0]))) ;
byte b[]= md5.getDigest();
System.out.println (stringify(b)) ;
}}
byte[] bytes = ...;
MessageDigest md = MessageDigest.getInstance("MD5");
// 获得MD5信息摘要
byte[] md5Bytes = md.digest(bytes);import java.security.MessageDigest;/**
* MD5工具类。
*
* @author Michael J Chane
* @version $Revision: 1.2 $ $Date: 2009/08/30 08:52:57 $
*/
public final class MD5Util { /**
* 十六进制MD5编码长度
*/
private static final int HEX_DIGEST_LENGTH = 32; /**
* 十六进制字符
*/
private static final char[] HEX_CHAR = new char[] {
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd',
'e', 'f'
}; /**
* 不需要实例化
*/
private MD5Util() {
} /**
* 对指定的文本信息进行MD5摘要，并以十六进制格式返回。
*
* @param text
* 要进行MD5摘要的文本信息
* @return 十六进制的MD5摘要
* @throws Exception
* 如果处理中发生异常的话
*/
public static String hexDigest(String text) throws Exception {
return hexDigest(text.getBytes());
} /**
* 对指定的信息进行MD5摘要，并以十六进制格式返回。
*
* @param bytes
* 要进行MD5摘要的字节信息
* @return 十六进制的MD5摘要
* @throws Exception
* 如果处理中发生异常的话
*/
public static String hexDigest(byte[] bytes) throws Exception {
// 信息摘要器
MessageDigest md = MessageDigest.getInstance("MD5");
// 获得MD5信息摘要
byte[] md5Bytes = md.digest(bytes);
// 返回十六进制的MD5摘要
return toHexString(md5Bytes);
} /**
* 将MD5的字节码表现为十六进制编码。
*
* @param md5Bytes
* MD5的字节码
* @return 十六进制编码
*/
private static String toHexString(byte[] md5Bytes) {
StringBuilder buff = new StringBuilder(HEX_DIGEST_LENGTH);
for (byte b : md5Bytes) {
int unsignedByte = b & 0xFF;
int high = unsignedByte >> 4;
int low = unsignedByte & 0xF;
buff.append(HEX_CHAR[high]).append(HEX_CHAR[low]);
} return buff.toString();
}}
MessageDigest md5 = MessageDigest.getInstance("MD5");
sun.misc.BASE64Encoder baseEncoder = new sun.misc.BASE64Encoder();
return baseEncoder.encode(md5.digest(s.getBytes("utf-8")));
}
}调用这个方法不就行了吗？
http://blog.csdn.net/m_changgong/archive/2009/07/19/4361526.aspx
这个是最简单的正确答案，我那个答案返回的是16进制表示的md5(也就是最常见的那种）。
不过，要注意的是JDK中所有sun开头的包，都是SUN自己实现的，不确保在新的版本中继续支持，或者会有不兼容情况，能避免使用尽量避免
md.update(youp.getBytes()); // 取得你传进来的字符的字节
byte[] b = md.digest();