java MD5 16/32位算法

方法1：

private static void Md5(String plainText ) {

try {

MessageDigest md = MessageDigest.getInstance("MD5");

md.update(plainText.getBytes());

byte b[] = md.digest();

int i;

StringBuffer buf = new StringBuffer("");

for (int offset = 0; offset < b.length; offset++) {

i = b[offset];

if(i<0) i+= 256;

if(i<16)

buf.append("0");

buf.append(Integer.toHexString(i));

}

System.out.println("result: " + buf.toString());//32位的加密

System.out.println("result: " + buf.toString().substring(8,24));//16位的加密

} catch (NoSuchAlgorithmException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

- - - - - - - - - - - - - - - - - - - - -

Md5("12312312312312"); 结果:

result: ba56bab91016bcb37878e06c16e9e68f

= = = = = = = = = = = = = = = = = = = = = = = = = = =

方法2：

由于消息摘要唯一性和不可逆性的特点，所以不失为一种简单的常用的加密手段，比如你可以用md5来加密你的应用中的用户口令。

package test;
import java.security.MessageDigest;
/**
* <p>Title: </p>
* <p>Description: </p>
* <p>Copyright: Copyright (c) 2003</p>
* <p>Company: </p>
* @author unascribed
* @version 1.0
*/

public class StringUtil {

private final static String[] hexDigits = {
"0", "1", "2", "3", "4", "5", "6", "7",
"8", "9", "a", "b", "c", "d", "e", "f"};

/**
* 转换字节数组为16进制字串
* @param b 字节数组
* @return 16进制字串
*/

public static String byteArrayToHexString(byte[] b) {
StringBuffer resultSb = new StringBuffer();
for (int i = 0; i < b.length; i++) {
resultSb.append(byteToHexString(b[i]));
}
return resultSb.toString();
}

private static String byteToHexString(byte b) {
int n = b;
if (n < 0)
n = 256 + n;
int d1 = n / 16;
int d2 = n % 16;
return hexDigits[d1] + hexDigits[d2];
}

public static String MD5Encode(String origin) {
String resultString = null;

try {
resultString=new String(origin);
MessageDigest md = MessageDigest.getInstance("MD5");
resultString=byteArrayToHexString(md.digest(resultString.getBytes()));
}
catch (Exception ex) {

}
return resultString;
}

public static void main(String[] args){
System.err.println(MD5Encode("a"));
}
}

- - - - - - - - - - - - - - - - - - -

在RFC 1321中，给出了Test suite用来检验你的实现是否正确：

MD5 ("") = d41d8cd98f00b204e9800998ecf8427e

MD5 ("a") = 0cc175b9c0f1b6a831c399e269772661

MD5 ("abc") = 900150983cd24fb0d6963f7d28e17f72

MD5 ("message digest") = f96b697d7cb7938d525a2f31aaf161d0

MD5 ("abcdefghijklmnopqrstuvwxyz") = c3fcd3d76192e4007dfb496cca67e13b

参考资料:《java security handbook》 jamie jaworski

= = = = = = = = = = = = = = = = = = = = = = = = = = = = =

方法3

package util;

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

public class SecurityMD5 {

private final static String[] hexDigits = {

"0", "1", "2", "3", "4", "5", "6", "7",

"8", "9", "a", "b", "c", "d", "e", "f"};

private String byteArrayToHexString(byte[] b) {

StringBuffer resultSb = new StringBuffer();

for (int i = 0; i < b.length; i++) {

resultSb.append(byteToHexString(b[i]));

}

return resultSb.toString();

}

private String byteToHexString(byte b) {

int n = b;

if (n < 0)

n = 256 + n;

int d1 = n / 16;

int d2 = n % 16;

return hexDigits[d1] + hexDigits[d2];

}

public String MD5Encode(String password) throws NoSuchAlgorithmException {

MessageDigest md = MessageDigest.getInstance("MD5");

return byteArrayToHexString(md.digest(password.getBytes()));

}

}

其它的java代码调用：

// md5加密

SecurityMD5 md5 = new SecurityMD5();

String mdPwd = md5.MD5Encode(password);

-------------------------------

import java.security.*;

import java.security.spec.*;

class MD5_Test{

public final static String MD5(String s){

char hexDigits[] = {

´0´, ´1´, ´2´, ´3´, ´4´, ´5´, ´6´, ´7´, ´8´, ´9´, ´a´, ´b´, ´c´, ´d´,

´e´, ´f´};

try {

byte[] strTemp = s.getBytes();

MessageDigest mdTemp = MessageDigest.getInstance("MD5");

mdTemp.update(strTemp);

byte[] md = mdTemp.digest();

int j = md.length;

char str[] = new char[j * 2];

int k = 0;

for (int i = 0; i < j; i++) {

byte byte0 = md[i];

str[k++] = hexDigits[byte0 >>> 4 & 0xf];

str[k++] = hexDigits[byte0 & 0xf];

}

return new String(str);

}

catch (Exception e){

return null;

}

}

public static void main(String[] args){

//MD5_Test aa = new MD5_Test();

System.out.print(MD5_Test.MD5("XX"));

}

= = = = = = = = = = = = = = = = = = = = = = = = = = = = =

方法4

package org.school.util;

import java.security.MessageDigest;

/** *//**

*

*/

public class MD5 ...{

/** *//**

* Constructs the MD5 object and sets the string whose MD5 is to be

* computed.

*

* @param inStr

* the <code>String</code> whose MD5 is to be computed

*/

public MD5() ...{

}

/** *//**

* Computes the MD5 fingerprint of a string.

*

* @return the MD5 digest of the input <code>String</code>

*/

public static String compute(String inStr) ...{

// convert input String to a char[]

// convert that char[] to byte[]

// get the md5 digest as byte[]

// bit-wise AND that byte[] with 0xff

// prepend "0" to the output StringBuffer to make sure that we don't end

// up with

// something like "e21ff" instead of "e201ff"

MessageDigest md5=null;

try ...{

md5 = MessageDigest.getInstance("MD5");

} catch (Exception e) ...{

System.out.println(e.toString());

e.printStackTrace();

return "";

}

char[] charArray = inStr.toCharArray();

byte[] byteArray = new byte[charArray.length];

for (int i = 0; i < charArray.length; i++)

byteArray[i] = (byte) charArray[i];

byte[] md5Bytes = md5.digest(byteArray);

StringBuffer hexValue = new StringBuffer();

for (int i = 0; i < md5Bytes.length; i++) ...{

int val = ((int) md5Bytes[i]) & 0xff;

if (val < 16)

hexValue.append("0");

hexValue.append(Integer.toHexString(val));

}

return hexValue.toString();

}

}

= = = = = = = = = = = = = = = = = = = = = = = = = = = = =

方法5

package util;

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

public class SecurityMD5 {

private final static String[] hexDigits = {

"0", "1", "2", "3", "4", "5", "6", "7",

"8", "9", "a", "b", "c", "d", "e", "f"};

private String byteArrayToHexString(byte[] b) {

StringBuffer resultSb = new StringBuffer();

for (int i = 0; i < b.length; i++) {

resultSb.append(byteToHexString(b[i]));

}

return resultSb.toString();

}

private String byteToHexString(byte b) {

int n = b;

if (n < 0)

n = 256 + n;

int d1 = n / 16;

int d2 = n % 16;

return hexDigits[d1] + hexDigits[d2];

}

public String MD5Encode(String password) throws NoSuchAlgorithmException {

MessageDigest md = MessageDigest.getInstance("MD5");

return byteArrayToHexString(md.digest(password.getBytes()));

}

}

其它的java代码调用：

// md5加密

SecurityMD5 md5 = new SecurityMD5();

String mdPwd = md5.MD5Encode(password);

-------------------------------

import java.security.*;

import java.security.spec.*;

class MD5_Test{

public final static String MD5(String s){

char hexDigits[] = {

´0´, ´1´, ´2´, ´3´, ´4´, ´5´, ´6´, ´7´, ´8´, ´9´, ´a´, ´b´, ´c´, ´d´,

´e´, ´f´};

try {

byte[] strTemp = s.getBytes();

MessageDigest mdTemp = MessageDigest.getInstance("MD5");

mdTemp.update(strTemp);

byte[] md = mdTemp.digest();

int j = md.length;

char str[] = new char[j * 2];

int k = 0;

for (int i = 0; i < j; i++) {

byte byte0 = md[i];

str[k++] = hexDigits[byte0 >>> 4 & 0xf];

str[k++] = hexDigits[byte0 & 0xf];

}

return new String(str);

}

catch (Exception e){

return null;

}

}

public static void main(String[] args){

//MD5_Test aa = new MD5_Test();

System.out.print(MD5_Test.MD5("XX"));

= = = = = = = = = = = = = = = = = = = = = = = = = = = = =

方法6（JavaScript）

<script language="JavaScript" runat="server">

/*****************************************************************************

* md5.js

*

* A JavaScript implementation of the RSA Data Security, Inc. MD5

* Message-Digest Algorithm.

*

* Copyright (C) Paul Johnston 1999. Distributed under the LGPL.

*****************************************************************************/

/* to convert strings to a list of ascii values */

function calcMD5(sInp) {

var sAscii = " !/"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ"

var sAscii = sAscii + "[/]^_`abcdefghijklmnopqrstuvwxyz~";

/* convert integer to hex string */

var sHex = "0123456789ABCDEF";

function hex(i) {

h = "";

for(j = 0; j <= 3; j++) {

h += sHex.charAt((i >> (j * 8 + 4)) & 0x0F) +

sHex.charAt((i >> (j * 8)) & 0x0F);

}

return h;

}

/* add, handling overflows correctly */

function add(x, y) {

return ((x&0x7FFFFFFF) + (y&0x7FFFFFFF)) ^ (x&0x80000000) ^ (y&0x80000000);

}

/* MD5 rounds functions */

function R1(A, B, C, D, X, S, T) {

q = add(add(A, (B & C) | (~B & D)), add(X, T));

return add((q << S) | ((q >> (32 - S)) & (Math.pow(2, S) - 1)), B);

}

function R2(A, B, C, D, X, S, T) {

q = add(add(A, (B & D) | (C & ~D)), add(X, T));

return add((q << S) | ((q >> (32 - S)) & (Math.pow(2, S) - 1)), B);

}

function R3(A, B, C, D, X, S, T) {

q = add(add(A, B ^ C ^ D), add(X, T));

return add((q << S) | ((q >> (32 - S)) & (Math.pow(2, S) - 1)), B);

}

function R4(A, B, C, D, X, S, T) {

q = add(add(A, C ^ (B | ~D)), add(X, T));

return add((q << S) | ((q >> (32 - S)) & (Math.pow(2, S) - 1)), B);

} /* Calculate length in machine words, including padding */

wLen = (((sInp.length + 8) >> 6) + 1) << 4;

var X = new Array(wLen);

/* main entry point */

/* Convert string to array of words */

j = 4;

for (i = 0; (i * 4) < sInp.length; i++) {

X[i] = 0;

for (j = 0; (j < 4) && ((j + i * 4) < sInp.length); j++) {

X[i] += (sAscii.indexOf(sInp.charAt((i * 4) + j)) + 32) << (j * 8);

}

}

/* Append padding bits and length */

if (j == 4) {

X[i++] = 0x80;

}

else {

X[i - 1] += 0x80 << (j * 8);

}

for(; i < wLen; i++) {

X[i] = 0;

}

X[wLen - 2] = sInp.length * 8;

/* hard-coded initial values */

a = 0x67452301;

b = 0xefcdab89;

c = 0x98badcfe;

d = 0x10325476;

/* Process each 16-word block in turn */

for (i = 0; i < wLen; i += 16) {

aO = a;

bO = b;

cO = c;

dO = d;

a = R1(a, b, c, d, X[i+ 0], 7 , 0xd76aa478);

d = R1(d, a, b, c, X[i+ 1], 12, 0xe8c7b756);

c = R1(c, d, a, b, X[i+ 2], 17, 0x242070db);

b = R1(b, c, d, a, X[i+ 3], 22, 0xc1bdceee);

a = R1(a, b, c, d, X[i+ 4], 7 , 0xf57c0faf);

d = R1(d, a, b, c, X[i+ 5], 12, 0x4787c62a);

c = R1(c, d, a, b, X[i+ 6], 17, 0xa8304613);

b = R1(b, c, d, a, X[i+ 7], 22, 0xfd469501);

a = R1(a, b, c, d, X[i+ 8], 7 , 0x698098d8);

d = R1(d, a, b, c, X[i+ 9], 12, 0x8b44f7af);

c = R1(c, d, a, b, X[i+10], 17, 0xffff5bb1);

b = R1(b, c, d, a, X[i+11], 22, 0x895cd7be);

a = R1(a, b, c, d, X[i+12], 7 , 0x6b901122);

d = R1(d, a, b, c, X[i+13], 12, 0xfd987193);

c = R1(c, d, a, b, X[i+14], 17, 0xa679438e);

b = R1(b, c, d, a, X[i+15], 22, 0x49b40821);

a = R2(a, b, c, d, X[i+ 1], 5 , 0xf61e2562);

d = R2(d, a, b, c, X[i+ 6], 9 , 0xc040b340);

c = R2(c, d, a, b, X[i+11], 14, 0x265e5a51);

b = R2(b, c, d, a, X[i+ 0], 20, 0xe9b6c7aa);

a = R2(a, b, c, d, X[i+ 5], 5 , 0xd62f105d);

d = R2(d, a, b, c, X[i+10], 9 , 0x2441453);

c = R2(c, d, a, b, X[i+15], 14, 0xd8a1e681);

b = R2(b, c, d, a, X[i+ 4], 20, 0xe7d3fbc8);

a = R2(a, b, c, d, X[i+ 9], 5 , 0x21e1cde6);

d = R2(d, a, b, c, X[i+14], 9 , 0xc33707d6);

c = R2(c, d, a, b, X[i+ 3], 14, 0xf4d50d87);

b = R2(b, c, d, a, X[i+ 8], 20, 0x455a14ed);

a = R2(a, b, c, d, X[i+13], 5 , 0xa9e3e905);

d = R2(d, a, b, c, X[i+ 2], 9 , 0xfcefa3f8);

c = R2(c, d, a, b, X[i+ 7], 14, 0x676f02d9);

b = R2(b, c, d, a, X[i+12], 20, 0x8d2a4c8a);

a = R3(a, b, c, d, X[i+ 5], 4 , 0xfffa3942);

d = R3(d, a, b, c, X[i+ 8], 11, 0x8771f681);

c = R3(c, d, a, b, X[i+11], 16, 0x6d9d6122);

b = R3(b, c, d, a, X[i+14], 23, 0xfde5380c);

a = R3(a, b, c, d, X[i+ 1], 4 , 0xa4beea44);

d = R3(d, a, b, c, X[i+ 4], 11, 0x4bdecfa9);

c = R3(c, d, a, b, X[i+ 7], 16, 0xf6bb4b60);

b = R3(b, c, d, a, X[i+10], 23, 0xbebfbc70);

a = R3(a, b, c, d, X[i+13], 4 , 0x289b7ec6);

d = R3(d, a, b, c, X[i+ 0], 11, 0xeaa127fa);

c = R3(c, d, a, b, X[i+ 3], 16, 0xd4ef3085);

b = R3(b, c, d, a, X[i+ 6], 23, 0x4881d05);

a = R3(a, b, c, d, X[i+ 9], 4 , 0xd9d4d039);

d = R3(d, a, b, c, X[i+12], 11, 0xe6db99e5);

c = R3(c, d, a, b, X[i+15], 16, 0x1fa27cf8);

b = R3(b, c, d, a, X[i+ 2], 23, 0xc4ac5665);

a = R4(a, b, c, d, X[i+ 0], 6 , 0xf4292244);

d = R4(d, a, b, c, X[i+ 7], 10, 0x432aff97);

c = R4(c, d, a, b, X[i+14], 15, 0xab9423a7);

b = R4(b, c, d, a, X[i+ 5], 21, 0xfc93a039);

a = R4(a, b, c, d, X[i+12], 6 , 0x655b59c3);

d = R4(d, a, b, c, X[i+ 3], 10, 0x8f0ccc92);

c = R4(c, d, a, b, X[i+10], 15, 0xffeff47d);

b = R4(b, c, d, a, X[i+ 1], 21, 0x85845dd1);

a = R4(a, b, c, d, X[i+ 8], 6 , 0x6fa87e4f);

d = R4(d, a, b, c, X[i+15], 10, 0xfe2ce6e0);

c = R4(c, d, a, b, X[i+ 6], 15, 0xa3014314);

b = R4(b, c, d, a, X[i+13], 21, 0x4e0811a1);

a = R4(a, b, c, d, X[i+ 4], 6 , 0xf7537e82);

d = R4(d, a, b, c, X[i+11], 10, 0xbd3af235);

c = R4(c, d, a, b, X[i+ 2], 15, 0x2ad7d2bb);

b = R4(b, c, d, a, X[i+ 9], 21, 0xeb86d391);

a = add(a, aO);

b = add(b, bO);

c = add(c, cO);

d = add(d, dO);

}

return hex(a) + hex(b) + hex(c) + hex(d);

}

</script>