# RSA Encryption, getting bad length

C#EncryptionRsaEncryption Asymmetric## C# Problem Overview

When calling the following function :

```
byte[] bytes = rsa.Encrypt(System.Text.UTF8Encoding.UTF8.GetBytes(stringToEncrypt), true);
```

I am now getting the error: bad length.

With a smaller string it works, any ideas what the problem could be the string I am passing is under 200 characters.

## C# Solutions

## Solution 1 - C#

RSA encryption is only mean for small amounts of data, the amount of data you can encrypt is dependent on the size of the key you are using, for example for 1024 bit RSA keys, and PKCS # 1 V1.5 padding, you can encrypt 117 bytes at most, with a 2048 RSA key, you can encrypt 245 bytes.

There's a good reason for this, asymmetric encryption is computationally expensive. If you want to encrypt large amounts of data you should be using symmetric encryption. But what if you want non-repudiation? Well what you then do is use both. You create a symmetric key and exchange it using asymmetric encryption, then that safely exchanged symmetric key to encrypt your large amounts of data. This is what SSL and WS-Secure use underneath the covers.

## Solution 2 - C#

For future searches regarding RSA bad length exceptions...

You can calculate the max number of bytes which can be encrypted with a particular key size with the following:

```
((KeySize - 384) / 8) + 37
```

However, if the optimal asymmetric encryption padding (OAEP) parameter is true, as it is in the original post, the following can be used to calculate the max bytes:

```
((KeySize - 384) / 8) + 7
```

The legal key sizes are 384 thru 16384 with a skip size of 8.

## Solution 3 - C#

As explained above, the solution to the 'bad length' type exceptions is to hybridize the use of symmetric and asymmetric encryption, so that the size of the text you are encrypting is not constrained by the key size. You basically use RSA encryption to asymmetrically encrypt the random **key** .

> **For encryption:**
>
> 1. Generate a random key of the length required for symmetrical encryption technique such as AES or Rijndael.
>
> 2. Symmetrically encrypt your text/data using AES/Rijndael using the random key generated in step 1.
>
> 3. Using RSA, asymmetrically encrypt the random key generated in step 1.
>
> **For decryption:**
>
> 1. First decrypt the AES/Rijndael-generated random key using your private RSA key.
>
> 2. Then decrypt the original text/data using the RSA-decrypted random key

For a demonstration, you may wish to have a look this following example in C#:

http://www.technical-recipes.com/2013/using-rsa-to-encrypt-large-data-files-in-c/

## Solution 4 - C#

I faced the same challenge while doing 2048 RSA encryption of plain text having less than 200 characters.

In my opinion, we can achieve the target without getting into complexity of Symmetric or Asymmetric encryption, with following simple steps;

**By doing so I managed to encrypt and decrypt 40x larger text**

**Encryption:**

- Compress the plain text by using *Zip() method and convert into array of bytes
- Encrypt with RSA

**Decryption:**

- Decrypt cypher text with RSA
- un-compress decrypted data by using **Unzip() method

*byte[] bytes = Zip(stringToEncrypt); // Zip() method copied below

**decryptedData = Unzip(decryptedBytes); // Unzip() method copied below

```
public static byte[] Zip(string str)
{
var bytes = System.Text.Encoding.UTF8.GetBytes(str);
using (var msi = new MemoryStream(bytes))
using (var mso = new MemoryStream())
{
using (var gs = new GZipStream(mso, CompressionMode.Compress))
{
CopyTo(msi, gs);
}
return mso.ToArray();
}
}
public static string Unzip(byte[] bytes)
{
using (var msi = new MemoryStream(bytes))
using (var mso = new MemoryStream())
{
using (var gs = new GZipStream(msi, CompressionMode.Decompress))
{
CopyTo(gs, mso);
}
return System.Text.Encoding.UTF8.GetString(mso.ToArray());
}
}
public static void CopyTo(Stream src, Stream dest)
{
byte[] bytes = new byte[4096];
int cnt;
while ((cnt = src.Read(bytes, 0, bytes.Length)) != 0)
{
dest.Write(bytes, 0, cnt);
}
}
```