前端登陆进行加密后台解密

最新推荐文章于 2024-04-24 15:39:54 发布
最新推荐文章于 2024-04-24 15:39:54 发布
阅读量1.5k 收藏 11
点赞数 3
文章标签： javascript java
原文链接：https://blog.csdn.net/qq_34357835/article/details/79993230
版权

公司最近让在登录首页登录时，js加密，java解密。
首先必不可少的就是jar包，和js文件
后台引入的jar包：
jar 包 bcprov-jdk16-146.jar 和commons-codec-1.2.jar (maven项目的话引入相对应的依赖就好)

	<dependenccies>
		<dependency>
    		<groupId>commons-codec</groupId>
    		<artifactId>commons-codec</artifactId>
    		<version>1.10</version>
		</dependency>

		<dependency>
            <groupId>org.bouncycastle</groupId>
            <artifactId>bcprov-jdk15on</artifactId>
            <version>1.60</version>
        </dependencies>
    <dependencys>

前端引入的脚本文件
jquery.min.js和security.js (security.js的源码可以在前一篇中找到)
java工具类 RSAUtils

import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.Security;
import java.security.interfaces.RSAPublicKey;
import java.util.HashMap;
import java.math.BigInteger;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.Security;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.RSAPrivateKeySpec;
import java.security.spec.RSAPublicKeySpec;
import java.util.HashMap;
import javax.crypto.Cipher;


public class RSAUtils {

