Rsa非对称性算法-springboot实现

最新推荐文章于 2024-08-06 11:44:26 发布
最新推荐文章于 2024-08-06 11:44:26 发布
阅读量220 收藏 1
点赞数
分类专栏： java 文章标签： java 加密解密 rsa 算法 javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48184989/article/details/109352549
版权

Rsa非对称性算法-springboot实现

使用这个算法增强表单提交的安全性。

原理相当简单如下：

假设后端a和前端b是两个人，a有两把钥匙（俗称：公钥和秘钥，他们是一对的缺一不可），a把私钥留给自己，公钥给了b，b可以使用公钥对账号密码加密。但是b无法解密因为私钥在a的手上，b把加密后的东西给a。a用私钥解密。这就完成了Rsa的实现原理。

1、引入maven依赖替换Base64

<!-- 替换sun.misc.BASE64Encoder  Rsa非对称性算法-->
        <dependency>
            <groupId>commons-codec</groupId>
            <artifactId>commons-codec</artifactId>
            <version>1.10</version>
        </dependency>

2、工具类RsaUtils

package com.su.main.utils;

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

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;

/**
 * RSA加解密工具类，实现公钥加密私钥解密和私钥解密公钥解密
 */
public class RSAUtils {

    private static final String src = "123abc";


    public static void main(String[] args) throws Exception {
        System.out.println("\n");
        RSAKeyPair keyPair = generateKeyPair();
        System.out.println("公钥：" + keyPair.getPublicKey());
        System.out.println("私钥：" + keyPair.getPrivateKey());
        System.out.println("\n");
        test1(keyPair, src);
        System.out.println("\n");
        test2(keyPair, src);
        System.out.println("\n");
    }

    /**
     * 公钥加密私钥解密
     */
    private static void test1(RSAKeyPair keyPair, String source) throws Exception {
        System.out.println("***************** 公钥加密私钥解密开始 *****************");
        String text1 = encryptByPublicKey(keyPair.getPublicKey(), source);
        String text2 = decryptByPrivateKey(keyPair.getPrivateKey(), text1);
        System.out.println("加密前：" + source);
        System.out.println("加密后：" + text1);
        System.out.println("解密后：" + text2);
        if (source.equals(text2)) {
            System.out.println("解密字符串和原始字符串一致，解密成功");
        } else {
            System.out.println("解密字符串和原始字符串不一致，解密失败");
        }
        System.out.println("***************** 公钥加密私钥解密结束 *****************");
    }

    /**
     * 私钥加密公钥解密
     *
     * @throws Exception
     */
    private static void test2(RSAKeyPair keyPair, String source) throws Exception {
        System.out.println("***************** 私钥加密公钥解密开始 *****************");
        String text1 = encryptByPrivateKey(keyPair.getPrivateKey(), source);
        String text2 = decryptByPublicKey(keyPair.getPublicKey(), text1);
        System.out.println("加密前：" + source);
        System.out.println("加密后：" + text1);
        System.out.println("解密后：" + text2);
        if (source.equals(text2)) {
            System.out.println("解密字符串和原始字符串一致，解密成功");
        } else {
            System.out.println("解密字符串和原始字符串不一致，解密失败");
        }
        System.out.println("***************** 私钥加密公钥解密结束 *****************");
    }

