Java Bouncy Castle的块式RSA加密

Question

在C#中，我正在通过如下操作加密文本数据（请注意，我正在以块（块）形式加密数据）：

        public string EncryptData(string publicKey, string data)
        {
            try
            {
                var bytesToEncrypt = Encoding.UTF8.GetBytes(data);
                int srclen = bytesToEncrypt.Length;

                //Prepare encryption engine
                var encryptEngine = new Pkcs1Encoding(new RsaEngine());

                //Initialize Key
                using (var txtreader = new StringReader(publicKey))
                {
                    var keyParameter = (AsymmetricKeyParameter)new PemReader(txtreader).ReadObject();
                    encryptEngine.Init(true, keyParameter);
                }

                //Encrypt in loop
                byte[] complete = new byte[0];
                int src_block_size = encryptEngine.GetInputBlockSize();
                for (int idx = 0; idx < srclen; idx += src_block_size)
                {
                    int data_len = srclen - idx;
                    if (data_len > src_block_size)
                    {
                        data_len = src_block_size;
                    }

                    var encryptedChunk = encryptEngine.ProcessBlock(bytesToEncrypt, idx, data_len);
                    complete = CombineByteArrays(complete, encryptedChunk);
                }

                var finalString = Convert.ToBase64String(complete);
                return finalString;
            }
            catch (InvalidCipherTextException)
            {
                //catch exception
            }
        }

现在，我需要提供相同的加密逻辑给一些Java的家伙（我根本不熟悉Java）。现在他们是这样做的：

public static byte[] encrypt(byte[] text, PublicKey key) throws Exception
    {
        byte[] cipherText = null;
        //
        // get an RSA cipher object and print the provider
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");

        // encrypt the plain text using the public key
        cipher.init(Cipher.ENCRYPT_MODE, key);
        cipherText = cipher.doFinal(text);
        return cipherText;
    }

因此，有时解密（发生在基于.NET的服务器上）会失败，并出现错误“输入太大而不是RSA密码”。所以我怀疑这可能是因为加密和解密数据的逻辑不同（加密发生在基于Java的客户端上，逻辑如下所示，解密发生在基于.NET的客户端上，逻辑如下）：

public string DecryptData(string privateKey, string base64Data)
        {
            try
            {
                var bytesToDecrypt = Convert.FromBase64String(base64Data);
                AsymmetricCipherKeyPair keyPair;
                //var internalEngine = new RsaEngine();
                var decryptEngine = new RsaEngine(); //No paddind. We'll hunt the data inside packets
                using (var txtreader = new StringReader(privateKey))
                {
                    keyPair = (AsymmetricCipherKeyPair)new PemReader(txtreader).ReadObject();
                    decryptEngine.Init(false, keyPair.Private);
                }

                //Loop por todo el bloque y saca data
                byte[] complete = new byte[0];
                int blockSize = decryptEngine.GetInputBlockSize();
                for (int chunkPosition = 0; chunkPosition < bytesToDecrypt.Length; chunkPosition += blockSize)
                {
                    //int chunkSize = Math.Min(blockSize, bytesToDecrypt.Length - ((chunkPosition / blockSize) * blockSize));
                    int chunkSize = bytesToDecrypt.Length - chunkPosition;
                    if (chunkSize > blockSize)
                    {
                        chunkSize = blockSize;
                    }

                    var decryptedChunk = decryptEngine.ProcessBlock(bytesToDecrypt, chunkPosition, chunkSize);

                    //the actual decrypted data is in the middle, locate it!
                    int idxFirstZero = -1;
                    int outlen = decryptedChunk.Length;
                    int idxNextZero = (int)outlen;
                    for (int i = 0; i < outlen; i++)
                    {
                        if (decryptedChunk[i] == 0)
                        {
                            if (idxFirstZero < 0)
                            {
                                idxFirstZero = i;
                            }
                            else
                            {
                                idxNextZero = i;
                                break;
                            }
                        }
                    }

                    var totalSizeToCopy = idxNextZero - idxFirstZero - 1;
                    Array.Resize(ref complete, complete.Length + totalSizeToCopy);
                    int dstOffset = complete.Length - totalSizeToCopy > 0 ? complete.Length - totalSizeToCopy : 0;
                    Buffer.BlockCopy(decryptedChunk, idxFirstZero + 1, complete, dstOffset, totalSizeToCopy);
                }

                var finalString = Encoding.UTF8.GetString(complete).Trim('\0');
                return finalString;
            }
            catch (InvalidCipherTextException)
            {

            }
        }

如你所见，我正在对数据进行块解密。所以我的问题是，我们如何在Java（使用bouncy castle）中进行块式加密（就像我在文章的第一段代码中在.NET中所做的那样）？

Answer 1

这不是一个常见的操作，因为对于大数据（甚至更小的数据），通常使用混合加密，其中使用对称密码的操作模式（例如CBC）来加密较大的数据对象。

据我所知，没有直接的方法从cipher实例请求RSA/PKCS#1的最大输入大小。

然而，这并不是一个大问题，因为您可以在给定RSA密钥大小的情况下自己计算这个值。并且该密钥大小与模数的大小（以字节为单位）相同：

1. 以字节为单位计算模数大小:(keysize-1)/byte.size+1或者，如果keysize是8的倍数（像往常一样），当然只需keysize/byte.size；
2. 从结果中减去11个字节（对于PKCS#1 v1.5填充）；

要获得keysize，只需将密钥强制转换为RSAPublickey，然后调用GetModulus()，然后在生成的BigInteger上调用BitLengts()。

注意，发送没有完整性保护（例如签名）的密文不被认为是非常安全的。PKCS#1也可能成为填充oracle攻击的牺牲品，特别是在传输模式安全中使用时。RSA/OAEP将是一个更好的选择，用于混合加密（因为RSA/OAEP将存储更少）。