    /**
     * 生成公钥和私钥 
     * @throwsNoSuchAlgorithmException 
     */
    public static HashMap<String, Object> getKeys() throws NoSuchAlgorithmException {
        Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
        HashMap<String, Object> map = new HashMap<String, Object>();
        //为RSA算法创建一个KeyPairGenerator对象
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());
        keyPairGen.initialize(1024);
        //生成密钥对
        KeyPair keyPair = keyPairGen.generateKeyPair();
        //得到公钥
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        //得到私钥
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        map.put("public", publicKey);
        map.put("private", privateKey);
        return map;
    }

    /**
     *  
     * 使用模和指数生成RSA公钥 
     *
     * @parammodulus 模 
     * @paramexponent 指数 
     * @return 
     */
    public static RSAPublicKey getPublicKey(String modulus, String exponent) {
        Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
        try {
            BigInteger b1 = new BigInteger(modulus);
            BigInteger b2 = new BigInteger(exponent);
            KeyFactory keyFactory = KeyFactory.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());
            RSAPublicKeySpec keySpec = new RSAPublicKeySpec(b1, b2);
            return (RSAPublicKey) keyFactory.generatePublic(keySpec);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     *  
     * 使用模和指数生成RSA私钥 
     * None/NoPadding
     * @parammodulus 模
     * @paramexponent指数 
     * @return 
     */
    public static RSAPrivateKey getPrivateKey(String modulus, String exponent) {
        try {
            Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
            BigInteger b1 = new BigInteger(modulus);
            BigInteger b2 = new BigInteger(exponent);
            KeyFactory keyFactory = KeyFactory.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());
            RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(b1, b2);
            return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 公钥加密 
     * @return
     * @paramdata
     * @parampublicKey
     * @throwsException
     */
    public static String encryptByPublicKey(String data, RSAPublicKey publicKey) throws Exception {
        Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
        Cipher cipher = Cipher.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        //模长
        int key_len = publicKey.getModulus().bitLength() / 8;
        //加密数据长度<=模长-11
        String[] datas = splitString(data, key_len - 11);
        String mi = "";
        //如果明文长度大于模长-11则要分组加密
        for (String s : datas) {
            mi += bcd2Str(cipher.doFinal(s.getBytes()));
        }
        return mi;
    }

    /**
     * 私钥解密 
     *
     * @paramdata 
     * @paramprivateKey 
     * @return 
     * @throwsException  
     */
    public static String decryptByPrivateKey(String data, RSAPrivateKey privateKey) throws Exception {
        Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
        Cipher cipher = Cipher.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        //模长
        int key_len = privateKey.getModulus().bitLength() / 8;
        byte[] bytes = data.getBytes();
        byte[] bcd = ASCII_To_BCD(bytes, bytes.length);
        //System.err.println(bcd.length);
        //如果密文长度大于模长则要分组解密
        String ming = "";
        byte[][] arrays = splitArray(bcd, key_len);
        for (byte[] arr : arrays) {
            ming += new String(cipher.doFinal(arr));
        }
        return ming;
    }

    /**
     *  
     * ASCII码转BCD码 
     */
    public static byte[] ASCII_To_BCD(byte[] ascii, int asc_len) {
        byte[] bcd = new byte[asc_len / 2];
        int j = 0;
        for (int i = 0; i < (asc_len + 1) / 2; i++) {
            bcd[i] = asc_to_bcd(ascii[j++]);
            bcd[i] = (byte) (((j >= asc_len) ? 0x00 : asc_to_bcd(ascii[j++])) + (bcd[i] << 4));
        }
        return bcd;
    }

    public static byte asc_to_bcd(byte asc) {
        byte bcd;
        if ((asc >= '0') && (asc <= '9')) {
            bcd = (byte) (asc - '0');
        } else if ((asc >= 'A') && (asc <= 'F')) {
            bcd = (byte) (asc - 'A' + 10);
        } else if ((asc >= 'a') && (asc <= 'f')) {
            bcd = (byte) (asc - 'a' + 10);
        } else {
            bcd = (byte) (asc - 48);
        }
        return bcd;
    }

    /**
     * BCD转字符串
     */
    public static String bcd2Str(byte[] bytes) {
        char temp[] = new char[bytes.length * 2], val;

        for (int i = 0; i < bytes.length; i++) {
            val = (char) (((bytes[i] & 0xf0) >> 4) & 0x0f);
            temp[i * 2] = (char) (val > 9 ? val + 'A' - 10 : val + '0');

            val = (char) (bytes[i] & 0x0f);
            temp[i * 2 + 1] = (char) (val > 9 ? val + 'A' - 10 : val + '0');
        }
        return new String(temp);
    }

    /**
     *  
     * 拆分字符串  
     */
    public static String[] splitString(String string, int len) {
        int x = string.length() / len;
        int y = string.length() % len;
        int z = 0;
        if (y != 0) {
            z = 1;
        }
        String[] strings = new String[x + z];
        String str = "";
        for (int i = 0; i < x + z; i++) {
            if (i == x + z - 1 && y != 0) {
                str = string.substring(i * len, i * len + y);
            } else {
                str = string.substring(i * len, i * len + len);
            }
            strings[i] = str;
        }
        return strings;
    }

    /**
     * 拆分数组 
     */
    public static byte[][] splitArray(byte[] data, int len) {
        int x = data.length / len;
        int y = data.length % len;
        int z = 0;
        if (y != 0) {
            z = 1;
        }
        byte[][] arrays = new byte[x + z][];
        byte[] arr;
        for (int i = 0; i < x + z; i++) {
            arr = new byte[len];
            if (i == x + z - 1 && y != 0) {
                System.arraycopy(data, i * len, arr, 0, y);
            } else {
                System.arraycopy(data, i * len, arr, 0, len);
            }
            arrays[i] = arr;
        }
        return arrays;
    }

    public static void main(String[] args) throws Exception {
        HashMap<String, Object> map = getKeys();
        //生成公钥和私钥
        RSAPublicKey publicKey = (RSAPublicKey) map.get("public");
        RSAPrivateKey privateKey = (RSAPrivateKey) map.get("private");

        //模
        String modulus = publicKey.getModulus().toString();
        System.out.println("pubkeymodulus=" + modulus);
        //公钥指数
        String public_exponent = publicKey.getPublicExponent().toString();
        System.out.println("pubkeyexponent=" + public_exponent);
        //私钥指数
        String private_exponent = privateKey.getPrivateExponent().toString();
        System.out.println("privateexponent=" + private_exponent);
        //明文
        String ming = "123456";
        //使用模和指数生成公钥和私钥
        RSAPublicKey pubKey = RSAUtils.getPublicKey(modulus, public_exponent);
        RSAPrivateKey priKey = RSAUtils.getPrivateKey(modulus, private_exponent);
        //加密后的密文
        String mi = RSAUtils.encryptByPublicKey(ming, pubKey);
        System.err.println("mi=" + mi);
        //解密后的明文
        String ming2 = RSAUtils.decryptByPrivateKey(mi, priKey);
        System.err.println("ming2=" + ming2);
    }
}

js 加密

账号：<input type="text" id="username" ><br><br>
密码：<input type="password" id="password"><br><br>
<input id="publicKeyExponent" value="" type="hidden"> //后台传过来的公钥
<input id="publicKeyModulus" value="" type="hidden">//后台传过来的模

<script>
	$(function(){
		//生成登陆用RSA公钥 密钥
		$.ajax({
			url:'${basePath}UserText/loginRSA.do',
			type:'post',
			dataType:'json',
			success:function(data){
				$("#publicKeyExponent").val(data[0]);
				$("#publicKeyModulus").val(data[1]);
			}
		})
	});

	//点击登录按钮，执行的方法
	function login1(){
		var username=$("#username").val();
		var password=$("#password").val();
		//RSA加密
        var publicKeyExponent=$("#publicKeyExponent").val();
        var publicKeyModulus=$("#publicKeyModulus").val();
        RSAUtils.setMaxDigits(200);
		var key = new RSAUtils.getKeyPair(publicKeyExponent, "", publicKeyModulus);
		var userNameEncrypt = RSAUtils.encryptedString(key,username.split("").reverse().join(""));
		var userPwdEncrypt = RSAUtils.encryptedString(key,password.split("").reverse().join(""));

		$.ajax({
			url:"${basePath}UserText/textLogin.do",
			data:'post',
			dataType:'json',
			data:{"username":userNameEncrypt,"password":userPwdEncrypt},
			success:function(data) {
				if(data == 'success') {
					alert("登录成功")
					window.location.href="${basePath}UserText/textList.do";
				} else if (data == 'usernameIsNull'){
					alert("账号错误")
				} else if (data == 'passwordIsNull'){
					alert("密码错误")
				} else {
					alert("登录失败")
				}
			}
		})
	}
</script>

java 后台接收，解密

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

/**
 * @Description：Login
 * @Author：Anhk丶
 * @Date：2020/7/611:27
 * @Version：1.0
 */
public class LoginController {

    //生成登陆用RSA公钥密钥
    @RequestMapping(value = "/loginRSA")
    @ResponseBody
    public List<String> loginRSA(HttpServletRequest request) {
        //HttpServletRequestrequest=ServletActionContext.getRequest();
        String publicKeyExponent = "";
        String publicKeyModulus = "";

        try {
            HashMap<String, Object> map = RSAUtils.getKeys();
            //生成公钥和私钥
            RSAPublicKey publicKey = (RSAPublicKey) map.get("public");
            RSAPrivateKey privateKey = (RSAPrivateKey) map.get("private");
            //私钥保存在session中，用于解密
            request.getSession().setAttribute("privateKeyLogin", privateKey);
            //公钥信息保存在页面，用于加密公钥指数  .toString(16)表示转为16进制的字符串;
            publicKeyExponent = publicKey.getPublicExponent().toString(16);
            System.out.println("公钥指数:" + publicKeyExponent);
            //模 .toString(16)表示转为16进制的字符串;
            publicKeyModulus = publicKey.getModulus().toString(16);
            System.out.println("模指数:" + publicKeyModulus);

            //request.getSession().setAttribute("publicKeyExponent",publicKeyExponent);
            //request.getSession().setAttribute("publicKeyModulus",publicKeyModulus);
        } catch (Exception e) {
            log.error("RSA生成公钥错误", e);
        }
        List<String> list = new ArrayList<String>();
        list.add(publicKeyExponent);
        list.add(publicKeyModulus);
        return list;
    }

    //登录验证
    @RequestMapping(value = "/textLogin")
    @ResponseBody
    public String textLogin(String username, String password, HttpServletRequest request) {

        if (org.apache.commons.lang.StringUtils.isBlank(username)) {
            System.out.println("theusernameisnull");
            return "usernameIsNull";
        }
        if (org.apache.commons.lang.StringUtils.isBlank(password)) {
            System.out.println("thepasswordisnull");
            return "passwordIsNull";
        }
        RSAPrivateKey privateKey = (RSAPrivateKey) request.getSession().getAttribute("privateKeyLogin");
        try {
            username = RSAUtils.decryptByPrivateKey(username, privateKey);
            System.out.println("解密后的用户名：" + username);
            password = RSAUtils.decryptByPrivateKey(password, privateKey);
            System.out.println("解密后密码：" + password);
        } catch (Exception e) {
            log.error("RSA解密失败", e);
        }
        User user = userService.getUser(username);
        if (user != null) {
            if (password.equals(user.getPassword())) {
                System.out.println("登陆成功");
                return "success";
            }
        }
        System.out.println("登录失败");
        return "fail";
    }
}
Anhk丶
关注
  • 3
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
密码的前端加密与后端解密
code_baogege的博客
10-12 1282
一前端vue加密 #安装依赖 npm install jsencrypt #公钥加密密码 import JSEncrypt from 'jsencrypt/bin/jsencrypt.min' const publicKey = 'MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAMNRhRdV7BI4MN5buB2Dyj6+dSOEpa6jCiJETtBtwfTuWlerqzdgxvFJHKLrHDscCagHY1X1wXh599LE0fs2nQ8CAwEAAQ==' // 加密 e
aes 前端加密 后端c# 解密
12-22
压缩包中的`AesDome.cs`文件可能是一个包含AES加密和解密示例的C#类，而`BAES.html`可能是展示如何使用`crypto-js`库进行前端加密的HTML页面。通过这两个文件，你可以更深入地了解如何在实际项目中实现这个流程。 ...
前端加密登录，后端解密,aes加密
01-15
前端加密登录，对称加密
前端登陆加密和后端解密
weixin_30354675的博客
11-29 4425
实现了前端对数据进行加密后传输，后端对加密的数据进行解密，然后去数据库对比。因为要解密所以采用对称加密算法。不讨论哪个对称加密算法好，这里采用DES，在实现的过程中发现要找一个js版本的DES加密，并且java能DES解密的还真不容易。加解密思路由于是对称加密，所以加解密的密钥就非常重要。这里采用uuid作为加解密的密钥，而且每次请求页面时生成的uuid都不一样，保证每次的密钥都不知道是什么。看后...
前端cryptojs加解密，后端node环境（nestjs）crypto加解密
最新发布
weixin_55458088的博客
04-24 1058
搞定，之前还做了很多猜想，因为看大家写的加解密的例子秘钥都是16位的，于是猜测是不是前端默认是16位的，所以把后端的解密模式也改成了aes-128-cbc，后面再试的时候发现32位aes-256-cbc也没问题，所以意味着前端其实没有固定秘钥位数，后端解密的时候用的模式才固定了秘钥位数，前端跟着后端走就行。之前说搞一个完整的前后端项目，前端用nuxt3，后端用nestjs，先搞个简单的用户体系，里面包含了连接数据库，增删改查操作，联表查询，用户token校验，数据加解密传输。
前后端登录的密码加密和解密
qq_55272229的博客
10-30 3202
salt 盐,每一个用户在注册的时候随机生成一个盐,在做用户明文登录，转换成二次加密,然后根据用户的盐在进行一次加密保存到数据库,这样即使数据库被袭击,用需要大量时间来破解密码。在一个典型的前后端应用中，前端对密码进行加密后传给后端，后端再进行解密或验证。这通常涉及前端加密、后端解密或验证的相互配合。后端收到加密后的密码后，不进行解密，而是对密码进行相同的加密（使用相同的哈希函数或加密算法和密钥），然后与数据库中存储的加密后密码进行比对。前端可以使用各种加密库或算法对密码进行加密。
用户密码的加密解密操作（前端加密，后端解密）
热门推荐
weixin_42510217的博客
08-02 1万+
用户密码的加密解密操作 作者是个小菜狗，行文过程基本都基于自己理解，没有深入查阅文献，如有错误，还请大神指出 背景： 公司做的是一个某某平台的系统，包括前台和后台，作者刚毕业，刚开始试用，带我的师傅让我实现密码的加密解密，说实话，都有封装好的api，直接调用什么的，真的没啥难度，后来被其他小事情耽搁了，回过头来，前辈已经做好了，就叫我好好看看，理解下，嗯嗯……说好的让我做的，咋就自己弄了呢？嘿嘿 1、流程 先说说加密的需要，http协议默认情况下是以明文进行传输的，即没有对网上传输的数据进行加密的，
aes加密前端js+后台解密
08-20
在这个例子中，`encryptedText`是前端加密后的Base64字符串，`key`和`iv`分别是从前端接收到的密钥和向量。解密完成后，原始数据将恢复为字符串形式。 在整个过程中，需要注意的是，前端和后端必须使用相同的密钥和...
国密SM4，layui前端 和.net core后台 加密解密 .net加密解密
03-22
在实现前端加密时，开发者通常会利用JavaScript的CryptoJS库或者其他支持SM4的JavaScript库来执行加密操作。JavaScript的加密库通常需要与后端进行配合，确保加解密的密钥管理和算法一致性。 在.NET Core后端，C#...
java后台及前端js使用AES互相加解密及前端md5加密
11-02
本主题涉及的是在Java后台与前端JavaScript之间利用AES（Advanced Encryption Standard）进行加解密，以及前端的MD5（Message-Digest Algorithm 5）加密技术。以下是关于这些知识点的详细解释： 1. **AES加密**：...
RSA前端加密后台解密
11-21
实现前端通过RSA的公钥加密，后台通过RSA的秘钥进行解密。
DES前端加密，后端可解密
06-06
前端DES加密代码，与后端约定密钥可解密。使用了谷歌的tripledes.js插件实现
前端JS加密，后端JAVA解密实例.rar
05-23
前端JS加密，后端JAVA解密实例和代码，适合前端加密参数然后传到后端解密。
RSA前台加密后台解密Demo
10-28
在项目中，需要用到登录把用户名和密码进行加密传输需求。本人使用了DES+RSA加密技术，在这里就写了一个Demo。此压缩包中包含所有jar文件，下载后只需解压导入，无需再从网络查找jar包，包含齐全，在此分享给大家。
security.js 前端RSA加密解密
07-10
security.js基于RSA算法用于前端加密与密钥传输，需要跟后台配合使用 var key = new RSAUtils.getKeyPair("${publicKeyExponent}", "", "${publicKeyModulus}"); var reversedPwd = password.split("").reverse().join("");//js里面是反序的字符串，不知道为啥 var encrypedPwd = RSAUtils.encryptedString(key,reversedPwd);
security.js 实现前台加密
01-31
亲测可以使用，各位可以放心下载使用 js实现的RSA算法 使用RSA加密过的数据可在网络上安全传输 RSAUtils.setMaxDigits(200); var key = new RSAUtils.getKeyPair("${publicKeyExponent}", "", "${publicKeyModulus}"); //颠倒密码的顺序，否则解密后会发现密码顺序是反的 var reversedPwd = password.split("").reverse().join(""); var encrypedPwd = RSAUtils.encryptedString(key,reversedPwd);
前端AES加密，后端解密，有效防止数据外泄_前端加密后端解密
m0_60732644的博客
04-16 2047
/AES加密$.ajax({data: {......});iv: _iv,});
前端密码加密后端解密保证登录安全
ZXJ~佳的博客
05-21 884
目前很多网站需要登录安全认证，登录的时候输入用户名密码，密码虽然是看不到的，但是会点前端的都会按f12后还是可以看到用户输入的是明码，轻松知道用户名和密码，而且现在浏览器很多都是记住用户名密码的，更加导致了用户名和密码的泄露风险，在网上没有找到好的解决方法，自己贴一个记录一下，欢迎大家多多评论： 前端： var password = $.common.trim($("input[name='...
前端AES加密，后端解密，有效防止数据外泄
hexianfan的博客
07-13 9309
/AES加密 var key = "ABCDEFGHIJKL_key";
base64前后台加密解密
09-13
在前端进行Base64加密解密时，同样可以使用编程语言提供的相关函数或库来实现。一般而言，前端的加密解密逻辑如下： 1. 首先，将待加密或解密的数据转换为字节数组或字符串。 2. 然后，使用Base64编码算法对字节数组...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值