RSA非对称性前端加密后端解密

最新推荐文章于 2024-05-12 22:36:33 发布
最新推荐文章于 2024-05-12 22:36:33 发布
阅读量1.3w 收藏 17
点赞数 2
分类专栏： 加密与安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chang_li/article/details/58196141
版权

参考：http://netsecurity.51cto.com/art/201108/287971.htm

对称加密和非对称加密。

对称加密中加密和解密用同一个密钥，如 AES/DES。密钥一旦被泄露，那么整体加密信息都将被破解。

非对称加密是生成一个密钥对即私钥和公钥，私钥加密的信息，只有对应的公钥才能解密；反之，公钥加密的信息，只能由对应的私钥才能解密。一定要保护好私钥。从性能上来说，非对称加密相对于对称加密要慢很多，所以一般只用于少量数据的加密，如银行三要素、登录密码等信息。 

数字签名

数字签名的意义在于，对传输过来的数据进行校验，确保数据在传输过程中不被修改。提交之前对明文信息通过hash算法获取摘要，然后进行加密即为数字签名。

数字证书

数字证书的意义在于，确保公钥没被篡改。数字证书主要包括：证书的发布机构，证书的有效期，公钥，证书所有者，签名所使用的的算法。

数字证书需要由权威的公司来提供，证书中心CA为公钥做认证，证书中心会对甲方的公钥和一些相关信息加密，生成数字证书。这样甲方在给乙方发送信息时，只需在签名的同时附上数字证书就可以了。乙方在收到信息后，使用CA的公钥解开数字证书，就可以拿到甲方的公钥，然后就证明数字签名是不是甲方的。https就是应用数字证书的一个示例。

数据交互流程分析

1、user向server发送一个通信请求
user->server：你好
2、server向user发送自己的数字证书。证书中有一个公钥用来加密信息，私钥由server持有
server->user：你好，我是server，这里是我的数字证书 
3、user收到server的证书后，首先验证这个数字证书到底是不是server的，数字证书有没有什么问题，数字证书如果检查没有问题，就说明数字证书中的公钥确实是server的。检查数字证书后，user会发送一个随机的字符串给server用私钥去加密（检查数字证书，后文介绍）
user->server：向我证明你就是server，这是一个随机字符串  
4、server把加密的结果返回给user。
server->user：{一个随机字符串(信息摘要加密)}（用私钥进行RSA加密）
5、user用公钥解密这个返回结果，如果解密结果与之前生成的随机字符串一致，那说明对方确实是私钥的持有者，或者说对方确实是server。 验证server的身份后，user生成一个对称加密算法和密钥，用于后面的通信的加密和解密。这个对称加密算法和密钥，user会用公钥加密后发送给server，别人截获了也没用，因为只有server手中有可以解密的私钥。这样，后面server和user就都可以用对称加密算法来加密和解密通信内容了。
server->user：{OK，已经收到你发来的对称加密算法和密钥！有什么可以帮到你的？}（用密钥进行对称加密）
user->server：{我的用户名是test，密码是123321，我要登录}(用密钥进行对称加密)
server->user：{你好，你已登录成功}(用密钥进行对称加密)

 

/** 
 * RSA 工具类。提供加密，解密，生成密钥对等方法。 
 * 需要到http://www.bouncycastle.org下载bcprov-jdk14-123.jar。 
 *  
 */
public class RSAUtils {
    public static final String WEB_MODULUS = "abcb0c959f370bcaae9dff448826ccec64616debac81b220d3302296c1f7cc845b83c449c0ae35bfe49869d0924466de5dfdf416998516e95bd4ec0fdfb825eb3c1b2864dad0786f35675f5cf63fbea271cb1079330ef84dab8941d140aa57f93c853e0518051e5751e78512667d8047b82e7e3adae0bf3dcb95c6a7852763db";
    public static final String WEB_PRIVATEEXPONENT = "528eb47fd3ab3348beb8c0d44f94dc380bb916266e190c321b6927fa1f8d60dda273c389398db0eb3c3cb1ac2ec049e6247cd6b70e158d200c6ef8bc42110c5d103cd5e5c51ce265f20dbd967231a505b5f179701e7b5e5e6d59530a9f291464c3101a18e7755fc9dfbefc091c52e51528d47a7b87a6f2349fb8c2a9ffc5f4d9";

