java加密算法介绍-landuochong-ChinaUnix博客

BigTeam_learninglanduochong.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

landuochong

博客访问： 3426117
博文数量： 864
博客积分： 14125
博客等级：上将
技术积分： 10634
用户组：普通用户
注册时间： 2007-07-27 16:53

个人简介

https://github.com/zytc2009/BigTeam_learning

文章分类

全部博文（864）

webrtc（1）
小程序（1）
管理（0）
大数据（8）
图像处理（3）
html5（0）
iphone（9）
web创新（5）
开发模式（5）
SDL（20）
QT（150）

徒弟们的作品（0）
Java（21）
shell（16）
测试（1）
MeeGo（7）
市场动态（12）
php（5）
配置管理（8）
多媒体（40）
嵌入式培训（12）
教育（79）
其他（8）
Android（187）
ARM（2）
network（17）
openGL（46）
GTK（2）
生活经典（54）
linux（74）
C和C++（68）
未分配的博文（3）

文章存档

2023年（1）

2021年（1）

2019年（3）

2018年（1）

2017年（10）

2015年（3）

2014年（8）

2013年（3）

2012年（69）

2011年（103）

2010年（357）

2009年（283）

2008年（22）

我的朋友

相关博文

java加密算法介绍

分类： Java

2010-11-11 11:29:38

转自：http://justsee.javaeye.com/blog/747824
    http://www.javaeye.com/wiki/security/1710-one-way-encryption-algorithm

         http://sarin.javaeye.com/blog/600045

   ● BASE64 严格地说，属于编码格式，而非加密算法
    ● MD5(Message Digest algorithm 5，信息摘要算法)
    ● SHA(Secure Hash Algorithm，安全散列算法)
    ● HMAC(Hash Message Authentication Code，散列消息鉴别码)复杂的对称加密（DES、PBE）、非对称加密算法：
    ● DES(Data Encryption Standard，数据加密算法)
    ● PBE(Password-based encryption，基于密码验证)
    ● RSA(算法的名字以发明者的名字命名：Ron Rivest, AdiShamir 和Leonard Adleman)
    ● DH(Diffie-Hellman算法，密钥一致协议)
    ● DSA(Digital Signature Algorithm，数字签名)
    ● ECC(Elliptic Curves Cryptography，椭圆曲线密码编码学)[/size]

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

本篇内容简要介绍BASE64、MD5、SHA、HMAC几种加密算法。
    BASE64编码算法不算是真正的加密算法。
    MD5、SHA、HMAC这三种加密算法，可谓是非可逆加密，就是不可解密的加密方法，我们称之为单向加密算法。我们通常只把他们作为加密的基础。单纯的以上三种的加密并不可靠。

BASE64
按照RFC2045的定义，Base64被定义为：Base64内容传送编码被设计用来把任意序列的8位字节描述为一种不易被人直接识别的形式。（The Base64 Content-Transfer-Encoding is designed to represent arbitrary sequences of octets in a form that need not be humanly readable.）
常见于邮件、http加密，截取http信息，你就会发现登录操作的用户名、密码字段通过BASE64加密的。

主要就是BASE64Encoder、BASE64Decoder两个类，我们只需要知道使用对应的方法即可。另，BASE加密后产生的字节位数是8的倍数，如果不够位数以=符号填充。

sun不推荐使用它们自己的base64,所以用apache的挺好！

MD5
MD5 -- message-digest algorithm 5 （信息-摘要算法）缩写，广泛用于加密和解密技术，常用于文件校验。校验？不管文件多大，经过MD5后都能生成唯一的MD5值。好比现在的ISO校验，都是MD5校验。怎么用？当然是把ISO经过MD5后产生MD5的值。一般下载linux-ISO的朋友都见过下载链接旁边放着MD5的串。就是用来验证文件是否一致的。

通常我们不直接使用上述MD5加密。通常将MD5产生的字节数组交给BASE64再加密一把，得到相应的字符串。

