RSA公钥加密私钥解

已于 2022-05-18 17:55:10 修改
阅读量1.1k 收藏
点赞数
文章标签： java
于 2022-01-26 14:22:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39643007/article/details/122700887
版权

1.工具类如下：

package Cloud.Base.Security;


import com.alibaba.fastjson.JSON;

import java.io.ByteArrayOutputStream;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.*;

import javax.crypto.Cipher;

public class RSACrypt {
    /** */
    /**
     * 加密算法RSA
     */
    public static final String KEY_ALGORITHM = "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 = Base64.getDecoder().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 Base64.getEncoder().encodeToString(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 = Base64.getDecoder().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(Base64.getDecoder().decode(sign));
    }

    /** */
    /**
     * <P>
     * 私钥解密
     * </p>
     *
     * @param encryptedData 已加密数据
     * @param privateKey    私钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey) throws Exception {
        byte[] keyBytes = Base64.getDecoder().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 = Base64.getDecoder().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;
    }

    /** */
    /**
     * <p>
     * 公钥加密
     * </p>
     *
     * @param data      源数据
     * @param publicKey 公钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPublicKey(byte[] data, String publicKey) throws Exception {
        byte[] keyBytes = Base64.getDecoder().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 = Base64.getDecoder().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 Base64.getEncoder().encodeToString(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 Base64.getEncoder().encodeToString(key.getEncoded());
    }

  

}

2.写过main方法测试：

public static void main(String[] args) throws Exception  {
    String PublicKey="MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCbT0lJ6dipiuhhCJM2e/8AD7v3bjYfBn3zyM82EqEkQYWPNqfTYbzq1vwQqo4Q/lCs2/YlQV7tg6Fpy5d0StUQpFkni2ArXe9iEf3qd8KFE0nOQc1WNCSruaPvdHoMACQjkzz1i98/pqXw5oAhIDYkbyRnoKpTySfC3jVzOhjnuQIDAQAB";
    String PrivateKey="MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAJtPSUnp2KmK6GEIkzZ7/wAPu/duNh8GffPIzzYSoSRBhY82p9NhvOrW/BCqjhD+UKzb9iVBXu2DoWnLl3RK1RCkWSeLYCtd72IR/ep3woUTSc5BzVY0JKu5o+90egwAJCOTPPWL3z+mpfDmgCEgNiRvJGegqlPJJ8LeNXM6GOe5AgMBAAECgYA4p6ShjOeXeW+prfodvv/XouW7rf2aNcEOhCtqm0MjOa+h/ZsdFiNXO5N59O2cL1l4pUjWcFFTrVfdgwI9zuqH9AVDVQsoCTH7RaHXzGyIS9FRsWKi/VxhMwNsK8z8FD7PbrgqthXUvRitsv54xufI+Dw4mprL91tW59ufGo6o7QJBAOGemI+McoXRvAInCYC2JPrHkspPUSncZdCK6QHjoIAErxKU3jkAqbPU8DebrH6egTysvVD8LUQTFUNi5a8DNYMCQQCwOQSkRZo8jCbim1uy+RfNGyDvY1S4OML9BNwYLUnaXJolk8ioqwybPZioKnUQ84EPLpgx5YbnAO3ysCBnYCUTAkEAw2PJ02daNrHwFB0iiak0VUpIwZP3Qj1wny3tpIkxEiz8QSdTXCJK1UZv0niq5ez3F0ixm1UJDo9INteK+gnZaQJAGN9TWmRAir81VdKbtL0XsOldUqxwbrgEPXYMIpVx0RI054zeS4Ao/VhKTaIAd+4Gj0ACVziQO9aTvydAy5Z0ZQJBAIOCoagMq749e4ZdjttcBclYUd/9IERqR8x7opjg2QIKKpgsxqA8zZLJfaYegABac5kY8ewNpxzg0KIZy2iSE1A=";
    Map<String,Object> resMap = new HashMap<>();
    resMap.put("Expression","{ \"Sendtype\": 3}");
    resMap.put("uuid","27f6a7f091a74216b30035e7cfea8d30");
    resMap.put("date","20211115120102");
    resMap.put("carMob","13396022147");
    resMap.put("resultCode","01");
    resMap.put("carNum","鄂A12345");
    resMap.put("callTimes","3");
    resMap.put("callFlag","1");
    resMap.put("resultDesc","结果说明");
    resMap.put("userid","esds");
    resMap.put("Sendtype",1);


    String originData = JSON.toJSONString(resMap);
    byte[] res = RSACrypt.encryptByPublicKey(originData.getBytes("UTF-8"), PublicKey);
    String resString = Base64.getEncoder().encodeToString(res);
    System.out.println("加密后的数据是:");
    System.out.println(resString);

    byte[] res2 = decryptByPrivateKey(Base64.getDecoder().decode(new String(resString.getBytes(),"UTF-8")), PrivateKey);
    String res2String = new String(res2);
    System.out.println("解密密后的数据是:");
    System.out.println(res2String);
}

3.测试结果如下：

浅唱~幸福
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C# .net版 RSA 公钥加密私钥解密 私钥加密公钥解密
02-15
亲测可用，可参考：https://blog.csdn.net/qq_37835111/article/details/87358779
RSA加密、解密、签名、验签方法
qq_38028454的博客
03-09 2260
1. RSAEncrypt.java package com.abc.util; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.security.InvalidKeyException; import java.security.KeyFacto
Rsa 加密的使用
紫青宝剑的博客
12-03 3811
RSA 非对称加密，更好的实现前后端信息的安全传送
深入解析RSA算法原理及其安全性机制
最新发布
码到三十五
03-28 2012
RSA算法是一种广泛使用的公钥加密算法，它的安全性基于大数分解和离散对数等数学难题。该算法利用一对密钥（公钥和私钥）进行加密和解密操作，其中公钥可以公开分发，用于加密信息，而私钥必须保密，用于解密信息。RSA算法的核心思想在于通过一系列数学运算，将明文转换为密文，并且只有持有相应私钥的人才能解密出原始明文。
java 私钥签名公钥认证
zhao_963084302的博客
09-09 1778
  Java实现私钥签名公钥认证demo package com.ibs.clearing.sign.demo; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.FileReader; import java.io.FileWriter; import java.io.IO...
RSA 加密和解密介绍
KevinSwift的博客
02-24 4821
RSA加密和解密的一些简单介绍和实现
RSA
f543711700的专栏
10-21 189
[code="java"]package com.ghca.roam.sync; import java.io.ByteArrayOutputStream; import java.security.Key; import java.security.KeyFactory; import java.security.KeyPair; import java.security.KeyP...
Windows版 生成RSA公钥和私钥的工具
05-15
生成RSA公钥和私钥的工具：Windows版OpenSSL 亲测可用。提供32位系统和64位系统版本
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一个，其它文件是因为带了一个演示窗口。
rsa.zip_RSA 公钥加密_rsa_rsa私钥加密
09-21
rsa加密算法的加解密过程，利用公钥与私钥
RSA简单加密与解密
算法小生
11-13 644
RSA简单加密与解密。
RSA双向加解密（公钥加密-私钥解密；私钥加密-公钥解密）
qq_42014561的博客
12-20 8568
RSA私钥加密-公钥解密
RSA 加密解密
qq_30436011的博客
08-03 1117
RSA是一种块加密的算法，所以对于明文需要将他们分成固定的块长度，考虑到输入的数据长度的问题，所以加解密的填充有好几种： 无填充，就是直接对明文进行加密 PKCS1。将数据长度分成密钥长度-11byte，比如密钥是1024bit，那么长度就是1024/8-11=117bytes，具体的格式：先填0，2，然后随机生成其他的byte，后面才是真正的数据 PKCS1_OAEP将数据长度分成密钥长度-41byte，比如密钥是1024bit，那么长度就是1024/8-41=77bytes，.
RSA加密与解密原理
Alphamilk的博客
10-15 5462
一、什么是RSA加密 二、RSA加密原理 三、RSA加解密过程与算法代码
RSA加密算法解析
paycho的博客
06-05 2869
个人理解，n是两边都有的，具体加密中的p，q不知道，一个很大的数，想确定一对p*q=n很难（就算是质数也很难，因为数量真的很多） 用e加密，e是随机取的，用d解密 d是根据e和φ(n)算出来的 ,φ(n)是通过p和q算出来的 所以想破解d是很难的，关于怎么加密解密的过程， 注意点：M=C^d mod n 与C= M^e mod n的代换、ed的产生、1的n次幂还是1、以及欧拉定理 a^φ(n)=1 (mod n) 的同乘M。这样，一个具体用户就可以将自己设计的加密密钥和算法公诸于众，而只保密解密密钥。
带密钥的消息摘要算法——数据签名算法
chiqiao5151的博客
04-19 838
数字签名算法可以看做是一种带有密钥（公钥+私钥）的消息摘要算法，也就是说，数据签名算法是非对称加密算法和消息摘要算法的结合体。该算法包含签名和验证两项操作，遵循 “私钥签名，公钥验证” 的签名/验证方式。 数字签名算法消息传递模型 1、甲方构建密钥对，并能公布公钥给乙方。 2、甲...
RSA加密、解密、签名、验签的原理及方法
weixin_42900551的博客
08-23 1101
一、RSA加密简介 RSA加密是一种非对称加密。可以在不直接传递密钥的情况下，完成解密。这能够确保信息的安全性，避免了直接传递密钥所造成的被破解的风险。是由一对密钥来进行加解密的过程，分别称为公钥和私钥。两者之间有数学相关，该加密算法的原理就是对一极大整数做因数分解的困难性来保证安全性。通常个人保存私钥，公钥是公开的（可能同时多人持有）。 二、RSA加密、签名区别 加密和签名都是为了安全性考虑，...
rsa加密解密，使用rsa对密码加密
wangwei的博客
05-12 631
rsa加密解密
rsa加密公钥私钥软件
07-28
RSA加密是一种常见的非对称加密算法，它使用公钥和私钥进行加密和解密操作。公钥用于加密数据，而私钥则用于解密被加密的数据。 在软件开发领域，有许多可以生成RSA密钥对以及执行加密和解密操作的软件。其中一些...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值