RSA非对称加密

最新推荐文章于 2023-12-03 00:00:00 发布
最新推荐文章于 2023-12-03 00:00:00 发布
阅读量281 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kings_coming/article/details/103572240
版权

非对称加密

js写法

这里要引入js文件，否则无法加密

	<script type="text/javascript"
		src="<%=basePath%>common/js/jsencrypt.min.js" charset="UTF-8"></script>
<script type="text/javascript">

 function encryptUrl(a) {
			a = a.toString();
			var publicKey = 'MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAJ1Y+eHJ9hkQWKAvBTZI+TyLAPRfpCCWt0Cg4bzfhH0HbEmN04hPCb65zYgHAWwUGDRavzuOyOH9zu70XJjFj4UCAwEAAQ==';
			var encrypt = new JSEncrypt();
			encrypt.setPublicKey(publicKey);
			var aEn = encrypt.encrypt(a);
			//alert(aEn);
			window.location.href = 'course_CourseRe_index1_course?prodid2=' + aEn;
		}

后端代码写法

在这里插入图片描述

package com.great.cymooc.module.course.service;


import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

import javax.crypto.Cipher;

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




/**
 * RSA工具类
 *
 */
public class RSAUtils {
	
	//   测试 start  
    public static void main(String[] args) throws Exception {
		// 后端接收到加密后的密码串
    	String encodedData = "jLZJ2LClFC59aPV9R+YUmaHe+QcXMaryDD0eBAsTfmZdNbyfWxIGnovR7P847NVCPm9/ejNyMrkgWKUDhf/SxA==";
    	
		byte[] decodedData = RSAUtils.decryptByPrivateKey(encodedData, PRIVATE_KEY);
        String outputStr = new String(decodedData);
        System.err.println("解密后: " + outputStr + "结束");
	}
   
	
    private static String publicKey;
    private static String privateKey;
    
    public static void setUp() throws Exception {
        Map<String, Key> keyMap = RSAUtils.initKey();
        publicKey = RSAUtils.getPublicKey(keyMap);
        privateKey = RSAUtils.getPrivateKey(keyMap);
        System.err.println("公钥: \n\r" + publicKey);
        System.err.println("私钥： \n\r" + privateKey);
    }

