3 Steps Beyond

This is the second part of a two-part article about using the OpenSSL functionality in PHP to encrypt and decrypt data.  Part One covers key generation.  This part shows you how to use those keys to encrypt and decrypt data.

Loading a key file

There are a couple of ways to encrypt data using OpenSSL.   But before you can encrypt or decrypt, you first have to load the appropriate key from file.   Most of the sample code that I have seen shows this as two steps – loading the data and then getting the key from that data.   Like this:

However, the openssl_pkey_get_public() (and _private()) functions allow you to pass in a filename prefixed with file:// and the function will do the loading for you.   So you can actually get your key from a file with a single command:

The above example would load public.key from a relative path (ie. The directory the script is run in).   You could also load from an absolute path by specifying the entire path:

Loading the private key is done in a similar way, but since we’re about to encrypt data we want the public key at this point.

openssl_pkey_get_public() has an alias, openssl_get_publickey().  This is functionally identical.

Encrypting some data asymmetrically

If you want to encrypt a tiny amount of data, you can use asymmetric encryption to encrypt the data itself.   The amount of data you can encrypt and the size of the resulting encrypted data are both determined by the size of the key.

The size of the encrypted data is the number of bytes in the key (rounded up).   So for a 1024-bit key this will be 128 bytes (1024 divided by 8).   Even if you were to encrypt a string with a single byte in it, the resulting encrypted data would still be 128 bytes long.

The maximum amount of data that can be encrypted is 11 bytes less than this.   So for a 1024-bit key, up to 117 bytes can be encrypted.

To encrypt your data, use the openssl_public_encrypt() function.   This takes three arguments:

• The string to encrypt
• A reference to a string to place the encrypted data in.
• The public key to use for encryption.

It returns a boolean indicating whether encryption was successful or not.

The resulting data is binary.   A base64 encoded version of the encrypted data looks something like this:

Part of the encryption mechanism uses a random value as a key (totally separate from the public/private key pair).   So if I encode exactly the same text a second time with the same public key, I get different encrypted data:

Both of these strings would decrypt to the same string.

Encrypting longer strings – splitting into chunks

If your data is longer than the maximum size that your key can allow, you might be tempted to split your data into chunks and encrypt each chunk, something like this:

This example gets the key size from the public key that you’ve loaded (in this case 1024) and calculates the maximum amount of data that it can encode (117 bytes).   It then splits the data into chunks of this size and encrypts each one, appending the resulting encrypted data to $output.

While this may seem like a good idea, in practice it’s not so great for two reasons.

• Every chunk of data will add an 11 byte overhead.
• Asymmetric encryption and decryption is processor-intensive.

You may be able to reduce the size of your input data by compressing it, but this will only save you a certain amount.   For larger amounts of data, you need to encrypt in a different way.

Encrypting longer strings – using two encryption mechanisms

The solution to this problem is to use two different encryption mechanisms – one symmetric and one asymmetric.  It works like this:

• First, a random key is generated.
• This random key is used to encrypt the data using symmetric encryption.  This step is a lot faster than using asymmetric encryption.
• Finally, the random key is encrypted using asymmetric encryption.  Because the key itself is relatively short, the overhead of asymmetric encryption is kept to a minimum.

The symmetric encryption does not affect the size of the encrypted data – it is the same size as the input.

The encrypted key – called an envelope – is the same size as the asymmetric key.   This means that no matter how large the data being encrypted, the storage overhead will always be the same.   In the case of a 1024-bit key, this would be 128 bytes.

The openssl_seal() function does all of this work for us in a single function call.   Here is some sample code:

The openssl_seal() function takes four arguments:

• The data to be encrypted.
• A reference to the string where the encrypted data is to be stored.
• A reference to an array to store the envelopes in.
• An array of public keys to be used when creating the envelopes.

The function returns the size of the encrypted data, or FALSE if it fails.

The symmetric encryption is done using RC4.   While this encryption mechanism has some known weaknesses, these relate to using the same key more than once.   Since openssl_seal() generates a new key every time, this is not considered to be a problem in this instance.

You may be wondering why the last two arguments are arrays.   This is simply because openssl_seal() can be used to encrypt the same data for multiple recipients at the same time.   The data is encrypted once using symmetric encryption and then the random key is encrypted asymmetrically for each of the public keys.   When the data is transmitted, you would send the same encrypted data to each recipient but only the relevant envelope to the intended recipient.   If you were to send the wrong envelope to the wrong recipient, they would not be able to decode it and would therefore not be able to decode the encrypted data.

If I run the example above, I get encrypted data:

and an encrypted key:

(As before, I have base64 encoded these in order to display them).

If I were to run this a second time, a new random key would be picked and the encrypted data would be different.   You can see that the encrypted data is short, because the input data was short.

For this particular data it would probably be more efficient to simply encode the data asymmetrically as a single chunk.   The choice for any given application will depend on the size of “typical” data.   If in doubt, I suggest testing both methods with typical data and using the microtime() function on either side of the test to take some timings.   You should test both the encryption and decryption times when doing this.

An important caveat about symmetric encryption

The asymmetric decryption we are using includes integrity checking, but the symmetric encryption does not.  If your encrypted data is corrupted or tampered with, you will get different results depending on whether it was encrypted asymmetrically or symmetrically.

If the asymmetric data is corrupted, it will fail to decrypt (the exact nature of the error will vary depending on which part of the message is corrupted).  But if the symmetric data is corrupted, it is likely to still decrypt but the output will also be corrupted.

One simple solution to this problem is to generate a hash of your data prior to encrypting it, using functions such as md5() or sha1().  This hash can then be included with the data when you encrypt it.  After decryption, the hash can be separated from the rest of the data and checked against it to ensure it still matches.

Throw it into reverse

All of this encryption is great, but it’s useless unless you can decrypt the data again.   The first step in decrypting is to load the private key.

If you exported the private key with a password, you need to specify it when loading the key:

If you wanted to export the key with a different password (or no password) at this point, you could use openssl_pkey_export_to_file() to do this.

openssl_pkey_get_private() has an alias, openssl_get_privatekey().  This is functionally identical.

Decrypting the encrypted data

The decryption process is very similar to the encryption process.   If the data was encrypted as a single chunk using openssl_public_encrypt(), you would use openssl_private_decrypt() to decode it.   The arguments are very similar:

If the data was split into chunks, you need to do the same thing to decrypt.   This time the chunk size is the number of bytes in the key (rounded up).   We don’t subtract 11:

Finally, if the data was encrypted using openssl_seal(), you need to use openssl_open() to decrypt it.   Unlike openssl_seal(), the last two arguments are not arrays, since there is no need to do a bulk decrypt:

And that’s how you encrypt and decrypt data using OpenSSL in PHP!