RSA公钥解密

最新推荐文章于 2024-04-10 10:18:27 发布
最新推荐文章于 2024-04-10 10:18:27 发布
阅读量1.2k 收藏 2
点赞数 2
分类专栏： rsa公钥解密 文章标签： rsa
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013350170/article/details/54972140
版权

RSAUtils.java

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;  
import java.security.SecureRandom;
import java.security.Signature;  
import java.security.interfaces.RSAPrivateKey;  
import java.security.interfaces.RSAPublicKey;  
import java.security.spec.PKCS8EncodedKeySpec;  
import java.security.spec.X509EncodedKeySpec;  
import java.util.HashMap;  
import java.util.Map;  
  


import javax.crypto.Cipher;  

public class RSAUtils {  
  
    /** *//** 
     * 加密算法RSA 
     */  
    public static final String KEY_ALGORITHM = "RSA";  //RSA
      
    /** *//** 
     * 签名算法 
     */  
    public static final String SIGNATURE_ALGORITHM = "MD5withRSA";  
  
    /** *//** 
     * 获取公钥的key 
     */  
    private static final String PUBLIC_KEY = "RSAPublicKey";  
      
    /** *//** 
     * 获取私钥的key 
     */  
    private static final String PRIVATE_KEY = "RSAPrivateKey";  
      
    /** *//** 
     * RSA最大加密明文大小 
     */  
    private static final int MAX_ENCRYPT_BLOCK = 117;  
      
    /** *//** 
     * RSA最大解密密文大小 
     */  
    private static final int MAX_DECRYPT_BLOCK = 128;  
  