    public static void test() throws Exception {
        System.err.println("公钥加密——私钥解密");
        String inputStr = "www.Baidu.com$";
        byte[] encodedData = RSAUtils.encryptByPublicKey(inputStr, publicKey);
        byte[] decodedData = RSAUtils.decryptByPrivateKey(encodedData,
                privateKey);
        String outputStr = new String(decodedData);
        System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);
        System.err.println(inputStr.equals(outputStr));
    }

    public static void testSign() throws Exception {
        System.err.println("私钥加密——公钥解密");
        String inputStr = "www.Hao123.com$";
        byte[] data = inputStr.getBytes();
        byte[] encodedData = RSAUtils.encryptByPrivateKey(data, privateKey);
        byte[] decodedData = RSAUtils.decryptByPublicKey(encodedData, publicKey);
        String outputStr = new String(decodedData);
        System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);
        System.err.println(inputStr.equals(outputStr));
        
        
        System.err.println("私钥签名——公钥验证签名");
        // 产生签名
        String sign = RSAUtils.sign(encodedData, privateKey);
        System.err.println("签名:" + sign);
        // 验证签名
        boolean status = RSAUtils.verify(encodedData, publicKey, sign);
        System.err.println("状态:" + status);
    }
    //   测试 end  
	
	
	
	
	
	
	
	public static final String PUBLIC_KEY = "MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAJ1Y+eHJ9hkQWKAvBTZI+TyLAPRfpCCWt0Cg4bzfhH0HbEmN04hPCb65zYgHAWwUGDRavzuOyOH9zu70XJjFj4UCAwEAAQ==";
	public static final String PRIVATE_KEY = "MIIBVQIBADANBgkqhkiG9w0BAQEFAASCAT8wggE7AgEAAkEAnVj54cn2GRBYoC8FNkj5PIsA9F+kIJa3QKDhvN+EfQdsSY3TiE8JvrnNiAcBbBQYNFq/O47I4f3O7vRcmMWPhQIDAQABAkBXm9T2HMdDyVAvUD7srNDpHtRXPHFcG87I00sdKK7SFc/DFExwg5gUfZIKLwrDRmR3KQ0qp0KPMdHh5QY+6IPBAiEA6o/9+UmIwnmWQc9hyiqpYbhQ239nmg12w/lAPNRlf2kCIQCrumdDdbTjt8M0HKcIg+cdmm8GRJcA3+sQYLpBN9GnvQIhAL8iRGcNR5aI8yp/LYVKjClnwuOJhsdeb0ez5Gds/6P5AiAmXI2U1EaEWBiTG5N0o4KNamJC1C+nUl4AWptA1mdPQQIhANaHeNARyBmBG9bH00XNG6zpg+5UImR1tEDjktIyr9NB";
    /*public static final String PUBLIC_KEY = "MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBANID4bpP43dkdDdcl7HS3oJVIUKXNnpLLefL/CBWHGloZyF173SJoFeajEb+yjoI1GGToFqy7roqN1cE+etquTUCAwEAAQ==";
	public static final String PRIVATE_KEY = "MIIBVAIBADANBgkqhkiG9w0BAQEFAASCAT4wggE6AgEAAkEA0gPhuk/jd2R0N1yXsdLeglUhQpc2ekst58v8IFYcaWhnIXXvdImgV5qMRv7KOgjUYZOgWrLuuio3VwT562q5NQIDAQABAkBcgiE4NGB6AuG+USbwyXYB6wXPk1QH4n3CEPRqOgQh2XLVkp3ywJMRaqX0WfILcYQpGkL/dUYjKCfKfnCprwABAiEA7xYCJBa1ODPI64WAeBka/ZXOwgpWGFXu++IQKhcHuTUCIQDg32IrTjw3dHdtwZnKS3axWZlqIOYieYeTr+0WIjcAAQIgR3lE2pUPR+XzQrV+Wmjm8LhAPzHn2w6ViydhvbN006ECIQCbCWglc0sQ8LtmcJQXZO/wVlXvVb9VBXTz3dcX638AAQIgHHm2JB1LJCDyk7Un6PRDCJwhfGT84JXmyQMMWMvQcb0=";
    */
    /** 
     * 密钥长度，DH算法的默认密钥长度是1024 
     * 密钥长度必须是64的倍数，在512到65536位之间 
     * */  
    private static final int KEY_SIZE = 512; 
    public static final String KEY_ALGORITHM = "RSA";
    public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
    private static final String PUBLIC_KEY_PARAM = "RSAPublicKey";
    private static final String PRIVATE_KEY_PARAM = "RSAPrivateKey";

    public static byte[] decryptBASE64(String key) {
        return Base64.decodeBase64(key);
    }

    public static String encryptBASE64(byte[] bytes) {
        return Base64.encodeBase64String(bytes);
    }

    /**
     * 用私钥对信息生成数字签名
     *
     * @param data       加密数据
     * @param privateKey 私钥
     * @return
     * @throws Exception
     */
    public static String sign(byte[] data, String privateKey) throws Exception {
        // 解密由base64编码的私钥
        byte[] keyBytes = decryptBASE64(privateKey);
        // 构造PKCS8EncodedKeySpec对象
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        // KEY_ALGORITHM 指定的加密算法
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        // 取私钥匙对象
        PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);
        // 用私钥对信息生成数字签名
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initSign(priKey);
        signature.update(data);
        return encryptBASE64(signature.sign());
    }

    /**
     * 校验数字签名
     *
     * @param data      加密数据
     * @param publicKey 公钥
     * @param sign      数字签名
     * @return 校验成功返回true 失败返回false
     * @throws Exception
     */
    public static boolean verify(byte[] data, String publicKey, String sign)
            throws Exception {
        // 解密由base64编码的公钥
        byte[] keyBytes = decryptBASE64(publicKey);
        // 构造X509EncodedKeySpec对象
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        // KEY_ALGORITHM 指定的加密算法
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        // 取公钥匙对象
        PublicKey pubKey = keyFactory.generatePublic(keySpec);
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initVerify(pubKey);
        signature.update(data);
        // 验证签名是否正常
        return signature.verify(decryptBASE64(sign));
    }

    public static byte[] decryptByPrivateKey(byte[] data, String key) throws Exception{
        // 对密钥解密
        byte[] keyBytes = decryptBASE64(key);
        // 取得私钥
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
        // 对数据解密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        return cipher.doFinal(data);
    }

    /**
     * 解密<br>
     * 用私钥解密
     *
     * @param data
     * @param key
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPrivateKey(String data, String key)
            throws Exception {
        return decryptByPrivateKey(decryptBASE64(data),key);
    }

    /**
     * 解密<br>
     * 用公钥解密
     *
     * @param data
     * @param key
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPublicKey(byte[] data, String key)
            throws Exception {
        // 对密钥解密
        byte[] keyBytes = decryptBASE64(key);
        // 取得公钥
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicKey = keyFactory.generatePublic(x509KeySpec);
        // 对数据解密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, publicKey);
        return cipher.doFinal(data);
    }

    /**
     * 加密<br>
     * 用公钥加密
     *
     * @param data
     * @param key
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPublicKey(String data, String key)
            throws Exception {
        // 对公钥解密
        byte[] keyBytes = decryptBASE64(key);
        // 取得公钥
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicKey = keyFactory.generatePublic(x509KeySpec);
        // 对数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        return cipher.doFinal(data.getBytes());
    }

    /**
     * 加密<br>
     * 用私钥加密
     *
     * @param data
     * @param key
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPrivateKey(byte[] data, String key)
            throws Exception {
        // 对密钥解密
        byte[] keyBytes = decryptBASE64(key);
        // 取得私钥
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
        // 对数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, privateKey);
        return cipher.doFinal(data);
    }

    /**
     * 取得私钥
     *
     * @param keyMap
     * @return
     * @throws Exception
     */
    public static String getPrivateKey(Map<String, Key> keyMap)
            throws Exception {
        Key key = (Key) keyMap.get(PRIVATE_KEY_PARAM);
        return encryptBASE64(key.getEncoded());
    }

    /**
     * 取得公钥
     *
     * @param keyMap
     * @return
     * @throws Exception
     */
    public static String getPublicKey(Map<String, Key> keyMap)
            throws Exception {
        Key key = keyMap.get(PUBLIC_KEY_PARAM);
        return encryptBASE64(key.getEncoded());
    }

    /**
     * 初始化密钥
     *
     * @return
     * @throws Exception
     */
    public static Map<String, Key> initKey() throws Exception {
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        keyPairGen.initialize(KEY_SIZE);
        KeyPair keyPair = keyPairGen.generateKeyPair();
        Map<String, Key> keyMap = new HashMap<String, Key>(2);
        keyMap.put(PUBLIC_KEY_PARAM, keyPair.getPublic());// 公钥
        keyMap.put(PRIVATE_KEY_PARAM, keyPair.getPrivate());// 私钥
        return keyMap;
    }
    
}
`
前端用公钥加密完，传到后端，后端用私钥进行解密
kings_coming
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
非对称加密-RSA
BlockchainY的博客
04-11 971
非对称加密 非对称加密也叫公钥密码: 使用公钥加密, 使用私钥解密。 在对称密码中，由于加密和解密的密钥是相同的，因此必须向接收者配送密钥。用于解密的密钥必须被配送给接收者，这一问题称为密钥配送问题。如果使用非对称加密也可以称为公钥密码，则无需向接收者配送用于解密的密钥，这样就解决了密钥配送问题。 非对称加密中，密钥分为加密密钥和解密密钥两种。发送者用加密密钥对消息进行加密，接收者用解密密钥对密文进行解密。要理解公钥密码，清楚地区分加密密钥和解密密钥是非常重要的。加密密钥是发送者加密时使用的，而解密密钥则是
使用RSA实现前端公钥加密后端私钥解密
weixin_44727080的博客
02-11 2478
项目中在用户登录时需要进行用户名和密码加密,这里选用了RSA非对称加密的方式. 公钥私钥:OpenSSL的公钥私钥(Node crypto模块限制) 前端: jsencrypt库加密 后端: Node crypto模块 使用openssl生成公钥私钥 linux生成公钥私钥命令: genrsa -out rsa_private_key.pem 1024 // 生成1024位私钥 pkcs8 -topk8 -inform PEM -in rsa_private_key.pem -outform P
RSA加密
生命的演绎的博客
09-25 756
1、引用js(jsencrypt.min.js); 2、在发请求的js里增加 var password1 = $('#password').val(); var name1=$('#loginname').val(); var en_psw = "",en_name = ""; var publicKey = ""; var privateKey =...
nodejs之JSEncrypt模块，浏览器端非对称加密RSA算法库
最新发布
局外人LZ的博客
12-03 8186
JSEncrypt 是一个用于在浏览器中进行RSA加密和解密的 JavaScript 库。它提供了一种简单的方式来生成 RSA 密钥对、加密数据并使用私钥解密数据。生成密钥对：使用 JSEncrypt，你可以轻松地生成 RSA 密钥对。你可以通过调用 new JSEncrypt() 创建一个 JSEncrypt 实例，然后使用 getKey() 方法生成密钥对。生成的密钥对包括公钥和私钥。加密数据：一旦你有了密钥对，你可以使用公钥对数据进行加密。
RSA加解密 前台+后台方法
qq_16177883的博客
05-27 422
前台: 前台需要引用jsencrypt.min.js 来进行RAS加密操作 var encrypt = new JSEncrypt(); encrypt.setPublicKey('通过java代码RSA工具类获取的公钥'); <%-- 对登录名、密码、验证码进行加密 --%> var loginId=$("#loginId").val(); var passwo...
rsa与jsencrypt加密实现
一切都不太晚
10-11 1812
非对称加密，一般由发送方（客户端）和接收方（服务端）各持有一对公钥和私钥。私钥可以推出公钥，公钥不能推出私钥。数据交换的过程中，双方交换自己的公钥。各自私钥不公开。发送时使用对方的公钥进行加密。接收对方发来的密文时，使用自己私钥进行解密。发送方使用私钥将信息进行加签（签名），将密文与签名作为参数发起请求。接收方用自己私钥解密得到的明文，请求方公钥，接收的签名，进行验签（签名验证）。注释：必须会nodejs才能实现。
RSA非对称加密算法
02-14
RSA 非对称加密算法 RSA 非对称加密算法是一种经典的非对称加密算法，由罗纳德·李维斯特、阿迪·萨莫尔和伦纳德·阿德曼三人于 1977 年共同提出的。该算法的主要思想是基于大素数的乘积和因式分解之间的关系，通过...
ThinkPHP实现的rsa非对称加密类示例
10-18
ThinkPHP框架实现RSA非对称加密涉及到密钥的生成、公钥和私钥的存储、加密和解密操作。RSA加密是非对称加密的一种，它使用一对密钥——公钥和私钥。公钥可以公开给所有人使用，用于加密数据；私钥必须保密，用于解密...
C#实现简单的RSA非对称加密算法示例
08-29
C#实现简单的RSA非对称加密算法示例 本文主要介绍了C#实现简单的RSA非对称加密算法，结合实例形式分析了C#实现RSA加密的具体步骤与相关操作技巧。 RSA非对称加密算法是公钥密码体制中的一种，使用了一对密钥，一个...
jsencrypt.js
08-27
前端密码js加密工具，适用于前端页面引入，使用方法： var passWord = “12345678” var encrypt = new JSEncrypt(); encrypt.setPublicKey(p) //p指的是后端rsa生成的公钥 passWord = encrypt.encrypt(passWord);
rsa非对称加密，内含三个前端能用的加解密js
01-10
总之，RSA非对称加密技术为前端开发提供了安全传输数据的手段，而`security.js`、`jsencrypt.min.js`、`RSAjs`和`encrypt.js`这些JavaScript库则为开发者提供了实现这一技术的便捷工具。在实际开发中，需结合项目...
常见的加密方式
gong1422425666的博客
08-24 6228
加密在我们前端的开发中也是经常遇见的。本文只把我们常用的加密方法进行总结。不去纠结加密的具体实现方式（密码学，太庞大了）。 常见的加密方式 常见的加密算法基本分为这几类， 线性散列算法（签名算法）MD5 SHA1 对称性加密算法 AES DES 非对称性加密算法 RSA Md5加密 MD5是一种被广泛使用的线性散列算法，可以产生出一个128位（16字节）的散列值（hash value），用于确保信息传输完整一致。 MD5加密之后产生的是一个固定长度（32位或16位）的数据
使用RSA算法对用户密码进行加密
qq_36575363的博客
07-21 1067
RSA工具类 package utils; import java.io.ByteArrayOutputStream; import java.security.Key; import java.security.KeyFactory; import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.PrivateKey; import java.security.PublicKey;
Vue中使用jsencrypt进行RSA非对称加密
04-07 2835
在线生成生成RSA密钥对：http://web.chacuo.net/netrsakeypair 下载jsencrypt cnpm i -S jsencrypt 引入 import { JSEncrypt } from "jsencrypt"; 基本使用 注意：要加密的数据必须是字符串！！ 提示：给公钥直接用双引号“”引起来后可能要手动删掉每行末尾多余的空格，有点麻烦，此时可以直接用``来引。只是这样可能排版显示不太好看 testRSA() { l...
公钥（Public Key）与私钥（Private Key）
c1sdn19的专栏
11-09 9816
公钥（Public Key）与私钥（Private Key） 公钥（Public Key）与私钥（Private Key）是通过一种算法得到的一个密钥对（即一个公钥和一个私钥），公钥是密钥对中公开的部分，私钥则是非公开的部分。公钥通常用于加密会话密钥、验证数字签名，或加密可以用相应的私钥解密的数据。通过这种算法得到的密钥对能保证在世界范围内是唯一的。使用这个密钥对的...
RSA生成公私钥并加解密
龙吟山庄
04-29 1851
1.RSA简介 RSA是目前使用最广泛的公钥密码体制之一,可以实现非对称加密。它是1977年由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）一起提出的。当时他们三人都在麻省理工学院工作。RSA就是他们三人姓氏开头字母拼在一起组成的。RSA算法的安全性基于RSA问题的困难性，也就是基于大整数因子分解的困难性上。但是RS...
使用公钥加密配置文件中的用户名密码
dw147258dw的专栏
08-14 784
1.引入依赖 <dependency> <groupId>com.github.ulisesbocchio</groupId> <artifactId>jasypt-spring-boot-starter</artifactId> <version>3.0.2</version> </dependency> 2.生成public key 和private key，可以网上在线生成http://www.meto
使用Public Key (OpenSSH) 不用密码登陆
热门推荐
疯猫
01-13 5万+
1.PublicKey认证基本原理<br />    Public Key（非对称，asymmetric）认证使用一对相关联的Key Pair（一个公钥Public Key，一个私钥Private Key）来代替传统的密码（或我们常说的口令，Password）。顾名思义，PublicKey是用来公开的，可以将其放到SSH服务器自己的帐号中，而PrivateKey只能由自己保管，用来证明自己身份。<br />使用PublicKey加密过的数据只有用与之相对应的PrivateKey才能解密。这样在认证的过程中，
rsa非对称加密解密python
09-12
RSA是一种非对称加密技术，可以用于数据的加密和解密。在Python中，可以使用rsa模块来实现RSA非对称加密和解密操作。通过引用中的文章，我们可以了解到如何在Python中使用rsa模块进行非对称加密和解密。 首先，需要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值