欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

DES(一)加密解密工具类

程序员文章站 2022-03-12 19:37:08
...

import org.junit.Test;

import javax.crypto.Cipher;
import java.security.Key;
import java.security.Security;

/**
 * 描述 des加密工具类
 *
 * @author ***
 * @date 2019/7/10 9:27
 */
public class DesUtil {
    /**
     * 随机字符串
     */
    private static final String RANDOM_STRING = "hoaiudhfliojoajidflkadnfak";

    /**
     * 加密模式为des
     */
    private static final String ENCRYPTION_MODE = "DES";

    /**
     * 加密器
     */
    private static Cipher encryptCipher = null;

    /**
     * 解密器
     */
    private static Cipher decryptCipher = null;

    static {
        Security.addProvider(new com.sun.crypto.provider.SunJCE());
        try {
            Key key = getKey(RANDOM_STRING.getBytes("UTF8"));
            //初始化解密器
            encryptCipher = Cipher.getInstance(ENCRYPTION_MODE);
            encryptCipher.init(Cipher.ENCRYPT_MODE, key);
            //初始化解密器
            decryptCipher = Cipher.getInstance(ENCRYPTION_MODE);
            decryptCipher.init(Cipher.DECRYPT_MODE, key);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    /**
     * 描述 入口-加密字符串
     *
     * @param str
     * @return String
     * @author ***
     * @date 2019/7/9 18:46
     */
    public static String encrypt(String str) throws Exception {
        String cipherStr = byteArrToHexStr(entry(str.getBytes("UTF8")));
        return cipherStr;
    }

    /**
     * 描述 入口-解密字符串
     *
     * @param str
     * @return String
     * @author ***
     * @date 2019/7/9 19:00
     */
    public static String decrypt(String str) throws Exception {
        String cipherStr = new String(decrypt(hexStrToByteArr(str)), "UTF8");
        return cipherStr;
    }

    /**
     * 描述 加密字节数组
     *
     * @param byteArray
     * @return byte[]
     * @author ***
     * @date 2019/7/9 18:43
     */
    static byte[] entry(byte[] byteArray) throws Exception {
        return encryptCipher.doFinal(byteArray);
    }

    /**
     * 描述 解密字节数组
     *
     * @param byteArray
     * @return byte[]
     * @author ***
     * @date 2019/7/9 19:08
     */
    static byte[] decrypt(byte[] byteArray) throws Exception {
        return decryptCipher.doFinal(byteArray);
    }

    /**
     * 描述 加密过程->将byte数组转换为表示16进制值的字符串, 如:byte[]{8,18}转换为:0813,
     * 此方法与 public static byte[] hexStrToByteArr(String strIn) 互为可逆的转换过程
     *
     * @param byteArray
     * @return String
     * @author ***
     * @date 2019/7/9 18:47
     */
    private static String byteArrToHexStr(byte[] byteArray) throws Exception {
        int iLength = byteArray.length;

        /**
         * 一个字节,8位二进制
         * 十六进制,一个十六进制可以表示4位二进制
         * 所以一个字节需要2个十六进制‘字符’来表示
         * 所以定义字符串的长度应是数组长度的两倍
         */
        StringBuffer sb = new StringBuffer(iLength * 2);

        for (int i = 0; i < iLength; i++) {
            int intTmp = byteArray[i];
            // 把负数转换为正数
            while (intTmp < 0) {
                intTmp = intTmp + 256;
            }

            // 小于0F的数需要在前面补0
            if (intTmp < 16) {
                sb.append("0");
            }

            sb.append(Integer.toString(intTmp, 16));
        }

        return sb.toString();
    }

    /**
     * 描述 解密过程->将表示16进制值的字符串转换为byte数组,
     * 此方法与public static String byteArrToHexStr(byte[] byteArray) 互为可逆的转换过程
     *
     * @param str
     * @return byte[]
     * @author ***
     * @date 2019/7/9 19:04
     */
    static byte[] hexStrToByteArr(String str) throws Exception {
        byte[] resArray = str.getBytes("UTF8");
        int iLength = resArray.length;

        // 两个字符表示一个字节,所以字节数组长度是字符串长度除以2
        byte[] arrOut = new byte[iLength / 2];
        for (int i = 0; i < iLength; i = i + 2) {
            String strTmp = new String(resArray, i, 2, "UTF8");
            arrOut[i / 2] = (byte) Integer.parseInt(strTmp, 16);
        }

        return arrOut;
    }

    /**
     * 描述 根据随机字符串生成一个秘钥key
     *
     * @param byteArray
     * @return Key
     * @author ***
     * @date 2019/7/9 18:19
     */
    static Key getKey(byte[] byteArray) {
        //定义一个长度为8的字节数组
        byte[] bytesArr = new byte[8];

        //取原始字节数组的前8个,用于生成秘钥
        for (int i = 0; i < bytesArr.length && i < byteArray.length; i++) {
            bytesArr[i] = byteArray[i];
        }

        //生成秘钥
        Key key = new javax.crypto.spec.SecretKeySpec(bytesArr, ENCRYPTION_MODE);
        return key;
    }


    @Test
    public void test01() {
        try {
            String mingwen = "admin123";
            String miwen = encrypt(mingwen);
            System.out.println(miwen);
            String mw = decrypt(miwen);
            System.out.println(mw);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}