    /** 
     * * 生成密钥对
     * @return KeyPair
     * @throws Exception
     */
    public static KeyPair generateKeyPair(File cfgFile) throws Exception {
        try {
            KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());
            final int KEY_SIZE = 1024;// 没什么好说的了，这个值关系到块加密的大小，可以更改，但是不要太大，否则效率会低  
            keyPairGen.initialize(KEY_SIZE, new SecureRandom());
            KeyPair keyPair = keyPairGen.generateKeyPair();
            saveKeyPair(keyPair, cfgFile);
            return keyPair;
        } catch (Exception e) {
            throw new Exception(e.getMessage());
        }
    }

    /**
     * getKeyPair
     * @param cfgFile
     * @return
     * @throws Exception
     */
    public static KeyPair getKeyPair(File cfgFile) throws Exception {
        FileInputStream fis = new FileInputStream(cfgFile);
        ObjectInputStream oos = new ObjectInputStream(fis);
        KeyPair kp = (KeyPair) oos.readObject();
        oos.close();
        fis.close();
        return kp;
    }

    /**
     * saveKeyPair
     * @param kp
     * @param cfgFile
     * @throws Exception
     */
    public static void saveKeyPair(KeyPair kp, File cfgFile) throws Exception {
        FileOutputStream fos = new FileOutputStream(cfgFile);
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        //生成密钥  
        oos.writeObject(kp);
        oos.close();
        fos.close();
    }

    /** 
     * * 生成公钥
     * @param modulus
     * @param publicExponent
     * @return RSAPublicKey
     * @throws Exception 
     */
    public static RSAPublicKey generateRSAPublicKey(byte[] modulus, byte[] publicExponent) throws Exception {
        KeyFactory keyFac = null;
        try {
            keyFac = KeyFactory.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());
        } catch (NoSuchAlgorithmException ex) {
            throw new Exception(ex.getMessage());
        }
        RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(new BigInteger(modulus), new BigInteger(publicExponent));
        try {
            return (RSAPublicKey) keyFac.generatePublic(pubKeySpec);
        } catch (InvalidKeySpecException ex) {
            throw new Exception(ex.getMessage());
        }
    }

    /** 
     * * 生成私钥 
     * @param modulus
     * @param privateExponent
     * @return RSAPrivateKey
     * @throws Exception 
     */
    public static RSAPrivateKey generateRSAPrivateKey(byte[] modulus, byte[] privateExponent) throws Exception {
        KeyFactory keyFac = null;
        try {
            keyFac = KeyFactory.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());
        } catch (NoSuchAlgorithmException ex) {
            throw new Exception(ex.getMessage());
        }

        RSAPrivateKeySpec priKeySpec = new RSAPrivateKeySpec(new BigInteger(modulus), new BigInteger(privateExponent));
        try {
            return (RSAPrivateKey) keyFac.generatePrivate(priKeySpec);
        } catch (InvalidKeySpecException ex) {
            throw new Exception(ex.getMessage());
        }
    }

    /** 
     * * 加密 
     * @param pk 加密的密钥
     * @param data 待加密的明文数据
     * @return 加密后的数据 
     * @throws Exception 
     */
    public static byte[] encrypt(PublicKey pk, byte[] data) throws Exception {
        try {
            Cipher cipher = Cipher.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());
            cipher.init(Cipher.ENCRYPT_MODE, pk);
            int blockSize = cipher.getBlockSize();// 获得加密块大小，如：加密前数据为128个byte，而key_size=1024  
            // 加密块大小为127  
            // byte,加密后为128个byte;因此共有2个加密块，第一个127  
            // byte第二个为1个byte  
            int outputSize = cipher.getOutputSize(data.length);// 获得加密块加密后块大小  
            int leavedSize = data.length % blockSize;
            int blocksSize = leavedSize != 0 ? data.length / blockSize + 1 : data.length / blockSize;
            byte[] raw = new byte[outputSize * blocksSize];
            int i = 0;
            while (data.length - i * blockSize > 0) {
                if (data.length - i * blockSize > blockSize) {
                    cipher.doFinal(data, i * blockSize, blockSize, raw, i * outputSize);
                } else {
                    cipher.doFinal(data, i * blockSize, data.length - i * blockSize, raw, i * outputSize);
                }
                // 这里面doUpdate方法不可用，查看源代码后发现每次doUpdate后并没有什么实际动作除了把byte[]放到
                // ByteArrayOutputStream中，而最后doFinal的时候才将所有的byte[]进行加密，可是到了此时加密块大小很可能已经超出了  
                // OutputSize所以只好用dofinal方法。  
                i++;
            }
            return raw;
        } catch (Exception e) {
            throw new Exception(e.getMessage());
        }
    }

    /** 
     * 解密 
     * @param pk 解密的密钥
     * @param raw 已经加密的数据
     * @return 解密后的明文
     * @throws Exception 
     */
    @SuppressWarnings("static-access")
    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());
        }
    }

    /**
     * hexStringToBytes
     * @param hexString
     * @return
     */
    public static byte[] hexStringToBytes(String hexString) {
        if (null == hexString || "".equals(hexString)) {
            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 args
     * @throws Exception 
     */
    public static void main(String[] args) throws Exception {
        String result = "3bcf5f398f5017b66d3d8df2db3d88c9be06f8397b28b6f3b6e430d5abd84b3644d601b477c4292b53d4c28f17b9864803bdd8c93a2c2a4e9b277f89c5c648de96da9cc91d1cdab3e3adcdb837f0f0fbd6be8b6c2e36d735f8aa1674439b11ed3520303cef5c2c886363c63db70b844c95c8284b12bdb48b43ade84b707627a2";  
        System.out.println("原文加密后为：");  
        System.out.println(result);  
        byte[] en_result = hexStringToBytes(result);//new BigInteger(result, 16).toByteArray();  
        String modulus = WEB_MODULUS;
        String privateExponent = WEB_PRIVATEEXPONENT;
        RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) RSAUtils.generateRSAPrivateKey(new BigInteger(modulus, 16).toByteArray(), new BigInteger(privateExponent, 16).toByteArray());
        byte[] de_result = RSAUtils.decrypt(rsaPrivateKey, en_result);  
        System.out.println("还原密文：");  
        StringBuffer sb = new StringBuffer();  
        sb.append(new String(de_result));  
        System.out.println(sb.reverse().toString().substring(13));  
    }  
}