SHA
SHA(Secure Hash Algorithm，安全散列算法），数字签名等密码学应用中重要的工具，被广泛地应用于电子商务等信息安全领域。虽然，SHA与MD5通过碰撞法都被破解了，但是SHA仍然是公认的安全加密算法，较之MD5更为安全。

HMAC
HMAC(Hash Message Authentication Code，散列消息鉴别码，基于密钥的Hash算法的认证协议。消息鉴别码实现鉴别的原理是，用公开函数和密钥产生一个固定长度的值作为认证标识，用这个标识鉴别消息的完整性。使用一个密钥生成一个固定大小的小数据块，即MAC，并将其加入到消息中，然后传输。接收方利用与发送方共享的密钥进行鉴别认证等。

BASE64的加密解密是双向的，可以求反解。
    MD5、SHA以及HMAC是单向加密，任何数据加密后只会产生唯一的一个加密串，通常用来校验数据在传输过程中是否被修改。其中HMAC算法有一个密钥，增强了数据传输过程中的安全性，强化了算法外的不可控因素。[img]http://www.javaeye.com/images/smiles /icon_biggrin.gif" alt="[/img]
    单向加密的用途主要是为了校验数据在传输过程中是否被修改。

代码如下：

Java代码

import java.math.BigInteger;
import java.security.InvalidKeyException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import javax.crypto.KeyGenerator;
import javax.crypto.Mac;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import org.apache.commons.codec.binary.Base64;
public class MyEncrypt {
public static final String KEY_SHA = "SHA";
public static final String KEY_MD5 = "MD5";
public static final String KEY_MAC = "HmacMD5";
// sun不推荐使用它们自己的base64,用apache的挺好
/**
* BASE64解密
*/
public static byte[] decryptBASE64(byte[] dest) {
if (dest == null) {
return null;
}
return Base64.decodeBase64(dest);
}
/**
* BASE64加密
*/
public static byte[] encryptBASE64(byte[] origin) {
if (origin == null) {
return null;
}
return Base64.encodeBase64(origin);
}
/**
* MD5加密
*
* @throws NoSuchAlgorithmException
*/
public static byte[] encryptMD5(byte[] data)
throws NoSuchAlgorithmException {
if (data == null) {
return null;
}
MessageDigest md5 = MessageDigest.getInstance(KEY_MD5);
md5.update(data);
return md5.digest();
}
/**
* SHA加密
*
* @throws NoSuchAlgorithmException
*/
public static byte[] encryptSHA(byte[] data)
throws NoSuchAlgorithmException {
if (data == null) {
return null;
}
MessageDigest sha = MessageDigest.getInstance(KEY_SHA);
sha.update(data);
return sha.digest();
}
/**
* 初始化HMAC密钥
*
* @throws NoSuchAlgorithmException
*/
public static String initMacKey() throws NoSuchAlgorithmException {
KeyGenerator keyGenerator = KeyGenerator.getInstance(KEY_MAC);
SecretKey secretKey = keyGenerator.generateKey();
return new String(encryptBASE64(secretKey.getEncoded()));
}
/**
* HMAC加密
*
* @throws NoSuchAlgorithmException
* @throws InvalidKeyException
*/
public static byte[] encryptHMAC(byte[] data, String key)
throws NoSuchAlgorithmException, InvalidKeyException {
SecretKey secretKey = new SecretKeySpec(decryptBASE64(key.getBytes()),
KEY_MAC);
Mac mac = Mac.getInstance(secretKey.getAlgorithm());
mac.init(secretKey);
return mac.doFinal(data);
}
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
String data = "简单加密";
System.out.println(new BigInteger(encryptBASE64(data.getBytes())).toString(16));
System.out.println(new BigInteger(encryptBASE64(data.getBytes())).toString(32));
System.out.println(new String(decryptBASE64(encryptBASE64(data.getBytes()))));
System.out.println(new BigInteger(encryptMD5(data.getBytes())).toString());
System.out.println(new BigInteger(encryptSHA(data.getBytes())).toString());
System.out.println(new BigInteger(encryptHMAC(data.getBytes(), initMacKey())).toString());
}
}

import java.math.BigInteger;
import java.security.InvalidKeyException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import javax.crypto.KeyGenerator;
import javax.crypto.Mac;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import org.apache.commons.codec.binary.Base64;

public class MyEncrypt {
public static final String KEY_SHA = "SHA";
public static final String KEY_MD5 = "MD5";
public static final String KEY_MAC = "HmacMD5";


// sun不推荐使用它们自己的base64,用apache的挺好
/**
* BASE64解密
*/
public static byte[] decryptBASE64(byte[] dest) {
if (dest == null) {
return null;
}
return Base64.decodeBase64(dest);
}

/**
* BASE64加密
*/
public static byte[] encryptBASE64(byte[] origin) {
if (origin == null) {
return null;
}
return Base64.encodeBase64(origin);
}

/**
* MD5加密
* 
* @throws NoSuchAlgorithmException
*/
public static byte[] encryptMD5(byte[] data)
throws NoSuchAlgorithmException {
if (data == null) {
return null;
}
MessageDigest md5 = MessageDigest.getInstance(KEY_MD5);
md5.update(data);
return md5.digest();
}

/**
* SHA加密
* 
* @throws NoSuchAlgorithmException
*/
public static byte[] encryptSHA(byte[] data)
throws NoSuchAlgorithmException {
if (data == null) {
return null;
}
MessageDigest sha = MessageDigest.getInstance(KEY_SHA);
sha.update(data);
return sha.digest();
}

/**
* 初始化HMAC密钥
* 
* @throws NoSuchAlgorithmException
*/
public static String initMacKey() throws NoSuchAlgorithmException {
KeyGenerator keyGenerator = KeyGenerator.getInstance(KEY_MAC);
SecretKey secretKey = keyGenerator.generateKey();
return new String(encryptBASE64(secretKey.getEncoded()));
}

/**
* HMAC加密
* 
* @throws NoSuchAlgorithmException
* @throws InvalidKeyException
*/
public static byte[] encryptHMAC(byte[] data, String key)
throws NoSuchAlgorithmException, InvalidKeyException {
SecretKey secretKey = new SecretKeySpec(decryptBASE64(key.getBytes()),
KEY_MAC);
Mac mac = Mac.getInstance(secretKey.getAlgorithm());
mac.init(secretKey);
return mac.doFinal(data);

}

public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
String data = "简单加密";
System.out.println(new BigInteger(encryptBASE64(data.getBytes())).toString(16));
System.out.println(new BigInteger(encryptBASE64(data.getBytes())).toString(32));
System.out.println(new String(decryptBASE64(encryptBASE64(data.getBytes()))));

System.out.println(new BigInteger(encryptMD5(data.getBytes())).toString());
System.out.println(new BigInteger(encryptSHA(data.getBytes())).toString());

System.out.println(new BigInteger(encryptHMAC(data.getBytes(), initMacKey())).toString());
}

}

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

