求一个md5加密算法java类

Question

刚下了传智播客网上在线支付实战视频，里面没有源码，视频中有用到一个md5加密算法类，
类名：DigestUtil
我在网上搜到部分源码：
public static String hmacSign(String aValue, String aKey) { 
byte k_ipad[] = new byte[64]; 
byte k_opad[] = new byte[64]; 
byte keyb[]; 
byte value[]; 
try { 
keyb = aKey.getBytes(encodingCharset); 
value = aValue.getBytes(encodingCharset); 
} catch (UnsupportedEncodingException e) { 
keyb = aKey.getBytes(); 
value = aValue.getBytes(); 
}  Arrays.fill(k_ipad, keyb.length, 64, (byte) 54); 
Arrays.fill(k_opad, keyb.length, 64, (byte) 92); 
for (int i = 0; i < keyb.length; i++) { 
k_ipad[i] = (byte) (keyb[i] ^ 0x36); 
k_opad[i] = (byte) (keyb[i] ^ 0x5c); 
}  MessageDigest md = null; 
try { 
md = MessageDigest.getInstance("MD5"); 
} catch (NoSuchAlgorithmException e) {  return null; 
} 
md.update(k_ipad); 
md.update(value); 
byte dg[] = md.digest(); 
md.reset(); 
md.update(k_opad); 
md.update(dg, 0, 16); 
dg = md.digest(); 
return toHex(dg); 
}  public static String toHex(byte input[]) { 
if (input == null) 
return null; 
StringBuffer output = new StringBuffer(input.length * 2); 
for (int i = 0; i < input.length; i++) { 
int current = input[i] & 0xff; 
if (current < 16) 
output.append("0"); 
output.append(Integer.toString(current, 16)); 
}  return output.toString(); 
}
哪位高手有全的发给我下啊，有视频的源码也行，谢谢！！！
急！！！！！！！！！！

Answer 1

import java.lang.reflect.*; /******************************************************************************* 
* keyBean 类实现了RSA Data Security, Inc.在提交给IETF 的RFC1321中的keyBean message-digest 
* 算法。 
******************************************************************************/ 
public class keyBean { 
/* 
* 下面这些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 }; /* 
* 下面的三个成员是keyBean计算过程中用到的3个核心数据，在原始的C实现中 被定义到keyBean_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是keyBean的唯一一个公共成员，是最新一次计算结果的 16进制ASCII表示. 
*/ public String digestHexStr; /* 
* digest,是最新一次计算结果的2进制内部表示，表示128bit的keyBean值. 
*/ 
private byte[] digest = new byte[16]; /* 
* getkeyBeanofStr是类keyBean最主要的公共方法，入口参数是你想要进行keyBean变换的字符串 
* 返回的是变换完的结果，这个结果是从公共成员digestHexStr取得的． 
*/ 
public String getkeyBeanofStr(String inbuf) { 
keyBeanInit(); 
keyBeanUpdate(inbuf.getBytes(), inbuf.length()); 
keyBeanFinal(); 
digestHexStr = ""; 
for (int i = 0; i < 16; i++) { 
digestHexStr += byteHEX(digest[i]); 
} 
return digestHexStr; 
} // 这是keyBean这个类的标准构造函数，JavaBean要求有一个public的并且没有参数的构造函数 
public keyBean() { 
keyBeanInit(); 
return; 
} /* keyBeanInit是一个初始化函数，初始化核心变量，装入标准的幻数 */ 
private void keyBeanInit() { 
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个基本的keyBean函数，在原始的keyBean的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; 
} 

Answer 2

/* 
* keyBeanUpdate是keyBean的主计算过程，inbuf是要变换的字节串，inputlen是长度，这个 
* 函数由getkeyBeanofStr调用，调用之前需要调用keyBeaninit，因此把它设计成private的 
*/ 
private void keyBeanUpdate(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) { 
keyBeanMemcpy(buffer, inbuf, index, 0, partLen); 
keyBeanTransform(buffer); 
for (i = partLen; i + 63 < inputLen; i += 64) { 
keyBeanMemcpy(block, inbuf, 0, i, 64); 
keyBeanTransform(block); 
} 
index = 0; 
} else 
i = 0; 
// /* Buffer remaining input */ 
keyBeanMemcpy(buffer, inbuf, index, i, inputLen - i); 
} /* 
* keyBeanFinal整理和填写输出结果 
*/ 
private void keyBeanFinal() { 
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); 
keyBeanUpdate(PADDING, padLen); 
// /* Append length (before padding) */ 
keyBeanUpdate(bits, 8); 
// /* Store state in digest */ 
Encode(digest, state, 16); 
} /* 
* keyBeanMemcpy是一个内部使用的byte数组的块拷贝函数，从input的inpos开始把len长度的 
* 字节拷贝到output的outpos位置开始 
*/ 
private void keyBeanMemcpy(byte[] output, byte[] input, int outpos, 
int inpos, int len) { 
int i; 
for (i = 0; i < len; i++) 
output[outpos + i] = input[inpos + i]; 
} /* 
* keyBeanTransform是keyBean核心变换程序，有keyBeanUpdate调用，block是分块的原始字节 
*/ 
private void keyBeanTransform(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[]) { keyBean m = new keyBean(); 
if (Array.getLength(args) == 0) { // 如果没有参数，执行标准的Test Suite 
System.out.println("keyBean Test suite:"); 
System.out.println("keyBean(\"):" + m.getkeyBeanofStr("")); 
System.out.println("keyBean(\"a\"):" + m.getkeyBeanofStr("a")); 
System.out.println("keyBean(\"abc\"):" + m.getkeyBeanofStr("abc")); 
System.out.println("keyBean(\"message digest\"):" 
+ m.getkeyBeanofStr("message digest")); 
System.out.println("keyBean(\"abcdefghijklmnopqrstuvwxyz\"):" 
+ m.getkeyBeanofStr("abcdefghijklmnopqrstuvwxyz")); 
System.out 
.println("keyBean(\"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789\"):" 
+ m 
.getkeyBeanofStr("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789")); 
} else 
System.out.println("keyBean(" + args[0] + ")=" 
+ m.getkeyBeanofStr(args[0])); } 
} 

