java密码加密与解密

以下两个类可以很方便的完成字符串的加密和解密

加密 CryptHelper encrypt（password）

解密 CrypHelper decrypt（password）

代码如下

CryptUtils java

[java]

package gdie lab crypt

import java io IOException

import javax crypto Cipher

import javax crypto KeyGenerator

import javax crypto SecretKey

import apache xerces internal impl dv util Base

public class CryptUtils {

private static String Algorithm = DES

private static byte[] DEFAULT_KEY=new byte[] { }

private static String VALUE_ENCODING= UTF

/**

* 生成密钥

*

* @return byte[] 返回生成的密钥

* @throws exception

*             扔出异常

*/

public static byte[] getSecretKey（） throws Exception {

KeyGenerator keygen = KeyGenerator getInstance（Algorithm）

SecretKey deskey = keygen generateKey（）

// if （debug ） System out println （ 生成密钥 +byte hex （deskey getEncoded

// （）））

return deskey getEncoded（）

}

/**

* 将指定的数据根据提供的密钥进行加密

*

* @param input

*            需要加密的数据

* @param key

*            密钥

* @return byte[] 加密后的数据

* @throws Exception

*/

public static byte[] encryptData（byte[] input byte[] key） throws Exception {

SecretKey deskey = new javax crypto spec SecretKeySpec（key Algorithm）

// if （debug ）

// {

// System out println （ 加密前的二进串 +byte hex （input ））

// System out println （ 加密前的字符串 +new String （input ））

//

// }

Cipher c = Cipher getInstance（Algorithm）

c init（Cipher ENCRYPT_MODE deskey）

byte[] cipherByte = c doFinal（input）

// if （debug ） System out println （ 加密后的二进串 +byte hex （cipherByte ））

return cipherByte

}

public static byte[] encryptData（byte[] input） throws Exception {

return encryptData（input DEFAULT_KEY）

}

/**

* 将给定的已加密的数据通过指定的密钥进行解密

*

* @param input

*            待解密的数据

* @param key

*            密钥

* @return byte[] 解密后的数据

* @throws Exception

*/

public static byte[] decryptData（byte[] input byte[] key） throws Exception {

SecretKey deskey = new javax crypto spec SecretKeySpec（key Algorithm）

// if （debug ） System out println （ 解密前的信息 +byte hex （input ））

Cipher c = Cipher getInstance（Algorithm）

c init（Cipher DECRYPT_MODE deskey）

byte[] clearByte = c doFinal（input）

// if （debug ）

// {

// System out println （ 解密后的二进串 +byte hex （clearByte ））

// System out println （ 解密后的字符串 +（new String （clearByte ）））

//

// }

return clearByte

}

public static byte[] decryptData（byte[] input） throws Exception {

return decryptData（input DEFAULT_KEY）

}

/**

* 字节码转换成 进制字符串

*

* @param byte[] b 输入要转换的字节码

* @return String 返回转换后的 进制字符串

*/

public static String byte hex（byte[] bytes） {

StringBuilder hs = new StringBuilder（）

for（byte b : bytes）

hs append（String format（ % $ X b））

return hs toString（）

}

public static byte[] hex byte（String content） {

int l=content length（）》

byte[] result=new byte[l]

for（int i= i<li++） {

int j=i《

String s=content substring（j j+ ）

result[i]=Integer valueOf（s ） byteValue（）

}

return result

}

/**

* 将字节数组转换为base 编码字符串

* @param buffer

* @return

*/

public static String bytesToBase （byte[] buffer） {

//BASE Encoder en=new BASE Encoder（）

return Base encode（buffer）

//      return encoder encode（buffer）

}

/**

* 将base 编码的字符串解码为字节数组

* @param value

* @return

* @throws IOException

*/

public static byte[] base ToBytes（String value） throws IOException {

//return Base decodeToByteArray（value）

//      System out println（decoder decodeBuffer（value））

//      return decoder decodeBuffer（value）

return Base decode（value）

}

/**

* 加密给定的字符串

* @param value

* @return 加密后的base 字符串

*/

public static String encryptString（String value） {

return encryptString（value DEFAULT_KEY）

}

/**

* 根据给定的密钥加密字符串

* @param value 待加密的字符串

* @param key 以BASE 形式存在的密钥

* @return 加密后的base 字符串

* @throws IOException

*/

public static String encryptString（String value String key） throws IOException {

return encryptString（value base ToBytes（key））

}

/**

* 根据给定的密钥加密字符串

* @param value 待加密的字符串

* @param key 字节数组形式的密钥

* @return 加密后的base 字符串

*/

public static String encryptString（String value byte[] key） {

try {

byte[] data=value getBytes（VALUE_ENCODING）

data=CryptUtils encryptData（data key）

return bytesToBase （data）

} catch （Exception e） {

// TODO Auto generated catch block

e printStackTrace（）

return null

}

}

/**

* 解密字符串

* @param value base 形式存在的密文

* @return 明文

*/

public static String decryptString（String value） {

return decryptString（value DEFAULT_KEY）

}

/**

* 解密字符串

* @param value base 形式存在的密文

* @param key base 形式存在的密钥

* @return 明文

* @throws IOException

*/

public static String decryptString（String value String key） throws IOException {

String s=decryptString（value base ToBytes（key））

return s

}

/**

* 解密字符串

* @param value base 形式存在的密文

* @param key 字节数据形式存在的密钥

* @return 明文

*/

public static String decryptString（String value byte[] key） {

try {

byte[] data=base ToBytes（value）

data=CryptUtils decryptData（data key）

return new String（data VALUE_ENCODING）

}catch（Exception e） {

e printStackTrace（）

return null

}

}

}

