spring boot + vue 实现 rsa 非对称加密

1. 背景

在我们平时项目开发过程中经常会遇到各种各样的安全问题，为了防止我们的业务数据不被泄露，提高我们系统的安全性，在数据传输的时候我们对传输的数据加密。

2.加密分类

我们平时接触到的加密算法有很多种，如：md5,base64 等。它们可以分为：对称加密，非对称加密和hash加密。

对称加密 指加密和解密使用相同密钥的加密算法。对称加密算法的优点在于加解密的高速度和使用长密钥时的难破解性。假设两个用户需要使用对称加密方法加密然后交换数据，则用户最少需要2个密钥并交换使用，如果企业内用户有n个，则整个企业共需要n×(n-1) 个密钥，密钥的生成和分发将成为企业信息部门的恶梦。对称加密算法的安全性取决于加密密钥的保存情况，但要求企业中每一个持有密钥的人都保守秘密是不可能的，他们通常会有意无意的把密钥泄漏出去——如果一个用户使用的密钥被入侵者所获得，入侵者便可以读取该用户密钥加密的所有文档，如果整个企业共用一个加密密钥，那整个企业文档的保密性便无从谈起。
常见的对称加密算法：DES、3DES、DESX、Blowfish、IDEA、RC4、RC5、RC6和AES
非对称加密 指加密和解密使用不同密钥的加密算法，也称为公私钥加密。假设两个用户要加密交换数据，双方交换公钥，使用时一方用对方的公钥加密，另一方即可用自己的私钥解密。如果企业中有n个用户，企业需要生成n对密钥，并分发n个公钥。由于公钥是可以公开的，用户只要保管好自己的私钥即可，因此加密密钥的分发将变得十分简单。同时，由于每个用户的私钥是唯一的，其他用户除了可以可以通过信息发送者的公钥来验证信息的来源是否真实，还可以确保发送者无法否认曾发送过该信息。非对称加密的缺点是加解密速度要远远慢于对称加密，在某些极端情况下，甚至能比非对称加密慢上1000倍。
常见的非对称加密算法：RSA、ECC（移动设备用）、Diffie-Hellman、El Gamal、DSA（数字签名用)
hash加密 Hash算法特别的地方在于它是一种单向算法，用户可以通过Hash算法对目标信息生成一段特定长度的唯一的Hash值，却不能通过这个Hash值重新获得目标信息。因此Hash算法常用在不可还原的密码存储、信息完整性校验等。
常见的Hash算法：MD2、MD4、MD5、HAVAL、SHA、SHA-1、HMAC、HMAC-MD5、HMAC-SHA1

3. spring boot 实现 rsa 加密算法

3.1 rsa 工具类

package com.flow.utils;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.codec.binary.Base64;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.springframework.util.Assert;

import javax.crypto.Cipher;
import java.security.*;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

/**
 * rsa 加密的工具类
 *
 *  字符串格式的密钥在未在特殊说明情况下都为BASE64编码格式<br/>
 *  由于非对称加密速度极其缓慢，一般文件不使用它来加密而是使用对称加密，<br/>
 *  非对称加密算法可以用来对对称加密的密钥加密，这样保证密钥的安全也就保证了数据的安全
 */
@Slf4j
public class RSAUtils {

    /** 安全服务提供者 */
    private static final Provider PROVIDER = new BouncyCastleProvider();

    /** 密钥大小 */
    private static final int KEY_SIZE = 1024;

    public static final String KEY_ALGORITHM = "RSA";

    /**
     * 不可实例化
     */
    private RSAUtils() {
    }