<!DOCTYPE html>
<html>
<head>
<!-- <base href=""></base> -->
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<script src="jquery-1.8.3.js"></script>
<script src="jsencrypt.min.js"></script>
<script src="Barrett.js"></script>
<script src="BigInt.js"></script>
<script type="text/javascript">
     function webencryptAES(str){
        if(!str) return '';
        setMaxDigits(130);
        var PublicExponent ="10001";
        var modulus ="abcb0c959f370bcaae9dff448826ccec64616debac81b220d3302296c1f7cc845b83c449c0ae35bfe49869d0924466de5dfdf416998516e95bd4ec0fdfb825eb3c1b2864dad0786f35675f5cf63fbea271cb1079330ef84dab8941d140aa57f93c853e0518051e5751e78512667d8047b82e7e3adae0bf3dcb95c6a7852763db";
        var key = new RSAKeyPair(PublicExponent,"",modulus);
        var ramdomTxt= String(new Date().getTime());
        if(ramdomTxt.length>8){
            ramdomTxt= ramdomTxt.substring(ramdomTxt.length-8);
        }else if(ramdomTxt.length<8){
            var lStr='';
            for(var i=0;i<8-ramdomTxt.length;i++){
                lStr+='0';
            }
            ramdomTxt = lStr+ramdomTxt;
        }
        ramdomTxt+=String(Math.ceil(Math.random()*100000));
        return encryptedString(key,ramdomTxt+String(str));
    }
</script>
<script type="text/javascript">
	
	$(function(){
		$("#getPwtBtn").click(function(){
			var pwdText = $('#pwdText').val();
			var test = webencryptAES(pwdText);
			$("#resultPwd").text(test);
		});
	});
	
</script>
</body>
<body>
	<div id="" class="">
		<label>密码：</label>
		<input id="pwdText" type="text"></input>
		<button id="getPwtBtn">获取密文</button>
	</div>
	<div id="" class="" style="width:60%">
		<textfield id="resultPwd"></textfield>
	</div>
</body>
</html>

 

1、通过代码能看出来，公钥长度明显小于私钥
2、遵循：公钥加密-私钥解密，私钥加密-公钥解密的原则
3、公钥和私钥肯定是完全不同

参考：https://blog.csdn.net/chay_chan/article/details/58605605

