RSA-Java加解密

最新推荐文章于 2024-04-27 09:13:51 发布
最新推荐文章于 2024-04-27 09:13:51 发布
阅读量3.8k 收藏 16
点赞数 1
分类专栏： JAVA 文章标签： java 安全 开发语言 rsa
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34890544/article/details/122394379
版权

文章目录

背景介绍

项目中最近使用RSA算法对敏感数据进行加解密,因此在结合网上相关文章后进行整理。
RSA算法是一种非对称加密算法,会生成一对RSA秘钥,即公钥+私钥,将公钥提供给调用方，调用方使用公钥对数据进行加密后,接口根据私钥进行解密

JAVA RSA加解密工具类

基础工具类


import java.io.ByteArrayOutputStream;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

import javax.crypto.Cipher;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

/**
 * Title:RSAUtil
 * Description:
 * Company:
 *
 * @version 1.0
 * @Create zhoujt
 * @Author 2022-01-09 15-22
 **/
public class RSAUtil {

    public static final String KEY_ALGORITHM = "RSA";

    private static final String PUBLIC_KEY = "RSAPublicKey";

    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;

    /**
     * 生成密钥对
     */
    public static Map<String, Object> initKey() throws Exception {
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        //设置密钥对的bit数 越大越安全
        keyPairGen.initialize(1024);
        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;
    }

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

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


