java中RSA分段加解密及Data must not be longer than异常处理

谈到RSA非对称加密，作为开发的我们第一想到的是安全，几乎不会被破解，以及公钥加密，私钥解密这些。在Java代码中，我们常使用一些现成的工具类如hutool中提供的工具类、网上在线的或者博客上的RSAUtils工具类来实现公钥私钥的生成以及加解密方法。但探究其中的一些原理可以来帮我们更助于理解和使用。
本文主要谈论的是加解密中的对于加解密长度的限制和规定。一般情况下，我们使用Jdk（SunJCE version 1.8）自带的RSA相关类算法进行操作，有的项目可能会引入BC库，即org.bouncycastle库，可以通过maven引入相关依赖，如下：

<dependency>
    <groupId>org.bouncycastle</groupId>
    <artifactId>bcprov-jdk15on</artifactId>
    <version>1.45</version>
</dependency>

并在静态代码块设置对应的provider

static {
    try{
        Security.addProvider(new BouncyCastleProvider());
    }catch(Exceptione){
        e.printStackTrace();
    }
}

如果不清楚自己项目使用的是哪种库，可以输入如下代码打印查看

for (Provider provider : Security.getProviders()) {
    System.out.println("算法提供者名：" + provider.getName());
    System.out.println("算法提供者的版本：" + provider.getVersion());
    System.out.println("算法提供者的信息：" + provider.getInfo());
}

稍微扩展下，就此打住。本文主要谈论Sun jdk中的RSA算法，关于密钥的生成，我们一般这么操作

private static KeyPair generateKeyPair() {
		try {
			KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
			keyPairGenerator.initialize(2048);
			KeyPair keyPair = keyPairGenerator.generateKeyPair();
			return keyPair;
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		}
		return null;
	}

其中“RSA”为指定算法，当我们输入RSA时，会默认使用一种名为PKCS1Padding填充方式，下面会详细谈。
2048为生成密钥的模长，会生成2048位（bit）的二进制数。注意这并不是指公钥私钥的字符串长度，一般情况我们会将密钥通过如PEM、DER或Base64编码转变成人能识别的文本形式，由于编码的不同，字符串的长度也会不一样。
还需要注意的是，为什么此处填2048，在jdk1.8源码中，规定了生成长度的限制，最小为512位，最大为16384位

可以通过如下方法打印佐证，输出结果均为2048

KeyPair keyPair = generateKeyPair();
RSAPublicKey aPublic = (RSAPublicKey) keyPair.getPublic();
RSAPrivateKey aPrivate = (RSAPrivateKey) keyPair.getPrivate();
System.out.println(aPublic.getModulus().bitLength());
System.out.println(aPrivate.getModulus().bitLength());

密钥生成好后，下面就来看看加解密，我们知道一般用公钥来加密，私钥来解密，代码如下

/**
 * 加密
 * @param data
 * @param publicKey
 * @return
 */
private static String encrypt(String data, PublicKey publicKey) {
   try {
      Cipher cipher = Cipher.getInstance("RSA");
      cipher.init(Cipher.ENCRYPT_MODE, publicKey);
      byte[] bytes = cipher.doFinal(data.getBytes());
      return Base64.encode(bytes);
   } catch (Exception e) {
      e.printStackTrace();
   }
   return null;
}

/**
 * 解密
 * @param data
 * @param privateKey
 * @return
 */
private static String decrypt(String data, PrivateKey privateKey) {
   try {
      Cipher cipher = Cipher.getInstance("RSA");
      cipher.init(Cipher.DECRYPT_MODE, privateKey);
      byte[] bytes = cipher.doFinal(Base64.decode(data));
      return new String(bytes);
   } catch (Exception e) {
      e.printStackTrace();
   }
   return null;
}

测试加解密方法，能够正常加解密