    /** *//** 
     * <p> 
     * 生成密钥对(公钥和私钥) 
     * </p> 
     *  
     * @return 
     * @throws Exception 
     */  
    public static Map<String, Object> genKeyPair() throws Exception {  
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);  
        keyPairGen.initialize(1024);  
        KeyPair keyPair = keyPairGen.generateKeyPair();  
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();  
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();  
        Map<String, Object> keyMap = new HashMap<String, Object>(2);  
        keyMap.put(PUBLIC_KEY, publicKey);  
        keyMap.put(PRIVATE_KEY, privateKey);  
        return keyMap;  
    }  
      
    /** *//** 
     * <p> 
     * 用私钥对信息生成数字签名 
     * </p> 
     *  
     * @param data 已加密数据 
     * @param privateKey 私钥(BASE64编码) 
     *  
     * @return 
     * @throws Exception 
     */  
    public static String sign(byte[] data, String privateKey) throws Exception {  
        byte[] keyBytes = Base64Utils.decode(privateKey);  
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);  
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
        PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);  
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);  
        signature.initSign(privateK);  
        signature.update(data);  
        return Base64Utils.encode(signature.sign());  
    }  
  
    /** *//** 
     * <p> 
     * 校验数字签名 
     * </p> 
     *  
     * @param data 已加密数据 
     * @param publicKey 公钥(BASE64编码) 
     * @param sign 数字签名 
     *  
     * @return 
     * @throws Exception 
     *  
     */  
    public static boolean verify(byte[] data, String publicKey, String sign)  
            throws Exception {  
        byte[] keyBytes = Base64Utils.decode(publicKey);  
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);  
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
        PublicKey publicK = keyFactory.generatePublic(keySpec);  
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);  
        signature.initVerify(publicK);  
        signature.update(data);  
        return signature.verify(Base64Utils.decode(sign));  
    }  
  
    /** *//** 
     * <P> 
     * 私钥解密 
     * </p> 
     *  
     * @param encryptedData 已加密数据 
     * @param privateKey 私钥(BASE64编码) 
     * @return 
     * @throws Exception 
     */  
    public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey)  
            throws Exception {  
        byte[] keyBytes = Base64Utils.decode(privateKey);  
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);  
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);  
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  
        cipher.init(Cipher.DECRYPT_MODE, privateK);  
        int inputLen = encryptedData.length;  
        ByteArrayOutputStream out = new ByteArrayOutputStream();  
        int offSet = 0;  
        byte[] cache;  
        int i = 0;  
        // 对数据分段解密  
        while (inputLen - offSet > 0) {  
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {  
                cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);  
            } else {  
                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);  
            }  
            out.write(cache, 0, cache.length);  
            i++;  
            offSet = i * MAX_DECRYPT_BLOCK;  
        }  
        byte[] decryptedData = out.toByteArray();  
        out.close();  
        return decryptedData;  
    }  
  
    /** *//** 
     * <p> 
     * 公钥解密 
     * </p> 
     *  
     * @param encryptedData 已加密数据 
     * @param publicKey 公钥(BASE64编码) 
     * @return 
     * @throws Exception 
     */  
    public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey)  
            throws Exception {  
        byte[] keyBytes = Base64Utils.decode(publicKey);  
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);  
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
        Key publicK = keyFactory.generatePublic(x509KeySpec);  
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  
        cipher.init(Cipher.DECRYPT_MODE, publicK);  
        int inputLen = encryptedData.length;  
        ByteArrayOutputStream out = new ByteArrayOutputStream();  
        int offSet = 0;  
        byte[] cache;  
        int i = 0;  
        // 对数据分段解密  
        while (inputLen - offSet > 0) {  
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {  
                cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);  
            } else {  
                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);  
            }  
            out.write(cache, 0, cache.length);  
            i++;  
            offSet = i * MAX_DECRYPT_BLOCK;  
        }  
        byte[] decryptedData = out.toByteArray();  
        out.close();  
        return decryptedData;  
    }  
    public static void testPadding() throws Exception {
        SecureRandom random = SecureRandom.getInstance("SHA1PRNG");

        KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
        keyGen.initialize(1024, random);
        KeyPair keyPair = keyGen.generateKeyPair();

        /* constant 117 is a public key size - 11 */
        byte[] plaintext = new byte[117];
        random.nextBytes(plaintext);

        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, keyPair.getPublic());
        byte[] ciphertext = cipher.doFinal(plaintext);
        System.out.println(plaintext.length + " becomes " + ciphertext.length);
    }
    public static void main(String[] args) {
    	try {
			testPadding();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
  
    /** *//** 
     * <p> 
     * 公钥加密 
     * </p> 
     *  
     * @param data 源数据 
     * @param publicKey 公钥(BASE64编码) 
     * @return 
     * @throws Exception 
     */  
    public static byte[] encryptByPublicKey(byte[] data, String publicKey)  
            throws Exception {  
        byte[] keyBytes = Base64Utils.decode(publicKey);  
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);  
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
        Key publicK = keyFactory.generatePublic(x509KeySpec);  
        // 对数据加密  
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  
        cipher.init(Cipher.ENCRYPT_MODE, publicK);  
        int inputLen = data.length;  
        ByteArrayOutputStream out = new ByteArrayOutputStream();  
        int offSet = 0;  
        byte[] cache;  
        int i = 0;  
        // 对数据分段加密  
        while (inputLen - offSet > 0) {  
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {  
                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);  
            } else {  
                cache = cipher.doFinal(data, offSet, inputLen - offSet);  
            }  
            out.write(cache, 0, cache.length);  
            i++;  
            offSet = i * MAX_ENCRYPT_BLOCK;  
        }  
        byte[] encryptedData = out.toByteArray();  
        out.close();  
        return encryptedData;  
    }  
  
    /** *//** 
     * <p> 
     * 私钥加密 
     * </p> 
     *  
     * @param data 源数据 
     * @param privateKey 私钥(BASE64编码) 
     * @return 
     * @throws Exception 
     */  
    public static byte[] encryptByPrivateKey(byte[] data, String privateKey)  
            throws Exception {  
        byte[] keyBytes = Base64Utils.decode(privateKey);  
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);  
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);  
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  
        cipher.init(Cipher.ENCRYPT_MODE, privateK);  
        int inputLen = data.length;  
        ByteArrayOutputStream out = new ByteArrayOutputStream();  
        int offSet = 0;  
        byte[] cache;  
        int i = 0;  
        // 对数据分段加密  
        while (inputLen - offSet > 0) {  
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {  
                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);  
            } else {  
                cache = cipher.doFinal(data, offSet, inputLen - offSet);  
            }  
            out.write(cache, 0, cache.length);  
            i++;  
            offSet = i * MAX_ENCRYPT_BLOCK;  
        }  
        byte[] encryptedData = out.toByteArray();  
        out.close();  
        return encryptedData;  
    }  
  
    /** *//** 
     * <p> 
     * 获取私钥 
     * </p> 
     *  
     * @param keyMap 密钥对 
     * @return 
     * @throws Exception 
     */  
    public static String getPrivateKey(Map<String, Object> keyMap)  
            throws Exception {  
        Key key = (Key) keyMap.get(PRIVATE_KEY);  
        return Base64Utils.encode(key.getEncoded());  
    }  
  
    /** *//** 
     * <p> 
     * 获取公钥 
     * </p> 
     *  
     * @param keyMap 密钥对 
     * @return 
     * @throws Exception 
     */  
    public static String getPublicKey(Map<String, Object> keyMap)  
            throws Exception {  
        Key key = (Key) keyMap.get(PUBLIC_KEY);  
        return Base64Utils.encode(key.getEncoded());  
    }  
  
}