    /**
     * 生成密钥对
     *
     * @return 密钥对
     */
    public static KeyPair generateKeyPair() {
        try {
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA", PROVIDER);
            keyPairGenerator.initialize(KEY_SIZE, new SecureRandom());
            return keyPairGenerator.generateKeyPair();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 加密
     *
     * @param publicKey
     *            公钥
     * @param data
     *            数据
     * @return 加密后的数据
     */
    public static byte[] encrypt(PublicKey publicKey, byte[] data) {
        Assert.notNull(publicKey);
        Assert.notNull(data);
        try {
            Cipher cipher = Cipher.getInstance("RSA", PROVIDER);
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            return cipher.doFinal(data);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 加密
     *
     * @param publicKey
     *            公钥
     * @param text
     *            字符串
     *
     * @return Base64编码字符串
     */
    public static String encrypt(PublicKey publicKey, String text) {
        byte[] data = encrypt(publicKey, text.getBytes());
        return data != null ? Base64.encodeBase64String(data) : null;
    }

    /**
     * 解密
     *            私钥
     * @param data
     *            数据
     * @return 解密后的数据
     */
    public static byte[] decrypt(String key, byte[] data) {
        try {
            PrivateKey privateKey = getPrivateKey(key);
            Cipher cipher = Cipher.getInstance("RSA", PROVIDER);
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            return cipher.doFinal(data);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 密钥串转privateKey
     * @param keyStr
     * @return
     * @throws Exception
     */
    public static Key stringToPrivateKey(String keyStr) throws Exception {
        byte[] keyBytes=Base64.decodeBase64(keyStr);
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        return keyFactory.generatePrivate(keySpec);
    }

    //获取私钥
    private static PrivateKey getPrivateKey(String key) throws Exception {
        byte[] keyBytes;
        //  keyBytes = (new BASE64Decoder()).decodeBuffer(key);
        keyBytes = Base64.decodeBase64(key);
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
        return privateKey;
    }


    /**
     * 私钥解密算法
     * @param cryptograph 密文
     * @return
     * @throws Exception
     */
    public static String decrypt(String privateKey,String cryptograph) throws Exception {
        Key key=stringToPrivateKey(privateKey);
        /** 得到Cipher对象对已用公钥加密的数据进行RSA解密 */
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, key);
        byte[] b1 = Base64.decodeBase64(cryptograph);
        /** 执行解密操作 */
        byte[] b = cipher.doFinal(b1);
        return new String(b);
    }

    /**
     * RSA公钥加密
     *
     * @param str
     *            加密字符串
     * @param publicKey
     *            公钥
     * @return 密文
     * @throws Exception
     *             加密过程中的异常信息
     */
    public static String encrypt( String str, String publicKey ) throws Exception{
        //base64编码的公钥
        byte[] decoded = Base64.decodeBase64(publicKey);
        RSAPublicKey pubKey = (RSAPublicKey) KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(decoded));
        //RSA加密
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, pubKey);
        String outStr = Base64.encodeBase64String(cipher.doFinal(str.getBytes("UTF-8")));
        return outStr;
    }

    /**
     * <p>
     * 获取私钥
     * </p>
     * @return
     */
    public static String getPrivateKey(PrivateKey privateKey)  {
        return Base64.encodeBase64String(privateKey.getEncoded());
    }

    public static String getPublicKey(PublicKey publicKey) {
        return Base64.encodeBase64String(publicKey.getEncoded());
    }
}

该类必须要引用如下jar 包

        <dependency>
            <groupId>org.bouncycastle</groupId>
            <artifactId>bcpkix-jdk15on</artifactId>
            <version>1.64</version>
            <scope>provided</scope>
       </dependency>
 	   <dependency>
            <groupId>commons-codec</groupId>
            <artifactId>commons-codec</artifactId>
        </dependency>

3.2 定义返回对象

@Setter
@Getter
@NoArgsConstructor
public class RsaPublicKeyBo implements Serializable {
    private static final long serialVersionUID = 1110954441225034643L;

    /** 公钥 **/
    private String modulus;

    /** 指数 **/
    private String exponent;

    /** 公钥字符串 **/
    private String publicKeyStr;

    /** 保存的随机数 **/
    private String random;

    public RsaPublicKeyBo(RSAPublicKey publicKey, String random, String publicKeyStr) {
        this.modulus = Base64.encodeBase64String(publicKey.getModulus().toByteArray());
        this.exponent = Base64.encodeBase64String(publicKey.getPublicExponent().toByteArray());
        this.random = random;
        this.publicKeyStr = publicKeyStr;
    }
}

3.3 定义rsa的接口

import com.flow.bos.RsaPublicKeyBo;

public interface RsaService {
    RsaPublicKeyBo generateKey();
    String RSADecrypt(String content, String random);
}

3.4 定义实现类

public class RsaServiceImpl implements RsaService {
    /**
     * "私钥"参数名称
     */
    private static final String PRIVATE_KEY_ATTRIBUTE_NAME = "rsa_privateKey_%s";

    private RedisTemplate<String, String> redisTemplate;

    public RsaServiceImpl(RedisTemplate<String, String> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    @Override
    public RsaPublicKeyBo generateKey() {
        try {
            KeyPair keyPair = RSAUtils.generateKeyPair();
            RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
            RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
            String privateStringKey = RSAUtils.getPrivateKey(privateKey);
            String random = RandomStringUtils.randomAlphanumeric(10);
            ValueOperations<String, String> valueOperations = redisTemplate.opsForValue();
            valueOperations.set(String.format(PRIVATE_KEY_ATTRIBUTE_NAME, random), privateStringKey, 1200,  TimeUnit.SECONDS);
            return new RsaPublicKeyBo(publicKey, random, RSAUtils.getPublicKey(publicKey));
        } catch (Exception e) {
            log.error("初始化异常:", e);
            throw new ValidateException(ErrorFormatable.INTERVAL_FAIL_CODE, "获取rsa秘钥异常");
        }

    }

    @Override
    public String RSADecrypt(String content, String random) {
        ValueOperations<String, String> valueOperations = redisTemplate.opsForValue();
        String privateKeyString = valueOperations.get(String.format(PRIVATE_KEY_ATTRIBUTE_NAME, random));
        ErrorFormatable.CUSTOM.isEmptyThrow(privateKeyString, "解密失败");
        try {
            content = RSAUtils.decrypt(privateKeyString, content);
        } catch (Exception e) {
            log.error("解密失败:", e);
            throw new ValidateException(ErrorFormatable.INTERVAL_FAIL_CODE, "解密失败");
        }

        return content;
    }
}

控制器的代码自己可以自由发挥

4. vue使用 rsa

4.1 安装jsencrypt

cnpm install jsencrypt --save

4.2 使用jsencrypt加密

const entry = new JSEncrypt()
entry.setPublicKey(data.publicKeyStr)
const password = entry.encrypt(this.form.password)

5. 最终的效果