[深圳|结业弟子]JAVA-张粤艺|2020年06月11日的日报-技能树.IT修真院

发表于： 2020-06-11 22:34:05

1 1683

今天完成的事情：

1. 了解 DES、cookie

遇到的问题：

1. DES

原本以为这个要自己实现，后来发现已经是一个类库了

看了一下网上的实现也是各显神通，主要的区别就是 byte[] 与 String 的转换，其他的都差不多。

2. 拦截器

关于拦截器我之前都没用过，今天看了一下主要是实现 HandlerInterceptor 接口。

preHandle：在 controller 之前对传入的参数做修改，会返回一个 boolean，这决定了之后的 postHandle、afterCompletion 要不要进行处理。

postHandle：如果 preHandle 返回了 true，那么就在 controller 处理完后开始渲染前对数据做处理。

afterCompletion：在渲染完成后做一些处理，一般是清理资源。

今天了解的也就仅此而已了，怎么处理 cookie 我还不知道。

3. 为什么 cookie 中只对用户名与登录时间做 DES 呢？

我能想到的原因：

a，DES 并不安全，加密码进去后果可能比较严重

b，用户名与登录时间已经足够做登录校验

4. DES 加密时间

发现一个问题，如果让 DES 用刚刚生成的密钥去加密，那么需要 10 ms 左右。但是如果把密钥复制下来下次去加密那就需要几百毫秒。

实际测试下来我发现了一个更意思的事情，这个加密可能本来就要花费好几百毫秒不过我还没去验证。明天仔细分析一下。

代码我放在这里，可以试一下：

import java.security.SecureRandom;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKeyFactory;
import javax.crypto.SecretKey;
import javax.crypto.Cipher;

/**
 * @ClassName DES
 * @Description DES 加解密
 * @Author owlwinter
 * @Date 2020/6/11 18:52
 * @Version 1.0
 **/

public class DES {
    /**
     * 加密
     * @param datasource byte[]
     * @param password String
     * @return byte[]
     */
    public static String encrypt(byte[] datasource, String password) {
        try{
            SecureRandom random = new SecureRandom();
            DESKeySpec desKey = new DESKeySpec(password.getBytes());
            //创建一个密匙工厂，然后用它把DESKeySpec转换成
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
            SecretKey securekey = keyFactory.generateSecret(desKey);
            //Cipher对象实际完成加密操作
            Cipher cipher = Cipher.getInstance("DES");
            //用密匙初始化Cipher对象
            cipher.init(Cipher.ENCRYPT_MODE, securekey, random);
            //现在，获取数据并加密
            //正式执行加密操作
            return byteArr2HexStr(cipher.doFinal(datasource));
        }catch(Throwable e){
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 解密
     * @param src byte[]
     * @param password String
     * @return byte[]
     * @throws Exception
     */
    public static byte[] decrypt(byte[] src, String password) throws Exception {
        // DES算法要求有一个可信任的随机数源
        SecureRandom random = new SecureRandom();
        // 创建一个DESKeySpec对象
        DESKeySpec desKey = new DESKeySpec(password.getBytes());
        // 创建一个密匙工厂
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
        // 将DESKeySpec对象转换成SecretKey对象
        SecretKey securekey = keyFactory.generateSecret(desKey);
        // Cipher对象实际完成解密操作
        Cipher cipher = Cipher.getInstance("DES");
        // 用密匙初始化Cipher对象
        cipher.init(Cipher.DECRYPT_MODE, securekey, random);
        // 真正开始解密操作
        return cipher.doFinal(src);
    }

    /**
     * 将byte数组转换为表示16进制值的字符串， 如：byte[]{8,18}转换为：0813， 和public static byte[]
     * hexStr2ByteArr(String strIn) 互为可逆的转换过程

     *
     * @param arrB
     *            需要转换的byte数组

     * @return 转换后的字符串
     * @throws Exception
     *             本方法不处理任何异常，所有异常全部抛出
     */
    private static String byteArr2HexStr(byte[] arrB) throws Exception {
        int iLen = arrB.length;
        // 每个byte用两个字符才能表示，所以字符串的长度是数组长度的两倍

        StringBuffer sb = new StringBuffer(iLen * 2);
        for (int i = 0; i < iLen; i++) {
            int intTmp = arrB[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 byteArr2HexStr(byte[] arrB)
     * 互为可逆的转换过程

     *
     * @param strIn
     *            需要转换的字符串
     * @return 转换后的byte数组

     * @throws Exception
     *             本方法不处理任何异常，所有异常全部抛出
     */
    private static byte[] hexStr2ByteArr(String strIn) throws Exception {
        byte[] arrB = strIn.getBytes();
        int iLen = arrB.length;

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

    //随机生成密钥
    private static String getKey() throws Exception{
        // DES算法要求有一个可信任的随机数源
        SecureRandom sr = new SecureRandom();
        // 为我们选择的DES算法生成一个KeyGenerator对象
        KeyGenerator kg = KeyGenerator.getInstance("DES");
        kg.init(sr);
        // 生成密匙
        SecretKey key = kg.generateKey();
        // 获取密匙数据
        byte rawKeyData[] = key.getEncoded();

        //return new String(rawKeyData);

        return byteArr2HexStr(rawKeyData);
    }

    /**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {

        //待加密内容
        String str = "我想要测试";
        //密码，长度要是8的倍数
        String key = "79a8ae23467c8052"; // 如果把密钥保存下来测试，加密要几百毫秒

        //随机生成密钥
        //key=getKey(); // 用刚刚随机生成的密钥加密会很快
        System.out.println("随机密钥：" + key);

        long startEncrypt = System.currentTimeMillis(); //开始加密时间戳
        String result = DES.encrypt(str.getBytes("UTF8"),key);
        long finshEncrypt = System.currentTimeMillis(); //加密结束时间戳
        System.out.println("加密后："+result);
        System.out.println("加密耗时: " + (finshEncrypt - startEncrypt) + "ms");

        //直接将如上内容解密
        long startDecrypt = System.currentTimeMillis(); // 开始解密时间戳
        try {
            byte[] decryResult = DES.decrypt(hexStr2ByteArr(result), key);
            System.out.println("解密后："+new String(decryResult));
        } catch (Exception e1) {
            e1.printStackTrace();
        }
       long finshDecrypt = System.currentTimeMillis(); // 解密结束时间戳
       System.out.println("解密耗时: " + (finshDecrypt - startDecrypt) + "ms");
    }

}