public static void main(String[] args) {
		// 生成密钥对
		KeyPair keyPair = generateKeyPair();
		RSAPublicKey aPublic = (RSAPublicKey) keyPair.getPublic();
		RSAPrivateKey aPrivate = (RSAPrivateKey) keyPair.getPrivate();
		// 打印公钥和私钥模长
		System.out.println(aPublic.getModulus().bitLength());
		System.out.println(aPrivate.getModulus().bitLength());
		// 将公钥和私钥转换为Base64编码
		String publicKey = Base64.encode(aPublic.getEncoded());
		String privateKey = Base64.encode(aPrivate.getEncoded());
		System.out.println("公钥：" + publicKey);
		System.out.println("私钥：" + privateKey);
		// 测试加密解密
		String data = "Hello, world!";
		String encrypt = encrypt(data, keyPair.getPublic());
		System.out.println("加密后：" + encrypt);
		String decrypt = decrypt(encrypt, keyPair.getPrivate());
		System.out.println("解密后：" + decrypt);
}

你可能以为结束了，但如果解析长文本时，会发现报错

// 加密解密长文本
public static void main(String[] args) {
		// 生成密钥对
		KeyPair keyPair = generateKeyPair();
		RSAPublicKey aPublic = (RSAPublicKey) keyPair.getPublic();
		RSAPrivateKey aPrivate = (RSAPrivateKey) keyPair.getPrivate();
		// 打印公钥和私钥模长
		System.out.println(aPublic.getModulus().bitLength());
		System.out.println(aPrivate.getModulus().bitLength());
		// 将公钥和私钥转换为Base64编码
		String publicKey = Base64.encode(aPublic.getEncoded());
		String privateKey = Base64.encode(aPrivate.getEncoded());
		System.out.println("公钥：" + publicKey);
		System.out.println("私钥：" + privateKey);
		// 加密解密长文本
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < 1000; i++) {
			sb.append(data);
		}
		data = sb.toString();
		encrypt = encrypt(data, keyPair.getPublic());
		System.out.println("加密后：" + encrypt);
		decrypt = decrypt(encrypt, keyPair.getPrivate());
		System.out.println("解密后：" + decrypt);
	}

报错如下，提示长度不能超过245个字节

javax.crypto.IllegalBlockSizeException: Data must not be longer than 245 bytes
        at com.sun.crypto.provider.RSACipher.doFinal(RSACipher.java:346)
        at com.sun.crypto.provider.RSACipher.engineDoFinal(RSACipher.java:391)
        at javax.crypto.Cipher.doFinal(Cipher.java:2168)
        at cn.hutool.crypto.KeyUtil.encrypt(KeyUtil.java:1046)
        at cn.hutool.crypto.KeyUtil.main(KeyUtil.java:1097)
java.lang.IllegalArgumentException: Null input buffer
        at javax.crypto.Cipher.doFinal(Cipher.java:2164)
        at cn.hutool.crypto.KeyUtil.decrypt(KeyUtil.java:1064)
        at cn.hutool.crypto.KeyUtil.main(KeyUtil.java:1099)

所以我们能得知，加密的明文长度最长为245，好像跟2048也没啥关系呀。深入探究得知，加密的明文长度需要满足条件：0<明文长度<密钥模长/8-11，其中“模长/8”为字节数；“-11”为填充的字节长度，而填充的字节长度正是由上文提到的填充方式决定的。当我们在加解密时，选择了RSA，在jdk库下，就会默认设置填充方式为PKCS1Padding

 Cipher cipher = Cipher.getInstance("RSA");

详细说下PKCS1Padding填充方式。PKCS1Padding即PKCS#1 v1.5是RSA加密的一种常用填充模式，它通过在明文前添加特定的填充字节来确保加密数据的完整性和安全性。这种填充模式要求加密后的数据块（Encryption Block, EB）长度与RSA密钥的模长（modulus）相等。
填充结构
在PKCS#1 v1.5填充模式下，加密块（EB）的结构大致如下：

