Java 加密解密

package com.util;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.MessageDigest;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.Signature;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;

/**
 * 加密解密算法
 * 
 * @author wujinsong
 */
public class CryptUtil {
    
    public CryptUtil() {
        
    }
    
    /**
     * MD5加密
     * 
     * @param content 加密内容
     * @return String 加密后的内容
     */
    public String encryptToMD5(String content) {
        byte[] digesta = null;
        
        try {
            // 得到一个MD5消息摘要
            MessageDigest digest = MessageDigest.getInstance("MD5");
            // 添加要进行加密的内容
            digest.update(content.getBytes());
            // 得到消息摘要
            digesta = digest.digest();
        }
        catch (Exception e) {
            System.out.println(e.getMessage());
        }
        
        // 将消息摘要转化为字符串
        String rs = byte2hex(digesta);
        
        return rs;
    }
    
    /**
     * 进行SHA加密
     * 
     * @param content 要加密的内容
     * @return String 加密后的字符串
     */
    public String encryptToSHA(String content) {
        byte[] digesta = null;
        
        try {
            // 得到一个SHA-1的消息摘要
            MessageDigest digest = MessageDigest.getInstance("SH1-1");
            // 添加要进行加密的内容
            digest.update(content.getBytes());
            // 得到消息摘要
            digesta = digest.digest();
        }
        catch (Exception e) {
            System.out.println(e.getMessage());
        }
        
        // 将摘要转化为字符串
        String rs = byte2hex(digesta);
        
        return rs;
    }
    
    /**
     * 创建密钥
     * 
     * @param algorithm 加密算法，可用DES，DESede，Blowfish
     * @return SecretKey 秘密(对称)密钥
     */
    public SecretKey createSecretKey(String algorithm) {
        // 声明KeyGenerator对象
        KeyGenerator keyGenerator = null;
        // 声明密钥对象
        SecretKey secretKey = null;
        try {
            // 返回生成制定算法的秘密密钥的KeyGenerator对象
            keyGenerator = keyGenerator.getInstance(algorithm);
            // 生成一个密钥
            secretKey = keyGenerator.generateKey();
        }
        catch (Exception e) {
            System.out.println(e.getMessage());
        }
        
        return secretKey;
    }
    
    /**
     * DES加密
     * 
     * @param key
     * @param content
     * @return
     */
    public String encryptToDES(SecretKey key, String content) {
        // 定义加密算法，可用DES,DESede,Blowfish
        String algorithm = "DES";
        // 加密随机数生成器(RNG)，可以不屑
        SecureRandom random = new SecureRandom();
        // 定义要生成的密文
        byte[] cipherByte = null;
        try {
            // 得到加密/解密器
            Cipher cipher = Cipher.getInstance(algorithm);
            // 用指定的密钥和模式初始化Cipher对象
            // 参数:(ENCRYPT_MODE,DECRYPT_MODE.WRAP_MODE.UNWRAP_MODE)
            cipher.init(Cipher.ENCRYPT_MODE, key, random);
            // 对要加密的内容及进行编码处理
            cipherByte = cipher.doFinal(content.getBytes());
        }
        catch (Exception e) {
            System.out.println(e.getMessage());
        }
        
        return byte2hex(cipherByte);
    }
    
    /**
     * 根据密钥进行DES解密
     * 
     * @param key 密钥
     * @param content 要解密的密文
     * @return String 返回解密后的信息
     */
    public String decryptByDES(SecretKey key, String content) {
        // 定义加密算法
        String algorithm = "DES";
        // 加密随机数生成器(RNG)
        SecureRandom random = new SecureRandom();
        byte[] cipherByte = null;
        
        try {
            // 得到加密/解密器
            Cipher cipher = Cipher.getInstance(algorithm);
            // 用指定的密钥和模式初始化Cipher对象
            cipher.init(Cipher.DECRYPT_MODE, key, random);
            // 对要解密的内容进行编码处理
            cipherByte = cipher.doFinal(hex2byte(content));
        }
        catch (Exception e) {
            System.out.println(e.getMessage());
        }
        
        return new String(cipherByte);
    }
    
