java加解密_Java加解密全

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

}

}