package gdie lab crypt

import java io IOException

import javax crypto Cipher

import javax crypto KeyGenerator

import javax crypto SecretKey

import apache xerces internal impl dv util Base

public class CryptUtils {

private static String Algorithm = DES

private static byte[] DEFAULT_KEY=new byte[] { }

private static String VALUE_ENCODING= UTF

/**

* 生成密钥

*

* @return byte[] 返回生成的密钥

* @throws exception

*             扔出异常

*/

public static byte[] getSecretKey（） throws Exception {

KeyGenerator keygen = KeyGenerator getInstance（Algorithm）

SecretKey deskey = keygen generateKey（）

// if （debug ） System out println （ 生成密钥 +byte hex （deskey getEncoded

// （）））

return deskey getEncoded（）

}

/**

* 将指定的数据根据提供的密钥进行加密

*

* @param input

*            需要加密的数据

* @param key

*            密钥

* @return byte[] 加密后的数据

* @throws Exception

*/

public static byte[] encryptData（byte[] input byte[] key） throws Exception {

SecretKey deskey = new javax crypto spec SecretKeySpec（key Algorithm）

// if （debug ）

// {

// System out println （ 加密前的二进串 +byte hex （input ））

// System out println （ 加密前的字符串 +new String （input ））

//

// }

Cipher c = Cipher getInstance（Algorithm）

c init（Cipher ENCRYPT_MODE deskey）

byte[] cipherByte = c doFinal（input）

// if （debug ） System out println （ 加密后的二进串 +byte hex （cipherByte ））

return cipherByte

}

public static byte[] encryptData（byte[] input） throws Exception {

return encryptData（input DEFAULT_KEY）

}

/**

* 将给定的已加密的数据通过指定的密钥进行解密

*

* @param input

*            待解密的数据

* @param key

*            密钥

* @return byte[] 解密后的数据

* @throws Exception

*/

public static byte[] decryptData（byte[] input byte[] key） throws Exception {

SecretKey deskey = new javax crypto spec SecretKeySpec（key Algorithm）

// if （debug ） System out println （ 解密前的信息 +byte hex （input ））

Cipher c = Cipher getInstance（Algorithm）

c init（Cipher DECRYPT_MODE deskey）

byte[] clearByte = c doFinal（input）

// if （debug ）

// {

// System out println （ 解密后的二进串 +byte hex （clearByte ））

// System out println （ 解密后的字符串 +（new String （clearByte ）））

//

// }

return clearByte

}

public static byte[] decryptData（byte[] input） throws Exception {

return decryptData（input DEFAULT_KEY）

}

/**

* 字节码转换成 进制字符串

*

* @param byte[] b 输入要转换的字节码

* @return String 返回转换后的 进制字符串

*/

public static String byte hex（byte[] bytes） {

StringBuilder hs = new StringBuilder（）

for（byte b : bytes）

hs append（String format（ % $ X b））

return hs toString（）

}

public static byte[] hex byte（String content） {

int l=content length（）》

byte[] result=new byte[l]

for（int i= i<li++） {

int j=i《

String s=content substring（j j+ ）

result[i]=Integer valueOf（s ） byteValue（）

}

return result

}

/**

* 将字节数组转换为base 编码字符串

* @param buffer

* @return

*/

public static String bytesToBase （byte[] buffer） {

//BASE Encoder en=new BASE Encoder（）

return Base encode（buffer）

//  return encoder encode（buffer）

}

/**

* 将base 编码的字符串解码为字节数组

* @param value

* @return

* @throws IOException

*/

public static byte[] base ToBytes（String value） throws IOException {

//return Base decodeToByteArray（value）

//  System out println（decoder decodeBuffer（value））

//  return decoder decodeBuffer（value）

return Base decode（value）

}

/**

* 加密给定的字符串

* @param value

* @return 加密后的base 字符串

*/

public static String encryptString（String value） {

return encryptString（value DEFAULT_KEY）

}

/**

* 根据给定的密钥加密字符串

* @param value 待加密的字符串

* @param key 以BASE 形式存在的密钥

* @return 加密后的base 字符串

* @throws IOException

*/

public static String encryptString（String value String key） throws IOException {

return encryptString（value base ToBytes（key））

}

/**

* 根据给定的密钥加密字符串

* @param value 待加密的字符串

* @param key 字节数组形式的密钥

* @return 加密后的base 字符串

*/

public static String encryptString（String value byte[] key） {

try {

byte[] data=value getBytes（VALUE_ENCODING）

data=CryptUtils encryptData（data key）

return bytesToBase （data）

} catch （Exception e） {

// TODO Auto generated catch block

e printStackTrace（）

return null

}

}

/**

* 解密字符串

* @param value base 形式存在的密文

* @return 明文

*/

public static String decryptString（String value） {

return decryptString（value DEFAULT_KEY）

}

/**

* 解密字符串

* @param value base 形式存在的密文

* @param key base 形式存在的密钥

* @return 明文

* @throws IOException

*/

public static String decryptString（String value String key） throws IOException {

String s=decryptString（value base ToBytes（key））

return s

}

/**

* 解密字符串

* @param value base 形式存在的密文

* @param key 字节数据形式存在的密钥

* @return 明文

*/

public static String decryptString（String value byte[] key） {

try {

byte[] data=base ToBytes（value）

data=CryptUtils decryptData（data key）

return new String（data VALUE_ENCODING）

}catch（Exception e） {

e printStackTrace（）

return null

}

}

}