Answer 3

java标准包里面有现成的。
你找找java加密包的资料，现成的类和加密算法

Answer 4

MD5 不知道哇 但是常用的确实是在LS说的地方 常用API
　　java.security.KeyPairGenerator 密钥生成器类
　　public static KeyPairGenerator getInstance(String algorithm) throws NoSuchAlgorithmException
　　以指定的算法返回一个KeyPairGenerator 对象
　　参数: algorithm 算法名.如:"DSA","RSA"
　　
　　public void initialize(int keysize)
　　
　　以指定的长度初始化KeyPairGenerator对象,如果没有初始化系统以1024长度默认设置
　　
　　参数:keysize 算法位长.其范围必须在 512 到 1024 之间，且必须为 64 的倍数
　　
　　public void initialize(int keysize, SecureRandom random)
　　以指定的长度初始化和随机发生器初始化KeyPairGenerator对象
　　参数:keysize 算法位长.其范围必须在 512 到 1024 之间，且必须为 64 的倍数
　　random 一个随机位的来源(对于initialize(int keysize)使用了默认随机器
　　
　　public abstract KeyPair generateKeyPair()
　　产生新密钥对
　　
　　java.security.KeyPair 密钥对类
　　public PrivateKey getPrivate()
　　返回私钥
　　
　　public PublicKey getPublic()
　　返回公钥
　　
　　java.security.Signature 签名类
　　public static Signature getInstance(String algorithm) throws NoSuchAlgorithmException
　　返回一个指定算法的Signature对象
　　参数 algorithm 如:"DSA"
　　
　　public final void initSign(PrivateKey privateKey)
　　throws InvalidKeyException
　　用指定的私钥初始化
　　参数:privateKey 所进行签名时用的私钥
　　
　　public final void update(byte data)
　　throws SignatureException
　　public final void update(byte[] data)
　　throws SignatureException
　　public final void update(byte[] data, int off, int len)
　　throws SignatureException
　　添加要签名的信息
　　
　　public final byte[] sign()
　　throws SignatureException
　　返回签名的数组,前提是initSign和update
　　
　　public final void initVerify(PublicKey publicKey)
　　throws InvalidKeyException
　　用指定的公钥初始化
　　参数:publicKey 验证时用的公钥
　　
　　public final boolean verify(byte[] signature)
　　throws SignatureException
　　验证签名是否有效,前提是已经initVerify初始化
　　参数: signature 签名数组 

Answer 5

这个最简单
import java.security.MessageDigest;
public class Ecryption { 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();
}
/** J
 * 转换byte到16进制
 * @param b
 * @return
 */
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];

}
/** J
 * 编码
 * @param origin
 * @return
 */

//MessageDigest 为 JDK 提供的加密类
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[] sdf){

System.out.print(Ecryption.MD5Encode("test"));
}
}

Answer 6

import java.security.MessageDigest;public class MD5 { public MD5() {
  // TODO Auto-generated constructor stub
 } public static String encode(String str) {
  StringBuffer buf = new StringBuffer();
  try {
   MessageDigest md5 = MessageDigest.getInstance("MD5");
   md5.update(str.getBytes());
   byte[] bytes = md5.digest();
   for (int i = 0; i < bytes.length; i++) {
    String s = Integer.toHexString(bytes[i] & 0xff);
    if (s.length() == 1) {
     buf.append("0");
    }
    buf.append(s);
   }
  } catch (Exception ex) {
   ex.printStackTrace();
  }
  return buf.toString();
 } 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
 }}

Answer 7

import java.security.MessageDigest;public class MD5 { public MD5() {
  // TODO Auto-generated constructor stub
 } public static String encode(String str) {
  StringBuffer buf = new StringBuffer();
  try {
   MessageDigest md5 = MessageDigest.getInstance("MD5");
   md5.update(str.getBytes());
   byte[] bytes = md5.digest();
   for (int i = 0; i < bytes.length; i++) {
    String s = Integer.toHexString(bytes[i] & 0xff);
    if (s.length() == 1) {
     buf.append("0");
    }
    buf.append(s);
   }
  } catch (Exception ex) {
   ex.printStackTrace();
  }
  return buf.toString();
 } 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
 }}

Answer 8

我想，楼主google一下 java md5，就会有收获的。jdk自己带了

Answer 9

我想，楼主访问一下yeepay网站，就会有收获的。
给你个链接，https://www.yeepay.com/selfservice/shareinf/resourcedownload/YeePay_HTMLcommon_V3.0.zip
压缩包里面就有。