RSA加密解密工具类（多种加密填充方式）

已于 2023-01-11 09:48:07 修改
阅读量408 收藏 2
点赞数
文章标签： java 网络 服务器
于 2022-12-27 19:43:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46379892/article/details/128460529
版权

RSA加密解密工具类

import org.bouncycastle.jce.provider.BouncyCastleProvider;

import javax.crypto.Cipher;
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.Base64;
import java.util.HashMap;
import java.util.Map;

/**
 * RSA加密工具类
 *
 * @author ACGkaka
 * @since 2021-09-19 19:11:03
 */
public class RSAUtil {

    /**
     * 密钥类实例化入参
     */
    private static final String KEY_ALGORITHM = "RSA";
    /**
     * Cipher类实例化入参
     */
    private static final String CIPHER_ALGORITHM = "RSA/ECB/PKCS1Padding";
    /**
     * 密钥对中公钥映射key
     */
    private static final String PUBLIC_KEY = "RSAPublicKey";
    /**
     * 密钥对中私钥映射key
     */
    private static final String PRIVATE_KEY = "RSAPrivateKey";
    /**
     * 签名类实例化入参
     */
    private static final String SIGNATURE_ALGORITHM = "MD5withRSA";
    /**
     * RSA最大加密明文大小
     */
    private static final int MAX_ENCRYPT_BLOCK = 117;

    /**
     * 初始化密钥对生成器时，指定密钥大小的整数值（安全漏洞，长度至少为2048）
     */
    private static final int KEY_PAIR_INIT_SIZE = 2048;

    /**
     * RSA最大解密密文大小，
     * RSA 位数 如果采用1024 上面最大加密和最大解密则须填写: 117 128
     * RSA 位数 如果采用2048 上面最大加密和最大解密则须填写: 245 256
     */
    private static final int MAX_DECRYPT_BLOCK = 256;

