Java Web学习（三）数据加密方式详解

一、对称加密

定义：加密和解密使用相同密钥的算法。

常见的有DES、3DES、AES、PBE等加密算法，这几种算法安全性依次是逐渐增强的。

DES加密

特点：简便、密钥长度比较短。

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

/**
 * DES加密介绍
 * DES是一种对称加密算法，所谓对称加密算法即：加密和解密使用相同密钥的算法。DES加密算法出自IBM的研究，
 * 后来被美国政府正式采用，之后开始广泛流传，但是近些年使用越来越少，因为DES使用56位密钥，以现代计算能力，
 * 24小时内即可被破解。虽然如此，在某些简单应用中，我们还是可以使用DES加密算法，本文简单讲解DES的JAVA实现
 * 。
 * 注意：DES加密和解密过程中，密钥长度都必须是8的倍数
 */
public class DESUtil {

    /**
     * 加密
     *
     * @param datasource byte[]  需要加密的数据.getBytes()
     * @param password   String   密码（作用：生成密钥，长度要是8的倍数）
     * @return byte[]
     */
    public static byte[] encrypt(byte[] datasource, String password) {
        try {
            //1、实例化一个DES密匙工厂
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
            //2、使用密码，创建一个DESKeySpec对象
            DESKeySpec desKey = new DESKeySpec(password.getBytes());
            //3、DES密匙工厂生成DES密钥
            SecretKey securekey = keyFactory.generateSecret(desKey);
            //4、实例化一个DES类型的Cipher对象，Cipher对象实际完成加密操作
            Cipher cipher = Cipher.getInstance("DES");
            //5、用密匙初始化Cipher对象
            SecureRandom random = new SecureRandom();//DES算法要求有一个可信任的随机数源
            cipher.init(Cipher.ENCRYPT_MODE, securekey, random);
            //6、正式执行加密操作
            return 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 {
        //1、实例化一个DES密匙工厂
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
        //2、使用密码，创建一个DESKeySpec对象
        DESKeySpec desKey = new DESKeySpec(password.getBytes());
        //3、DES密匙工厂生成DES密钥
        SecretKey securekey = keyFactory.generateSecret(desKey);
        //4、实例化一个DES类型的Cipher对象，Cipher对象实际完成解密操作
        Cipher cipher = Cipher.getInstance("DES");
        //5、用密匙初始化Cipher对象
        SecureRandom random = new SecureRandom();//DES算法要求有一个可信任的随机数源
        cipher.init(Cipher.DECRYPT_MODE, securekey, random);
        //6、真正开始解密操作
        return cipher.doFinal(src);
    }

    //测试
    public static void main(String args[]) {
        //待加密内容
        String str = "测试内容";
        //密码，长度要是8的倍数
        String password = "9588028820109132570743325311898426347857298773549468758875018579537757772163084478873699447306034466200616411960574122434059469100235892702736860872901247123456";

        byte[] result = encrypt(str.getBytes(), password);
        System.out.println("加密后：" + new String(result));
        //直接将如上内容解密
        try {
            byte[] decryResult = decrypt(result, password);
            System.out.println("解密后：" + new String(decryResult));
        } catch (Exception e1) {
            e1.printStackTrace();
        }
    }


}

AES加密

特点：简便、相比DES更安全。

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.security.SecureRandom;
import java.util.Base64;

/**
 * AES 加密方法，是对称的密码算法(加密与解密的密钥一致)，这里使用最大的 256 位的密钥
 * PS:加密比DES安全，但同时速度也会相对慢一些
 */
public class AESUtil {
    /**
     * 获得一个长度为128位的AES密钥（256的需要换jar包，具体原因请参考网络）
     *
     * @return 返回经 BASE64 处理之后的密钥字符串
     */
    public static String getStrKeyAES() throws Exception {
        //密钥生成器,指定生成AES类型的密钥
        KeyGenerator keyGen = KeyGenerator.getInstance("AES");
        //加密的强随机数
        SecureRandom secureRandom = new SecureRandom(String.valueOf(System.currentTimeMillis()).getBytes("utf-8"));
        //初始化密钥生成器的长度为128位
        keyGen.init(128, secureRandom);   // 这里可以是 128、192、256、越大越安全
        //生成密钥
        SecretKey secretKey = keyGen.generateKey();
        //Base64.getEncoder():使用base64编码来编码字节数据（多加一步更安全）
        return Base64.getEncoder().encodeToString(secretKey.getEncoded());
    }

    /**
     * 将使用 Base64 加密后的字符串类型的 SecretKey 解码为 SecretKey
     *
     * @param strKey
     * @return SecretKey
     */
    public static SecretKey strKey2SecretKey(String strKey) {
        byte[] bytes = Base64.getDecoder().decode(strKey);
        SecretKeySpec secretKey = new SecretKeySpec(bytes, "AES");
        return secretKey;
    }

    /**
     * 加密
     *
     * @param content   待加密内容
     * @param secretKey 加密使用的 AES 密钥
     * @return 加密后的密文 byte[]
     */
    public static byte[] encryptAES(byte[] content, SecretKey secretKey) throws Exception {
        Cipher cipher = Cipher.getInstance("AES");
        cipher.init(Cipher.ENCRYPT_MODE, secretKey);
        return cipher.doFinal(content);
    }

    /**
     * 解密
     *
     * @param content   待解密内容
     * @param secretKey 解密使用的 AES 密钥
     * @return 解密后的明文 byte[]
     */
    public static byte[] decryptAES(byte[] content, SecretKey secretKey) throws Exception {
        Cipher cipher = Cipher.getInstance("AES");
        cipher.init(Cipher.DECRYPT_MODE, secretKey);
        return cipher.doFinal(content);
    }


    //测试
    public static void main(String args[]) throws Exception {
        //待加密内容
        String str = "测试内容";
        //获得一个经 BASE64 处理之后的密钥字符串
        String secretKeyStr = getStrKeyAES();
        //用BASE64方式处理密钥字符串，获取密钥
        SecretKey secretKey = strKey2SecretKey(secretKeyStr);
        //获得加密后的内容
        byte[] result = encryptAES(str.getBytes(), secretKey);
        System.out.println("加密后：" + new String(result));
        //将如上内容解密
        try {
            byte[] decryResult = decryptAES(result, secretKey);
            System.out.println("解密后：" + new String(decryResult));
        } catch (Exception e1) {
            e1.printStackTrace();
        }
    }
}

二、非对称加密

定义：非对称加密算法需要两个密钥：公开密钥（publickey）和私有密钥（privatekey）。一般公钥是公开的，私钥是自己保存。

常见的有RSA算法

RSA加密

具体的使用方法请参照网络，这个加密方式暂时还没玩透...😂😂😂

 

参考资料：

• chengbinbbs（特此感谢！）
• FKNIGHT0X（特此感谢！）
• Central-Perk（特此感谢！）