可变MD5加密(Java实现)

可变在这里含义很简单，就是最终的加密结果是可变的，而非必需按标准MD5加密实现。Java类库security中的MessageDigest类就提供了MD5加密的支持，实现起来非常方便。为了实现更多效果，我们可以如下设计MD5工具类。

Java代码

import java.security.MessageDigest;
/**
* 标准MD5加密方法，使用java类库的security包的MessageDigest类处理
*/
public class MD5 {
/**
* 获得MD5加密密码的方法
*/
public static String getMD5ofStr(String origString) {
String origMD5 = null;
try {
MessageDigest md5 = MessageDigest.getInstance("MD5");
// md5.update(origString.getBytes());
byte[] result = md5.digest(origString.getBytes());
origMD5 = byteArray2HexStr(result);
// if ("123".equals(origString)) {
// System.out.println(new String(result));
// System.out.println(new BigInteger(result).toString(16));
// }
} catch (Exception e) {
e.printStackTrace();
}
return origMD5;
}
/**
* 处理字节数组得到MD5密码的方法
*/
private static String byteArray2HexStr(byte[] bs) {
StringBuffer sb = new StringBuffer();
for (byte b : bs) {
sb.append(byte2HexStr(b));
}
return sb.toString();
}
/**
* 字节标准移位转十六进制方法
*/
private static String byte2HexStr(byte b) {
String hexStr = null;
int n = b;
if (n < 0) {
// 若需要自定义加密,请修改这个移位算法即可
n = b & 0x7F + 128;
}
hexStr = Integer.toHexString(n / 16) + Integer.toHexString(n % 16);
return hexStr.toUpperCase();
}
/**
* 提供一个MD5多次加密方法
*/
public static String getMD5ofStr(String origString, int times) {
String md5 = getMD5ofStr(origString);
for (int i = 0; i < times - 1; i++) {
md5 = getMD5ofStr(md5);
}
return getMD5ofStr(md5);
}
/**
* 密码验证方法
*/
public static boolean verifyPassword(String inputStr, String MD5Code) {
return getMD5ofStr(inputStr).equals(MD5Code);
}
/**
* 重载一个多次加密时的密码验证方法
*/
public static boolean verifyPassword(String inputStr, String MD5Code,
int times) {
return getMD5ofStr(inputStr, times).equals(MD5Code);
}
/**
* 提供一个测试的主函数
*/
public static void main(String[] args) {
System.out.println("123:" + getMD5ofStr("123"));
System.out.println("123456789:" + getMD5ofStr("123456789"));
System.out.println("sarin:" + getMD5ofStr("sarin"));
System.out.println("123:" + getMD5ofStr("123", 4));
}
}

import java.security.MessageDigest;

/**
 * 标准MD5加密方法，使用java类库的security包的MessageDigest类处理
 */
public class MD5 {
	/**
	 * 获得MD5加密密码的方法
	 */
	public static String getMD5ofStr(String origString) {
		String origMD5 = null;
		try {
			MessageDigest md5 = MessageDigest.getInstance("MD5");
			// md5.update(origString.getBytes());
			byte[] result = md5.digest(origString.getBytes());
			origMD5 = byteArray2HexStr(result);
			// if ("123".equals(origString)) {
			// System.out.println(new String(result));
			// System.out.println(new BigInteger(result).toString(16));
			// }
		} catch (Exception e) {
			e.printStackTrace();
		}
		return origMD5;
	}