    /**
     * 获取公钥
     */
    public static PublicKey getPublicKey(String publicKeyString) throws NoSuchAlgorithmException, InvalidKeySpecException {
        byte[] publicKeyByte = Base64.getDecoder().decode(publicKeyString);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKeyByte);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        PublicKey publicKey = keyFactory.generatePublic(keySpec);
        return publicKey;
    }

    /**
     * 获取私钥
     */
    public static PrivateKey getPrivateKey(String privateKeyString) throws Exception {
        byte[] privateKeyByte = Base64.getDecoder().decode(privateKeyString);
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKeyByte);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
        return privateKey;
    }


    /**
     * BASE64解码 返回字节数组
     * key 需要解码的字符串
     */
    public static byte[] decryptBASE64(String key) {
        return Base64.getDecoder().decode(key);
    }

    /**
     * BASE64编码返回加密字符串
     * key 需要编码的字节数组
     */
    public static String encryptBASE64(byte[] key) throws Exception {
        return new String(Base64.getEncoder().encode(key));
    }


    /**
     * 公钥加密
     */

    public static String encrypto(String text, String publicKeyStr) {

        try {

            System.out.println("明文lenth为"+text.length());
            Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
            cipher.init(Cipher.ENCRYPT_MODE, getPublicKey(publicKeyStr));
            byte tempBytes[] = cipher.doFinal(text.getBytes());
            String secretText = Base64.getEncoder().encodeToString(tempBytes);
            return secretText;
        } catch (Exception e) {
            throw new RuntimeException("加密字符串[" + text + "]时遇到异常", e);
        }

    }

    /**
     * 私钥解密
     *
     * @param secretText
     */

    public static String decrypto(String secretText, String privateKeyStr) {

        try {
            //生成公钥
            Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
            cipher.init(Cipher.DECRYPT_MODE, getPrivateKey(privateKeyStr));
            // 密文解码
            byte[] secretText_decode = Base64.getDecoder().decode(secretText.getBytes());
            byte tempBytes[] = cipher.doFinal(secretText_decode);
            String text = new String(tempBytes);
            return text;
        } catch (Exception e) {
            throw new RuntimeException("解密字符串[" + secretText + "]时遇到异常", e);
        }

    }

    public static void main(String[] args) throws Exception {
        Map<String, Object> keyMap;
        String cipherText;
        String input = "数字测试就是多久覅偶按实际说就大佛我按时间覅哦啊师傅欧艾斯师傅到了独爱偶素大放";
        try {
            keyMap = initKey();
            String publicKey = getPublicKeyStr(keyMap);
            System.out.println("公钥------------------");
            System.out.println(publicKey);
            System.out.println("length: " + publicKey.length());

            String privateKey = getPrivateKeyStr(keyMap);
            System.out.println("私钥------------------");
            System.out.println(privateKey);
            System.out.println("length: " + privateKey.length())
            cipherText = encrypto(input, publicKey);
            //加密后的东西
            System.out.println("密文=======" + cipherText);
            System.out.println("length: " + cipherText.length());
            //开始解密
            String plainText = decrypto(cipherText, privateKey);
            System.out.println("解密后明文===== " + plainText);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行结果截图
如果所示, 生成一对1024bit 的rsa密钥对,并加解密成功。

问题记录 — 报文长度过长加解密失败

测试发现当明文过长时,加密异常, 返回如下报错
在这里插入图片描述

原因

RSA 加解密时,对加密的数据大小有限制,最大不大于秘钥长度。
在使用1024位的密钥时,最大可以加密 1024/8 = 128字节的数据,此时需要对数据进行分组加密,分组加密后的加密串拼接成一个字符串返回给客户端。如果Padding方式使用默认的OPENSSL_PKCS1_PADDING(需要占用11字节用于填充),则明文长度最多为 128 - 11 = 117 Bytes
同理当解密的密文超过128Byte时 也需要进行分组解密

分段加解密code

 /**
     * 分段加密
     */
    public static String encrypt(String plainText, String publicKeyStr) throws Exception {
        System.out.println("明文lenth为"+plainText.length());
        byte[] plainTextArray = plainText.getBytes();
        PublicKey publicKey = getPublicKey(publicKeyStr);
        Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        int inputLen = plainTextArray.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(plainTextArray, offSet, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(plainTextArray, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptText = out.toByteArray();
        out.close();
        return Base64.getEncoder().encodeToString(encryptText);
    }

    /**
     * 分段解密
     */
    public static String decrypt(String encryptTextHex, String privateKeyStr) throws Exception {
        byte[] encryptText = Base64.getDecoder().decode(encryptTextHex);
        PrivateKey privateKey = getPrivateKey(privateKeyStr);
        Cipher cipher = Cipher.getInstance(KEY_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);
    }

问题记录二 – 当密钥对改为2048 bit

如上文提到, 当密钥对改为2048位时, 最大加密明文大小 = 2048(bit) / 8 - 11(byte) = 245 byte

  /**
     * RSA最大加密明文大小
     */
    private static final int MAX_ENCRYPT_BLOCK = 245;

    /**
     * RSA最大解密密文大小
     */
    private static final int MAX_DECRYPT_BLOCK = 256;

    /**
     * 生成密钥对
     */
    public static Map<String, Object> initKey() throws Exception {
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        //设置密钥对的bit数 越大越安全
        keyPairGen.initialize(2048);
        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;
    }

备注

PKCS1 和 PKCS8 的区别

以-----BEGIN RSA PRIVATE KEY-----开头
以-----END RSA PRIVATE KEY-----结束
的就是PKCS#1格式

以-----BEGIN PRIVATE KEY-----开头
以-----END PRIVATE KEY-----结束
的就是PKCS#8格式

通常JAVA中需要PKCS8 格式的密钥

在线rsa加解密网站

rsa加解密

qq_34890544
关注
  • 1
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RSA sha-256加密解密，加签验签工具类
01-14
spring框架中关于RSA sha-256加密解密，加签验签工具类
JAVA实现RSA加解密算法
DevNinja的博客
08-13 762
它基于大数的因子分解难题，通过使用一对密钥来完成数学运算，实现信息的安全传输。本文将详细介绍如何使用Java语言实现RSA加解密算法，并提供相应的源代码。通过生成RSA密钥对，并分别使用公钥和私钥对数据进行加解密操作，保证了数据的安全传输和保密性。以上是对Java实现RSA加解密算法的一种简单示例，您可以根据实际需求进行扩展和优化。获取RSA算法的加密器，使用公钥对加密器进行初始化。获取RSA算法的解密器，使用私钥对解密器进行初始化。方法对加密后的数据进行解密处理，并输出解密后的数据。
RSA加密与解密(Java实现)
Mr朱鹏的博客
03-15 725
RSA加密与解密(Java实现)
java案例RSA分段加密解密，签名验签，公钥加密私钥解密，私钥加密公钥解密，解密乱码怎么解决
记录工作历程
10-12 1378
java案例RSA分段加密解密，签名验签，公钥加密私钥解密，私钥加密公钥解密，解密乱码怎么解决
RSA 加解密（Java 实现）
长安明月的博客
08-03 2万+
RSA 算法是一种非对称加解密算法。服务方生成一对 RSA 密钥，即公钥 + 私钥，将公钥提供给调用方，调用方使用公钥对数据进行加密后，服务方根据私钥进行解密。
从加密到签名：如何使用Java实现高效、安全的RSA加解密算法？
m0_63300795的博客
06-19 7982
我们为什么要使用RSA算法来进行加解密？RSA 加密算法是一种非对称加密算法，也是目前广泛使用的加密技术之一。RSA 算法的安全性基于大素数分解的困难性问题，其主要特点是安全性高、密钥管理简单等。RSA 算法采用非对称加密的方式，即加密和解密使用不同的密钥进行操作。算法的安全性基于两个大素数相乘难以分解的数学问题，保证了密钥的安全性和机密性。在 RSA 算法中，公钥用于加密，私钥用于解密。
【IoT】加密与安全：非对称加密算法 RSA 1024 公钥、秘钥、明文和密文长度
热门推荐
产品线负责人
11-05 3万+
RSA 1024 是指公钥及私钥分别是 1024bit，也就是 1024/8 = 128Bytes。 RSA 原理 RSA 算法密钥长度的选择是安全性和程序性能平衡的结果，密钥长度越长，安全性越好，加密解密所需时间越长。 1、非对称加密算法中 1024bit 密钥的强度相当于对称加密算法 80bit 密钥的强度； 2、密钥长度增长一倍，公钥操作所需时间增加约 4 倍，私钥操作所需时间...
人人都能看懂的RSA非对称加密算法
搬砖信条
06-16 3706
RSA加密算法简介 RSA加密算法是最常用的非对称加密算法，由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）于1977年一起提出，RSA就是他们三人姓氏开头字母拼在一起组成的。 非对称加密算法的特点就是加密秘钥和解密秘钥不同，秘钥分为公钥和私钥，用私钥加密的明文，只能用公钥解密；用公钥加密的明文，只能用私钥解密。 RSA是第一个比较完善的公开密钥算法，它既能用于加密，也能用于数字签名。这个算法经受住了多年深入的密码分析，虽然密
RSA算法详解
程序那些事
01-15 1万+
文章目录什么是RSARSA的加密RSA的解密N,E,D的生成1. 生成N2. 求L3. 求E4. 求D破解RSA 什么是RSA 前面文章我们讲了AES算法，AES算法是一种是对称加密算法，本文我们来介绍一个十分常用的非对称加密算法RSA。 非对称加密算法也叫公钥密码算法，通过生成的公私钥来对明文密文进行加密解密。 RSA的名字是由它的三个开发者Ron Rivest, Adi Shamir和 Leo...
[单片机] rsa2048签名算法
jianqiang.xue
01-30 4492
RSA-2048具有617个十进制数字，共2048bits。是目前最大的RSA数字，有20万美金的悬赏用于对RSA-2048的因式分解。 RSA-2048：为非对称成加密算法，发送方和接收方均各有一组公钥和私钥key。因存在幂运算，其计算速度远远小于AES-256。可用于对小量数据的加密，如用于对密钥key的加密。是密钥交换协议的重要组成部分。采用公钥进行加密，采用私钥进行解密。 SHA-256：不是加解密算法，是一个安全Hash算法。可用于确认数据的完整性。可称为one way encryption，不存
RSA-1024
IOT2017的博客
03-02 238
def exp_mode(base, exponent, n): bin_array = bin(exponent)[2:][::-1] r = len(bin_array) base_array = [] pre_base = base base_array.append(pre_base) for _ in range(r - 1): next_base = (...
java使用RSA与AES加密解密的实例代码详解
08-25
主要介绍了java使用RSA与AES加密解密的实例代码，代码简单易懂，非常不错，具有一定的参考借鉴价值,需要的朋友可以参考下
RSA2--》加签+加密+解密+验签
09-23
根据证书私钥加签---》RSA公钥加密--》RSA私钥解密---》证书公钥验签
RSA算法加解密java工具
02-23
RSA算法加解密java工具， 包括： 创建公钥、私钥、加密、解密、分段加密 创建公钥、私钥、加密、解密、分段加密 创建公钥、私钥、加密、解密、分段加密
RSA加解密的JAVA实现
07-16
非对称加密算法RSA算法的JAVA实现，可视化界面，支持多种形式，供参考
mybatisPlus使用MetaObjectHandler对字段进行更新
m0_56356631的博客
04-23 372
都是符合我们的预期的。
java方法重写（重点讲），方法重载
最新发布
weixin_46281068的博客
04-27 442
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
string模拟实现
m0_73969414的博客
04-23 1469
c++中string的模拟实现，面试必会知识点
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 631
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
rsa java 加解密文件代码
05-26
下面是一个简单的RSA加解密文件的Java代码示例： ```java import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.security.Key; import java.security.KeyFactory; ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值