    /**
     * 创建密钥组，并将公钥，私钥放入到指定文件中
     * 默认放入mykeys.bat文件中
     */
    public void createPairKey() {
        try {
            // 根据特定的算法生成一个密钥对生成器
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("DSA");
            // 加密随机数生成器(RNG)
            SecureRandom random = new SecureRandom();
            // 重新设置此随机对象的种子
            random.setSeed(1000);
            // 使用给定的随机源（和默认的参数集合)初始化确定密钥大小的密钥对生成器
            keyPairGenerator.initialize(512, random);
            // 生成密钥组
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            // 得到公钥
            PublicKey publicKey = keyPair.getPublic();
            // 得到私钥
            PrivateKey privateKey = keyPair.getPrivate();
            // 将公钥和私钥写入到文档中
            persist2File("mykeys.bat", new Object[] { privateKey, publicKey });
        }
        catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
    
    /**
     * 利用私钥对信息进行签名，把签名的信息放到指定的文件中
     * 
     * @param content 要签名的内容更
     * @param signFile 存放的文件
     */
    public void signatureContent(String content, String signFile) {
        // 从文件当中读取私钥
        PrivateKey privateKey = (PrivateKey) getObjFromFile("mykeys.bat", 1);
        // 从文件中读取公钥
        PublicKey publicKey = (PublicKey) getObjFromFile("mykeys.bat", 2);
        
        try {
            // Signature 对象可用来生成和验证数字签名
            Signature signature = Signature.getInstance("DSA");
            // 初始化签署签名的私钥
            signature.initSign(privateKey);
            // 更新要由字节签名或验证的数据
            signature.update(content.getBytes());
            // 签署或验证所有更新字节的签名，返回签名
            byte[] signed = signature.sign();
            // 将数字签名，公钥信息放入文件中
            persist2File(signFile, new Object[] { signed, publicKey, content });
        }
        catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
    
    /**
     * 读取数字签名文件，工具公钥，签名信息验证信息的合法性
     * 
     * @param signFile 签名文件
     * @return
     */
    public boolean validateSign(String signFile) {
        // 读取公钥
        PublicKey publicKey = (PublicKey) getObjFromFile(signFile, 2);
        // 读取签名
        byte[] signed = (byte[]) getObjFromFile(signFile, 1);
        // 读取信息
        String content = (String) getObjFromFile(signFile, 3);
        
        try {
            // 初始化一个Signature对象，并用公钥和签名进行验证
            Signature signature = Signature.getInstance("DSA");
            // 初始化验证签名的公钥
            signature.initVerify(publicKey);
            // 使用指定的byte数组更新要签名或严验证的数据
            signature.update(content.getBytes());
            System.out.println(content);
            
            return signature.verify(signed);
        }
        catch (Exception e) {
            System.out.println(e.getMessage());
            return false;
        }
    }
    
    /**
     * 范围在文件中指定位置的对象
     * 
     * @param file 指定的文件
     * @param i
     * @return
     */
    private Object getObjFromFile(String file, int i) {
        ObjectInputStream inputStream = null;
        Object obj = null;
        
        try {
            FileInputStream fileInputStream = new FileInputStream(file);
            inputStream = new ObjectInputStream(fileInputStream);
            
            for (int j = 0; j < i; j++) {
                obj = inputStream.readObject();
            }
        }
        catch (Exception e) {
            System.out.println(e.getMessage());
        }
        finally {
            try {
                inputStream.close();
            }
            catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        
        return obj;
    }
    
    /**
     * 将对象写入指定的文件
     * 
     * @param string
     * @param objects
     */
    private void persist2File(String file, Object[] objects) {
        ObjectOutputStream objectOutputStream = null;
        
        try {
            FileOutputStream fileOutputStream = new FileOutputStream(file);
            objectOutputStream = new ObjectOutputStream(fileOutputStream);
            
            for (int i = 0; i < objects.length; i++) {
                objectOutputStream.writeObject(objects[i]);
            }
        }
        catch (Exception e) {
            System.out.println(e.getMessage());
        }
        finally {
            try {
                objectOutputStream.close();
            }
            catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
    
    /**
     * 将2进制转化为16进制
     * 
     * @param b
     * @return
     */
    public String byte2hex(byte[] b) {
        String hs = "";
        String stmp = "";
        
        for (int i = 0; i < b.length; i++) {
            stmp = Integer.toHexString(b[i] & 0xFF);
            if (stmp.length() == 1) {
                hs = hs + "0" + stmp;
            }
            else {
                hs = hs + stmp;
            }
        }
        
        return hs.toUpperCase();
    }
    
    /**
     * 将十六进制转化为2进制
     * 
     * @param hex 16进制数
     * @return
     */
    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;
    }
    
    /**
     * 将两个ASCII字符合成一个字节：如："EF" -->0xEF
     * 
     * @param src0
     * @param src1
     * @return
     */
    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 static void main(String[] args) {
        CryptUtil cryptUtil = new CryptUtil();
        System.out.println("Hello经过MD5加密:" + cryptUtil.encryptToMD5("Hello"));
        SecretKey key = cryptUtil.createSecretKey("DES");
        String str1 = cryptUtil.encryptToDES(key, "Hello");
        System.out.println("使用des加密信息为Hello为：" + str1);
        String str2 = cryptUtil.decryptByDES(key, str1);
        System.out.println(str2);
        cryptUtil.createPairKey();
        cryptUtil.signatureContent("Hello", "mysign.bat");
        if (cryptUtil.validateSign("mysign.bat")) {
            System.out.println("Success!");
        }
        else {
            System.out.println("Failure");
        }
    }
}