JAVA--数据加密之AES+RSA

前言

在开发工作中比较频繁的使用到数据的加密，今天记录下AES+RSA加密在JAVA中的应用。

一、使用场景

关于AES和RSA的详细特点大家可去详细研究一下，现在说一下他们的特性：
1.AES：对称加密，即一个公钥可对原文加密，也可对密文还原；加解密速度快，所以适合对数据量大的数据加密。
2.RSA：非对称加密，即拥有一个公私**对，公钥加密私钥解密，反之亦然。但是j加解密速度慢，所以一般只对少量数据加密

综上，所以我们在做数据加密的时候步骤是：

1.先产出一对RSA公私钥密码对，由前端和后端分别保存。
2.AES公钥使用随机产生
3.数据传输时使用RSA加密AES的公钥，使用AES的公钥加密原文。（此时，得到被RSA加密的AES公钥和被AES加密的原文）
4.前端拿到数据后，使用RSA解出AES公钥，在使用AES公钥解出密文

整个步骤结束。这样去做的原因是因为上边我提到的AES和RSA的特性所制定的数据加密方式，反过来前端加密数据后端还原的道理是一样的。

二、实现

1.下面贴出我的AES/RSA util类

package com.hziot.agriculture.encryption;

import org.apache.commons.codec.binary.Base64;

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;

public class AESCoder {

    private static final String CipherMode="AES/CBC/PKCS5Padding";
 
    //private static final String SecretKey="zzh";
 
    private static final Integer IVSize=16;
 
    private static final String EncryptAlg ="AES";
 
    private static final String Encode="UTF-8";
 
    private static final int SecretKeySize=32;
 
    private static final String Key_Encode="UTF-8";