CryptHelper java

[java]

package gdie lab crypt

import javax crypto Cipher

import javax crypto SecretKey

import javax crypto SecretKeyFactory

import javax crypto spec DESKeySpec

import javax crypto spec IvParameterSpec

import springframework util DigestUtils

public class CryptHelper{

private static String CRYPT_KEY = zhongqian

//加密

private static Cipher ecip

//解密

private static Cipher dcip

static {

try {

String KEY = DigestUtils md DigestAsHex（CRYPT_KEY getBytes（）） toUpperCase（）

KEY = KEY substring（ ）

byte[] bytes = KEY getBytes（）

DESKeySpec ks = new DESKeySpec（bytes）

SecretKeyFactory skf = SecretKeyFactory getInstance（ DES ）

SecretKey sk = skf generateSecret（ks）

IvParameterSpec iv = new IvParameterSpec（bytes）

ecip = Cipher getInstance（ DES/CBC/PKCS Padding ）

ecip init（Cipher ENCRYPT_MODE sk iv ）

dcip = Cipher getInstance（ DES/CBC/PKCS Padding ）

dcip init（Cipher DECRYPT_MODE sk iv ）

}catch（Exception ex） {

ex printStackTrace（）

}

}

public static String encrypt（String content） throws Exception {

byte[] bytes = ecip doFinal（content getBytes（ ascii ））

return CryptUtils byte hex（bytes）

}

public static String decrypt（String content） throws Exception {

byte[] bytes  = CryptUtils hex byte（content）

bytes = dcip doFinal（bytes）

return new String（bytes ascii ）

}

//test

public static void main（String[] args） throws Exception {

String password = gly

String en = encrypt（password）

System out println（en）

System out println（decrypt（en））

}

}

