MD5算法，希望高手解决 200 分在线等

hechenqingtian 2009-12-11 11:03:16

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加密。但是无法得到相同的结果，希望高手帮忙解决。本人在线等

...全文

277 20 打赏收藏转发到动态举报

写回复

用AI写文章

20 条回复

切换为时间正序

请发表友善的回复…

发表回复

itstudy123 2011-03-02

打赏
举报

MessageDigest md = MessageDigest.getInstance("md5"); // 返回实现指定算法

md.update(youp.getBytes()); // 取得你传进来的字符的字节

byte[] b = md.digest();

zys2419740 2009-12-11

打赏
举报

弄这个有什么用？真搞不懂，前段时间弄了下，觉得太没意思，你们老总让的还是你自己要弄？反正我不赞成这么做，没什么意义

phoenix_qiqi 2009-12-11

打赏
举报

mack

道光2008 2009-12-11

打赏
举报

讨论什么，测试下，能用就行啦嘛

jarvis_java 2009-12-11

打赏
举报

java 安全类里有查看API

shine333 2009-12-11

打赏
举报

[Quote=引用 10 楼 xuqi2850661 的回复:]
public class Encrypter {

public static String md5Encrypt(String s) throws Exception{
MessageDigest md5 = MessageDigest.getInstance("MD5");
sun.misc.BASE64Encoder baseEncoder = new sun.misc.BASE64Encoder();
return baseEncoder.encode(md5.digest(s.getBytes("utf-8")));
}
}

调用这个方法不就行了吗？
[/Quote]

这个是最简单的正确答案，我那个答案返回的是16进制表示的md5(也就是最常见的那种）。
不过，要注意的是JDK中所有sun开头的包，都是SUN自己实现的，不确保在新的版本中继续支持，或者会有不兼容情况，能避免使用尽量避免

shine333 2009-12-11

打赏
举报

本人不使用任何即时聊天工具

hechenqingtian 2009-12-11

打赏
举报

各位高手加我QQ 821865130 讨论

zl3450341 2009-12-11

打赏
举报

去看吧
http://blog.csdn.net/m_changgong/archive/2009/07/19/4361526.aspx

hechenqingtian 2009-12-11

打赏
举报

warison2008 加我QQ 821865130 我们讨论一下

xuqi2850661 2009-12-11

打赏
举报

public class Encrypter {

public static String md5Encrypt(String s) throws Exception{
MessageDigest md5 = MessageDigest.getInstance("MD5");
sun.misc.BASE64Encoder baseEncoder = new sun.misc.BASE64Encoder();
return baseEncoder.encode(md5.digest(s.getBytes("utf-8")));
}
}

调用这个方法不就行了吗？

shine333 2009-12-11

打赏
举报

使用MessageDigest, 重点是

    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();

  }



}

道光2008 2009-12-11

打赏
举报

内容太长，发了两次，100分给我，记得

道光2008 2009-12-11

打赏
举报

private final void update (byte input[], int len) {
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)) ;
}

}

道光2008 2009-12-11

打赏
举报

import java.io.ByteArrayInputStream;
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;
}

zfangla 2009-12-11

打赏
举报

这代码可用的, 刚好我现在也要做MD5加密, 测试都通过了的, 还有想匹配的解密函数.

zfangla 2009-12-11

打赏
举报

相关私有函数:

static private final String itoa64 = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";

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

hechenqingtian 2009-12-11

打赏
举报

呵呵兄弟能否帮忙解决问题呢，不要随便贴段代码啥。我相信你也不会看这段代码

zfangla 2009-12-11

打赏
举报

这是完全用JAVA实现的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();
}

　Java编写的山寨QQ，多人聊天+用户在线，程序分服务端和客户端，典型C/S结构，　当用户发送第一次请求的时候，验证用户登录，创建一个该qq号和服务器端保持通讯连接得线程，启动该通讯线程，通讯完毕，关闭Scoket...

Java编写的山寨QQ，多人聊天+用户在线 21个目标文件摘要:JAVA源码,媒体网络,山寨QQ,Java聊天程序 Java编写的山寨QQ，多人聊天+用户在线，程序分服务端和客户端，典型C/S结构，当用户发送第一次请求的时候，验证...

短短半年的时间，数字签名加密算法的两座大厦先后倒塌——MD5和SHA-1这两种应用最为广泛的数字签名加密算法都被山东大学的王小云教授破解，业界为这次数字签名遭遇的“9.11”事件感到震惊的同时，也开始对今天广泛...

在8个月以前，人们还以为在全球广泛应用的MD5和SHA-1都是值得信任的安全的数字签名算法；8个月后的今天，曾经值得信赖的数字签名体系，令人震惊的两次“碰撞”将这两种应用最广的签名加密算法都逼上了绝

md5的全称是message-digest algorithm 5（信息-摘要算法），在90年代初由mit laboratory for computer science和rsa data security inc的ronald l. rivest开发出来，经md2、md3和md4发展而来。它的作用是让大容量...