    /**
     * 创建**
     * @return
     */
    private static SecretKeySpec createKey(String secretKey){
        StringBuilder sb=new StringBuilder(SecretKeySize);
        sb.append(secretKey);
        if (sb.length()>SecretKeySize){
            sb.setLength(SecretKeySize);
        }
        if (sb.length()<SecretKeySize){
            while (sb.length()<SecretKeySize){
                sb.append(" ");
            }
        }
        try {
            byte[] data=sb.toString().getBytes(Encode);
            return new SecretKeySpec(data, EncryptAlg);
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 创建16位向量: 不够则用0填充
     * @return
     */
    private static IvParameterSpec createIV(String secretKey) {
        StringBuffer sb = new StringBuffer(IVSize);
        sb.append(secretKey);
        if (sb.length()>IVSize){
            sb.setLength(IVSize);
        }
        if (sb.length()<IVSize){
            while (sb.length()<IVSize){
                sb.append("0");
            }
        }
        byte[] data=null;
        try {
             data=sb.toString().getBytes(Encode);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return new IvParameterSpec(data);
    }
 
    /**
     * 加密：有向量16位，结果转base64
     * @param context
     * @return
     */
    public static String encrypt(String context,String secretKey) {
        try {
            byte[] content=context.getBytes(Encode);
            SecretKeySpec key = createKey(secretKey);
            Cipher cipher = Cipher.getInstance(CipherMode);
            cipher.init(Cipher.ENCRYPT_MODE, key, createIV(secretKey));
            byte[] data = cipher.doFinal(content);
            String result= Base64.encodeBase64String(data);
            return result;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
 
    /**
     * 解密
     * @param context
     * @return
     */
    public static String decrypt(String context,String secretKey) {
        try {
            byte[] data= Base64.decodeBase64(context);
            SecretKeySpec key = createKey(secretKey);
            Cipher cipher = Cipher.getInstance(CipherMode);
            cipher.init(Cipher.DECRYPT_MODE, key, createIV(secretKey));
            byte[] content = cipher.doFinal(data);
            String result=new String(content,Encode);
            return result;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * PKCS5Padding -- Pkcs7 两种padding方法都可以
     * @param context 3c2b1416d82883dfeaa6a9aa5ecb8245  16进制
     * @param key
     * @return
     */
    public static String decryptAES(String context, String key) {
        try {
            byte[] data= Base64.decodeBase64(context);
            SecretKeySpec skeySpec = new SecretKeySpec(key.getBytes(StandardCharsets.UTF_8), "AES");
            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding"); // "算法/模式/补码方式"
            cipher.init(Cipher.DECRYPT_MODE, skeySpec);
            return new String(cipher.doFinal(data));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    /**将16进制转换为二进制
     * @param hexStr
     * @return
     */
    public static byte[] parseHexStr2Byte(String hexStr) {
        if (hexStr.length() < 1)
            return null;
        byte[] result = new byte[hexStr.length() / 2];
        for (int i = 0; i < hexStr.length() / 2; i++) {
            int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
            int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2), 16);
            result[i] = (byte) (high * 16 + low);
        }
        return result;
    }

}

package com.hziot.agriculture.encryption;

import javax.crypto.Cipher;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;


/**
 * 非对称加密算法RSA算法组件
 * 非对称算法一般是用来传送对称加密算法的**来使用的，相对于DH算法，RSA算法只需要一方构造**，不需要
 * 大费周章的构造各自本地的**对了。DH算法只能算法非对称算法的底层实现。而RSA算法算法实现起来较为简单
 *
 */
public class RSACoder {
    //非对称**算法
    public static final String KEY_ALGORITHM = "RSA";
    /**
          * **长度，DH算法的默认**长度是1024
          * **长度必须是64的倍数，在512到65536位之间
     */
    private static final int KEY_SIZE = 2048;
    //公钥
    private static final String PUBLIC_KEY = "RSAPublicKey";
    //私钥
    private static final String PRIVATE_KEY = "RSAPrivateKey";

    /**
     * 初始化**对
     *
     * @return Map 甲方**的Map
     */
    public static Map<String, Object> initKey() throws Exception {
//    	final int KEY_SIZE = key_size;
        //实例化**生成器
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        //初始化**生成器
        keyPairGenerator.initialize(KEY_SIZE);
        //生成**对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        //甲方公钥
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        //甲方私钥
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        //将**存储在map中
        Map<String, Object> keyMap = new HashMap<String, Object>();
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
        System.out.println("PUBLIC_KEY:"+publicKey);
        System.out.println("PRIVATE_KEY:"+privateKey);
        return keyMap;
    }


    /**
     * 私钥加密
     *
     * @param data 待加密数据
     * @param key       **
     * @return byte[] 加密数据
     */
    public static byte[] encryptByPrivateKey(byte[] data, byte[] key) throws Exception {

        //取得私钥
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        //生成私钥
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
        //数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, privateKey);
        return cipher.doFinal(data);
    }

    /**
           * 公钥加密
     *
     * @param data 待加密数据
     * @param key       **
     * @return byte[] 加密数据
     */
    public static byte[] encryptByPublicKey(byte[] data, byte[] key) throws Exception {

        //实例化**工厂
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        //初始化公钥
        //**材料转换
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
        //产生公钥
        PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);

        //数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, pubKey);
        return cipher.doFinal(data);
    }

    /**
     * 私钥解密
     *
     * @param data 待解密数据
     * @param key  **
     * @return byte[] 解密数据
     */
    public static byte[] decryptByPrivateKey(byte[] data, byte[] key) throws Exception {
    	java.security.Security.addProvider(
        	    new org.bouncycastle.jce.provider.BouncyCastleProvider()
    	);
        //取得私钥
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        //生成私钥
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
        //数据解密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        return cipher.doFinal(data);
    }

    /**
     * 公钥解密
     *
     * @param data 待解密数据
     * @param key  **
     * @return byte[] 解密数据
     */
    public static byte[] decryptByPublicKey(byte[] data, byte[] key) throws Exception {

        //实例化**工厂
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        //初始化公钥
        //**材料转换
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
        //产生公钥
        PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);
        //数据解密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, pubKey);
        return cipher.doFinal(data);
    }

    /**
     * 取得私钥
     * @param keyMap **map
     * @return byte[] 私钥
     */
    public static byte[] getPrivateKey(Map<String, Object> keyMap) {
        Key key = (Key) keyMap.get(PRIVATE_KEY);
        return key.getEncoded();
    }
    /**
     * 取得公钥
     *
     * @param keyMap **map
     * @return byte[] 公钥
     */
    public static byte[] getPublicKey(Map<String, Object> keyMap) throws Exception {
        Key key = (Key) keyMap.get(PUBLIC_KEY);
        return key.getEncoded();
    }
}

##下边是我在项目中使用的的某个代码片段，resKey提前和前端协商好,这里是前端进行的一次数据加密，我这边做的一个解密。
   			rsaKey rsakey = new rsaKey();
            //1.使用rsa解密除aes的public key
            byte[] aesKey = RSACoder.decryptByPrivateKey(Base64.decodeBase64(enAesKey),Base64.decodeBase64(rsakey.getPrivateKey()));
            //2.使用aes key 解密出原文
            String aseKeyStr = new String(aesKey);

            String _id = AESCoder.decryptAES(id,aseKeyStr);
            String _pwd = AESCoder.decryptAES(pwd,aseKeyStr);