package gdie lab crypt

import javax crypto Cipher

import javax crypto SecretKey

import javax crypto SecretKeyFactory

import javax crypto spec DESKeySpec

import javax crypto spec IvParameterSpec

import springframework util DigestUtils

public class CryptHelper{

private static String CRYPT_KEY = zhongqian

//加密

private static Cipher ecip

//解密

private static Cipher dcip

static {

try {

String KEY = DigestUtils md DigestAsHex（CRYPT_KEY getBytes（）） toUpperCase（）

KEY = KEY substring（ ）

byte[] bytes = KEY getBytes（）

DESKeySpec ks = new DESKeySpec（bytes）

SecretKeyFactory skf = SecretKeyFactory getInstance（ DES ）

SecretKey sk = skf generateSecret（ks）

IvParameterSpec iv = new IvParameterSpec（bytes）

ecip = Cipher getInstance（ DES/CBC/PKCS Padding ）

ecip init（Cipher ENCRYPT_MODE sk iv ）

dcip = Cipher getInstance（ DES/CBC/PKCS Padding ）

dcip init（Cipher DECRYPT_MODE sk iv ）

}catch（Exception ex） {

ex printStackTrace（）

}

}

public static String encrypt（String content） throws Exception {

byte[] bytes = ecip doFinal（content getBytes（ ascii ））

return CryptUtils byte hex（bytes）

}

public static String decrypt（String content） throws Exception {

byte[] bytes  = CryptUtils hex byte（content）

bytes = dcip doFinal（bytes）

return new String（bytes ascii ）

}

//test

public static void main（String[] args） throws Exception {

String password = gly

String en = encrypt（password）

System out println（en）

System out println（decrypt（en））

}

lishixinzhi/Article/program/Java/hx/201311/26449

package com.cube.limail.util

import javax.crypto.Cipher

import javax.crypto.KeyGenerator

import javax.crypto.SecretKey/**

* 加密解密类

*/

public class Eryptogram

{

private static String Algorithm ="DES"

private String key="CB7A92E3D3491964"

//定义 加密算法,可用 DES,DESede,Blowfish

static boolean debug = false

/**

* 构造子注解.

*/

public Eryptogram ()

{

} /**

* 生成密钥

* @return byte[] 返回生成的密钥

* @throws exception 扔出异常.

*/

public static byte [] getSecretKey () throws Exception

{

KeyGenerator keygen = KeyGenerator.getInstance (Algorithm )

SecretKey deskey = keygen.generateKey ()

System.out.println ("生成密钥:"+bytesToHexString (deskey.getEncoded ()))

if (debug ) System.out.println ("生成密钥:"+bytesToHexString (deskey.getEncoded ()))

return deskey.getEncoded ()

} /**

* 将指定的数据根据提供的密钥进行加密

* @param input 需要加密的数据

* @param key 密钥

* @return byte[] 加密后的数据

* @throws Exception

*/

public static byte [] encryptData (byte [] input ,byte [] key ) throws Exception

{

SecretKey deskey = new javax.crypto.spec.SecretKeySpec (key ,Algorithm )

if (debug )

{

System.out.println ("加密前的二进串:"+byte2hex (input ))

System.out.println ("加密前的字符串:"+new String (input ))

} Cipher c1 = Cipher.getInstance (Algorithm )

c1.init (Cipher.ENCRYPT_MODE ,deskey )

byte [] cipherByte =c1.doFinal (input )

if (debug ) System.out.println ("加密后的二进串:"+byte2hex (cipherByte ))

return cipherByte

} /**

* 将给定的已加密的数据通过指定的密钥进行解密

* @param input 待解密的数据

* @param key 密钥

* @return byte[] 解密后的数据

* @throws Exception

*/

public static byte [] decryptData (byte [] input ,byte [] key ) throws Exception

{

SecretKey deskey = new javax.crypto.spec.SecretKeySpec (key ,Algorithm )

if (debug ) System.out.println ("解密前的信息:"+byte2hex (input ))

Cipher c1 = Cipher.getInstance (Algorithm )

c1.init (Cipher.DECRYPT_MODE ,deskey )

byte [] clearByte =c1.doFinal (input )

if (debug )

{

System.out.println ("解密后的二进串:"+byte2hex (clearByte ))

System.out.println ("解密后的字符串:"+(new String (clearByte )))

} return clearByte

} /**

* 字节码转换成16进制字符串

* @param byte[] b 输入要转换的字节码

* @return String 返回转换后的16进制字符串

*/

public static 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

if (n <b.length -1 ) hs =hs +":"

} return hs.toUpperCase ()

}

