RSA加解密前端js加密，后台解密

最新推荐文章于 2024-09-12 17:12:18 发布
最新推荐文章于 2024-09-12 17:12:18 发布
阅读量3.8k 收藏 9
点赞数 1
分类专栏： 安全问题 文章标签： rsa加解密 js加密

RSA加解密——前端js加密，后台解密
公司最近安全测试,前端要求密码 前端 js 加密 后端 java解密. 并只能做对称加密. 因为是老系统 原有的登陆逻辑不能破坏. 本文抄自 https://blog.csdn.net/danshangu/article/details/81129228 感谢博主的分享.

首先整理下思路:

需求是要将登陆 密码加密传输并每次加密公钥不能相同.

  1. 登陆操作: 前端输入账号密码后,点击登陆按钮. 登陆前先从后端获取公钥,获取公钥同时将本次登陆请求的公钥和秘钥存入秘钥队列();
  2. 通过rsa.js 使用公钥给密码加密.
  3. Post请求登陆
  4. 后端从秘钥队列中获取公钥和秘钥
  5. 使用获取到的公钥和秘钥解密
  6. 将解密后的密码传给原有登陆逻辑走后面的流程

需要用到的素材:

Barrett.js
BigInt.js
RSA.js
可以从链接: rsa-js. 下载

可能需要用到的依赖:

 <dependency>
    <groupId>org.bouncycastle</groupId>
    <artifactId>bcprov-ext-jdk14</artifactId>
    <version>1.60</version>
</dependency>

代码片段:

RSAUtils.java工具类

package com.utils;

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

import javax.crypto.Cipher;

import java.io.ByteArrayOutputStream;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

/**
 * rsa工具类
 *
 * @author naruto
 * @version 1.0
 * @date 2019-4-8
 */
public class RSAUtils {
    public static final String CHARSET = "UTF-8";
    public static final String RSA_ALGORITHM = "RSA";

    public static Map<String, String> createKeys(int keySize) {
        //为RSA算法创建一个KeyPairGenerator对象
        KeyPairGenerator kpg;
        try {
            kpg = KeyPairGenerator.getInstance(RSA_ALGORITHM);
        } catch (NoSuchAlgorithmException e) {
            throw new IllegalArgumentException("No such algorithm-->[" + RSA_ALGORITHM + "]");
        }
        //初始化KeyPairGenerator对象,密钥长度
        kpg.initialize(keySize);
        //生成密匙对
        KeyPair keyPair = kpg.generateKeyPair();
        //得到公钥
        Key publicKey = keyPair.getPublic();
        String publicKeyStr = Base64.encodeBase64URLSafeString(publicKey.getEncoded());
        //得到私钥
        Key privateKey = keyPair.getPrivate();
        String privateKeyStr = Base64.encodeBase64URLSafeString(privateKey.getEncoded());
        Map<String, String> keyPairMap = new HashMap<String, String>();
        keyPairMap.put("publicKey", publicKeyStr);
        keyPairMap.put("privateKey", privateKeyStr);
        return keyPairMap;
    }

    /**
     * 得到公钥
     *
     * @param publicKey 密钥字符串（经过base64编码）
     * @throws Exception
     */
    public static RSAPublicKey getPublicKey(String publicKey) throws NoSuchAlgorithmException, InvalidKeySpecException {
        //通过X509编码的Key指令获得公钥对象
        KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(Base64.decodeBase64(publicKey));
        RSAPublicKey key = (RSAPublicKey) keyFactory.generatePublic(x509KeySpec);
        return key;
    }

    /**
     * 得到私钥
     *
     * @param privateKey 密钥字符串（经过base64编码）
     * @throws Exception
     */
    public static RSAPrivateKey getPrivateKey(String privateKey)
        throws NoSuchAlgorithmException, InvalidKeySpecException {
        //通过PKCS#8编码的Key指令获得私钥对象
        KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(Base64.decodeBase64(privateKey));
        RSAPrivateKey key = (RSAPrivateKey) keyFactory.generatePrivate(pkcs8KeySpec);
        return key;
    }

    /**
     * 公钥加密
     *
     * @param data
     * @param publicKey
     * @return
     */