chang_hf
关注
  • 2
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
非对称加密-RSA
BlockchainY的博客
04-11 955
非对称加密 非对称加密也叫公钥密码: 使用公钥加密, 使用私钥解密。 在对称密码中，由于加密和解密的密钥是相同的，因此必须向接收者配送密钥。用于解密的密钥必须被配送给接收者，这一问题称为密钥配送问题。如果使用非对称加密也可以称为公钥密码，则无需向接收者配送用于解密的密钥，这样就解决了密钥配送问题。 非对称加密中，密钥分为加密密钥和解密密钥两种。发送者用加密密钥对消息进行加密，接收者用解密密钥对密文进行解密。要理解公钥密码，清楚地区分加密密钥和解密密钥是非常重要的。加密密钥是发送者加密时使用的，而解密密钥则是
前后端RSA非对称加密解密(代码示例).rar
02-10
登录时，用户的密码用明文传输，太不安全，应该加密传输，怎么做呢，对称加密一旦秘钥丢失则形同虚设，最好使用非对称加密的方式，由后端事先生成公钥和私钥，公钥发给前端页面，私钥后端自己保留，前端进行认证时，把密码原文用公钥加密再发给后端，后端用私钥解密而得到原文。非对称加密算法常用RSA算法，秘钥使用base64编码成字符串，后端使用jdk8的标准API,前端使用jsencrypt.js进行RSA的对应操作。经过测试，本例中的前后端代码的加密解密计算结果是一致的。
一文详解 RSA 非对称加密算法
赶路人儿
08-25 4393
RSA加密算法是一种非对称加密算法。RSA是1977年由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）一起提出的。当时他们三人都在麻省理工学院工作。RSA就是他们三人姓氏开头字母拼在一起组成的。1973年，在英国政府通讯总部工作的数学家克利福德·柯克斯（Clifford Cocks）在一个内部文件中提出了一个相同的算法，但他的发现被列入机密，一直到1997年才被发表。换言之，对一极大整数做因数分解愈困难，RSA算法愈可靠。..
2024年前端最全前后端（JAVA）实现AES对称加解密方式_前端后端对称加解密(1)，华为社招面试
最新发布
2401_84436058的博客
05-12 865
前端框架太多了，真的学不动了，别慌，其实对于前端的三大马车，Angular、React、Vue 只要把其中一种框架学明白，底层原理实现，其他两个学起来不会很吃力，这也取决于你以后就职的公司要求你会哪一个框架了，当然，会的越多越好，但是往往每个人的时间是有限的，对于自学的学生，或者即将面试找工作的人，当然要选择一门框架深挖原理。JS 内容涉及到的知识点较多，看到网上有很多人建议你从头到尾抱着那本《JavaScript高级程序设计》学，我是不建议的，毕竟刚接触 JS 谁能看得下去，当时我也不能，也没那样做。
RSA前端加密后端解密
马万明的专栏
12-16 9426
通过强大的开源工具类，我们可以实现前端公钥加密，后端私钥解密，非对称加密方式相对比较安全。 通过强大的开源工具类，我们可以实现前端公钥加密，后端私钥解密，非对称加密方式相对比较安全。 1. 准备工作 下载jar包     https://mvnrepository.com/artifact/org.bouncycastle/bcprov-jdk16  加密解密工具类，引用到该包 网上下载三个js文件       2.开始具体工作 前端页面加密，rsaPublicKey是后端写的一个action
Java(110)：非对称加密RSA的使用(KeyPair生成密钥)
fen_fen的专栏
03-13 3325
Java(110)：非对称加密RSA的使用(KeyPair生成密钥)
RSA加解密方式以及生成RSA密钥对方式
社畜程序员的无聊博客
11-11 8252
RSA加解密方式以及生成RSA密钥对方式 需要按照具体情况进行操作对于某些时候可能有相对改动 前端使用jsencrypt实现密码加密传输方式 Java后端使用hutool工具和原生两种方式对于RSA进行生成与加解密 在线密钥对生成工具网站 http://web.chacuo.net/netrsakeypair 目前登录接口密码是明文传输，如果安全性有要求，可以调整成加密方式传输。参考如下 如果只需要查看后端方式请点击目录或者下拉到下方查看 前端实现 实例demo 1、修改前端login.js对密码进行
RSA非对称加密前端加密后端解密
12-29
总的来说，RSA非对称加密在前端加密和后端解密的应用中，提供了一种强安全性的解决方案。前端使用公钥加密，保护数据在传输过程中的安全；后端用私钥解密，确保只有合法的服务器才能访问到敏感信息。这种方式广泛...
RSA实现JS前端加密与PHP后端解密功能示例
10-16
RSA算法是一种非对称加密算法，它基于两个密钥：公钥和私钥。在JS前端加密和PHP后端解密的场景中，RSA扮演着关键角色，确保数据在传输过程中的安全。以下是对RSA在该场景下实现的详细解释： 1. **前端加密**： - ...
python Django RSA 前台加密 后端解密。
12-06
Python Django框架是一个强大的后端开发工具，而RSA（Rivest-Shamir-Adleman）则是一种广泛应用的非对称加密算法，常用于数据加密和数字签名。在这个场景中，我们将讨论如何在Django应用中实现RSA加密和解密，以便于...
rsa加密前后端交互.前端加密后端解密
08-01
后端则可能使用Java的Java Cryptography Extension (JCE)、Python的pycryptodome库或者其他语言的相应库来处理RSA加密解密。 在"RSA_DEMO"这个压缩包文件中，可能包含了实现RSA加密交互的示例代码，包括生成密钥对...
RSA 前端加密C#后端解密（两套可用程序）
11-28
3. 示例数据：可能包括示例明文、公钥和密文，用于测试和验证加密解密过程。 4. 配置文件或说明文档：可能提供了如何使用这些程序的指南，包括如何在前端和后端设置和调用相应的函数。 理解并使用这些程序涉及到的...
JS逆向之RSA 房天下登录pwd加密参数
tiebanggg的博客
02-25 3964
项目前言 tiebanggg又来更新了，本文章仅供学习研究，如若侵犯到贵公司权益请联系344567536@qq.com第一时间进行删除；切忌用于一切非法途径，否则后果自行承担！ 项目描述 最近在巩固学校js逆向，为加深记忆就此写下文章进行记录。 本次地址：aHR0cHM6Ly9wYXNzcG9ydC5mYW5nLmNvbS8/YmFja3VybD1odHRwcyUzQSUyRiUyRnd3dy5mYW5nLmNvbSUyRmRlZmF1bHQuaHRt 废话不多说不整花里胡哨的，直接开干 *********
RSA加密、解密、签名、验签的原理及方法
qq_61863348的博客
09-13 529
RSA加密是一种非对称加密。可以在不直接传递密钥的情况下，完成解密。这能够确保信息的安全性，避免了直接传递密钥所造成的被破解的风险。是由一对密钥来进行加解密的过程，分别称为公钥和私钥。两者之间有数学相关，该加密算法的原理就是对一极大整数做因数分解的困难性来保证安全性。通常个人保存私钥，公钥是公开的（可能同时多人持有）。
RSA-Keypair
weixin_42094659的博客
11-30 3547
package main import ( "crypto/rand" "crypto/rsa" "crypto/x509" "encoding/pem" "fmt" "os" ) const privateKeyFile = "./privateKeyKey.pem" //需求：生成并保存私钥，公钥 func generateKeyPair(bits int)error{ /...
使用非对称加密(RSA) 实现前端加密后端解密
joe0235的博客
02-27 3735
数据加密方式有： 单向加密、对称加密、非对称加密、加密盐、散列函数、数字签名。
Js实现AES/RSA加密
diemei3272的博客
02-25 371
1. function aesEncrypt(text, secKey) { var key = CryptoJS.enc.Utf8.parse(secKey); var iv = CryptoJS.enc.Utf8.parse("0102030405060708"); var srcs = CryptoJS.enc.Utf8.parse(text);...
前后端 JS 加密常用方法（非对称加密、对称加密）
热门推荐
雪急飞绪博客
04-15 1万+
jsencrypt 进行 RSA 加密 npm i jsencrypt 生成 RSA 密钥对 将生产的公钥和私钥复制过来 import JSEncrypt from 'jsencrypt/bin/jsencrypt' const publicKey = `非对称加密公钥` const privateKey = `非对称加密私钥` const txt = 'hello world' /* 加密 */ function encrypt(pass) { const encryptor = ne
rsa前端加密后端解密
03-30
RSA加密算法是一种非对称加密算法，即加密和解密使用不同的密钥。在前端使用RSA加密算法加密数据，需要使用公钥进行加密，然后将加密后的数据传输给后端进行解密，后端使用私钥进行解密。 具体步骤如下： 1. 前端生成公钥和私钥，将公钥传输给后端。 2. 后端接收到公钥后，使用公钥进行加密操作。 3. 前端接收到加密后的数据，将其传输给后端。 4. 后端接收到加密后的数据，使用私钥进行解密操作。 需要注意的是，RSA加密算法的密钥长度越长，安全性越高，但是加解密的速度也会越慢。因此需要根据具体情况选择合适的密钥长度。同时，RSA加密算法只适用于加密较小的数据，对于大数据的加密需要使用对称加密算法。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值