    private static final char[] HEX_CHAR = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};

    /**
     * 获取公钥字符串
     *
     * @param keyMap 密钥对
     * @return 公钥字符串
     * @throws Exception 异常
     */
    public static String getPublicKeyStr(Map<String, Object> keyMap) throws Exception {
        //获得map中的公钥对象 转为key对象
        Key key = (Key) keyMap.get(PUBLIC_KEY);
        //编码返回字符串
        return encryptBASE64(key.getEncoded());
    }

    /**
     * 获取私钥字符串
     *
     * @param keyMap 密钥对
     * @return 私钥字符串
     * @throws Exception 异常
     */
    public static String getPrivateKeyStr(Map<String, Object> keyMap) throws Exception {
        //获得map中的私钥对象 转为key对象
        Key key = (Key) keyMap.get(PRIVATE_KEY);
        //编码返回字符串
        return encryptBASE64(key.getEncoded());
    }


    /**
     * 获取公钥
     *
     * @param key 公钥字符串
     * @return 公钥
     * @throws Exception 异常
     */
    public static PublicKey getPublicKey(String key) throws Exception {
        byte[] keyBytes;
        keyBytes = decryptBASE64(key);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        PublicKey publicKey = keyFactory.generatePublic(keySpec);
        return publicKey;
    }

    /**
     * 获取私钥
     *
     * @param key 私钥字符串
     * @return 私钥
     * @throws Exception 异常
     */
    public static PrivateKey getPrivateKey(String key) throws Exception {
        byte[] keyBytes;
        keyBytes = decryptBASE64(key);
        // 修复异常：java.security.InvalidKeyException: IOException : algid parse error, not a sequence
        Security.addProvider(new BouncyCastleProvider());
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
        return privateKey;
    }

    /**
     * Base64解码，返回byte[]
     *
     * @param key 待解码字符串
     * @return 解码后的byte[]
     */
    public static byte[] decryptBASE64(String key) {
        return Base64.getMimeDecoder().decode(key);
    }

    /**
     * 将byte[]进行Base64编码
     *
     * @param key 待编码的byte[]
     * @return 编码后的字符串
     */
    public static String encryptBASE64(byte[] key) {
        return Base64.getMimeEncoder().encodeToString(key);
    }

    /**
     * 生成签名
     *
     * @param data          待生成签名内容
     * @param privateKeyStr 私钥
     * @return 签名信息
     * @throws Exception 异常
     */
    public static String sign(byte[] data, String privateKeyStr) throws Exception {
        PrivateKey priK = getPrivateKey(new String(hexToBytes(privateKeyStr)));
        Signature sig = Signature.getInstance(SIGNATURE_ALGORITHM);
        sig.initSign(priK);
        sig.update(data);
        return bytesToHex(sig.sign());
    }

    /**
     * 验证签名
     *
     * @param data         待验证原文
     * @param sign         待验证签名
     * @param publicKeyStr 公钥
     * @return 是否验证成功
     * @throws Exception 异常
     */
    public static boolean verify(byte[] data, String sign, String publicKeyStr) throws Exception {
        PublicKey pubK = getPublicKey(new String(hexToBytes(publicKeyStr)));
        Signature sig = Signature.getInstance(SIGNATURE_ALGORITHM);
        sig.initVerify(pubK);
        sig.update(data);
        return sig.verify(hexToBytes(sign));
    }

    /**
     * RSA加密
     * @param plainText 待加密内容
     * @param publicKeyStr 公钥字符串
     * @return 加密后内容
     * @throws Exception 异常
     */
    public static String encrypt(byte[] plainText, String publicKeyStr) throws Exception {
        PublicKey publicKey = getPublicKey(publicKeyStr);
        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        int inputLen = plainText.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        int i = 0;
        byte[] cache;
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                cache = cipher.doFinal(plainText, offSet, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(plainText, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptText = out.toByteArray();
        out.close();
        return bytesToHex(encryptText);
    }

    /**
     * RSA解密
     * @param encryptTextHex 已加密内容
     * @param privateKeyStr 私钥字符串
     * @return 解密后内容
     * @throws Exception 异常
     */
    public static String decrypt(String encryptTextHex, String privateKeyStr) throws Exception {
        byte[] encryptText = hexToBytes(encryptTextHex);
        PrivateKey privateKey = getPrivateKey(privateKeyStr);
        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        int inputLen = encryptText.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(encryptText, offSet, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(encryptText, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
        byte[] plainText = out.toByteArray();
        out.close();
        return new String(plainText);
    }

    public static Map<String, Object> initKey() throws Exception {
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        keyPairGen.initialize(KEY_PAIR_INIT_SIZE);
        KeyPair keyPair = keyPairGen.generateKeyPair();
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        Map<String, Object> keyMap = new HashMap<>(2);
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
        return keyMap;
    }

    /**
     * 将byte[]转换为16进制字符串
     *
     * @param bytes 待转换byte[]
     * @return 转换后的字符串
     */
    public static String bytesToHex(byte[] bytes) {
        //一个byte为8位，可用两个十六进制位标识
        char[] buf = new char[bytes.length * 2];
        int a = 0;
        int index = 0;
        for (byte b : bytes) { // 使用除与取余进行转换
            if (b < 0) {
                a = 256 + b;
            } else {
                a = b;
            }

            buf[index++] = HEX_CHAR[a / 16];
            buf[index++] = HEX_CHAR[a % 16];
        }
        return new String(buf);
    }

    /**
     * 将16进制字符串转换为byte[]
     *
     * @param str 待转换字符串
     * @return 转换后的byte[]
     */
    public static byte[] hexToBytes(String str) {
        if (str == null || "".equals(str.trim())) {
            return new byte[0];
        }

        byte[] bytes = new byte[str.length() / 2];
        for (int i = 0; i < str.length() / 2; i++) {
            String subStr = str.substring(i * 2, i * 2 + 2);
            bytes[i] = (byte) Integer.parseInt(subStr, 16);
        }

        return bytes;
    }

    public static void main(String[] args) throws Exception {
        // 初始化密钥对
        Map<String, Object> keyMap = initKey();
        // 获取公钥字符串
        String publicKey = getPublicKeyStr(keyMap);
        // 获取私钥字符串
        String privateKey = getPrivateKeyStr(keyMap);

        // 打印公钥、私钥
        System.out.println("公钥：（填充方式：PKCS1_PADDING，输出类型：base64，字符集：utf8编码）");
        System.out.println("-----BEGIN PUBLIC KEY-----");
        System.out.println(publicKey);
        System.out.println("-----END PUBLIC KEY-----");
        System.out.println("\n");

        System.out.println("私钥：（填充方式：PKCS1_PADDING，输出类型：base64，字符集：utf8编码）");
        System.out.println("-----BEGIN RSA PRIVATE KEY-----");
        System.out.println(privateKey);
        System.out.println("-----END RSA PRIVATE KEY-----");
        System.out.println("\n");

        // 待加密内容，例：123
        String s = "123";
        // 进行RSA加密
        String encrypt = encrypt(s.getBytes(), publicKey);
        // 打印加密后内容
        System.out.println("密文：（填充方式：PKCS1_PADDING，输出类型：hex，字符集：utf8编码）");
        System.out.println(encrypt);
        System.out.println("\n");

        // 进行RSA解密
        String decrypt = decrypt(encrypt, privateKey);
        // 打印解密后内容
        System.out.println("解密后明文: ");
        System.out.println(decrypt);
    }
}

参考大佬的Java实现加密（二）RSA加解密

上班不绝对摸鱼
关注
python rsa加密解密_RSA加密解密（python版）
weixin_39811842的博客
12-09 1520
RSA的算法涉及三个参数，n、e、d。其中，n是两个大质数p、q的积，n的二进制表示时所占用的位数，就是所谓的密钥长度。e1和d是一对相关的值，e可以任意取，但要求e与(p-1)*(q-1)互质；再选择d，要求(d*e1)mod((p-1)*(q-1))=1。(n，e),(n，d)就是密钥对。其中(n，e)为公钥，(n，d)为私钥。[1]RSA加解密的算法完全相同，设A为明文，B为密文，则：A=B...
RSA加密工具类
11-06
RSA非对称加密是可逆的，有的时候数据出现问题，需要解密进行排解问题
RSA公私钥加密工具类
tjd5214的博客
08-26 520
import org.apache.commons.codec.binary.Base64; import javax.crypto.Cipher; import java.nio.charset.StandardCharsets; import java.security.*; import java.security.interfaces.RSAPrivateKey; import java.security.interfaces.RSAPublicKey; import java.security..
推荐文章：RSA加密解密利器——Objective-C中的RSA插件
最新发布
gitblog_00713的博客
08-29 955
推荐文章：RSA加密解密利器——Objective-C中的RSA插件 RSA-objcExample for RSA encryption & decryption on iOS项目地址:https://gitcode.com/gh_mirrors/rs/RSA-objc 在iOS开发领域，安全性始终是绕不开的话题。今天，我们来探讨一个尽管已年代久远但仍对老项目保持价值的工具——专为Object...
RAS生成非对称加密公私钥Base64转换显示
小屁孩的博客
01-02 969
测试main方法 package RSA; import java.security.KeyPair; import java.security.PrivateKey; import java.security.PublicKey; /** *功能描述 * @author kangjinfan * @date 2020/1/2 */ public class Base64Main {...
RSA加密算法工具类
二掌柜的博客
07-01 1295
RSA加密是一种非对称加密算法，由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）在1977年首次公开提出。RSA是他们三人姓氏的首字母组成的。RSA算法基于一个数学上的事实：将两个大质数相乘很容易，但是想要将其乘积分解成原始的质数因子却非常困难。这就是所谓的“陷门函数TDF”的概念，是RSA加密安全性的基础。
unity工具类RSA加密和解密
11-04
文件可能定义了一个名为UEncrypt的工具类，其中包含用于加密和解密的方法。这些方法可能接收字节数组或字符串作为输入，处理加密和解密的过程，并返回结果。 在实际应用中，注意以下几点： - 避免明文存储私钥，...
C#RSA加密解密汇总
09-17
总结来说，C#中的RSA加密解密是通过`RSACryptoServiceProvider`类实现的，它支持创建密钥对、加密和解密数据，以及密钥的存储和加载。在实际开发中，确保正确管理和保护私钥至关重要，因为它们是保障数据安全的关键...
Delphi(delphi7-XE)标准RSA加密,解密,签名.与C,Java,php等通用
04-04
在Delphi（包括Delphi 7到XE版本）中实现RSA加密、解密和签名，你需要理解以下几个关键概念： 1. **密钥对生成**：RSA的核心是密钥对，包括一个公钥和一个私钥。公钥可以公开，用于加密信息；私钥必须保密，用于...
java 在线rsa解密_通用的Java RSA加密工具类，可在线验证通过
weixin_33344952的博客
02-24 2358
/*** RSA加密工具类* 使用PKCS1_PADDING填充，密钥长度1024* 加解密结果在这里测试通过：http://tool.chacuo.net/cryptrsaprikey* 注意加密内容的编码要一致，统一UTF-8比较好* @author daxi*/public class RSAUtil {public static final String KEY_ALGORTHM="RSA...
RSA加解密工具
08-09
RSA工具（来源于网络），此工具用着比较顺手，详细情况及使用请看：http://blog.csdn.net/yxstars/article/details/38443937
RSA加密用工具类
03-29
RSA非对称加密，所需要的工具类。简单实用。静态代码块生成公钥私钥对
C# RSA加密解密实战指南
总结，C#中的RSA加密解密涉及到生成密钥对、存储和管理证书以及使用RSACryptoServiceProvider类进行加解密操作。理解这些概念和步骤对于实现安全的通信至关重要。在实际应用中，还需要考虑密钥的安全存储、证书的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

上班不绝对摸鱼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值