    public static String publicEncrypt(String data, RSAPublicKey publicKey) {
        try {
            Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            byte[] bs = rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(CHARSET),
                publicKey.getModulus().bitLength());
            return Base64.encodeBase64URLSafeString(bs);
        } catch (Exception e) {
            throw new RuntimeException("加密字符串[" + data + "]时遇到异常", e);
        }
    }

    /**
     * 私钥解密
     *
     * @param data
     * @param privateKey
     * @return
     */
    public static String privateDecrypt(String data, RSAPrivateKey privateKey) {
        try {
            Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            byte[] bs = Base64.decodeBase64(data);
            return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, bs, privateKey.getModulus().bitLength()),
                CHARSET);
        } catch (Exception e) {
            throw new RuntimeException("解密字符串[" + data + "]时遇到异常", e);
        }
    }

    public static String privateDecrypt(byte[] data, RSAPrivateKey privateKey) {
        try {
            Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, data, privateKey.getModulus().bitLength()),
                CHARSET);
        } catch (Exception e) {
            throw new RuntimeException("解密字符串[" + data + "]时遇到异常", e);
        }
    }

    /**
     * 私钥加密
     *
     * @param data
     * @param privateKey
     * @return
     */
    public static String privateEncrypt(String data, RSAPrivateKey privateKey) {
        try {
            Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
            cipher.init(Cipher.ENCRYPT_MODE, privateKey);
            return Base64.encodeBase64URLSafeString(rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(CHARSET),
                privateKey.getModulus().bitLength()));
        } catch (Exception e) {
            throw new RuntimeException("加密字符串[" + data + "]时遇到异常", e);
        }
    }

    /**
     * 公钥解密
     *
     * @param data
     * @param publicKey
     * @return
     */
    public static String publicDecrypt(String data, RSAPublicKey publicKey) {
        try {
            Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
            cipher.init(Cipher.DECRYPT_MODE, publicKey);
            return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, Base64.decodeBase64(data),
                publicKey.getModulus().bitLength()), CHARSET);
        } catch (Exception e) {
            throw new RuntimeException("解密字符串[" + data + "]时遇到异常", e);
        }

    }

    private static byte[] rsaSplitCodec(Cipher cipher, int opmode, byte[] datas, int keySize) {
        int maxBlock = 0;
        if (opmode == Cipher.DECRYPT_MODE) {
            maxBlock = keySize / 8;
        } else {
            maxBlock = keySize / 8 - 11;
        }
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] buff;
        int i = 0;
        try {
            while (datas.length > offSet) {
                if (datas.length - offSet > maxBlock) {
                    buff = cipher.doFinal(datas, offSet, maxBlock);
                } else {
                    buff = cipher.doFinal(datas, offSet, datas.length - offSet);
                }
                out.write(buff, 0, buff.length);
                i++;
                offSet = i * maxBlock;
            }

        } catch (Exception e) {
            throw new RuntimeException("加解密阀值为[" + maxBlock + "]的数据时发生异常", e);
        }
        byte[] resultDatas = out.toByteArray();
        IOUtils.closeQuietly(out);
        return resultDatas;
    }

    public static byte[] hexStringToBytes(String hexString) {
        if (hexString == null || hexString.equals("")) {
            return null;
        }
        hexString = hexString.toUpperCase();
        int length = hexString.length() / 2;
        char[] hexChars = hexString.toCharArray();
        byte[] d = new byte[length];
        for (int i = 0; i < length; i++) {
            int pos = i * 2;
            d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
        }
        return d;
    }

    private static byte charToByte(char c) {
        return (byte) "0123456789ABCDEF".indexOf(c);
    }

    /**
     * * 解密 *
     *
     * @param pk  解密的密钥 *
     * @param raw 已经加密的数据 *
     * @return 解密后的明文 *
     * @throws Exception
     */
    public static byte[] decrypt(PrivateKey pk, byte[] raw) throws Exception {
        try {
            Cipher cipher = Cipher.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());
            cipher.init(cipher.DECRYPT_MODE, pk);
            int blockSize = cipher.getBlockSize();
            ByteArrayOutputStream bout = new ByteArrayOutputStream(64);
            int j = 0;
            while (raw.length - j * blockSize > 0) {
                bout.write(cipher.doFinal(raw, j * blockSize, blockSize));
                j++;
            }
            return bout.toByteArray();
        } catch (Exception e) {
            throw new Exception(e.getMessage());
        }
    }

    public static void main(String[] args) throws Exception {
        Map<String, String> keyMap = RSAUtils.createKeys(1024);
        String publicKey = keyMap.get("publicKey");
        String privateKey = keyMap.get("privateKey");
        System.out.println("公钥: \n\r" + publicKey);
        System.out.println("私钥： \n\r" + privateKey);
        System.out.println("公钥加密——私钥解密");
        RSAPublicKey rsaPublicKey = RSAUtils.getPublicKey(publicKey);
        RSAPrivateKey rsaPrivateKey = RSAUtils.getPrivateKey(privateKey);
        System.out.println(rsaPublicKey.getPublicExponent());
        String modulus = rsaPublicKey.getModulus().toString();
        System.out.println(modulus);
        String str = "321";
        System.out.println("\r明文：\r\n" + str);
        System.out.println("\r明文大小：\r\n" + str.getBytes().length);
        String encodedData = RSAUtils.publicEncrypt(str, RSAUtils.getPublicKey(publicKey));
        System.out.println("密文：\r\n" + encodedData);
        String decodedData = RSAUtils.privateDecrypt(encodedData, RSAUtils.getPrivateKey(privateKey));
        System.out.println("解密后文字: \r\n" + decodedData);
    }
}

