DES加密解密工具類

package com.fastech.ws;

import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.spec.InvalidKeySpecException;
 
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;

import com.sun.jersey.core.util.Base64;
 
/**
 * DES加密和解密。
 *
 * @author mnn
 * @date 2017年12月14日
 */
public class DESUtil {
 
    /** 安全密鑰 */
    private String keyData = "ABCDEFGHIJKLMNOPQRSTWXYZabcdefghijklmnopqrstwxyz0123456789-_.";
 
    /**
     * 功能：構造
     *
     * @author mnn
     * @date 2017年12月14日
     */
    public DESUtil() {
    }
 
    /**
     * 功能：構造
     *
     * @author mnn
     * @date 2017年12月14日
     * @param keyData
     *  key
     */
    public DESUtil(String key) {
        this.keyData = key;
    }
 
    /**
     * 功能：加密 (UTF-8)
     *
     * @author mnn
     * @date 2017年12月14日
     * @param source
     *  源字符串
     * @param charSet
     *  編碼
     * @return String
     * @throws UnsupportedEncodingException
     *  編碼異常
     */
    public String encrypt(String source) throws UnsupportedEncodingException {
        return encrypt(source, "UTF-8");
    }
 
    /**
     *
     * 功能：解密 (UTF-8)
     *
     * @author mnn
     * @date 2017年12月14日
     * @param encryptedData
     *  被加密后的字符串
     * @return String
     * @throws UnsupportedEncodingException
     *  編碼異常
     */
    public String decrypt(String encryptedData)
            throws UnsupportedEncodingException {
        return decrypt(encryptedData, "UTF-8");
    }
 
    /**
     * 功能：加密
     *
     * @author mnn
     * @date 2017年0712月14日
     * @param source
     *  源字符串
     * @param charSet
     *  編碼
     * @return String
     * @throws UnsupportedEncodingException
     *  編碼異常
     */
    public String encrypt(String source, String charSet)
            throws UnsupportedEncodingException {
        String encrypt = null;
        byte[] ret = encrypt(source.getBytes(charSet));
        encrypt = new String(Base64.encode(ret));
        return encrypt;
    }
 
    /**
     *
     * 功能：解密
     *
     * @author mnn
     * @date 2017年12月14日
     * @param encryptedData
     *  被加密后的字符串
     * @param charSet
     *  編碼
     * @return String
     * @throws UnsupportedEncodingException
     *  編碼異常
     */
    public String decrypt(String encryptedData, String charSet)
            throws UnsupportedEncodingException {
        String descryptedData = null;
        byte[] ret = descrypt(Base64.decode(encryptedData));
        descryptedData = new String(ret, charSet);
        return descryptedData;
    }
 
    /**
     * 加密數據 用生成的密鑰加密原始數據
     *
     * @param primaryData
     *  原始數據
     * @return byte[]
     * @author mnn
     * @date 2017年12月14日
     */
    private byte[] encrypt(byte[] primaryData) {
 
        /** 取得安全密鑰 */
        byte rawKeyData[] = getKey();
 
        /** DES算法要求有一個可信任的隨機數源 */
        SecureRandom sr = new SecureRandom();
 
        /** 使用原始密鑰數據創建DESKeySpec對象 */
        DESKeySpec dks = null;
        try {
            dks = new DESKeySpec(keyData.getBytes());
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        }
 
        /** 創建一個密鑰工廠 */
        SecretKeyFactory keyFactory = null;
        try {
            keyFactory = SecretKeyFactory.getInstance("DES");
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
 
        /** 用密鑰工廠把DESKeySpec轉換成一個SecretKey對象 */
        SecretKey key = null;
        try {
            key = keyFactory.generateSecret(dks);
        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
        }
 
        /** Cipher對象實際完成加密操作 */
        Cipher cipher = null;
        try {
            cipher = Cipher.getInstance("DES");
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        }
 
        /** 用密鑰初始化Cipher對象 */
        try {
            cipher.init(Cipher.ENCRYPT_MODE, key, sr);
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        }
 
        /** 正式執行加密操作 */
        byte encryptedData[] = null;
        try {
            encryptedData = cipher.doFinal(primaryData);
        } catch (IllegalStateException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        }
 
        /** 返回加密數據 */
        return encryptedData;
    }
 
    /**
     * 用密鑰解密數據
     *
     * @param encryptedData
     *  加密后的數據
     * @return byte[]
     * @author mnn
     * @date 2017年12月14日
     */
    private byte[] descrypt(byte[] encryptedData) {
 
        /** DES算法要求有一個可信任的隨機數源 */
        SecureRandom sr = new SecureRandom();
 
        /** 取得安全密鑰 */
        byte rawKeyData[] = getKey();
 
        /** 使用原始密鑰數據創建DESKeySpec對象 */
        DESKeySpec dks = null;
        try {
            dks = new DESKeySpec(keyData.getBytes());
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        }
 
        /** 創建一個密鑰工廠 */
        SecretKeyFactory keyFactory = null;
        try {
            keyFactory = SecretKeyFactory.getInstance("DES");
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
 
        /** 用密鑰工廠把DESKeySpec轉換成一個SecretKey對象 */
        SecretKey key = null;
        try {
            key = keyFactory.generateSecret(dks);
        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
        }
 
        /** Cipher對象實際完成加密操作 */
        Cipher cipher = null;
        try {
            cipher = Cipher.getInstance("DES");
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        }
 
        /** 用密鑰初始化Cipher對象 */
        try {
            cipher.init(Cipher.DECRYPT_MODE, key, sr);
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        }
 
        /** 正式執行解密操作 */
        byte decryptedData[] = null;
        try {
            decryptedData = cipher.doFinal(encryptedData);
        } catch (IllegalStateException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        }
 
        return decryptedData;
    }
 
    /**
     * 取得安全密鑰 此方法作廢,因為每次key生成都不一樣導致解密加密用的密鑰都不一樣， 從而導致Given final block not
     * properly padded錯誤.
     *
     * @return byte數組
     * @author mnn
     * @date 2017年12月14日
     */
    private byte[] getKey() {
 
        /** DES算法要求有一個可信任的隨機數源 */
        SecureRandom sr = new SecureRandom();
 
        /** 為我們選擇的DES算法生成一個密鑰生成器對象 */
        KeyGenerator kg = null;
        try {
            kg = KeyGenerator.getInstance("DES");
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        kg.init(sr);
 
        /** 生成密鑰工具類 */
        SecretKey key = kg.generateKey();
 
        /** 生成密鑰byte數組 */
        byte rawKeyData[] = key.getEncoded();
 
        return rawKeyData;
    }
 public static void main(String[] args) throws UnsupportedEncodingException {
     DESUtil desUtil=new DESUtil();
     String sourse="22222222222222";
     String encryString =desUtil.encrypt(sourse);//加密
     String decryString =desUtil.decrypt(encryString);//解密
     System.out.println(sourse+"DES加密后為:"+encryString);
     System.out.println(encryString+"DES解密后為:"+decryString);
}
}