• EB = 00 || BT || PS || 00 || D
  • 00：一个字节的保留位，总是0x00。
  • BT：一个字节的块类型（Block Type），对于公钥加密操作，通常为0x02。
  • PS：填充字符串（Padding String），由随机数（对于公钥加密）或特定值（对于私钥操作）组成，长度可变，但最小为8字节。
  • 00：一个字节的分隔符，用于区分填充字符串和明文。
  • D：待加密的明文数据。
    长度计算
    由于EB的长度必须与RSA密钥的模长相等，且需要留出空间给上述的填充部分，因此可加密的明文长度（D的长度）会受到限制。具体来说，限制因素包括：
• 保留位（00）：1字节
• 块类型（BT）：1字节
• 填充字符串（PS）：至少8字节（PKCS#1规范建议的最小长度）
• 分隔符（00）：1字节
  因此，对于给定的RSA密钥模长（以字节为单位），可加密的明文最大长度大致为：模长 - 1（保留位） - 1（块类型） - 8（填充字符串最小长度） - 1（分隔符）= 模长 - 11字节。
  示例
  以1024位RSA密钥为例，其模长（以字节为单位）为1024/8 = 128字节。因此，在PKCS#1 v1.5填充模式下，可加密的明文最大长度约为128 - 11 = 117字节。
  所以，如果当我们的明文长度超过117字节时，如果不进行分段处理，就会报错；因为加密的密文长度是模长，所以不用减。
  所以应对明文长度超过模长大小时，修改加解密代码如下：

/**
 * 加密
 *
 * @param data
 * @param publicKey
 * @return
 */
private static String encrypt(String data, PublicKey publicKey) {
   try {
      Cipher cipher = Cipher.getInstance("RSA");
      cipher.init(Cipher.ENCRYPT_MODE, publicKey);
      // 分块加密，每次最大加密长度为密钥长度/8-11
      int keyLength = ((RSAPublicKey) publicKey).getModulus().bitLength();
      int blockSize = keyLength / 8 - 11;
      ByteArrayOutputStream encryptedBytesStream = new ByteArrayOutputStream();
      byte[] inputBytes = data.getBytes();
      for (int i = 0; i < inputBytes.length; i += blockSize) {
         int end = Math.min(inputBytes.length, i + blockSize);
         byte[] block = Arrays.copyOfRange(inputBytes, i, end);
         byte[] encryptBytes = cipher.doFinal(block);
         encryptedBytesStream.write(encryptBytes);
      }
      return Base64.encode(encryptedBytesStream.toByteArray());
   } catch (Exception e) {
      e.printStackTrace();
   }
   return null;
}

/**
 * 解密
 *
 * @param data
 * @param privateKey
 * @return
 */
private static String decrypt(String data, PrivateKey privateKey) {
   try {
      Cipher cipher = Cipher.getInstance("RSA");
      cipher.init(Cipher.DECRYPT_MODE, privateKey);
      // 分块解密，每次最大解密长度为密钥长度/8
      int keyLength = ((RSAPrivateKey) privateKey).getModulus().bitLength();
      int blockSize = keyLength / 8;
      ByteArrayOutputStream decryptedBytesStream = new ByteArrayOutputStream();
      byte[] inputBytes = Base64.decode(data);
      for (int i = 0; i < inputBytes.length; i += blockSize) {
         int end = Math.min(inputBytes.length, i + blockSize);
         byte[] block = Arrays.copyOfRange(inputBytes, i, end);
         byte[] decryptBytes = cipher.doFinal(block);
         decryptedBytesStream.write(decryptBytes);
      }
      return new String(decryptedBytesStream.toByteArray());
   } catch (Exception e) {
      e.printStackTrace();
   }
   return null;
}

当报文长度超过最大长度时也能够成功地进行加解密。

如果您对技术有兴趣，友好交流，可以加v进技术群一起沟通，v:zzs1067632338，备注csdn即可