登陆controller 中的代码

/**
 * 获取登陆秘钥
 * @return
 * @throws InvalidKeySpecException
 * @throws NoSuchAlgorithmException
 */
@RequestMapping(value = "getkey",method = RequestMethod.POST)
@ResponseBody
   public String getkey() throws  InvalidKeySpecException, NoSuchAlgorithmException {
   Map<String, String> keyMap = RSAUtils.createKeys(1024);
   String publicKeyString = keyMap.get("publicKey");
   String privateKeyString = keyMap.get("privateKey");
   RSAPublicKey rsaPublicKey=RSAUtils.getPublicKey(publicKeyString);
   PrivateKey privateKey=RSAUtils.getPrivateKey(privateKeyString);
   String Modulus=rsaPublicKey.getModulus().toString(16);
   String Exponent=rsaPublicKey.getPublicExponent().toString(16);
//将公钥私钥存入 队列
   Subject currentUser = SecurityUtils.getSubject();
   Session session = currentUser.getSession();
   session.setAttribute(Modulus, privateKey);
   return Modulus;
   }

解密操作

/**
 * 解密password
 * @param password
 * @param publicKey
 * @return
 * @throws Exception
 */
private String checkPasRsa(String password,String publicKey) throws Exception {
   Subject currentUser = SecurityUtils.getSubject();
   Session session = currentUser.getSession();
   Object attribute = session.getAttribute(publicKey);
   if(attribute ==null || !(attribute instanceof PrivateKey)){
      log.error("session中私钥失效.publickey={},password={}",publicKey,password);
      return null;
   }
   session.removeAttribute(publicKey);
   PrivateKey privateKey = (PrivateKey) attribute;
   byte[] en_result = RSAUtils.hexStringToBytes(password);
   byte[] de_result = RSAUtils.decrypt(privateKey, en_result);
   StringBuffer sb = new StringBuffer();
   sb.append(new String(de_result));
   return sb.reverse().toString();
}

Jsp 中 请求片段 – 获取本次登陆公钥

function getPublicKey() {
  var publickey = "";
  $.ajax({
    type: "post",
    async: false,
    url: '${ctx}/login/getkey?'+new Date(),
    dataType: 'text',
    success: function (data) {
      publickey = data;
    }
  });
  return publickey;
}

Jsp 中 请求片段 – 用获取到的公钥给密码加密

Jsp 中 请求片段 – 用获取到的公钥给密码加密
这里需要引入上面说的三个js了
<script src="${res.url}/static/plugins/security/Barrett.js"></script>
<script src="${res.url}/static/plugins/security/BigInt.js"></script>
<script src="${res.url}/static/plugins/security/RSA.js"></script>