	/**
	 * 处理字节数组得到MD5密码的方法
	 */
	private static String byteArray2HexStr(byte[] bs) {
		StringBuffer sb = new StringBuffer();
		for (byte b : bs) {
			sb.append(byte2HexStr(b));
		}
		return sb.toString();
	}

	/**
	 * 字节标准移位转十六进制方法
	 */
	private static String byte2HexStr(byte b) {
		String hexStr = null;
		int n = b;
		if (n < 0) {
			// 若需要自定义加密,请修改这个移位算法即可
			n = b & 0x7F + 128;
		}
		hexStr = Integer.toHexString(n / 16) + Integer.toHexString(n % 16);
		return hexStr.toUpperCase();
	}

	/**
	 * 提供一个MD5多次加密方法
	 */
	public static String getMD5ofStr(String origString, int times) {
		String md5 = getMD5ofStr(origString);
		for (int i = 0; i < times - 1; i++) {
			md5 = getMD5ofStr(md5);
		}
		return getMD5ofStr(md5);
	}

	/**
	 * 密码验证方法
	 */
	public static boolean verifyPassword(String inputStr, String MD5Code) {
		return getMD5ofStr(inputStr).equals(MD5Code);
	}

	/**
	 * 重载一个多次加密时的密码验证方法
	 */
	public static boolean verifyPassword(String inputStr, String MD5Code,
			int times) {
		return getMD5ofStr(inputStr, times).equals(MD5Code);
	}

	/**
	 * 提供一个测试的主函数
	 */
	public static void main(String[] args) {
		System.out.println("123:" + getMD5ofStr("123"));
		System.out.println("123456789:" + getMD5ofStr("123456789"));
		System.out.println("sarin:" + getMD5ofStr("sarin"));
		System.out.println("123:" + getMD5ofStr("123", 4));
	}
}

可以看出实现的过程非常简单，因为由java类库提供了处理支持。但是要清楚的是这种方式产生的密码不是标准的MD5码，它需要进行移位处理才能得到标准MD5码。这个程序的关键之处也在这了，怎么可变？调整移位算法不就可变了么！不进行移位，也能够得到32位的密码，这就不是标准加密了，只要加密和验证过程使用相同的算法就可以了。
    MD5加密还是很安全的，像CMD5那些穷举破解的只是针对标准MD5加密的结果进行的，如果自定义移位算法后，它还有效么？可以说是无解的了，所以MD5非常安全可靠。
    为了更可变，还提供了多次加密的方法，可以在MD5基础之上继续MD5，就是对32位的第一次加密结果再MD5，恩，这样去破解？没有任何意义。
    这样在MIS系统中使用，安全可靠，欢迎交流，希望对使用者有用。
    我们最后看看由MD5加密算法实现的类，那是非常庞大的。

Java代码

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[i]);
}
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 & y) | ((~x) & z);
}
private long G(long x, long y, long z) {
return (x & z) | (y & (~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) & 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) & 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[i] & 0xffL);
output[j + 1] = (byte) ((input[i] >>> 8) & 0xffL);
output[j + 2] = (byte) ((input[i] >>> 16) & 0xffL);
output[j + 3] = (byte) ((input[i] >>> 24) & 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[i] = 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 & 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) & 0X0F];
ob[1] = Digit[ib & 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(\"11\"):" + m.getMD5ofStr("11"));
System.out.println("MD5(\"123\"):" + m.getMD5ofStr("123"));
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]));
}
}

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[i]);  
        }  
        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 & y) | ((~x) & z);  
  
    }  
  
    private long G(long x, long y, long z) {  
        return (x & z) | (y & (~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) & 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) & 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[i] & 0xffL);  
            output[j + 1] = (byte) ((input[i] >>> 8) & 0xffL);  
            output[j + 2] = (byte) ((input[i] >>> 16) & 0xffL);  
            output[j + 3] = (byte) ((input[i] >>> 24) & 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[i] = 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 & 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) & 0X0F];  
        ob[1] = Digit[ib & 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(\"11\"):" + m.getMD5ofStr("11"));  
            System.out.println("MD5(\"123\"):" + m.getMD5ofStr("123"));  
            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]));  
  
    }  
  
}

(57 KB)
下载次数: 7

阅读(1587) | 评论(0) | 转发(0) |

上一篇：JAVA加密算法7

下一篇：JAVA实现AES加密算法代码

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6