Decryption of a "long" message encrypted using RSA java

Question

Hi, this is the same question that was asked two years ago: Java / JCE: decryption of a "long" message encrypted using RSA

I had a large array of bytes and an rsa key pair, triggered by a value of 1024. Using rsa encryption and a given key size is a strong requirement, I cannot change it. Therefore, I cannot use symmetric encryption with a symmetric asymmetric encryption key. I can not use other keys. I had an array of bytes, and we needed an encrypted array of bytes. I wonder if there is any ready-made tool that can handle this problem?

Sorry for such an amateurish question, but I really need help.

Answer 1

As already mentioned, your question has one answer, but no. RSA encryption is an algorithm that encrypts messages to a given size, which depends on the size of the key; with a 1024-bit RSA key and RSA as a standard describes it, the maximum size is 117 bytes, no more. It is not possible to encrypt a larger message using only RSA and certain mathematical certainty.

If you really need to handle longer messages, you definitely need to add something else. In this case, please do not try to make any fantasies about your own design with some kind of clever splitting of data into small blocks and the like. This path leads to death. You can create something that seems to compile and run, but that will be consistently weak in some way, like almost all other home cryptography modifications. This is because security cannot be verified: this is not a case of “working” or “not working”.

The well-trodden path of asymmetric encryption goes as follows:

• You choose a random sequence of bytes of some suitable length, for example. 128 bits (this is 16 bytes). Let K. be called
• You encrypt K with the RSA public key; this gives E.
• You encrypt the message using K using the symmetric encryption algorithm ( "AES/CBC/PKCS5Padding" ). Since this is a one-time key, you can use all IV zeros. This gives a bunch of bytes, let's call it F.
• The encrypted message is a concatenation of E and F.

Decryption continues in the reverse order: the RSA private key is used to recover K from E, then K is used to decrypt F into the original message. The key K is never stored anywhere, and each time a new key K is generated (even if you encrypt the same message twice). This is important, do not change it if you do not understand what you are doing (and if so, then you already know this).

Given that you are reporting your problem, you need to do something else besides "just RSA." The procedure described above deals with the best “something else” that you could handle from a security point of view.

Assembling some cryptographic elements in such a protocol is a process fraught with traps, so you may be lucky using an already defined format and a support library. Two common asymmetric encryption formats are CMS and OpenPGP . A library that supports both has a good reputation - Bouncy Castle .

Answer 2

If you need to encrypt / decrypt long strings using RSA, you can break the bytes into smaller “chunks” and process each piece of bytes in ciphers at a time, storing the results in ByteBuffer.

Encryption:

 byte[] encData = null; try { // create public key X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(key); KeyFactory kf = KeyFactory.getInstance("RSA"); PublicKey pk = kf.generatePublic(publicKeySpec); Cipher pkCipher = Cipher.getInstance("RSA/ECB/PKCS1Padding"); pkCipher.init(Cipher.ENCRYPT_MODE, pk); int chunkSize = 117; // 1024 / 8 - 11(padding) = 117 int encSize = (int) (Math.ceil(data.length/117.0)*128); int idx = 0; ByteBuffer buf = ByteBuffer.allocate(encSize); while (idx < data.length) { int len = Math.min(data.length-idx, chunkSize); byte[] encChunk = pkCipher.doFinal(data, idx, len); buf.put(encChunk); idx += len; } // fully encrypted data encData = buf.array(); } catch (Exception e) { e.printStackTrace(); 

Decryption

 Cipher rsaCipher = Cipher.getInstance("RSA/ECB/PKCS1Padding"); rsaCipher.init(Cipher.DECRYPT_MODE, rsaPk); int chunkSize = 128; int idx = 0; ByteBuffer buf = ByteBuffer.allocate(data.length); while(idx < data.length) { int len = Math.min(data.length-idx, chunkSize); byte[] chunk = rsaCipher.doFinal(data, idx, len); buf.put(chunk); idx += len; } // fully decrypted data byte[] decryptedData = buf.array();