var loginname = $("#loginname").val();
var password = $("#password").val();
setMaxDigits(130);
var publicKey = getPublicKey();
var key = new RSAKeyPair("10001","",publicKey);
password = encryptedString(key, encodeURIComponent(password));
//这里的password就是加密后的结果了.

setMaxDigits()，要注意里面的参数，1024位对应130(RSAUtils.createKeys(1024)),2048位对应260

一个更加值得注意的问题是 秘钥队列: 如果应用服务器有多个的话 不能简单的存在 内存(map),需要存放到session(需要实现session共享)或者redis 队列,并且注意一定要设定一个超时时间.避免无限增量消耗内存

华子哥、
关注
专栏目录
前端 RSA分段加密算法
03-31
RSA非对称加密，前端加解密算法代码。公钥明文，私钥各自保存，公钥加密，私钥解密。 RSA分段加密 适用于加密长度超标，可用于图片base64等大长度内容加密。
前端RSA加解密(支持超长分段)
一屁小肥羊的专栏
06-17 791
RSA加解密, RSA超长加解密
JavaScript实现RSA加密和解密
最新发布
weixin_48839391的博客
09-12 944
在JavaScript中，可以使用RSA算法实现数据的加密和解密。下载链接RSA 是一种非对称加密算法，使用一对密钥：公钥 和 私钥。公钥加密：任何人可以使用公钥加密信息。私钥解密：只有拥有私钥的人才能解密加密的信息。私钥签名：私钥可以用于对消息进行签名。公钥验证签名：任何人都可以用公钥验证签名的真实性。通过这个封装好的 rsa-crypto.js 文件，所有与RSA加密和解密相关的操作（密钥生成、密钥存储、加密、解密）都被整理为独立的功能模块。
前端使用jsencrypt库实现RSA公钥解密——uniapp同样适用
m0_52941894的博客
12-25 2025
小程序实现RSA公钥解密
Node.js 中的 RSA 加密、解密、签名与验证详解
qq_53742640的博客
04-14 5566
RSA算法作为一种非对称加密技术，在保障数据传输安全方面发挥着重要作用。Node.js提供了内置的crypto模块和第三方库node-rsa，使得在Node.js环境中实现RSA加密、解密、签名和验证变得简单易行。开发者可以根据项目需求和环境选择合适的工具进行数据加密和安全保护。
js rsa加密_Python实现RSA(jsencrypt)加密的两种方式
weixin_39581318的博客
01-08 1055
RSA是一种常用加密算法，经常用在前端向后端传送密码的时候。一、通过运行rsa.js文件加密rsa.js文件下载地址：https://gitee.com/youchuanming/rsa_jsencryptimport urllib.purse import execjs # 找到rsa.js文件里最下方的公钥参数，把这个参数修改成自己的公钥 js_file = './rsa.js' with ...
python Django RSA 前台加密 后端解密。
12-06
在这个场景中，我们将讨论如何在Django应用中实现RSA加密和解密，以便于前端与后端的安全通信。 首先，让我们理解RSA的基本原理。RSA是一种基于大素数因子分解困难性的公钥加密算法。它包括一对密钥：公钥（可公开...
security.js 前端RSA加密解密
07-10
security.js基于RSA算法用于前端加密与密钥传输，需要跟后台配合使用 var key = new RSAUtils.getKeyPair("${publicKeyExponent}", "", "${publicKeyModulus}"); var reversedPwd = password.split("").reverse...
JAVA 中解密RSA算法JS加密实例详解
10-20
需要注意的是，RSA虽然安全性较高，但其加密和解密速度相对较慢，不适合对大量数据进行直接加密。在实际应用中，通常会结合对称加密算法，如AES，先用AES加密大量数据，再用RSA加密AES的密钥，这样既保证了安全性，...
js前台通过RSA，DES加解密，java后台解密、加密
10-16
本主题主要关注两种常见的加密算法：RSA和DES，以及如何在JavaScript前端和Java后端之间进行加解密操作。 **RSA加密解密** RSA（Rivest-Shamir-Adleman）是一种非对称加密算法，它的核心特点是有一对公钥和私钥。...
RSA 简介及 C# 和 js 实现
woisking2的博客
07-08 1842
公钥就是公开的，让全部发送方使用，私钥是保密的，不能公开，专门供接收方解密收到的密文，没有私钥的第三方就无法解密密文，从而保证了数据传输的安全性。可见，针对公钥处理的数据，其填充内容为伪随机（限制范围的随机数）的 16 进制字符串，每次操作的填充内容都不一样。本文也将做专门介绍。BT 取值为 01 时，PS 为全 FF 的字符串，通过填充得到的整数会足够大，可以阻止某些攻击，因此也是推荐的填充方式。"填充后数据" = "00" + "数据块类型" + "填充字符串" + "00" + "原始数据"
使用RSA非对称加密完成JavaScript前端分段加密和java后端分段解密
ycb1689的专栏
01-11 6489
前言 最近研究了RSA非对称加密，关于什么是RSA，网上各种文章一搜一大把，但是关于如何使用RSA完成前后端的组合加密解密，东西就非常少了，并且由于RSA的特性，一个1024位的密钥只能加密117位字节数据，当数据量超过117位字节的时候，程序就会抛出异常，下面就给出如何完成前端RSA分段解密和后端RSA分段解密。 准备 前端RSA的JS类库jsencrypt-master 或 https://g...
RSA加解密——前端js加密，后台解密
热门推荐
摸爬滚打
10-24 3万+
一、前端js     1、前端js           先引入 jsencrypt.js             &lt;script src="${pageContext.request.contextPath}/static/scripts/jquery/dist/jsencrypt.js"&gt;&lt;/script&gt;           页面放置一个隐藏的input标签...
Java&前端JS使用RSA加密、解密方法
或执与你梦的博客
06-10 2177
概述 项目登录信息传输需要密文，之前使用AES被告知容易被破解，故换成要求的RSA前端加密，后端解密验证，踩了一些小坑，给大家分享一下~ 小坑： 因为RSA加密对明文的长度有所限制，规定需加密的明文最大长度=密钥长度-11（单位是字节，即byte），所以在加密和解密的过程中需要分块进行。而密钥默认是1024位，即1024位/8位-11=128-11=117字节。所以默认加密前的明文最大长度117字节，解密密文最大长度为128字。那么为啥两者相差11字节呢？是因为RSA加密使用到了填充模式（padding），
JSEncrypt的长文本分段加解密
wph06rj的专栏
07-26 2111
JSEncrypt长字符串加解密
前端使用RSA对密码进行加密
木木木不哭的博客
07-13 727
前端使用RSA对密码进行加密
RSA前端JS加密，后端JAVA解密实现
ccecwg的专栏
01-20 7871
用RSA非对称加密方式实现。后台生成rsa密钥对，然后在页面设置rsa公钥，提交时用公钥加密密码，生成的密文传到后台，后台再用私钥解密，获取密码明文。     这样客户端只需要知道rsa加密方式和公钥，前台不知道私钥是无法解密的，此解决方案还是相对比较安全的。     需要到http://www.bouncycastle.org下载bcprov-jdk16-140.jar文件。     缺陷
nodeJS的RSA分段加密实现方法
starbrookHuang的博客
05-25 98
node.js 使用crypto模块进行RSA加解密操作-CSDN博客
在JavaScript中进行RSA加密和解密
cduoa的专栏
07-15 9083
点击按钮TestMe!后，将使用公钥对文本进行加密，然后再使用私钥进行解密，最后对比解密后的文本与原始文本。倘若两者一致，说明RSA加密解密过程正确，将alert"Itworks!JavaScript在当今B/S系统中的重要性就不必多说了。中成功使用openssl生成了用于RSA加密和解密的公钥和私钥。样例中有3个输入框，分别输入PrivateKey（私钥），PublicKey（公钥），Texttoencrypt（待加密文本）将上文中生成的公钥和私钥分别复制到输入框中，经过测试，是OK的。...
前端实现RSA加密与解密技术详解
2. jsencrypt.js库：jsencrypt.js是一个纯JavaScript编写的RSA加密解密库，它提供了一种简单方便的方式来在前端进行RSA加密解密操作。该库支持主流浏览器，包括IE、Firefox、Chrome等，也支持在uni-app中使用，使得...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值