基于RSA的前端表单加密

RSA简介

非对称加密算法是一种密钥的保密方法

非对称加密算法需要两个密钥：公开密钥（publickey）和私有密钥（privatekey）。公开密钥与私有密钥是一对，如果用公开密钥对数据进行加密，只有用对应的私有密钥才能解密；如果用私有密钥对数据进行加密，那么只有用对应的公开密钥才能解密。因为加密和解密使用的是两个不同的密钥，所以这种算法叫作非对称加密算法。 非对称加密算法实现机密信息交换的基本过程是：甲方生成一对密钥并将其中的一把作为公用密钥向其它方公开；得到该公用密钥的乙方使用该密钥对机密信息进行加密后再发送给甲方；甲方再用自己保存的另一把专用密钥对加密后的信息进行解密

RSA公开密钥加密系统采用公钥加密，私钥解密，能够安全传输需要加密的文本。但是，由于其需要进行大量的指数运算，速度慢，成本高，常用于加密少量的文本

在这里使用js加密，java解密

前端使用RSA加密

导入jsencrypt.min.js

• 可以使用cdn

<script src="https://cdn.bootcdn.net/ajax/libs/jsencrypt/3.2.1/jsencrypt.min.js"></script>

• 或者直接下载源码，放到static文件夹中

表单

<form id="login-form">
	<input type="text" name="username"placeholder="账户" required />
	<input type="password" id="password" name="password" placeholder="密码"required />
	<button class="btn theme-button" id="login-button" type="button">登陆</button>
</form>

加密

$('#login-button').click(function(e){
	//注销默认事件
	e.preventDefault();
	// 密码框
	var that = $('#password');
	//获取公钥
	$.ajax({
		type:'post',
		url:'/get-password-key',  // 自己编写的获取公钥的后台接口
		data:{},
		success:function(data){
			var publicKey = data;
			console.log(publicKey);
			//对密码进行加密
			var encrypt = new JSEncrypt();
			encrypt.setPublicKey(publicKey);
			var password = that.val();
			// 将加密好的再放回密码框
			that.val(encrypt.encrypt(password));
			// 表单提交
			$('#login-form').submit();
		}
	})
})

后端解密

导入依赖

<!-- https://mvnrepository.com/artifact/org.bouncycastle/bcprov-jdk15on -->
<dependency>
    <groupId>org.bouncycastle</groupId>
    <artifactId>bcprov-jdk15on</artifactId>
    <version>1.69</version>
</dependency>
<!-- https://mvnrepository.com/artifact/commons-codec/commons-codec -->
<dependency>
    <groupId>commons-codec</groupId>
    <artifactId>commons-codec</artifactId>
    <version>1.15</version>
</dependency>

编写工具类

package com.wcy.util;

import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.Provider;
import java.security.SecureRandom;
import java.security.Security;
import java.security.interfaces.RSAPublicKey;

import javax.crypto.Cipher;

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

public class RSAUtil {
    // KeyPair is a simple holder for a key pair.
    private static final KeyPair keyPair = initKey();

    /**
     * 初始化方法，产生key pair，提供provider和random
     * @return KeyPair instance
     */
    private static KeyPair initKey() {
        try {
            // 添加provider
            Provider provider = new org.bouncycastle.jce.provider.BouncyCastleProvider();
            Security.addProvider(provider);
            // 产生用于安全加密的随机数
            SecureRandom random = new SecureRandom();
            KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA", provider);
            generator.initialize(1024, random);
            return generator.generateKeyPair();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 产生public key
     * @return public key字符串
     */
    public static String generateBase64PublicKey() {
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        // encodeBase64(): Encodes binary data using the base64
        // algorithm but does not chunk the output.
        // getEncoded():返回key的原始编码形式
        return new String(Base64.encodeBase64(publicKey.getEncoded()));
    }

    /**
     * 解密数据
     * @param string 需要解密的字符串
     * @return 破解之后的字符串
     */
    public static String decryptBase64(String string) {
        // decodeBase64():将Base64数据解码为"八位字节”数据
        return new String(decrypt(Base64.decodeBase64(string)));
    }

    private static byte[] decrypt(byte[] byteArray) {
        try {
            Provider provider = new org.bouncycastle.jce.provider.BouncyCastleProvider();
            Security.addProvider(provider);
            // Cipher: 提供加密和解密功能的实例
            // transformation: "algorithm/mode/padding"
            Cipher cipher = Cipher.getInstance("RSA/None/PKCS1Padding", provider);
            PrivateKey privateKey = keyPair.getPrivate();
            // 初始化
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            // doFinal(): 加密或者解密数据
            return cipher.doFinal(byteArray);
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
}

编写公钥接口

@RequestMapping("/get-password-key")
@ResponseBody
public String getPasswordKey() {
    String publicKey = RSAUtil.generateBase64PublicKey();
    System.out.println("公共秘钥->" + publicKey);
    return publicKey;
}

解密

// 密码解密
String decodePassword = RSAUtil.decryptBase64(password);

解密之后获得的就是用户输入的明文密码