package com.epayto.until;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.security.*;
import java.security.spec.AlgorithmParameterSpec;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.IvParameterSpec;
import sun.misc.BASE64Decoder;//无法引用此,请使用Sun JDK
import sun.misc.BASE64Encoder;
public class Crypt {
public String encryptToMD5(String info) {
byte[] digesta = null;
try {
//
得到一个md5的消息摘要
MessageDigest
alga = MessageDigest.getInstance("MD5");
//
添加要进行计算摘要的信息
alga.update(info.getBytes());
//
得到该摘要
digesta =
alga.digest();
} catch
(NoSuchAlgorithmExceptione) {
e.printStackTrace();
}
// 将摘要转为字符串
String rs =
byte2hex(digesta);
return rs;
}
public String encryptToSHA(String info) {
byte[] digesta = null;
try {
//
得到一个SHA-1的消息摘要
MessageDigest
alga = MessageDigest.getInstance("SHA-1");
//
添加要进行计算摘要的信息
alga.update(info.getBytes());
//
得到该摘要
digesta =
alga.digest();
} catch
(NoSuchAlgorithmExceptione) {
e.printStackTrace();
}
// 将摘要转为字符串
String rs =
byte2hex(digesta);
return rs;
}
//
//
public SecretKey createSecretKey(String
algorithm) {
// 声明KeyGenerator对象
KeyGenerator keygen;
// 声明 密钥对象
SecretKey deskey = null;
try {
//
返回生成指定算法的秘密密钥的 KeyGenerator 对象
keygen =
KeyGenerator.getInstance(algorithm);
//
生成一个密钥
deskey =
keygen.generateKey();
} catch
(NoSuchAlgorithmExceptione) {
e.printStackTrace();
}
// 返回密匙
return deskey;
}
public String encryptToDES(SecretKey key, String
info) {
// 定义 加密算法,可用
DES,DESede,Blowfish
String Algorithm = "DES";
// 加密随机数生成器 (RNG),(可以不写)
SecureRandom sr = new
SecureRandom();
// 定义要生成的密文
byte[] cipherByte = null;
try {
//
得到加密/解密器
Cipher c1 =
Cipher.getInstance(Algorithm);
//
用指定的密钥和模式初始化Cipher对象
//
参数:(ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE,UNWRAP_MODE)
c1.init(Cipher.ENCRYPT_MODE,
key, sr);
//
对要加密的内容进行编码处理,
cipherByte =
c1.doFinal(info.getBytes());
} catch (Exception e) {
e.printStackTrace();
}
// 返回密文的十六进制形式
return
byte2hex(cipherByte);
}
public String decryptByDES(SecretKey key, String
sInfo) {
// 定义 加密算法,
String Algorithm = "DES";
// 加密随机数生成器 (RNG)
SecureRandom sr = new
SecureRandom();
byte[] cipherByte = null;
try {
//
得到加密/解密器
Cipher c1 =
Cipher.getInstance(Algorithm);
//
用指定的密钥和模式初始化Cipher对象
c1.init(Cipher.DECRYPT_MODE,
key, sr);
//
对要解密的内容进行编码处理
cipherByte =
c1.doFinal(hex2byte(sInfo));
} catch (Exception e) {
e.printStackTrace();
}
// return
byte2hex(cipherByte);
return new
String(cipherByte);
}
//
/
public void createPairKey() {
try {
//
根据特定的算法一个密钥对生成器
KeyPairGenerator
keygen = KeyPairGenerator.getInstance("DSA");
// 加密随机数生成器
(RNG)
SecureRandom
random = new SecureRandom();
//
重新设置此随机对象的种子
random.setSeed(1000);
//
使用给定的随机源(和默认的参数集合)初始化确定密钥大小的密钥对生成器
keygen.initialize(512,
random);// keygen.initialize(512);
//
生成密钥组
KeyPair keys
= keygen.generateKeyPair();
// 得到公匙
PublicKey
pubkey = keys.getPublic();
// 得到私匙
PrivateKey
prikey = keys.getPrivate();
//
将公匙私匙写入到文件当中
doObjToFile("mykeys.bat",
new Object[] { prikey, pubkey });
} catch
(NoSuchAlgorithmExceptione) {
e.printStackTrace();
}
}
public void signToInfo(String info, String
signfile) {
// 从文件当中读取私匙
PrivateKey myprikey =
(PrivateKey) getObjFromFile("mykeys.bat", 1);
// 从文件中读取公匙
PublicKey mypubkey =
(PublicKey) getObjFromFile("mykeys.bat", 2);
try {
// Signature
对象可用来生成和验证数字签名
Signature
signet = Signature.getInstance("DSA");
//
初始化签署签名的私钥
signet.initSign(myprikey);
//
更新要由字节签名或验证的数据
signet.update(info.getBytes());
//
签署或验证所有更新字节的签名,返回签名
byte[] signed
= signet.sign();
//
将数字签名,公匙,信息放入文件中
doObjToFile(signfile,
new Object[] { signed, mypubkey, info });
} catch (Exception e) {
e.printStackTrace();
}
}
public boolean validateSign(String signfile)
{
// 读取公匙
PublicKey mypubkey =
(PublicKey) getObjFromFile(signfile, 2);
// 读取签名
byte[] signed = (byte[])
getObjFromFile(signfile, 1);
// 读取信息
String info = (String)
getObjFromFile(signfile, 3);
try {
//
初始一个Signature对象,并用公钥和签名进行验证
Signature
signetcheck = Signature.getInstance("DSA");
//
初始化验证签名的公钥
signetcheck.initVerify(mypubkey);
// 使用指定的 byte
数组更新要签名或验证的数据
signetcheck.update(info.getBytes());
System.out.println(info);
//
验证传入的签名
return
signetcheck.verify(signed);
} catch (Exception e) {
e.printStackTrace();
return
false;
}
}
public String byte2hex(byte[] b) {
String hs = "";
String stmp = "";
for (int n = 0; n
< b.length; n++) {
stmp =
(java.lang.Integer.toHexString(b[n] & 0XFF));
if
(stmp.length() == 1) {
hs
= hs + "0" + stmp;
} else
{
hs
= hs + stmp;
}
}
return hs.toUpperCase();
}
public byte[] hex2byte(String hex) {
byte[] ret = new byte[8];
byte[] tmp =
hex.getBytes();
for (int i = 0; i
< 8; i++) {
ret[i] =
uniteBytes(tmp[i * 2], tmp[i * 2 + 1]);
}
return ret;
}
public static byte uniteBytes(byte src0, byte
src1) {
byte _b0 = Byte.decode("0x" +
new String(new byte[] { src0 }))
.byteValue();
_b0 = (byte) (_b0
<< 4);
byte _b1 = Byte.decode("0x" +
new String(new byte[] { src1 }))
.byteValue();
byte ret = (byte) (_b0 ^
_b1);
return ret;
}
public void doObjToFile(String file, Object[]
objs) {
ObjectOutputStream oos =
null;
try {
FileOutputStream
fos = new FileOutputStream(file);
oos = new
ObjectOutputStream(fos);
for (int i =
0; i < objs.length; i++) {
oos.writeObject(objs[i]);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
oos.close();
} catch
(IOException e) {
e.printStackTrace();
}
}
}
public Object getObjFromFile(String file, int i)
{
ObjectInputStream ois =
null;
Object obj = null;
try {
FileInputStream
fis = new FileInputStream(file);
ois = new
ObjectInputStream(fis);
for (int j =
0; j < i; j++) {
obj
= ois.readObject();
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
ois.close();
} catch
(IOException e) {
e.printStackTrace();
}
}
return obj;
}
public static void main(String[] args) throws
Exception {
Crypt jiami = new
Crypt();
// 执行MD5加密"Hello world!"
System.out.println("Hello经过MD5:"
+ jiami.encryptToMD5("Hello"));
// 生成一个DES算法的密匙
SecretKey key =
jiami.createSecretKey("DES");
// 用密匙加密信息"Hello world!"
String str1 =
jiami.encryptToDES(key, "Hello");
System.out.println("使用des加密信息Hello为:"
+ str1);
// 使用这个密匙解密
String str2 =
jiami.decryptByDES(key, str1);
System.out.println("解密后为:" +
str2);
// 创建公匙和私匙
jiami.createPairKey();
// 对Hello world!使用私匙进行签名
jiami.signToInfo("Hello",
"mysign.bat");
// 利用公匙对签名进行验证。
if
(jiami.validateSign("mysign.bat")) {
System.out.println("Success!");
} else {
System.out.println("Fail!");
}
System.out.println("加密:" +
jiami.encode("天下"));
System.out.println("解密:" +
jiami.decode(jiami.encode("天下")));
}
private static final byte[] DESkey =
"12345678".getBytes();// 设置密钥,略去
private static final byte[] DESIV =
"12345678".getBytes();// 设置向量,略去
public String encode(String data) throws
Exception {
AlgorithmParameterSpec iv =
null;// 加密算法的参数接口,IvParameterSpec是它的一个实现
Key key = null;
DESKeySpec keySpec = new
DESKeySpec(DESkey);// 设置密钥参数
iv = new
IvParameterSpec(DESIV);// 设置向量
SecretKeyFactory keyFactory =
SecretKeyFactory.getInstance("DES");// 获得密钥工厂
key =
keyFactory.generateSecret(keySpec);// 得到密钥对象
Cipher enCipher =
Cipher.getInstance("DES/CBC/PKCS5Padding");// 得到加密对象Cipher
enCipher.init(Cipher.ENCRYPT_MODE,
key, iv);// 设置工作模式为加密模式,给出密钥和向量
byte[] pasByte =
enCipher.doFinal(data.getBytes("utf-8"));
BASE64Encoder base64Encoder =
new BASE64Encoder();
return
base64Encoder.encode(pasByte);
}
public String encode(String DESkey, String
DESIV, String data) {
AlgorithmParameterSpec iv =
null;// 加密算法的参数接口,IvParameterSpec是它的一个实现
Key key = null;
DESKeySpec keySpec =null;
try {
keySpec = new
DESKeySpec(DESkey.getBytes());// 设置密钥参数
iv = new
IvParameterSpec(DESIV.getBytes());// 设置向量
SecretKeyFactory
keyFactory = SecretKeyFactory.getInstance("DES");// 获得密钥工厂
key =
keyFactory.generateSecret(keySpec);// 得到密钥对象
Cipher
enCipher = Cipher.getInstance("DES/CBC/PKCS5Padding");//
得到加密对象Cipher
enCipher.init(Cipher.ENCRYPT_MODE,
key, iv);// 设置工作模式为加密模式,给出密钥和向量
byte[]
pasByte = enCipher.doFinal(data.getBytes("utf-8"));
BASE64Encoder
base64Encoder = new BASE64Encoder();
return
base64Encoder.encode(pasByte);
// }
// catch
(InvalidKeyException iex) {
//
// } catch
(NoSuchAlgorithmExceptionnex) {
//
// } catch
(InvalidKeySpecException isex) {
//
// } catch
(NoSuchPaddingException nex) {
//
// } catch
(InvalidAlgorithmParameterException iex) {
//
// } catch
(UnsupportedEncodingException uex) {
//
} catch (Exception ex) {
ex.printStackTrace();
}
finally{
}
return null;
}
public String decode(String data) throws
Exception {
AlgorithmParameterSpec iv =
null;// 加密算法的参数接口,IvParameterSpec是它的一个实现
Key key = null;
DESKeySpec keySpec = new
DESKeySpec(DESkey);// 设置密钥参数
iv = new
IvParameterSpec(DESIV);// 设置向量
SecretKeyFactory keyFactory =
SecretKeyFactory.getInstance("DES");// 获得密钥工厂
key =
keyFactory.generateSecret(keySpec);// 得到密钥对象
Cipher deCipher =
Cipher.getInstance("DES/CBC/PKCS5Padding");
deCipher.init(Cipher.DECRYPT_MODE,
key, iv);
BASE64Decoder base64Decoder =
new BASE64Decoder();
byte[] pasByte =
deCipher.doFinal(base64Decoder.decodeBuffer(data));
return new String(pasByte,
"UTF-8");
}
}