/**

* 字符串转成字节数组.

* @param hex 要转化的字符串.

* @return byte[] 返回转化后的字符串.

*/

public static byte[] hexStringToByte(String hex) {

int len = (hex.length() / 2)

byte[] result = new byte[len]

char[] achar = hex.toCharArray()

for (int i = 0i <leni++) {

int pos = i * 2

result[i] = (byte) (toByte(achar[pos]) <<4 | toByte(achar[pos + 1]))

}

return result

}

private static byte toByte(char c) {

byte b = (byte) "0123456789ABCDEF".indexOf(c)

return b

}

/**

* 字节数组转成字符串.

* @param String 要转化的字符串.

* @return 返回转化后的字节数组.

*/

public static final String bytesToHexString(byte[] bArray) {

StringBuffer sb = new StringBuffer(bArray.length)

String sTemp

for (int i = 0i <bArray.lengthi++) {

sTemp = Integer.toHexString(0xFF &bArray[i])

if (sTemp.length() <2)

sb.append(0)

sb.append(sTemp.toUpperCase())

}

return sb.toString()

}

/**

* 从数据库中获取密钥.

* @param deptid 企业id.

* @return 要返回的字节数组.

* @throws Exception 可能抛出的异常.

*/

public static byte[] getSecretKey(long deptid) throws Exception {

byte[] key=null

String value=null

//CommDao dao=new CommDao()

// List list=dao.getRecordList("from Key k where k.deptid="+deptid)

//if(list.size()>0){

//value=((com.csc.sale.bean.Key)list.get(0)).getKey()

value = "CB7A92E3D3491964"

key=hexStringToByte(value)

//}

if (debug)

System.out.println("密钥:" + value)

return key

}

public String encryptData2(String data) {

String en = null

try {

byte[] key=hexStringToByte(this.key)

en = bytesToHexString(encryptData(data.getBytes(),key))

} catch (Exception e) {

e.printStackTrace()

}

return en

}

public String decryptData2(String data) {

String de = null

try {

byte[] key=hexStringToByte(this.key)

de = new String(decryptData(hexStringToByte(data),key))

} catch (Exception e) {

e.printStackTrace()

}

return de

}

} 加密使用： byte[] key=Eryptogram.getSecretKey(deptid) //获得钥匙（字节数组）

byte[] tmp=Eryptogram.encryptData(password.getBytes(), key) //传入密码和钥匙，获得加密后的字节数组的密码

password=Eryptogram.bytesToHexString(tmp) //将字节数组转化为字符串，获得加密后的字符串密码解密与之差不多

java加密字符串可以使用des加密算法，实例如下：

package test

import java.io.FileInputStream

import java.io.FileOutputStream

import java.io.IOException

import java.io.ObjectInputStream

import java.io.ObjectOutputStream

import java.security.*

import javax.crypto.Cipher

import javax.crypto.KeyGenerator

import javax.crypto.SecretKey

/**

* 加密解密

*

* @author shy.qiu

* @since http://blog.csdn.net/qiushyfm

*/