使用方式：

byte[] str = Base64Utils.decode(data);//需要BASE64字符串解码为二进制数据
String key = "";//公钥
byte[] decodedData;
decodedData = RSAUtils.decryptByPublicKey(str, key);
String target = new String(decodedData);





zhaoxiangchao
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RSA 公钥加密-私钥解密
06-14
RSA 公钥加密-私钥解密 博客地址 http://www.cnblogs.com/zyw-205520/p/5585043.html
RSA公钥加密与私钥解密算法
weixin_48526216的博客
11-14 5242
RSA公钥加密私钥解密算法
RSA加密解密算法原理以及实现_rsa简介及源码实现，2024年网络安全大厂面试分享
2401_84182842的博客
04-10 868
证明：p,2p,3p,…,(q−1)∗p有q−1个数整除pq，同理q,2q,3q,…,(p−1)∗q有p−1个数可以整除pq,再加上pq本身能整除pq,那么丢掉这些数剩余的数就与pq互质,一共有pq− (q−1+p−1+1) =(p−1)(q−1)。
使用RSA生成公钥和私钥
Domerobin的博客
04-19 7976
访问localhost:6080/generate/downloadAuthKeyZip可获取90天许可的证书。生成的authkey放到gateway下，生成的auth.jks放到auth认证服务下。网关结合鉴权，需要配置如下配置文件。接口AuthToolController。可以用keytool工具直接生成。认证服务配置Bean。
rsa public key not find
热门推荐
zhangguan96的博客
12-24 12万+
Navicat Premium 15 用注册机注册的时候 报错 rsa public key not find 第一步先不要打开 Navicat ，先打开注册机 第二步：点击path 找到你的Navicat启动的exe,安装路径的exe，选中Navicat.exe，点击打开。 第三步：稍等打开后，手动打开 Navicat 软件，进入激活界面后，点击注册机的Generate 第四步： 点击手动注册，然后先点击Copy 再点击 paste ，将那一串代码，输入到 DeFconX 下 第五步点击最后一
RSA加密、解密、签名、验签的原理及方法
PlutoZuo的博客
11-30 1108
RSA加密、解密、签名、验签的原理及方法
RSA加密、解密、签名、验签（验证签名）&RSA算法原理
Rssqzqyp的博客
11-13 2122
RSA加密是一种非对称加密。可在不直接传递密钥的情况下，完成解密；是由一对密钥来进行加密的过程，分别称为公钥和私钥。两者之间有数学相关，该加密算法的原理就是一对极大整数做因数分解的困难性来保证安全性。通常个人保存私钥，公钥是公开的（可能同时多人持有）。
C# .net版 RSA 公钥加密私钥解密 私钥加密公钥解密
02-15
亲测可用，可参考：https://blog.csdn.net/qq_37835111/article/details/87358779
Delphi RSA加解密【支持RSA公钥加密私钥解密，RSA私钥加密公钥解密，秘钥格式支持PKCS8和PKCS1】D7~XE10可用
02-26
【delphiRSA加解密】支持RSA公钥加密私钥解密，RSA私钥加密公钥解密，秘钥格式支持PKCS8和PKCS1，D7~XE10可用
C#RSA私钥加密公钥解密
08-25
利用System.Numerics.BigInteger实现，私钥加密，公钥解密。兼容PKCS1填充方式。有效文件只有MyRSA.cs一个，其它文件是因为带了一个演示窗口。
Go-gorsa支持rsa公钥加密私钥解密；支持rsa公钥解密私钥加密
08-14
gorsa 支持rsa公钥加密私钥解密；支持rsa公钥解密私钥加密
支持rsa公钥加密私钥解密；支持rsa公钥解密私钥加密
最新发布
05-13
支持rsa公钥加密私钥解密；支持rsa公钥解密私钥加密。
RSA基本介绍、加解密、加验签
SA的博客
11-17 1238
比如A和B都有一套自己的公钥和秘钥，当 A 要给B发送消息时，先用 B 的 公钥对消息加密，再用A的私钥对消息签名。这个过程中也有2次传递，第一次A将私钥加密的信息传递给B，第二次 B 获取 A 的公钥，即使被恶意截获，也没有危险，即使知道了消息的内容，也无法伪造带签名的信息回复给B，因为只有A的私钥才能对信息进行签名，防止了信息被恶意篡改。这个过程，有两次传递，一次是A将公钥传给B，第二次是B将公钥加密后的信息传给A，即使两次均被恶意获取，也没有关系，只有A手中的私钥，可以解密出准确的信息。
RSA加密解密（附源码工程）
小宝鸽
12-25 1万+
一、RSA加密介绍RSA公钥加密算法是1977年由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）一起提出的。1987年首次公布，当时他们三人都在麻省理工学院工作。RSA就是他们三人姓氏开头字母拼在一起组成的。RSA是目前最有影响力的公钥加密算法，它能够抵抗到目前为止已知的绝大多数密码攻击，已被ISO推荐为公钥数据加密标
RSA加密解密算法工具_JAVA
HelloWorld, GraspWorld!
04-03 524
这个版本绝对能用，本人亲测 注意：需要下载两个jar包 【commons-codec-1.11-bin.zip】下载地址如下： http://commons.apache.org/proper/commons-codec/download_codec.cgi 【commons-io-2.6-bin.zip】下载地址如下： http://commons.apache.org/proper/...
Error: Permission denied (publickey) 的解决方法
La La Land
11-22 1201
这一切都是源于智障的我在 创建SSH Key： $ ssh-keygen -t rsa -C "youremail@example.com" 你需要把邮件地址换成你自己的邮件地址，然后一路回车，使用默认值即可，由于这个Key也不是用于军事目的，所以也无需设置密码。 并没有一路回车，而是设置了一个文件名，让ssh储存在这个文件里。然后主目录下的.ssh文件夹里面没有id_rsa.pub和id_rsa...
RSA非对称加解密算法的使用
不落航班
12-19 1085
加密密钥和解密密钥相同时则称为对称加密。由于加密密钥和解密密钥相同，它们也被称为Shared Key。如AES等。 加密密钥（公钥）和解密密钥（私钥）不相同时则称为非对称加密，别称公钥密码。如RSA等。 非对称加密例子： 假设张三拥有的公钥Pu和私钥Pr，其公钥是公开的，谁想跟张三通信的话必须用张三的公钥Pu进行加密后传输给张三，张三用自己的私钥Pr解密后就能查看通信内容了。 RSA：建立
Permission denied (publickey)
日渐机智的博客
08-05 4827
git clone Permission denied
JS RSA 公钥解密
08-06
在 JavaScript 中使用 RSA 公钥进行解密需要使用一个加密库，例如 Node.js 的 `crypto` 模块或者前端浏览器中的 `jsencrypt` 库。以下是使用 `jsencrypt` 库进行 RSA 公钥解密的示例代码： 首先，确保你已经引入了 `jsencrypt` 库。你可以从官方网站下载该库，或者通过 CDN 引入： ```html <script src="https://cdnjs.cloudflare.com/ajax/libs/jsencrypt/3.0.0/jsencrypt.min.js"></script> ``` 然后，使用以下代码进行 RSA 公钥解密： ```javascript // 创建一个 JSEncrypt 实例 var encrypt = new JSEncrypt(); // 设置 RSA 公钥 var publicKey = 'YOUR_PUBLIC_KEY'; encrypt.setPublicKey(publicKey); // 要解密的密文 var encryptedData = 'YOUR_ENCRYPTED_DATA'; // 使用公钥进行解密 var decryptedData = encrypt.decrypt(encryptedData); // 输出解密后的明文 console.log(decryptedData); ``` 确保将 `YOUR_PUBLIC_KEY` 替换为你的 RSA 公钥，`YOUR_ENCRYPTED_DATA` 替换为要解密的密文。 请注意，这只能用于使用公钥加密的数据进行解密，如果需要对使用私钥加密的数据进行解密，则需要使用相应的 RSA 私钥解密方法。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值