What is the simplest way of doing two way encryption in common PHP installs?
I need to be able to encrypt data with a string key, and use the same key to decrypt on the other end.
The security isn’t as big of a concern as the portability of the code, so I’d like to be able to keep things as simple as possible. Currently, I am using an RC4 implementation, but if I can find something natively supported I figure I can save a lot of unnecessary code.phpsecurityencryptioncryptographyencryption-symmetricShareImprove this questionFollowedited Feb 12 ’17 at 16:38Braiam4,3161111 gold badges5050 silver badges7373 bronze badgesasked Feb 13 ’12 at 14:23user12069702,61733 gold badges1212 silver badges44 bronze badges
- 4Just XOR your string. – Thunraz Feb 13 ’12 at 14:28
- 3For general purpose encryption, use defuse/php-encryption/ instead of rolling your own. – Scott Arciszewski May 11 ’15 at 4:37
- 2Hands away from github.com/defuse/php-encryption – it is slower by orders of magnitude than mcrypt. – Eugen Rieck May 11 ’15 at 16:12
- 1@Scott Thinking along the lines of “this will probably not be the bottleneck” is what brought us a lot of bad software. – Eugen Rieck May 12 ’15 at 14:30
- 3If you’re really encrypting/decrypting a lot of data to the point that the milliseconds it costs bogs your application down, bite the bullet and switch to libsodium.
Sodium::crypto_secretbox()
andSodium::crypto_secretbox_open()
are secure and performant. – Scott Arciszewski May 12 ’15 at 18:53
6 Answers
Important: Unless you have a very particular use-case, do not encrypt passwords, use a password hashing algorithm instead. When someone says they encrypt their passwords in a server-side application, they’re either uninformed or they’re describing a dangerous system design. Safely storing passwords is a totally separate problem from encryption.
Be informed. Design safe systems.
Portable Data Encryption in PHP
If you’re using PHP 5.4 or newer and don’t want to write a cryptography module yourself, I recommend using an existing library that provides authenticated encryption. The library I linked relies only on what PHP provides and is under periodic review by a handful of security researchers. (Myself included.)
If your portability goals do not prevent requiring PECL extensions, libsodium is highly recommended over anything you or I can write in PHP.
Update (2016-06-12): You can now use sodium_compat and use the same crypto libsodium offers without installing PECL extensions.
If you want to try your hand at cryptography engineering, read on.
First, you should take the time to learn the dangers of unauthenticated encryption and the Cryptographic Doom Principle.
- Encrypted data can still be tampered with by a malicious user.
- Authenticating the encrypted data prevents tampering.
- Authenticating the unencrypted data does not prevent tampering.
Encryption and Decryption
Encryption in PHP is actually simple (we’re going to use openssl_encrypt()
and openssl_decrypt()
once you have made some decisions about how to encrypt your information. Consult openssl_get_cipher_methods()
for a list of the methods supported on your system. The best choice is AES in CTR mode:
aes-128-ctr
aes-192-ctr
aes-256-ctr
There is currently no reason to believe that the AES key size is a significant issue to worry about (bigger is probably not better, due to bad key-scheduling in the 256-bit mode).
Note: We are not using mcrypt
because it is abandonware and has unpatched bugs that might be security-affecting. Because of these reasons, I encourage other PHP developers to avoid it as well.
Simple Encryption/Decryption Wrapper using OpenSSL
class UnsafeCrypto { const METHOD = 'aes-256-ctr'; /** * Encrypts (but does not authenticate) a message * * @param string $message - plaintext message * @param string $key - encryption key (raw binary expected) * @param boolean $encode - set to TRUE to return a base64-encoded * @return string (raw binary) */ public static function encrypt($message, $key, $encode = false) { $nonceSize = openssl_cipher_iv_length(self::METHOD); $nonce = openssl_random_pseudo_bytes($nonceSize); $ciphertext = openssl_encrypt( $message, self::METHOD, $key, OPENSSL_RAW_DATA, $nonce ); // Now let's pack the IV and the ciphertext together // Naively, we can just concatenate if ($encode) { return base64_encode($nonce.$ciphertext); } return $nonce.$ciphertext; } /** * Decrypts (but does not verify) a message * * @param string $message - ciphertext message * @param string $key - encryption key (raw binary expected) * @param boolean $encoded - are we expecting an encoded string? * @return string */ public static function decrypt($message, $key, $encoded = false) { if ($encoded) { $message = base64_decode($message, true); if ($message === false) { throw new Exception('Encryption failure'); } } $nonceSize = openssl_cipher_iv_length(self::METHOD); $nonce = mb_substr($message, 0, $nonceSize, '8bit'); $ciphertext = mb_substr($message, $nonceSize, null, '8bit'); $plaintext = openssl_decrypt( $ciphertext, self::METHOD, $key, OPENSSL_RAW_DATA, $nonce ); return $plaintext; } }
Usage Example
$message = 'Ready your ammunition; we attack at dawn.'; $key = hex2bin('000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f'); $encrypted = UnsafeCrypto::encrypt($message, $key); $decrypted = UnsafeCrypto::decrypt($encrypted, $key); var_dump($encrypted, $decrypted);
Demo: https://3v4l.org/jl7qR
The above simple crypto library still is not safe to use. We need to authenticate ciphertexts and verify them before we decrypt.
Note: By default, UnsafeCrypto::encrypt()
will return a raw binary string. Call it like this if you need to store it in a binary-safe format (base64-encoded):
$message = 'Ready your ammunition; we attack at dawn.'; $key = hex2bin('000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f'); $encrypted = UnsafeCrypto::encrypt($message, $key, true); $decrypted = UnsafeCrypto::decrypt($encrypted, $key, true); var_dump($encrypted, $decrypted);
Demo: http://3v4l.org/f5K93
Simple Authentication Wrapper
class SaferCrypto extends UnsafeCrypto { const HASH_ALGO = 'sha256'; /** * Encrypts then MACs a message * * @param string $message - plaintext message * @param string $key - encryption key (raw binary expected) * @param boolean $encode - set to TRUE to return a base64-encoded string * @return string (raw binary) */ public static function encrypt($message, $key, $encode = false) { list($encKey, $authKey) = self::splitKeys($key); // Pass to UnsafeCrypto::encrypt $ciphertext = parent::encrypt($message, $encKey); // Calculate a MAC of the IV and ciphertext $mac = hash_hmac(self::HASH_ALGO, $ciphertext, $authKey, true); if ($encode) { return base64_encode($mac.$ciphertext); } // Prepend MAC to the ciphertext and return to caller return $mac.$ciphertext; } /** * Decrypts a message (after verifying integrity) * * @param string $message - ciphertext message * @param string $key - encryption key (raw binary expected) * @param boolean $encoded - are we expecting an encoded string? * @return string (raw binary) */ public static function decrypt($message, $key, $encoded = false) { list($encKey, $authKey) = self::splitKeys($key); if ($encoded) { $message = base64_decode($message, true); if ($message === false) { throw new Exception('Encryption failure'); } } // Hash Size -- in case HASH_ALGO is changed $hs = mb_strlen(hash(self::HASH_ALGO, '', true), '8bit'); $mac = mb_substr($message, 0, $hs, '8bit'); $ciphertext = mb_substr($message, $hs, null, '8bit'); $calculated = hash_hmac( self::HASH_ALGO, $ciphertext, $authKey, true ); if (!self::hashEquals($mac, $calculated)) { throw new Exception('Encryption failure'); } // Pass to UnsafeCrypto::decrypt $plaintext = parent::decrypt($ciphertext, $encKey); return $plaintext; } /** * Splits a key into two separate keys; one for encryption * and the other for authenticaiton * * @param string $masterKey (raw binary) * @return array (two raw binary strings) */ protected static function splitKeys($masterKey) { // You really want to implement HKDF here instead! return [ hash_hmac(self::HASH_ALGO, 'ENCRYPTION', $masterKey, true), hash_hmac(self::HASH_ALGO, 'AUTHENTICATION', $masterKey, true) ]; } /** * Compare two strings without leaking timing information * * @param string $a * @param string $b * @ref https://paragonie.com/b/WS1DLx6BnpsdaVQW * @return boolean */ protected static function hashEquals($a, $b) { if (function_exists('hash_equals')) { return hash_equals($a, $b); } $nonce = openssl_random_pseudo_bytes(32); return hash_hmac(self::HASH_ALGO, $a, $nonce) === hash_hmac(self::HASH_ALGO, $b, $nonce); } }
Usage Example
$message = 'Ready your ammunition; we attack at dawn.'; $key = hex2bin('000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f'); $encrypted = SaferCrypto::encrypt($message, $key); $decrypted = SaferCrypto::decrypt($encrypted, $key); var_dump($encrypted, $decrypted);
Demos: raw binary, base64-encoded
If anyone wishes to use this SaferCrypto
library in a production environment, or your own implementation of the same concepts, I strongly recommend reaching out to your resident cryptographers for a second opinion before you do. They’ll be able tell you about mistakes that I might not even be aware of.
You will be much better off using a reputable cryptography library.ShareImprove this answerFollowedited Jun 12 ’17 at 19:28answered May 12 ’15 at 11:42Scott Arciszewski31.5k1616 gold badges8585 silver badges200200 bronze badges
- 3So, I am just trying to get the UnsafeCrypto working first. The encryption happens fine, but every time I run the decrypt, I am getting ‘false’ as the response. I am using the same key to decrypt, and passing true on the encode, as well as the decode. There is, what I assume is a typeo in the example, I am wondering if that is where my problem is coming from. Can you explain where the $mac variable is coming from, and should it simply be $iv? – David C Jul 6 ’15 at 21:33
- 1@EugenRieck The OpenSSL cipher implementations are probably the only parts that don’t suck, and it’s the only way to leverage AES-NI in vanilla PHP. If you install on OpenBSD, PHP will be compiled against LibreSSL without the PHP code noticing a difference. Libsodium > OpenSSL any day. Also, don’t use libmcrypt. What would you recommend PHP developers use instead of OpenSSL? – Scott Arciszewski Jul 22 ’15 at 15:43
- 2Neither 5.2 nor 5.3 are supported anymore. You should instead look into updating to a supported version of PHP, such a 5.6. – Scott Arciszewski Sep 6 ’15 at 20:19
- 1@BBeta paragonie.com/blog/2015/09/… – Scott Arciszewski Apr 6 ’17 at 18:45
- 1I just did it as a demonstration of you want binary strings, not human-readabale strings, for your keys. – Scott Arciszewski Aug 26 ’17 at 16:10
Edited:
You should really be using openssl_encrypt() & openssl_decrypt()
As Scott says, Mcrypt is not a good idea as it has not been updated since 2007.
There is even an RFC to remove Mcrypt from PHP – https://wiki.php.net/rfc/mcrypt-viking-funeral