    /**
     * 公钥解密
     *
     * @param publicKeyText
     * @param text
     * @return
     * @throws Exception
     */
    public static String decryptByPublicKey(String publicKeyText, String text) throws Exception {
        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(Base64.decodeBase64(publicKeyText));
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, publicKey);
        byte[] result = cipher.doFinal(Base64.decodeBase64(text));
        return new String(result);
    }

    /**
     * 私钥加密
     *
     * @param privateKeyText
     * @param text
     * @return
     * @throws Exception
     */
    public static String encryptByPrivateKey(String privateKeyText, String text) throws Exception {
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(Base64.decodeBase64(privateKeyText));
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, privateKey);
        byte[] result = cipher.doFinal(text.getBytes());
        return Base64.encodeBase64String(result);
    }

    /**
     * 私钥解密
     *
     * @param privateKeyText
     * @param text
     * @return
     * @throws Exception
     */
    public static String decryptByPrivateKey(String privateKeyText, String text) throws Exception {
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec5 = new PKCS8EncodedKeySpec(Base64.decodeBase64(privateKeyText));
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec5);
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        byte[] result = cipher.doFinal(Base64.decodeBase64(text));
        return new String(result);
    }

    /**
     * 公钥加密
     *
     * @param publicKeyText
     * @param text
     * @return
     */
    public static String encryptByPublicKey(String publicKeyText, String text) throws Exception {
        X509EncodedKeySpec x509EncodedKeySpec2 = new X509EncodedKeySpec(Base64.decodeBase64(publicKeyText));
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec2);
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        byte[] result = cipher.doFinal(text.getBytes());
        return Base64.encodeBase64String(result);
    }

    /**
     * 构建RSA密钥对
     *
     * @return
     * @throws NoSuchAlgorithmException
     */
    public static RSAKeyPair generateKeyPair() throws NoSuchAlgorithmException {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        keyPairGenerator.initialize(1024);
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();
        String publicKeyString = Base64.encodeBase64String(rsaPublicKey.getEncoded());
        String privateKeyString = Base64.encodeBase64String(rsaPrivateKey.getEncoded());
        RSAKeyPair rsaKeyPair = new RSAKeyPair(publicKeyString, privateKeyString);
        return rsaKeyPair;
    }


    /**
     * RSA密钥对对象
     */
    public static class RSAKeyPair {

        private String publicKey;
        private String privateKey;

        public RSAKeyPair(String publicKey, String privateKey) {
            this.publicKey = publicKey;
            this.privateKey = privateKey;
        }

        public String getPublicKey() {
            return publicKey;
        }

        public String getPrivateKey() {
            return privateKey;
        }

    }

}

3、controller 的调用

package com.su.main.controller;

import com.su.main.utils.RSAUtils;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpSession;
import java.security.NoSuchAlgorithmException;

import static com.su.main.utils.RSAUtils.generateKeyPair;

/**
 * TODO
 *
 * @author Administrator
 * @version 1.0
 * @date 2020/10/28 17:44
 */
@Controller
public class RsaTest {


    @RequestMapping("/rsa")
    public String toRsaTest(){
        return "rsaTest";
    }

    @RequestMapping("/getPublicKey")
    @ResponseBody
    public String buildKeyPair(HttpSession session) throws NoSuchAlgorithmException {
        RSAUtils.RSAKeyPair rsaKeyPair = generateKeyPair();
        //如果这个session存在，先删除后添加
        if(session.getAttribute("privateKeySu")!=null){
            session.removeAttribute("privateKeySu");
            session.setAttribute("privateKeySu",rsaKeyPair.getPrivateKey());
            System.out.println("privateKeySu:"+rsaKeyPair.getPrivateKey());
        }else {
            session.setAttribute("privateKeySu",rsaKeyPair.getPrivateKey());
            System.out.println("privateKeySu:"+rsaKeyPair.getPrivateKey());
        }

        String publicKey = rsaKeyPair.getPublicKey();

        System.out.println("publicKey:"+publicKey);
        //返回公钥
        return rsaKeyPair.getPublicKey();
    }


    @RequestMapping("/aaa")
    @ResponseBody
    public String Login(String name, HttpSession session) throws Exception {
        String comeBackMsg;
        //获得秘钥对
        if(session.getAttribute("privateKeySu")!=null){
            String privateKey = (String) session.getAttribute("privateKeySu");
            System.out.println("privateKey:"+privateKey);
            //获取私钥解密方法
            RSAUtils rsaUtils = new RSAUtils();

            String changeName = rsaUtils.decryptByPrivateKey(privateKey, name);

            comeBackMsg = "私钥解开了！解开为："+changeName;
        }else{
            comeBackMsg = "抱歉你没有权限";
        }


        return comeBackMsg;
    }



}

4、前端页面设计和js的导入

前端页面设计：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <div>
        账号：<input type="text" id="name1" name="name1" oninput="getPublicKey(this)" >
    </div>
    <div>
        密码：<input type="password" id="pwd1" name="pwd1">
    </div>
    <div>
        <button type="button" name="aaa" onclick="clickA(this)">aaa</button>
    </div>

    <form action="">

        <input type="hidden" id="name2" name="name2">
        <input type="hidden" id="pwd2" name="pwd2">
        <input type="hidden" id="publicKey" name="publicKey">
        <input type="submit" value="提交">
    </form>


<script type="text/javascript"  src="/Rsa/js/jquery.min-2.1.4.js"></script>
    <!--Rsa非对称性算法前端js-->
