getting a IllegalBlockSizeException: Data must not be longer than 256 bytes when using rsa

The RSA algorithm can only encrypt data that has a maximum byte length of the RSA key length in bits divided with eight minus eleven padding bytes, i.e. number of maximum bytes = key length in bits / 8 - 11.

So basicly you divide the key length with 8 -11(if you have padding). For example if you have a 2048bit key you can encrypt 2048/8 = 256 bytes (- 11 bytes if you have padding). So, either use a larger key or you encrypt the data with a symmetric key, and encrypt that key with rsa (which is the recommended approach).

That will require you to:

1. generate a symmetric key
2. Encrypt the data with the symmetric key
3. Encrypt the symmetric key with rsa
4. send the encrypted key and the data
5. Decrypt the encrypted symmetric key with rsa
6. decrypt the data with the symmetric key
7. done :)

Based on @John Snow answer, I did an example

1. Generate Symmetric Key (AES with 128 bits)

   KeyGenerator generator = KeyGenerator.getInstance("AES");
   generator.init(128); // The AES key size in number of bits
   SecretKey secKey = generator.generateKey();
   

2. Encrypt plain text using AES

   String plainText = "Please encrypt me urgently..."
   Cipher aesCipher = Cipher.getInstance("AES");
   aesCipher.init(Cipher.ENCRYPT_MODE, secKey);
   byte[] byteCipherText = aesCipher.doFinal(plainText.getBytes());
   

3. Encrypt the key using RSA public key

   KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA");
   kpg.initialize(2048);
   KeyPair keyPair = kpg.generateKeyPair();
   
   PublicKey puKey = keyPair.getPublic();
   PrivateKey prKey = keyPair.getPrivate();
   
   Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
   cipher.init(Cipher.PUBLIC_KEY, puKey);
   byte[] encryptedKey = cipher.doFinal(secKey.getEncoded()/*Seceret Key From Step 1*/);
   

4. Send encrypted data (byteCipherText) + encrypted AES Key (encryptedKey)

5. On the client side, decrypt symmetric key using RSA private key

   cipher.init(Cipher.PRIVATE_KEY, prKey);
   byte[] decryptedKey = cipher.doFinal(encryptedKey);
   

6. Decrypt the cipher text using decrypted symmetric key

   //Convert bytes to AES SecertKey
   SecretKey originalKey = new SecretKeySpec(decryptedKey , 0, decryptedKey .length, "AES");
   Cipher aesCipher = Cipher.getInstance("AES");
   aesCipher.init(Cipher.DECRYPT_MODE, originalKey);
   byte[] bytePlainText = aesCipher.doFinal(byteCipherText);
   String plainText = new String(bytePlainText);`
   

You should not use RSA on your secret data directly. You should only ever use RSA on pseudo-random or completely random data, such as session keys or message authentication codes.

You've gotten the problem at 256 bytes -- that is because you're probably working with 2048 bit keys. The keys are able to encrypt any integer in the range 0 to 2^2048 - 1 into the same range, and that means your data must be 256 bytes or smaller.

If you intend to encrypt more than this, please use one RSA encryption to encrypt a session key for a symmetric algorithm, and use that to encrypt your data.