public class CryptTest {

/**

* 进行MD5加密

*

* @param info

*要加密的信息

* @return String 加密后的字符串

*/

public String encryptToMD5(String info) {

byte[] digesta = null

try {

// 得到一个md5的消息摘要

MessageDigest alga = MessageDigest.getInstance("MD5")

// 添加要进行计算摘要的信息

alga.update(info.getBytes())

// 得到该摘要

digesta = alga.digest()

} catch (NoSuchAlgorithmException e) {

e.printStackTrace()

}

// 将摘要转为字符串

String rs = byte2hex(digesta)

return rs

}

/**

* 进行SHA加密

*

* @param info

*要加密的信息

* @return String 加密后的字符串

*/

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 (NoSuchAlgorithmException e) {

e.printStackTrace()

}

// 将摘要转为字符串

String rs = byte2hex(digesta)

return rs

}

// //////////////////////////////////////////////////////////////////////////

/**

* 创建密匙

*

* @param algorithm

*加密算法,可用 DES,DESede,Blowfish

* @return SecretKey 秘密（对称）密钥

*/

public SecretKey createSecretKey(String algorithm) {

// 声明KeyGenerator对象

KeyGenerator keygen

// 声明 密钥对象

SecretKey deskey = null

try {

// 返回生成指定算法的秘密密钥的 KeyGenerator 对象

keygen = KeyGenerator.getInstance(algorithm)

// 生成一个密钥

deskey = keygen.generateKey()

} catch (NoSuchAlgorithmException e) {

e.printStackTrace()

}

// 返回密匙

return deskey

}

/**

* 根据密匙进行DES加密

*

* @param key

*密匙

* @param info

*要加密的信息

* @return String 加密后的信息

*/

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)

}

/**

* 根据密匙进行DES解密

*

* @param key

*密匙

* @param sInfo

*要解密的密文

* @return String 返回解密后信息

*/

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)

}

// /////////////////////////////////////////////////////////////////////////////

/**

* 创建密匙组，并将公匙，私匙放入到指定文件中

*

* 默认放入mykeys.bat文件中

*/

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 (NoSuchAlgorithmException e) {

e.printStackTrace()

}

}

/**

* 利用私匙对信息进行签名 把签名后的信息放入到指定的文件中

*

* @param info

*要签名的信息

* @param signfile

*存入的文件

*/

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()

}

}

/**

* 读取数字签名文件 根据公匙，签名，信息验证信息的合法性

*

* @return true 验证成功 false 验证失败

*/

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

}

}

/**

* 将二进制转化为16进制字符串

*

* @param b

*二进制字节数组

* @return String

*/

public String byte2hex(byte[] b) {

String hs = ""

String stmp = ""

for (int n = 0n <b.lengthn++) {

stmp = (java.lang.Integer.toHexString(b[n] &0XFF))

if (stmp.length() == 1) {

hs = hs + "0" + stmp

} else {

hs = hs + stmp

}

}

return hs.toUpperCase()

}

/**

* 十六进制字符串转化为2进制

*

* @param hex

* @return

*/

public byte[] hex2byte(String hex) {

byte[] ret = new byte[8]

byte[] tmp = hex.getBytes()

for (int i = 0i <8i++) {

ret[i] = uniteBytes(tmp[i * 2], tmp[i * 2 + 1])

}

return ret

}

/**

* 将两个ASCII字符合成一个字节； 如："EF"-->0xEF

*

* @param src0

*byte

* @param src1

*byte

* @return byte

*/

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

}

/**

* 将指定的对象写入指定的文件

*

* @param file

*指定写入的文件

* @param objs

*要写入的对象

*/

public void doObjToFile(String file, Object[] objs) {

ObjectOutputStream oos = null

try {

FileOutputStream fos = new FileOutputStream(file)

oos = new ObjectOutputStream(fos)

for (int i = 0i <objs.lengthi++) {

oos.writeObject(objs[i])

}

} catch (Exception e) {

e.printStackTrace()

} finally {

try {

oos.close()

} catch (IOException e) {

e.printStackTrace()

}

}

}

/**

* 返回在文件中指定位置的对象

*

* @param file

*指定的文件

* @param i

*从1开始

* @return

*/

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 = 0j <ij++) {

obj = ois.readObject()

}

} catch (Exception e) {

e.printStackTrace()

} finally {

try {

ois.close()

} catch (IOException e) {

e.printStackTrace()

}

}

return obj

}

/**

* 测试

*

* @param args

*/

public static void main(String[] args) {

CryptTest jiami = new CryptTest()

// 执行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!")

}

}

}

---