<script type="text/javascript"  src="/Rsa/js/jsencrypt.min.js"></script>
<script>


    //oninput 当表单的value值改变是触发，但js改变value的值不会触发
    function getPublicKey(e) {
        // 3-Url参数加密类
        //公钥加密
        var encrypt = new JSEncrypt();

        //获取公钥
        $.post(
            "/getPublicKey",
            function (r) {

                //获取公钥
                console.log(r);
                let pkey = r;
                console.log(pkey);
                $("#publicKey").val(pkey);
                //公匙加密
                encrypt.setPublicKey(pkey);
                let name1 = $("#name1").val();
                console.log("name1加密前:"+name1);
                let name2;
                name2 = encrypt.encrypt(JSON.stringify(name1));
                console.log("name2加密后:"+name2);
                $("#name2").val(name2);

            }
        );


    }

    function clickA() {
        //获取加密后的密码上交解密
        if($("#name2").val()!=null){
            let name2 = $("#name2").val();
            console.log(name2);
            $.post(
                "/aaa",
                {
                    name : name2
                },
                function (r) {
                    alert(r);

                }
            );
        }else {
            alert("请输入你的账号在试试点击我！");
        }


    }

</script>

</body>
</html>

js的引入（需要jQuery和jsencrypt.min.js（前端Rsa的库））

这两个js自行去网站下载即可啦，jQuery要求不高，其他版本也可以，jsencrypt.min.js，百度一下在别人项目里面拿也可以
粟德桡 QQ：648713624

weixin_48184989
关注
专栏目录
Ubuntu零基础教学-SpringBoot项目如何生成SSL证书并配置HTTPS协议 | 超级详细，建议收藏
**My Coding Family**
04-01 391
SpringBoot项目如何生成SSL证书并配置HTTPS协议，快进来，我教你...
SpringBoot中_JAVA利用国密算法_实现内容的加密_解密--SpringCloud工作笔记180
添柴程序猿的专栏
06-26 2530
首先来看一下什么是国密算法:国密即国家密码局认定的国产密码算法，即商用密码。国密主要有SM1，SM2，SM3，SM4。密钥长度和分组长度均为128位。1、SM1 为对称加密。其加密强度与AES(高级加密标准,Advanced Encryption Standard)相当。该算法不公开，调用该算法时，需要通过加密芯片的接口进行调用。2、SM2为非对称加密，基于ECC。该算法已公开。由于该算法基于ECC，故其签名速度与秘钥生成速度都快于RSA。ECC 256位（SM2采用的就是ECC 256位的一种）安全强度比
AES+RSA加密解密（js和java互通）
07-13
rsa aes 加解密 js java 前后端互通
RSA加解密工具类RSAUtils.java，实现公钥加密私钥解密和私钥解密公钥解密
weixin_30432179的博客
04-11 276
package com.geostar.gfstack.cas.util; import org.apache.commons.codec.binary.Base64; import javax.crypto.Cipher; import java.security.*; import java.security.interfaces.RSAPrivateKey; impor...
springboot配置前后端RSA非对称加密
zf04295的博客
08-01 196
3.前端页面引用jsencrypt.js（vue需要执行npm install jsencrypt安装，js文件获取则可以利用vue项目npm install安装后在本地modules里找到对应的js文件拷贝到自己的项目里引用）5.RSA解密，登录密码校验逻辑之前对密码进行解密（根据数据库存储密码的加密格式需要转换为对应的，方便后面校验）4.RSA加密，js登录请求前用公钥对密码进行加密。1.RSA公钥私钥生成工具类。2.RSA公钥后台请求接口。
RSA-Keypair
weixin_42094659的博客
11-30 3594
package main import ( "crypto/rand" "crypto/rsa" "crypto/x509" "encoding/pem" "fmt" "os" ) const privateKeyFile = "./privateKeyKey.pem" //需求：生成并保存私钥，公钥 func generateKeyPair(bits int)error{ /...
SpringBoot通过RSA实现用户名和密码的加密和解密
qq_36735969的博客
05-18 7660
RSA加密和解密示例。
RSA+AES+Base64实现数据非对称加密解密
最新发布
jianghuchuang的博客
08-06 771
然后使用。
springboot实现注册加密与登录解密功能(demo)
08-24
RSA 加密算法是一种非对称加密算法，具有很高的安全性。 知识点四：异常处理 在 Spring Boot 项目中，异常处理是非常重要的。可以通过使用 @ExceptionHandler 注解来处理异常，例如，使用 @ExceptionHandler 注解...
SpringSecurityOauth2授权模式与使用RSA非对称加密方式生成公钥私钥
DreamsArchitects的博客
11-17 5365
文章目录一、用户认证分析1.1 认证与授权身份认证用户授权1.2 单点登录1.3 第三方登录二、认证技术方案了解（单点登录+第三方授权认证）2.1单点登录技术方案2.2 Oauth2认证三、SpringSecurity Oauth2.0入门导入依赖Oauth2授权模式授权码模式授权四、公钥私钥加密解密生成证书mac下载openssl安装openssl方式一 使用brew命令安装openssl方式二导出公钥基于私钥生成jwt令牌 一、用户认证分析 上面流程图描述了用户要操作的各个微服务，用户查看个人信息需要
SpringCloud学习笔记024---SpringBoot中使用大部分公用的配置记录
添柴程序猿的专栏
07-27 1304
JAVA技术交流QQ群：170933152  常用应用属性 可以在application.properties / application.yml file中指定各种属性，也可以在命令行开关中指定。本节提供了常见的Spring Boot属性和对使用它们的基础类的引用的列表。 摘自：http://docs.spring.io/spring-boot/docs/current/reference...
rsakey.txt
06-06
rsaket.txt详见博客 http://blog.csdn.net/hanlin0605/article/details/54809563
rsa js var b new RSAKey;
07-13
rsa.js var b = new RSAKey; var b = new RSAKey;
Spring Boot使用RSA模拟简单的登录加密功能
qq_50994235的博客
12-01 1594
Spring Boot使用RSA模拟简单的登录加密功能什么是RSA?RSA加密和解密的过程RSA加密和解密的实现模拟简单登录加密功能 什么是RSA? RSA是一种公钥密码算法，它的名字由三位开发者，即Ron Rivest、Adi Shamir和Leonard Adleman的姓氏的首字母组成的。 RSA被用于公钥密码和数字签名。 RSA被认为是非常安全的，不过计算速度要比DES慢很多。同DES一样，其安全性也从未被证明过，但想攻破RSA算法涉及的大数（至少200位的大数）的因子分解是一个极其困难的问题。所以
AES与RSA联合使用进行加解密（C#、Java实现）
beautiful77moon的博客
07-05 1776
AES与RSA联合使用进行加解密（C#）
js php rsakeypair,在C#服务器和PHP客户端中使用RSA KeyPair
weixin_39854951的博客
03-23 409
根据3v4l,openssl_get_publickey() is returning false.你需要给它一个PEM formatted public key.如果你想要一个更简单的界面,你不太可能犯一个破坏你的应用程序安全性的错误,请查看libsodium.Libsodium是NaCl的分支,这是一个易于使用的高速软件库,用于网络通信,加密,解密,签名等,由Daniel J. Bernste...
Java实现RSA非对称加密工具类
vandet100的博客
06-23 1798
RSA非对称加密通常运用于对字符串进行加密，通过密钥对（公钥、私钥）实现加密。 通过生成的公钥，对字符串加密后，得到一个加密的字符串，将私钥与这个加密后的字符串进行解密，得到原先的字符串。 Java代码： package com.vandet.indwebproject.utils; import org.apache.commons.codec.binary.Base64; import org.bouncycastle.jce.provider.BouncyCastleProvider; im
Java(110)：非对称加密RSA的使用(KeyPair生成密钥)
fen_fen的专栏
03-13 3532
Java(110)：非对称加密RSA的使用(KeyPair生成密钥)
Spring-boot如何使用RSA加密
热门推荐
T_Antry
10-20 1万+
RSA加密一、什么是RSA加密？二、如何使用RSA1.生成私钥和公钥2.将生成的秘钥放到application.properties中3.前端请求公钥4.后端随机获取公钥给前端5.前端加密Ajax发送（登录为例）6.后端解密（登录为例） 一、什么是RSA加密？ RSA加密算法是一种非对称加密算法。 由后端生成公钥和私钥，公钥和私钥为一对一的关系。 将公钥传给前端，前端：公钥+value生成密文。 后端拿到密文时，取出私钥：密文 - 私钥 = value 通过这样的形式将传输内容保密。 二、如何使用RSA
***平台RSA加密算法可视化实现与研究
RSA算法是一种广泛使用的非对称加密算法，其特点是基于一个公开的密钥对，包括一个公开密钥和一个私有密钥。非对称加密算法与对称加密算法不同，非对称加密算法使用一对密钥，一个用于加密信息，另一个用于解密信息...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值